authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2019-12-09 00:18:01-05:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2019-12-09 00:18:01-05:00
log8b3c0bbeeef080b77d0cb7999682abc52de437e3
tree0bddf7eb99d6daaaa2e5ee80b51a6766aefb7d9c
parentd571fad20eac23cadf6116742ad4abab5ed281e5
signature Commit is signed but in an unrecognized format.

update docgen to new format API

1 files changed, 146 insertions(+), 135 deletions(-)

doc/docgen.zig+146-135
......@@ -215,32 +215,33 @@ const Tokenizer = struct {
215215 }
216216};
217217
218fn parseError(tokenizer: *Tokenizer, token: Token, comptime fmt: []const u8, args: ...) anyerror {
218fn parseError(tokenizer: *Tokenizer, token: Token, comptime fmt: []const u8, args: var) anyerror {
219219 const loc = tokenizer.getTokenLocation(token);
220 warn("{}:{}:{}: error: " ++ fmt ++ "\n", tokenizer.source_file_name, loc.line + 1, loc.column + 1, args);
220 const args_prefix = .{ tokenizer.source_file_name, loc.line + 1, loc.column + 1 };
221 warn("{}:{}:{}: error: " ++ fmt ++ "\n", args_prefix ++ args);
221222 if (loc.line_start <= loc.line_end) {
222 warn("{}\n", tokenizer.buffer[loc.line_start..loc.line_end]);
223 warn("{}\n", .{tokenizer.buffer[loc.line_start..loc.line_end]});
223224 {
224225 var i: usize = 0;
225226 while (i < loc.column) : (i += 1) {
226 warn(" ");
227 warn(" ", .{});
227228 }
228229 }
229230 {
230231 const caret_count = token.end - token.start;
231232 var i: usize = 0;
232233 while (i < caret_count) : (i += 1) {
233 warn("~");
234 warn("~", .{});
234235 }
235236 }
236 warn("\n");
237 warn("\n", .{});
237238 }
238239 return error.ParseError;
239240}
240241
241242fn assertToken(tokenizer: *Tokenizer, token: Token, id: Token.Id) !void {
242243 if (token.id != id) {
243 return parseError(tokenizer, token, "expected {}, found {}", @tagName(id), @tagName(token.id));
244 return parseError(tokenizer, token, "expected {}, found {}", .{ @tagName(id), @tagName(token.id) });
244245 }
245246}
246247
......@@ -339,7 +340,7 @@ fn genToc(allocator: *mem.Allocator, tokenizer: *Tokenizer) !Toc {
339340 switch (token.id) {
340341 Token.Id.Eof => {
341342 if (header_stack_size != 0) {
342 return parseError(tokenizer, token, "unbalanced headers");
343 return parseError(tokenizer, token, "unbalanced headers", .{});
343344 }
344345 try toc.write(" </ul>\n");
345346 break;
......@@ -373,10 +374,15 @@ fn genToc(allocator: *mem.Allocator, tokenizer: *Tokenizer) !Toc {
373374 if (mem.eql(u8, param, "3col")) {
374375 columns = 3;
375376 } else {
376 return parseError(tokenizer, bracket_tok, "unrecognized header_open param: {}", param);
377 return parseError(
378 tokenizer,
379 bracket_tok,
380 "unrecognized header_open param: {}",
381 .{param},
382 );
377383 }
378384 },
379 else => return parseError(tokenizer, bracket_tok, "invalid header_open token"),
385 else => return parseError(tokenizer, bracket_tok, "invalid header_open token", .{}),
380386 }
381387 }
382388
......@@ -391,15 +397,15 @@ fn genToc(allocator: *mem.Allocator, tokenizer: *Tokenizer) !Toc {
391397 },
392398 });
393399 if (try urls.put(urlized, tag_token)) |entry| {
394 parseError(tokenizer, tag_token, "duplicate header url: #{}", urlized) catch {};
395 parseError(tokenizer, entry.value, "other tag here") catch {};
400 parseError(tokenizer, tag_token, "duplicate header url: #{}", .{urlized}) catch {};
401 parseError(tokenizer, entry.value, "other tag here", .{}) catch {};
396402 return error.ParseError;
397403 }
398404 if (last_action == Action.Open) {
399405 try toc.writeByte('\n');
400406 try toc.writeByteNTimes(' ', header_stack_size * 4);
401407 if (last_columns) |n| {
402 try toc.print("<ul style=\"columns: {}\">\n", n);
408 try toc.print("<ul style=\"columns: {}\">\n", .{n});
403409 } else {
404410 try toc.write("<ul>\n");
405411 }
......@@ -408,10 +414,10 @@ fn genToc(allocator: *mem.Allocator, tokenizer: *Tokenizer) !Toc {
408414 }
409415 last_columns = columns;
410416 try toc.writeByteNTimes(' ', 4 + header_stack_size * 4);
411 try toc.print("<li><a id=\"toc-{}\" href=\"#{}\">{}</a>", urlized, urlized, content);
417 try toc.print("<li><a id=\"toc-{}\" href=\"#{}\">{}</a>", .{ urlized, urlized, content });
412418 } else if (mem.eql(u8, tag_name, "header_close")) {
413419 if (header_stack_size == 0) {
414 return parseError(tokenizer, tag_token, "unbalanced close header");
420 return parseError(tokenizer, tag_token, "unbalanced close header", .{});
415421 }
416422 header_stack_size -= 1;
417423 _ = try eatToken(tokenizer, Token.Id.BracketClose);
......@@ -442,7 +448,7 @@ fn genToc(allocator: *mem.Allocator, tokenizer: *Tokenizer) !Toc {
442448 try nodes.append(Node{ .SeeAlso = list.toOwnedSlice() });
443449 break;
444450 },
445 else => return parseError(tokenizer, see_also_tok, "invalid see_also token"),
451 else => return parseError(tokenizer, see_also_tok, "invalid see_also token", .{}),
446452 }
447453 }
448454 } else if (mem.eql(u8, tag_name, "link")) {
......@@ -459,7 +465,7 @@ fn genToc(allocator: *mem.Allocator, tokenizer: *Tokenizer) !Toc {
459465 _ = try eatToken(tokenizer, Token.Id.BracketClose);
460466 break :blk tokenizer.buffer[explicit_text.start..explicit_text.end];
461467 },
462 else => return parseError(tokenizer, tok, "invalid link token"),
468 else => return parseError(tokenizer, tok, "invalid link token", .{}),
463469 }
464470 };
465471
......@@ -482,7 +488,7 @@ fn genToc(allocator: *mem.Allocator, tokenizer: *Tokenizer) !Toc {
482488 _ = try eatToken(tokenizer, Token.Id.BracketClose);
483489 },
484490 Token.Id.BracketClose => {},
485 else => return parseError(tokenizer, token, "invalid token"),
491 else => return parseError(tokenizer, token, "invalid token", .{}),
486492 }
487493 const code_kind_str = tokenizer.buffer[code_kind_tok.start..code_kind_tok.end];
488494 var code_kind_id: Code.Id = undefined;
......@@ -512,7 +518,7 @@ fn genToc(allocator: *mem.Allocator, tokenizer: *Tokenizer) !Toc {
512518 code_kind_id = Code.Id{ .Obj = null };
513519 is_inline = true;
514520 } else {
515 return parseError(tokenizer, code_kind_tok, "unrecognized code kind: {}", code_kind_str);
521 return parseError(tokenizer, code_kind_tok, "unrecognized code kind: {}", .{code_kind_str});
516522 }
517523
518524 var mode = builtin.Mode.Debug;
......@@ -550,7 +556,12 @@ fn genToc(allocator: *mem.Allocator, tokenizer: *Tokenizer) !Toc {
550556 _ = try eatToken(tokenizer, Token.Id.BracketClose);
551557 break content_tok;
552558 } else {
553 return parseError(tokenizer, end_code_tag, "invalid token inside code_begin: {}", end_tag_name);
559 return parseError(
560 tokenizer,
561 end_code_tag,
562 "invalid token inside code_begin: {}",
563 .{end_tag_name},
564 );
554565 }
555566 _ = try eatToken(tokenizer, Token.Id.BracketClose);
556567 } else
......@@ -575,15 +586,20 @@ fn genToc(allocator: *mem.Allocator, tokenizer: *Tokenizer) !Toc {
575586 const end_syntax_tag = try eatToken(tokenizer, Token.Id.TagContent);
576587 const end_tag_name = tokenizer.buffer[end_syntax_tag.start..end_syntax_tag.end];
577588 if (!mem.eql(u8, end_tag_name, "endsyntax")) {
578 return parseError(tokenizer, end_syntax_tag, "invalid token inside syntax: {}", end_tag_name);
589 return parseError(
590 tokenizer,
591 end_syntax_tag,
592 "invalid token inside syntax: {}",
593 .{end_tag_name},
594 );
579595 }
580596 _ = try eatToken(tokenizer, Token.Id.BracketClose);
581597 try nodes.append(Node{ .Syntax = content_tok });
582598 } else {
583 return parseError(tokenizer, tag_token, "unrecognized tag name: {}", tag_name);
599 return parseError(tokenizer, tag_token, "unrecognized tag name: {}", .{tag_name});
584600 }
585601 },
586 else => return parseError(tokenizer, token, "invalid token"),
602 else => return parseError(tokenizer, token, "invalid token", .{}),
587603 }
588604 }
589605
......@@ -729,7 +745,7 @@ fn termColor(allocator: *mem.Allocator, input: []const u8) ![]u8 {
729745 try out.write("</span>");
730746 }
731747 if (first_number != 0 or second_number != 0) {
732 try out.print("<span class=\"t{}_{}\">", first_number, second_number);
748 try out.print("<span class=\"t{}_{}\">", .{ first_number, second_number });
733749 open_span_count += 1;
734750 }
735751 },
......@@ -960,6 +976,7 @@ fn tokenizeAndPrintRaw(docgen_tokenizer: *Tokenizer, out: var, source_token: Tok
960976 docgen_tokenizer,
961977 source_token,
962978 "syntax error",
979 .{},
963980 ),
964981 }
965982 index = token.end;
......@@ -987,9 +1004,9 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: var
9871004 },
9881005 Node.Link => |info| {
9891006 if (!toc.urls.contains(info.url)) {
990 return parseError(tokenizer, info.token, "url not found: {}", info.url);
1007 return parseError(tokenizer, info.token, "url not found: {}", .{info.url});
9911008 }
992 try out.print("<a href=\"#{}\">{}</a>", info.url, info.name);
1009 try out.print("<a href=\"#{}\">{}</a>", .{ info.url, info.name });
9931010 },
9941011 Node.Nav => {
9951012 try out.write(toc.toc);
......@@ -1002,12 +1019,7 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: var
10021019 Node.HeaderOpen => |info| {
10031020 try out.print(
10041021 "<h{} id=\"{}\"><a href=\"#toc-{}\">{}</a> <a class=\"hdr\" href=\"#{}\">§</a></h{}>\n",
1005 info.n,
1006 info.url,
1007 info.url,
1008 info.name,
1009 info.url,
1010 info.n,
1022 .{ info.n, info.url, info.url, info.name, info.url, info.n },
10111023 );
10121024 },
10131025 Node.SeeAlso => |items| {
......@@ -1015,9 +1027,9 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: var
10151027 for (items) |item| {
10161028 const url = try urlize(allocator, item.name);
10171029 if (!toc.urls.contains(url)) {
1018 return parseError(tokenizer, item.token, "url not found: {}", url);
1030 return parseError(tokenizer, item.token, "url not found: {}", .{url});
10191031 }
1020 try out.print("<li><a href=\"#{}\">{}</a></li>\n", url, item.name);
1032 try out.print("<li><a href=\"#{}\">{}</a></li>\n", .{ url, item.name });
10211033 }
10221034 try out.write("</ul>\n");
10231035 },
......@@ -1026,17 +1038,17 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: var
10261038 },
10271039 Node.Code => |code| {
10281040 code_progress_index += 1;
1029 warn("docgen example code {}/{}...", code_progress_index, tokenizer.code_node_count);
1041 warn("docgen example code {}/{}...", .{ code_progress_index, tokenizer.code_node_count });
10301042
10311043 const raw_source = tokenizer.buffer[code.source_token.start..code.source_token.end];
10321044 const trimmed_raw_source = mem.trim(u8, raw_source, " \n");
10331045 if (!code.is_inline) {
1034 try out.print("<p class=\"file\">{}.zig</p>", code.name);
1046 try out.print("<p class=\"file\">{}.zig</p>", .{code.name});
10351047 }
10361048 try out.write("<pre>");
10371049 try tokenizeAndPrint(tokenizer, out, code.source_token);
10381050 try out.write("</pre>");
1039 const name_plus_ext = try std.fmt.allocPrint(allocator, "{}.zig", code.name);
1051 const name_plus_ext = try std.fmt.allocPrint(allocator, "{}.zig", .{code.name});
10401052 const tmp_source_file_name = try fs.path.join(
10411053 allocator,
10421054 &[_][]const u8{ tmp_dir_name, name_plus_ext },
......@@ -1045,7 +1057,7 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: var
10451057
10461058 switch (code.id) {
10471059 Code.Id.Exe => |expected_outcome| code_block: {
1048 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, "{}{}", .{ code.name, exe_ext });
10491061 var build_args = std.ArrayList([]const u8).init(allocator);
10501062 defer build_args.deinit();
10511063 try build_args.appendSlice(&[_][]const u8{
......@@ -1059,40 +1071,40 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: var
10591071 "--cache",
10601072 "on",
10611073 });
1062 try out.print("<pre><code class=\"shell\">$ zig build-exe {}.zig", code.name);
1074 try out.print("<pre><code class=\"shell\">$ zig build-exe {}.zig", .{code.name});
10631075 switch (code.mode) {
10641076 builtin.Mode.Debug => {},
10651077 builtin.Mode.ReleaseSafe => {
10661078 try build_args.append("--release-safe");
1067 try out.print(" --release-safe");
1079 try out.print(" --release-safe", .{});
10681080 },
10691081 builtin.Mode.ReleaseFast => {
10701082 try build_args.append("--release-fast");
1071 try out.print(" --release-fast");
1083 try out.print(" --release-fast", .{});
10721084 },
10731085 builtin.Mode.ReleaseSmall => {
10741086 try build_args.append("--release-small");
1075 try out.print(" --release-small");
1087 try out.print(" --release-small", .{});
10761088 },
10771089 }
10781090 for (code.link_objects) |link_object| {
1079 const name_with_ext = try std.fmt.allocPrint(allocator, "{}{}", link_object, obj_ext);
1091 const name_with_ext = try std.fmt.allocPrint(allocator, "{}{}", .{ link_object, obj_ext });
10801092 const full_path_object = try fs.path.join(
10811093 allocator,
10821094 &[_][]const u8{ tmp_dir_name, name_with_ext },
10831095 );
10841096 try build_args.append("--object");
10851097 try build_args.append(full_path_object);
1086 try out.print(" --object {}", name_with_ext);
1098 try out.print(" --object {}", .{name_with_ext});
10871099 }
10881100 if (code.link_libc) {
10891101 try build_args.append("-lc");
1090 try out.print(" -lc");
1102 try out.print(" -lc", .{});
10911103 }
10921104 if (code.target_str) |triple| {
10931105 try build_args.appendSlice(&[_][]const u8{ "-target", triple });
10941106 if (!code.is_inline) {
1095 try out.print(" -target {}", triple);
1107 try out.print(" -target {}", .{triple});
10961108 }
10971109 }
10981110 if (expected_outcome == .BuildFail) {
......@@ -1106,29 +1118,29 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: var
11061118 switch (result.term) {
11071119 .Exited => |exit_code| {
11081120 if (exit_code == 0) {
1109 warn("{}\nThe following command incorrectly succeeded:\n", result.stderr);
1121 warn("{}\nThe following command incorrectly succeeded:\n", .{result.stderr});
11101122 for (build_args.toSliceConst()) |arg|
1111 warn("{} ", arg)
1123 warn("{} ", .{arg})
11121124 else
1113 warn("\n");
1114 return parseError(tokenizer, code.source_token, "example incorrectly compiled");
1125 warn("\n", .{});
1126 return parseError(tokenizer, code.source_token, "example incorrectly compiled", .{});
11151127 }
11161128 },
11171129 else => {
1118 warn("{}\nThe following command crashed:\n", result.stderr);
1130 warn("{}\nThe following command crashed:\n", .{result.stderr});
11191131 for (build_args.toSliceConst()) |arg|
1120 warn("{} ", arg)
1132 warn("{} ", .{arg})
11211133 else
1122 warn("\n");
1123 return parseError(tokenizer, code.source_token, "example compile crashed");
1134 warn("\n", .{});
1135 return parseError(tokenizer, code.source_token, "example compile crashed", .{});
11241136 },
11251137 }
11261138 const escaped_stderr = try escapeHtml(allocator, result.stderr);
11271139 const colored_stderr = try termColor(allocator, escaped_stderr);
1128 try out.print("\n{}</code></pre>\n", colored_stderr);
1140 try out.print("\n{}</code></pre>\n", .{colored_stderr});
11291141 break :code_block;
11301142 }
1131 const exec_result = exec(allocator, &env_map, build_args.toSliceConst()) catch return parseError(tokenizer, code.source_token, "example failed to compile");
1143 const exec_result = exec(allocator, &env_map, build_args.toSliceConst()) catch return parseError(tokenizer, code.source_token, "example failed to compile", .{});
11321144
11331145 if (code.target_str) |triple| {
11341146 if (mem.startsWith(u8, triple, "wasm32") or
......@@ -1137,7 +1149,7 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: var
11371149 (builtin.os != .linux or builtin.arch != .x86_64))
11381150 {
11391151 // skip execution
1140 try out.print("</code></pre>\n");
1152 try out.print("</code></pre>\n", .{});
11411153 break :code_block;
11421154 }
11431155 }
......@@ -1152,12 +1164,12 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: var
11521164 switch (result.term) {
11531165 .Exited => |exit_code| {
11541166 if (exit_code == 0) {
1155 warn("{}\nThe following command incorrectly succeeded:\n", result.stderr);
1167 warn("{}\nThe following command incorrectly succeeded:\n", .{result.stderr});
11561168 for (run_args) |arg|
1157 warn("{} ", arg)
1169 warn("{} ", .{arg})
11581170 else
1159 warn("\n");
1160 return parseError(tokenizer, code.source_token, "example incorrectly compiled");
1171 warn("\n", .{});
1172 return parseError(tokenizer, code.source_token, "example incorrectly compiled", .{});
11611173 }
11621174 },
11631175 .Signal => exited_with_signal = true,
......@@ -1165,7 +1177,7 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: var
11651177 }
11661178 break :blk result;
11671179 } else blk: {
1168 break :blk exec(allocator, &env_map, run_args) catch return parseError(tokenizer, code.source_token, "example crashed");
1180 break :blk exec(allocator, &env_map, run_args) catch return parseError(tokenizer, code.source_token, "example crashed", .{});
11691181 };
11701182
11711183 const escaped_stderr = try escapeHtml(allocator, result.stderr);
......@@ -1174,11 +1186,11 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: var
11741186 const colored_stderr = try termColor(allocator, escaped_stderr);
11751187 const colored_stdout = try termColor(allocator, escaped_stdout);
11761188
1177 try out.print("\n$ ./{}\n{}{}", code.name, colored_stdout, colored_stderr);
1189 try out.print("\n$ ./{}\n{}{}", .{ code.name, colored_stdout, colored_stderr });
11781190 if (exited_with_signal) {
1179 try out.print("(process terminated by signal)");
1191 try out.print("(process terminated by signal)", .{});
11801192 }
1181 try out.print("</code></pre>\n");
1193 try out.print("</code></pre>\n", .{});
11821194 },
11831195 Code.Id.Test => {
11841196 var test_args = std.ArrayList([]const u8).init(allocator);
......@@ -1191,34 +1203,34 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: var
11911203 "--cache",
11921204 "on",
11931205 });
1194 try out.print("<pre><code class=\"shell\">$ zig test {}.zig", code.name);
1206 try out.print("<pre><code class=\"shell\">$ zig test {}.zig", .{code.name});
11951207 switch (code.mode) {
11961208 builtin.Mode.Debug => {},
11971209 builtin.Mode.ReleaseSafe => {
11981210 try test_args.append("--release-safe");
1199 try out.print(" --release-safe");
1211 try out.print(" --release-safe", .{});
12001212 },
12011213 builtin.Mode.ReleaseFast => {
12021214 try test_args.append("--release-fast");
1203 try out.print(" --release-fast");
1215 try out.print(" --release-fast", .{});
12041216 },
12051217 builtin.Mode.ReleaseSmall => {
12061218 try test_args.append("--release-small");
1207 try out.print(" --release-small");
1219 try out.print(" --release-small", .{});
12081220 },
12091221 }
12101222 if (code.link_libc) {
12111223 try test_args.append("-lc");
1212 try out.print(" -lc");
1224 try out.print(" -lc", .{});
12131225 }
12141226 if (code.target_str) |triple| {
12151227 try test_args.appendSlice(&[_][]const u8{ "-target", triple });
1216 try out.print(" -target {}", triple);
1228 try out.print(" -target {}", .{triple});
12171229 }
1218 const result = exec(allocator, &env_map, test_args.toSliceConst()) catch return parseError(tokenizer, code.source_token, "test failed");
1230 const result = exec(allocator, &env_map, test_args.toSliceConst()) catch return parseError(tokenizer, code.source_token, "test failed", .{});
12191231 const escaped_stderr = try escapeHtml(allocator, result.stderr);
12201232 const escaped_stdout = try escapeHtml(allocator, result.stdout);
1221 try out.print("\n{}{}</code></pre>\n", escaped_stderr, escaped_stdout);
1233 try out.print("\n{}{}</code></pre>\n", .{ escaped_stderr, escaped_stdout });
12221234 },
12231235 Code.Id.TestError => |error_match| {
12241236 var test_args = std.ArrayList([]const u8).init(allocator);
......@@ -1233,50 +1245,50 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: var
12331245 "--output-dir",
12341246 tmp_dir_name,
12351247 });
1236 try out.print("<pre><code class=\"shell\">$ zig test {}.zig", code.name);
1248 try out.print("<pre><code class=\"shell\">$ zig test {}.zig", .{code.name});
12371249 switch (code.mode) {
12381250 builtin.Mode.Debug => {},
12391251 builtin.Mode.ReleaseSafe => {
12401252 try test_args.append("--release-safe");
1241 try out.print(" --release-safe");
1253 try out.print(" --release-safe", .{});
12421254 },
12431255 builtin.Mode.ReleaseFast => {
12441256 try test_args.append("--release-fast");
1245 try out.print(" --release-fast");
1257 try out.print(" --release-fast", .{});
12461258 },
12471259 builtin.Mode.ReleaseSmall => {
12481260 try test_args.append("--release-small");
1249 try out.print(" --release-small");
1261 try out.print(" --release-small", .{});
12501262 },
12511263 }
12521264 const result = try ChildProcess.exec(allocator, test_args.toSliceConst(), null, &env_map, max_doc_file_size);
12531265 switch (result.term) {
12541266 .Exited => |exit_code| {
12551267 if (exit_code == 0) {
1256 warn("{}\nThe following command incorrectly succeeded:\n", result.stderr);
1268 warn("{}\nThe following command incorrectly succeeded:\n", .{result.stderr});
12571269 for (test_args.toSliceConst()) |arg|
1258 warn("{} ", arg)
1270 warn("{} ", .{arg})
12591271 else
1260 warn("\n");
1261 return parseError(tokenizer, code.source_token, "example incorrectly compiled");
1272 warn("\n", .{});
1273 return parseError(tokenizer, code.source_token, "example incorrectly compiled", .{});
12621274 }
12631275 },
12641276 else => {
1265 warn("{}\nThe following command crashed:\n", result.stderr);
1277 warn("{}\nThe following command crashed:\n", .{result.stderr});
12661278 for (test_args.toSliceConst()) |arg|
1267 warn("{} ", arg)
1279 warn("{} ", .{arg})
12681280 else
1269 warn("\n");
1270 return parseError(tokenizer, code.source_token, "example compile crashed");
1281 warn("\n", .{});
1282 return parseError(tokenizer, code.source_token, "example compile crashed", .{});
12711283 },
12721284 }
12731285 if (mem.indexOf(u8, result.stderr, error_match) == null) {
1274 warn("{}\nExpected to find '{}' in stderr", result.stderr, error_match);
1275 return parseError(tokenizer, code.source_token, "example did not have expected compile error");
1286 warn("{}\nExpected to find '{}' in stderr", .{ result.stderr, error_match });
1287 return parseError(tokenizer, code.source_token, "example did not have expected compile error", .{});
12761288 }
12771289 const escaped_stderr = try escapeHtml(allocator, result.stderr);
12781290 const colored_stderr = try termColor(allocator, escaped_stderr);
1279 try out.print("\n{}</code></pre>\n", colored_stderr);
1291 try out.print("\n{}</code></pre>\n", .{colored_stderr});
12801292 },
12811293
12821294 Code.Id.TestSafety => |error_match| {
......@@ -1311,38 +1323,37 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: var
13111323 switch (result.term) {
13121324 .Exited => |exit_code| {
13131325 if (exit_code == 0) {
1314 warn("{}\nThe following command incorrectly succeeded:\n", result.stderr);
1326 warn("{}\nThe following command incorrectly succeeded:\n", .{result.stderr});
13151327 for (test_args.toSliceConst()) |arg|
1316 warn("{} ", arg)
1328 warn("{} ", .{arg})
13171329 else
1318 warn("\n");
1319 return parseError(tokenizer, code.source_token, "example test incorrectly succeeded");
1330 warn("\n", .{});
1331 return parseError(tokenizer, code.source_token, "example test incorrectly succeeded", .{});
13201332 }
13211333 },
13221334 else => {
1323 warn("{}\nThe following command crashed:\n", result.stderr);
1335 warn("{}\nThe following command crashed:\n", .{result.stderr});
13241336 for (test_args.toSliceConst()) |arg|
1325 warn("{} ", arg)
1337 warn("{} ", .{arg})
13261338 else
1327 warn("\n");
1328 return parseError(tokenizer, code.source_token, "example compile crashed");
1339 warn("\n", .{});
1340 return parseError(tokenizer, code.source_token, "example compile crashed", .{});
13291341 },
13301342 }
13311343 if (mem.indexOf(u8, result.stderr, error_match) == null) {
1332 warn("{}\nExpected to find '{}' in stderr", result.stderr, error_match);
1333 return parseError(tokenizer, code.source_token, "example did not have expected runtime safety error message");
1344 warn("{}\nExpected to find '{}' in stderr", .{ result.stderr, error_match });
1345 return parseError(tokenizer, code.source_token, "example did not have expected runtime safety error message", .{});
13341346 }
13351347 const escaped_stderr = try escapeHtml(allocator, result.stderr);
13361348 const colored_stderr = try termColor(allocator, escaped_stderr);
1337 try out.print(
1338 "<pre><code class=\"shell\">$ zig test {}.zig{}\n{}</code></pre>\n",
1349 try out.print("<pre><code class=\"shell\">$ zig test {}.zig{}\n{}</code></pre>\n", .{
13391350 code.name,
13401351 mode_arg,
13411352 colored_stderr,
1342 );
1353 });
13431354 },
13441355 Code.Id.Obj => |maybe_error_match| {
1345 const name_plus_obj_ext = try std.fmt.allocPrint(allocator, "{}{}", code.name, obj_ext);
1356 const name_plus_obj_ext = try std.fmt.allocPrint(allocator, "{}{}", .{ code.name, obj_ext });
13461357 const tmp_obj_file_name = try fs.path.join(
13471358 allocator,
13481359 &[_][]const u8{ tmp_dir_name, name_plus_obj_ext },
......@@ -1350,7 +1361,7 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: var
13501361 var build_args = std.ArrayList([]const u8).init(allocator);
13511362 defer build_args.deinit();
13521363
1353 const name_plus_h_ext = try std.fmt.allocPrint(allocator, "{}.h", code.name);
1364 const name_plus_h_ext = try std.fmt.allocPrint(allocator, "{}.h", .{code.name});
13541365 const output_h_file_name = try fs.path.join(
13551366 allocator,
13561367 &[_][]const u8{ tmp_dir_name, name_plus_h_ext },
......@@ -1369,7 +1380,7 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: var
13691380 });
13701381
13711382 if (!code.is_inline) {
1372 try out.print("<pre><code class=\"shell\">$ zig build-obj {}.zig", code.name);
1383 try out.print("<pre><code class=\"shell\">$ zig build-obj {}.zig", .{code.name});
13731384 }
13741385
13751386 switch (code.mode) {
......@@ -1377,26 +1388,26 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: var
13771388 builtin.Mode.ReleaseSafe => {
13781389 try build_args.append("--release-safe");
13791390 if (!code.is_inline) {
1380 try out.print(" --release-safe");
1391 try out.print(" --release-safe", .{});
13811392 }
13821393 },
13831394 builtin.Mode.ReleaseFast => {
13841395 try build_args.append("--release-fast");
13851396 if (!code.is_inline) {
1386 try out.print(" --release-fast");
1397 try out.print(" --release-fast", .{});
13871398 }
13881399 },
13891400 builtin.Mode.ReleaseSmall => {
13901401 try build_args.append("--release-small");
13911402 if (!code.is_inline) {
1392 try out.print(" --release-small");
1403 try out.print(" --release-small", .{});
13931404 }
13941405 },
13951406 }
13961407
13971408 if (code.target_str) |triple| {
13981409 try build_args.appendSlice(&[_][]const u8{ "-target", triple });
1399 try out.print(" -target {}", triple);
1410 try out.print(" -target {}", .{triple});
14001411 }
14011412
14021413 if (maybe_error_match) |error_match| {
......@@ -1404,35 +1415,35 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: var
14041415 switch (result.term) {
14051416 .Exited => |exit_code| {
14061417 if (exit_code == 0) {
1407 warn("{}\nThe following command incorrectly succeeded:\n", result.stderr);
1418 warn("{}\nThe following command incorrectly succeeded:\n", .{result.stderr});
14081419 for (build_args.toSliceConst()) |arg|
1409 warn("{} ", arg)
1420 warn("{} ", .{arg})
14101421 else
1411 warn("\n");
1412 return parseError(tokenizer, code.source_token, "example build incorrectly succeeded");
1422 warn("\n", .{});
1423 return parseError(tokenizer, code.source_token, "example build incorrectly succeeded", .{});
14131424 }
14141425 },
14151426 else => {
1416 warn("{}\nThe following command crashed:\n", result.stderr);
1427 warn("{}\nThe following command crashed:\n", .{result.stderr});
14171428 for (build_args.toSliceConst()) |arg|
1418 warn("{} ", arg)
1429 warn("{} ", .{arg})
14191430 else
1420 warn("\n");
1421 return parseError(tokenizer, code.source_token, "example compile crashed");
1431 warn("\n", .{});
1432 return parseError(tokenizer, code.source_token, "example compile crashed", .{});
14221433 },
14231434 }
14241435 if (mem.indexOf(u8, result.stderr, error_match) == null) {
1425 warn("{}\nExpected to find '{}' in stderr", result.stderr, error_match);
1426 return parseError(tokenizer, code.source_token, "example did not have expected compile error message");
1436 warn("{}\nExpected to find '{}' in stderr", .{ result.stderr, error_match });
1437 return parseError(tokenizer, code.source_token, "example did not have expected compile error message", .{});
14271438 }
14281439 const escaped_stderr = try escapeHtml(allocator, result.stderr);
14291440 const colored_stderr = try termColor(allocator, escaped_stderr);
1430 try out.print("\n{}", colored_stderr);
1441 try out.print("\n{}", .{colored_stderr});
14311442 } else {
1432 _ = exec(allocator, &env_map, build_args.toSliceConst()) catch return parseError(tokenizer, code.source_token, "example failed to compile");
1443 _ = exec(allocator, &env_map, build_args.toSliceConst()) catch return parseError(tokenizer, code.source_token, "example failed to compile", .{});
14331444 }
14341445 if (!code.is_inline) {
1435 try out.print("</code></pre>\n");
1446 try out.print("</code></pre>\n", .{});
14361447 }
14371448 },
14381449 Code.Id.Lib => {
......@@ -1446,33 +1457,33 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: var
14461457 "--output-dir",
14471458 tmp_dir_name,
14481459 });
1449 try out.print("<pre><code class=\"shell\">$ zig build-lib {}.zig", code.name);
1460 try out.print("<pre><code class=\"shell\">$ zig build-lib {}.zig", .{code.name});
14501461 switch (code.mode) {
14511462 builtin.Mode.Debug => {},
14521463 builtin.Mode.ReleaseSafe => {
14531464 try test_args.append("--release-safe");
1454 try out.print(" --release-safe");
1465 try out.print(" --release-safe", .{});
14551466 },
14561467 builtin.Mode.ReleaseFast => {
14571468 try test_args.append("--release-fast");
1458 try out.print(" --release-fast");
1469 try out.print(" --release-fast", .{});
14591470 },
14601471 builtin.Mode.ReleaseSmall => {
14611472 try test_args.append("--release-small");
1462 try out.print(" --release-small");
1473 try out.print(" --release-small", .{});
14631474 },
14641475 }
14651476 if (code.target_str) |triple| {
14661477 try test_args.appendSlice(&[_][]const u8{ "-target", triple });
1467 try out.print(" -target {}", triple);
1478 try out.print(" -target {}", .{triple});
14681479 }
1469 const result = exec(allocator, &env_map, test_args.toSliceConst()) catch return parseError(tokenizer, code.source_token, "test failed");
1480 const result = exec(allocator, &env_map, test_args.toSliceConst()) catch return parseError(tokenizer, code.source_token, "test failed", .{});
14701481 const escaped_stderr = try escapeHtml(allocator, result.stderr);
14711482 const escaped_stdout = try escapeHtml(allocator, result.stdout);
1472 try out.print("\n{}{}</code></pre>\n", escaped_stderr, escaped_stdout);
1483 try out.print("\n{}{}</code></pre>\n", .{ escaped_stderr, escaped_stdout });
14731484 },
14741485 }
1475 warn("OK\n");
1486 warn("OK\n", .{});
14761487 },
14771488 }
14781489 }
......@@ -1483,20 +1494,20 @@ fn exec(allocator: *mem.Allocator, env_map: *std.BufMap, args: []const []const u
14831494 switch (result.term) {
14841495 .Exited => |exit_code| {
14851496 if (exit_code != 0) {
1486 warn("{}\nThe following command exited with code {}:\n", result.stderr, exit_code);
1497 warn("{}\nThe following command exited with code {}:\n", .{ result.stderr, exit_code });
14871498 for (args) |arg|
1488 warn("{} ", arg)
1499 warn("{} ", .{arg})
14891500 else
1490 warn("\n");
1501 warn("\n", .{});
14911502 return error.ChildExitError;
14921503 }
14931504 },
14941505 else => {
1495 warn("{}\nThe following command crashed:\n", result.stderr);
1506 warn("{}\nThe following command crashed:\n", .{result.stderr});
14961507 for (args) |arg|
1497 warn("{} ", arg)
1508 warn("{} ", .{arg})
14981509 else
1499 warn("\n");
1510 warn("\n", .{});
15001511 return error.ChildCrashed;
15011512 },
15021513 }