authorgravatar for thatlemon@gmail.comLemonBoy <thatlemon@gmail.com> 2020-11-26 19:14:22+01:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2021-01-02 17:12:57-07:00
log1fbe89dc2e204defc18add72efd2bba4dbe728fc
tree2002b7d890016ebff5d7205bcfd4fbb8ccd0749e
parentd2f6fa1608f31cbd7137f81b5dd6df2977766eae

langref: Update langref to use {s}

5 files changed, 80 insertions(+), 81 deletions(-)

doc/docgen.zig+54-54
......@@ -215,9 +215,9 @@ const Tokenizer = struct {
215215fn parseError(tokenizer: *Tokenizer, token: Token, comptime fmt: []const u8, args: anytype) anyerror {
216216 const loc = tokenizer.getTokenLocation(token);
217217 const args_prefix = .{ tokenizer.source_file_name, loc.line + 1, loc.column + 1 };
218 print("{}:{}:{}: error: " ++ fmt ++ "\n", args_prefix ++ args);
218 print("{s}:{d}:{d}: error: " ++ fmt ++ "\n", args_prefix ++ args);
219219 if (loc.line_start <= loc.line_end) {
220 print("{}\n", .{tokenizer.buffer[loc.line_start..loc.line_end]});
220 print("{s}\n", .{tokenizer.buffer[loc.line_start..loc.line_end]});
221221 {
222222 var i: usize = 0;
223223 while (i < loc.column) : (i += 1) {
......@@ -238,7 +238,7 @@ fn parseError(tokenizer: *Tokenizer, token: Token, comptime fmt: []const u8, arg
238238
239239fn assertToken(tokenizer: *Tokenizer, token: Token, id: Token.Id) !void {
240240 if (token.id != id) {
241 return parseError(tokenizer, token, "expected {}, found {}", .{ @tagName(id), @tagName(token.id) });
241 return parseError(tokenizer, token, "expected {s}, found {s}", .{ @tagName(id), @tagName(token.id) });
242242 }
243243}
244244
......@@ -374,7 +374,7 @@ fn genToc(allocator: *mem.Allocator, tokenizer: *Tokenizer) !Toc {
374374 return parseError(
375375 tokenizer,
376376 bracket_tok,
377 "unrecognized header_open param: {}",
377 "unrecognized header_open param: {s}",
378378 .{param},
379379 );
380380 }
......@@ -394,7 +394,7 @@ fn genToc(allocator: *mem.Allocator, tokenizer: *Tokenizer) !Toc {
394394 },
395395 });
396396 if (try urls.fetchPut(urlized, tag_token)) |entry| {
397 parseError(tokenizer, tag_token, "duplicate header url: #{}", .{urlized}) catch {};
397 parseError(tokenizer, tag_token, "duplicate header url: #{s}", .{urlized}) catch {};
398398 parseError(tokenizer, entry.value, "other tag here", .{}) catch {};
399399 return error.ParseError;
400400 }
......@@ -411,7 +411,7 @@ fn genToc(allocator: *mem.Allocator, tokenizer: *Tokenizer) !Toc {
411411 }
412412 last_columns = columns;
413413 try toc.writeByteNTimes(' ', 4 + header_stack_size * 4);
414 try toc.print("<li><a id=\"toc-{}\" href=\"#{}\">{}</a>", .{ urlized, urlized, content });
414 try toc.print("<li><a id=\"toc-{s}\" href=\"#{s}\">{s}</a>", .{ urlized, urlized, content });
415415 } else if (mem.eql(u8, tag_name, "header_close")) {
416416 if (header_stack_size == 0) {
417417 return parseError(tokenizer, tag_token, "unbalanced close header", .{});
......@@ -515,7 +515,7 @@ fn genToc(allocator: *mem.Allocator, tokenizer: *Tokenizer) !Toc {
515515 code_kind_id = Code.Id{ .Obj = null };
516516 is_inline = true;
517517 } else {
518 return parseError(tokenizer, code_kind_tok, "unrecognized code kind: {}", .{code_kind_str});
518 return parseError(tokenizer, code_kind_tok, "unrecognized code kind: {s}", .{code_kind_str});
519519 }
520520
521521 var mode: builtin.Mode = .Debug;
......@@ -559,7 +559,7 @@ fn genToc(allocator: *mem.Allocator, tokenizer: *Tokenizer) !Toc {
559559 return parseError(
560560 tokenizer,
561561 end_code_tag,
562 "invalid token inside code_begin: {}",
562 "invalid token inside code_begin: {s}",
563563 .{end_tag_name},
564564 );
565565 }
......@@ -590,14 +590,14 @@ fn genToc(allocator: *mem.Allocator, tokenizer: *Tokenizer) !Toc {
590590 return parseError(
591591 tokenizer,
592592 end_syntax_tag,
593 "invalid token inside syntax: {}",
593 "invalid token inside syntax: {s}",
594594 .{end_tag_name},
595595 );
596596 }
597597 _ = try eatToken(tokenizer, Token.Id.BracketClose);
598598 try nodes.append(Node{ .Syntax = content_tok });
599599 } else {
600 return parseError(tokenizer, tag_token, "unrecognized tag name: {}", .{tag_name});
600 return parseError(tokenizer, tag_token, "unrecognized tag name: {s}", .{tag_name});
601601 }
602602 },
603603 else => return parseError(tokenizer, token, "invalid token", .{}),
......@@ -744,7 +744,7 @@ fn termColor(allocator: *mem.Allocator, input: []const u8) ![]u8 {
744744 try out.writeAll("</span>");
745745 }
746746 if (first_number != 0 or second_number != 0) {
747 try out.print("<span class=\"t{}_{}\">", .{ first_number, second_number });
747 try out.print("<span class=\"t{d}_{d}\">", .{ first_number, second_number });
748748 open_span_count += 1;
749749 }
750750 },
......@@ -1004,9 +1004,9 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: any
10041004 },
10051005 .Link => |info| {
10061006 if (!toc.urls.contains(info.url)) {
1007 return parseError(tokenizer, info.token, "url not found: {}", .{info.url});
1007 return parseError(tokenizer, info.token, "url not found: {s}", .{info.url});
10081008 }
1009 try out.print("<a href=\"#{}\">{}</a>", .{ info.url, info.name });
1009 try out.print("<a href=\"#{s}\">{s}</a>", .{ info.url, info.name });
10101010 },
10111011 .Nav => {
10121012 try out.writeAll(toc.toc);
......@@ -1018,7 +1018,7 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: any
10181018 },
10191019 .HeaderOpen => |info| {
10201020 try out.print(
1021 "<h{} id=\"{}\"><a href=\"#toc-{}\">{}</a> <a class=\"hdr\" href=\"#{}\">§</a></h{}>\n",
1021 "<h{d} id=\"{s}\"><a href=\"#toc-{s}\">{s}</a> <a class=\"hdr\" href=\"#{s}\">§</a></h{d}>\n",
10221022 .{ info.n, info.url, info.url, info.name, info.url, info.n },
10231023 );
10241024 },
......@@ -1027,9 +1027,9 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: any
10271027 for (items) |item| {
10281028 const url = try urlize(allocator, item.name);
10291029 if (!toc.urls.contains(url)) {
1030 return parseError(tokenizer, item.token, "url not found: {}", .{url});
1030 return parseError(tokenizer, item.token, "url not found: {s}", .{url});
10311031 }
1032 try out.print("<li><a href=\"#{}\">{}</a></li>\n", .{ url, item.name });
1032 try out.print("<li><a href=\"#{s}\">{s}</a></li>\n", .{ url, item.name });
10331033 }
10341034 try out.writeAll("</ul>\n");
10351035 },
......@@ -1043,12 +1043,12 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: any
10431043 const raw_source = tokenizer.buffer[code.source_token.start..code.source_token.end];
10441044 const trimmed_raw_source = mem.trim(u8, raw_source, " \n");
10451045 if (!code.is_inline) {
1046 try out.print("<p class=\"file\">{}.zig</p>", .{code.name});
1046 try out.print("<p class=\"file\">{s}.zig</p>", .{code.name});
10471047 }
10481048 try out.writeAll("<pre>");
10491049 try tokenizeAndPrint(tokenizer, out, code.source_token);
10501050 try out.writeAll("</pre>");
1051 const name_plus_ext = try std.fmt.allocPrint(allocator, "{}.zig", .{code.name});
1051 const name_plus_ext = try std.fmt.allocPrint(allocator, "{s}.zig", .{code.name});
10521052 const tmp_source_file_name = try fs.path.join(
10531053 allocator,
10541054 &[_][]const u8{ tmp_dir_name, name_plus_ext },
......@@ -1057,7 +1057,7 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: any
10571057
10581058 switch (code.id) {
10591059 Code.Id.Exe => |expected_outcome| code_block: {
1060 const name_plus_bin_ext = try std.fmt.allocPrint(allocator, "{}{}", .{ code.name, exe_ext });
1060 const name_plus_bin_ext = try std.fmt.allocPrint(allocator, "{s}{s}", .{ code.name, exe_ext });
10611061 var build_args = std.ArrayList([]const u8).init(allocator);
10621062 defer build_args.deinit();
10631063 try build_args.appendSlice(&[_][]const u8{
......@@ -1066,7 +1066,7 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: any
10661066 "--color", "on",
10671067 "--enable-cache", tmp_source_file_name,
10681068 });
1069 try out.print("<pre><code class=\"shell\">$ zig build-exe {}.zig", .{code.name});
1069 try out.print("<pre><code class=\"shell\">$ zig build-exe {s}.zig", .{code.name});
10701070 switch (code.mode) {
10711071 .Debug => {},
10721072 else => {
......@@ -1075,7 +1075,7 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: any
10751075 },
10761076 }
10771077 for (code.link_objects) |link_object| {
1078 const name_with_ext = try std.fmt.allocPrint(allocator, "{}{}", .{ link_object, obj_ext });
1078 const name_with_ext = try std.fmt.allocPrint(allocator, "{s}{s}", .{ link_object, obj_ext });
10791079 const full_path_object = try fs.path.join(
10801080 allocator,
10811081 &[_][]const u8{ tmp_dir_name, name_with_ext },
......@@ -1093,7 +1093,7 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: any
10931093 if (code.target_str) |triple| {
10941094 try build_args.appendSlice(&[_][]const u8{ "-target", triple });
10951095 if (!code.is_inline) {
1096 try out.print(" -target {}", .{triple});
1096 try out.print(" -target {s}", .{triple});
10971097 }
10981098 }
10991099 if (expected_outcome == .BuildFail) {
......@@ -1106,20 +1106,20 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: any
11061106 switch (result.term) {
11071107 .Exited => |exit_code| {
11081108 if (exit_code == 0) {
1109 print("{}\nThe following command incorrectly succeeded:\n", .{result.stderr});
1109 print("{s}\nThe following command incorrectly succeeded:\n", .{result.stderr});
11101110 dumpArgs(build_args.items);
11111111 return parseError(tokenizer, code.source_token, "example incorrectly compiled", .{});
11121112 }
11131113 },
11141114 else => {
1115 print("{}\nThe following command crashed:\n", .{result.stderr});
1115 print("{s}\nThe following command crashed:\n", .{result.stderr});
11161116 dumpArgs(build_args.items);
11171117 return parseError(tokenizer, code.source_token, "example compile crashed", .{});
11181118 },
11191119 }
11201120 const escaped_stderr = try escapeHtml(allocator, result.stderr);
11211121 const colored_stderr = try termColor(allocator, escaped_stderr);
1122 try out.print("\n{}</code></pre>\n", .{colored_stderr});
1122 try out.print("\n{s}</code></pre>\n", .{colored_stderr});
11231123 break :code_block;
11241124 }
11251125 const exec_result = exec(allocator, &env_map, build_args.items) catch
......@@ -1138,7 +1138,7 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: any
11381138 }
11391139
11401140 const path_to_exe_dir = mem.trim(u8, exec_result.stdout, " \r\n");
1141 const path_to_exe_basename = try std.fmt.allocPrint(allocator, "{}{}", .{
1141 const path_to_exe_basename = try std.fmt.allocPrint(allocator, "{s}{s}", .{
11421142 code.name,
11431143 target.exeFileExt(),
11441144 });
......@@ -1160,7 +1160,7 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: any
11601160 switch (result.term) {
11611161 .Exited => |exit_code| {
11621162 if (exit_code == 0) {
1163 print("{}\nThe following command incorrectly succeeded:\n", .{result.stderr});
1163 print("{s}\nThe following command incorrectly succeeded:\n", .{result.stderr});
11641164 dumpArgs(run_args);
11651165 return parseError(tokenizer, code.source_token, "example incorrectly compiled", .{});
11661166 }
......@@ -1179,7 +1179,7 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: any
11791179 const colored_stderr = try termColor(allocator, escaped_stderr);
11801180 const colored_stdout = try termColor(allocator, escaped_stdout);
11811181
1182 try out.print("\n$ ./{}\n{}{}", .{ code.name, colored_stdout, colored_stderr });
1182 try out.print("\n$ ./{s}\n{s}{s}", .{ code.name, colored_stdout, colored_stderr });
11831183 if (exited_with_signal) {
11841184 try out.print("(process terminated by signal)", .{});
11851185 }
......@@ -1190,7 +1190,7 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: any
11901190 defer test_args.deinit();
11911191
11921192 try test_args.appendSlice(&[_][]const u8{ zig_exe, "test", tmp_source_file_name });
1193 try out.print("<pre><code class=\"shell\">$ zig test {}.zig", .{code.name});
1193 try out.print("<pre><code class=\"shell\">$ zig test {s}.zig", .{code.name});
11941194 switch (code.mode) {
11951195 .Debug => {},
11961196 else => {
......@@ -1204,12 +1204,12 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: any
12041204 }
12051205 if (code.target_str) |triple| {
12061206 try test_args.appendSlice(&[_][]const u8{ "-target", triple });
1207 try out.print(" -target {}", .{triple});
1207 try out.print(" -target {s}", .{triple});
12081208 }
12091209 const result = exec(allocator, &env_map, test_args.items) catch return parseError(tokenizer, code.source_token, "test failed", .{});
12101210 const escaped_stderr = try escapeHtml(allocator, result.stderr);
12111211 const escaped_stdout = try escapeHtml(allocator, result.stdout);
1212 try out.print("\n{}{}</code></pre>\n", .{ escaped_stderr, escaped_stdout });
1212 try out.print("\n{s}{s}</code></pre>\n", .{ escaped_stderr, escaped_stdout });
12131213 },
12141214 Code.Id.TestError => |error_match| {
12151215 var test_args = std.ArrayList([]const u8).init(allocator);
......@@ -1222,7 +1222,7 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: any
12221222 "on",
12231223 tmp_source_file_name,
12241224 });
1225 try out.print("<pre><code class=\"shell\">$ zig test {}.zig", .{code.name});
1225 try out.print("<pre><code class=\"shell\">$ zig test {s}.zig", .{code.name});
12261226 switch (code.mode) {
12271227 .Debug => {},
12281228 else => {
......@@ -1239,24 +1239,24 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: any
12391239 switch (result.term) {
12401240 .Exited => |exit_code| {
12411241 if (exit_code == 0) {
1242 print("{}\nThe following command incorrectly succeeded:\n", .{result.stderr});
1242 print("{s}\nThe following command incorrectly succeeded:\n", .{result.stderr});
12431243 dumpArgs(test_args.items);
12441244 return parseError(tokenizer, code.source_token, "example incorrectly compiled", .{});
12451245 }
12461246 },
12471247 else => {
1248 print("{}\nThe following command crashed:\n", .{result.stderr});
1248 print("{s}\nThe following command crashed:\n", .{result.stderr});
12491249 dumpArgs(test_args.items);
12501250 return parseError(tokenizer, code.source_token, "example compile crashed", .{});
12511251 },
12521252 }
12531253 if (mem.indexOf(u8, result.stderr, error_match) == null) {
1254 print("{}\nExpected to find '{}' in stderr\n", .{ result.stderr, error_match });
1254 print("{s}\nExpected to find '{s}' in stderr\n", .{ result.stderr, error_match });
12551255 return parseError(tokenizer, code.source_token, "example did not have expected compile error", .{});
12561256 }
12571257 const escaped_stderr = try escapeHtml(allocator, result.stderr);
12581258 const colored_stderr = try termColor(allocator, escaped_stderr);
1259 try out.print("\n{}</code></pre>\n", .{colored_stderr});
1259 try out.print("\n{s}</code></pre>\n", .{colored_stderr});
12601260 },
12611261
12621262 Code.Id.TestSafety => |error_match| {
......@@ -1294,31 +1294,31 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: any
12941294 switch (result.term) {
12951295 .Exited => |exit_code| {
12961296 if (exit_code == 0) {
1297 print("{}\nThe following command incorrectly succeeded:\n", .{result.stderr});
1297 print("{s}\nThe following command incorrectly succeeded:\n", .{result.stderr});
12981298 dumpArgs(test_args.items);
12991299 return parseError(tokenizer, code.source_token, "example test incorrectly succeeded", .{});
13001300 }
13011301 },
13021302 else => {
1303 print("{}\nThe following command crashed:\n", .{result.stderr});
1303 print("{s}\nThe following command crashed:\n", .{result.stderr});
13041304 dumpArgs(test_args.items);
13051305 return parseError(tokenizer, code.source_token, "example compile crashed", .{});
13061306 },
13071307 }
13081308 if (mem.indexOf(u8, result.stderr, error_match) == null) {
1309 print("{}\nExpected to find '{}' in stderr\n", .{ result.stderr, error_match });
1309 print("{s}\nExpected to find '{s}' in stderr\n", .{ result.stderr, error_match });
13101310 return parseError(tokenizer, code.source_token, "example did not have expected runtime safety error message", .{});
13111311 }
13121312 const escaped_stderr = try escapeHtml(allocator, result.stderr);
13131313 const colored_stderr = try termColor(allocator, escaped_stderr);
1314 try out.print("<pre><code class=\"shell\">$ zig test {}.zig{}\n{}</code></pre>\n", .{
1314 try out.print("<pre><code class=\"shell\">$ zig test {s}.zig{s}\n{s}</code></pre>\n", .{
13151315 code.name,
13161316 mode_arg,
13171317 colored_stderr,
13181318 });
13191319 },
13201320 Code.Id.Obj => |maybe_error_match| {
1321 const name_plus_obj_ext = try std.fmt.allocPrint(allocator, "{}{}", .{ code.name, obj_ext });
1321 const name_plus_obj_ext = try std.fmt.allocPrint(allocator, "{s}{s}", .{ code.name, obj_ext });
13221322 const tmp_obj_file_name = try fs.path.join(
13231323 allocator,
13241324 &[_][]const u8{ tmp_dir_name, name_plus_obj_ext },
......@@ -1326,7 +1326,7 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: any
13261326 var build_args = std.ArrayList([]const u8).init(allocator);
13271327 defer build_args.deinit();
13281328
1329 const name_plus_h_ext = try std.fmt.allocPrint(allocator, "{}.h", .{code.name});
1329 const name_plus_h_ext = try std.fmt.allocPrint(allocator, "{s}.h", .{code.name});
13301330 const output_h_file_name = try fs.path.join(
13311331 allocator,
13321332 &[_][]const u8{ tmp_dir_name, name_plus_h_ext },
......@@ -1345,7 +1345,7 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: any
13451345 }),
13461346 });
13471347 if (!code.is_inline) {
1348 try out.print("<pre><code class=\"shell\">$ zig build-obj {}.zig", .{code.name});
1348 try out.print("<pre><code class=\"shell\">$ zig build-obj {s}.zig", .{code.name});
13491349 }
13501350
13511351 switch (code.mode) {
......@@ -1360,7 +1360,7 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: any
13601360
13611361 if (code.target_str) |triple| {
13621362 try build_args.appendSlice(&[_][]const u8{ "-target", triple });
1363 try out.print(" -target {}", .{triple});
1363 try out.print(" -target {s}", .{triple});
13641364 }
13651365
13661366 if (maybe_error_match) |error_match| {
......@@ -1373,24 +1373,24 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: any
13731373 switch (result.term) {
13741374 .Exited => |exit_code| {
13751375 if (exit_code == 0) {
1376 print("{}\nThe following command incorrectly succeeded:\n", .{result.stderr});
1376 print("{s}\nThe following command incorrectly succeeded:\n", .{result.stderr});
13771377 dumpArgs(build_args.items);
13781378 return parseError(tokenizer, code.source_token, "example build incorrectly succeeded", .{});
13791379 }
13801380 },
13811381 else => {
1382 print("{}\nThe following command crashed:\n", .{result.stderr});
1382 print("{s}\nThe following command crashed:\n", .{result.stderr});
13831383 dumpArgs(build_args.items);
13841384 return parseError(tokenizer, code.source_token, "example compile crashed", .{});
13851385 },
13861386 }
13871387 if (mem.indexOf(u8, result.stderr, error_match) == null) {
1388 print("{}\nExpected to find '{}' in stderr\n", .{ result.stderr, error_match });
1388 print("{s}\nExpected to find '{s}' in stderr\n", .{ result.stderr, error_match });
13891389 return parseError(tokenizer, code.source_token, "example did not have expected compile error message", .{});
13901390 }
13911391 const escaped_stderr = try escapeHtml(allocator, result.stderr);
13921392 const colored_stderr = try termColor(allocator, escaped_stderr);
1393 try out.print("\n{}", .{colored_stderr});
1393 try out.print("\n{s}", .{colored_stderr});
13941394 } else {
13951395 _ = exec(allocator, &env_map, build_args.items) catch return parseError(tokenizer, code.source_token, "example failed to compile", .{});
13961396 }
......@@ -1416,7 +1416,7 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: any
14161416 tmp_dir_name, fs.path.sep_str, bin_basename,
14171417 }),
14181418 });
1419 try out.print("<pre><code class=\"shell\">$ zig build-lib {}.zig", .{code.name});
1419 try out.print("<pre><code class=\"shell\">$ zig build-lib {s}.zig", .{code.name});
14201420 switch (code.mode) {
14211421 .Debug => {},
14221422 else => {
......@@ -1426,12 +1426,12 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: any
14261426 }
14271427 if (code.target_str) |triple| {
14281428 try test_args.appendSlice(&[_][]const u8{ "-target", triple });
1429 try out.print(" -target {}", .{triple});
1429 try out.print(" -target {s}", .{triple});
14301430 }
14311431 const result = exec(allocator, &env_map, test_args.items) catch return parseError(tokenizer, code.source_token, "test failed", .{});
14321432 const escaped_stderr = try escapeHtml(allocator, result.stderr);
14331433 const escaped_stdout = try escapeHtml(allocator, result.stdout);
1434 try out.print("\n{}{}</code></pre>\n", .{ escaped_stderr, escaped_stdout });
1434 try out.print("\n{s}{s}</code></pre>\n", .{ escaped_stderr, escaped_stdout });
14351435 },
14361436 }
14371437 print("OK\n", .{});
......@@ -1450,13 +1450,13 @@ fn exec(allocator: *mem.Allocator, env_map: *std.BufMap, args: []const []const u
14501450 switch (result.term) {
14511451 .Exited => |exit_code| {
14521452 if (exit_code != 0) {
1453 print("{}\nThe following command exited with code {}:\n", .{ result.stderr, exit_code });
1453 print("{s}\nThe following command exited with code {}:\n", .{ result.stderr, exit_code });
14541454 dumpArgs(args);
14551455 return error.ChildExitError;
14561456 }
14571457 },
14581458 else => {
1459 print("{}\nThe following command crashed:\n", .{result.stderr});
1459 print("{s}\nThe following command crashed:\n", .{result.stderr});
14601460 dumpArgs(args);
14611461 return error.ChildCrashed;
14621462 },
......@@ -1471,7 +1471,7 @@ fn getBuiltinCode(allocator: *mem.Allocator, env_map: *std.BufMap, zig_exe: []co
14711471
14721472fn dumpArgs(args: []const []const u8) void {
14731473 for (args) |arg|
1474 print("{} ", .{arg})
1474 print("{s} ", .{arg})
14751475 else
14761476 print("\n", .{});
14771477}
doc/langref.html.in+21-21
......@@ -236,7 +236,7 @@ const std = @import("std");
236236
237237pub fn main() !void {
238238 const stdout = std.io.getStdOut().writer();
239 try stdout.print("Hello, {}!\n", .{"world"});
239 try stdout.print("Hello, {s}!\n", .{"world"});
240240}
241241 {#code_end#}
242242 <p>
......@@ -308,7 +308,7 @@ pub fn main() !void {
308308 multiple arguments passed to a function, they are separated by commas <code>,</code>.
309309 </p>
310310 <p>
311 The two arguments passed to the <code>stdout.print()</code> function, <code>"Hello, {}!\n"</code>
311 The two arguments passed to the <code>stdout.print()</code> function, <code>"Hello, {s}!\n"</code>
312312 and <code>.{"world"}</code>, are evaluated at {#link|compile-time|comptime#}. The code sample is
313313 purposely written to show how to perform {#link|string|String Literals and Character Literals#}
314314 substitution in the <code>print</code> function. The curly-braces inside of the first argument
......@@ -435,7 +435,7 @@ pub fn main() void {
435435 var optional_value: ?[]const u8 = null;
436436 assert(optional_value == null);
437437
438 print("\noptional 1\ntype: {}\nvalue: {}\n", .{
438 print("\noptional 1\ntype: {s}\nvalue: {s}\n", .{
439439 @typeName(@TypeOf(optional_value)),
440440 optional_value,
441441 });
......@@ -443,7 +443,7 @@ pub fn main() void {
443443 optional_value = "hi";
444444 assert(optional_value != null);
445445
446 print("\noptional 2\ntype: {}\nvalue: {}\n", .{
446 print("\noptional 2\ntype: {s}\nvalue: {s}\n", .{
447447 @typeName(@TypeOf(optional_value)),
448448 optional_value,
449449 });
......@@ -451,14 +451,14 @@ pub fn main() void {
451451 // error union
452452 var number_or_error: anyerror!i32 = error.ArgNotFound;
453453
454 print("\nerror union 1\ntype: {}\nvalue: {}\n", .{
454 print("\nerror union 1\ntype: {s}\nvalue: {}\n", .{
455455 @typeName(@TypeOf(number_or_error)),
456456 number_or_error,
457457 });
458458
459459 number_or_error = 1234;
460460
461 print("\nerror union 2\ntype: {}\nvalue: {}\n", .{
461 print("\nerror union 2\ntype: {s}\nvalue: {}\n", .{
462462 @typeName(@TypeOf(number_or_error)),
463463 number_or_error,
464464 });
......@@ -2339,7 +2339,7 @@ test "using slices for strings" {
23392339 // You can use slice syntax on an array to convert an array into a slice.
23402340 const all_together_slice = all_together[0..];
23412341 // String concatenation example.
2342 const hello_world = try fmt.bufPrint(all_together_slice, "{} {}", .{ hello, world });
2342 const hello_world = try fmt.bufPrint(all_together_slice, "{s} {s}", .{ hello, world });
23432343
23442344 // Generally, you can use UTF-8 and not worry about whether something is a
23452345 // string. If you don't need to deal with individual characters, no need
......@@ -2772,9 +2772,9 @@ const std = @import("std");
27722772
27732773pub fn main() void {
27742774 const Foo = struct {};
2775 std.debug.print("variable: {}\n", .{@typeName(Foo)});
2776 std.debug.print("anonymous: {}\n", .{@typeName(struct {})});
2777 std.debug.print("function: {}\n", .{@typeName(List(i32))});
2775 std.debug.print("variable: {s}\n", .{@typeName(Foo)});
2776 std.debug.print("anonymous: {s}\n", .{@typeName(struct {})});
2777 std.debug.print("function: {s}\n", .{@typeName(List(i32))});
27782778}
27792779
27802780fn List(comptime T: type) type {
......@@ -6110,7 +6110,7 @@ const a_number: i32 = 1234;
61106110const a_string = "foobar";
61116111
61126112pub fn main() void {
6113 print("here is a string: '{}' here is a number: {}\n", .{a_string, a_number});
6113 print("here is a string: '{s}' here is a number: {}\n", .{a_string, a_number});
61146114}
61156115 {#code_end#}
61166116
......@@ -6230,7 +6230,7 @@ const a_number: i32 = 1234;
62306230const a_string = "foobar";
62316231
62326232test "printf too many arguments" {
6233 print("here is a string: '{}' here is a number: {}\n", .{
6233 print("here is a string: '{s}' here is a number: {}\n", .{
62346234 a_string,
62356235 a_number,
62366236 a_number,
......@@ -6249,7 +6249,7 @@ const print = @import("std").debug.print;
62496249
62506250const a_number: i32 = 1234;
62516251const a_string = "foobar";
6252const fmt = "here is a string: '{}' here is a number: {}\n";
6252const fmt = "here is a string: '{s}' here is a number: {}\n";
62536253
62546254pub fn main() void {
62556255 print(fmt, .{a_string, a_number});
......@@ -6720,8 +6720,8 @@ fn amain() !void {
67206720 const download_text = try await download_frame;
67216721 defer allocator.free(download_text);
67226722
6723 std.debug.print("download_text: {}\n", .{download_text});
6724 std.debug.print("file_text: {}\n", .{file_text});
6723 std.debug.print("download_text: {s}\n", .{download_text});
6724 std.debug.print("file_text: {s}\n", .{file_text});
67256725}
67266726
67276727var global_download_frame: anyframe = undefined;
......@@ -6790,8 +6790,8 @@ fn amain() !void {
67906790 const download_text = try await download_frame;
67916791 defer allocator.free(download_text);
67926792
6793 std.debug.print("download_text: {}\n", .{download_text});
6794 std.debug.print("file_text: {}\n", .{file_text});
6793 std.debug.print("download_text: {s}\n", .{download_text});
6794 std.debug.print("file_text: {s}\n", .{file_text});
67956795}
67966796
67976797fn fetchUrl(allocator: *Allocator, url: []const u8) ![]u8 {
......@@ -8848,7 +8848,7 @@ pub fn main() !void {
88488848 var byte: u8 = 255;
88498849
88508850 byte = if (math.add(u8, byte, 1)) |result| result else |err| {
8851 print("unable to add one: {}\n", .{@errorName(err)});
8851 print("unable to add one: {s}\n", .{@errorName(err)});
88528852 return err;
88538853 };
88548854
......@@ -9078,7 +9078,7 @@ pub fn main() void {
90789078 if (result) |number| {
90799079 print("got number: {}\n", .{number});
90809080 } else |err| {
9081 print("got error: {}\n", .{@errorName(err)});
9081 print("got error: {s}\n", .{@errorName(err)});
90829082 }
90839083}
90849084
......@@ -9135,7 +9135,7 @@ const Foo = enum {
91359135pub fn main() void {
91369136 var a: u2 = 3;
91379137 var b = @intToEnum(Foo, a);
9138 std.debug.print("value: {}\n", .{@tagName(b)});
9138 std.debug.print("value: {s}\n", .{@tagName(b)});
91399139}
91409140 {#code_end#}
91419141 {#header_close#}
......@@ -10025,7 +10025,7 @@ pub fn main() !void {
1002510025 defer std.process.argsFree(gpa, args);
1002610026
1002710027 for (args) |arg, i| {
10028 std.debug.print("{}: {}\n", .{ i, arg });
10028 std.debug.print("{}: {s}\n", .{ i, arg });
1002910029 }
1003010030}
1003110031 {#code_end#}
lib/std/testing.zig+1-2
......@@ -29,8 +29,7 @@ pub var zig_exe_path: []const u8 = undefined;
2929/// and then aborts when actual_error_union is not expected_error.
3030pub fn expectError(expected_error: anyerror, actual_error_union: anytype) void {
3131 if (actual_error_union) |actual_payload| {
32 // std.debug.panic("expected error.{s}, found {}", .{ @errorName(expected_error), actual_payload });
33 std.debug.panic("expected error.{s}, found", .{@errorName(expected_error)});
32 std.debug.panic("expected error.{s}, found {}", .{ @errorName(expected_error), actual_payload });
3433 } else |actual_error| {
3534 if (expected_error != actual_error) {
3635 std.debug.panic("expected error.{s}, found error.{s}", .{
src/astgen.zig+3-3
......@@ -560,14 +560,14 @@ fn varDecl(
560560 .local_val => {
561561 const local_val = s.cast(Scope.LocalVal).?;
562562 if (mem.eql(u8, local_val.name, ident_name)) {
563 return mod.fail(scope, name_src, "redefinition of '{}'", .{ident_name});
563 return mod.fail(scope, name_src, "redefinition of '{s}'", .{ident_name});
564564 }
565565 s = local_val.parent;
566566 },
567567 .local_ptr => {
568568 const local_ptr = s.cast(Scope.LocalPtr).?;
569569 if (mem.eql(u8, local_ptr.name, ident_name)) {
570 return mod.fail(scope, name_src, "redefinition of '{}'", .{ident_name});
570 return mod.fail(scope, name_src, "redefinition of '{s}'", .{ident_name});
571571 }
572572 s = local_ptr.parent;
573573 },
......@@ -578,7 +578,7 @@ fn varDecl(
578578
579579 // Namespace vars shadowing detection
580580 if (mod.lookupDeclName(scope, ident_name)) |_| {
581 return mod.fail(scope, name_src, "redefinition of '{}'", .{ident_name});
581 return mod.fail(scope, name_src, "redefinition of '{s}'", .{ident_name});
582582 }
583583 const init_node = node.getInitNode() orelse
584584 return mod.fail(scope, name_src, "variables must be initialized", .{});
src/link/MachO.zig+1-1
......@@ -620,7 +620,7 @@ fn linkWithLLD(self: *MachO, comp: *Compilation) !void {
620620 try argv.append(cur_vers);
621621 }
622622
623 const dylib_install_name = try std.fmt.allocPrint(arena, "@rpath/{}", .{self.base.options.emit.?.sub_path});
623 const dylib_install_name = try std.fmt.allocPrint(arena, "@rpath/{s}", .{self.base.options.emit.?.sub_path});
624624 try argv.append("-install_name");
625625 try argv.append(dylib_install_name);
626626 }