authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2018-09-14 10:35:03-04:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2018-09-14 10:35:03-04:00
log5e39328542094043bc7b34787ced45dbffe3abee
tree3440e35c30d8c6095282f98a337b0736a2b6e8a4
parent3d38feded93cb2ccecf5ecb538c8957a965a891e
signaturelock-open Commit is signed but in an unrecognized format.

docs: more syntax highlighting

2 files changed, 687 insertions(+), 660 deletions(-)

doc/docgen.zig+29-5
...@@ -300,6 +300,7 @@ const Node = union(enum) {...@@ -300,6 +300,7 @@ const Node = union(enum) {
300 SeeAlso: []const SeeAlsoItem,300 SeeAlso: []const SeeAlsoItem,
301 Code: Code,301 Code: Code,
302 Link: Link,302 Link: Link,
303 Syntax: Token,
303};304};
304305
305const Toc = struct {306const Toc = struct {
...@@ -530,6 +531,17 @@ fn genToc(allocator: *mem.Allocator, tokenizer: *Tokenizer) !Toc {...@@ -530,6 +531,17 @@ fn genToc(allocator: *mem.Allocator, tokenizer: *Tokenizer) !Toc {
530 },531 },
531 });532 });
532 tokenizer.code_node_count += 1;533 tokenizer.code_node_count += 1;
534 } else if (mem.eql(u8, tag_name, "syntax")) {
535 _ = try eatToken(tokenizer, Token.Id.BracketClose);
536 const content_tok = try eatToken(tokenizer, Token.Id.Content);
537 _ = try eatToken(tokenizer, Token.Id.BracketOpen);
538 const end_syntax_tag = try eatToken(tokenizer, Token.Id.TagContent);
539 const end_tag_name = tokenizer.buffer[end_syntax_tag.start..end_syntax_tag.end];
540 if (!mem.eql(u8, end_tag_name, "endsyntax")) {
541 return parseError(tokenizer, end_syntax_tag, "invalid token inside syntax: {}", end_tag_name);
542 }
543 _ = try eatToken(tokenizer, Token.Id.BracketClose);
544 try nodes.append(Node{ .Syntax = content_tok });
533 } else {545 } else {
534 return parseError(tokenizer, tag_token, "unrecognized tag name: {}", tag_name);546 return parseError(tokenizer, tag_token, "unrecognized tag name: {}", tag_name);
535 }547 }
...@@ -706,8 +718,10 @@ fn isType(name: []const u8) bool {...@@ -706,8 +718,10 @@ fn isType(name: []const u8) bool {
706 return false;718 return false;
707}719}
708720
709fn tokenizeAndPrint(allocator: *mem.Allocator, out: var, src: []const u8) !void {721fn tokenizeAndPrint(allocator: *mem.Allocator, docgen_tokenizer: *Tokenizer, out: var, source_token: Token) !void {
710 try out.write("<pre><code class=\"zig\">");722 const raw_src = docgen_tokenizer.buffer[source_token.start..source_token.end];
723 const src = mem.trim(u8, raw_src, " \n");
724 try out.write("<code class=\"zig\">");
711 var tokenizer = std.zig.Tokenizer.init(src);725 var tokenizer = std.zig.Tokenizer.init(src);
712 var index: usize = 0;726 var index: usize = 0;
713 var next_tok_is_fn = false;727 var next_tok_is_fn = false;
...@@ -900,12 +914,17 @@ fn tokenizeAndPrint(allocator: *mem.Allocator, out: var, src: []const u8) !void...@@ -900,12 +914,17 @@ fn tokenizeAndPrint(allocator: *mem.Allocator, out: var, src: []const u8) !void
900 std.zig.Token.Id.AngleBracketAngleBracketRightEqual,914 std.zig.Token.Id.AngleBracketAngleBracketRightEqual,
901 std.zig.Token.Id.Tilde,915 std.zig.Token.Id.Tilde,
902 std.zig.Token.Id.BracketStarBracket,916 std.zig.Token.Id.BracketStarBracket,
903 std.zig.Token.Id.Invalid,
904 => try writeEscaped(out, src[token.start..token.end]),917 => try writeEscaped(out, src[token.start..token.end]),
918
919 std.zig.Token.Id.Invalid => return parseError(
920 docgen_tokenizer,
921 source_token,
922 "syntax error",
923 ),
905 }924 }
906 index = token.end;925 index = token.end;
907 }926 }
908 try out.write("</code></pre>");927 try out.write("</code>");
909}928}
910929
911fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: var, zig_exe: []const u8) !void {930fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: var, zig_exe: []const u8) !void {
...@@ -947,6 +966,9 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: var...@@ -947,6 +966,9 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: var
947 }966 }
948 try out.write("</ul>\n");967 try out.write("</ul>\n");
949 },968 },
969 Node.Syntax => |content_tok| {
970 try tokenizeAndPrint(allocator, tokenizer, out, content_tok);
971 },
950 Node.Code => |code| {972 Node.Code => |code| {
951 code_progress_index += 1;973 code_progress_index += 1;
952 warn("docgen example code {}/{}...", code_progress_index, tokenizer.code_node_count);974 warn("docgen example code {}/{}...", code_progress_index, tokenizer.code_node_count);
...@@ -956,7 +978,9 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: var...@@ -956,7 +978,9 @@ fn genHtml(allocator: *mem.Allocator, tokenizer: *Tokenizer, toc: *Toc, out: var
956 if (!code.is_inline) {978 if (!code.is_inline) {
957 try out.print("<p class=\"file\">{}.zig</p>", code.name);979 try out.print("<p class=\"file\">{}.zig</p>", code.name);
958 }980 }
959 try tokenizeAndPrint(allocator, out, trimmed_raw_source);981 try out.write("<pre>");
982 try tokenizeAndPrint(allocator, tokenizer, out, code.source_token);
983 try out.write("</pre>");
960 const name_plus_ext = try std.fmt.allocPrint(allocator, "{}.zig", code.name);984 const name_plus_ext = try std.fmt.allocPrint(allocator, "{}.zig", code.name);
961 const tmp_source_file_name = try os.path.join(allocator, tmp_dir_name, name_plus_ext);985 const tmp_source_file_name = try os.path.join(allocator, tmp_dir_name, name_plus_ext);
962 try io.writeFile(tmp_source_file_name, trimmed_raw_source);986 try io.writeFile(tmp_source_file_name, trimmed_raw_source);
doc/langref.html.in+658-655
...@@ -161,8 +161,8 @@ pub fn main() void {...@@ -161,8 +161,8 @@ pub fn main() void {
161}161}
162 {#code_end#}162 {#code_end#}
163 <p>163 <p>
164 Note that we also left off the <code class="zig">!</code> from the return type.164 Note that we also left off the {#syntax#}!{#endsyntax#} from the return type.
165 In Zig, if your main function cannot fail, you must use the <code class="zig">void</code> return type.165 In Zig, if your main function cannot fail, you must use the {#syntax#}void{#endsyntax#} return type.
166 </p>166 </p>
167 {#see_also|Values|@import|Errors|Root Source File#}167 {#see_also|Values|@import|Errors|Root Source File#}
168 {#header_close#}168 {#header_close#}
...@@ -181,14 +181,14 @@ test "comments" {...@@ -181,14 +181,14 @@ test "comments" {
181}181}
182 {#code_end#}182 {#code_end#}
183 <p>183 <p>
184 There are no multiline comments in Zig (e.g. like <code>/* */</code>184 There are no multiline comments in Zig (e.g. like <code class="c">/* */</code>
185 comments in C). This helps allow Zig to have the property that each line185 comments in C). This helps allow Zig to have the property that each line
186 of code can be tokenized out of context.186 of code can be tokenized out of context.
187 </p>187 </p>
188 {#header_open|Doc comments#}188 {#header_open|Doc comments#}
189 <p>189 <p>
190 A doc comment is one that begins with exactly three slashes (i.e.190 A doc comment is one that begins with exactly three slashes (i.e.
191 <code class="zig">///</code> but not <code class="zig">////</code>);191 {#syntax#}///{#endsyntax#} but not {#syntax#}////{#endsyntax#});
192 multiple doc comments in a row are merged together to form a multiline192 multiple doc comments in a row are merged together to form a multiline
193 doc comment. The doc comment documents whatever immediately follows it.193 doc comment. The doc comment documents whatever immediately follows it.
194 </p>194 </p>
...@@ -280,169 +280,169 @@ pub fn main() void {...@@ -280,169 +280,169 @@ pub fn main() void {
280 </th>280 </th>
281 </tr>281 </tr>
282 <tr>282 <tr>
283 <td><code>i8</code></td>283 <td>{#syntax#}i8{#endsyntax#}</td>
284 <td><code>int8_t</code></td>284 <td><code class="c">int8_t</code></td>
285 <td>signed 8-bit integer</td>285 <td>signed 8-bit integer</td>
286 </tr>286 </tr>
287 <tr>287 <tr>
288 <td><code>u8</code></td>288 <td>{#syntax#}u8{#endsyntax#}</td>
289 <td><code>uint8_t</code></td>289 <td><code class="c">uint8_t</code></td>
290 <td>unsigned 8-bit integer</td>290 <td>unsigned 8-bit integer</td>
291 </tr>291 </tr>
292 <tr>292 <tr>
293 <td><code>i16</code></td>293 <td>{#syntax#}i16{#endsyntax#}</td>
294 <td><code>int16_t</code></td>294 <td><code class="c">int16_t</code></td>
295 <td>signed 16-bit integer</td>295 <td>signed 16-bit integer</td>
296 </tr>296 </tr>
297 <tr>297 <tr>
298 <td><code>u16</code></td>298 <td>{#syntax#}u16{#endsyntax#}</td>
299 <td><code>uint16_t</code></td>299 <td><code class="c">uint16_t</code></td>
300 <td>unsigned 16-bit integer</td>300 <td>unsigned 16-bit integer</td>
301 </tr>301 </tr>
302 <tr>302 <tr>
303 <td><code>i32</code></td>303 <td>{#syntax#}i32{#endsyntax#}</td>
304 <td><code>int32_t</code></td>304 <td><code class="c">int32_t</code></td>
305 <td>signed 32-bit integer</td>305 <td>signed 32-bit integer</td>
306 </tr>306 </tr>
307 <tr>307 <tr>
308 <td><code>u32</code></td>308 <td>{#syntax#}u32{#endsyntax#}</td>
309 <td><code>uint32_t</code></td>309 <td><code class="c">uint32_t</code></td>
310 <td>unsigned 32-bit integer</td>310 <td>unsigned 32-bit integer</td>
311 </tr>311 </tr>
312 <tr>312 <tr>
313 <td><code>i64</code></td>313 <td>{#syntax#}i64{#endsyntax#}</td>
314 <td><code>int64_t</code></td>314 <td><code class="c">int64_t</code></td>
315 <td>signed 64-bit integer</td>315 <td>signed 64-bit integer</td>
316 </tr>316 </tr>
317 <tr>317 <tr>
318 <td><code>u64</code></td>318 <td>{#syntax#}u64{#endsyntax#}</td>
319 <td><code>uint64_t</code></td>319 <td><code class="c">uint64_t</code></td>
320 <td>unsigned 64-bit integer</td>320 <td>unsigned 64-bit integer</td>
321 </tr>321 </tr>
322 <tr>322 <tr>
323 <td><code>i128</code></td>323 <td>{#syntax#}i128{#endsyntax#}</td>
324 <td><code>__int128</code></td>324 <td><code class="c">__int128</code></td>
325 <td>signed 128-bit integer</td>325 <td>signed 128-bit integer</td>
326 </tr>326 </tr>
327 <tr>327 <tr>
328 <td><code>u128</code></td>328 <td>{#syntax#}u128{#endsyntax#}</td>
329 <td><code>unsigned __int128</code></td>329 <td><code class="c">unsigned __int128</code></td>
330 <td>unsigned 128-bit integer</td>330 <td>unsigned 128-bit integer</td>
331 </tr>331 </tr>
332 <tr>332 <tr>
333 <td><code>isize</code></td>333 <td>{#syntax#}isize{#endsyntax#}</td>
334 <td><code>intptr_t</code></td>334 <td><code class="c">intptr_t</code></td>
335 <td>signed pointer sized integer</td>335 <td>signed pointer sized integer</td>
336 </tr>336 </tr>
337 <tr>337 <tr>
338 <td><code>usize</code></td>338 <td>{#syntax#}usize{#endsyntax#}</td>
339 <td><code>uintptr_t</code></td>339 <td><code class="c">uintptr_t</code></td>
340 <td>unsigned pointer sized integer</td>340 <td>unsigned pointer sized integer</td>
341 </tr>341 </tr>
342342
343 <tr>343 <tr>
344 <td><code>c_short</code></td>344 <td>{#syntax#}c_short{#endsyntax#}</td>
345 <td><code>short</code></td>345 <td><code class="c">short</code></td>
346 <td>for ABI compatibility with C</td>346 <td>for ABI compatibility with C</td>
347 </tr>347 </tr>
348 <tr>348 <tr>
349 <td><code>c_ushort</code></td>349 <td>{#syntax#}c_ushort{#endsyntax#}</td>
350 <td><code>unsigned short</code></td>350 <td><code class="c">unsigned short</code></td>
351 <td>for ABI compatibility with C</td>351 <td>for ABI compatibility with C</td>
352 </tr>352 </tr>
353 <tr>353 <tr>
354 <td><code>c_int</code></td>354 <td>{#syntax#}c_int{#endsyntax#}</td>
355 <td><code>int</code></td>355 <td><code class="c">int</code></td>
356 <td>for ABI compatibility with C</td>356 <td>for ABI compatibility with C</td>
357 </tr>357 </tr>
358 <tr>358 <tr>
359 <td><code>c_uint</code></td>359 <td>{#syntax#}c_uint{#endsyntax#}</td>
360 <td><code>unsigned int</code></td>360 <td><code class="c">unsigned int</code></td>
361 <td>for ABI compatibility with C</td>361 <td>for ABI compatibility with C</td>
362 </tr>362 </tr>
363 <tr>363 <tr>
364 <td><code>c_long</code></td>364 <td>{#syntax#}c_long{#endsyntax#}</td>
365 <td><code>long</code></td>365 <td><code class="c">long</code></td>
366 <td>for ABI compatibility with C</td>366 <td>for ABI compatibility with C</td>
367 </tr>367 </tr>
368 <tr>368 <tr>
369 <td><code>c_ulong</code></td>369 <td>{#syntax#}c_ulong{#endsyntax#}</td>
370 <td><code>unsigned long</code></td>370 <td><code class="c">unsigned long</code></td>
371 <td>for ABI compatibility with C</td>371 <td>for ABI compatibility with C</td>
372 </tr>372 </tr>
373 <tr>373 <tr>
374 <td><code>c_longlong</code></td>374 <td>{#syntax#}c_longlong{#endsyntax#}</td>
375 <td><code>long long</code></td>375 <td><code class="c">long long</code></td>
376 <td>for ABI compatibility with C</td>376 <td>for ABI compatibility with C</td>
377 </tr>377 </tr>
378 <tr>378 <tr>
379 <td><code>c_ulonglong</code></td>379 <td>{#syntax#}c_ulonglong{#endsyntax#}</td>
380 <td><code>unsigned long long</code></td>380 <td><code class="c">unsigned long long</code></td>
381 <td>for ABI compatibility with C</td>381 <td>for ABI compatibility with C</td>
382 </tr>382 </tr>
383 <tr>383 <tr>
384 <td><code>c_longdouble</code></td>384 <td>{#syntax#}c_longdouble{#endsyntax#}</td>
385 <td><code>long double</code></td>385 <td><code class="c">long double</code></td>
386 <td>for ABI compatibility with C</td>386 <td>for ABI compatibility with C</td>
387 </tr>387 </tr>
388 <tr>388 <tr>
389 <td><code>c_void</code></td>389 <td>{#syntax#}c_void{#endsyntax#}</td>
390 <td><code>void</code></td>390 <td><code class="c">void</code></td>
391 <td>for ABI compatibility with C</td>391 <td>for ABI compatibility with C</td>
392 </tr>392 </tr>
393393
394 <tr>394 <tr>
395 <td><code>f16</code></td>395 <td>{#syntax#}f16{#endsyntax#}</td>
396 <td><code>float</code></td>396 <td><code class="c">float</code></td>
397 <td>16-bit floating point (10-bit mantissa) IEEE-754-2008 binary16</td>397 <td>16-bit floating point (10-bit mantissa) IEEE-754-2008 binary16</td>
398 </tr>398 </tr>
399 <tr>399 <tr>
400 <td><code>f32</code></td>400 <td>{#syntax#}f32{#endsyntax#}</td>
401 <td><code>float</code></td>401 <td><code class="c">float</code></td>
402 <td>32-bit floating point (23-bit mantissa) IEEE-754-2008 binary32</td>402 <td>32-bit floating point (23-bit mantissa) IEEE-754-2008 binary32</td>
403 </tr>403 </tr>
404 <tr>404 <tr>
405 <td><code>f64</code></td>405 <td>{#syntax#}f64{#endsyntax#}</td>
406 <td><code>double</code></td>406 <td><code class="c">double</code></td>
407 <td>64-bit floating point (52-bit mantissa) IEEE-754-2008 binary64</td>407 <td>64-bit floating point (52-bit mantissa) IEEE-754-2008 binary64</td>
408 </tr>408 </tr>
409 <tr>409 <tr>
410 <td><code>f128</code></td>410 <td>{#syntax#}f128{#endsyntax#}</td>
411 <td>(none)</td>411 <td>(none)</td>
412 <td>128-bit floating point (112-bit mantissa) IEEE-754-2008 binary128</td>412 <td>128-bit floating point (112-bit mantissa) IEEE-754-2008 binary128</td>
413 </tr>413 </tr>
414 <tr>414 <tr>
415 <td><code>bool</code></td>415 <td>{#syntax#}bool{#endsyntax#}</td>
416 <td><code>bool</code></td>416 <td><code class="c">bool</code></td>
417 <td><code>true</code> or <code>false</code></td>417 <td>{#syntax#}true{#endsyntax#} or {#syntax#}false{#endsyntax#}</td>
418 </tr>418 </tr>
419 <tr>419 <tr>
420 <td><code>void</code></td>420 <td>{#syntax#}void{#endsyntax#}</td>
421 <td>(none)</td>421 <td>(none)</td>
422 <td>0 bit type</td>422 <td>0 bit type</td>
423 </tr>423 </tr>
424 <tr>424 <tr>
425 <td><code>noreturn</code></td>425 <td>{#syntax#}noreturn{#endsyntax#}</td>
426 <td>(none)</td>426 <td>(none)</td>
427 <td>the type of <code>break</code>, <code>continue</code>, <code>return</code>, <code>unreachable</code>, and <code>while (true) {}</code></td>427 <td>the type of {#syntax#}break{#endsyntax#}, {#syntax#}continue{#endsyntax#}, {#syntax#}return{#endsyntax#}, {#syntax#}unreachable{#endsyntax#}, and {#syntax#}while (true) {}{#endsyntax#}</td>
428 </tr>428 </tr>
429 <tr>429 <tr>
430 <td><code>type</code></td>430 <td>{#syntax#}type{#endsyntax#}</td>
431 <td>(none)</td>431 <td>(none)</td>
432 <td>the type of types</td>432 <td>the type of types</td>
433 </tr>433 </tr>
434 <tr>434 <tr>
435 <td><code>error</code></td>435 <td>{#syntax#}error{#endsyntax#}</td>
436 <td>(none)</td>436 <td>(none)</td>
437 <td>an error code</td>437 <td>an error code</td>
438 </tr>438 </tr>
439 <tr>439 <tr>
440 <td><code>comptime_int</code></td>440 <td>{#syntax#}comptime_int{#endsyntax#}</td>
441 <td>(none)</td>441 <td>(none)</td>
442 <td>Only allowed for {#link|comptime#}-known values. The type of integer literals.</td>442 <td>Only allowed for {#link|comptime#}-known values. The type of integer literals.</td>
443 </tr>443 </tr>
444 <tr>444 <tr>
445 <td><code>comptime_float</code></td>445 <td>{#syntax#}comptime_float{#endsyntax#}</td>
446 <td>(none)</td>446 <td>(none)</td>
447 <td>Only allowed for {#link|comptime#}-known values. The type of float literals.</td>447 <td>Only allowed for {#link|comptime#}-known values. The type of float literals.</td>
448 </tr>448 </tr>
...@@ -451,7 +451,7 @@ pub fn main() void {...@@ -451,7 +451,7 @@ pub fn main() void {
451 <p>451 <p>
452 In addition to the integer types above, arbitrary bit-width integers can be referenced by using452 In addition to the integer types above, arbitrary bit-width integers can be referenced by using
453 an identifier of <code>i</code> or </code>u</code> followed by digits. For example, the identifier453 an identifier of <code>i</code> or </code>u</code> followed by digits. For example, the identifier
454 <code>i7</code> refers to a signed 7-bit integer.454 {#syntax#}i7{#endsyntax#} refers to a signed 7-bit integer.
455 </p>455 </p>
456 {#see_also|Integers|Floats|void|Errors#}456 {#see_also|Integers|Floats|void|Errors#}
457 {#header_close#}457 {#header_close#}
...@@ -467,15 +467,15 @@ pub fn main() void {...@@ -467,15 +467,15 @@ pub fn main() void {
467 </th>467 </th>
468 </tr>468 </tr>
469 <tr>469 <tr>
470 <td><code>true</code> and <code>false</code></td>470 <td>{#syntax#}true{#endsyntax#} and {#syntax#}false{#endsyntax#}</td>
471 <td><code>bool</code> values</td>471 <td>{#syntax#}bool{#endsyntax#} values</td>
472 </tr>472 </tr>
473 <tr>473 <tr>
474 <td><code>null</code></td>474 <td>{#syntax#}null{#endsyntax#}</td>
475 <td>used to set an optional type to <code>null</code></td>475 <td>used to set an optional type to {#syntax#}null{#endsyntax#}</td>
476 </tr>476 </tr>
477 <tr>477 <tr>
478 <td><code>undefined</code></td>478 <td>{#syntax#}undefined{#endsyntax#}</td>
479 <td>used to leave a value unspecified</td>479 <td>used to leave a value unspecified</td>
480 </tr>480 </tr>
481 </table>481 </table>
...@@ -515,52 +515,52 @@ test "string literals" {...@@ -515,52 +515,52 @@ test "string literals" {
515 </th>515 </th>
516 </tr>516 </tr>
517 <tr>517 <tr>
518 <td><code>\n</code></td>518 <td><code>\n</code></td>
519 <td>Newline</td>519 <td>Newline</td>
520 </tr>520 </tr>
521 <tr>521 <tr>
522 <td><code>\r</code></td>522 <td><code>\r</code></td>
523 <td>Carriage Return</td>523 <td>Carriage Return</td>
524 </tr>524 </tr>
525 <tr>525 <tr>
526 <td><code>\t</code></td>526 <td><code>\t</code></td>
527 <td>Tab</td>527 <td>Tab</td>
528 </tr>528 </tr>
529 <tr>529 <tr>
530 <td><code>\\</code></td>530 <td><code>\\</code></td>
531 <td>Backslash</td>531 <td>Backslash</td>
532 </tr>532 </tr>
533 <tr>533 <tr>
534 <td><code>\'</code></td>534 <td><code>\'</code></td>
535 <td>Single Quote</td>535 <td>Single Quote</td>
536 </tr>536 </tr>
537 <tr>537 <tr>
538 <td><code>\"</code></td>538 <td><code>\"</code></td>
539 <td>Double Quote</td>539 <td>Double Quote</td>
540 </tr>540 </tr>
541 <tr>541 <tr>
542 <td><code>\xNN</code></td>542 <td><code>\xNN</code></td>
543 <td>hexadecimal 8-bit character code (2 digits)</td>543 <td>hexadecimal 8-bit character code (2 digits)</td>
544 </tr>544 </tr>
545 <tr>545 <tr>
546 <td><code>\uNNNN</code></td>546 <td><code>\uNNNN</code></td>
547 <td>hexadecimal 16-bit Unicode character code UTF-8 encoded (4 digits)</td>547 <td>hexadecimal 16-bit Unicode character code UTF-8 encoded (4 digits)</td>
548 </tr>548 </tr>
549 <tr>549 <tr>
550 <td><code>\UNNNNNN</code></td>550 <td><code>\UNNNNNN</code></td>
551 <td>hexadecimal 24-bit Unicode character code UTF-8 encoded (6 digits)</td>551 <td>hexadecimal 24-bit Unicode character code UTF-8 encoded (6 digits)</td>
552 </tr>552 </tr>
553 </table>553 </table>
554 </div>554 </div>
555 <p>Note that the maximum valid Unicode point is <code>0x10ffff</code>.</p>555 <p>Note that the maximum valid Unicode point is {#syntax#}0x10ffff{#endsyntax#}.</p>
556 {#header_close#}556 {#header_close#}
557 {#header_open|Multiline String Literals#}557 {#header_open|Multiline String Literals#}
558 <p>558 <p>
559 Multiline string literals have no escapes and can span across multiple lines.559 Multiline string literals have no escapes and can span across multiple lines.
560 To start a multiline string literal, use the <code>\\</code> token. Just like a comment,560 To start a multiline string literal, use the {#syntax#}\\{#endsyntax#} token. Just like a comment,
561 the string literal goes until the end of the line. The end of the line is561 the string literal goes until the end of the line. The end of the line is
562 not included in the string literal.562 not included in the string literal.
563 However, if the next line begins with <code>\\</code> then a newline is appended and563 However, if the next line begins with {#syntax#}\\{#endsyntax#} then a newline is appended and
564 the string literal continues.564 the string literal continues.
565 </p>565 </p>
566 {#code_begin|syntax#}566 {#code_begin|syntax#}
...@@ -574,7 +574,7 @@ const hello_world_in_c =...@@ -574,7 +574,7 @@ const hello_world_in_c =
574;574;
575 {#code_end#}575 {#code_end#}
576 <p>576 <p>
577 For a multiline C string literal, prepend <code>c</code> to each <code>\\</code>:577 For a multiline C string literal, prepend <code>c</code> to each {#syntax#}\\{#endsyntax#}:
578 </p>578 </p>
579 {#code_begin|syntax#}579 {#code_begin|syntax#}
580const c_string_literal =580const c_string_literal =
...@@ -587,14 +587,14 @@ const c_string_literal =...@@ -587,14 +587,14 @@ const c_string_literal =
587;587;
588 {#code_end#}588 {#code_end#}
589 <p>589 <p>
590 In this example the variable <code>c_string_literal</code> has type <code>[*]const char</code> and590 In this example the variable {#syntax#}c_string_literal{#endsyntax#} has type {#syntax#}[*]const char{#endsyntax#} and
591 has a terminating null byte.591 has a terminating null byte.
592 </p>592 </p>
593 {#see_also|@embedFile#}593 {#see_also|@embedFile#}
594 {#header_close#}594 {#header_close#}
595 {#header_close#}595 {#header_close#}
596 {#header_open|Assignment#}596 {#header_open|Assignment#}
597 <p>Use the <code>const</code> keyword to assign a value to an identifier:</p>597 <p>Use the {#syntax#}const{#endsyntax#} keyword to assign a value to an identifier:</p>
598 {#code_begin|test_err|cannot assign to constant#}598 {#code_begin|test_err|cannot assign to constant#}
599const x = 1234;599const x = 1234;
600600
...@@ -610,8 +610,8 @@ test "assignment" {...@@ -610,8 +610,8 @@ test "assignment" {
610 foo();610 foo();
611}611}
612 {#code_end#}612 {#code_end#}
613 <p><code>const</code> applies to all of the bytes that the identifier immediately addresses. {#link|Pointers#} have their own const-ness.</p>613 <p>{#syntax#}const{#endsyntax#} applies to all of the bytes that the identifier immediately addresses. {#link|Pointers#} have their own const-ness.</p>
614 <p>If you need a variable that you can modify, use the <code>var</code> keyword:</p>614 <p>If you need a variable that you can modify, use the {#syntax#}var{#endsyntax#} keyword:</p>
615 {#code_begin|test#}615 {#code_begin|test#}
616const assert = @import("std").debug.assert;616const assert = @import("std").debug.assert;
617617
...@@ -632,7 +632,7 @@ test "initialization" {...@@ -632,7 +632,7 @@ test "initialization" {
632}632}
633 {#code_end#}633 {#code_end#}
634 {#header_open|undefined#}634 {#header_open|undefined#}
635 <p>Use <code>undefined</code> to leave variables uninitialized:</p>635 <p>Use {#syntax#}undefined{#endsyntax#} to leave variables uninitialized:</p>
636 {#code_begin|test#}636 {#code_begin|test#}
637const assert = @import("std").debug.assert;637const assert = @import("std").debug.assert;
638638
...@@ -643,14 +643,14 @@ test "init with undefined" {...@@ -643,14 +643,14 @@ test "init with undefined" {
643}643}
644 {#code_end#}644 {#code_end#}
645 <p>645 <p>
646 <code>undefined</code> can be {#link|implicitly cast|Implicit Casts#} to any type.646 {#syntax#}undefined{#endsyntax#} can be {#link|implicitly cast|Implicit Casts#} to any type.
647 Once this happens, it is no longer possible to detect that the value is <code>undefined</code>.647 Once this happens, it is no longer possible to detect that the value is {#syntax#}undefined{#endsyntax#}.
648 <code>undefined</code> means the value could be anything, even something that is nonsense648 {#syntax#}undefined{#endsyntax#} means the value could be anything, even something that is nonsense
649 according to the type. Translated into English, <code>undefined</code> means "Not a meaningful649 according to the type. Translated into English, {#syntax#}undefined{#endsyntax#} means "Not a meaningful
650 value. Using this value would be a bug. The value will be unused, or overwritten before being used."650 value. Using this value would be a bug. The value will be unused, or overwritten before being used."
651 </p>651 </p>
652 <p>652 <p>
653 In {#link|Debug#} mode, Zig writes <code>0xaa</code> bytes to undefined memory. This is to catch653 In {#link|Debug#} mode, Zig writes {#syntax#}0xaa{#endsyntax#} bytes to undefined memory. This is to catch
654 bugs early, and to help detect use of undefined memory in a debugger.654 bugs early, and to help detect use of undefined memory in a debugger.
655 </p>655 </p>
656 {#header_close#}656 {#header_close#}
...@@ -681,14 +681,14 @@ fn divide(a: i32, b: i32) i32 {...@@ -681,14 +681,14 @@ fn divide(a: i32, b: i32) i32 {
681}681}
682 {#code_end#}682 {#code_end#}
683 <p>683 <p>
684 In this function, values <code>a</code> and <code>b</code> are known only at runtime,684 In this function, values {#syntax#}a{#endsyntax#} and {#syntax#}b{#endsyntax#} are known only at runtime,
685 and thus this division operation is vulnerable to both integer overflow and685 and thus this division operation is vulnerable to both integer overflow and
686 division by zero.686 division by zero.
687 </p>687 </p>
688 <p>688 <p>
689 Operators such as <code>+</code> and <code>-</code> cause undefined behavior on689 Operators such as {#syntax#}+{#endsyntax#} and {#syntax#}-{#endsyntax#} cause undefined behavior on
690 integer overflow. Also available are operations such as <code>+%</code> and690 integer overflow. Also available are operations such as {#syntax#}+%{#endsyntax#} and
691 <code>-%</code> which are defined to have wrapping arithmetic on all targets.691 {#syntax#}-%{#endsyntax#} which are defined to have wrapping arithmetic on all targets.
692 </p>692 </p>
693 {#see_also|Integer Overflow|Division by Zero|Wrapping Operations#}693 {#see_also|Integer Overflow|Division by Zero|Wrapping Operations#}
694 {#header_close#}694 {#header_close#}
...@@ -696,15 +696,15 @@ fn divide(a: i32, b: i32) i32 {...@@ -696,15 +696,15 @@ fn divide(a: i32, b: i32) i32 {
696 {#header_open|Floats#}696 {#header_open|Floats#}
697 <p>Zig has the following floating point types:</p>697 <p>Zig has the following floating point types:</p>
698 <ul>698 <ul>
699 <li><code>f16</code> - IEEE-754-2008 binary16</li>699 <li>{#syntax#}f16{#endsyntax#} - IEEE-754-2008 binary16</li>
700 <li><code>f32</code> - IEEE-754-2008 binary32</li>700 <li>{#syntax#}f32{#endsyntax#} - IEEE-754-2008 binary32</li>
701 <li><code>f64</code> - IEEE-754-2008 binary64</li>701 <li>{#syntax#}f64{#endsyntax#} - IEEE-754-2008 binary64</li>
702 <li><code>f128</code> - IEEE-754-2008 binary128</li>702 <li>{#syntax#}f128{#endsyntax#} - IEEE-754-2008 binary128</li>
703 <li><code>c_longdouble</code> - matches <code>long double</code> for the target C ABI</li>703 <li>{#syntax#}c_longdouble{#endsyntax#} - matches <code class="c">long double</code> for the target C ABI</li>
704 </ul>704 </ul>
705 {#header_open|Float Literals#}705 {#header_open|Float Literals#}
706 <p>706 <p>
707 Float literals have type <code>comptime_float</code> which is guaranteed to hold at least all possible values707 Float literals have type {#syntax#}comptime_float{#endsyntax#} which is guaranteed to hold at least all possible values
708 that the largest other floating point type can hold. Float literals {#link|implicitly cast|Implicit Casts#} to any other type.708 that the largest other floating point type can hold. Float literals {#link|implicitly cast|Implicit Casts#} to any other type.
709 </p>709 </p>
710 {#code_begin|syntax#}710 {#code_begin|syntax#}
...@@ -718,8 +718,8 @@ const yet_another_hex_float = 0x103.70P-5;...@@ -718,8 +718,8 @@ const yet_another_hex_float = 0x103.70P-5;
718 {#code_end#}718 {#code_end#}
719 {#header_close#}719 {#header_close#}
720 {#header_open|Floating Point Operations#}720 {#header_open|Floating Point Operations#}
721 <p>By default floating point operations use <code>Strict</code> mode,721 <p>By default floating point operations use {#syntax#}Strict{#endsyntax#} mode,
722 but you can switch to <code>Optimized</code> mode on a per-block basis:</p>722 but you can switch to {#syntax#}Optimized{#endsyntax#} mode on a per-block basis:</p>
723 {#code_begin|obj|foo#}723 {#code_begin|obj|foo#}
724 {#code_release_fast#}724 {#code_release_fast#}
725const builtin = @import("builtin");725const builtin = @import("builtin");
...@@ -772,8 +772,8 @@ pub fn main() void {...@@ -772,8 +772,8 @@ pub fn main() void {
772 </th>772 </th>
773 </tr>773 </tr>
774 <tr>774 <tr>
775 <td><pre><code class="zig">a + b775 <td><pre>{#syntax#}a + b
776a += b</code></pre></td>776a += b{#endsyntax#}</pre></td>
777 <td>777 <td>
778 <ul>778 <ul>
779 <li>{#link|Integers#}</li>779 <li>{#link|Integers#}</li>
...@@ -788,12 +788,12 @@ a += b</code></pre></td>...@@ -788,12 +788,12 @@ a += b</code></pre></td>
788 </ul>788 </ul>
789 </td>789 </td>
790 <td>790 <td>
791 <pre><code class="zig">2 + 5 == 7</code></pre>791 <pre>{#syntax#}2 + 5 == 7{#endsyntax#}</pre>
792 </td>792 </td>
793 </tr>793 </tr>
794 <tr>794 <tr>
795 <td><pre><code class="zig">a +% b795 <td><pre>{#syntax#}a +% b
796a +%= b</code></pre></td>796a +%= b{#endsyntax#}</pre></td>
797 <td>797 <td>
798 <ul>798 <ul>
799 <li>{#link|Integers#}</li>799 <li>{#link|Integers#}</li>
...@@ -807,12 +807,12 @@ a +%= b</code></pre></td>...@@ -807,12 +807,12 @@ a +%= b</code></pre></td>
807 </ul>807 </ul>
808 </td>808 </td>
809 <td>809 <td>
810 <pre><code class="zig">u32(@maxValue(u32)) +% 1 == 0</code></pre>810 <pre>{#syntax#}u32(@maxValue(u32)) +% 1 == 0{#endsyntax#}</pre>
811 </td>811 </td>
812 </tr>812 </tr>
813 <tr>813 <tr>
814 <td><pre><code class="zig">a - b814 <td><pre>{#syntax#}a - b
815a -= b</code></pre></td>815a -= b{#endsyntax#}</pre></td>
816 <td>816 <td>
817 <ul>817 <ul>
818 <li>{#link|Integers#}</li>818 <li>{#link|Integers#}</li>
...@@ -827,12 +827,12 @@ a -= b</code></pre></td>...@@ -827,12 +827,12 @@ a -= b</code></pre></td>
827 </ul>827 </ul>
828 </td>828 </td>
829 <td>829 <td>
830 <pre><code class="zig">2 - 5 == -3</code></pre>830 <pre>{#syntax#}2 - 5 == -3{#endsyntax#}</pre>
831 </td>831 </td>
832 </tr>832 </tr>
833 <tr>833 <tr>
834 <td><pre><code class="zig">a -% b834 <td><pre>{#syntax#}a -% b
835a -%= b</code></pre></td>835a -%= b{#endsyntax#}</pre></td>
836 <td>836 <td>
837 <ul>837 <ul>
838 <li>{#link|Integers#}</li>838 <li>{#link|Integers#}</li>
...@@ -846,11 +846,11 @@ a -%= b</code></pre></td>...@@ -846,11 +846,11 @@ a -%= b</code></pre></td>
846 </ul>846 </ul>
847 </td>847 </td>
848 <td>848 <td>
849 <pre><code class="zig">u32(0) -% 1 == @maxValue(u32)</code></pre>849 <pre>{#syntax#}u32(0) -% 1 == @maxValue(u32){#endsyntax#}</pre>
850 </td>850 </td>
851 </tr>851 </tr>
852 <tr>852 <tr>
853 <td><pre><code class="zig">-a<code></pre></td>853 <td><pre>{#syntax#}-a{#endsyntax#}</pre></td>
854 <td>854 <td>
855 <ul>855 <ul>
856 <li>{#link|Integers#}</li>856 <li>{#link|Integers#}</li>
...@@ -864,11 +864,11 @@ a -%= b</code></pre></td>...@@ -864,11 +864,11 @@ a -%= b</code></pre></td>
864 </ul>864 </ul>
865 </td>865 </td>
866 <td>866 <td>
867 <pre><code class="zig">-1 == 0 - 1</code></pre>867 <pre>{#syntax#}-1 == 0 - 1{#endsyntax#}</pre>
868 </td>868 </td>
869 </tr>869 </tr>
870 <tr>870 <tr>
871 <td><pre><code class="zig">-%a<code></pre></td>871 <td><pre>{#syntax#}-%a{#endsyntax#}</pre></td>
872 <td>872 <td>
873 <ul>873 <ul>
874 <li>{#link|Integers#}</li>874 <li>{#link|Integers#}</li>
...@@ -881,12 +881,12 @@ a -%= b</code></pre></td>...@@ -881,12 +881,12 @@ a -%= b</code></pre></td>
881 </ul>881 </ul>
882 </td>882 </td>
883 <td>883 <td>
884 <pre><code class="zig">-%i32(@minValue(i32)) == @minValue(i32)</code></pre>884 <pre>{#syntax#}-%i32(@minValue(i32)) == @minValue(i32){#endsyntax#}</pre>
885 </td>885 </td>
886 </tr>886 </tr>
887 <tr>887 <tr>
888 <td><pre><code class="zig">a * b888 <td><pre>{#syntax#}a * b
889a *= b</code></pre></td>889a *= b{#endsyntax#}</pre></td>
890 <td>890 <td>
891 <ul>891 <ul>
892 <li>{#link|Integers#}</li>892 <li>{#link|Integers#}</li>
...@@ -901,12 +901,12 @@ a *= b</code></pre></td>...@@ -901,12 +901,12 @@ a *= b</code></pre></td>
901 </ul>901 </ul>
902 </td>902 </td>
903 <td>903 <td>
904 <pre><code class="zig">2 * 5 == 10</code></pre>904 <pre>{#syntax#}2 * 5 == 10{#endsyntax#}</pre>
905 </td>905 </td>
906 </tr>906 </tr>
907 <tr>907 <tr>
908 <td><pre><code class="zig">a *% b908 <td><pre>{#syntax#}a *% b
909a *%= b</code></pre></td>909a *%= b{#endsyntax#}</pre></td>
910 <td>910 <td>
911 <ul>911 <ul>
912 <li>{#link|Integers#}</li>912 <li>{#link|Integers#}</li>
...@@ -920,12 +920,12 @@ a *%= b</code></pre></td>...@@ -920,12 +920,12 @@ a *%= b</code></pre></td>
920 </ul>920 </ul>
921 </td>921 </td>
922 <td>922 <td>
923 <pre><code class="zig">u8(200) *% 2 == 144</code></pre>923 <pre>{#syntax#}u8(200) *% 2 == 144{#endsyntax#}</pre>
924 </td>924 </td>
925 </tr>925 </tr>
926 <tr>926 <tr>
927 <td><pre><code class="zig">a / b927 <td><pre>{#syntax#}a / b
928a /= b</code></pre></td>928a /= b{#endsyntax#}</pre></td>
929 <td>929 <td>
930 <ul>930 <ul>
931 <li>{#link|Integers#}</li>931 <li>{#link|Integers#}</li>
...@@ -940,18 +940,18 @@ a /= b</code></pre></td>...@@ -940,18 +940,18 @@ a /= b</code></pre></td>
940 <li>For non-compile-time-known signed integers, must use940 <li>For non-compile-time-known signed integers, must use
941 {#link|@divTrunc#},941 {#link|@divTrunc#},
942 {#link|@divFloor#}, or942 {#link|@divFloor#}, or
943 {#link|@divExact#} instead of <code>/</code>.943 {#link|@divExact#} instead of {#syntax#}/{#endsyntax#}.
944 </li>944 </li>
945 <li>Invokes {#link|Peer Type Resolution#} for the operands.</li>945 <li>Invokes {#link|Peer Type Resolution#} for the operands.</li>
946 </ul>946 </ul>
947 </td>947 </td>
948 <td>948 <td>
949 <pre><code class="zig">10 / 5 == 2</code></pre>949 <pre>{#syntax#}10 / 5 == 2{#endsyntax#}</pre>
950 </td>950 </td>
951 </tr>951 </tr>
952 <tr>952 <tr>
953 <td><pre><code class="zig">a % b953 <td><pre>{#syntax#}a % b
954a %= b</code></pre></td>954a %= b{#endsyntax#}</pre></td>
955 <td>955 <td>
956 <ul>956 <ul>
957 <li>{#link|Integers#}</li>957 <li>{#link|Integers#}</li>
...@@ -964,18 +964,18 @@ a %= b</code></pre></td>...@@ -964,18 +964,18 @@ a %= b</code></pre></td>
964 <li>Can cause {#link|Division by Zero#} for floats in {#link|FloatMode.Optimized Mode|Floating Point Operations#}.</li>964 <li>Can cause {#link|Division by Zero#} for floats in {#link|FloatMode.Optimized Mode|Floating Point Operations#}.</li>
965 <li>For non-compile-time-known signed integers, must use965 <li>For non-compile-time-known signed integers, must use
966 {#link|@rem#} or966 {#link|@rem#} or
967 {#link|@mod#} instead of <code>%</code>.967 {#link|@mod#} instead of {#syntax#}%{#endsyntax#}.
968 </li>968 </li>
969 <li>Invokes {#link|Peer Type Resolution#} for the operands.</li>969 <li>Invokes {#link|Peer Type Resolution#} for the operands.</li>
970 </ul>970 </ul>
971 </td>971 </td>
972 <td>972 <td>
973 <pre><code class="zig">10 % 3 == 1</code></pre>973 <pre>{#syntax#}10 % 3 == 1{#endsyntax#}</pre>
974 </td>974 </td>
975 </tr>975 </tr>
976 <tr>976 <tr>
977 <td><pre><code class="zig">a &lt;&lt; b977 <td><pre>{#syntax#}a << b
978a &lt;&lt;= b</code></pre></td>978a <<= b{#endsyntax#}</pre></td>
979 <td>979 <td>
980 <ul>980 <ul>
981 <li>{#link|Integers#}</li>981 <li>{#link|Integers#}</li>
...@@ -983,18 +983,18 @@ a &lt;&lt;= b</code></pre></td>...@@ -983,18 +983,18 @@ a &lt;&lt;= b</code></pre></td>
983 </td>983 </td>
984 <td>Bit Shift Left.984 <td>Bit Shift Left.
985 <ul>985 <ul>
986 <li><code>b</code> must be {#link|comptime-known|comptime#} or have a type with log2 number of bits as <code>a</code>.</li>986 <li>{#syntax#}b{#endsyntax#} must be {#link|comptime-known|comptime#} or have a type with log2 number of bits as {#syntax#}a{#endsyntax#}.</li>
987 <li>See also {#link|@shlExact#}.</li>987 <li>See also {#link|@shlExact#}.</li>
988 <li>See also {#link|@shlWithOverflow#}.</li>988 <li>See also {#link|@shlWithOverflow#}.</li>
989 </ul>989 </ul>
990 </td>990 </td>
991 <td>991 <td>
992 <pre><code class="zig">1 &lt;&lt; 8 == 256</code></pre>992 <pre>{#syntax#}1 << 8 == 256{#endsyntax#}</pre>
993 </td>993 </td>
994 </tr>994 </tr>
995 <tr>995 <tr>
996 <td><pre><code class="zig">a &gt;&gt; b996 <td><pre>{#syntax#}a >> b
997a &gt;&gt;= b</code></pre></td>997a >>= b{#endsyntax#}</pre></td>
998 <td>998 <td>
999 <ul>999 <ul>
1000 <li>{#link|Integers#}</li>1000 <li>{#link|Integers#}</li>
...@@ -1002,17 +1002,17 @@ a &gt;&gt;= b</code></pre></td>...@@ -1002,17 +1002,17 @@ a &gt;&gt;= b</code></pre></td>
1002 </td>1002 </td>
1003 <td>Bit Shift Right.1003 <td>Bit Shift Right.
1004 <ul>1004 <ul>
1005 <li><code>b</code> must be {#link|comptime-known|comptime#} or have a type with log2 number of bits as <code>a</code>.</li>1005 <li>{#syntax#}b{#endsyntax#} must be {#link|comptime-known|comptime#} or have a type with log2 number of bits as {#syntax#}a{#endsyntax#}.</li>
1006 <li>See also {#link|@shrExact#}.</li>1006 <li>See also {#link|@shrExact#}.</li>
1007 </ul>1007 </ul>
1008 </td>1008 </td>
1009 <td>1009 <td>
1010 <pre><code class="zig">10 &gt;&gt; 1 == 5</code></pre>1010 <pre>{#syntax#}10 >> 1 == 5{#endsyntax#}</pre>
1011 </td>1011 </td>
1012 </tr>1012 </tr>
1013 <tr>1013 <tr>
1014 <td><pre><code class="zig">a &amp; b1014 <td><pre>{#syntax#}a & b
1015a &amp;= b</code></pre></td>1015a &= b{#endsyntax#}</pre></td>
1016 <td>1016 <td>
1017 <ul>1017 <ul>
1018 <li>{#link|Integers#}</li>1018 <li>{#link|Integers#}</li>
...@@ -1024,12 +1024,12 @@ a &amp;= b</code></pre></td>...@@ -1024,12 +1024,12 @@ a &amp;= b</code></pre></td>
1024 </ul>1024 </ul>
1025 </td>1025 </td>
1026 <td>1026 <td>
1027 <pre><code class="zig">0b011 &amp; 0b101 == 0b001</code></pre>1027 <pre>{#syntax#}0b011 &amp; 0b101 == 0b001{#endsyntax#}</pre>
1028 </td>1028 </td>
1029 </tr>1029 </tr>
1030 <tr>1030 <tr>
1031 <td><pre><code class="zig">a | b1031 <td><pre>{#syntax#}a | b
1032a |= b</code></pre></td>1032a |= b{#endsyntax#}</pre></td>
1033 <td>1033 <td>
1034 <ul>1034 <ul>
1035 <li>{#link|Integers#}</li>1035 <li>{#link|Integers#}</li>
...@@ -1041,12 +1041,12 @@ a |= b</code></pre></td>...@@ -1041,12 +1041,12 @@ a |= b</code></pre></td>
1041 </ul>1041 </ul>
1042 </td>1042 </td>
1043 <td>1043 <td>
1044 <pre><code class="zig">0b010 | 0b100 == 0b110</code></pre>1044 <pre>{#syntax#}0b010 | 0b100 == 0b110{#endsyntax#}</pre>
1045 </td>1045 </td>
1046 </tr>1046 </tr>
1047 <tr>1047 <tr>
1048 <td><pre><code class="zig">a ^ b1048 <td><pre>{#syntax#}a ^ b
1049a ^= b</code></pre></td>1049a ^= b{#endsyntax#}</pre></td>
1050 <td>1050 <td>
1051 <ul>1051 <ul>
1052 <li>{#link|Integers#}</li>1052 <li>{#link|Integers#}</li>
...@@ -1058,11 +1058,11 @@ a ^= b</code></pre></td>...@@ -1058,11 +1058,11 @@ a ^= b</code></pre></td>
1058 </ul>1058 </ul>
1059 </td>1059 </td>
1060 <td>1060 <td>
1061 <pre><code class="zig">0b011 ^ 0b101 == 0b110</code></pre>1061 <pre>{#syntax#}0b011 ^ 0b101 == 0b110{#endsyntax#}</pre>
1062 </td>1062 </td>
1063 </tr>1063 </tr>
1064 <tr>1064 <tr>
1065 <td><pre><code class="zig">~a<code></pre></td>1065 <td><pre>{#syntax#}~a{#endsyntax#}</pre></td>
1066 <td>1066 <td>
1067 <ul>1067 <ul>
1068 <li>{#link|Integers#}</li>1068 <li>{#link|Integers#}</li>
...@@ -1072,29 +1072,29 @@ a ^= b</code></pre></td>...@@ -1072,29 +1072,29 @@ a ^= b</code></pre></td>
1072 Bitwise NOT.1072 Bitwise NOT.
1073 </td>1073 </td>
1074 <td>1074 <td>
1075 <pre><code class="zig">~u8(0b0101111) == 0b1010000</code></pre>1075 <pre>{#syntax#}~u8(0b0101111) == 0b1010000{#endsyntax#}</pre>
1076 </td>1076 </td>
1077 </tr>1077 </tr>
1078 <tr>1078 <tr>
1079 <td><pre><code class="zig">a orelse b</code></pre></td>1079 <td><pre>{#syntax#}a orelse b{#endsyntax#}</pre></td>
1080 <td>1080 <td>
1081 <ul>1081 <ul>
1082 <li>{#link|Optionals#}</li>1082 <li>{#link|Optionals#}</li>
1083 </ul>1083 </ul>
1084 </td>1084 </td>
1085 <td>If <code>a</code> is <code>null</code>,1085 <td>If {#syntax#}a{#endsyntax#} is {#syntax#}null{#endsyntax#},
1086 returns <code>b</code> ("default value"),1086 returns {#syntax#}b{#endsyntax#} ("default value"),
1087 otherwise returns the unwrapped value of <code>a</code>.1087 otherwise returns the unwrapped value of {#syntax#}a{#endsyntax#}.
1088 Note that <code>b</code> may be a value of type {#link|noreturn#}.1088 Note that {#syntax#}b{#endsyntax#} may be a value of type {#link|noreturn#}.
1089 </td>1089 </td>
1090 <td>1090 <td>
1091 <pre><code class="zig">const value: ?u32 = null;1091 <pre>{#syntax#}const value: ?u32 = null;
1092const unwrapped = value orelse 1234;1092const unwrapped = value orelse 1234;
1093unwrapped == 1234</code></pre>1093unwrapped == 1234{#endsyntax#}</pre>
1094 </td>1094 </td>
1095 </tr>1095 </tr>
1096 <tr>1096 <tr>
1097 <td><pre><code class="zig">a.?</code></pre></td>1097 <td><pre>{#syntax#}a.?{#endsyntax#}</pre></td>
1098 <td>1098 <td>
1099 <ul>1099 <ul>
1100 <li>{#link|Optionals#}</li>1100 <li>{#link|Optionals#}</li>
...@@ -1102,65 +1102,65 @@ unwrapped == 1234</code></pre>...@@ -1102,65 +1102,65 @@ unwrapped == 1234</code></pre>
1102 </td>1102 </td>
1103 <td>1103 <td>
1104 Equivalent to:1104 Equivalent to:
1105 <pre><code class="zig">a orelse unreachable</code></pre>1105 <pre>{#syntax#}a orelse unreachable{#endsyntax#}</pre>
1106 </td>1106 </td>
1107 <td>1107 <td>
1108 <pre><code class="zig">const value: ?u32 = 5678;1108 <pre>{#syntax#}const value: ?u32 = 5678;
1109value.? == 5678</code></pre>1109value.? == 5678{#endsyntax#}</pre>
1110 </td>1110 </td>
1111 </tr>1111 </tr>
1112 <tr>1112 <tr>
1113 <td><pre><code class="zig">a catch b1113 <td><pre>{#syntax#}a catch b
1114a catch |err| b</code></pre></td>1114a catch |err| b{#endsyntax#}</pre></td>
1115 <td>1115 <td>
1116 <ul>1116 <ul>
1117 <li>{#link|Error Unions|Errors#}</li>1117 <li>{#link|Error Unions|Errors#}</li>
1118 </ul>1118 </ul>
1119 </td>1119 </td>
1120 <td>If <code>a</code> is an <code>error</code>,1120 <td>If {#syntax#}a{#endsyntax#} is an {#syntax#}error{#endsyntax#},
1121 returns <code>b</code> ("default value"),1121 returns {#syntax#}b{#endsyntax#} ("default value"),
1122 otherwise returns the unwrapped value of <code>a</code>.1122 otherwise returns the unwrapped value of {#syntax#}a{#endsyntax#}.
1123 Note that <code>b</code> may be a value of type {#link|noreturn#}.1123 Note that {#syntax#}b{#endsyntax#} may be a value of type {#link|noreturn#}.
1124 <code>err</code> is the <code>error</code> and is in scope of the expression <code>b</code>.1124 {#syntax#}err{#endsyntax#} is the {#syntax#}error{#endsyntax#} and is in scope of the expression {#syntax#}b{#endsyntax#}.
1125 </td>1125 </td>
1126 <td>1126 <td>
1127 <pre><code class="zig">const value: error!u32 = error.Broken;1127 <pre>{#syntax#}const value: error!u32 = error.Broken;
1128const unwrapped = value catch 1234;1128const unwrapped = value catch 1234;
1129unwrapped == 1234</code></pre>1129unwrapped == 1234{#endsyntax#}</pre>
1130 </td>1130 </td>
1131 </tr>1131 </tr>
1132 <tr>1132 <tr>
1133 <td><pre><code class="zig">a and b<code></pre></td>1133 <td><pre>{#syntax#}a and b{#endsyntax#}</pre></td>
1134 <td>1134 <td>
1135 <ul>1135 <ul>
1136 <li>{#link|bool|Primitive Types#}</li>1136 <li>{#link|bool|Primitive Types#}</li>
1137 </ul>1137 </ul>
1138 </td>1138 </td>
1139 <td>1139 <td>
1140 If <code>a</code> is <code>false</code>, returns <code>false</code>1140 If {#syntax#}a{#endsyntax#} is {#syntax#}false{#endsyntax#}, returns {#syntax#}false{#endsyntax#}
1141 without evaluating <code>b</code>. Otherwise, returns <code>b</code>.1141 without evaluating {#syntax#}b{#endsyntax#}. Otherwise, returns {#syntax#}b{#endsyntax#}.
1142 </td>1142 </td>
1143 <td>1143 <td>
1144 <pre><code class="zig">false and true == false</code></pre>1144 <pre>{#syntax#}false and true == false{#endsyntax#}</pre>
1145 </td>1145 </td>
1146 </tr>1146 </tr>
1147 <tr>1147 <tr>
1148 <td><pre><code class="zig">a or b<code></pre></td>1148 <td><pre>{#syntax#}a or b{#endsyntax#}</pre></td>
1149 <td>1149 <td>
1150 <ul>1150 <ul>
1151 <li>{#link|bool|Primitive Types#}</li>1151 <li>{#link|bool|Primitive Types#}</li>
1152 </ul>1152 </ul>
1153 </td>1153 </td>
1154 <td>1154 <td>
1155 If <code>a</code> is <code>true</code>, returns <code>true</code>1155 If {#syntax#}a{#endsyntax#} is {#syntax#}true{#endsyntax#}, returns {#syntax#}true{#endsyntax#}
1156 without evaluating <code>b</code>. Otherwise, returns <code>b</code>.1156 without evaluating {#syntax#}b{#endsyntax#}. Otherwise, returns {#syntax#}b{#endsyntax#}.
1157 </td>1157 </td>
1158 <td>1158 <td>
1159 <pre><code class="zig">false or true == true</code></pre>1159 <pre>{#syntax#}false or true == true{#endsyntax#}</pre>
1160 </td>1160 </td>
1161 </tr>1161 </tr>
1162 <tr>1162 <tr>
1163 <td><pre><code class="zig">!a<code></pre></td>1163 <td><pre>{#syntax#}!a{#endsyntax#}</pre></td>
1164 <td>1164 <td>
1165 <ul>1165 <ul>
1166 <li>{#link|bool|Primitive Types#}</li>1166 <li>{#link|bool|Primitive Types#}</li>
...@@ -1170,11 +1170,11 @@ unwrapped == 1234</code></pre>...@@ -1170,11 +1170,11 @@ unwrapped == 1234</code></pre>
1170 Boolean NOT.1170 Boolean NOT.
1171 </td>1171 </td>
1172 <td>1172 <td>
1173 <pre><code class="zig">!false == true</code></pre>1173 <pre>{#syntax#}!false == true{#endsyntax#}</pre>
1174 </td>1174 </td>
1175 </tr>1175 </tr>
1176 <tr>1176 <tr>
1177 <td><pre><code class="zig">a == b<code></pre></td>1177 <td><pre>{#syntax#}a == b{#endsyntax#}</pre></td>
1178 <td>1178 <td>
1179 <ul>1179 <ul>
1180 <li>{#link|Integers#}</li>1180 <li>{#link|Integers#}</li>
...@@ -1184,30 +1184,30 @@ unwrapped == 1234</code></pre>...@@ -1184,30 +1184,30 @@ unwrapped == 1234</code></pre>
1184 </ul>1184 </ul>
1185 </td>1185 </td>
1186 <td>1186 <td>
1187 Returns <code>true</code> if a and b are equal, otherwise returns <code>false</code>.1187 Returns {#syntax#}true{#endsyntax#} if a and b are equal, otherwise returns {#syntax#}false{#endsyntax#}.
1188 Invokes {#link|Peer Type Resolution#} for the operands.1188 Invokes {#link|Peer Type Resolution#} for the operands.
1189 </td>1189 </td>
1190 <td>1190 <td>
1191 <pre><code class="zig">(1 == 1) == true</code></pre>1191 <pre>{#syntax#}(1 == 1) == true{#endsyntax#}</pre>
1192 </td>1192 </td>
1193 </tr>1193 </tr>
1194 <tr>1194 <tr>
1195 <td><pre><code class="zig">a == null<code></pre></td>1195 <td><pre>{#syntax#}a == null{#endsyntax#}</pre></td>
1196 <td>1196 <td>
1197 <ul>1197 <ul>
1198 <li>{#link|Optionals#}</li>1198 <li>{#link|Optionals#}</li>
1199 </ul>1199 </ul>
1200 </td>1200 </td>
1201 <td>1201 <td>
1202 Returns <code>true</code> if a is <code>null</code>, otherwise returns <code>false</code>.1202 Returns {#syntax#}true{#endsyntax#} if a is {#syntax#}null{#endsyntax#}, otherwise returns {#syntax#}false{#endsyntax#}.
1203 </td>1203 </td>
1204 <td>1204 <td>
1205 <pre><code class="zig">const value: ?u32 = null;1205 <pre>{#syntax#}const value: ?u32 = null;
1206value == null</code></pre>1206value == null{#endsyntax#}</pre>
1207 </td>1207 </td>
1208 </tr>1208 </tr>
1209 <tr>1209 <tr>
1210 <td><pre><code class="zig">a != b<code></pre></td>1210 <td><pre>{#syntax#}a != b{#endsyntax#}</pre></td>
1211 <td>1211 <td>
1212 <ul>1212 <ul>
1213 <li>{#link|Integers#}</li>1213 <li>{#link|Integers#}</li>
...@@ -1217,15 +1217,15 @@ value == null</code></pre>...@@ -1217,15 +1217,15 @@ value == null</code></pre>
1217 </ul>1217 </ul>
1218 </td>1218 </td>
1219 <td>1219 <td>
1220 Returns <code>false</code> if a and b are equal, otherwise returns <code>true</code>.1220 Returns {#syntax#}false{#endsyntax#} if a and b are equal, otherwise returns {#syntax#}true{#endsyntax#}.
1221 Invokes {#link|Peer Type Resolution#} for the operands.1221 Invokes {#link|Peer Type Resolution#} for the operands.
1222 </td>1222 </td>
1223 <td>1223 <td>
1224 <pre><code class="zig">(1 != 1) == false</code></pre>1224 <pre>{#syntax#}(1 != 1) == false{#endsyntax#}</pre>
1225 </td>1225 </td>
1226 </tr>1226 </tr>
1227 <tr>1227 <tr>
1228 <td><pre><code class="zig">a &gt; b<code></pre></td>1228 <td><pre>{#syntax#}a > b{#endsyntax#}</pre></td>
1229 <td>1229 <td>
1230 <ul>1230 <ul>
1231 <li>{#link|Integers#}</li>1231 <li>{#link|Integers#}</li>
...@@ -1233,15 +1233,15 @@ value == null</code></pre>...@@ -1233,15 +1233,15 @@ value == null</code></pre>
1233 </ul>1233 </ul>
1234 </td>1234 </td>
1235 <td>1235 <td>
1236 Returns <code>true</code> if a is greater than b, otherwise returns <code>false</code>.1236 Returns {#syntax#}true{#endsyntax#} if a is greater than b, otherwise returns {#syntax#}false{#endsyntax#}.
1237 Invokes {#link|Peer Type Resolution#} for the operands.1237 Invokes {#link|Peer Type Resolution#} for the operands.
1238 </td>1238 </td>
1239 <td>1239 <td>
1240 <pre><code class="zig">(2 &gt; 1) == true</code></pre>1240 <pre>{#syntax#}(2 > 1) == true{#endsyntax#}</pre>
1241 </td>1241 </td>
1242 </tr>1242 </tr>
1243 <tr>1243 <tr>
1244 <td><pre><code class="zig">a &gt;= b<code></pre></td>1244 <td><pre>{#syntax#}a >= b{#endsyntax#}</pre></td>
1245 <td>1245 <td>
1246 <ul>1246 <ul>
1247 <li>{#link|Integers#}</li>1247 <li>{#link|Integers#}</li>
...@@ -1249,15 +1249,15 @@ value == null</code></pre>...@@ -1249,15 +1249,15 @@ value == null</code></pre>
1249 </ul>1249 </ul>
1250 </td>1250 </td>
1251 <td>1251 <td>
1252 Returns <code>true</code> if a is greater than or equal to b, otherwise returns <code>false</code>.1252 Returns {#syntax#}true{#endsyntax#} if a is greater than or equal to b, otherwise returns {#syntax#}false{#endsyntax#}.
1253 Invokes {#link|Peer Type Resolution#} for the operands.1253 Invokes {#link|Peer Type Resolution#} for the operands.
1254 </td>1254 </td>
1255 <td>1255 <td>
1256 <pre><code class="zig">(2 &gt;= 1) == true</code></pre>1256 <pre>{#syntax#}(2 >= 1) == true{#endsyntax#}</pre>
1257 </td>1257 </td>
1258 </tr>1258 </tr>
1259 <tr>1259 <tr>
1260 <td><pre><code class="zig">a &lt; b<code></pre></td>1260 <td><pre>{#syntax#}a < b{#endsyntax#}</pre></td>
1261 <td>1261 <td>
1262 <ul>1262 <ul>
1263 <li>{#link|Integers#}</li>1263 <li>{#link|Integers#}</li>
...@@ -1265,15 +1265,15 @@ value == null</code></pre>...@@ -1265,15 +1265,15 @@ value == null</code></pre>
1265 </ul>1265 </ul>
1266 </td>1266 </td>
1267 <td>1267 <td>
1268 Returns <code>true</code> if a is less than b, otherwise returns <code>false</code>.1268 Returns {#syntax#}true{#endsyntax#} if a is less than b, otherwise returns {#syntax#}false{#endsyntax#}.
1269 Invokes {#link|Peer Type Resolution#} for the operands.1269 Invokes {#link|Peer Type Resolution#} for the operands.
1270 </td>1270 </td>
1271 <td>1271 <td>
1272 <pre><code class="zig">(1 &lt; 2) == true</code></pre>1272 <pre>{#syntax#}(1 < 2) == true{#endsyntax#}></pre>
1273 </td>1273 </td>
1274 </tr>1274 </tr>
1275 <tr>1275 <tr>
1276 <td><pre><code class="zig">a &lt;= b<code></pre></td>1276 <td><pre>{#syntax#}a <= b{#endsyntax#}</pre></td>
1277 <td>1277 <td>
1278 <ul>1278 <ul>
1279 <li>{#link|Integers#}</li>1279 <li>{#link|Integers#}</li>
...@@ -1281,15 +1281,15 @@ value == null</code></pre>...@@ -1281,15 +1281,15 @@ value == null</code></pre>
1281 </ul>1281 </ul>
1282 </td>1282 </td>
1283 <td>1283 <td>
1284 Returns <code>true</code> if a is less than or equal to b, otherwise returns <code>false</code>.1284 Returns {#syntax#}true{#endsyntax#} if a is less than or equal to b, otherwise returns {#syntax#}false{#endsyntax#}.
1285 Invokes {#link|Peer Type Resolution#} for the operands.1285 Invokes {#link|Peer Type Resolution#} for the operands.
1286 </td>1286 </td>
1287 <td>1287 <td>
1288 <pre><code class="zig">(1 &lt;= 2) == true</code></pre>1288 <pre>{#syntax#}(1 <= 2) == true{#endsyntax#}</pre>
1289 </td>1289 </td>
1290 </tr>1290 </tr>
1291 <tr>1291 <tr>
1292 <td><pre><code class="zig">a ++ b<code></pre></td>1292 <td><pre>{#syntax#}a ++ b{#endsyntax#}</pre></td>
1293 <td>1293 <td>
1294 <ul>1294 <ul>
1295 <li>{#link|Arrays#}</li>1295 <li>{#link|Arrays#}</li>
...@@ -1298,19 +1298,19 @@ value == null</code></pre>...@@ -1298,19 +1298,19 @@ value == null</code></pre>
1298 <td>1298 <td>
1299 Array concatenation.1299 Array concatenation.
1300 <ul>1300 <ul>
1301 <li>Only available when <code>a</code> and <code>b</code> are {#link|compile-time known|comptime#}.1301 <li>Only available when {#syntax#}a{#endsyntax#} and {#syntax#}b{#endsyntax#} are {#link|compile-time known|comptime#}.
1302 </ul>1302 </ul>
1303 </td>1303 </td>
1304 <td>1304 <td>
1305 <pre><code class="zig">const mem = @import("std").mem;1305 <pre>{#syntax#}const mem = @import("std").mem;
1306const array1 = []u32{1,2};1306const array1 = []u32{1,2};
1307const array2 = []u32{3,4};1307const array2 = []u32{3,4};
1308const together = array1 ++ array2;1308const together = array1 ++ array2;
1309mem.eql(u32, together, []u32{1,2,3,4})</code></pre>1309mem.eql(u32, together, []u32{1,2,3,4}){#endsyntax#}</pre>
1310 </td>1310 </td>
1311 </tr>1311 </tr>
1312 <tr>1312 <tr>
1313 <td><pre><code class="zig">a ** b<code></pre></td>1313 <td><pre>{#syntax#}a ** b{#endsyntax#}</pre></td>
1314 <td>1314 <td>
1315 <ul>1315 <ul>
1316 <li>{#link|Arrays#}</li>1316 <li>{#link|Arrays#}</li>
...@@ -1319,17 +1319,17 @@ mem.eql(u32, together, []u32{1,2,3,4})</code></pre>...@@ -1319,17 +1319,17 @@ mem.eql(u32, together, []u32{1,2,3,4})</code></pre>
1319 <td>1319 <td>
1320 Array multiplication.1320 Array multiplication.
1321 <ul>1321 <ul>
1322 <li>Only available when <code>a</code> and <code>b</code> are {#link|compile-time known|comptime#}.1322 <li>Only available when {#syntax#}a{#endsyntax#} and {#syntax#}b{#endsyntax#} are {#link|compile-time known|comptime#}.
1323 </ul>1323 </ul>
1324 </td>1324 </td>
1325 <td>1325 <td>
1326 <pre><code class="zig">const mem = @import("std").mem;1326 <pre>{#syntax#}const mem = @import("std").mem;
1327const pattern = "ab" ** 3;1327const pattern = "ab" ** 3;
1328mem.eql(u8, pattern, "ababab")</code></pre>1328mem.eql(u8, pattern, "ababab"){#endsyntax#}</pre>
1329 </td>1329 </td>
1330 </tr>1330 </tr>
1331 <tr>1331 <tr>
1332 <td><pre><code class="zig">a.*<code></pre></td>1332 <td><pre>{#syntax#}a.*{#endsyntax#}</pre></td>
1333 <td>1333 <td>
1334 <ul>1334 <ul>
1335 <li>{#link|Pointers#}</li>1335 <li>{#link|Pointers#}</li>
...@@ -1339,13 +1339,13 @@ mem.eql(u8, pattern, "ababab")</code></pre>...@@ -1339,13 +1339,13 @@ mem.eql(u8, pattern, "ababab")</code></pre>
1339 Pointer dereference.1339 Pointer dereference.
1340 </td>1340 </td>
1341 <td>1341 <td>
1342 <pre><code class="zig">const x: u32 = 1234;1342 <pre>{#syntax#}const x: u32 = 1234;
1343const ptr = &amp;x;1343const ptr = &x;
1344x.* == 1234</code></pre>1344x.* == 1234{#endsyntax#}</pre>
1345 </td>1345 </td>
1346 </tr>1346 </tr>
1347 <tr>1347 <tr>
1348 <td><pre><code class="zig">&amp;a<code></pre></td>1348 <td><pre>{#syntax#}&amp;a{#endsyntax#}</pre></td>
1349 <td>1349 <td>
1350 All types1350 All types
1351 </td>1351 </td>
...@@ -1353,13 +1353,13 @@ x.* == 1234</code></pre>...@@ -1353,13 +1353,13 @@ x.* == 1234</code></pre>
1353 Address of.1353 Address of.
1354 </td>1354 </td>
1355 <td>1355 <td>
1356 <pre><code class="zig">const x: u32 = 1234;1356 <pre>{#syntax#}const x: u32 = 1234;
1357const ptr = &amp;x;1357const ptr = &x;
1358x.* == 1234</code></pre>1358x.* == 1234{#endsyntax#}</pre>
1359 </td>1359 </td>
1360 </tr>1360 </tr>
1361 <tr>1361 <tr>
1362 <td><pre><code class="zig">a || b<code></pre></td>1362 <td><pre>{#syntax#}a || b{#endsyntax#}</pre></td>
1363 <td>1363 <td>
1364 <ul>1364 <ul>
1365 <li>{#link|Error Set Type#}</li>1365 <li>{#link|Error Set Type#}</li>
...@@ -1369,30 +1369,30 @@ x.* == 1234</code></pre>...@@ -1369,30 +1369,30 @@ x.* == 1234</code></pre>
1369 {#link|Merging Error Sets#}1369 {#link|Merging Error Sets#}
1370 </td>1370 </td>
1371 <td>1371 <td>
1372 <pre><code class="zig">const A = error{One};1372 <pre>{#syntax#}const A = error{One};
1373const B = error{Two};1373const B = error{Two};
1374(A || B) == error{One, Two}</code></pre>1374(A || B) == error{One, Two}{#endsyntax#}</pre>
1375 </td>1375 </td>
1376 </tr>1376 </tr>
1377 </table>1377 </table>
1378 </div>1378 </div>
1379 {#header_close#}1379 {#header_close#}
1380 {#header_open|Precedence#}1380 {#header_open|Precedence#}
1381 <pre><code>x() x[] x.y1381 <pre>{#syntax#}x() x[] x.y
1382a!b1382a!b
1383!x -x -%x ~x &amp;x ?x1383!x -x -%x ~x &x ?x
1384x{} x.* x.?1384x{} x.* x.?
1385! * / % ** *% ||1385! * / % ** *% ||
1386+ - ++ +% -%1386+ - ++ +% -%
1387&lt;&lt; &gt;&gt;1387<< >>
1388&amp;1388&
1389^1389^
1390|1390|
1391== != &lt; &gt; &lt;= &gt;=1391== != < > <= >=
1392and1392and
1393or1393or
1394orelse catch1394orelse catch
1395= *= /= %= += -= &lt;&lt;= &gt;&gt;= &amp;= ^= |=</code></pre>1395= *= /= %= += -= <<= >>= &= ^= |={#endsyntax#}</pre>
1396 {#header_close#}1396 {#header_close#}
1397 {#header_close#}1397 {#header_close#}
1398 {#header_open|Arrays#}1398 {#header_open|Arrays#}
...@@ -1641,7 +1641,7 @@ test "pointer child type" {...@@ -1641,7 +1641,7 @@ test "pointer child type" {
1641 </p>1641 </p>
1642 <p>1642 <p>
1643 Alignment depends on the CPU architecture, but is always a power of two, and1643 Alignment depends on the CPU architecture, but is always a power of two, and
1644 less than <code>1 &lt;&lt; 29</code>.1644 less than {#syntax#}1 << 29{#endsyntax#}.
1645 </p>1645 </p>
1646 <p>1646 <p>
1647 In Zig, a pointer type has an alignment value. If the value is equal to the1647 In Zig, a pointer type has an alignment value. If the value is equal to the
...@@ -1661,8 +1661,8 @@ test "variable alignment" {...@@ -1661,8 +1661,8 @@ test "variable alignment" {
1661 }1661 }
1662}1662}
1663 {#code_end#}1663 {#code_end#}
1664 <p>In the same way that a <code>*i32</code> can be {#link|implicitly cast|Implicit Casts#} to a1664 <p>In the same way that a {#syntax#}*i32{#endsyntax#} can be {#link|implicitly cast|Implicit Casts#} to a
1665 <code>*const i32</code>, a pointer with a larger alignment can be implicitly1665 {#syntax#}*const i32{#endsyntax#}, a pointer with a larger alignment can be implicitly
1666 cast to a pointer with a smaller alignment, but not vice versa.1666 cast to a pointer with a smaller alignment, but not vice versa.
1667 </p>1667 </p>
1668 <p>1668 <p>
...@@ -1717,14 +1717,14 @@ fn foo(bytes: []u8) u32 {...@@ -1717,14 +1717,14 @@ fn foo(bytes: []u8) u32 {
1717 {#header_open|Type Based Alias Analysis#}1717 {#header_open|Type Based Alias Analysis#}
1718 <p>Zig uses Type Based Alias Analysis (also known as Strict Aliasing) to1718 <p>Zig uses Type Based Alias Analysis (also known as Strict Aliasing) to
1719 perform some optimizations. This means that pointers of different types must1719 perform some optimizations. This means that pointers of different types must
1720 not alias the same memory, with the exception of <code>u8</code>. Pointers to1720 not alias the same memory, with the exception of {#syntax#}u8{#endsyntax#}. Pointers to
1721 <code>u8</code> can alias any memory.1721 {#syntax#}u8{#endsyntax#} can alias any memory.
1722 </p>1722 </p>
1723 <p>As an example, this code produces undefined behavior:</p>1723 <p>As an example, this code produces undefined behavior:</p>
1724 <pre><code class="zig">@ptrCast(*u32, f32(12.34)).*</code></pre>1724 <pre>{#syntax#}@ptrCast(*u32, f32(12.34)).*{#endsyntax#}</pre>
1725 <p>Instead, use {#link|@bitCast#}:1725 <p>Instead, use {#link|@bitCast#}:
1726 <pre><code class="zig">@bitCast(u32, f32(12.34))</code></pre>1726 <pre>{#syntax#}@bitCast(u32, f32(12.34)){#endsyntax#}</pre>
1727 <p>As an added benefit, the <code>@bitCast</code> version works at compile-time.</p>1727 <p>As an added benefit, the {#syntax#}@bitCast{#endsyntax#} version works at compile-time.</p>
1728 {#see_also|Slices|Memory#}1728 {#see_also|Slices|Memory#}
1729 {#header_close#}1729 {#header_close#}
1730 {#header_close#}1730 {#header_close#}
...@@ -1952,9 +1952,9 @@ test "linked list" {...@@ -1952,9 +1952,9 @@ test "linked list" {
1952 <ul>1952 <ul>
1953 <li>If the struct is in the initialization expression of a variable, it gets named after1953 <li>If the struct is in the initialization expression of a variable, it gets named after
1954 that variable.</li>1954 that variable.</li>
1955 <li>If the struct is in the <code>return</code> expression, it gets named after1955 <li>If the struct is in the {#syntax#}return{#endsyntax#} expression, it gets named after
1956 the function it is returning from, with the parameter values serialized.</li>1956 the function it is returning from, with the parameter values serialized.</li>
1957 <li>Otherwise, the struct gets a same such as <code>(anonymous struct at file.zig:7:38)</code>.</li>1957 <li>Otherwise, the struct gets a same such as {#syntax#}(anonymous struct at file.zig:7:38){#endsyntax#}.</li>
1958 </ul>1958 </ul>
1959 {#code_begin|exe|struct_name#}1959 {#code_begin|exe|struct_name#}
1960const std = @import("std");1960const std = @import("std");
...@@ -2086,7 +2086,7 @@ const Foo = enum { A, B, C };...@@ -2086,7 +2086,7 @@ const Foo = enum { A, B, C };
2086export fn entry(foo: Foo) void { }2086export fn entry(foo: Foo) void { }
2087 {#code_end#}2087 {#code_end#}
2088 <p>2088 <p>
2089 For a C-ABI-compatible enum, use <code class="zig">extern enum</code>:2089 For a C-ABI-compatible enum, use {#syntax#}extern enum{#endsyntax#}:
2090 </p>2090 </p>
2091 {#code_begin|obj#}2091 {#code_begin|obj#}
2092const Foo = extern enum { A, B, C };2092const Foo = extern enum { A, B, C };
...@@ -2095,7 +2095,7 @@ export fn entry(foo: Foo) void { }...@@ -2095,7 +2095,7 @@ export fn entry(foo: Foo) void { }
2095 {#header_close#}2095 {#header_close#}
2096 {#header_open|packed enum#}2096 {#header_open|packed enum#}
2097 <p>By default, the size of enums is not guaranteed.</p>2097 <p>By default, the size of enums is not guaranteed.</p>
2098 <p><code>packed enum</code> causes the size of the enum to be the same as the size of the integer tag type2098 <p>{#syntax#}packed enum{#endsyntax#} causes the size of the enum to be the same as the size of the integer tag type
2099 of the enum:</p>2099 of the enum:</p>
2100 {#code_begin|test#}2100 {#code_begin|test#}
2101const std = @import("std");2101const std = @import("std");
...@@ -2246,7 +2246,7 @@ test "access variable after block scope" {...@@ -2246,7 +2246,7 @@ test "access variable after block scope" {
2246 x += 1;2246 x += 1;
2247}2247}
2248 {#code_end#}2248 {#code_end#}
2249 <p>Blocks are expressions. When labeled, <code>break</code> can be used2249 <p>Blocks are expressions. When labeled, {#syntax#}break{#endsyntax#} can be used
2250 to return a value from the block:2250 to return a value from the block:
2251 </p>2251 </p>
2252 {#code_begin|test#}2252 {#code_begin|test#}
...@@ -2264,7 +2264,7 @@ test "labeled break from labeled block expression" {...@@ -2264,7 +2264,7 @@ test "labeled break from labeled block expression" {
2264 assert(y == 124);2264 assert(y == 124);
2265}2265}
2266 {#code_end#}2266 {#code_end#}
2267 <p>Here, <code>blk</code> can be any name.</p>2267 <p>Here, {#syntax#}blk{#endsyntax#} can be any name.</p>
2268 {#see_also|Labeled while|Labeled for#}2268 {#see_also|Labeled while|Labeled for#}
2269 {#header_close#}2269 {#header_close#}
2270 {#header_open|switch#}2270 {#header_open|switch#}
...@@ -2380,7 +2380,7 @@ test "while basic" {...@@ -2380,7 +2380,7 @@ test "while basic" {
2380}2380}
2381 {#code_end#}2381 {#code_end#}
2382 <p>2382 <p>
2383 Use <code>break</code> to exit a while loop early.2383 Use {#syntax#}break{#endsyntax#} to exit a while loop early.
2384 </p>2384 </p>
2385 {#code_begin|test|while#}2385 {#code_begin|test|while#}
2386const assert = @import("std").debug.assert;2386const assert = @import("std").debug.assert;
...@@ -2396,7 +2396,7 @@ test "while break" {...@@ -2396,7 +2396,7 @@ test "while break" {
2396}2396}
2397 {#code_end#}2397 {#code_end#}
2398 <p>2398 <p>
2399 Use <code>continue</code> to jump back to the beginning of the loop.2399 Use {#syntax#}continue{#endsyntax#} to jump back to the beginning of the loop.
2400 </p>2400 </p>
2401 {#code_begin|test|while#}2401 {#code_begin|test|while#}
2402const assert = @import("std").debug.assert;2402const assert = @import("std").debug.assert;
...@@ -2414,7 +2414,7 @@ test "while continue" {...@@ -2414,7 +2414,7 @@ test "while continue" {
2414 {#code_end#}2414 {#code_end#}
2415 <p>2415 <p>
2416 While loops support a continue expression which is executed when the loop2416 While loops support a continue expression which is executed when the loop
2417 is continued. The <code>continue</code> keyword respects this expression.2417 is continued. The {#syntax#}continue{#endsyntax#} keyword respects this expression.
2418 </p>2418 </p>
2419 {#code_begin|test|while#}2419 {#code_begin|test|while#}
2420const assert = @import("std").debug.assert;2420const assert = @import("std").debug.assert;
...@@ -2436,13 +2436,13 @@ test "while loop continue expression, more complicated" {...@@ -2436,13 +2436,13 @@ test "while loop continue expression, more complicated" {
2436 {#code_end#}2436 {#code_end#}
2437 <p>2437 <p>
2438 While loops are expressions. The result of the expression is the2438 While loops are expressions. The result of the expression is the
2439 result of the <code>else</code> clause of a while loop, which is executed when2439 result of the {#syntax#}else{#endsyntax#} clause of a while loop, which is executed when
2440 the condition of the while loop is tested as false.2440 the condition of the while loop is tested as false.
2441 </p>2441 </p>
2442 <p>2442 <p>
2443 <code>break</code>, like <code>return</code>, accepts a value2443 {#syntax#}break{#endsyntax#}, like {#syntax#}return{#endsyntax#}, accepts a value
2444 parameter. This is the result of the <code>while</code> expression.2444 parameter. This is the result of the {#syntax#}while{#endsyntax#} expression.
2445 When you <code>break</code> from a while loop, the <code>else</code> branch is not2445 When you {#syntax#}break{#endsyntax#} from a while loop, the {#syntax#}else{#endsyntax#} branch is not
2446 evaluated.2446 evaluated.
2447 </p>2447 </p>
2448 {#code_begin|test|while#}2448 {#code_begin|test|while#}
...@@ -2463,8 +2463,8 @@ fn rangeHasNumber(begin: usize, end: usize, number: usize) bool {...@@ -2463,8 +2463,8 @@ fn rangeHasNumber(begin: usize, end: usize, number: usize) bool {
2463}2463}
2464 {#code_end#}2464 {#code_end#}
2465 {#header_open|Labeled while#}2465 {#header_open|Labeled while#}
2466 <p>When a <code>while</code> loop is labeled, it can be referenced from a <code>break</code>2466 <p>When a {#syntax#}while{#endsyntax#} loop is labeled, it can be referenced from a {#syntax#}break{#endsyntax#}
2467 or <code>continue</code> from within a nested loop:</p>2467 or {#syntax#}continue{#endsyntax#} from within a nested loop:</p>
2468 {#code_begin|test#}2468 {#code_begin|test#}
2469test "nested break" {2469test "nested break" {
2470 outer: while (true) {2470 outer: while (true) {
...@@ -2491,11 +2491,11 @@ test "nested continue" {...@@ -2491,11 +2491,11 @@ test "nested continue" {
2491 exits.2491 exits.
2492 </p>2492 </p>
2493 <p>2493 <p>
2494 When the <code>|x|</code> syntax is present on a <code>while</code> expression,2494 When the {#syntax#}|x|{#endsyntax#} syntax is present on a {#syntax#}while{#endsyntax#} expression,
2495 the while condition must have an {#link|Optional Type#}.2495 the while condition must have an {#link|Optional Type#}.
2496 </p>2496 </p>
2497 <p>2497 <p>
2498 The <code>else</code> branch is allowed on optional iteration. In this case, it will2498 The {#syntax#}else{#endsyntax#} branch is allowed on optional iteration. In this case, it will
2499 be executed on the first null value encountered.2499 be executed on the first null value encountered.
2500 </p>2500 </p>
2501 {#code_begin|test|while#}2501 {#code_begin|test|while#}
...@@ -2537,7 +2537,7 @@ fn eventuallyNullSequence() ?u32 {...@@ -2537,7 +2537,7 @@ fn eventuallyNullSequence() ?u32 {
2537 the loop is finished.2537 the loop is finished.
2538 </p>2538 </p>
2539 <p>2539 <p>
2540 When the <code>else |x|</code> syntax is present on a <code>while</code> expression,2540 When the {#syntax#}else |x|{#endsyntax#} syntax is present on a {#syntax#}while{#endsyntax#} expression,
2541 the while condition must have an {#link|Error Union Type#}.2541 the while condition must have an {#link|Error Union Type#}.
2542 </p>2542 </p>
2543 {#code_begin|test|while#}2543 {#code_begin|test|while#}
...@@ -2593,7 +2593,7 @@ fn typeNameLength(comptime T: type) usize {...@@ -2593,7 +2593,7 @@ fn typeNameLength(comptime T: type) usize {
2593}2593}
2594 {#code_end#}2594 {#code_end#}
2595 <p>2595 <p>
2596 It is recommended to use <code>inline</code> loops only for one of these reasons:2596 It is recommended to use {#syntax#}inline{#endsyntax#} loops only for one of these reasons:
2597 </p>2597 </p>
2598 <ul>2598 <ul>
2599 <li>You need the loop to execute at {#link|comptime#} for the semantics to work.</li>2599 <li>You need the loop to execute at {#link|comptime#} for the semantics to work.</li>
...@@ -2671,8 +2671,8 @@ test "for else" {...@@ -2671,8 +2671,8 @@ test "for else" {
2671}2671}
2672 {#code_end#}2672 {#code_end#}
2673 {#header_open|Labeled for#}2673 {#header_open|Labeled for#}
2674 <p>When a <code>for</code> loop is labeled, it can be referenced from a <code>break</code>2674 <p>When a {#syntax#}for{#endsyntax#} loop is labeled, it can be referenced from a {#syntax#}break{#endsyntax#}
2675 or <code>continue</code> from within a nested loop:</p>2675 or {#syntax#}continue{#endsyntax#} from within a nested loop:</p>
2676 {#code_begin|test#}2676 {#code_begin|test#}
2677const std = @import("std");2677const std = @import("std");
2678const assert = std.debug.assert;2678const assert = std.debug.assert;
...@@ -2732,7 +2732,7 @@ fn typeNameLength(comptime T: type) usize {...@@ -2732,7 +2732,7 @@ fn typeNameLength(comptime T: type) usize {
2732}2732}
2733 {#code_end#}2733 {#code_end#}
2734 <p>2734 <p>
2735 It is recommended to use <code>inline</code> loops only for one of these reasons:2735 It is recommended to use {#syntax#}inline{#endsyntax#} loops only for one of these reasons:
2736 </p>2736 </p>
2737 <ul>2737 <ul>
2738 <li>You need the loop to execute at {#link|comptime#} for the semantics to work.</li>2738 <li>You need the loop to execute at {#link|comptime#} for the semantics to work.</li>
...@@ -2932,13 +2932,13 @@ test "errdefer unwinding" {...@@ -2932,13 +2932,13 @@ test "errdefer unwinding" {
2932 {#header_close#}2932 {#header_close#}
2933 {#header_open|unreachable#}2933 {#header_open|unreachable#}
2934 <p>2934 <p>
2935 In <code>Debug</code> and <code>ReleaseSafe</code> mode, and when using <code>zig test</code>,2935 In {#syntax#}Debug{#endsyntax#} and {#syntax#}ReleaseSafe{#endsyntax#} mode, and when using <code>zig test</code>,
2936 <code>unreachable</code> emits a call to <code>panic</code> with the message <code>reached unreachable code</code>.2936 {#syntax#}unreachable{#endsyntax#} emits a call to {#syntax#}panic{#endsyntax#} with the message <code>reached unreachable code</code>.
2937 </p>2937 </p>
2938 <p>2938 <p>
2939 In <code>ReleaseFast</code> mode, the optimizer uses the assumption that <code>unreachable</code> code2939 In {#syntax#}ReleaseFast{#endsyntax#} mode, the optimizer uses the assumption that {#syntax#}unreachable{#endsyntax#} code
2940 will never be hit to perform optimizations. However, <code>zig test</code> even in <code>ReleaseFast</code> mode2940 will never be hit to perform optimizations. However, <code>zig test</code> even in {#syntax#}ReleaseFast{#endsyntax#} mode
2941 still emits <code>unreachable</code> as calls to <code>panic</code>.2941 still emits {#syntax#}unreachable{#endsyntax#} as calls to {#syntax#}panic{#endsyntax#}.
2942 </p>2942 </p>
2943 {#header_open|Basics#}2943 {#header_open|Basics#}
2944 {#code_begin|test#}2944 {#code_begin|test#}
...@@ -2984,17 +2984,17 @@ test "type of unreachable" {...@@ -2984,17 +2984,17 @@ test "type of unreachable" {
2984 {#header_close#}2984 {#header_close#}
2985 {#header_open|noreturn#}2985 {#header_open|noreturn#}
2986 <p>2986 <p>
2987 <code>noreturn</code> is the type of:2987 {#syntax#}noreturn{#endsyntax#} is the type of:
2988 </p>2988 </p>
2989 <ul>2989 <ul>
2990 <li><code>break</code></li>2990 <li>{#syntax#}break{#endsyntax#}</li>
2991 <li><code>continue</code></li>2991 <li>{#syntax#}continue{#endsyntax#}</li>
2992 <li><code>return</code></li>2992 <li>{#syntax#}return{#endsyntax#}</li>
2993 <li><code>unreachable</code></li>2993 <li>{#syntax#}unreachable{#endsyntax#}</li>
2994 <li><code>while (true) {}</code></li>2994 <li>{#syntax#}while (true) {}{#endsyntax#}</li>
2995 </ul>2995 </ul>
2996 <p>When resolving types together, such as <code>if</code> clauses or <code>switch</code> prongs,2996 <p>When resolving types together, such as {#syntax#}if{#endsyntax#} clauses or {#syntax#}switch{#endsyntax#} prongs,
2997 the <code>noreturn</code> type is compatible with every other type. Consider:2997 the {#syntax#}noreturn{#endsyntax#} type is compatible with every other type. Consider:
2998 </p>2998 </p>
2999 {#code_begin|test#}2999 {#code_begin|test#}
3000fn foo(condition: bool, b: u32) void {3000fn foo(condition: bool, b: u32) void {
...@@ -3005,7 +3005,7 @@ test "noreturn" {...@@ -3005,7 +3005,7 @@ test "noreturn" {
3005 foo(false, 1);3005 foo(false, 1);
3006}3006}
3007 {#code_end#}3007 {#code_end#}
3008 <p>Another use case for <code>noreturn</code> is the <code>exit</code> function:</p>3008 <p>Another use case for {#syntax#}noreturn{#endsyntax#} is the {#syntax#}exit{#endsyntax#} function:</p>
3009 {#code_begin|test#}3009 {#code_begin|test#}
3010 {#target_windows#}3010 {#target_windows#}
3011pub extern "kernel32" stdcallcc fn ExitProcess(exit_code: c_uint) noreturn;3011pub extern "kernel32" stdcallcc fn ExitProcess(exit_code: c_uint) noreturn;
...@@ -3134,7 +3134,7 @@ test "fn reflection" {...@@ -3134,7 +3134,7 @@ test "fn reflection" {
3134 </p>3134 </p>
3135 <p>3135 <p>
3136 The number of unique error values across the entire compilation should determine the size of the error set type.3136 The number of unique error values across the entire compilation should determine the size of the error set type.
3137 However right now it is hard coded to be a <code>u16</code>. See <a href="https://github.com/ziglang/zig/issues/786">#768</a>.3137 However right now it is hard coded to be a {#syntax#}u16{#endsyntax#}. See <a href="https://github.com/ziglang/zig/issues/786">#768</a>.
3138 </p>3138 </p>
3139 <p>3139 <p>
3140 You can {#link|implicitly cast|Implicit Casts#} an error from a subset to its superset:3140 You can {#link|implicitly cast|Implicit Casts#} an error from a subset to its superset:
...@@ -3197,7 +3197,7 @@ const err = (error {FileNotFound}).FileNotFound;...@@ -3197,7 +3197,7 @@ const err = (error {FileNotFound}).FileNotFound;
3197 This becomes useful when using {#link|Inferred Error Sets#}.3197 This becomes useful when using {#link|Inferred Error Sets#}.
3198 </p>3198 </p>
3199 {#header_open|The Global Error Set#}3199 {#header_open|The Global Error Set#}
3200 <p><code>error</code> refers to the global error set.3200 <p>{#syntax#}error{#endsyntax#} refers to the global error set.
3201 This is the error set that contains all errors in the entire compilation unit.3201 This is the error set that contains all errors in the entire compilation unit.
3202 It is a superset of all other error sets and a subset of none of them.3202 It is a superset of all other error sets and a subset of none of them.
3203 </p>3203 </p>
...@@ -3216,7 +3216,7 @@ const err = (error {FileNotFound}).FileNotFound;...@@ -3216,7 +3216,7 @@ const err = (error {FileNotFound}).FileNotFound;
3216 {#header_close#}3216 {#header_close#}
3217 {#header_open|Error Union Type#}3217 {#header_open|Error Union Type#}
3218 <p>3218 <p>
3219 An error set type and normal type can be combined with the <code>!</code>3219 An error set type and normal type can be combined with the {#syntax#}!{#endsyntax#}
3220 binary operator to form an error union type. You are likely to use an3220 binary operator to form an error union type. You are likely to use an
3221 error union type more often than an error set type by itself.3221 error union type more often than an error set type by itself.
3222 </p>3222 </p>
...@@ -3263,14 +3263,14 @@ test "parse u64" {...@@ -3263,14 +3263,14 @@ test "parse u64" {
3263}3263}
3264 {#code_end#}3264 {#code_end#}
3265 <p>3265 <p>
3266 Notice the return type is <code>!u64</code>. This means that the function3266 Notice the return type is {#syntax#}!u64{#endsyntax#}. This means that the function
3267 either returns an unsigned 64 bit integer, or an error. We left off the error set3267 either returns an unsigned 64 bit integer, or an error. We left off the error set
3268 to the left of the <code>!</code>, so the error set is inferred.3268 to the left of the {#syntax#}!{#endsyntax#}, so the error set is inferred.
3269 </p>3269 </p>
3270 <p>3270 <p>
3271 Within the function definition, you can see some return statements that return3271 Within the function definition, you can see some return statements that return
3272 an error, and at the bottom a return statement that returns a <code>u64</code>.3272 an error, and at the bottom a return statement that returns a {#syntax#}u64{#endsyntax#}.
3273 Both types {#link|implicitly cast|Implicit Casts#} to <code>error!u64</code>.3273 Both types {#link|implicitly cast|Implicit Casts#} to {#syntax#}error!u64{#endsyntax#}.
3274 </p>3274 </p>
3275 <p>3275 <p>
3276 What it looks like to use this function varies depending on what you're3276 What it looks like to use this function varies depending on what you're
...@@ -3283,7 +3283,7 @@ test "parse u64" {...@@ -3283,7 +3283,7 @@ test "parse u64" {
3283 <li>You want to take a different action for each possible error.</li>3283 <li>You want to take a different action for each possible error.</li>
3284 </ul>3284 </ul>
3285 {#header_open|catch#}3285 {#header_open|catch#}
3286 <p>If you want to provide a default value, you can use the <code>catch</code> binary operator:</p>3286 <p>If you want to provide a default value, you can use the {#syntax#}catch{#endsyntax#} binary operator:</p>
3287 {#code_begin|syntax#}3287 {#code_begin|syntax#}
3288fn doAThing(str: []u8) void {3288fn doAThing(str: []u8) void {
3289 const number = parseU64(str, 10) catch 13;3289 const number = parseU64(str, 10) catch 13;
...@@ -3291,9 +3291,9 @@ fn doAThing(str: []u8) void {...@@ -3291,9 +3291,9 @@ fn doAThing(str: []u8) void {
3291}3291}
3292 {#code_end#}3292 {#code_end#}
3293 <p>3293 <p>
3294 In this code, <code>number</code> will be equal to the successfully parsed string, or3294 In this code, {#syntax#}number{#endsyntax#} will be equal to the successfully parsed string, or
3295 a default value of 13. The type of the right hand side of the binary <code>catch</code> operator must3295 a default value of 13. The type of the right hand side of the binary {#syntax#}catch{#endsyntax#} operator must
3296 match the unwrapped error union type, or be of type <code>noreturn</code>.3296 match the unwrapped error union type, or be of type {#syntax#}noreturn{#endsyntax#}.
3297 </p>3297 </p>
3298 {#header_close#}3298 {#header_close#}
3299 {#header_open|try#}3299 {#header_open|try#}
...@@ -3306,7 +3306,7 @@ fn doAThing(str: []u8) !void {...@@ -3306,7 +3306,7 @@ fn doAThing(str: []u8) !void {
3306}3306}
3307 {#code_end#}3307 {#code_end#}
3308 <p>3308 <p>
3309 There is a shortcut for this. The <code>try</code> expression:3309 There is a shortcut for this. The {#syntax#}try{#endsyntax#} expression:
3310 </p>3310 </p>
3311 {#code_begin|syntax#}3311 {#code_begin|syntax#}
3312fn doAThing(str: []u8) !void {3312fn doAThing(str: []u8) !void {
...@@ -3315,7 +3315,7 @@ fn doAThing(str: []u8) !void {...@@ -3315,7 +3315,7 @@ fn doAThing(str: []u8) !void {
3315}3315}
3316 {#code_end#}3316 {#code_end#}
3317 <p>3317 <p>
3318 <code>try</code> evaluates an error union expression. If it is an error, it returns3318 {#syntax#}try{#endsyntax#} evaluates an error union expression. If it is an error, it returns
3319 from the current function with the same error. Otherwise, the expression results in3319 from the current function with the same error. Otherwise, the expression results in
3320 the unwrapped value.3320 the unwrapped value.
3321 </p>3321 </p>
...@@ -3327,7 +3327,7 @@ fn doAThing(str: []u8) !void {...@@ -3327,7 +3327,7 @@ fn doAThing(str: []u8) !void {
3327 {#code_begin|syntax#}const number = parseU64("1234", 10) catch unreachable;{#code_end#}3327 {#code_begin|syntax#}const number = parseU64("1234", 10) catch unreachable;{#code_end#}
3328 <p>3328 <p>
3329 Here we know for sure that "1234" will parse successfully. So we put the3329 Here we know for sure that "1234" will parse successfully. So we put the
3330 <code>unreachable</code> value on the right hand side. <code>unreachable</code> generates3330 {#syntax#}unreachable{#endsyntax#} value on the right hand side. {#syntax#}unreachable{#endsyntax#} generates
3331 a panic in Debug and ReleaseSafe modes and undefined behavior in ReleaseFast mode. So, while we're debugging the3331 a panic in Debug and ReleaseSafe modes and undefined behavior in ReleaseFast mode. So, while we're debugging the
3332 application, if there <em>was</em> a surprise error here, the application would crash3332 application, if there <em>was</em> a surprise error here, the application would crash
3333 appropriately.3333 appropriately.
...@@ -3352,7 +3352,7 @@ fn doAThing(str: []u8) void {...@@ -3352,7 +3352,7 @@ fn doAThing(str: []u8) void {
3352 {#header_open|errdefer#}3352 {#header_open|errdefer#}
3353 <p>3353 <p>
3354 The other component to error handling is defer statements.3354 The other component to error handling is defer statements.
3355 In addition to an unconditional {#link|defer#}, Zig has <code>errdefer</code>,3355 In addition to an unconditional {#link|defer#}, Zig has {#syntax#}errdefer{#endsyntax#},
3356 which evaluates the deferred expression on block exit path if and only if3356 which evaluates the deferred expression on block exit path if and only if
3357 the function returned with an error from the block.3357 the function returned with an error from the block.
3358 </p>3358 </p>
...@@ -3390,7 +3390,7 @@ fn createFoo(param: i32) !Foo {...@@ -3390,7 +3390,7 @@ fn createFoo(param: i32) !Foo {
3390 <ul>3390 <ul>
3391 <li>These primitives give enough expressiveness that it's completely practical3391 <li>These primitives give enough expressiveness that it's completely practical
3392 to have failing to check for an error be a compile error. If you really want3392 to have failing to check for an error be a compile error. If you really want
3393 to ignore the error, you can add <code>catch unreachable</code> and3393 to ignore the error, you can add {#syntax#}catch unreachable{#endsyntax#} and
3394 get the added benefit of crashing in Debug and ReleaseSafe modes if your assumption was wrong.3394 get the added benefit of crashing in Debug and ReleaseSafe modes if your assumption was wrong.
3395 </li>3395 </li>
3396 <li>3396 <li>
...@@ -3401,7 +3401,7 @@ fn createFoo(param: i32) !Foo {...@@ -3401,7 +3401,7 @@ fn createFoo(param: i32) !Foo {
3401 </ul>3401 </ul>
3402 {#see_also|defer|if|switch#}3402 {#see_also|defer|if|switch#}
34033403
3404 <p>An error union is created with the <code>!</code> binary operator.3404 <p>An error union is created with the {#syntax#}!{#endsyntax#} binary operator.
3405 You can use compile-time reflection to access the child type of an error union:</p>3405 You can use compile-time reflection to access the child type of an error union:</p>
3406 {#code_begin|test#}3406 {#code_begin|test#}
3407const assert = @import("std").debug.assert;3407const assert = @import("std").debug.assert;
...@@ -3424,15 +3424,15 @@ test "error union" {...@@ -3424,15 +3424,15 @@ test "error union" {
3424 {#code_end#}3424 {#code_end#}
3425 {#header_open|Merging Error Sets#}3425 {#header_open|Merging Error Sets#}
3426 <p>3426 <p>
3427 Use the <code>||</code> operator to merge two error sets together. The resulting3427 Use the {#syntax#}||{#endsyntax#} operator to merge two error sets together. The resulting
3428 error set contains the errors of both error sets. Doc comments from the left-hand3428 error set contains the errors of both error sets. Doc comments from the left-hand
3429 side override doc comments from the right-hand side. In this example, the doc3429 side override doc comments from the right-hand side. In this example, the doc
3430 comments for <code>C.PathNotFound</code> is <code>A doc comment</code>.3430 comments for {#syntax#}C.PathNotFound{#endsyntax#} is <code>A doc comment</code>.
3431 </p>3431 </p>
3432 <p>3432 <p>
3433 This is especially useful for functions which return different error sets depending3433 This is especially useful for functions which return different error sets depending
3434 on {#link|comptime#} branches. For example, the Zig standard library uses3434 on {#link|comptime#} branches. For example, the Zig standard library uses
3435 <code>LinuxFileOpenError || WindowsFileOpenError</code> for the error set of opening3435 {#syntax#}LinuxFileOpenError || WindowsFileOpenError{#endsyntax#} for the error set of opening
3436 files.3436 files.
3437 </p>3437 </p>
3438 {#code_begin|test#}3438 {#code_begin|test#}
...@@ -3565,8 +3565,8 @@ fn bang2() !void {...@@ -3565,8 +3565,8 @@ fn bang2() !void {
3565 Look closely at this example. This is no stack trace.3565 Look closely at this example. This is no stack trace.
3566 </p>3566 </p>
3567 <p>3567 <p>
3568 You can see that the final error bubbled up was <code>PermissionDenied</code>,3568 You can see that the final error bubbled up was {#syntax#}PermissionDenied{#endsyntax#},
3569 but the original error that started this whole thing was <code>FileNotFound</code>. In the <code>bar</code> function, the code handles the original error code,3569 but the original error that started this whole thing was {#syntax#}FileNotFound{#endsyntax#}. In the {#syntax#}bar{#endsyntax#} function, the code handles the original error code,
3570 and then returns another one, from the switch statement. Error Return Traces make this clear, whereas a stack trace would look like this:3570 and then returns another one, from the switch statement. Error Return Traces make this clear, whereas a stack trace would look like this:
3571 </p>3571 </p>
3572 {#code_begin|exe_err#}3572 {#code_begin|exe_err#}
...@@ -3612,7 +3612,7 @@ fn bang2() void {...@@ -3612,7 +3612,7 @@ fn bang2() void {
3612 {#code_end#}3612 {#code_end#}
3613 <p>3613 <p>
3614 Here, the stack trace does not explain how the control3614 Here, the stack trace does not explain how the control
3615 flow in <code>bar</code> got to the <code>hello()</code> call.3615 flow in {#syntax#}bar{#endsyntax#} got to the {#syntax#}hello(){#endsyntax#} call.
3616 One would have to open a debugger or further instrument the application3616 One would have to open a debugger or further instrument the application
3617 in order to find out. The error return trace, on the other hand, 3617 in order to find out. The error return trace, on the other hand,
3618 shows exactly how the error bubbled up.3618 shows exactly how the error bubbled up.
...@@ -3631,8 +3631,8 @@ fn bang2() void {...@@ -3631,8 +3631,8 @@ fn bang2() void {
3631 </p>3631 </p>
3632 <ul>3632 <ul>
3633 <li>Return an error from main</li>3633 <li>Return an error from main</li>
3634 <li>An error makes its way to <code>catch unreachable</code> and you have not overridden the default panic handler</li>3634 <li>An error makes its way to {#syntax#}catch unreachable{#endsyntax#} and you have not overridden the default panic handler</li>
3635 <li>Use {#link|errorReturnTrace#} to access the current return trace. You can use <code>std.debug.dumpStackTrace</code> to print it. This function returns comptime-known {#link|null#} when building without error return tracing support.</li>3635 <li>Use {#link|errorReturnTrace#} to access the current return trace. You can use {#syntax#}std.debug.dumpStackTrace{#endsyntax#} to print it. This function returns comptime-known {#link|null#} when building without error return tracing support.</li>
3636 </ul>3636 </ul>
3637 {#header_open|Implementation Details#}3637 {#header_open|Implementation Details#}
3638 <p>3638 <p>
...@@ -3643,7 +3643,7 @@ fn bang2() void {...@@ -3643,7 +3643,7 @@ fn bang2() void {
3643 <li>when returning errors</li>3643 <li>when returning errors</li>
3644 </ul>3644 </ul>
3645 <p>3645 <p>
3646 For the case when no errors are returned, the cost is a single memory write operation, only in the first non-failable function in the call graph that calls a failable function, i.e. when a function returning <code>void</code> calls a function returning <code>error</code>.3646 For the case when no errors are returned, the cost is a single memory write operation, only in the first non-failable function in the call graph that calls a failable function, i.e. when a function returning {#syntax#}void{#endsyntax#} calls a function returning {#syntax#}error{#endsyntax#}.
3647 This is to initialize this struct in the stack memory:3647 This is to initialize this struct in the stack memory:
3648 </p>3648 </p>
3649 {#code_begin|syntax#}3649 {#code_begin|syntax#}
...@@ -3656,13 +3656,13 @@ pub const StackTrace = struct {...@@ -3656,13 +3656,13 @@ pub const StackTrace = struct {
3656 Here, N is the maximum function call depth as determined by call graph analysis. Recursion is ignored and counts for 2.3656 Here, N is the maximum function call depth as determined by call graph analysis. Recursion is ignored and counts for 2.
3657 </p>3657 </p>
3658 <p>3658 <p>
3659 A pointer to <code>StackTrace</code> is passed as a secret parameter to every function that can return an error, but it's always the first parameter, so it can likely sit in a register and stay there.3659 A pointer to {#syntax#}StackTrace{#endsyntax#} is passed as a secret parameter to every function that can return an error, but it's always the first parameter, so it can likely sit in a register and stay there.
3660 </p>3660 </p>
3661 <p>3661 <p>
3662 That's it for the path when no errors occur. It's practically free in terms of performance.3662 That's it for the path when no errors occur. It's practically free in terms of performance.
3663 </p>3663 </p>
3664 <p>3664 <p>
3665 When generating the code for a function that returns an error, just before the <code>return</code> statement (only for the <code>return</code> statements that return errors), Zig generates a call to this function:3665 When generating the code for a function that returns an error, just before the {#syntax#}return{#endsyntax#} statement (only for the {#syntax#}return{#endsyntax#} statements that return errors), Zig generates a call to this function:
3666 </p>3666 </p>
3667 {#code_begin|syntax#}3667 {#code_begin|syntax#}
3668// marked as "no-inline" in LLVM IR3668// marked as "no-inline" in LLVM IR
...@@ -3677,7 +3677,7 @@ fn __zig_return_error(stack_trace: *StackTrace) void {...@@ -3677,7 +3677,7 @@ fn __zig_return_error(stack_trace: *StackTrace) void {
3677 <p>3677 <p>
3678 As for code size cost, 1 function call before a return statement is no big deal. Even so,3678 As for code size cost, 1 function call before a return statement is no big deal. Even so,
3679 I have <a href="https://github.com/ziglang/zig/issues/690">a plan</a> to make the call to3679 I have <a href="https://github.com/ziglang/zig/issues/690">a plan</a> to make the call to
3680 <code>__zig_return_error</code> a tail call, which brings the code size cost down to actually zero. What is a return statement in code without error return tracing can become a jump instruction in code with error return tracing.3680 {#syntax#}__zig_return_error{#endsyntax#} a tail call, which brings the code size cost down to actually zero. What is a return statement in code without error return tracing can become a jump instruction in code with error return tracing.
3681 </p>3681 </p>
3682 {#header_close#}3682 {#header_close#}
3683 {#header_close#}3683 {#header_close#}
...@@ -3699,7 +3699,7 @@ const normal_int: i32 = 1234;...@@ -3699,7 +3699,7 @@ const normal_int: i32 = 1234;
3699const optional_int: ?i32 = 5678;3699const optional_int: ?i32 = 5678;
3700 {#code_end#}3700 {#code_end#}
3701 <p>3701 <p>
3702 Now the variable <code>optional_int</code> could be an <code>i32</code>, or <code>null</code>.3702 Now the variable {#syntax#}optional_int{#endsyntax#} could be an {#syntax#}i32{#endsyntax#}, or {#syntax#}null{#endsyntax#}.
3703 </p>3703 </p>
3704 <p>3704 <p>
3705 Instead of integers, let's talk about pointers. Null references are the source of many runtime3705 Instead of integers, let's talk about pointers. Null references are the source of many runtime
...@@ -3740,8 +3740,8 @@ fn doAThing() ?*Foo {...@@ -3740,8 +3740,8 @@ fn doAThing() ?*Foo {
3740 {#code_end#}3740 {#code_end#}
3741 <p>3741 <p>
3742 Here, Zig is at least as convenient, if not more, than C. And, the type of "ptr"3742 Here, Zig is at least as convenient, if not more, than C. And, the type of "ptr"
3743 is <code>*u8</code> <em>not</em> <code>?*u8</code>. The <code>orelse</code> keyword3743 is {#syntax#}*u8{#endsyntax#} <em>not</em> {#syntax#}?*u8{#endsyntax#}. The {#syntax#}orelse{#endsyntax#} keyword
3744 unwrapped the optional type and therefore <code>ptr</code> is guaranteed to be non-null everywhere3744 unwrapped the optional type and therefore {#syntax#}ptr{#endsyntax#} is guaranteed to be non-null everywhere
3745 it is used in the function.3745 it is used in the function.
3746 </p>3746 </p>
3747 <p>3747 <p>
...@@ -3772,7 +3772,7 @@ fn doAThing(optional_foo: ?*Foo) void {...@@ -3772,7 +3772,7 @@ fn doAThing(optional_foo: ?*Foo) void {
3772 {#code_end#}3772 {#code_end#}
3773 <p>3773 <p>
3774 Once again, the notable thing here is that inside the if block,3774 Once again, the notable thing here is that inside the if block,
3775 <code>foo</code> is no longer an optional pointer, it is a pointer, which3775 {#syntax#}foo{#endsyntax#} is no longer an optional pointer, it is a pointer, which
3776 cannot be null.3776 cannot be null.
3777 </p>3777 </p>
3778 <p>3778 <p>
...@@ -3783,7 +3783,7 @@ fn doAThing(optional_foo: ?*Foo) void {...@@ -3783,7 +3783,7 @@ fn doAThing(optional_foo: ?*Foo) void {
3783 cannot be null.3783 cannot be null.
3784 </p>3784 </p>
3785 {#header_open|Optional Type#}3785 {#header_open|Optional Type#}
3786 <p>An optional is created by putting <code>?</code> in front of a type. You can use compile-time3786 <p>An optional is created by putting {#syntax#}?{#endsyntax#} in front of a type. You can use compile-time
3787 reflection to access the child type of an optional:</p>3787 reflection to access the child type of an optional:</p>
3788 {#code_begin|test#}3788 {#code_begin|test#}
3789const assert = @import("std").debug.assert;3789const assert = @import("std").debug.assert;
...@@ -3802,7 +3802,7 @@ test "optional type" {...@@ -3802,7 +3802,7 @@ test "optional type" {
3802 {#header_close#}3802 {#header_close#}
3803 {#header_open|null#}3803 {#header_open|null#}
3804 <p>3804 <p>
3805 Just like {#link|undefined#}, <code>null</code> has its own type, and the only way to use it is to3805 Just like {#link|undefined#}, {#syntax#}null{#endsyntax#} has its own type, and the only way to use it is to
3806 cast it to a different type:3806 cast it to a different type:
3807 </p>3807 </p>
3808 {#code_begin|syntax#}3808 {#code_begin|syntax#}
...@@ -3850,9 +3850,9 @@ test "implicit cast - invoke a type as a function" {...@@ -3850,9 +3850,9 @@ test "implicit cast - invoke a type as a function" {
3850 of the qualifiers, no matter how nested the qualifiers are:3850 of the qualifiers, no matter how nested the qualifiers are:
3851 </p>3851 </p>
3852 <ul>3852 <ul>
3853 <li><code>const</code> - non-const to const is allowed</li>3853 <li>{#syntax#}const{#endsyntax#} - non-const to const is allowed</li>
3854 <li><code>volatile</code> - non-volatile to volatile is allowed</li>3854 <li>{#syntax#}volatile{#endsyntax#} - non-volatile to volatile is allowed</li>
3855 <li><code>align</code> - bigger to smaller alignment is allowed </li>3855 <li>{#syntax#}align{#endsyntax#} - bigger to smaller alignment is allowed </li>
3856 <li>{#link|error sets|Error Set Type#} to supersets is allowed</li>3856 <li>{#link|error sets|Error Set Type#} to supersets is allowed</li>
3857 </ul>3857 </ul>
3858 <p>3858 <p>
...@@ -4100,7 +4100,7 @@ fn peerTypeEmptyArrayAndSliceAndError(a: bool, slice: []u8) error![]u8 {...@@ -4100,7 +4100,7 @@ fn peerTypeEmptyArrayAndSliceAndError(a: bool, slice: []u8) error![]u8 {
41004100
4101 {#header_open|void#}4101 {#header_open|void#}
4102 <p>4102 <p>
4103 <code>void</code> represents a type that has no value. Code that makes use of void values is4103 {#syntax#}void{#endsyntax#} represents a type that has no value. Code that makes use of void values is
4104 not included in the final generated code:4104 not included in the final generated code:
4105 </p>4105 </p>
4106 {#code_begin|syntax#}4106 {#code_begin|syntax#}
...@@ -4110,7 +4110,7 @@ export fn entry() void {...@@ -4110,7 +4110,7 @@ export fn entry() void {
4110 x = y;4110 x = y;
4111}4111}
4112 {#code_end#}4112 {#code_end#}
4113 <p>When this turns into LLVM IR, there is no code generated in the body of <code>entry</code>,4113 <p>When this turns into LLVM IR, there is no code generated in the body of {#syntax#}entry{#endsyntax#},
4114 even in debug mode. For example, on x86_64:</p>4114 even in debug mode. For example, on x86_64:</p>
4115 <pre><code>0000000000000010 &lt;entry&gt;:4115 <pre><code>0000000000000010 &lt;entry&gt;:
4116 10: 55 push %rbp4116 10: 55 push %rbp
...@@ -4120,9 +4120,9 @@ export fn entry() void {...@@ -4120,9 +4120,9 @@ export fn entry() void {
4120 <p>These assembly instructions do not have any code associated with the void values -4120 <p>These assembly instructions do not have any code associated with the void values -
4121 they only perform the function call prologue and epilog.</p>4121 they only perform the function call prologue and epilog.</p>
4122 <p>4122 <p>
4123 <code>void</code> can be useful for instantiating generic types. For example, given a4123 {#syntax#}void{#endsyntax#} can be useful for instantiating generic types. For example, given a
4124 <code>Map(Key, Value)</code>, one can pass <code>void</code> for the <code>Value</code>4124 {#syntax#}Map(Key, Value){#endsyntax#}, one can pass {#syntax#}void{#endsyntax#} for the {#syntax#}Value{#endsyntax#}
4125 type to make it into a <code>Set</code>:4125 type to make it into a {#syntax#}Set{#endsyntax#}:
4126 </p>4126 </p>
4127 {#code_begin|test#}4127 {#code_begin|test#}
4128const std = @import("std");4128const std = @import("std");
...@@ -4151,17 +4151,17 @@ fn eql_i32(a: i32, b: i32) bool {...@@ -4151,17 +4151,17 @@ fn eql_i32(a: i32, b: i32) bool {
4151}4151}
4152 {#code_end#}4152 {#code_end#}
4153 <p>Note that this is different than using a dummy value for the hash map value.4153 <p>Note that this is different than using a dummy value for the hash map value.
4154 By using <code>void</code> as the type of the value, the hash map entry type has no value field, and4154 By using {#syntax#}void{#endsyntax#} as the type of the value, the hash map entry type has no value field, and
4155 thus the hash map takes up less space. Further, all the code that deals with storing and loading the4155 thus the hash map takes up less space. Further, all the code that deals with storing and loading the
4156 value is deleted, as seen above.4156 value is deleted, as seen above.
4157 </p>4157 </p>
4158 <p>4158 <p>
4159 <code>void</code> is distinct from <code>c_void</code>, which is defined like this:4159 {#syntax#}void{#endsyntax#} is distinct from {#syntax#}c_void{#endsyntax#}, which is defined like this:
4160 <code>pub const c_void = @OpaqueType();</code>.4160 {#syntax#}pub const c_void = @OpaqueType();{#endsyntax#}.
4161 <code>void</code> has a known size of 0 bytes, and <code>c_void</code> has an unknown, but non-zero, size.4161 {#syntax#}void{#endsyntax#} has a known size of 0 bytes, and {#syntax#}c_void{#endsyntax#} has an unknown, but non-zero, size.
4162 </p>4162 </p>
4163 <p>4163 <p>
4164 Expressions of type <code>void</code> are the only ones whose value can be ignored. For example:4164 Expressions of type {#syntax#}void{#endsyntax#} are the only ones whose value can be ignored. For example:
4165 </p>4165 </p>
4166 {#code_begin|test_err|expression value is ignored#}4166 {#code_begin|test_err|expression value is ignored#}
4167test "ignoring expression value" {4167test "ignoring expression value" {
...@@ -4172,7 +4172,7 @@ fn foo() i32 {...@@ -4172,7 +4172,7 @@ fn foo() i32 {
4172 return 1234;4172 return 1234;
4173}4173}
4174 {#code_end#}4174 {#code_end#}
4175 <p>However, if the expression has type <code>void</code>:</p>4175 <p>However, if the expression has type {#syntax#}void{#endsyntax#}:</p>
4176 {#code_begin|test#}4176 {#code_begin|test#}
4177test "ignoring expression value" {4177test "ignoring expression value" {
4178 foo();4178 foo();
...@@ -4207,10 +4207,10 @@ fn gimmeTheBiggerInteger(a: u64, b: u64) u64 {...@@ -4207,10 +4207,10 @@ fn gimmeTheBiggerInteger(a: u64, b: u64) u64 {
4207 <p>4207 <p>
4208 In Zig, types are first-class citizens. They can be assigned to variables, passed as parameters to functions,4208 In Zig, types are first-class citizens. They can be assigned to variables, passed as parameters to functions,
4209 and returned from functions. However, they can only be used in expressions which are known at <em>compile-time</em>,4209 and returned from functions. However, they can only be used in expressions which are known at <em>compile-time</em>,
4210 which is why the parameter <code>T</code> in the above snippet must be marked with <code>comptime</code>.4210 which is why the parameter {#syntax#}T{#endsyntax#} in the above snippet must be marked with {#syntax#}comptime{#endsyntax#}.
4211 </p>4211 </p>
4212 <p>4212 <p>
4213 A <code>comptime</code> parameter means that:4213 A {#syntax#}comptime{#endsyntax#} parameter means that:
4214 </p>4214 </p>
4215 <ul>4215 <ul>
4216 <li>At the callsite, the value must be known at compile-time, or it is a compile error.</li>4216 <li>At the callsite, the value must be known at compile-time, or it is a compile error.</li>
...@@ -4255,7 +4255,7 @@ test "try to compare bools" {...@@ -4255,7 +4255,7 @@ test "try to compare bools" {
4255}4255}
4256 {#code_end#}4256 {#code_end#}
4257 <p>4257 <p>
4258 On the flip side, inside the function definition with the <code>comptime</code> parameter, the4258 On the flip side, inside the function definition with the {#syntax#}comptime{#endsyntax#} parameter, the
4259 value is known at compile-time. This means that we actually could make this work for the bool type4259 value is known at compile-time. This means that we actually could make this work for the bool type
4260 if we wanted to:4260 if we wanted to:
4261 </p>4261 </p>
...@@ -4274,12 +4274,12 @@ test "try to compare bools" {...@@ -4274,12 +4274,12 @@ test "try to compare bools" {
4274}4274}
4275 {#code_end#}4275 {#code_end#}
4276 <p>4276 <p>
4277 This works because Zig implicitly inlines <code>if</code> expressions when the condition4277 This works because Zig implicitly inlines {#syntax#}if{#endsyntax#} expressions when the condition
4278 is known at compile-time, and the compiler guarantees that it will skip analysis of4278 is known at compile-time, and the compiler guarantees that it will skip analysis of
4279 the branch not taken.4279 the branch not taken.
4280 </p>4280 </p>
4281 <p>4281 <p>
4282 This means that the actual function generated for <code>max</code> in this situation looks like4282 This means that the actual function generated for {#syntax#}max{#endsyntax#} in this situation looks like
4283 this:4283 this:
4284 </p>4284 </p>
4285 {#code_begin|syntax#}4285 {#code_begin|syntax#}
...@@ -4292,18 +4292,18 @@ fn max(a: bool, b: bool) bool {...@@ -4292,18 +4292,18 @@ fn max(a: bool, b: bool) bool {
4292 the necessary run-time code to accomplish the task.4292 the necessary run-time code to accomplish the task.
4293 </p>4293 </p>
4294 <p>4294 <p>
4295 This works the same way for <code>switch</code> expressions - they are implicitly inlined4295 This works the same way for {#syntax#}switch{#endsyntax#} expressions - they are implicitly inlined
4296 when the target expression is compile-time known.4296 when the target expression is compile-time known.
4297 </p>4297 </p>
4298 {#header_close#}4298 {#header_close#}
4299 {#header_open|Compile-Time Variables#}4299 {#header_open|Compile-Time Variables#}
4300 <p>4300 <p>
4301 In Zig, the programmer can label variables as <code>comptime</code>. This guarantees to the compiler4301 In Zig, the programmer can label variables as {#syntax#}comptime{#endsyntax#}. This guarantees to the compiler
4302 that every load and store of the variable is performed at compile-time. Any violation of this results in a4302 that every load and store of the variable is performed at compile-time. Any violation of this results in a
4303 compile error.4303 compile error.
4304 </p>4304 </p>
4305 <p>4305 <p>
4306 This combined with the fact that we can <code>inline</code> loops allows us to write4306 This combined with the fact that we can {#syntax#}inline{#endsyntax#} loops allows us to write
4307 a function which is partially evaluated at compile-time and partially at run-time.4307 a function which is partially evaluated at compile-time and partially at run-time.
4308 </p>4308 </p>
4309 <p>4309 <p>
...@@ -4346,8 +4346,8 @@ test "perform fn" {...@@ -4346,8 +4346,8 @@ test "perform fn" {
4346 <p>4346 <p>
4347 This example is a bit contrived, because the compile-time evaluation component is unnecessary;4347 This example is a bit contrived, because the compile-time evaluation component is unnecessary;
4348 this code would work fine if it was all done at run-time. But it does end up generating4348 this code would work fine if it was all done at run-time. But it does end up generating
4349 different code. In this example, the function <code>performFn</code> is generated three different times,4349 different code. In this example, the function {#syntax#}performFn{#endsyntax#} is generated three different times,
4350 for the different values of <code>prefix_char</code> provided:4350 for the different values of {#syntax#}prefix_char{#endsyntax#} provided:
4351 </p>4351 </p>
4352 {#code_begin|syntax#}4352 {#code_begin|syntax#}
4353// From the line:4353// From the line:
...@@ -4388,7 +4388,7 @@ fn performFn(start_value: i32) i32 {...@@ -4388,7 +4388,7 @@ fn performFn(start_value: i32) i32 {
4388 {#header_open|Compile-Time Expressions#}4388 {#header_open|Compile-Time Expressions#}
4389 <p>4389 <p>
4390 In Zig, it matters whether a given expression is known at compile-time or run-time. A programmer can4390 In Zig, it matters whether a given expression is known at compile-time or run-time. A programmer can
4391 use a <code>comptime</code> expression to guarantee that the expression will be evaluated at compile-time.4391 use a {#syntax#}comptime{#endsyntax#} expression to guarantee that the expression will be evaluated at compile-time.
4392 If this cannot be accomplished, the compiler will emit an error. For example:4392 If this cannot be accomplished, the compiler will emit an error. For example:
4393 </p>4393 </p>
4394 {#code_begin|test_err|unable to evaluate constant expression#}4394 {#code_begin|test_err|unable to evaluate constant expression#}
...@@ -4401,16 +4401,16 @@ test "foo" {...@@ -4401,16 +4401,16 @@ test "foo" {
4401}4401}
4402 {#code_end#}4402 {#code_end#}
4403 <p>4403 <p>
4404 It doesn't make sense that a program could call <code>exit()</code> (or any other external function)4404 It doesn't make sense that a program could call {#syntax#}exit(){#endsyntax#} (or any other external function)
4405 at compile-time, so this is a compile error. However, a <code>comptime</code> expression does much4405 at compile-time, so this is a compile error. However, a {#syntax#}comptime{#endsyntax#} expression does much
4406 more than sometimes cause a compile error.4406 more than sometimes cause a compile error.
4407 </p>4407 </p>
4408 <p>4408 <p>
4409 Within a <code>comptime</code> expression:4409 Within a {#syntax#}comptime{#endsyntax#} expression:
4410 </p>4410 </p>
4411 <ul>4411 <ul>
4412 <li>All variables are <code>comptime</code> variables.</li>4412 <li>All variables are {#syntax#}comptime{#endsyntax#} variables.</li>
4413 <li>All <code>if</code>, <code>while</code>, <code>for</code>, and <code>switch</code>4413 <li>All {#syntax#}if{#endsyntax#}, {#syntax#}while{#endsyntax#}, {#syntax#}for{#endsyntax#}, and {#syntax#}switch{#endsyntax#}
4414 expressions are evaluated at compile-time, or emit a compile error if this is not possible.</li>4414 expressions are evaluated at compile-time, or emit a compile error if this is not possible.</li>
4415 <li>All function calls cause the compiler to interpret the function at compile-time, emitting a4415 <li>All function calls cause the compiler to interpret the function at compile-time, emitting a
4416 compile error if the function tries to do something that has global run-time side effects.</li>4416 compile error if the function tries to do something that has global run-time side effects.</li>
...@@ -4487,7 +4487,7 @@ test "fibonacci" {...@@ -4487,7 +4487,7 @@ test "fibonacci" {
4487 {#link|@setEvalBranchQuota#} to change the default number 1000 to something else.4487 {#link|@setEvalBranchQuota#} to change the default number 1000 to something else.
4488 </p>4488 </p>
4489 <p>4489 <p>
4490 What if we fix the base case, but put the wrong value in the <code>assert</code> line?4490 What if we fix the base case, but put the wrong value in the {#syntax#}assert{#endsyntax#} line?
4491 </p>4491 </p>
4492 {#code_begin|test_err|encountered @panic at compile-time#}4492 {#code_begin|test_err|encountered @panic at compile-time#}
4493const assert = @import("std").debug.assert;4493const assert = @import("std").debug.assert;
...@@ -4504,16 +4504,16 @@ test "fibonacci" {...@@ -4504,16 +4504,16 @@ test "fibonacci" {
4504}4504}
4505 {#code_end#}4505 {#code_end#}
4506 <p>4506 <p>
4507 What happened is Zig started interpreting the <code>assert</code> function with the4507 What happened is Zig started interpreting the {#syntax#}assert{#endsyntax#} function with the
4508 parameter <code>ok</code> set to <code>false</code>. When the interpreter hit4508 parameter {#syntax#}ok{#endsyntax#} set to {#syntax#}false{#endsyntax#}. When the interpreter hit
4509 <code>unreachable</code> it emitted a compile error, because reaching unreachable4509 {#syntax#}unreachable{#endsyntax#} it emitted a compile error, because reaching unreachable
4510 code is undefined behavior, and undefined behavior causes a compile error if it is detected4510 code is undefined behavior, and undefined behavior causes a compile error if it is detected
4511 at compile-time.4511 at compile-time.
4512 </p>4512 </p>
45134513
4514 <p>4514 <p>
4515 In the global scope (outside of any function), all expressions are implicitly4515 In the global scope (outside of any function), all expressions are implicitly
4516 <code>comptime</code> expressions. This means that we can use functions to4516 {#syntax#}comptime{#endsyntax#} expressions. This means that we can use functions to
4517 initialize complex static data. For example:4517 initialize complex static data. For example:
4518 </p>4518 </p>
4519 {#code_begin|test#}4519 {#code_begin|test#}
...@@ -4561,7 +4561,7 @@ test "variable values" {...@@ -4561,7 +4561,7 @@ test "variable values" {
4561@1 = internal unnamed_addr constant i32 1060</code></pre>4561@1 = internal unnamed_addr constant i32 1060</code></pre>
4562 <p>4562 <p>
4563 Note that we did not have to do anything special with the syntax of these functions. For example,4563 Note that we did not have to do anything special with the syntax of these functions. For example,
4564 we could call the <code>sum</code> function as is with a slice of numbers whose length and values were4564 we could call the {#syntax#}sum{#endsyntax#} function as is with a slice of numbers whose length and values were
4565 only known at run-time.4565 only known at run-time.
4566 </p>4566 </p>
4567 {#header_close#}4567 {#header_close#}
...@@ -4573,8 +4573,8 @@ test "variable values" {...@@ -4573,8 +4573,8 @@ test "variable values" {
4573 generic data structure.4573 generic data structure.
4574 </p>4574 </p>
4575 <p>4575 <p>
4576 Here is an example of a generic <code>List</code> data structure, that we will instantiate with4576 Here is an example of a generic {#syntax#}List{#endsyntax#} data structure, that we will instantiate with
4577 the type <code>i32</code>. In Zig we refer to the type as <code>List(i32)</code>.4577 the type {#syntax#}i32{#endsyntax#}. In Zig we refer to the type as {#syntax#}List(i32){#endsyntax#}.
4578 </p>4578 </p>
4579 {#code_begin|syntax#}4579 {#code_begin|syntax#}
4580fn List(comptime T: type) type {4580fn List(comptime T: type) type {
...@@ -4585,8 +4585,8 @@ fn List(comptime T: type) type {...@@ -4585,8 +4585,8 @@ fn List(comptime T: type) type {
4585}4585}
4586 {#code_end#}4586 {#code_end#}
4587 <p>4587 <p>
4588 That's it. It's a function that returns an anonymous <code>struct</code>. For the purposes of error messages4588 That's it. It's a function that returns an anonymous {#syntax#}struct{#endsyntax#}. For the purposes of error messages
4589 and debugging, Zig infers the name <code>"List(i32)"</code> from the function name and parameters invoked when creating4589 and debugging, Zig infers the name {#syntax#}"List(i32)"{#endsyntax#} from the function name and parameters invoked when creating
4590 the anonymous struct.4590 the anonymous struct.
4591 </p>4591 </p>
4592 <p>4592 <p>
...@@ -4602,13 +4602,13 @@ const Node = struct {...@@ -4602,13 +4602,13 @@ const Node = struct {
4602 <p>4602 <p>
4603 This works because all top level declarations are order-independent, and as long as there isn't4603 This works because all top level declarations are order-independent, and as long as there isn't
4604 an actual infinite regression, values can refer to themselves, directly or indirectly. In this case,4604 an actual infinite regression, values can refer to themselves, directly or indirectly. In this case,
4605 <code>Node</code> refers to itself as a pointer, which is not actually an infinite regression, so4605 {#syntax#}Node{#endsyntax#} refers to itself as a pointer, which is not actually an infinite regression, so
4606 it works fine.4606 it works fine.
4607 </p>4607 </p>
4608 {#header_close#}4608 {#header_close#}
4609 {#header_open|Case Study: printf in Zig#}4609 {#header_open|Case Study: printf in Zig#}
4610 <p>4610 <p>
4611 Putting all of this together, let's see how <code>printf</code> works in Zig.4611 Putting all of this together, let's see how {#syntax#}printf{#endsyntax#} works in Zig.
4612 </p>4612 </p>
4613 {#code_begin|exe|printf#}4613 {#code_begin|exe|printf#}
4614const warn = @import("std").debug.warn;4614const warn = @import("std").debug.warn;
...@@ -4709,7 +4709,7 @@ pub fn printf(self: *OutStream, arg0: i32, arg1: []const u8) !void {...@@ -4709,7 +4709,7 @@ pub fn printf(self: *OutStream, arg0: i32, arg1: []const u8) !void {
4709}4709}
4710 {#code_end#}4710 {#code_end#}
4711 <p>4711 <p>
4712 <code>printValue</code> is a function that takes a parameter of any type, and does different things depending4712 {#syntax#}printValue{#endsyntax#} is a function that takes a parameter of any type, and does different things depending
4713 on the type:4713 on the type:
4714 </p>4714 </p>
4715 {#code_begin|syntax#}4715 {#code_begin|syntax#}
...@@ -4725,7 +4725,7 @@ pub fn printValue(self: *OutStream, value: var) !void {...@@ -4725,7 +4725,7 @@ pub fn printValue(self: *OutStream, value: var) !void {
4725}4725}
4726 {#code_end#}4726 {#code_end#}
4727 <p>4727 <p>
4728 And now, what happens if we give too many arguments to <code>printf</code>?4728 And now, what happens if we give too many arguments to {#syntax#}printf{#endsyntax#}?
4729 </p>4729 </p>
4730 {#code_begin|test_err|Unused arguments#}4730 {#code_begin|test_err|Unused arguments#}
4731const warn = @import("std").debug.warn;4731const warn = @import("std").debug.warn;
...@@ -4743,7 +4743,7 @@ test "printf too many arguments" {...@@ -4743,7 +4743,7 @@ test "printf too many arguments" {
4743 </p>4743 </p>
4744 <p>4744 <p>
4745 Zig doesn't care whether the format argument is a string literal,4745 Zig doesn't care whether the format argument is a string literal,
4746 only that it is a compile-time known value that is implicitly castable to a <code>[]const u8</code>:4746 only that it is a compile-time known value that is implicitly castable to a {#syntax#}[]const u8{#endsyntax#}:
4747 </p>4747 </p>
4748 {#code_begin|exe|printf#}4748 {#code_begin|exe|printf#}
4749const warn = @import("std").debug.warn;4749const warn = @import("std").debug.warn;
...@@ -4797,16 +4797,16 @@ pub fn main() void {...@@ -4797,16 +4797,16 @@ pub fn main() void {
4797 </p>4797 </p>
4798 {#header_open|Minimal Coroutine Example#}4798 {#header_open|Minimal Coroutine Example#}
4799 <p>4799 <p>
4800 Declare a coroutine with the <code>async</code> keyword.4800 Declare a coroutine with the {#syntax#}async{#endsyntax#} keyword.
4801 The expression in angle brackets must evaluate to a struct4801 The expression in angle brackets must evaluate to a struct
4802 which has these fields:4802 which has these fields:
4803 </p>4803 </p>
4804 <ul>4804 <ul>
4805 <li><code>allocFn: fn (self: *Allocator, byte_count: usize, alignment: u29) Error![]u8</code> - where <code>Error</code> can be any error set.</li>4805 <li>{#syntax#}allocFn: fn (self: *Allocator, byte_count: usize, alignment: u29) Error![]u8{#endsyntax#} - where {#syntax#}Error{#endsyntax#} can be any error set.</li>
4806 <li><code>freeFn: fn (self: *Allocator, old_mem: []u8) void</code></li>4806 <li>{#syntax#}freeFn: fn (self: *Allocator, old_mem: []u8) void{#endsyntax#}</li>
4807 </ul>4807 </ul>
4808 <p>4808 <p>
4809 You may notice that this corresponds to the <code>std.mem.Allocator</code> interface.4809 You may notice that this corresponds to the {#syntax#}std.mem.Allocator{#endsyntax#} interface.
4810 This makes it convenient to integrate with existing allocators. Note, however,4810 This makes it convenient to integrate with existing allocators. Note, however,
4811 that the language feature does not depend on the standard library, and any struct which4811 that the language feature does not depend on the standard library, and any struct which
4812 has these fields is allowed.4812 has these fields is allowed.
...@@ -4816,13 +4816,13 @@ pub fn main() void {...@@ -4816,13 +4816,13 @@ pub fn main() void {
4816 the function generic. Zig will infer the allocator type when the async function is called.4816 the function generic. Zig will infer the allocator type when the async function is called.
4817 </p>4817 </p>
4818 <p>4818 <p>
4819 Call a coroutine with the <code>async</code> keyword. Here, the expression in angle brackets4819 Call a coroutine with the {#syntax#}async{#endsyntax#} keyword. Here, the expression in angle brackets
4820 is a pointer to the allocator struct that the coroutine expects.4820 is a pointer to the allocator struct that the coroutine expects.
4821 </p>4821 </p>
4822 <p>4822 <p>
4823 The result of an async function call is a <code>promise->T</code> type, where <code>T</code>4823 The result of an async function call is a {#syntax#}promise->T{#endsyntax#} type, where {#syntax#}T{#endsyntax#}
4824 is the return type of the async function. Once a promise has been created, it must be4824 is the return type of the async function. Once a promise has been created, it must be
4825 consumed, either with <code>cancel</code> or <code>await</code>:4825 consumed, either with {#syntax#}cancel{#endsyntax#} or {#syntax#}await{#endsyntax#}:
4826 </p>4826 </p>
4827 <p>4827 <p>
4828 Async functions start executing when created, so in the following example, the entire4828 Async functions start executing when created, so in the following example, the entire
...@@ -4911,18 +4911,18 @@ async fn testSuspendBlock() void {...@@ -4911,18 +4911,18 @@ async fn testSuspendBlock() void {
4911 {#code_end#}4911 {#code_end#}
4912 <p>4912 <p>
4913 Every suspend point in an async function represents a point at which the coroutine4913 Every suspend point in an async function represents a point at which the coroutine
4914 could be destroyed. If that happens, <code>defer</code> expressions that are in4914 could be destroyed. If that happens, {#syntax#}defer{#endsyntax#} expressions that are in
4915 scope are run, as well as <code>errdefer</code> expressions.4915 scope are run, as well as {#syntax#}errdefer{#endsyntax#} expressions.
4916 </p>4916 </p>
4917 <p>4917 <p>
4918 {#link|Await#} counts as a suspend point.4918 {#link|Await#} counts as a suspend point.
4919 </p>4919 </p>
4920 {#header_open|Resuming from Suspend Blocks#}4920 {#header_open|Resuming from Suspend Blocks#}
4921 <p>4921 <p>
4922 Upon entering a <code>suspend</code> block, the coroutine is already considered4922 Upon entering a {#syntax#}suspend{#endsyntax#} block, the coroutine is already considered
4923 suspended, and can be resumed. For example, if you started another kernel thread,4923 suspended, and can be resumed. For example, if you started another kernel thread,
4924 and had that thread call <code>resume</code> on the promise handle provided by the4924 and had that thread call {#syntax#}resume{#endsyntax#} on the promise handle provided by the
4925 <code>suspend</code> block, the new thread would begin executing after the suspend4925 {#syntax#}suspend{#endsyntax#} block, the new thread would begin executing after the suspend
4926 block, while the old thread continued executing the suspend block.4926 block, while the old thread continued executing the suspend block.
4927 </p>4927 </p>
4928 <p>4928 <p>
...@@ -4957,26 +4957,26 @@ async fn testResumeFromSuspend(my_result: *i32) void {...@@ -4957,26 +4957,26 @@ async fn testResumeFromSuspend(my_result: *i32) void {
4957 {#header_close#}4957 {#header_close#}
4958 {#header_open|Await#}4958 {#header_open|Await#}
4959 <p>4959 <p>
4960 The <code>await</code> keyword is used to coordinate with an async function's4960 The {#syntax#}await{#endsyntax#} keyword is used to coordinate with an async function's
4961 <code>return</code> statement.4961 {#syntax#}return{#endsyntax#} statement.
4962 </p>4962 </p>
4963 <p>4963 <p>
4964 <code>await</code> is valid only in an <code>async</code> function, and it takes4964 {#syntax#}await{#endsyntax#} is valid only in an {#syntax#}async{#endsyntax#} function, and it takes
4965 as an operand a promise handle.4965 as an operand a promise handle.
4966 If the async function associated with the promise handle has already returned, 4966 If the async function associated with the promise handle has already returned,
4967 then <code>await</code> destroys the target async function, and gives the return value.4967 then {#syntax#}await{#endsyntax#} destroys the target async function, and gives the return value.
4968 Otherwise, <code>await</code> suspends the current async function, registering its4968 Otherwise, {#syntax#}await{#endsyntax#} suspends the current async function, registering its
4969 promise handle with the target coroutine. It becomes the target coroutine's responsibility4969 promise handle with the target coroutine. It becomes the target coroutine's responsibility
4970 to have ensured that it will be resumed or destroyed. When the target coroutine reaches4970 to have ensured that it will be resumed or destroyed. When the target coroutine reaches
4971 its return statement, it gives the return value to the awaiter, destroys itself, and then4971 its return statement, it gives the return value to the awaiter, destroys itself, and then
4972 resumes the awaiter.4972 resumes the awaiter.
4973 </p>4973 </p>
4974 <p>4974 <p>
4975 A promise handle must be consumed exactly once after it is created, either by <code>cancel</code> or <code>await</code>.4975 A promise handle must be consumed exactly once after it is created, either by {#syntax#}cancel{#endsyntax#} or {#syntax#}await{#endsyntax#}.
4976 </p>4976 </p>
4977 <p>4977 <p>
4978 <code>await</code> counts as a suspend point, and therefore at every <code>await</code>,4978 {#syntax#}await{#endsyntax#} counts as a suspend point, and therefore at every {#syntax#}await{#endsyntax#},
4979 a coroutine can be potentially destroyed, which would run <code>defer</code> and <code>errdefer</code> expressions.4979 a coroutine can be potentially destroyed, which would run {#syntax#}defer{#endsyntax#} and {#syntax#}errdefer{#endsyntax#} expressions.
4980 </p>4980 </p>
4981 {#code_begin|test#}4981 {#code_begin|test#}
4982const std = @import("std");4982const std = @import("std");
...@@ -5020,9 +5020,9 @@ fn seq(c: u8) void {...@@ -5020,9 +5020,9 @@ fn seq(c: u8) void {
5020}5020}
5021 {#code_end#}5021 {#code_end#}
5022 <p>5022 <p>
5023 In general, <code>suspend</code> is lower level than <code>await</code>. Most application5023 In general, {#syntax#}suspend{#endsyntax#} is lower level than {#syntax#}await{#endsyntax#}. Most application
5024 code will use only <code>async</code> and <code>await</code>, but event loop5024 code will use only {#syntax#}async{#endsyntax#} and {#syntax#}await{#endsyntax#}, but event loop
5025 implementations will make use of <code>suspend</code> internally.5025 implementations will make use of {#syntax#}suspend{#endsyntax#} internally.
5026 </p>5026 </p>
5027 {#header_close#}5027 {#header_close#}
5028 {#header_open|Open Issues#}5028 {#header_open|Open Issues#}
...@@ -5052,36 +5052,36 @@ fn seq(c: u8) void {...@@ -5052,36 +5052,36 @@ fn seq(c: u8) void {
5052 {#header_open|Builtin Functions#}5052 {#header_open|Builtin Functions#}
5053 <p>5053 <p>
5054 Builtin functions are provided by the compiler and are prefixed with <code>@</code>.5054 Builtin functions are provided by the compiler and are prefixed with <code>@</code>.
5055 The <code>comptime</code> keyword on a parameter means that the parameter must be known5055 The {#syntax#}comptime{#endsyntax#} keyword on a parameter means that the parameter must be known
5056 at compile time.5056 at compile time.
5057 </p>5057 </p>
5058 {#header_open|@addWithOverflow#}5058 {#header_open|@addWithOverflow#}
5059 <pre><code class="zig">@addWithOverflow(comptime T: type, a: T, b: T, result: *T) bool</code></pre>5059 <pre>{#syntax#}@addWithOverflow(comptime T: type, a: T, b: T, result: *T) bool{#endsyntax#}</pre>
5060 <p>5060 <p>
5061 Performs <code>result.* = a + b</code>. If overflow or underflow occurs,5061 Performs {#syntax#}result.* = a + b{#endsyntax#}. If overflow or underflow occurs,
5062 stores the overflowed bits in <code>result</code> and returns <code>true</code>.5062 stores the overflowed bits in {#syntax#}result{#endsyntax#} and returns {#syntax#}true{#endsyntax#}.
5063 If no overflow or underflow occurs, returns <code>false</code>.5063 If no overflow or underflow occurs, returns {#syntax#}false{#endsyntax#}.
5064 </p>5064 </p>
5065 {#header_close#}5065 {#header_close#}
5066 {#header_open|@ArgType#}5066 {#header_open|@ArgType#}
5067 <pre><code class="zig">@ArgType(comptime T: type, comptime n: usize) type</code></pre>5067 <pre>{#syntax#}@ArgType(comptime T: type, comptime n: usize) type{#endsyntax#}</pre>
5068 <p>5068 <p>
5069 This builtin function takes a function type and returns the type of the parameter at index <code>n</code>.5069 This builtin function takes a function type and returns the type of the parameter at index {#syntax#}n{#endsyntax#}.
5070 </p>5070 </p>
5071 <p>5071 <p>
5072 <code>T</code> must be a function type.5072 {#syntax#}T{#endsyntax#} must be a function type.
5073 </p>5073 </p>
5074 <p>5074 <p>
5075 Note: This function is deprecated. Use {#link|@typeInfo#} instead.5075 Note: This function is deprecated. Use {#link|@typeInfo#} instead.
5076 </p>5076 </p>
5077 {#header_close#}5077 {#header_close#}
5078 {#header_open|@atomicLoad#}5078 {#header_open|@atomicLoad#}
5079 <pre><code class="zig">@atomicLoad(comptime T: type, ptr: *const T, comptime ordering: builtin.AtomicOrder) T</code></pre>5079 <pre>{#syntax#}@atomicLoad(comptime T: type, ptr: *const T, comptime ordering: builtin.AtomicOrder) T{#endsyntax#}</pre>
5080 <p>5080 <p>
5081 This builtin function atomically dereferences a pointer and returns the value.5081 This builtin function atomically dereferences a pointer and returns the value.
5082 </p>5082 </p>
5083 <p>5083 <p>
5084 <code>T</code> must be a pointer type, a <code>bool</code>,5084 {#syntax#}T{#endsyntax#} must be a pointer type, a {#syntax#}bool{#endsyntax#},
5085 or an integer whose bit count meets these requirements:5085 or an integer whose bit count meets these requirements:
5086 </p>5086 </p>
5087 <ul>5087 <ul>
...@@ -5095,12 +5095,12 @@ fn seq(c: u8) void {...@@ -5095,12 +5095,12 @@ fn seq(c: u8) void {
5095 </p>5095 </p>
5096 {#header_close#}5096 {#header_close#}
5097 {#header_open|@atomicRmw#}5097 {#header_open|@atomicRmw#}
5098 <pre><code class="zig">@atomicRmw(comptime T: type, ptr: *T, comptime op: builtin.AtomicRmwOp, operand: T, comptime ordering: builtin.AtomicOrder) T</code></pre>5098 <pre>{#syntax#}@atomicRmw(comptime T: type, ptr: *T, comptime op: builtin.AtomicRmwOp, operand: T, comptime ordering: builtin.AtomicOrder) T{#endsyntax#}</pre>
5099 <p>5099 <p>
5100 This builtin function atomically modifies memory and then returns the previous value.5100 This builtin function atomically modifies memory and then returns the previous value.
5101 </p>5101 </p>
5102 <p>5102 <p>
5103 <code>T</code> must be a pointer type, a <code>bool</code>,5103 {#syntax#}T{#endsyntax#} must be a pointer type, a {#syntax#}bool{#endsyntax#},
5104 or an integer whose bit count meets these requirements:5104 or an integer whose bit count meets these requirements:
5105 </p>5105 </p>
5106 <ul>5106 <ul>
...@@ -5114,29 +5114,29 @@ fn seq(c: u8) void {...@@ -5114,29 +5114,29 @@ fn seq(c: u8) void {
5114 </p>5114 </p>
5115 {#header_close#}5115 {#header_close#}
5116 {#header_open|@bitCast#}5116 {#header_open|@bitCast#}
5117 <pre><code class="zig">@bitCast(comptime DestType: type, value: var) DestType</code></pre>5117 <pre>{#syntax#}@bitCast(comptime DestType: type, value: var) DestType{#endsyntax#}</pre>
5118 <p>5118 <p>
5119 Converts a value of one type to another type.5119 Converts a value of one type to another type.
5120 </p>5120 </p>
5121 <p>5121 <p>
5122 Asserts that <code>@sizeOf(@typeOf(value)) == @sizeOf(DestType)</code>.5122 Asserts that {#syntax#}@sizeOf(@typeOf(value)) == @sizeOf(DestType){#endsyntax#}.
5123 </p>5123 </p>
5124 <p>5124 <p>
5125 Asserts that <code>@typeId(DestType) != @import("builtin").TypeId.Pointer</code>. Use <code>@ptrCast</code> or <code>@intToPtr</code> if you need this.5125 Asserts that {#syntax#}@typeId(DestType) != @import("builtin").TypeId.Pointer{#endsyntax#}. Use {#syntax#}@ptrCast{#endsyntax#} or {#syntax#}@intToPtr{#endsyntax#} if you need this.
5126 </p>5126 </p>
5127 <p>5127 <p>
5128 Can be used for these things for example:5128 Can be used for these things for example:
5129 </p>5129 </p>
5130 <ul>5130 <ul>
5131 <li>Convert <code>f32</code> to <code>u32</code> bits</li>5131 <li>Convert {#syntax#}f32{#endsyntax#} to {#syntax#}u32{#endsyntax#} bits</li>
5132 <li>Convert <code>i32</code> to <code>u32</code> preserving twos complement</li>5132 <li>Convert {#syntax#}i32{#endsyntax#} to {#syntax#}u32{#endsyntax#} preserving twos complement</li>
5133 </ul>5133 </ul>
5134 <p>5134 <p>
5135 Works at compile-time if <code>value</code> is known at compile time. It's a compile error to bitcast a struct to a scalar type of the same size since structs have undefined layout. However if the struct is packed then it works.5135 Works at compile-time if {#syntax#}value{#endsyntax#} is known at compile time. It's a compile error to bitcast a struct to a scalar type of the same size since structs have undefined layout. However if the struct is packed then it works.
5136 </p>5136 </p>
5137 {#header_close#}5137 {#header_close#}
5138 {#header_open|@breakpoint#}5138 {#header_open|@breakpoint#}
5139 <pre><code class="zig">@breakpoint()</code></pre>5139 <pre>{#syntax#}@breakpoint(){#endsyntax#}</pre>
5140 <p>5140 <p>
5141 This function inserts a platform-specific debug trap instruction which causes5141 This function inserts a platform-specific debug trap instruction which causes
5142 debuggers to break there.5142 debuggers to break there.
...@@ -5147,10 +5147,10 @@ fn seq(c: u8) void {...@@ -5147,10 +5147,10 @@ fn seq(c: u8) void {
51475147
5148 {#header_close#}5148 {#header_close#}
5149 {#header_open|@alignCast#}5149 {#header_open|@alignCast#}
5150 <pre><code class="zig">@alignCast(comptime alignment: u29, ptr: var) var</code></pre>5150 <pre>{#syntax#}@alignCast(comptime alignment: u29, ptr: var) var{#endsyntax#}</pre>
5151 <p>5151 <p>
5152 <code>ptr</code> can be <code>*T</code>, <code>fn()</code>, <code>?*T</code>,5152 {#syntax#}ptr{#endsyntax#} can be {#syntax#}*T{#endsyntax#}, {#syntax#}fn(){#endsyntax#}, {#syntax#}?*T{#endsyntax#},
5153 <code>?fn()</code>, or <code>[]T</code>. It returns the same type as <code>ptr</code>5153 {#syntax#}?fn(){#endsyntax#}, or {#syntax#}[]T{#endsyntax#}. It returns the same type as {#syntax#}ptr{#endsyntax#}
5154 except with the alignment adjusted to the new value.5154 except with the alignment adjusted to the new value.
5155 </p>5155 </p>
5156 <p>A {#link|pointer alignment safety check|Incorrect Pointer Alignment#} is added5156 <p>A {#link|pointer alignment safety check|Incorrect Pointer Alignment#} is added
...@@ -5158,16 +5158,16 @@ fn seq(c: u8) void {...@@ -5158,16 +5158,16 @@ fn seq(c: u8) void {
51585158
5159 {#header_close#}5159 {#header_close#}
5160 {#header_open|@alignOf#}5160 {#header_open|@alignOf#}
5161 <pre><code class="zig">@alignOf(comptime T: type) comptime_int</code></pre>5161 <pre>{#syntax#}@alignOf(comptime T: type) comptime_int{#endsyntax#}</pre>
5162 <p>5162 <p>
5163 This function returns the number of bytes that this type should be aligned to5163 This function returns the number of bytes that this type should be aligned to
5164 for the current target to match the C ABI. When the child type of a pointer has5164 for the current target to match the C ABI. When the child type of a pointer has
5165 this alignment, the alignment can be omitted from the type.5165 this alignment, the alignment can be omitted from the type.
5166 </p>5166 </p>
5167 <pre><code class="zig">const assert = @import("std").debug.assert;5167 <pre>{#syntax#}const assert = @import("std").debug.assert;
5168comptime {5168comptime {
5169 assert(*u32 == *align(@alignOf(u32)) u32);5169 assert(*u32 == *align(@alignOf(u32)) u32);
5170}</code></pre>5170}{#endsyntax#}</pre>
5171 <p>5171 <p>
5172 The result is a target-specific compile time constant. It is guaranteed to be5172 The result is a target-specific compile time constant. It is guaranteed to be
5173 less than or equal to {#link|@sizeOf(T)|@sizeOf#}.5173 less than or equal to {#link|@sizeOf(T)|@sizeOf#}.
...@@ -5176,21 +5176,21 @@ comptime {...@@ -5176,21 +5176,21 @@ comptime {
5176 {#header_close#}5176 {#header_close#}
51775177
5178 {#header_open|@boolToInt#}5178 {#header_open|@boolToInt#}
5179 <pre><code class="zig">@boolToInt(value: bool) u1</code></pre>5179 <pre>{#syntax#}@boolToInt(value: bool) u1{#endsyntax#}</pre>
5180 <p>5180 <p>
5181 Converts <code>true</code> to <code>u1(1)</code> and <code>false</code> to5181 Converts {#syntax#}true{#endsyntax#} to {#syntax#}u1(1){#endsyntax#} and {#syntax#}false{#endsyntax#} to
5182 <code>u1(0)</code>.5182 {#syntax#}u1(0){#endsyntax#}.
5183 </p>5183 </p>
5184 <p>5184 <p>
5185 If the value is known at compile-time, the return type is <code>comptime_int</code>5185 If the value is known at compile-time, the return type is {#syntax#}comptime_int{#endsyntax#}
5186 instead of <code>u1</code>.5186 instead of {#syntax#}u1{#endsyntax#}.
5187 </p>5187 </p>
5188 {#header_close#}5188 {#header_close#}
51895189
5190 {#header_open|@bytesToSlice#}5190 {#header_open|@bytesToSlice#}
5191 <pre><code class="zig">@bytesToSlice(comptime Element: type, bytes: []u8) []Element</code></pre>5191 <pre>{#syntax#}@bytesToSlice(comptime Element: type, bytes: []u8) []Element{#endsyntax#}</pre>
5192 <p>5192 <p>
5193 Converts a slice of bytes or array of bytes into a slice of <code>Element</code>.5193 Converts a slice of bytes or array of bytes into a slice of {#syntax#}Element{#endsyntax#}.
5194 The resulting slice has the same {#link|pointer|Pointers#} properties as the parameter.5194 The resulting slice has the same {#link|pointer|Pointers#} properties as the parameter.
5195 </p>5195 </p>
5196 <p>5196 <p>
...@@ -5200,12 +5200,12 @@ comptime {...@@ -5200,12 +5200,12 @@ comptime {
5200 {#header_close#}5200 {#header_close#}
52015201
5202 {#header_open|@cDefine#}5202 {#header_open|@cDefine#}
5203 <pre><code class="zig">@cDefine(comptime name: []u8, value)</code></pre>5203 <pre>{#syntax#}@cDefine(comptime name: []u8, value){#endsyntax#}</pre>
5204 <p>5204 <p>
5205 This function can only occur inside <code>@cImport</code>.5205 This function can only occur inside {#syntax#}@cImport{#endsyntax#}.
5206 </p>5206 </p>
5207 <p>5207 <p>
5208 This appends <code>#define $name $value</code> to the <code>@cImport</code>5208 This appends <code>#define $name $value</code> to the {#syntax#}@cImport{#endsyntax#}
5209 temporary buffer.5209 temporary buffer.
5210 </p>5210 </p>
5211 <p>5211 <p>
...@@ -5215,72 +5215,72 @@ comptime {...@@ -5215,72 +5215,72 @@ comptime {
5215 <p>5215 <p>
5216 Use the void value, like this:5216 Use the void value, like this:
5217 </p>5217 </p>
5218 <pre><code class="zig">@cDefine("_GNU_SOURCE", {})</code></pre>5218 <pre>{#syntax#}@cDefine("_GNU_SOURCE", {}){#endsyntax#}</pre>
5219 {#see_also|Import from C Header File|@cInclude|@cImport|@cUndef|void#}5219 {#see_also|Import from C Header File|@cInclude|@cImport|@cUndef|void#}
5220 {#header_close#}5220 {#header_close#}
5221 {#header_open|@cImport#}5221 {#header_open|@cImport#}
5222 <pre><code class="zig">@cImport(expression) (namespace)</code></pre>5222 <pre>{#syntax#}@cImport(expression) (namespace){#endsyntax#}</pre>
5223 <p>5223 <p>
5224 This function parses C code and imports the functions, types, variables, and5224 This function parses C code and imports the functions, types, variables, and
5225 compatible macro definitions into the result namespace.5225 compatible macro definitions into the result namespace.
5226 </p>5226 </p>
5227 <p>5227 <p>
5228 <code>expression</code> is interpreted at compile time. The builtin functions5228 {#syntax#}expression{#endsyntax#} is interpreted at compile time. The builtin functions
5229 <code>@cInclude</code>, <code>@cDefine</code>, and <code>@cUndef</code> work5229 {#syntax#}@cInclude{#endsyntax#}, {#syntax#}@cDefine{#endsyntax#}, and {#syntax#}@cUndef{#endsyntax#} work
5230 within this expression, appending to a temporary buffer which is then parsed as C code.5230 within this expression, appending to a temporary buffer which is then parsed as C code.
5231 </p>5231 </p>
5232 <p>5232 <p>
5233 Usually you should only have one <code>@cImport</code> in your entire application, because it saves the compiler5233 Usually you should only have one {#syntax#}@cImport{#endsyntax#} in your entire application, because it saves the compiler
5234 from invoking clang multiple times, and prevents inline functions from being duplicated.5234 from invoking clang multiple times, and prevents inline functions from being duplicated.
5235 </p>5235 </p>
5236 <p>5236 <p>
5237 Reasons for having multiple <code>@cImport</code> expressions would be:5237 Reasons for having multiple {#syntax#}@cImport{#endsyntax#} expressions would be:
5238 </p>5238 </p>
5239 <ul>5239 <ul>
5240 <li>To avoid a symbol collision, for example if foo.h and bar.h both <code>#define CONNECTION_COUNT</code></li>5240 <li>To avoid a symbol collision, for example if foo.h and bar.h both <code>#define CONNECTION_COUNT</code></li>
5241 <li>To analyze the C code with different preprocessor defines</li>5241 <li>To analyze the C code with different preprocessor defines</li>
5242 </ul>5242 </ul>
5243 {#see_also|Import from C Header File|@cInclude|@cDefine|@cUndef#}5243 {#see_also|Import from C Header File|@cInclude|@cDefine|@cUndef#}
5244 {#header_close#}5244 {#header_close#}
5245 {#header_open|@cInclude#}5245 {#header_open|@cInclude#}
5246 <pre><code class="zig">@cInclude(comptime path: []u8)</code></pre>5246 <pre>{#syntax#}@cInclude(comptime path: []u8){#endsyntax#}</pre>
5247 <p>5247 <p>
5248 This function can only occur inside <code>@cImport</code>.5248 This function can only occur inside {#syntax#}@cImport{#endsyntax#}.
5249 </p>5249 </p>
5250 <p>5250 <p>
5251 This appends <code>#include <$path>\n</code> to the <code>c_import</code>5251 This appends <code>#include <$path>\n</code> to the {#syntax#}c_import{#endsyntax#}
5252 temporary buffer.5252 temporary buffer.
5253 </p>5253 </p>
5254 {#see_also|Import from C Header File|@cImport|@cDefine|@cUndef#}5254 {#see_also|Import from C Header File|@cImport|@cDefine|@cUndef#}
5255 {#header_close#}5255 {#header_close#}
5256 {#header_open|@cUndef#}5256 {#header_open|@cUndef#}
5257 <pre><code class="zig">@cUndef(comptime name: []u8)</code></pre>5257 <pre>{#syntax#}@cUndef(comptime name: []u8){#endsyntax#}</pre>
5258 <p>5258 <p>
5259 This function can only occur inside <code>@cImport</code>.5259 This function can only occur inside {#syntax#}@cImport{#endsyntax#}.
5260 </p>5260 </p>
5261 <p>5261 <p>
5262 This appends <code>#undef $name</code> to the <code>@cImport</code>5262 This appends <code>#undef $name</code> to the {#syntax#}@cImport{#endsyntax#}
5263 temporary buffer.5263 temporary buffer.
5264 </p>5264 </p>
5265 {#see_also|Import from C Header File|@cImport|@cDefine|@cInclude#}5265 {#see_also|Import from C Header File|@cImport|@cDefine|@cInclude#}
5266 {#header_close#}5266 {#header_close#}
5267 {#header_open|@clz#}5267 {#header_open|@clz#}
5268 <pre><code class="zig">@clz(x: T) U</code></pre>5268 <pre>{#syntax#}@clz(x: T) U{#endsyntax#}</pre>
5269 <p>5269 <p>
5270 This function counts the number of leading zeroes in <code>x</code> which is an integer5270 This function counts the number of leading zeroes in {#syntax#}x{#endsyntax#} which is an integer
5271 type <code>T</code>.5271 type {#syntax#}T{#endsyntax#}.
5272 </p>5272 </p>
5273 <p>5273 <p>
5274 The return type <code>U</code> is an unsigned integer with the minimum number5274 The return type {#syntax#}U{#endsyntax#} is an unsigned integer with the minimum number
5275 of bits that can represent the value <code>T.bit_count</code>.5275 of bits that can represent the value {#syntax#}T.bit_count{#endsyntax#}.
5276 </p>5276 </p>
5277 <p>5277 <p>
5278 If <code>x</code> is zero, <code>@clz</code> returns <code>T.bit_count</code>.5278 If {#syntax#}x{#endsyntax#} is zero, {#syntax#}@clz{#endsyntax#} returns {#syntax#}T.bit_count{#endsyntax#}.
5279 </p>5279 </p>
5280 {#see_also|@ctz|@popCount#}5280 {#see_also|@ctz|@popCount#}
5281 {#header_close#}5281 {#header_close#}
5282 {#header_open|@cmpxchgStrong#}5282 {#header_open|@cmpxchgStrong#}
5283 <pre><code class="zig">@cmpxchgStrong(comptime T: type, ptr: *T, expected_value: T, new_value: T, success_order: AtomicOrder, fail_order: AtomicOrder) ?T</code></pre>5283 <pre>{#syntax#}@cmpxchgStrong(comptime T: type, ptr: *T, expected_value: T, new_value: T, success_order: AtomicOrder, fail_order: AtomicOrder) ?T{#endsyntax#}</pre>
5284 <p>5284 <p>
5285 This function performs a strong atomic compare exchange operation. It's the equivalent of this code,5285 This function performs a strong atomic compare exchange operation. It's the equivalent of this code,
5286 except atomic:5286 except atomic:
...@@ -5301,13 +5301,13 @@ fn cmpxchgStrongButNotAtomic(comptime T: type, ptr: *T, expected_value: T, new_v...@@ -5301,13 +5301,13 @@ fn cmpxchgStrongButNotAtomic(comptime T: type, ptr: *T, expected_value: T, new_v
5301 more efficiently in machine instructions.5301 more efficiently in machine instructions.
5302 </p>5302 </p>
5303 <p>5303 <p>
5304 <code>AtomicOrder</code> can be found with <code>@import("builtin").AtomicOrder</code>.5304 {#syntax#}AtomicOrder{#endsyntax#} can be found with {#syntax#}@import("builtin").AtomicOrder{#endsyntax#}.
5305 </p>5305 </p>
5306 <p><code>@typeOf(ptr).alignment</code> must be <code>&gt;= @sizeOf(T).</code></p>5306 <p>{#syntax#}@typeOf(ptr).alignment{#endsyntax#} must be {#syntax#}>= @sizeOf(T).{#endsyntax#}</p>
5307 {#see_also|Compile Variables|cmpxchgWeak#}5307 {#see_also|Compile Variables|cmpxchgWeak#}
5308 {#header_close#}5308 {#header_close#}
5309 {#header_open|@cmpxchgWeak#}5309 {#header_open|@cmpxchgWeak#}
5310 <pre><code class="zig">@cmpxchgWeak(comptime T: type, ptr: *T, expected_value: T, new_value: T, success_order: AtomicOrder, fail_order: AtomicOrder) ?T</code></pre>5310 <pre>{#syntax#}@cmpxchgWeak(comptime T: type, ptr: *T, expected_value: T, new_value: T, success_order: AtomicOrder, fail_order: AtomicOrder) ?T{#endsyntax#}</pre>
5311 <p>5311 <p>
5312 This function performs a weak atomic compare exchange operation. It's the equivalent of this code,5312 This function performs a weak atomic compare exchange operation. It's the equivalent of this code,
5313 except atomic:5313 except atomic:
...@@ -5324,30 +5324,30 @@ fn cmpxchgWeakButNotAtomic(comptime T: type, ptr: *T, expected_value: T, new_val...@@ -5324,30 +5324,30 @@ fn cmpxchgWeakButNotAtomic(comptime T: type, ptr: *T, expected_value: T, new_val
5324}5324}
5325 {#code_end#}5325 {#code_end#}
5326 <p>5326 <p>
5327 If you are using cmpxchg in a loop, the sporadic failure will be no problem, and <code>cmpxchgWeak</code>5327 If you are using cmpxchg in a loop, the sporadic failure will be no problem, and {#syntax#}cmpxchgWeak{#endsyntax#}
5328 is the better choice, because it can be implemented more efficiently in machine instructions.5328 is the better choice, because it can be implemented more efficiently in machine instructions.
5329 However if you need a stronger guarantee, use {#link|@cmpxchgStrong#}.5329 However if you need a stronger guarantee, use {#link|@cmpxchgStrong#}.
5330 </p>5330 </p>
5331 <p>5331 <p>
5332 <code>AtomicOrder</code> can be found with <code>@import("builtin").AtomicOrder</code>.5332 {#syntax#}AtomicOrder{#endsyntax#} can be found with {#syntax#}@import("builtin").AtomicOrder{#endsyntax#}.
5333 </p>5333 </p>
5334 <p><code>@typeOf(ptr).alignment</code> must be <code>&gt;= @sizeOf(T).</code></p>5334 <p>{#syntax#}@typeOf(ptr).alignment{#endsyntax#} must be {#syntax#}>= @sizeOf(T).{#endsyntax#}</p>
5335 {#see_also|Compile Variables|cmpxchgStrong#}5335 {#see_also|Compile Variables|cmpxchgStrong#}
5336 {#header_close#}5336 {#header_close#}
5337 {#header_open|@compileError#}5337 {#header_open|@compileError#}
5338 <pre><code class="zig">@compileError(comptime msg: []u8)</code></pre>5338 <pre>{#syntax#}@compileError(comptime msg: []u8){#endsyntax#}</pre>
5339 <p>5339 <p>
5340 This function, when semantically analyzed, causes a compile error with the5340 This function, when semantically analyzed, causes a compile error with the
5341 message <code>msg</code>.5341 message {#syntax#}msg{#endsyntax#}.
5342 </p>5342 </p>
5343 <p>5343 <p>
5344 There are several ways that code avoids being semantically checked, such as5344 There are several ways that code avoids being semantically checked, such as
5345 using <code>if</code> or <code>switch</code> with compile time constants,5345 using {#syntax#}if{#endsyntax#} or {#syntax#}switch{#endsyntax#} with compile time constants,
5346 and <code>comptime</code> functions.5346 and {#syntax#}comptime{#endsyntax#} functions.
5347 </p>5347 </p>
5348 {#header_close#}5348 {#header_close#}
5349 {#header_open|@compileLog#}5349 {#header_open|@compileLog#}
5350 <pre><code class="zig">@compileLog(args: ...)</code></pre>5350 <pre>{#syntax#}@compileLog(args: ...){#endsyntax#}</pre>
5351 <p>5351 <p>
5352 This function prints the arguments passed to it at compile-time.5352 This function prints the arguments passed to it at compile-time.
5353 </p>5353 </p>
...@@ -5382,7 +5382,7 @@ test "main" {...@@ -5382,7 +5382,7 @@ test "main" {
5382 will ouput:5382 will ouput:
5383 </p>5383 </p>
5384 <p>5384 <p>
5385 If all <code>@compileLog</code> calls are removed or 5385 If all {#syntax#}@compileLog{#endsyntax#} calls are removed or
5386 not encountered by analysis, the5386 not encountered by analysis, the
5387 program compiles successfully and the generated executable prints:5387 program compiles successfully and the generated executable prints:
5388 </p> 5388 </p>
...@@ -5401,88 +5401,88 @@ test "main" {...@@ -5401,88 +5401,88 @@ test "main" {
5401 {#code_end#}5401 {#code_end#}
5402 {#header_close#}5402 {#header_close#}
5403 {#header_open|@ctz#}5403 {#header_open|@ctz#}
5404 <pre><code class="zig">@ctz(x: T) U</code></pre>5404 <pre>{#syntax#}@ctz(x: T) U{#endsyntax#}</pre>
5405 <p>5405 <p>
5406 This function counts the number of trailing zeroes in <code>x</code> which is an integer5406 This function counts the number of trailing zeroes in {#syntax#}x{#endsyntax#} which is an integer
5407 type <code>T</code>.5407 type {#syntax#}T{#endsyntax#}.
5408 </p>5408 </p>
5409 <p>5409 <p>
5410 The return type <code>U</code> is an unsigned integer with the minimum number5410 The return type {#syntax#}U{#endsyntax#} is an unsigned integer with the minimum number
5411 of bits that can represent the value <code>T.bit_count</code>.5411 of bits that can represent the value {#syntax#}T.bit_count{#endsyntax#}.
5412 </p>5412 </p>
5413 <p>5413 <p>
5414 If <code>x</code> is zero, <code>@ctz</code> returns <code>T.bit_count</code>.5414 If {#syntax#}x{#endsyntax#} is zero, {#syntax#}@ctz{#endsyntax#} returns {#syntax#}T.bit_count{#endsyntax#}.
5415 </p>5415 </p>
5416 {#see_also|@clz|@popCount#}5416 {#see_also|@clz|@popCount#}
5417 {#header_close#}5417 {#header_close#}
5418 {#header_open|@divExact#}5418 {#header_open|@divExact#}
5419 <pre><code class="zig">@divExact(numerator: T, denominator: T) T</code></pre>5419 <pre>{#syntax#}@divExact(numerator: T, denominator: T) T{#endsyntax#}</pre>
5420 <p>5420 <p>
5421 Exact division. Caller guarantees <code>denominator != 0</code> and5421 Exact division. Caller guarantees {#syntax#}denominator != 0{#endsyntax#} and
5422 <code>@divTrunc(numerator, denominator) * denominator == numerator</code>.5422 {#syntax#}@divTrunc(numerator, denominator) * denominator == numerator{#endsyntax#}.
5423 </p>5423 </p>
5424 <ul>5424 <ul>
5425 <li><code>@divExact(6, 3) == 2</code></li>5425 <li>{#syntax#}@divExact(6, 3) == 2{#endsyntax#}</li>
5426 <li><code>@divExact(a, b) * b == a</code></li>5426 <li>{#syntax#}@divExact(a, b) * b == a{#endsyntax#}</li>
5427 </ul>5427 </ul>
5428 <p>For a function that returns a possible error code, use <code>@import("std").math.divExact</code>.</p>5428 <p>For a function that returns a possible error code, use {#syntax#}@import("std").math.divExact{#endsyntax#}.</p>
5429 {#see_also|@divTrunc|@divFloor#}5429 {#see_also|@divTrunc|@divFloor#}
5430 {#header_close#}5430 {#header_close#}
5431 {#header_open|@divFloor#}5431 {#header_open|@divFloor#}
5432 <pre><code class="zig">@divFloor(numerator: T, denominator: T) T</code></pre>5432 <pre>{#syntax#}@divFloor(numerator: T, denominator: T) T{#endsyntax#}</pre>
5433 <p>5433 <p>
5434 Floored division. Rounds toward negative infinity. For unsigned integers it is5434 Floored division. Rounds toward negative infinity. For unsigned integers it is
5435 the same as <code>numerator / denominator</code>. Caller guarantees <code>denominator != 0</code> and5435 the same as {#syntax#}numerator / denominator{#endsyntax#}. Caller guarantees {#syntax#}denominator != 0{#endsyntax#} and
5436 <code>!(@typeId(T) == builtin.TypeId.Int and T.is_signed and numerator == @minValue(T) and denominator == -1)</code>.5436 {#syntax#}!(@typeId(T) == builtin.TypeId.Int and T.is_signed and numerator == @minValue(T) and denominator == -1){#endsyntax#}.
5437 </p>5437 </p>
5438 <ul>5438 <ul>
5439 <li><code>@divFloor(-5, 3) == -2</code></li>5439 <li>{#syntax#}@divFloor(-5, 3) == -2{#endsyntax#}</li>
5440 <li><code>@divFloor(a, b) + @mod(a, b) == a</code></li>5440 <li>{#syntax#}@divFloor(a, b) + @mod(a, b) == a{#endsyntax#}</li>
5441 </ul>5441 </ul>
5442 <p>For a function that returns a possible error code, use <code>@import("std").math.divFloor</code>.</p>5442 <p>For a function that returns a possible error code, use {#syntax#}@import("std").math.divFloor{#endsyntax#}.</p>
5443 {#see_also|@divTrunc|@divExact#}5443 {#see_also|@divTrunc|@divExact#}
5444 {#header_close#}5444 {#header_close#}
5445 {#header_open|@divTrunc#}5445 {#header_open|@divTrunc#}
5446 <pre><code class="zig">@divTrunc(numerator: T, denominator: T) T</code></pre>5446 <pre>{#syntax#}@divTrunc(numerator: T, denominator: T) T{#endsyntax#}</pre>
5447 <p>5447 <p>
5448 Truncated division. Rounds toward zero. For unsigned integers it is5448 Truncated division. Rounds toward zero. For unsigned integers it is
5449 the same as <code>numerator / denominator</code>. Caller guarantees <code>denominator != 0</code> and5449 the same as {#syntax#}numerator / denominator{#endsyntax#}. Caller guarantees {#syntax#}denominator != 0{#endsyntax#} and
5450 <code>!(@typeId(T) == builtin.TypeId.Int and T.is_signed and numerator == @minValue(T) and denominator == -1)</code>.5450 {#syntax#}!(@typeId(T) == builtin.TypeId.Int and T.is_signed and numerator == @minValue(T) and denominator == -1){#endsyntax#}.
5451 </p>5451 </p>
5452 <ul>5452 <ul>
5453 <li><code>@divTrunc(-5, 3) == -1</code></li>5453 <li>{#syntax#}@divTrunc(-5, 3) == -1{#endsyntax#}</li>
5454 <li><code>@divTrunc(a, b) + @rem(a, b) == a</code></li>5454 <li>{#syntax#}@divTrunc(a, b) + @rem(a, b) == a{#endsyntax#}</li>
5455 </ul>5455 </ul>
5456 <p>For a function that returns a possible error code, use <code>@import("std").math.divTrunc</code>.</p>5456 <p>For a function that returns a possible error code, use {#syntax#}@import("std").math.divTrunc{#endsyntax#}.</p>
5457 {#see_also|@divFloor|@divExact#}5457 {#see_also|@divFloor|@divExact#}
5458 {#header_close#}5458 {#header_close#}
5459 {#header_open|@embedFile#}5459 {#header_open|@embedFile#}
5460 <pre><code class="zig">@embedFile(comptime path: []const u8) [X]u8</code></pre>5460 <pre>{#syntax#}@embedFile(comptime path: []const u8) [X]u8{#endsyntax#}</pre>
5461 <p>5461 <p>
5462 This function returns a compile time constant fixed-size array with length5462 This function returns a compile time constant fixed-size array with length
5463 equal to the byte count of the file given by <code>path</code>. The contents of the array5463 equal to the byte count of the file given by {#syntax#}path{#endsyntax#}. The contents of the array
5464 are the contents of the file.5464 are the contents of the file.
5465 </p>5465 </p>
5466 <p>5466 <p>
5467 <code>path</code> is absolute or relative to the current file, just like <code>@import</code>.5467 {#syntax#}path{#endsyntax#} is absolute or relative to the current file, just like {#syntax#}@import{#endsyntax#}.
5468 </p>5468 </p>
5469 {#see_also|@import#}5469 {#see_also|@import#}
5470 {#header_close#}5470 {#header_close#}
54715471
5472 {#header_open|@enumToInt#}5472 {#header_open|@enumToInt#}
5473 <pre><code class="zig">@enumToInt(enum_value: var) var</code></pre>5473 <pre>{#syntax#}@enumToInt(enum_value: var) var{#endsyntax#}</pre>
5474 <p>5474 <p>
5475 Converts an enumeration value into its integer tag type.5475 Converts an enumeration value into its integer tag type.
5476 </p>5476 </p>
5477 <p>5477 <p>
5478 If the enum has only 1 possible value, the resut is a <code class="zig">comptime_int</code>5478 If the enum has only 1 possible value, the resut is a {#syntax#}comptime_int{#endsyntax#}
5479 known at {#link|comptime#}.5479 known at {#link|comptime#}.
5480 </p>5480 </p>
5481 {#see_also|@intToEnum#}5481 {#see_also|@intToEnum#}
5482 {#header_close#}5482 {#header_close#}
54835483
5484 {#header_open|@errSetCast#}5484 {#header_open|@errSetCast#}
5485 <pre><code class="zig">@errSetCast(comptime T: DestType, value: var) DestType</code></pre>5485 <pre>{#syntax#}@errSetCast(comptime T: DestType, value: var) DestType{#endsyntax#}</pre>
5486 <p>5486 <p>
5487 Converts an error value from one error set to another error set. Attempting to convert an error5487 Converts an error value from one error set to another error set. Attempting to convert an error
5488 which is not in the destination error set results in safety-protected {#link|Undefined Behavior#}.5488 which is not in the destination error set results in safety-protected {#link|Undefined Behavior#}.
...@@ -5490,24 +5490,24 @@ test "main" {...@@ -5490,24 +5490,24 @@ test "main" {
5490 {#header_close#}5490 {#header_close#}
54915491
5492 {#header_open|@errorName#}5492 {#header_open|@errorName#}
5493 <pre><code class="zig">@errorName(err: error) []u8</code></pre>5493 <pre>{#syntax#}@errorName(err: error) []u8{#endsyntax#}</pre>
5494 <p>5494 <p>
5495 This function returns the string representation of an error. If an error5495 This function returns the string representation of an error. If an error
5496 declaration is:5496 declaration is:
5497 </p>5497 </p>
5498 <pre><code class="zig">error OutOfMem</code></pre>5498 <pre>{#syntax#}error OutOfMem{#endsyntax#}</pre>
5499 <p>5499 <p>
5500 Then the string representation is <code>"OutOfMem"</code>.5500 Then the string representation is {#syntax#}"OutOfMem"{#endsyntax#}.
5501 </p>5501 </p>
5502 <p>5502 <p>
5503 If there are no calls to <code>@errorName</code> in an entire application,5503 If there are no calls to {#syntax#}@errorName{#endsyntax#} in an entire application,
5504 or all calls have a compile-time known value for <code>err</code>, then no5504 or all calls have a compile-time known value for {#syntax#}err{#endsyntax#}, then no
5505 error name table will be generated.5505 error name table will be generated.
5506 </p>5506 </p>
5507 {#header_close#}5507 {#header_close#}
55085508
5509 {#header_open|@errorReturnTrace#}5509 {#header_open|@errorReturnTrace#}
5510 <pre><code class="zig">@errorReturnTrace() ?*builtin.StackTrace</code></pre>5510 <pre>{#syntax#}@errorReturnTrace() ?*builtin.StackTrace{#endsyntax#}</pre>
5511 <p>5511 <p>
5512 If the binary is built with error return tracing, and this function is invoked in a5512 If the binary is built with error return tracing, and this function is invoked in a
5513 function that calls a function with an error or error union return type, returns a5513 function that calls a function with an error or error union return type, returns a
...@@ -5516,13 +5516,13 @@ test "main" {...@@ -5516,13 +5516,13 @@ test "main" {
5516 {#header_close#}5516 {#header_close#}
55175517
5518 {#header_open|@errorToInt#}5518 {#header_open|@errorToInt#}
5519 <pre><code class="zig">@errorToInt(err: var) @IntType(false, @sizeOf(error) * 8)</code></pre>5519 <pre>{#syntax#}@errorToInt(err: var) @IntType(false, @sizeOf(error) * 8){#endsyntax#}</pre>
5520 <p>5520 <p>
5521 Supports the following types:5521 Supports the following types:
5522 </p>5522 </p>
5523 <ul>5523 <ul>
5524 <li>error unions</li>5524 <li>error unions</li>
5525 <li><code>E!void</code></li>5525 <li>{#syntax#}E!void{#endsyntax#}</li>
5526 </ul>5526 </ul>
5527 <p>5527 <p>
5528 Converts an error to the integer representation of an error.5528 Converts an error to the integer representation of an error.
...@@ -5535,38 +5535,41 @@ test "main" {...@@ -5535,38 +5535,41 @@ test "main" {
5535 {#header_close#}5535 {#header_close#}
55365536
5537 {#header_open|@export#}5537 {#header_open|@export#}
5538 <pre><code class="zig">@export(comptime name: []const u8, target: var, linkage: builtin.GlobalLinkage) []const u8</code></pre>5538 <pre>{#syntax#}@export(comptime name: []const u8, target: var, linkage: builtin.GlobalLinkage) []const u8{#endsyntax#}</pre>
5539 <p>5539 <p>
5540 Creates a symbol in the output object file.5540 Creates a symbol in the output object file.
5541 </p>5541 </p>
5542 {#header_close#}5542 {#header_close#}
55435543
5544 {#header_open|@fence#}5544 {#header_open|@fence#}
5545 <pre><code class="zig">@fence(order: AtomicOrder)</code></pre>5545 <pre>{#syntax#}@fence(order: AtomicOrder){#endsyntax#}</pre>
5546 <p>5546 <p>
5547 The <code>fence</code> function is used to introduce happens-before edges between operations.5547 The {#syntax#}fence{#endsyntax#} function is used to introduce happens-before edges between operations.
5548 </p>5548 </p>
5549 <p>5549 <p>
5550 <code>AtomicOrder</code> can be found with <code>@import("builtin").AtomicOrder</code>.5550 {#syntax#}AtomicOrder{#endsyntax#} can be found with {#syntax#}@import("builtin").AtomicOrder{#endsyntax#}.
5551 </p>5551 </p>
5552 {#see_also|Compile Variables#}5552 {#see_also|Compile Variables#}
5553 {#header_close#}5553 {#header_close#}
55545554
5555 {#header_open|@field#}5555 {#header_open|@field#}
5556 <pre><code class="zig">@field(lhs: var, comptime field_name: []const u8) (field)</code></pre>5556 <pre>{#syntax#}@field(lhs: var, comptime field_name: []const u8) (field){#endsyntax#}</pre>
5557 <p>Preforms field access equivalent to <code>lhs.-&gtfield_name-&lt</code>.</p>5557 <p>Preforms field access equivalent to {#syntax#}lhs.field_name{#endsyntax#}, except instead
5558 of the field {#syntax#}"field_name"{#endsyntax#}, it accesses the field named by the string
5559 value of {#syntax#}field_name{#endsyntax#}.
5560 </p>
5558 {#header_close#}5561 {#header_close#}
55595562
5560 {#header_open|@fieldParentPtr#}5563 {#header_open|@fieldParentPtr#}
5561 <pre><code class="zig">@fieldParentPtr(comptime ParentType: type, comptime field_name: []const u8,5564 <pre>{#syntax#}@fieldParentPtr(comptime ParentType: type, comptime field_name: []const u8,
5562 field_ptr: *T) *ParentType</code></pre>5565 field_ptr: *T) *ParentType{#endsyntax#}</pre>
5563 <p>5566 <p>
5564 Given a pointer to a field, returns the base pointer of a struct.5567 Given a pointer to a field, returns the base pointer of a struct.
5565 </p>5568 </p>
5566 {#header_close#}5569 {#header_close#}
55675570
5568 {#header_open|@floatCast#}5571 {#header_open|@floatCast#}
5569 <pre><code class="zig">@floatCast(comptime DestType: type, value: var) DestType</code></pre>5572 <pre>{#syntax#}@floatCast(comptime DestType: type, value: var) DestType{#endsyntax#}</pre>
5570 <p>5573 <p>
5571 Convert from one float type to another. This cast is safe, but may cause the5574 Convert from one float type to another. This cast is safe, but may cause the
5572 numeric value to lose precision.5575 numeric value to lose precision.
...@@ -5574,7 +5577,7 @@ test "main" {...@@ -5574,7 +5577,7 @@ test "main" {
5574 {#header_close#}5577 {#header_close#}
55755578
5576 {#header_open|@floatToInt#}5579 {#header_open|@floatToInt#}
5577 <pre><code class="zig">@floatToInt(comptime DestType: type, float: var) DestType</code></pre>5580 <pre>{#syntax#}@floatToInt(comptime DestType: type, float: var) DestType{#endsyntax#}</pre>
5578 <p>5581 <p>
5579 Converts the integer part of a floating point number to the destination type.5582 Converts the integer part of a floating point number to the destination type.
5580 </p>5583 </p>
...@@ -5586,7 +5589,7 @@ test "main" {...@@ -5586,7 +5589,7 @@ test "main" {
5586 {#header_close#}5589 {#header_close#}
55875590
5588 {#header_open|@frameAddress#}5591 {#header_open|@frameAddress#}
5589 <pre><code class="zig">@frameAddress()</code></pre>5592 <pre>{#syntax#}@frameAddress(){#endsyntax#}</pre>
5590 <p>5593 <p>
5591 This function returns the base pointer of the current stack frame.5594 This function returns the base pointer of the current stack frame.
5592 </p>5595 </p>
...@@ -5600,9 +5603,9 @@ test "main" {...@@ -5600,9 +5603,9 @@ test "main" {
5600 </p>5603 </p>
5601 {#header_close#}5604 {#header_close#}
5602 {#header_open|@handle#}5605 {#header_open|@handle#}
5603 <pre><code class="zig">@handle()</code></pre>5606 <pre>{#syntax#}@handle(){#endsyntax#}</pre>
5604 <p>5607 <p>
5605 This function returns a <code>promise->T</code> type, where <code>T</code>5608 This function returns a {#syntax#}promise->T{#endsyntax#} type, where {#syntax#}T{#endsyntax#}
5606 is the return type of the async function in scope.5609 is the return type of the async function in scope.
5607 </p>5610 </p>
5608 <p>5611 <p>
...@@ -5610,27 +5613,27 @@ test "main" {...@@ -5610,27 +5613,27 @@ test "main" {
5610 </p>5613 </p>
5611 {#header_close#}5614 {#header_close#}
5612 {#header_open|@import#}5615 {#header_open|@import#}
5613 <pre><code class="zig">@import(comptime path: []u8) (namespace)</code></pre>5616 <pre>{#syntax#}@import(comptime path: []u8) (namespace){#endsyntax#}</pre>
5614 <p>5617 <p>
5615 This function finds a zig file corresponding to <code>path</code> and imports all the5618 This function finds a zig file corresponding to {#syntax#}path{#endsyntax#} and imports all the
5616 public top level declarations into the resulting namespace.5619 public top level declarations into the resulting namespace.
5617 </p>5620 </p>
5618 <p>5621 <p>
5619 <code>path</code> can be a relative or absolute path, or it can be the name of a package.5622 {#syntax#}path{#endsyntax#} can be a relative or absolute path, or it can be the name of a package.
5620 If it is a relative path, it is relative to the file that contains the <code>@import</code>5623 If it is a relative path, it is relative to the file that contains the {#syntax#}@import{#endsyntax#}
5621 function call.5624 function call.
5622 </p>5625 </p>
5623 <p>5626 <p>
5624 The following packages are always available:5627 The following packages are always available:
5625 </p>5628 </p>
5626 <ul>5629 <ul>
5627 <li><code>@import("std")</code> - Zig Standard Library</li>5630 <li>{#syntax#}@import("std"){#endsyntax#} - Zig Standard Library</li>
5628 <li><code>@import("builtin")</code> - Compiler-provided types and variables</li>5631 <li>{#syntax#}@import("builtin"){#endsyntax#} - Compiler-provided types and variables</li>
5629 </ul>5632 </ul>
5630 {#see_also|Compile Variables|@embedFile#}5633 {#see_also|Compile Variables|@embedFile#}
5631 {#header_close#}5634 {#header_close#}
5632 {#header_open|@inlineCall#}5635 {#header_open|@inlineCall#}
5633 <pre><code class="zig">@inlineCall(function: X, args: ...) Y</code></pre>5636 <pre>{#syntax#}@inlineCall(function: X, args: ...) Y{#endsyntax#}</pre>
5634 <p>5637 <p>
5635 This calls a function, in the same way that invoking an expression with parentheses does:5638 This calls a function, in the same way that invoking an expression with parentheses does:
5636 </p>5639 </p>
...@@ -5644,14 +5647,14 @@ test "inline function call" {...@@ -5644,14 +5647,14 @@ test "inline function call" {
5644fn add(a: i32, b: i32) i32 { return a + b; }5647fn add(a: i32, b: i32) i32 { return a + b; }
5645 {#code_end#}5648 {#code_end#}
5646 <p>5649 <p>
5647 Unlike a normal function call, however, <code>@inlineCall</code> guarantees that the call5650 Unlike a normal function call, however, {#syntax#}@inlineCall{#endsyntax#} guarantees that the call
5648 will be inlined. If the call cannot be inlined, a compile error is emitted.5651 will be inlined. If the call cannot be inlined, a compile error is emitted.
5649 </p>5652 </p>
5650 {#see_also|@noInlineCall#}5653 {#see_also|@noInlineCall#}
5651 {#header_close#}5654 {#header_close#}
56525655
5653 {#header_open|@intCast#}5656 {#header_open|@intCast#}
5654 <pre><code class="zig">@intCast(comptime DestType: type, int: var) DestType</code></pre>5657 <pre>{#syntax#}@intCast(comptime DestType: type, int: var) DestType{#endsyntax#}</pre>
5655 <p>5658 <p>
5656 Converts an integer to another integer while keeping the same numerical value.5659 Converts an integer to another integer while keeping the same numerical value.
5657 Attempting to convert a number which is out of range of the destination type results in5660 Attempting to convert a number which is out of range of the destination type results in
...@@ -5660,7 +5663,7 @@ fn add(a: i32, b: i32) i32 { return a + b; }...@@ -5660,7 +5663,7 @@ fn add(a: i32, b: i32) i32 { return a + b; }
5660 {#header_close#}5663 {#header_close#}
56615664
5662 {#header_open|@intToEnum#}5665 {#header_open|@intToEnum#}
5663 <pre><code class="zig">@intToEnum(comptime DestType: type, int_value: @TagType(DestType)) DestType</code></pre>5666 <pre>{#syntax#}@intToEnum(comptime DestType: type, int_value: @TagType(DestType)) DestType{#endsyntax#}</pre>
5664 <p>5667 <p>
5665 Converts an integer into an {#link|enum#} value.5668 Converts an integer into an {#link|enum#} value.
5666 </p>5669 </p>
...@@ -5672,7 +5675,7 @@ fn add(a: i32, b: i32) i32 { return a + b; }...@@ -5672,7 +5675,7 @@ fn add(a: i32, b: i32) i32 { return a + b; }
5672 {#header_close#}5675 {#header_close#}
56735676
5674 {#header_open|@intToError#}5677 {#header_open|@intToError#}
5675 <pre><code class="zig">@intToError(value: @IntType(false, @sizeOf(error) * 8)) error</code></pre>5678 <pre>{#syntax#}@intToError(value: @IntType(false, @sizeOf(error) * 8)) error{#endsyntax#}</pre>
5676 <p>5679 <p>
5677 Converts from the integer representation of an error into the global error set type.5680 Converts from the integer representation of an error into the global error set type.
5678 </p>5681 </p>
...@@ -5688,36 +5691,36 @@ fn add(a: i32, b: i32) i32 { return a + b; }...@@ -5688,36 +5691,36 @@ fn add(a: i32, b: i32) i32 { return a + b; }
5688 {#header_close#}5691 {#header_close#}
56895692
5690 {#header_open|@intToFloat#}5693 {#header_open|@intToFloat#}
5691 <pre><code class="zig">@intToFloat(comptime DestType: type, int: var) DestType</code></pre>5694 <pre>{#syntax#}@intToFloat(comptime DestType: type, int: var) DestType{#endsyntax#}</pre>
5692 <p>5695 <p>
5693 Converts an integer to the closest floating point representation. To convert the other way, use {#link|@floatToInt#}. This cast is always safe.5696 Converts an integer to the closest floating point representation. To convert the other way, use {#link|@floatToInt#}. This cast is always safe.
5694 </p>5697 </p>
5695 {#header_close#}5698 {#header_close#}
56965699
5697 {#header_open|@intToPtr#}5700 {#header_open|@intToPtr#}
5698 <pre><code class="zig">@intToPtr(comptime DestType: type, int: usize) DestType</code></pre>5701 <pre>{#syntax#}@intToPtr(comptime DestType: type, int: usize) DestType{#endsyntax#}</pre>
5699 <p>5702 <p>
5700 Converts an integer to a pointer. To convert the other way, use {#link|@ptrToInt#}.5703 Converts an integer to a pointer. To convert the other way, use {#link|@ptrToInt#}.
5701 </p>5704 </p>
5702 {#header_close#}5705 {#header_close#}
57035706
5704 {#header_open|@IntType#}5707 {#header_open|@IntType#}
5705 <pre><code class="zig">@IntType(comptime is_signed: bool, comptime bit_count: u32) type</code></pre>5708 <pre>{#syntax#}@IntType(comptime is_signed: bool, comptime bit_count: u32) type{#endsyntax#}</pre>
5706 <p>5709 <p>
5707 This function returns an integer type with the given signness and bit count.5710 This function returns an integer type with the given signness and bit count.
5708 </p>5711 </p>
5709 {#header_close#}5712 {#header_close#}
5710 {#header_open|@maxValue#}5713 {#header_open|@maxValue#}
5711 <pre><code class="zig">@maxValue(comptime T: type) comptime_int</code></pre>5714 <pre>{#syntax#}@maxValue(comptime T: type) comptime_int{#endsyntax#}</pre>
5712 <p>5715 <p>
5713 This function returns the maximum value of the integer type <code>T</code>.5716 This function returns the maximum value of the integer type {#syntax#}T{#endsyntax#}.
5714 </p>5717 </p>
5715 <p>5718 <p>
5716 The result is a compile time constant.5719 The result is a compile time constant.
5717 </p>5720 </p>
5718 {#header_close#}5721 {#header_close#}
5719 {#header_open|@memberCount#}5722 {#header_open|@memberCount#}
5720 <pre><code class="zig">@memberCount(comptime T: type) comptime_int</code></pre>5723 <pre>{#syntax#}@memberCount(comptime T: type) comptime_int{#endsyntax#}</pre>
5721 <p>5724 <p>
5722 This function returns the number of members in a struct, enum, or union type.5725 This function returns the number of members in a struct, enum, or union type.
5723 </p>5726 </p>
...@@ -5729,7 +5732,7 @@ fn add(a: i32, b: i32) i32 { return a + b; }...@@ -5729,7 +5732,7 @@ fn add(a: i32, b: i32) i32 { return a + b; }
5729 </p>5732 </p>
5730 {#header_close#}5733 {#header_close#}
5731 {#header_open|@memberName#}5734 {#header_open|@memberName#}
5732 <pre><code class="zig">@memberName(comptime T: type, comptime index: usize) [N]u8</code></pre>5735 <pre>{#syntax#}@memberName(comptime T: type, comptime index: usize) [N]u8{#endsyntax#}</pre>
5733 <p>Returns the field name of a struct, union, or enum.</p>5736 <p>Returns the field name of a struct, union, or enum.</p>
5734 <p>5737 <p>
5735 The result is a compile time constant.5738 The result is a compile time constant.
...@@ -5739,46 +5742,46 @@ fn add(a: i32, b: i32) i32 { return a + b; }...@@ -5739,46 +5742,46 @@ fn add(a: i32, b: i32) i32 { return a + b; }
5739 </p>5742 </p>
5740 {#header_close#}5743 {#header_close#}
5741 {#header_open|@memberType#}5744 {#header_open|@memberType#}
5742 <pre><code class="zig">@memberType(comptime T: type, comptime index: usize) type</code></pre>5745 <pre>{#syntax#}@memberType(comptime T: type, comptime index: usize) type{#endsyntax#}</pre>
5743 <p>Returns the field type of a struct or union.</p>5746 <p>Returns the field type of a struct or union.</p>
5744 {#header_close#}5747 {#header_close#}
5745 {#header_open|@memcpy#}5748 {#header_open|@memcpy#}
5746 <pre><code class="zig">@memcpy(noalias dest: [*]u8, noalias source: [*]const u8, byte_count: usize)</code></pre>5749 <pre>{#syntax#}@memcpy(noalias dest: [*]u8, noalias source: [*]const u8, byte_count: usize){#endsyntax#}</pre>
5747 <p>5750 <p>
5748 This function copies bytes from one region of memory to another. <code>dest</code> and5751 This function copies bytes from one region of memory to another. {#syntax#}dest{#endsyntax#} and
5749 <code>source</code> are both pointers and must not overlap.5752 {#syntax#}source{#endsyntax#} are both pointers and must not overlap.
5750 </p>5753 </p>
5751 <p>5754 <p>
5752 This function is a low level intrinsic with no safety mechanisms. Most code5755 This function is a low level intrinsic with no safety mechanisms. Most code
5753 should not use this function, instead using something like this:5756 should not use this function, instead using something like this:
5754 </p>5757 </p>
5755 <pre><code class="zig">for (source[0...byte_count]) |b, i| dest[i] = b;</code></pre>5758 <pre>{#syntax#}for (source[0...byte_count]) |b, i| dest[i] = b;{#endsyntax#}</pre>
5756 <p>5759 <p>
5757 The optimizer is intelligent enough to turn the above snippet into a memcpy.5760 The optimizer is intelligent enough to turn the above snippet into a memcpy.
5758 </p>5761 </p>
5759 <p>There is also a standard library function for this:</p>5762 <p>There is also a standard library function for this:</p>
5760 <pre><code class="zig">const mem = @import("std").mem;5763 <pre>{#syntax#}const mem = @import("std").mem;
5761mem.copy(u8, dest[0...byte_count], source[0...byte_count]);</code></pre>5764mem.copy(u8, dest[0...byte_count], source[0...byte_count]);{#endsyntax#}</pre>
5762 {#header_close#}5765 {#header_close#}
5763 {#header_open|@memset#}5766 {#header_open|@memset#}
5764 <pre><code class="zig">@memset(dest: [*]u8, c: u8, byte_count: usize)</code></pre>5767 <pre>{#syntax#}@memset(dest: [*]u8, c: u8, byte_count: usize){#endsyntax#}</pre>
5765 <p>5768 <p>
5766 This function sets a region of memory to <code>c</code>. <code>dest</code> is a pointer.5769 This function sets a region of memory to {#syntax#}c{#endsyntax#}. {#syntax#}dest{#endsyntax#} is a pointer.
5767 </p>5770 </p>
5768 <p>5771 <p>
5769 This function is a low level intrinsic with no safety mechanisms. Most5772 This function is a low level intrinsic with no safety mechanisms. Most
5770 code should not use this function, instead using something like this:5773 code should not use this function, instead using something like this:
5771 </p>5774 </p>
5772 <pre><code class="zig">for (dest[0...byte_count]) |*b| b.* = c;</code></pre>5775 <pre>{#syntax#}for (dest[0...byte_count]) |*b| b.* = c;{#endsyntax#}</pre>
5773 <p>5776 <p>
5774 The optimizer is intelligent enough to turn the above snippet into a memset.5777 The optimizer is intelligent enough to turn the above snippet into a memset.
5775 </p>5778 </p>
5776 <p>There is also a standard library function for this:</p>5779 <p>There is also a standard library function for this:</p>
5777 <pre><code>const mem = @import("std").mem;5780 <pre>{#syntax#}const mem = @import("std").mem;
5778mem.set(u8, dest, c);</code></pre>5781mem.set(u8, dest, c);{#endsyntax#}</pre>
5779 {#header_close#}5782 {#header_close#}
5780 {#header_open|@minValue#}5783 {#header_open|@minValue#}
5781 <pre><code class="zig">@minValue(comptime T: type) comptime_int</code></pre>5784 <pre>{#syntax#}@minValue(comptime T: type) comptime_int{#endsyntax#}</pre>
5782 <p>5785 <p>
5783 This function returns the minimum value of the integer type T.5786 This function returns the minimum value of the integer type T.
5784 </p>5787 </p>
...@@ -5787,31 +5790,31 @@ mem.set(u8, dest, c);</code></pre>...@@ -5787,31 +5790,31 @@ mem.set(u8, dest, c);</code></pre>
5787 </p>5790 </p>
5788 {#header_close#}5791 {#header_close#}
5789 {#header_open|@mod#}5792 {#header_open|@mod#}
5790 <pre><code class="zig">@mod(numerator: T, denominator: T) T</code></pre>5793 <pre>{#syntax#}@mod(numerator: T, denominator: T) T{#endsyntax#}</pre>
5791 <p>5794 <p>
5792 Modulus division. For unsigned integers this is the same as5795 Modulus division. For unsigned integers this is the same as
5793 <code>numerator % denominator</code>. Caller guarantees <code>denominator &gt; 0</code>.5796 {#syntax#}numerator % denominator{#endsyntax#}. Caller guarantees {#syntax#}denominator &gt; 0{#endsyntax#}.
5794 </p>5797 </p>
5795 <ul>5798 <ul>
5796 <li><code>@mod(-5, 3) == 1</code></li>5799 <li>{#syntax#}@mod(-5, 3) == 1{#endsyntax#}</li>
5797 <li><code>@divFloor(a, b) + @mod(a, b) == a</code></li>5800 <li>{#syntax#}@divFloor(a, b) + @mod(a, b) == a{#endsyntax#}</li>
5798 </ul>5801 </ul>
5799 <p>For a function that returns an error code, see <code>@import("std").math.mod</code>.</p>5802 <p>For a function that returns an error code, see {#syntax#}@import("std").math.mod{#endsyntax#}.</p>
5800 {#see_also|@rem#}5803 {#see_also|@rem#}
5801 {#header_close#}5804 {#header_close#}
5802 {#header_open|@mulWithOverflow#}5805 {#header_open|@mulWithOverflow#}
5803 <pre><code class="zig">@mulWithOverflow(comptime T: type, a: T, b: T, result: *T) bool</code></pre>5806 <pre>{#syntax#}@mulWithOverflow(comptime T: type, a: T, b: T, result: *T) bool{#endsyntax#}</pre>
5804 <p>5807 <p>
5805 Performs <code>result.* = a * b</code>. If overflow or underflow occurs,5808 Performs {#syntax#}result.* = a * b{#endsyntax#}. If overflow or underflow occurs,
5806 stores the overflowed bits in <code>result</code> and returns <code>true</code>.5809 stores the overflowed bits in {#syntax#}result{#endsyntax#} and returns {#syntax#}true{#endsyntax#}.
5807 If no overflow or underflow occurs, returns <code>false</code>.5810 If no overflow or underflow occurs, returns {#syntax#}false{#endsyntax#}.
5808 </p>5811 </p>
5809 {#header_close#}5812 {#header_close#}
5810 {#header_open|@newStackCall#}5813 {#header_open|@newStackCall#}
5811 <pre><code class="zig">@newStackCall(new_stack: []u8, function: var, args: ...) var</code></pre>5814 <pre>{#syntax#}@newStackCall(new_stack: []u8, function: var, args: ...) var{#endsyntax#}</pre>
5812 <p>5815 <p>
5813 This calls a function, in the same way that invoking an expression with parentheses does. However,5816 This calls a function, in the same way that invoking an expression with parentheses does. However,
5814 instead of using the same stack as the caller, the function uses the stack provided in the <code>new_stack</code>5817 instead of using the same stack as the caller, the function uses the stack provided in the {#syntax#}new_stack{#endsyntax#}
5815 parameter.5818 parameter.
5816 </p>5819 </p>
5817 {#code_begin|test#}5820 {#code_begin|test#}
...@@ -5844,7 +5847,7 @@ fn targetFunction(x: i32) usize {...@@ -5844,7 +5847,7 @@ fn targetFunction(x: i32) usize {
5844 {#code_end#}5847 {#code_end#}
5845 {#header_close#}5848 {#header_close#}
5846 {#header_open|@noInlineCall#}5849 {#header_open|@noInlineCall#}
5847 <pre><code class="zig">@noInlineCall(function: var, args: ...) var</code></pre>5850 <pre>{#syntax#}@noInlineCall(function: var, args: ...) var{#endsyntax#}</pre>
5848 <p>5851 <p>
5849 This calls a function, in the same way that invoking an expression with parentheses does:5852 This calls a function, in the same way that invoking an expression with parentheses does:
5850 </p>5853 </p>
...@@ -5860,19 +5863,19 @@ fn add(a: i32, b: i32) i32 {...@@ -5860,19 +5863,19 @@ fn add(a: i32, b: i32) i32 {
5860}5863}
5861 {#code_end#}5864 {#code_end#}
5862 <p>5865 <p>
5863 Unlike a normal function call, however, <code>@noInlineCall</code> guarantees that the call5866 Unlike a normal function call, however, {#syntax#}@noInlineCall{#endsyntax#} guarantees that the call
5864 will not be inlined. If the call must be inlined, a compile error is emitted.5867 will not be inlined. If the call must be inlined, a compile error is emitted.
5865 </p>5868 </p>
5866 {#see_also|@inlineCall#}5869 {#see_also|@inlineCall#}
5867 {#header_close#}5870 {#header_close#}
5868 {#header_open|@offsetOf#}5871 {#header_open|@offsetOf#}
5869 <pre><code class="zig">@offsetOf(comptime T: type, comptime field_name: [] const u8) comptime_int</code></pre>5872 <pre>{#syntax#}@offsetOf(comptime T: type, comptime field_name: [] const u8) comptime_int{#endsyntax#}</pre>
5870 <p>5873 <p>
5871 This function returns the byte offset of a field relative to its containing struct.5874 This function returns the byte offset of a field relative to its containing struct.
5872 </p>5875 </p>
5873 {#header_close#}5876 {#header_close#}
5874 {#header_open|@OpaqueType#}5877 {#header_open|@OpaqueType#}
5875 <pre><code class="zig">@OpaqueType() type</code></pre>5878 <pre>{#syntax#}@OpaqueType() type{#endsyntax#}</pre>
5876 <p>5879 <p>
5877 Creates a new type with an unknown size and alignment.5880 Creates a new type with an unknown size and alignment.
5878 </p>5881 </p>
...@@ -5895,14 +5898,14 @@ test "call foo" {...@@ -5895,14 +5898,14 @@ test "call foo" {
5895 {#code_end#}5898 {#code_end#}
5896 {#header_close#}5899 {#header_close#}
5897 {#header_open|@panic#}5900 {#header_open|@panic#}
5898 <pre><code class="zig">@panic(message: []const u8) noreturn</code></pre>5901 <pre>{#syntax#}@panic(message: []const u8) noreturn{#endsyntax#}</pre>
5899 <p>5902 <p>
5900 Invokes the panic handler function. By default the panic handler function5903 Invokes the panic handler function. By default the panic handler function
5901 calls the public <code>panic</code> function exposed in the root source file, or5904 calls the public {#syntax#}panic{#endsyntax#} function exposed in the root source file, or
5902 if there is not one specified, invokes the one provided in <code>std/special/panic.zig</code>.5905 if there is not one specified, invokes the one provided in {#syntax#}std/special/panic.zig{#endsyntax#}.
5903 </p>5906 </p>
5904 <p>Generally it is better to use <code>@import("std").debug.panic</code>.5907 <p>Generally it is better to use {#syntax#}@import("std").debug.panic{#endsyntax#}.
5905 However, <code>@panic</code> can be useful for 2 scenarios:5908 However, {#syntax#}@panic{#endsyntax#} can be useful for 2 scenarios:
5906 </p>5909 </p>
5907 <ul>5910 <ul>
5908 <li>From library code, calling the programmer's panic function if they exposed one in the root source file.</li>5911 <li>From library code, calling the programmer's panic function if they exposed one in the root source file.</li>
...@@ -5911,50 +5914,50 @@ test "call foo" {...@@ -5911,50 +5914,50 @@ test "call foo" {
5911 {#see_also|Root Source File#}5914 {#see_also|Root Source File#}
5912 {#header_close#}5915 {#header_close#}
5913 {#header_open|@popCount#}5916 {#header_open|@popCount#}
5914 <pre><code class="zig">@popCount(integer: var) var</code></pre>5917 <pre>{#syntax#}@popCount(integer: var) var{#endsyntax#}</pre>
5915 <p>Counts the number of bits set in an integer.</p>5918 <p>Counts the number of bits set in an integer.</p>
5916 <p>5919 <p>
5917 If <code>integer</code> is known at {#link|comptime#}, the return type is <code>comptime_int</code>.5920 If {#syntax#}integer{#endsyntax#} is known at {#link|comptime#}, the return type is {#syntax#}comptime_int{#endsyntax#}.
5918 Otherwise, the return type is an unsigned integer with the minimum number5921 Otherwise, the return type is an unsigned integer with the minimum number
5919 of bits that can represent the bit count of the integer type.5922 of bits that can represent the bit count of the integer type.
5920 </p>5923 </p>
5921 {#see_also|@ctz|@clz#}5924 {#see_also|@ctz|@clz#}
5922 {#header_close#}5925 {#header_close#}
5923 {#header_open|@ptrCast#}5926 {#header_open|@ptrCast#}
5924 <pre><code class="zig">@ptrCast(comptime DestType: type, value: var) DestType</code></pre>5927 <pre>{#syntax#}@ptrCast(comptime DestType: type, value: var) DestType{#endsyntax#}</pre>
5925 <p>5928 <p>
5926 Converts a pointer of one type to a pointer of another type.5929 Converts a pointer of one type to a pointer of another type.
5927 </p>5930 </p>
5928 {#header_close#}5931 {#header_close#}
5929 {#header_open|@ptrToInt#}5932 {#header_open|@ptrToInt#}
5930 <pre><code class="zig">@ptrToInt(value: var) usize</code></pre>5933 <pre>{#syntax#}@ptrToInt(value: var) usize{#endsyntax#}</pre>
5931 <p>5934 <p>
5932 Converts <code>value</code> to a <code>usize</code> which is the address of the pointer. <code>value</code> can be one of these types:5935 Converts {#syntax#}value{#endsyntax#} to a {#syntax#}usize{#endsyntax#} which is the address of the pointer. {#syntax#}value{#endsyntax#} can be one of these types:
5933 </p>5936 </p>
5934 <ul>5937 <ul>
5935 <li><code>*T</code></li>5938 <li>{#syntax#}*T{#endsyntax#}</li>
5936 <li><code>?*T</code></li>5939 <li>{#syntax#}?*T{#endsyntax#}</li>
5937 <li><code>fn()</code></li>5940 <li>{#syntax#}fn(){#endsyntax#}</li>
5938 <li><code>?fn()</code></li>5941 <li>{#syntax#}?fn(){#endsyntax#}</li>
5939 </ul>5942 </ul>
5940 <p>To convert the other way, use {#link|@intToPtr#}</p>5943 <p>To convert the other way, use {#link|@intToPtr#}</p>
59415944
5942 {#header_close#}5945 {#header_close#}
5943 {#header_open|@rem#}5946 {#header_open|@rem#}
5944 <pre><code class="zig">@rem(numerator: T, denominator: T) T</code></pre>5947 <pre>{#syntax#}@rem(numerator: T, denominator: T) T{#endsyntax#}</pre>
5945 <p>5948 <p>
5946 Remainder division. For unsigned integers this is the same as5949 Remainder division. For unsigned integers this is the same as
5947 <code>numerator % denominator</code>. Caller guarantees <code>denominator &gt; 0</code>.5950 {#syntax#}numerator % denominator{#endsyntax#}. Caller guarantees {#syntax#}denominator > 0{#endsyntax#}.
5948 </p>5951 </p>
5949 <ul>5952 <ul>
5950 <li><code>@rem(-5, 3) == -2</code></li>5953 <li>{#syntax#}@rem(-5, 3) == -2{#endsyntax#}</li>
5951 <li><code>@divTrunc(a, b) + @rem(a, b) == a</code></li>5954 <li>{#syntax#}@divTrunc(a, b) + @rem(a, b) == a{#endsyntax#}</li>
5952 </ul>5955 </ul>
5953 <p>For a function that returns an error code, see <code>@import("std").math.rem</code>.</p>5956 <p>For a function that returns an error code, see {#syntax#}@import("std").math.rem{#endsyntax#}.</p>
5954 {#see_also|@mod#}5957 {#see_also|@mod#}
5955 {#header_close#}5958 {#header_close#}
5956 {#header_open|@returnAddress#}5959 {#header_open|@returnAddress#}
5957 <pre><code class="zig">@returnAddress()</code></pre>5960 <pre>{#syntax#}@returnAddress(){#endsyntax#}</pre>
5958 <p>5961 <p>
5959 This function returns a pointer to the return address of the current stack5962 This function returns a pointer to the return address of the current stack
5960 frame.5963 frame.
...@@ -5968,32 +5971,32 @@ test "call foo" {...@@ -5968,32 +5971,32 @@ test "call foo" {
5968 </p>5971 </p>
5969 {#header_close#}5972 {#header_close#}
5970 {#header_open|@setAlignStack#}5973 {#header_open|@setAlignStack#}
5971 <pre><code class="zig">@setAlignStack(comptime alignment: u29)</code></pre>5974 <pre>{#syntax#}@setAlignStack(comptime alignment: u29){#endsyntax#}</pre>
5972 <p>5975 <p>
5973 Ensures that a function will have a stack alignment of at least <code>alignment</code> bytes.5976 Ensures that a function will have a stack alignment of at least {#syntax#}alignment{#endsyntax#} bytes.
5974 </p>5977 </p>
5975 {#header_close#}5978 {#header_close#}
5976 {#header_open|@setCold#}5979 {#header_open|@setCold#}
5977 <pre><code class="zig">@setCold(is_cold: bool)</code></pre>5980 <pre>{#syntax#}@setCold(is_cold: bool){#endsyntax#}</pre>
5978 <p>5981 <p>
5979 Tells the optimizer that a function is rarely called.5982 Tells the optimizer that a function is rarely called.
5980 </p>5983 </p>
5981 {#header_close#}5984 {#header_close#}
5982 {#header_open|@setRuntimeSafety#}5985 {#header_open|@setRuntimeSafety#}
5983 <pre><code class="zig">@setRuntimeSafety(safety_on: bool)</code></pre>5986 <pre>{#syntax#}@setRuntimeSafety(safety_on: bool){#endsyntax#}</pre>
5984 <p>5987 <p>
5985 Sets whether runtime safety checks are on for the scope that contains the function call.5988 Sets whether runtime safety checks are on for the scope that contains the function call.
5986 </p>5989 </p>
59875990
5988 {#header_close#}5991 {#header_close#}
5989 {#header_open|@setEvalBranchQuota#}5992 {#header_open|@setEvalBranchQuota#}
5990 <pre><code class="zig">@setEvalBranchQuota(new_quota: usize)</code></pre>5993 <pre>{#syntax#}@setEvalBranchQuota(new_quota: usize){#endsyntax#}</pre>
5991 <p>5994 <p>
5992 Changes the maximum number of backwards branches that compile-time code5995 Changes the maximum number of backwards branches that compile-time code
5993 execution can use before giving up and making a compile error.5996 execution can use before giving up and making a compile error.
5994 </p>5997 </p>
5995 <p>5998 <p>
5996 If the <code>new_quota</code> is smaller than the default quota (<code>1000</code>) or5999 If the {#syntax#}new_quota{#endsyntax#} is smaller than the default quota ({#syntax#}1000{#endsyntax#}) or
5997 a previously explicitly set quota, it is ignored.6000 a previously explicitly set quota, it is ignored.
5998 </p>6001 </p>
5999 <p>6002 <p>
...@@ -6007,7 +6010,7 @@ test "foo" {...@@ -6007,7 +6010,7 @@ test "foo" {
6007 }6010 }
6008}6011}
6009 {#code_end#}6012 {#code_end#}
6010 <p>Now we use <code class="zig">@setEvalBranchQuota</code>:</p>6013 <p>Now we use {#syntax#}@setEvalBranchQuota{#endsyntax#}:</p>
6011 {#code_begin|test#}6014 {#code_begin|test#}
6012test "foo" {6015test "foo" {
6013 comptime {6016 comptime {
...@@ -6021,7 +6024,7 @@ test "foo" {...@@ -6021,7 +6024,7 @@ test "foo" {
6021 {#see_also|comptime#}6024 {#see_also|comptime#}
6022 {#header_close#}6025 {#header_close#}
6023 {#header_open|@setFloatMode#}6026 {#header_open|@setFloatMode#}
6024 <pre><code class="zig">@setFloatMode(mode: @import("builtin").FloatMode)</code></pre>6027 <pre>{#syntax#}@setFloatMode(mode: @import("builtin").FloatMode){#endsyntax#}</pre>
6025 <p>6028 <p>
6026 Sets the floating point mode of the current scope. Possible values are:6029 Sets the floating point mode of the current scope. Possible values are:
6027 </p>6030 </p>
...@@ -6033,10 +6036,10 @@ pub const FloatMode = enum {...@@ -6033,10 +6036,10 @@ pub const FloatMode = enum {
6033 {#code_end#}6036 {#code_end#}
6034 <ul>6037 <ul>
6035 <li>6038 <li>
6036 <code>Strict</code> (default) - Floating point operations follow strict IEEE compliance.6039 {#syntax#}Strict{#endsyntax#} (default) - Floating point operations follow strict IEEE compliance.
6037 </li>6040 </li>
6038 <li>6041 <li>
6039 <code>Optimized</code> - Floating point operations may do all of the following:6042 {#syntax#}Optimized{#endsyntax#} - Floating point operations may do all of the following:
6040 <ul>6043 <ul>
6041 <li>Assume the arguments and result are not NaN. Optimizations are required to retain defined behavior over NaNs, but the value of the result is undefined.</li>6044 <li>Assume the arguments and result are not NaN. Optimizations are required to retain defined behavior over NaNs, but the value of the result is undefined.</li>
6042 <li>Assume the arguments and result are not +/-Inf. Optimizations are required to retain defined behavior over +/-Inf, but the value of the result is undefined.</li>6045 <li>Assume the arguments and result are not +/-Inf. Optimizations are required to retain defined behavior over +/-Inf, but the value of the result is undefined.</li>
...@@ -6055,54 +6058,54 @@ pub const FloatMode = enum {...@@ -6055,54 +6058,54 @@ pub const FloatMode = enum {
6055 {#see_also|Floating Point Operations#}6058 {#see_also|Floating Point Operations#}
6056 {#header_close#}6059 {#header_close#}
6057 {#header_open|@setGlobalLinkage#}6060 {#header_open|@setGlobalLinkage#}
6058 <pre><code class="zig">@setGlobalLinkage(global_variable_name, comptime linkage: GlobalLinkage)</code></pre>6061 <pre>{#syntax#}@setGlobalLinkage(global_variable_name, comptime linkage: GlobalLinkage){#endsyntax#}</pre>
6059 <p>6062 <p>
6060 <code>GlobalLinkage</code> can be found with <code>@import("builtin").GlobalLinkage</code>.6063 {#syntax#}GlobalLinkage{#endsyntax#} can be found with {#syntax#}@import("builtin").GlobalLinkage{#endsyntax#}.
6061 </p>6064 </p>
6062 {#see_also|Compile Variables#}6065 {#see_also|Compile Variables#}
6063 {#header_close#}6066 {#header_close#}
6064 {#header_open|@shlExact#}6067 {#header_open|@shlExact#}
6065 <pre><code class="zig">@shlExact(value: T, shift_amt: Log2T) T</code></pre>6068 <pre>{#syntax#}@shlExact(value: T, shift_amt: Log2T) T{#endsyntax#}</pre>
6066 <p>6069 <p>
6067 Performs the left shift operation (<code>&lt;&lt;</code>). Caller guarantees6070 Performs the left shift operation ({#syntax#}<<{#endsyntax#}). Caller guarantees
6068 that the shift will not shift any 1 bits out.6071 that the shift will not shift any 1 bits out.
6069 </p>6072 </p>
6070 <p>6073 <p>
6071 The type of <code>shift_amt</code> is an unsigned integer with <code>log2(T.bit_count)</code> bits.6074 The type of {#syntax#}shift_amt{#endsyntax#} is an unsigned integer with {#syntax#}log2(T.bit_count){#endsyntax#} bits.
6072 This is because <code>shift_amt &gt;= T.bit_count</code> is undefined behavior.6075 This is because {#syntax#}shift_amt >= T.bit_count{#endsyntax#} is undefined behavior.
6073 </p>6076 </p>
6074 {#see_also|@shrExact|@shlWithOverflow#}6077 {#see_also|@shrExact|@shlWithOverflow#}
6075 {#header_close#}6078 {#header_close#}
6076 {#header_open|@shlWithOverflow#}6079 {#header_open|@shlWithOverflow#}
6077 <pre><code class="zig">@shlWithOverflow(comptime T: type, a: T, shift_amt: Log2T, result: *T) bool</code></pre>6080 <pre>{#syntax#}@shlWithOverflow(comptime T: type, a: T, shift_amt: Log2T, result: *T) bool{#endsyntax#}</pre>
6078 <p>6081 <p>
6079 Performs <code>result.* = a &lt;&lt; b</code>. If overflow or underflow occurs,6082 Performs {#syntax#}result.* = a << b{#endsyntax#}. If overflow or underflow occurs,
6080 stores the overflowed bits in <code>result</code> and returns <code>true</code>.6083 stores the overflowed bits in {#syntax#}result{#endsyntax#} and returns {#syntax#}true{#endsyntax#}.
6081 If no overflow or underflow occurs, returns <code>false</code>.6084 If no overflow or underflow occurs, returns {#syntax#}false{#endsyntax#}.
6082 </p>6085 </p>
6083 <p>6086 <p>
6084 The type of <code>shift_amt</code> is an unsigned integer with <code>log2(T.bit_count)</code> bits.6087 The type of {#syntax#}shift_amt{#endsyntax#} is an unsigned integer with {#syntax#}log2(T.bit_count){#endsyntax#} bits.
6085 This is because <code>shift_amt &gt;= T.bit_count</code> is undefined behavior.6088 This is because {#syntax#}shift_amt >= T.bit_count{#endsyntax#} is undefined behavior.
6086 </p>6089 </p>
6087 {#see_also|@shlExact|@shrExact#}6090 {#see_also|@shlExact|@shrExact#}
6088 {#header_close#}6091 {#header_close#}
6089 {#header_open|@shrExact#}6092 {#header_open|@shrExact#}
6090 <pre><code class="zig">@shrExact(value: T, shift_amt: Log2T) T</code></pre>6093 <pre>{#syntax#}@shrExact(value: T, shift_amt: Log2T) T{#endsyntax#}</pre>
6091 <p>6094 <p>
6092 Performs the right shift operation (<code>&gt;&gt;</code>). Caller guarantees6095 Performs the right shift operation ({#syntax#}>>{#endsyntax#}). Caller guarantees
6093 that the shift will not shift any 1 bits out.6096 that the shift will not shift any 1 bits out.
6094 </p>6097 </p>
6095 <p>6098 <p>
6096 The type of <code>shift_amt</code> is an unsigned integer with <code>log2(T.bit_count)</code> bits.6099 The type of {#syntax#}shift_amt{#endsyntax#} is an unsigned integer with {#syntax#}log2(T.bit_count){#endsyntax#} bits.
6097 This is because <code>shift_amt &gt;= T.bit_count</code> is undefined behavior.6100 This is because {#syntax#}shift_amt >= T.bit_count{#endsyntax#} is undefined behavior.
6098 </p>6101 </p>
6099 {#see_also|@shlExact|@shlWithOverflow#}6102 {#see_also|@shlExact|@shlWithOverflow#}
6100 {#header_close#}6103 {#header_close#}
61016104
6102 {#header_open|@sizeOf#}6105 {#header_open|@sizeOf#}
6103 <pre><code class="zig">@sizeOf(comptime T: type) comptime_int</code></pre>6106 <pre>{#syntax#}@sizeOf(comptime T: type) comptime_int{#endsyntax#}</pre>
6104 <p>6107 <p>
6105 This function returns the number of bytes it takes to store <code>T</code> in memory.6108 This function returns the number of bytes it takes to store {#syntax#}T{#endsyntax#} in memory.
6106 </p>6109 </p>
6107 <p>6110 <p>
6108 The result is a target-specific compile time constant.6111 The result is a target-specific compile time constant.
...@@ -6110,39 +6113,39 @@ pub const FloatMode = enum {...@@ -6110,39 +6113,39 @@ pub const FloatMode = enum {
6110 {#header_close#}6113 {#header_close#}
61116114
6112 {#header_open|@sliceToBytes#}6115 {#header_open|@sliceToBytes#}
6113 <pre><code class="zig">@sliceToBytes(value: var) []u8</code></pre>6116 <pre>{#syntax#}@sliceToBytes(value: var) []u8{#endsyntax#}</pre>
6114 <p>6117 <p>
6115 Converts a slice or array to a slice of <code>u8</code>. The resulting slice has the same6118 Converts a slice or array to a slice of {#syntax#}u8{#endsyntax#}. The resulting slice has the same
6116 {#link|pointer|Pointers#} properties as the parameter.6119 {#link|pointer|Pointers#} properties as the parameter.
6117 </p>6120 </p>
6118 {#header_close#}6121 {#header_close#}
61196122
6120 {#header_open|@sqrt#}6123 {#header_open|@sqrt#}
6121 <pre><code class="zig">@sqrt(comptime T: type, value: T) T</code></pre>6124 <pre>{#syntax#}@sqrt(comptime T: type, value: T) T{#endsyntax#}</pre>
6122 <p>6125 <p>
6123 Performs the square root of a floating point number. Uses a dedicated hardware instruction6126 Performs the square root of a floating point number. Uses a dedicated hardware instruction
6124 when available. Currently only supports f32 and f64 at runtime. f128 at runtime is TODO.6127 when available. Currently only supports f32 and f64 at runtime. f128 at runtime is TODO.
6125 </p>6128 </p>
6126 <p>6129 <p>
6127 This is a low-level intrinsic. Most code can use <code>std.math.sqrt</code> instead.6130 This is a low-level intrinsic. Most code can use {#syntax#}std.math.sqrt{#endsyntax#} instead.
6128 </p>6131 </p>
6129 {#header_close#}6132 {#header_close#}
6130 {#header_open|@subWithOverflow#}6133 {#header_open|@subWithOverflow#}
6131 <pre><code class="zig">@subWithOverflow(comptime T: type, a: T, b: T, result: *T) bool</code></pre>6134 <pre>{#syntax#}@subWithOverflow(comptime T: type, a: T, b: T, result: *T) bool{#endsyntax#}</pre>
6132 <p>6135 <p>
6133 Performs <code>result.* = a - b</code>. If overflow or underflow occurs,6136 Performs {#syntax#}result.* = a - b{#endsyntax#}. If overflow or underflow occurs,
6134 stores the overflowed bits in <code>result</code> and returns <code>true</code>.6137 stores the overflowed bits in {#syntax#}result{#endsyntax#} and returns {#syntax#}true{#endsyntax#}.
6135 If no overflow or underflow occurs, returns <code>false</code>.6138 If no overflow or underflow occurs, returns {#syntax#}false{#endsyntax#}.
6136 </p>6139 </p>
6137 {#header_close#}6140 {#header_close#}
6138 {#header_open|@tagName#}6141 {#header_open|@tagName#}
6139 <pre><code class="zig">@tagName(value: var) []const u8</code></pre>6142 <pre>{#syntax#}@tagName(value: var) []const u8{#endsyntax#}</pre>
6140 <p>6143 <p>
6141 Converts an enum value or union value to a slice of bytes representing the name.6144 Converts an enum value or union value to a slice of bytes representing the name.
6142 </p>6145 </p>
6143 {#header_close#}6146 {#header_close#}
6144 {#header_open|@TagType#}6147 {#header_open|@TagType#}
6145 <pre><code class="zig">@TagType(T: type) type</code></pre>6148 <pre>{#syntax#}@TagType(T: type) type{#endsyntax#}</pre>
6146 <p>6149 <p>
6147 For an enum, returns the integer type that is used to store the enumeration value.6150 For an enum, returns the integer type that is used to store the enumeration value.
6148 </p>6151 </p>
...@@ -6151,7 +6154,7 @@ pub const FloatMode = enum {...@@ -6151,7 +6154,7 @@ pub const FloatMode = enum {
6151 </p>6154 </p>
6152 {#header_close#}6155 {#header_close#}
6153 {#header_open|@truncate#}6156 {#header_open|@truncate#}
6154 <pre><code class="zig">@truncate(comptime T: type, integer) T</code></pre>6157 <pre>{#syntax#}@truncate(comptime T: type, integer) T{#endsyntax#}</pre>
6155 <p>6158 <p>
6156 This function truncates bits from an integer type, resulting in a smaller6159 This function truncates bits from an integer type, resulting in a smaller
6157 integer type.6160 integer type.
...@@ -6160,14 +6163,14 @@ pub const FloatMode = enum {...@@ -6160,14 +6163,14 @@ pub const FloatMode = enum {
6160 The following produces a crash in debug mode and undefined behavior in6163 The following produces a crash in debug mode and undefined behavior in
6161 release mode:6164 release mode:
6162 </p>6165 </p>
6163 <pre><code class="zig">const a: u16 = 0xabcd;6166 <pre>{#syntax#}const a: u16 = 0xabcd;
6164const b: u8 = u8(a);</code></pre>6167const b: u8 = u8(a);{#endsyntax#}</pre>
6165 <p>6168 <p>
6166 However this is well defined and working code:6169 However this is well defined and working code:
6167 </p>6170 </p>
6168 <pre><code class="zig">const a: u16 = 0xabcd;6171 <pre>{#syntax#}const a: u16 = 0xabcd;
6169const b: u8 = @truncate(u8, a);6172const b: u8 = @truncate(u8, a);
6170// b is now 0xcd</code></pre>6173// b is now 0xcd{#endsyntax#}</pre>
6171 <p>6174 <p>
6172 This function always truncates the significant bits of the integer, regardless6175 This function always truncates the significant bits of the integer, regardless
6173 of endianness on the target platform.6176 of endianness on the target platform.
...@@ -6175,7 +6178,7 @@ const b: u8 = @truncate(u8, a);...@@ -6175,7 +6178,7 @@ const b: u8 = @truncate(u8, a);
61756178
6176 {#header_close#}6179 {#header_close#}
6177 {#header_open|@typeId#}6180 {#header_open|@typeId#}
6178 <pre><code class="zig">@typeId(comptime T: type) @import("builtin").TypeId</code></pre>6181 <pre>{#syntax#}@typeId(comptime T: type) @import("builtin").TypeId{#endsyntax#}</pre>
6179 <p>6182 <p>
6180 Returns which kind of type something is. Possible values:6183 Returns which kind of type something is. Possible values:
6181 </p>6184 </p>
...@@ -6209,7 +6212,7 @@ pub const TypeId = enum {...@@ -6209,7 +6212,7 @@ pub const TypeId = enum {
6209 {#code_end#}6212 {#code_end#}
6210 {#header_close#}6213 {#header_close#}
6211 {#header_open|@typeInfo#}6214 {#header_open|@typeInfo#}
6212 <pre><code class="zig">@typeInfo(comptime T: type) @import("builtin").TypeInfo</code></pre>6215 <pre>{#syntax#}@typeInfo(comptime T: type) @import("builtin").TypeInfo{#endsyntax#}</pre>
6213 <p>6216 <p>
6214 Returns information on the type. Returns a value of the following union:6217 Returns information on the type. Returns a value of the following union:
6215 </p>6218 </p>
...@@ -6392,14 +6395,14 @@ pub const TypeInfo = union(TypeId) {...@@ -6392,14 +6395,14 @@ pub const TypeInfo = union(TypeId) {
6392 {#code_end#}6395 {#code_end#}
6393 {#header_close#}6396 {#header_close#}
6394 {#header_open|@typeName#}6397 {#header_open|@typeName#}
6395 <pre><code class="zig">@typeName(T: type) []u8</code></pre>6398 <pre>{#syntax#}@typeName(T: type) []u8{#endsyntax#}</pre>
6396 <p>6399 <p>
6397 This function returns the string representation of a type.6400 This function returns the string representation of a type.
6398 </p>6401 </p>
63996402
6400 {#header_close#}6403 {#header_close#}
6401 {#header_open|@typeOf#}6404 {#header_open|@typeOf#}
6402 <pre><code class="zig">@typeOf(expression) type</code></pre>6405 <pre>{#syntax#}@typeOf(expression) type{#endsyntax#}</pre>
6403 <p>6406 <p>
6404 This function returns a compile-time constant, which is the type of the6407 This function returns a compile-time constant, which is the type of the
6405 expression passed as an argument. The expression is evaluated.6408 expression passed as an argument. The expression is evaluated.
...@@ -6576,11 +6579,11 @@ pub fn main() void {...@@ -6576,11 +6579,11 @@ pub fn main() void {
6576 {#header_open|Default Operations#}6579 {#header_open|Default Operations#}
6577 <p>The following operators can cause integer overflow:</p>6580 <p>The following operators can cause integer overflow:</p>
6578 <ul>6581 <ul>
6579 <li><code>+</code> (addition)</li>6582 <li>{#syntax#}+{#endsyntax#} (addition)</li>
6580 <li><code>-</code> (subtraction)</li>6583 <li>{#syntax#}-{#endsyntax#} (subtraction)</li>
6581 <li><code>-</code> (negation)</li>6584 <li>{#syntax#}-{#endsyntax#} (negation)</li>
6582 <li><code>*</code> (multiplication)</li>6585 <li>{#syntax#}*{#endsyntax#} (multiplication)</li>
6583 <li><code>/</code> (division)</li>6586 <li>{#syntax#}/{#endsyntax#} (division)</li>
6584 <li>{#link|@divTrunc#} (division)</li>6587 <li>{#link|@divTrunc#} (division)</li>
6585 <li>{#link|@divFloor#} (division)</li>6588 <li>{#link|@divFloor#} (division)</li>
6586 <li>{#link|@divExact#} (division)</li>6589 <li>{#link|@divExact#} (division)</li>
...@@ -6606,13 +6609,13 @@ pub fn main() void {...@@ -6606,13 +6609,13 @@ pub fn main() void {
6606 {#header_open|Standard Library Math Functions#}6609 {#header_open|Standard Library Math Functions#}
6607 <p>These functions provided by the standard library return possible errors.</p>6610 <p>These functions provided by the standard library return possible errors.</p>
6608 <ul>6611 <ul>
6609 <li><code>@import("std").math.add</code></li>6612 <li>{#syntax#}@import("std").math.add{#endsyntax#}</li>
6610 <li><code>@import("std").math.sub</code></li>6613 <li>{#syntax#}@import("std").math.sub{#endsyntax#}</li>
6611 <li><code>@import("std").math.mul</code></li>6614 <li>{#syntax#}@import("std").math.mul{#endsyntax#}</li>
6612 <li><code>@import("std").math.divTrunc</code></li>6615 <li>{#syntax#}@import("std").math.divTrunc{#endsyntax#}</li>
6613 <li><code>@import("std").math.divFloor</code></li>6616 <li>{#syntax#}@import("std").math.divFloor{#endsyntax#}</li>
6614 <li><code>@import("std").math.divExact</code></li>6617 <li>{#syntax#}@import("std").math.divExact{#endsyntax#}</li>
6615 <li><code>@import("std").math.shl</code></li>6618 <li>{#syntax#}@import("std").math.shl{#endsyntax#}</li>
6616 </ul>6619 </ul>
6617 <p>Example of catching an overflow for addition:</p>6620 <p>Example of catching an overflow for addition:</p>
6618 {#code_begin|exe_err#}6621 {#code_begin|exe_err#}
...@@ -6632,7 +6635,7 @@ pub fn main() !void {...@@ -6632,7 +6635,7 @@ pub fn main() !void {
6632 {#header_close#}6635 {#header_close#}
6633 {#header_open|Builtin Overflow Functions#}6636 {#header_open|Builtin Overflow Functions#}
6634 <p>6637 <p>
6635 These builtins return a <code>bool</code> of whether or not overflow6638 These builtins return a {#syntax#}bool{#endsyntax#} of whether or not overflow
6636 occurred, as well as returning the overflowed bits:6639 occurred, as well as returning the overflowed bits:
6637 </p>6640 </p>
6638 <ul>6641 <ul>
...@@ -6663,10 +6666,10 @@ pub fn main() void {...@@ -6663,10 +6666,10 @@ pub fn main() void {
6663 These operations have guaranteed wraparound semantics.6666 These operations have guaranteed wraparound semantics.
6664 </p>6667 </p>
6665 <ul>6668 <ul>
6666 <li><code>+%</code> (wraparound addition)</li>6669 <li>{#syntax#}+%{#endsyntax#} (wraparound addition)</li>
6667 <li><code>-%</code> (wraparound subtraction)</li>6670 <li>{#syntax#}-%{#endsyntax#} (wraparound subtraction)</li>
6668 <li><code>-%</code> (wraparound negation)</li>6671 <li>{#syntax#}-%{#endsyntax#} (wraparound negation)</li>
6669 <li><code>*%</code> (wraparound multiplication)</li>6672 <li>{#syntax#}*%{#endsyntax#} (wraparound multiplication)</li>
6670 </ul>6673 </ul>
6671 {#code_begin|test#}6674 {#code_begin|test#}
6672const assert = @import("std").debug.assert;6675const assert = @import("std").debug.assert;
...@@ -6818,7 +6821,7 @@ pub fn main() void {...@@ -6818,7 +6821,7 @@ pub fn main() void {
6818}6821}
6819 {#code_end#}6822 {#code_end#}
6820 <p>One way to avoid this crash is to test for null instead of assuming non-null, with6823 <p>One way to avoid this crash is to test for null instead of assuming non-null, with
6821 the <code>if</code> expression:</p>6824 the {#syntax#}if{#endsyntax#} expression:</p>
6822 {#code_begin|exe|test#}6825 {#code_begin|exe|test#}
6823const warn = @import("std").debug.warn;6826const warn = @import("std").debug.warn;
6824pub fn main() void {6827pub fn main() void {
...@@ -6858,7 +6861,7 @@ fn getNumberOrFail() !i32 {...@@ -6858,7 +6861,7 @@ fn getNumberOrFail() !i32 {
6858}6861}
6859 {#code_end#}6862 {#code_end#}
6860 <p>One way to avoid this crash is to test for an error instead of assuming a successful result, with6863 <p>One way to avoid this crash is to test for an error instead of assuming a successful result, with
6861 the <code>if</code> expression:</p>6864 the {#syntax#}if{#endsyntax#} expression:</p>
6862 {#code_begin|exe#}6865 {#code_begin|exe#}
6863const warn = @import("std").debug.warn;6866const warn = @import("std").debug.warn;
68646867
...@@ -7022,7 +7025,7 @@ fn bar(f: *Foo) void {...@@ -7022,7 +7025,7 @@ fn bar(f: *Foo) void {
7022}7025}
7023 {#code_end#}7026 {#code_end#}
7024 <p>7027 <p>
7025 This safety is not available for <code>extern</code> or <code>packed</code> unions.7028 This safety is not available for {#syntax#}extern{#endsyntax#} or {#syntax#}packed{#endsyntax#} unions.
7026 </p>7029 </p>
7027 <p>7030 <p>
7028 To change the active field of a union, assign the entire union, like this:7031 To change the active field of a union, assign the entire union, like this:
...@@ -7087,7 +7090,7 @@ fn bar(f: *Foo) void {...@@ -7087,7 +7090,7 @@ fn bar(f: *Foo) void {
7087 {#header_close#}7090 {#header_close#}
7088 {#header_open|Compile Variables#}7091 {#header_open|Compile Variables#}
7089 <p>7092 <p>
7090 Compile variables are accessible by importing the <code>"builtin"</code> package,7093 Compile variables are accessible by importing the {#syntax#}"builtin"{#endsyntax#} package,
7091 which the compiler makes available to every Zig source file. It contains7094 which the compiler makes available to every Zig source file. It contains
7092 compile-time constants such as the current target, endianness, and release mode.7095 compile-time constants such as the current target, endianness, and release mode.
7093 </p>7096 </p>
...@@ -7096,7 +7099,7 @@ const builtin = @import("builtin");...@@ -7096,7 +7099,7 @@ const builtin = @import("builtin");
7096const separator = if (builtin.os == builtin.Os.windows) '\\' else '/';7099const separator = if (builtin.os == builtin.Os.windows) '\\' else '/';
7097 {#code_end#}7100 {#code_end#}
7098 <p>7101 <p>
7099 Example of what is imported with <code>@import("builtin")</code>:7102 Example of what is imported with {#syntax#}@import("builtin"){#endsyntax#}:
7100 </p>7103 </p>
7101 {#builtin#}7104 {#builtin#}
7102 {#see_also|Build Mode#}7105 {#see_also|Build Mode#}
...@@ -7135,16 +7138,16 @@ const separator = if (builtin.os == builtin.Os.windows) '\\' else '/';...@@ -7135,16 +7138,16 @@ const separator = if (builtin.os == builtin.Os.windows) '\\' else '/';
7135 These have guaranteed C ABI compatibility and can be used like any other type.7138 These have guaranteed C ABI compatibility and can be used like any other type.
7136 </p>7139 </p>
7137 <ul>7140 <ul>
7138 <li><code>c_short</code></li>7141 <li>{#syntax#}c_short{#endsyntax#}</li>
7139 <li><code>c_ushort</code></li>7142 <li>{#syntax#}c_ushort{#endsyntax#}</li>
7140 <li><code>c_int</code></li>7143 <li>{#syntax#}c_int{#endsyntax#}</li>
7141 <li><code>c_uint</code></li>7144 <li>{#syntax#}c_uint{#endsyntax#}</li>
7142 <li><code>c_long</code></li>7145 <li>{#syntax#}c_long{#endsyntax#}</li>
7143 <li><code>c_ulong</code></li>7146 <li>{#syntax#}c_ulong{#endsyntax#}</li>
7144 <li><code>c_longlong</code></li>7147 <li>{#syntax#}c_longlong{#endsyntax#}</li>
7145 <li><code>c_ulonglong</code></li>7148 <li>{#syntax#}c_ulonglong{#endsyntax#}</li>
7146 <li><code>c_longdouble</code></li>7149 <li>{#syntax#}c_longdouble{#endsyntax#}</li>
7147 <li><code>c_void</code></li>7150 <li>{#syntax#}c_void{#endsyntax#}</li>
7148 </ul>7151 </ul>
7149 {#see_also|Primitive Types#}7152 {#see_also|Primitive Types#}
7150 {#header_close#}7153 {#header_close#}
...@@ -7166,7 +7169,7 @@ pub fn main() void {...@@ -7166,7 +7169,7 @@ pub fn main() void {
7166 {#header_close#}7169 {#header_close#}
7167 {#header_open|Import from C Header File#}7170 {#header_open|Import from C Header File#}
7168 <p>7171 <p>
7169 The <code>@cImport</code> builtin function can be used7172 The {#syntax#}@cImport{#endsyntax#} builtin function can be used
7170 to directly import symbols from .h files:7173 to directly import symbols from .h files:
7171 </p>7174 </p>
7172 {#code_begin|exe#}7175 {#code_begin|exe#}
...@@ -7181,7 +7184,7 @@ pub fn main() void {...@@ -7181,7 +7184,7 @@ pub fn main() void {
7181}7184}
7182 {#code_end#}7185 {#code_end#}
7183 <p>7186 <p>
7184 The <code>@cImport</code> function takes an expression as a parameter.7187 The {#syntax#}@cImport{#endsyntax#} function takes an expression as a parameter.
7185 This expression is evaluated at compile-time and is used to control7188 This expression is evaluated at compile-time and is used to control
7186 preprocessor directives and include multiple .h files:7189 preprocessor directives and include multiple .h files:
7187 </p>7190 </p>
...@@ -7205,7 +7208,7 @@ const c = @cImport({...@@ -7205,7 +7208,7 @@ const c = @cImport({
7205 {#header_open|Exporting a C Library#}7208 {#header_open|Exporting a C Library#}
7206 <p>7209 <p>
7207 One of the primary use cases for Zig is exporting a library with the C ABI for other programming languages7210 One of the primary use cases for Zig is exporting a library with the C ABI for other programming languages
7208 to call into. The <code>export</code> keyword in front of functions, variables, and types causes them to7211 to call into. The {#syntax#}export{#endsyntax#} keyword in front of functions, variables, and types causes them to
7209 be part of the library API:7212 be part of the library API:
7210 </p>7213 </p>
7211 <p class="file">mathtest.zig</p>7214 <p class="file">mathtest.zig</p>
...@@ -7454,7 +7457,7 @@ Environments:...@@ -7454,7 +7457,7 @@ Environments:
7454 coreclr7457 coreclr
7455 opencl</code></pre>7458 opencl</code></pre>
7456 <p>7459 <p>
7457 The Zig Standard Library (<code>@import("std")</code>) has architecture, environment, and operating sytsem7460 The Zig Standard Library ({#syntax#}@import("std"){#endsyntax#}) has architecture, environment, and operating sytsem
7458 abstractions, and thus takes additional work to support more platforms.7461 abstractions, and thus takes additional work to support more platforms.
7459 Not all standard library code requires operating system abstractions, however,7462 Not all standard library code requires operating system abstractions, however,
7460 so things such as generic data structures work an all above platforms.7463 so things such as generic data structures work an all above platforms.
...@@ -7491,25 +7494,25 @@ coding style....@@ -7491,25 +7494,25 @@ coding style.
7491 {#header_close#}7494 {#header_close#}
7492 {#header_open|Names#}7495 {#header_open|Names#}
7493 <p>7496 <p>
7494 Roughly speaking: <code>camelCaseFunctionName</code>, <code>TitleCaseTypeName</code>,7497 Roughly speaking: {#syntax#}camelCaseFunctionName{#endsyntax#}, {#syntax#}TitleCaseTypeName{#endsyntax#},
7495 <code>snake_case_variable_name</code>. More precisely:7498 {#syntax#}snake_case_variable_name{#endsyntax#}. More precisely:
7496 </p>7499 </p>
7497 <ul>7500 <ul>
7498 <li>7501 <li>
7499 If <code>x</code> is a <code>struct</code> (or an alias of a <code>struct</code>),7502 If {#syntax#}x{#endsyntax#} is a {#syntax#}struct{#endsyntax#} (or an alias of a {#syntax#}struct{#endsyntax#}),
7500 then <code>x</code> should be <code>TitleCase</code>.7503 then {#syntax#}x{#endsyntax#} should be {#syntax#}TitleCase{#endsyntax#}.
7501 </li>7504 </li>
7502 <li>7505 <li>
7503 If <code>x</code> otherwise identifies a type, <code>x</code> should have <code>snake_case</code>.7506 If {#syntax#}x{#endsyntax#} otherwise identifies a type, {#syntax#}x{#endsyntax#} should have {#syntax#}snake_case{#endsyntax#}.
7504 </li>7507 </li>
7505 <li>7508 <li>
7506 If <code>x</code> is callable, and <code>x</code>'s return type is <code>type</code>, then <code>x</code> should be <code>TitleCase</code>.7509 If {#syntax#}x{#endsyntax#} is callable, and {#syntax#}x{#endsyntax#}'s return type is {#syntax#}type{#endsyntax#}, then {#syntax#}x{#endsyntax#} should be {#syntax#}TitleCase{#endsyntax#}.
7507 </li>7510 </li>
7508 <li>7511 <li>
7509 If <code>x</code> is otherwise callable, then <code>x</code> should be <code>camelCase</code>.7512 If {#syntax#}x{#endsyntax#} is otherwise callable, then {#syntax#}x{#endsyntax#} should be {#syntax#}camelCase{#endsyntax#}.
7510 </li>7513 </li>
7511 <li>7514 <li>
7512 Otherwise, <code>x</code> should be <code>snake_case</code>.7515 Otherwise, {#syntax#}x{#endsyntax#} should be {#syntax#}snake_case{#endsyntax#}.
7513 </li>7516 </li>
7514 </ul>7517 </ul>
7515 <p>7518 <p>
...@@ -7521,7 +7524,7 @@ coding style....@@ -7521,7 +7524,7 @@ coding style.
7521 <p>7524 <p>
7522 These are general rules of thumb; if it makes sense to do something different,7525 These are general rules of thumb; if it makes sense to do something different,
7523 do what makes sense. For example, if there is an established convention such as7526 do what makes sense. For example, if there is an established convention such as
7524 <code>ENOENT</code>, follow the established convention.7527 {#syntax#}ENOENT{#endsyntax#}, follow the established convention.
7525 </p>7528 </p>
7526 {#header_close#}7529 {#header_close#}
7527 {#header_open|Examples#}7530 {#header_open|Examples#}