6072 lines
201 KiB
HTML
6072 lines
201 KiB
HTML
<!doctype html>
|
|
<html>
|
|
<head>
|
|
<meta charset="utf-8">
|
|
<meta name="viewport" content="width=device-width, initial-scale=1, user-scalable=no" />
|
|
<title>Documentation - The Zig Programming Language</title>
|
|
<style type="text/css">
|
|
.hljs{display:block;overflow-x:auto;padding:0.5em;color:#333;background:#f8f8f8}.hljs-comment,.hljs-quote{color:#998;font-style:italic}.hljs-keyword,.hljs-selector-tag,.hljs-subst{color:#333;font-weight:bold}.hljs-number,.hljs-literal,.hljs-variable,.hljs-template-variable,.hljs-tag .hljs-attr{color:#008080}.hljs-string,.hljs-doctag{color:#d14}.hljs-title,.hljs-section,.hljs-selector-id{color:#900;font-weight:bold}.hljs-subst{font-weight:normal}.hljs-type,.hljs-class .hljs-title{color:#458;font-weight:bold}.hljs-tag,.hljs-name,.hljs-attribute{color:#000080;font-weight:normal}.hljs-regexp,.hljs-link{color:#009926}.hljs-symbol,.hljs-bullet{color:#990073}.hljs-built_in,.hljs-builtin-name{color:#0086b3}.hljs-meta{color:#999;font-weight:bold}.hljs-deletion{background:#fdd}.hljs-addition{background:#dfd}.hljs-emphasis{font-style:italic}.hljs-strong{font-weight:bold}
|
|
</style>
|
|
<style type="text/css">
|
|
table, th, td {
|
|
border-collapse: collapse;
|
|
border: 1px solid grey;
|
|
}
|
|
th, td {
|
|
padding: 0.1em;
|
|
}
|
|
.t0_1, .t37, .t37_1 {
|
|
font-weight: bold;
|
|
}
|
|
.t2_0 {
|
|
color: grey;
|
|
}
|
|
.t31_1 {
|
|
color: red;
|
|
}
|
|
.t32_1 {
|
|
color: green;
|
|
}
|
|
.t36_1 {
|
|
color: #0086b3;
|
|
}
|
|
.file {
|
|
text-decoration: underline;
|
|
}
|
|
code {
|
|
font-size: 12pt;
|
|
}
|
|
pre > code {
|
|
display: block;
|
|
overflow: auto;
|
|
}
|
|
.table-wrapper {
|
|
width: 100%;
|
|
overflow-y: auto;
|
|
}
|
|
/* Desktop */
|
|
@media screen and (min-width: 56.25em) {
|
|
#nav {
|
|
width: 20em;
|
|
height: 100%;
|
|
position: fixed;
|
|
overflow-y: scroll;
|
|
left: 0;
|
|
top: 0;
|
|
padding-left: 1em;
|
|
}
|
|
#contents {
|
|
max-width: 60em;
|
|
padding-left: 22em;
|
|
padding: 1em;
|
|
padding-left: 24em;
|
|
}
|
|
}
|
|
/* Mobile */
|
|
@media screen and (max-width: 56.25em) {
|
|
body, code {
|
|
font-size: small;
|
|
}
|
|
#nav {
|
|
border-bottom: 1px solid grey;
|
|
}
|
|
}
|
|
</style>
|
|
</head>
|
|
<body>
|
|
<div id="nav">
|
|
<h3>Index</h3>
|
|
{#nav#}
|
|
</div>
|
|
<div id="contents">
|
|
{#header_open|Introduction#}
|
|
<p>
|
|
Zig is an open-source programming language designed for <strong>robustness</strong>,
|
|
<strong>optimality</strong>, and <strong>clarity</strong>.
|
|
</p>
|
|
<ul>
|
|
<li><strong>Robust</strong> - behavior is correct even for edge cases such as out of memory.</li>
|
|
<li><strong>Optimal</strong> - write programs the best way they can behave and perform.</li>
|
|
<li><strong>Clear</strong> - precisely communicate your intent to the compiler and other programmers. The language imposes a low overhead to reading code.</li>
|
|
</ul>
|
|
<p>
|
|
Often the most efficient way to learn something new is to see examples, so
|
|
this documentation shows how to use each of Zig's features. It is
|
|
all on one page so you can search with your browser's search tool.
|
|
</p>
|
|
<p>
|
|
If you search for something specific in this documentation and do not find it,
|
|
please <a href="https://github.com/zig-lang/www.ziglang.org/issues/new?title=I%20searched%20for%20___%20in%20the%20docs%20and%20didn%27t%20find%20it">file an issue</a> or <a href="https://webchat.freenode.net/?channels=%23zig">say something on IRC</a>.
|
|
</p>
|
|
<p>
|
|
The code samples in this document are compiled and tested as part of the main test suite of Zig.
|
|
This HTML document depends on no external files, so you can use it offline.
|
|
</p>
|
|
{#header_close#}
|
|
{#header_open|Hello World#}
|
|
|
|
{#code_begin|exe|hello#}
|
|
const std = @import("std");
|
|
|
|
pub fn main() !void {
|
|
// If this program is run without stdout attached, exit with an error.
|
|
var stdout_file = try std.io.getStdOut();
|
|
// If this program encounters pipe failure when printing to stdout, exit
|
|
// with an error.
|
|
try stdout_file.write("Hello, world!\n");
|
|
}
|
|
{#code_end#}
|
|
<p>
|
|
Usually you don't want to write to stdout. You want to write to stderr. And you
|
|
don't care if it fails. It's more like a <em>warning message</em> that you want
|
|
to emit. For that you can use a simpler API:
|
|
</p>
|
|
{#code_begin|exe|hello#}
|
|
const warn = @import("std").debug.warn;
|
|
|
|
pub fn main() void {
|
|
warn("Hello, world!\n");
|
|
}
|
|
{#code_end#}
|
|
<p>
|
|
Note that we also left off the <code class="zig">!</code> from the return type.
|
|
In Zig, if your main function cannot fail, you must use the <code class="zig">void</code> return type.
|
|
</p>
|
|
{#see_also|Values|@import|Errors|Root Source File#}
|
|
{#header_close#}
|
|
{#header_open|Values#}
|
|
{#code_begin|exe|values#}
|
|
const std = @import("std");
|
|
const warn = std.debug.warn;
|
|
const os = std.os;
|
|
const assert = std.debug.assert;
|
|
|
|
pub fn main() void {
|
|
// integers
|
|
const one_plus_one: i32 = 1 + 1;
|
|
warn("1 + 1 = {}\n", one_plus_one);
|
|
|
|
// floats
|
|
const seven_div_three: f32 = 7.0 / 3.0;
|
|
warn("7.0 / 3.0 = {}\n", seven_div_three);
|
|
|
|
// boolean
|
|
warn("{}\n{}\n{}\n",
|
|
true and false,
|
|
true or false,
|
|
!true);
|
|
|
|
// nullable
|
|
var nullable_value: ?[]const u8 = null;
|
|
assert(nullable_value == null);
|
|
|
|
warn("\nnullable 1\ntype: {}\nvalue: {}\n",
|
|
@typeName(@typeOf(nullable_value)), nullable_value);
|
|
|
|
nullable_value = "hi";
|
|
assert(nullable_value != null);
|
|
|
|
warn("\nnullable 2\ntype: {}\nvalue: {}\n",
|
|
@typeName(@typeOf(nullable_value)), nullable_value);
|
|
|
|
// error union
|
|
var number_or_error: error!i32 = error.ArgNotFound;
|
|
|
|
warn("\nerror union 1\ntype: {}\nvalue: {}\n",
|
|
@typeName(@typeOf(number_or_error)), number_or_error);
|
|
|
|
number_or_error = 1234;
|
|
|
|
warn("\nerror union 2\ntype: {}\nvalue: {}\n",
|
|
@typeName(@typeOf(number_or_error)), number_or_error);
|
|
}
|
|
{#code_end#}
|
|
{#header_open|Primitive Types#}
|
|
<div class="table-wrapper">
|
|
<table>
|
|
<tr>
|
|
<th>
|
|
Name
|
|
</th>
|
|
<th>
|
|
C Equivalent
|
|
</th>
|
|
<th>
|
|
Description
|
|
</th>
|
|
</tr>
|
|
<tr>
|
|
<td><code>i2</code></td>
|
|
<td><code>(none)</code></td>
|
|
<td>signed 2-bit integer</td>
|
|
</tr>
|
|
<tr>
|
|
<td><code>u2</code></td>
|
|
<td><code>(none)</code></td>
|
|
<td>unsigned 2-bit integer</td>
|
|
</tr>
|
|
<tr>
|
|
<td><code>i3</code></td>
|
|
<td><code>(none)</code></td>
|
|
<td>signed 3-bit integer</td>
|
|
</tr>
|
|
<tr>
|
|
<td><code>u3</code></td>
|
|
<td><code>(none)</code></td>
|
|
<td>unsigned 3-bit integer</td>
|
|
</tr>
|
|
<tr>
|
|
<td><code>i4</code></td>
|
|
<td><code>(none)</code></td>
|
|
<td>signed 4-bit integer</td>
|
|
</tr>
|
|
<tr>
|
|
<td><code>u4</code></td>
|
|
<td><code>(none)</code></td>
|
|
<td>unsigned 4-bit integer</td>
|
|
</tr>
|
|
<tr>
|
|
<td><code>i5</code></td>
|
|
<td><code>(none)</code></td>
|
|
<td>signed 5-bit integer</td>
|
|
</tr>
|
|
<tr>
|
|
<td><code>u5</code></td>
|
|
<td><code>(none)</code></td>
|
|
<td>unsigned 5-bit integer</td>
|
|
</tr>
|
|
<tr>
|
|
<td><code>i6</code></td>
|
|
<td><code>(none)</code></td>
|
|
<td>signed 6-bit integer</td>
|
|
</tr>
|
|
<tr>
|
|
<td><code>u6</code></td>
|
|
<td><code>(none)</code></td>
|
|
<td>unsigned 6-bit integer</td>
|
|
</tr>
|
|
<tr>
|
|
<td><code>i7</code></td>
|
|
<td><code>(none)</code></td>
|
|
<td>signed 7-bit integer</td>
|
|
</tr>
|
|
<tr>
|
|
<td><code>u7</code></td>
|
|
<td><code>(none)</code></td>
|
|
<td>unsigned 7-bit integer</td>
|
|
</tr>
|
|
<tr>
|
|
<td><code>i8</code></td>
|
|
<td><code>int8_t</code></td>
|
|
<td>signed 8-bit integer</td>
|
|
</tr>
|
|
<tr>
|
|
<td><code>u8</code></td>
|
|
<td><code>uint8_t</code></td>
|
|
<td>unsigned 8-bit integer</td>
|
|
</tr>
|
|
<tr>
|
|
<td><code>i16</code></td>
|
|
<td><code>int16_t</code></td>
|
|
<td>signed 16-bit integer</td>
|
|
</tr>
|
|
<tr>
|
|
<td><code>u16</code></td>
|
|
<td><code>uint16_t</code></td>
|
|
<td>unsigned 16-bit integer</td>
|
|
</tr>
|
|
<tr>
|
|
<td><code>i32</code></td>
|
|
<td><code>int32_t</code></td>
|
|
<td>signed 32-bit integer</td>
|
|
</tr>
|
|
<tr>
|
|
<td><code>u32</code></td>
|
|
<td><code>uint32_t</code></td>
|
|
<td>unsigned 32-bit integer</td>
|
|
</tr>
|
|
<tr>
|
|
<td><code>i64</code></td>
|
|
<td><code>int64_t</code></td>
|
|
<td>signed 64-bit integer</td>
|
|
</tr>
|
|
<tr>
|
|
<td><code>u64</code></td>
|
|
<td><code>uint64_t</code></td>
|
|
<td>unsigned 64-bit integer</td>
|
|
</tr>
|
|
<tr>
|
|
<td><code>i128</code></td>
|
|
<td><code>__int128</code></td>
|
|
<td>signed 128-bit integer</td>
|
|
</tr>
|
|
<tr>
|
|
<td><code>u128</code></td>
|
|
<td><code>unsigned __int128</code></td>
|
|
<td>unsigned 128-bit integer</td>
|
|
</tr>
|
|
<tr>
|
|
<td><code>isize</code></td>
|
|
<td><code>intptr_t</code></td>
|
|
<td>signed pointer sized integer</td>
|
|
</tr>
|
|
<tr>
|
|
<td><code>usize</code></td>
|
|
<td><code>uintptr_t</code></td>
|
|
<td>unsigned pointer sized integer</td>
|
|
</tr>
|
|
|
|
<tr>
|
|
<td><code>c_short</code></td>
|
|
<td><code>short</code></td>
|
|
<td>for ABI compatibility with C</td>
|
|
</tr>
|
|
<tr>
|
|
<td><code>c_ushort</code></td>
|
|
<td><code>unsigned short</code></td>
|
|
<td>for ABI compatibility with C</td>
|
|
</tr>
|
|
<tr>
|
|
<td><code>c_int</code></td>
|
|
<td><code>int</code></td>
|
|
<td>for ABI compatibility with C</td>
|
|
</tr>
|
|
<tr>
|
|
<td><code>c_uint</code></td>
|
|
<td><code>unsigned int</code></td>
|
|
<td>for ABI compatibility with C</td>
|
|
</tr>
|
|
<tr>
|
|
<td><code>c_long</code></td>
|
|
<td><code>long</code></td>
|
|
<td>for ABI compatibility with C</td>
|
|
</tr>
|
|
<tr>
|
|
<td><code>c_ulong</code></td>
|
|
<td><code>unsigned long</code></td>
|
|
<td>for ABI compatibility with C</td>
|
|
</tr>
|
|
<tr>
|
|
<td><code>c_longlong</code></td>
|
|
<td><code>long long</code></td>
|
|
<td>for ABI compatibility with C</td>
|
|
</tr>
|
|
<tr>
|
|
<td><code>c_ulonglong</code></td>
|
|
<td><code>unsigned long long</code></td>
|
|
<td>for ABI compatibility with C</td>
|
|
</tr>
|
|
<tr>
|
|
<td><code>c_longdouble</code></td>
|
|
<td><code>long double</code></td>
|
|
<td>for ABI compatibility with C</td>
|
|
</tr>
|
|
<tr>
|
|
<td><code>c_void</code></td>
|
|
<td><code>void</code></td>
|
|
<td>for ABI compatibility with C</td>
|
|
</tr>
|
|
|
|
<tr>
|
|
<td><code>f32</code></td>
|
|
<td><code>float</code></td>
|
|
<td>32-bit floating point (23-bit mantissa)</td>
|
|
</tr>
|
|
<tr>
|
|
<td><code>f64</code></td>
|
|
<td><code>double</code></td>
|
|
<td>64-bit floating point (52-bit mantissa)</td>
|
|
</tr>
|
|
<tr>
|
|
<td><code>f128</code></td>
|
|
<td>(none)</td>
|
|
<td>128-bit floating point (112-bit mantissa)</td>
|
|
</tr>
|
|
<tr>
|
|
<td><code>bool</code></td>
|
|
<td><code>bool</code></td>
|
|
<td><code>true</code> or <code>false</code></td>
|
|
</tr>
|
|
<tr>
|
|
<td><code>void</code></td>
|
|
<td>(none)</td>
|
|
<td>0 bit type</td>
|
|
</tr>
|
|
<tr>
|
|
<td><code>noreturn</code></td>
|
|
<td>(none)</td>
|
|
<td>the type of <code>break</code>, <code>continue</code>, <code>return</code>, <code>unreachable</code>, and <code>while (true) {}</code></td>
|
|
</tr>
|
|
<tr>
|
|
<td><code>type</code></td>
|
|
<td>(none)</td>
|
|
<td>the type of types</td>
|
|
</tr>
|
|
<tr>
|
|
<td><code>error</code></td>
|
|
<td>(none)</td>
|
|
<td>an error code</td>
|
|
</tr>
|
|
</table>
|
|
</div>
|
|
{#see_also|Integers|Floats|void|Errors#}
|
|
{#header_close#}
|
|
{#header_open|Primitive Values#}
|
|
<div class="table-wrapper">
|
|
<table>
|
|
<tr>
|
|
<th>
|
|
Name
|
|
</th>
|
|
<th>
|
|
Description
|
|
</th>
|
|
</tr>
|
|
<tr>
|
|
<td><code>true</code> and <code>false</code></td>
|
|
<td><code>bool</code> values</td>
|
|
</tr>
|
|
<tr>
|
|
<td><code>null</code></td>
|
|
<td>used to set a nullable type to <code>null</code></td>
|
|
</tr>
|
|
<tr>
|
|
<td><code>undefined</code></td>
|
|
<td>used to leave a value unspecified</td>
|
|
</tr>
|
|
<tr>
|
|
<td><code>this</code></td>
|
|
<td>refers to the thing in immediate scope</td>
|
|
</tr>
|
|
</table>
|
|
</div>
|
|
{#see_also|Nullables|this#}
|
|
{#header_close#}
|
|
{#header_open|String Literals#}
|
|
{#code_begin|test#}
|
|
const assert = @import("std").debug.assert;
|
|
const mem = @import("std").mem;
|
|
|
|
test "string literals" {
|
|
// In Zig a string literal is an array of bytes.
|
|
const normal_bytes = "hello";
|
|
assert(@typeOf(normal_bytes) == [5]u8);
|
|
assert(normal_bytes.len == 5);
|
|
assert(normal_bytes[1] == 'e');
|
|
assert('e' == '\x65');
|
|
assert(mem.eql(u8, "hello", "h\x65llo"));
|
|
|
|
// A C string literal is a null terminated pointer.
|
|
const null_terminated_bytes = c"hello";
|
|
assert(@typeOf(null_terminated_bytes) == &const u8);
|
|
assert(null_terminated_bytes[5] == 0);
|
|
}
|
|
{#code_end#}
|
|
{#see_also|Arrays|Zig Test#}
|
|
{#header_open|Escape Sequences#}
|
|
<div class="table-wrapper">
|
|
<table>
|
|
<tr>
|
|
<th>
|
|
Escape Sequence
|
|
</th>
|
|
<th>
|
|
Name
|
|
</th>
|
|
</tr>
|
|
<tr>
|
|
<td><code>\n</code></td>
|
|
<td>Newline</td>
|
|
</tr>
|
|
<tr>
|
|
<td><code>\r</code></td>
|
|
<td>Carriage Return</td>
|
|
</tr>
|
|
<tr>
|
|
<td><code>\t</code></td>
|
|
<td>Tab</td>
|
|
</tr>
|
|
<tr>
|
|
<td><code>\\</code></td>
|
|
<td>Backslash</td>
|
|
</tr>
|
|
<tr>
|
|
<td><code>\'</code></td>
|
|
<td>Single Quote</td>
|
|
</tr>
|
|
<tr>
|
|
<td><code>\"</code></td>
|
|
<td>Double Quote</td>
|
|
</tr>
|
|
<tr>
|
|
<td><code>\xNN</code></td>
|
|
<td>hexadecimal 8-bit character code (2 digits)</td>
|
|
</tr>
|
|
<tr>
|
|
<td><code>\uNNNN</code></td>
|
|
<td>hexadecimal 16-bit Unicode character code UTF-8 encoded (4 digits)</td>
|
|
</tr>
|
|
<tr>
|
|
<td><code>\UNNNNNN</code></td>
|
|
<td>hexadecimal 24-bit Unicode character code UTF-8 encoded (6 digits)</td>
|
|
</tr>
|
|
</table>
|
|
</div>
|
|
<p>Note that the maximum valid Unicode point is <code>0x10ffff</code>.</p>
|
|
{#header_close#}
|
|
{#header_open|Multiline String Literals#}
|
|
<p>
|
|
Multiline string literals have no escapes and can span across multiple lines.
|
|
To start a multiline string literal, use the <code>\\</code> token. Just like a comment,
|
|
the string literal goes until the end of the line. The end of the line is
|
|
not included in the string literal.
|
|
However, if the next line begins with <code>\\</code> then a newline is appended and
|
|
the string literal continues.
|
|
</p>
|
|
{#code_begin|syntax#}
|
|
const hello_world_in_c =
|
|
\\#include <stdio.h>
|
|
\\
|
|
\\int main(int argc, char **argv) {
|
|
\\ printf("hello world\n");
|
|
\\ return 0;
|
|
\\}
|
|
;
|
|
{#code_end#}
|
|
<p>
|
|
For a multiline C string literal, prepend <code>c</code> to each <code>\\</code>:
|
|
</p>
|
|
{#code_begin|syntax#}
|
|
const c_string_literal =
|
|
c\\#include <stdio.h>
|
|
c\\
|
|
c\\int main(int argc, char **argv) {
|
|
c\\ printf("hello world\n");
|
|
c\\ return 0;
|
|
c\\}
|
|
;
|
|
{#code_end#}
|
|
<p>
|
|
In this example the variable <code>c_string_literal</code> has type <code>&const char</code> and
|
|
has a terminating null byte.
|
|
</p>
|
|
{#see_also|@embedFile#}
|
|
{#header_close#}
|
|
{#header_close#}
|
|
{#header_open|Assignment#}
|
|
<p>Use <code>const</code> to assign a value to an identifier:</p>
|
|
{#code_begin|test_err|cannot assign to constant#}
|
|
const x = 1234;
|
|
|
|
fn foo() void {
|
|
// It works at global scope as well as inside functions.
|
|
const y = 5678;
|
|
|
|
// Once assigned, an identifier cannot be changed.
|
|
y += 1;
|
|
}
|
|
|
|
test "assignment" {
|
|
foo();
|
|
}
|
|
{#code_end#}
|
|
<p>If you need a variable that you can modify, use <code>var</code>:</p>
|
|
{#code_begin|test#}
|
|
const assert = @import("std").debug.assert;
|
|
|
|
test "var" {
|
|
var y: i32 = 5678;
|
|
|
|
y += 1;
|
|
|
|
assert(y == 5679);
|
|
}
|
|
{#code_end#}
|
|
<p>Variables must be initialized:</p>
|
|
{#code_begin|test_err#}
|
|
test "initialization" {
|
|
var x: i32;
|
|
|
|
x = 1;
|
|
}
|
|
{#code_end#}
|
|
<p>Use <code>undefined</code> to leave variables uninitialized:</p>
|
|
{#code_begin|test#}
|
|
const assert = @import("std").debug.assert;
|
|
|
|
test "init with undefined" {
|
|
var x: i32 = undefined;
|
|
x = 1;
|
|
assert(x == 1);
|
|
}
|
|
{#code_end#}
|
|
{#header_close#}
|
|
{#header_close#}
|
|
{#header_open|Integers#}
|
|
{#header_open|Integer Literals#}
|
|
{#code_begin|syntax#}
|
|
const decimal_int = 98222;
|
|
const hex_int = 0xff;
|
|
const another_hex_int = 0xFF;
|
|
const octal_int = 0o755;
|
|
const binary_int = 0b11110000;
|
|
{#code_end#}
|
|
{#header_close#}
|
|
{#header_open|Runtime Integer Values#}
|
|
<p>
|
|
Integer literals have no size limitation, and if any undefined behavior occurs,
|
|
the compiler catches it.
|
|
</p>
|
|
<p>
|
|
However, once an integer value is no longer known at compile-time, it must have a
|
|
known size, and is vulnerable to undefined behavior.
|
|
</p>
|
|
{#code_begin|syntax#}
|
|
fn divide(a: i32, b: i32) i32 {
|
|
return a / b;
|
|
}
|
|
{#code_end#}
|
|
<p>
|
|
In this function, values <code>a</code> and <code>b</code> are known only at runtime,
|
|
and thus this division operation is vulnerable to both integer overflow and
|
|
division by zero.
|
|
</p>
|
|
<p>
|
|
Operators such as <code>+</code> and <code>-</code> cause undefined behavior on
|
|
integer overflow. Also available are operations such as <code>+%</code> and
|
|
<code>-%</code> which are defined to have wrapping arithmetic on all targets.
|
|
</p>
|
|
{#see_also|Integer Overflow|Division by Zero|Wrapping Operations#}
|
|
{#header_close#}
|
|
{#header_close#}
|
|
{#header_open|Floats#}
|
|
{#header_open|Float Literals#}
|
|
{#code_begin|syntax#}
|
|
const floating_point = 123.0E+77;
|
|
const another_float = 123.0;
|
|
const yet_another = 123.0e+77;
|
|
|
|
const hex_floating_point = 0x103.70p-5;
|
|
const another_hex_float = 0x103.70;
|
|
const yet_another_hex_float = 0x103.70P-5;
|
|
{#code_end#}
|
|
{#header_close#}
|
|
{#header_open|Floating Point Operations#}
|
|
<p>By default floating point operations use <code>Optimized</code> mode,
|
|
but you can switch to <code>Strict</code> mode on a per-block basis:</p>
|
|
{#code_begin|obj|foo#}
|
|
{#code_release_fast#}
|
|
const builtin = @import("builtin");
|
|
const big = f64(1 << 40);
|
|
|
|
export fn foo_strict(x: f64) f64 {
|
|
@setFloatMode(this, builtin.FloatMode.Strict);
|
|
return x + big - big;
|
|
}
|
|
|
|
export fn foo_optimized(x: f64) f64 {
|
|
return x + big - big;
|
|
}
|
|
{#code_end#}
|
|
<p>For this test we have to separate code into two object files -
|
|
otherwise the optimizer figures out all the values at compile-time,
|
|
which operates in strict mode.</p>
|
|
{#code_begin|exe|float_mode#}
|
|
{#code_link_object|foo#}
|
|
const warn = @import("std").debug.warn;
|
|
|
|
extern fn foo_strict(x: f64) f64;
|
|
extern fn foo_optimized(x: f64) f64;
|
|
|
|
pub fn main() void {
|
|
const x = 0.001;
|
|
warn("optimized = {}\n", foo_optimized(x));
|
|
warn("strict = {}\n", foo_strict(x));
|
|
}
|
|
{#code_end#}
|
|
{#see_also|@setFloatMode|Division by Zero#}
|
|
{#header_close#}
|
|
{#header_close#}
|
|
{#header_open|Operators#}
|
|
{#header_open|Table of Operators#}
|
|
<div class="table-wrapper">
|
|
<table>
|
|
<tr>
|
|
<th>
|
|
Syntax
|
|
</th>
|
|
<th>
|
|
Relevant Types
|
|
</th>
|
|
<th>
|
|
Description
|
|
</th>
|
|
<th>
|
|
Example
|
|
</th>
|
|
</tr>
|
|
<tr>
|
|
<td><pre><code class="zig">a + b
|
|
a += b</code></pre></td>
|
|
<td>
|
|
<ul>
|
|
<li>{#link|Integers#}</li>
|
|
<li>{#link|Floats#}</li>
|
|
</ul>
|
|
</td>
|
|
<td>Addition.
|
|
<ul>
|
|
<li>Can cause {#link|overflow|Default Operations#} for integers.</li>
|
|
</ul>
|
|
</td>
|
|
<td>
|
|
<pre><code class="zig">2 + 5 == 7</code></pre>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td><pre><code class="zig">a +% b
|
|
a +%= b</code></pre></td>
|
|
<td>
|
|
<ul>
|
|
<li>{#link|Integers#}</li>
|
|
</ul>
|
|
</td>
|
|
<td>Wrapping Addition.
|
|
<ul>
|
|
<li>Guaranteed to have twos-complement wrapping behavior.</li>
|
|
</ul>
|
|
</td>
|
|
<td>
|
|
<pre><code class="zig">u32(@maxValue(u32)) +% 1 == 0</code></pre>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td><pre><code class="zig">a - b
|
|
a -= b</code></pre></td>
|
|
<td>
|
|
<ul>
|
|
<li>{#link|Integers#}</li>
|
|
<li>{#link|Floats#}</li>
|
|
</ul>
|
|
</td>
|
|
<td>Subtraction.
|
|
<ul>
|
|
<li>Can cause {#link|overflow|Default Operations#} for integers.</li>
|
|
</ul>
|
|
</td>
|
|
<td>
|
|
<pre><code class="zig">2 - 5 == -3</code></pre>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td><pre><code class="zig">a -% b
|
|
a -%= b</code></pre></td>
|
|
<td>
|
|
<ul>
|
|
<li>{#link|Integers#}</li>
|
|
</ul>
|
|
</td>
|
|
<td>Wrapping Subtraction.
|
|
<ul>
|
|
<li>Guaranteed to have twos-complement wrapping behavior.</li>
|
|
</ul>
|
|
</td>
|
|
<td>
|
|
<pre><code class="zig">u32(0) -% 1 == @maxValue(u32)</code></pre>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td><pre><code class="zig">-a<code></pre></td>
|
|
<td>
|
|
<ul>
|
|
<li>{#link|Integers#}</li>
|
|
<li>{#link|Floats#}</li>
|
|
</ul>
|
|
</td>
|
|
<td>
|
|
Negation.
|
|
<ul>
|
|
<li>Can cause {#link|overflow|Default Operations#} for integers.</li>
|
|
</ul>
|
|
</td>
|
|
<td>
|
|
<pre><code class="zig">-1 == 0 - 1</code></pre>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td><pre><code class="zig">-%a<code></pre></td>
|
|
<td>
|
|
<ul>
|
|
<li>{#link|Integers#}</li>
|
|
</ul>
|
|
</td>
|
|
<td>
|
|
Wrapping Negation.
|
|
<ul>
|
|
<li>Guaranteed to have twos-complement wrapping behavior.</li>
|
|
</ul>
|
|
</td>
|
|
<td>
|
|
<pre><code class="zig">-%i32(@minValue(i32)) == @minValue(i32)</code></pre>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td><pre><code class="zig">a * b
|
|
a *= b</code></pre></td>
|
|
<td>
|
|
<ul>
|
|
<li>{#link|Integers#}</li>
|
|
<li>{#link|Floats#}</li>
|
|
</ul>
|
|
</td>
|
|
<td>Multiplication.
|
|
<ul>
|
|
<li>Can cause {#link|overflow|Default Operations#} for integers.</li>
|
|
</ul>
|
|
</td>
|
|
<td>
|
|
<pre><code class="zig">2 * 5 == 10</code></pre>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td><pre><code class="zig">a *% b
|
|
a *%= b</code></pre></td>
|
|
<td>
|
|
<ul>
|
|
<li>{#link|Integers#}</li>
|
|
</ul>
|
|
</td>
|
|
<td>Wrapping Multiplication.
|
|
<ul>
|
|
<li>Guaranteed to have twos-complement wrapping behavior.</li>
|
|
</ul>
|
|
</td>
|
|
<td>
|
|
<pre><code class="zig">u8(200) *% 2 == 144</code></pre>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td><pre><code class="zig">a / b
|
|
a /= b</code></pre></td>
|
|
<td>
|
|
<ul>
|
|
<li>{#link|Integers#}</li>
|
|
<li>{#link|Floats#}</li>
|
|
</ul>
|
|
</td>
|
|
<td>Divison.
|
|
<ul>
|
|
<li>Can cause {#link|overflow|Default Operations#} for integers.</li>
|
|
<li>Can cause {#link|Division by Zero#} for integers.</li>
|
|
<li>Can cause {#link|Division by Zero#} for floats in {#link|FloatMode.Optimized Mode|Floating Point Operations#}.</li>
|
|
<li>For non-compile-time-known signed integers, must use
|
|
{#link|@divTrunc#},
|
|
{#link|@divFloor#}, or
|
|
{#link|@divExact#} instead of <code>/</code>.
|
|
</li>
|
|
</ul>
|
|
</td>
|
|
<td>
|
|
<pre><code class="zig">10 / 5 == 2</code></pre>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td><pre><code class="zig">a % b
|
|
a %= b</code></pre></td>
|
|
<td>
|
|
<ul>
|
|
<li>{#link|Integers#}</li>
|
|
<li>{#link|Floats#}</li>
|
|
</ul>
|
|
</td>
|
|
<td>Remainder Division.
|
|
<ul>
|
|
<li>Can cause {#link|Division by Zero#} for integers.</li>
|
|
<li>Can cause {#link|Division by Zero#} for floats in {#link|FloatMode.Optimized Mode|Floating Point Operations#}.</li>
|
|
<li>For non-compile-time-known signed integers, must use
|
|
{#link|@rem#} or
|
|
{#link|@mod#} instead of <code>%</code>.
|
|
</li>
|
|
</ul>
|
|
</td>
|
|
<td>
|
|
<pre><code class="zig">10 % 3 == 1</code></pre>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td><pre><code class="zig">a << b
|
|
a <<= b</code></pre></td>
|
|
<td>
|
|
<ul>
|
|
<li>{#link|Integers#}</li>
|
|
</ul>
|
|
</td>
|
|
<td>Bit Shift Left.
|
|
<ul>
|
|
<li>See also {#link|@shlExact#}.</li>
|
|
<li>See also {#link|@shlWithOverflow#}.</li>
|
|
</ul>
|
|
</td>
|
|
<td>
|
|
<pre><code class="zig">1 << 8 == 256</code></pre>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td><pre><code class="zig">a >> b
|
|
a >>= b</code></pre></td>
|
|
<td>
|
|
<ul>
|
|
<li>{#link|Integers#}</li>
|
|
</ul>
|
|
</td>
|
|
<td>Bit Shift Right.
|
|
<ul>
|
|
<li>See also {#link|@shrExact#}.</li>
|
|
</ul>
|
|
</td>
|
|
<td>
|
|
<pre><code class="zig">10 >> 1 == 5</code></pre>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td><pre><code class="zig">a & b
|
|
a &= b</code></pre></td>
|
|
<td>
|
|
<ul>
|
|
<li>{#link|Integers#}</li>
|
|
</ul>
|
|
</td>
|
|
<td>Bitwise AND.
|
|
</td>
|
|
<td>
|
|
<pre><code class="zig">0b011 & 0b101 == 0b001</code></pre>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td><pre><code class="zig">a | b
|
|
a |= b</code></pre></td>
|
|
<td>
|
|
<ul>
|
|
<li>{#link|Integers#}</li>
|
|
</ul>
|
|
</td>
|
|
<td>Bitwise OR.
|
|
</td>
|
|
<td>
|
|
<pre><code class="zig">0b010 | 0b100 == 0b110</code></pre>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td><pre><code class="zig">a ^ b
|
|
a ^= b</code></pre></td>
|
|
<td>
|
|
<ul>
|
|
<li>{#link|Integers#}</li>
|
|
</ul>
|
|
</td>
|
|
<td>Bitwise XOR.
|
|
</td>
|
|
<td>
|
|
<pre><code class="zig">0b011 ^ 0b101 == 0b110</code></pre>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td><pre><code class="zig">~a<code></pre></td>
|
|
<td>
|
|
<ul>
|
|
<li>{#link|Integers#}</li>
|
|
</ul>
|
|
</td>
|
|
<td>
|
|
Bitwise NOT.
|
|
</td>
|
|
<td>
|
|
<pre><code class="zig">~u8(0b0101111) == 0b1010000</code></pre>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td><pre><code class="zig">a ?? b</code></pre></td>
|
|
<td>
|
|
<ul>
|
|
<li>{#link|Nullables#}</li>
|
|
</ul>
|
|
</td>
|
|
<td>If <code>a</code> is <code>null</code>,
|
|
returns <code>b</code> ("default value"),
|
|
otherwise returns the unwrapped value of <code>a</code>.
|
|
Note that <code>b</code> may be a value of type {#link|noreturn#}.
|
|
</td>
|
|
<td>
|
|
<pre><code class="zig">const value: ?u32 = null;
|
|
const unwrapped = value ?? 1234;
|
|
unwrapped == 1234</code></pre>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td><pre><code class="zig">??a</code></pre></td>
|
|
<td>
|
|
<ul>
|
|
<li>{#link|Nullables#}</li>
|
|
</ul>
|
|
</td>
|
|
<td>
|
|
Equivalent to:
|
|
<pre><code class="zig">a ?? unreachable</code></pre>
|
|
</td>
|
|
<td>
|
|
<pre><code class="zig">const value: ?u32 = 5678;
|
|
??value == 5678</code></pre>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td><pre><code class="zig">a catch b
|
|
a catch |err| b</code></pre></td>
|
|
<td>
|
|
<ul>
|
|
<li>{#link|Error Unions|Errors#}</li>
|
|
</ul>
|
|
</td>
|
|
<td>If <code>a</code> is an <code>error</code>,
|
|
returns <code>b</code> ("default value"),
|
|
otherwise returns the unwrapped value of <code>a</code>.
|
|
Note that <code>b</code> may be a value of type {#link|noreturn#}.
|
|
<code>err</code> is the <code>error</code> and is in scope of the expression <code>b</code>.
|
|
</td>
|
|
<td>
|
|
<pre><code class="zig">const value: error!u32 = error.Broken;
|
|
const unwrapped = value catch 1234;
|
|
unwrapped == 1234</code></pre>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td><pre><code class="zig">a and b<code></pre></td>
|
|
<td>
|
|
<ul>
|
|
<li>{#link|bool|Primitive Types#}</li>
|
|
</ul>
|
|
</td>
|
|
<td>
|
|
If <code>a</code> is <code>false</code>, returns <code>false</code>
|
|
without evaluating <code>b</code>. Otherwise, retuns <code>b</code>.
|
|
</td>
|
|
<td>
|
|
<pre><code class="zig">false and true == false</code></pre>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td><pre><code class="zig">a or b<code></pre></td>
|
|
<td>
|
|
<ul>
|
|
<li>{#link|bool|Primitive Types#}</li>
|
|
</ul>
|
|
</td>
|
|
<td>
|
|
If <code>a</code> is <code>true</code>, returns <code>true</code>
|
|
without evaluating <code>b</code>. Otherwise, retuns <code>b</code>.
|
|
</td>
|
|
<td>
|
|
<pre><code class="zig">false or true == true</code></pre>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td><pre><code class="zig">!a<code></pre></td>
|
|
<td>
|
|
<ul>
|
|
<li>{#link|bool|Primitive Types#}</li>
|
|
</ul>
|
|
</td>
|
|
<td>
|
|
Boolean NOT.
|
|
</td>
|
|
<td>
|
|
<pre><code class="zig">!false == true</code></pre>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td><pre><code class="zig">a == b<code></pre></td>
|
|
<td>
|
|
<ul>
|
|
<li>{#link|Integers#}</li>
|
|
<li>{#link|Floats#}</li>
|
|
<li>{#link|bool|Primitive Types#}</li>
|
|
<li>{#link|type|Primitive Types#}</li>
|
|
</ul>
|
|
</td>
|
|
<td>
|
|
Returns <code>true</code> if a and b are equal, otherwise returns <code>false</code>.
|
|
</td>
|
|
<td>
|
|
<pre><code class="zig">(1 == 1) == true</code></pre>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td><pre><code class="zig">a == null<code></pre></td>
|
|
<td>
|
|
<ul>
|
|
<li>{#link|Nullables#}</li>
|
|
</ul>
|
|
</td>
|
|
<td>
|
|
Returns <code>true</code> if a is <code>null</code>, otherwise returns <code>false</code>.
|
|
</td>
|
|
<td>
|
|
<pre><code class="zig">const value: ?u32 = null;
|
|
value == null</code></pre>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td><pre><code class="zig">a != b<code></pre></td>
|
|
<td>
|
|
<ul>
|
|
<li>{#link|Integers#}</li>
|
|
<li>{#link|Floats#}</li>
|
|
<li>{#link|bool|Primitive Types#}</li>
|
|
<li>{#link|type|Primitive Types#}</li>
|
|
</ul>
|
|
</td>
|
|
<td>
|
|
Returns <code>false</code> if a and b are equal, otherwise returns <code>true</code>.
|
|
</td>
|
|
<td>
|
|
<pre><code class="zig">(1 != 1) == false</code></pre>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td><pre><code class="zig">a > b<code></pre></td>
|
|
<td>
|
|
<ul>
|
|
<li>{#link|Integers#}</li>
|
|
<li>{#link|Floats#}</li>
|
|
</ul>
|
|
</td>
|
|
<td>
|
|
Returns <code>true</code> if a is greater than b, otherwise returns <code>false</code>.
|
|
</td>
|
|
<td>
|
|
<pre><code class="zig">(2 > 1) == true</code></pre>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td><pre><code class="zig">a >= b<code></pre></td>
|
|
<td>
|
|
<ul>
|
|
<li>{#link|Integers#}</li>
|
|
<li>{#link|Floats#}</li>
|
|
</ul>
|
|
</td>
|
|
<td>
|
|
Returns <code>true</code> if a is greater than or equal to b, otherwise returns <code>false</code>.
|
|
</td>
|
|
<td>
|
|
<pre><code class="zig">(2 >= 1) == true</code></pre>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td><pre><code class="zig">a < b<code></pre></td>
|
|
<td>
|
|
<ul>
|
|
<li>{#link|Integers#}</li>
|
|
<li>{#link|Floats#}</li>
|
|
</ul>
|
|
</td>
|
|
<td>
|
|
Returns <code>true</code> if a is less than b, otherwise returns <code>false</code>.
|
|
</td>
|
|
<td>
|
|
<pre><code class="zig">(1 < 2) == true</code></pre>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td><pre><code class="zig">a <= b<code></pre></td>
|
|
<td>
|
|
<ul>
|
|
<li>{#link|Integers#}</li>
|
|
<li>{#link|Floats#}</li>
|
|
</ul>
|
|
</td>
|
|
<td>
|
|
Returns <code>true</code> if a is less than or equal to b, otherwise returns <code>false</code>.
|
|
</td>
|
|
<td>
|
|
<pre><code class="zig">(1 <= 2) == true</code></pre>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td><pre><code class="zig">a ++ b<code></pre></td>
|
|
<td>
|
|
<ul>
|
|
<li>{#link|Arrays#}</li>
|
|
</ul>
|
|
</td>
|
|
<td>
|
|
Array concatenation.
|
|
<ul>
|
|
<li>Only available when <code>a</code> and <code>b</code> are {#link|compile-time known|comptime#}.
|
|
</ul>
|
|
</td>
|
|
<td>
|
|
<pre><code class="zig">const mem = @import("std").mem;
|
|
const array1 = []u32{1,2};
|
|
const array2 = []u32{3,4};
|
|
const together = array1 ++ array2;
|
|
mem.eql(u32, together, []u32{1,2,3,4})</code></pre>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td><pre><code class="zig">a ** b<code></pre></td>
|
|
<td>
|
|
<ul>
|
|
<li>{#link|Arrays#}</li>
|
|
</ul>
|
|
</td>
|
|
<td>
|
|
Array multiplication.
|
|
<ul>
|
|
<li>Only available when <code>a</code> and <code>b</code> are {#link|compile-time known|comptime#}.
|
|
</ul>
|
|
</td>
|
|
<td>
|
|
<pre><code class="zig">const mem = @import("std").mem;
|
|
const pattern = "ab" ** 3;
|
|
mem.eql(u8, pattern, "ababab")</code></pre>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td><pre><code class="zig">*a<code></pre></td>
|
|
<td>
|
|
<ul>
|
|
<li>{#link|Pointers#}</li>
|
|
</ul>
|
|
</td>
|
|
<td>
|
|
Pointer dereference.
|
|
</td>
|
|
<td>
|
|
<pre><code class="zig">const x: u32 = 1234;
|
|
const ptr = &x;
|
|
*x == 1234</code></pre>
|
|
</td>
|
|
</tr>
|
|
<tr>
|
|
<td><pre><code class="zig">&a<code></pre></td>
|
|
<td>
|
|
All types
|
|
</td>
|
|
<td>
|
|
Address of.
|
|
</td>
|
|
<td>
|
|
<pre><code class="zig">const x: u32 = 1234;
|
|
const ptr = &x;
|
|
*x == 1234</code></pre>
|
|
</td>
|
|
</tr>
|
|
</table>
|
|
</div>
|
|
{#header_close#}
|
|
{#header_open|Precedence#}
|
|
<pre><code>x() x[] x.y
|
|
a!b
|
|
!x -x -%x ~x *x &x ?x ??x
|
|
x{}
|
|
! * / % ** *%
|
|
+ - ++ +% -%
|
|
<< >>
|
|
&
|
|
^
|
|
|
|
|
== != < > <= >=
|
|
and
|
|
or
|
|
?? catch
|
|
= *= /= %= += -= <<= >>= &= ^= |=</code></pre>
|
|
{#header_close#}
|
|
{#header_close#}
|
|
{#header_open|Arrays#}
|
|
{#code_begin|test|arrays#}
|
|
const assert = @import("std").debug.assert;
|
|
const mem = @import("std").mem;
|
|
|
|
// array literal
|
|
const message = []u8{'h', 'e', 'l', 'l', 'o'};
|
|
|
|
// get the size of an array
|
|
comptime {
|
|
assert(message.len == 5);
|
|
}
|
|
|
|
// a string literal is an array literal
|
|
const same_message = "hello";
|
|
|
|
comptime {
|
|
assert(mem.eql(u8, message, same_message));
|
|
assert(@typeOf(message) == @typeOf(same_message));
|
|
}
|
|
|
|
test "iterate over an array" {
|
|
var sum: usize = 0;
|
|
for (message) |byte| {
|
|
sum += byte;
|
|
}
|
|
assert(sum == usize('h') + usize('e') + usize('l') * 2 + usize('o'));
|
|
}
|
|
|
|
// modifiable array
|
|
var some_integers: [100]i32 = undefined;
|
|
|
|
test "modify an array" {
|
|
for (some_integers) |*item, i| {
|
|
*item = i32(i);
|
|
}
|
|
assert(some_integers[10] == 10);
|
|
assert(some_integers[99] == 99);
|
|
}
|
|
|
|
// array concatenation works if the values are known
|
|
// at compile time
|
|
const part_one = []i32{1, 2, 3, 4};
|
|
const part_two = []i32{5, 6, 7, 8};
|
|
const all_of_it = part_one ++ part_two;
|
|
comptime {
|
|
assert(mem.eql(i32, all_of_it, []i32{1,2,3,4,5,6,7,8}));
|
|
}
|
|
|
|
// remember that string literals are arrays
|
|
const hello = "hello";
|
|
const world = "world";
|
|
const hello_world = hello ++ " " ++ world;
|
|
comptime {
|
|
assert(mem.eql(u8, hello_world, "hello world"));
|
|
}
|
|
|
|
// ** does repeating patterns
|
|
const pattern = "ab" ** 3;
|
|
comptime {
|
|
assert(mem.eql(u8, pattern, "ababab"));
|
|
}
|
|
|
|
// initialize an array to zero
|
|
const all_zero = []u16{0} ** 10;
|
|
|
|
comptime {
|
|
assert(all_zero.len == 10);
|
|
assert(all_zero[5] == 0);
|
|
}
|
|
|
|
// use compile-time code to initialize an array
|
|
var fancy_array = init: {
|
|
var initial_value: [10]Point = undefined;
|
|
for (initial_value) |*pt, i| {
|
|
*pt = Point {
|
|
.x = i32(i),
|
|
.y = i32(i) * 2,
|
|
};
|
|
}
|
|
break :init initial_value;
|
|
};
|
|
const Point = struct {
|
|
x: i32,
|
|
y: i32,
|
|
};
|
|
|
|
test "compile-time array initalization" {
|
|
assert(fancy_array[4].x == 4);
|
|
assert(fancy_array[4].y == 8);
|
|
}
|
|
|
|
// call a function to initialize an array
|
|
var more_points = []Point{makePoint(3)} ** 10;
|
|
fn makePoint(x: i32) Point {
|
|
return Point {
|
|
.x = x,
|
|
.y = x * 2,
|
|
};
|
|
}
|
|
test "array initialization with function calls" {
|
|
assert(more_points[4].x == 3);
|
|
assert(more_points[4].y == 6);
|
|
assert(more_points.len == 10);
|
|
}
|
|
{#code_end#}
|
|
{#see_also|for|Slices#}
|
|
{#header_close#}
|
|
{#header_open|Pointers#}
|
|
{#code_begin|test#}
|
|
const assert = @import("std").debug.assert;
|
|
|
|
test "address of syntax" {
|
|
// Get the address of a variable:
|
|
const x: i32 = 1234;
|
|
const x_ptr = &x;
|
|
|
|
// Deference a pointer:
|
|
assert(*x_ptr == 1234);
|
|
|
|
// When you get the address of a const variable, you get a const pointer.
|
|
assert(@typeOf(x_ptr) == &const i32);
|
|
|
|
// If you want to mutate the value, you'd need an address of a mutable variable:
|
|
var y: i32 = 5678;
|
|
const y_ptr = &y;
|
|
assert(@typeOf(y_ptr) == &i32);
|
|
*y_ptr += 1;
|
|
assert(*y_ptr == 5679);
|
|
}
|
|
|
|
test "pointer array access" {
|
|
// Pointers do not support pointer arithmetic. If you
|
|
// need such a thing, use array index syntax:
|
|
|
|
var array = []u8{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
|
|
const ptr = &array[1];
|
|
|
|
assert(array[2] == 3);
|
|
ptr[1] += 1;
|
|
assert(array[2] == 4);
|
|
}
|
|
|
|
test "pointer slicing" {
|
|
// In Zig, we prefer using slices over null-terminated pointers.
|
|
// You can turn a pointer into a slice using slice syntax:
|
|
var array = []u8{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
|
|
const ptr = &array[1];
|
|
const slice = ptr[1..3];
|
|
|
|
assert(slice.ptr == &ptr[1]);
|
|
assert(slice.len == 2);
|
|
|
|
// Slices have bounds checking and are therefore protected
|
|
// against this kind of undefined behavior. This is one reason
|
|
// we prefer slices to pointers.
|
|
assert(array[3] == 4);
|
|
slice[1] += 1;
|
|
assert(array[3] == 5);
|
|
}
|
|
|
|
comptime {
|
|
// Pointers work at compile-time too, as long as you don't use
|
|
// @ptrCast.
|
|
var x: i32 = 1;
|
|
const ptr = &x;
|
|
*ptr += 1;
|
|
x += 1;
|
|
assert(*ptr == 3);
|
|
}
|
|
|
|
test "@ptrToInt and @intToPtr" {
|
|
// To convert an integer address into a pointer, use @intToPtr:
|
|
const ptr = @intToPtr(&i32, 0xdeadbeef);
|
|
|
|
// To convert a pointer to an integer, use @ptrToInt:
|
|
const addr = @ptrToInt(ptr);
|
|
|
|
assert(@typeOf(addr) == usize);
|
|
assert(addr == 0xdeadbeef);
|
|
}
|
|
|
|
comptime {
|
|
// Zig is able to do this at compile-time, as long as
|
|
// ptr is never dereferenced.
|
|
const ptr = @intToPtr(&i32, 0xdeadbeef);
|
|
const addr = @ptrToInt(ptr);
|
|
assert(@typeOf(addr) == usize);
|
|
assert(addr == 0xdeadbeef);
|
|
}
|
|
|
|
test "volatile" {
|
|
// In Zig, loads and stores are assumed to not have side effects.
|
|
// If a given load or store should have side effects, such as
|
|
// Memory Mapped Input/Output (MMIO), use `volatile`:
|
|
const mmio_ptr = @intToPtr(&volatile u8, 0x12345678);
|
|
|
|
// Now loads and stores with mmio_ptr are guaranteed to all happen
|
|
// and in the same order as in source code.
|
|
assert(@typeOf(mmio_ptr) == &volatile u8);
|
|
}
|
|
|
|
test "nullable pointers" {
|
|
// Pointers cannot be null. If you want a null pointer, use the nullable
|
|
// prefix `?` to make the pointer type nullable.
|
|
var ptr: ?&i32 = null;
|
|
|
|
var x: i32 = 1;
|
|
ptr = &x;
|
|
|
|
assert(*??ptr == 1);
|
|
|
|
// Nullable pointers are the same size as normal pointers, because pointer
|
|
// value 0 is used as the null value.
|
|
assert(@sizeOf(?&i32) == @sizeOf(&i32));
|
|
}
|
|
|
|
test "pointer casting" {
|
|
// To convert one pointer type to another, use @ptrCast. This is an unsafe
|
|
// operation that Zig cannot protect you against. Use @ptrCast only when other
|
|
// conversions are not possible.
|
|
const bytes align(@alignOf(u32)) = []u8{0x12, 0x12, 0x12, 0x12};
|
|
const u32_ptr = @ptrCast(&const u32, &bytes[0]);
|
|
assert(*u32_ptr == 0x12121212);
|
|
|
|
// Even this example is contrived - there are better ways to do the above than
|
|
// pointer casting. For example, using a slice narrowing cast:
|
|
const u32_value = ([]const u32)(bytes[0..])[0];
|
|
assert(u32_value == 0x12121212);
|
|
|
|
// And even another way, the most straightforward way to do it:
|
|
assert(@bitCast(u32, bytes) == 0x12121212);
|
|
}
|
|
|
|
test "pointer child type" {
|
|
// pointer types have a `child` field which tells you the type they point to.
|
|
assert((&u32).Child == u32);
|
|
}
|
|
{#code_end#}
|
|
{#header_open|Alignment#}
|
|
<p>
|
|
Each type has an <strong>alignment</strong> - a number of bytes such that,
|
|
when a value of the type is loaded from or stored to memory,
|
|
the memory address must be evenly divisible by this number. You can use
|
|
{#link|@alignOf#} to find out this value for any type.
|
|
</p>
|
|
<p>
|
|
Alignment depends on the CPU architecture, but is always a power of two, and
|
|
less than <code>1 << 29</code>.
|
|
</p>
|
|
<p>
|
|
In Zig, a pointer type has an alignment value. If the value is equal to the
|
|
alignment of the underlying type, it can be omitted from the type:
|
|
</p>
|
|
{#code_begin|test#}
|
|
const assert = @import("std").debug.assert;
|
|
const builtin = @import("builtin");
|
|
|
|
test "variable alignment" {
|
|
var x: i32 = 1234;
|
|
const align_of_i32 = @alignOf(@typeOf(x));
|
|
assert(@typeOf(&x) == &i32);
|
|
assert(&i32 == &align(align_of_i32) i32);
|
|
if (builtin.arch == builtin.Arch.x86_64) {
|
|
assert((&i32).alignment == 4);
|
|
}
|
|
}
|
|
{#code_end#}
|
|
<p>In the same way that a <code>&i32</code> can be implicitly cast to a
|
|
<code>&const i32</code>, a pointer with a larger alignment can be implicitly
|
|
cast to a pointer with a smaller alignment, but not vice versa.
|
|
</p>
|
|
<p>
|
|
You can specify alignment on variables and functions. If you do this, then
|
|
pointers to them get the specified alignment:
|
|
</p>
|
|
{#code_begin|test#}
|
|
const assert = @import("std").debug.assert;
|
|
|
|
var foo: u8 align(4) = 100;
|
|
|
|
test "global variable alignment" {
|
|
assert(@typeOf(&foo).alignment == 4);
|
|
assert(@typeOf(&foo) == &align(4) u8);
|
|
const slice = (&foo)[0..1];
|
|
assert(@typeOf(slice) == []align(4) u8);
|
|
}
|
|
|
|
fn derp() align(@sizeOf(usize) * 2) i32 { return 1234; }
|
|
fn noop1() align(1) void {}
|
|
fn noop4() align(4) void {}
|
|
|
|
test "function alignment" {
|
|
assert(derp() == 1234);
|
|
assert(@typeOf(noop1) == fn() align(1) void);
|
|
assert(@typeOf(noop4) == fn() align(4) void);
|
|
noop1();
|
|
noop4();
|
|
}
|
|
{#code_end#}
|
|
<p>
|
|
If you have a pointer or a slice that has a small alignment, but you know that it actually
|
|
has a bigger alignment, use {#link|@alignCast#} to change the
|
|
pointer into a more aligned pointer. This is a no-op at runtime, but inserts a
|
|
{#link|safety check|Incorrect Pointer Alignment#}:
|
|
</p>
|
|
{#code_begin|test_safety|incorrect alignment#}
|
|
const assert = @import("std").debug.assert;
|
|
|
|
test "pointer alignment safety" {
|
|
var array align(4) = []u32{0x11111111, 0x11111111};
|
|
const bytes = ([]u8)(array[0..]);
|
|
assert(foo(bytes) == 0x11111111);
|
|
}
|
|
fn foo(bytes: []u8) u32 {
|
|
const slice4 = bytes[1..5];
|
|
const int_slice = ([]u32)(@alignCast(4, slice4));
|
|
return int_slice[0];
|
|
}
|
|
{#code_end#}
|
|
{#header_close#}
|
|
{#header_open|Type Based Alias Analysis#}
|
|
<p>Zig uses Type Based Alias Analysis (also known as Strict Aliasing) to
|
|
perform some optimizations. This means that pointers of different types must
|
|
not alias the same memory, with the exception of <code>u8</code>. Pointers to
|
|
<code>u8</code> can alias any memory.
|
|
</p>
|
|
<p>As an example, this code produces undefined behavior:</p>
|
|
<pre><code class="zig">*@ptrCast(&u32, f32(12.34))</code></pre>
|
|
<p>Instead, use {#link|@bitCast#}:
|
|
<pre><code class="zig">@bitCast(u32, f32(12.34))</code></pre>
|
|
<p>As an added benefit, the <code>@bitcast</code> version works at compile-time.</p>
|
|
{#see_also|Slices|Memory#}
|
|
{#header_close#}
|
|
{#header_close#}
|
|
{#header_open|Slices#}
|
|
{#code_begin|test_safety|index out of bounds#}
|
|
const assert = @import("std").debug.assert;
|
|
|
|
test "basic slices" {
|
|
var array = []i32{1, 2, 3, 4};
|
|
// A slice is a pointer and a length. The difference between an array and
|
|
// a slice is that the array's length is part of the type and known at
|
|
// compile-time, whereas the slice's length is known at runtime.
|
|
// Both can be accessed with the `len` field.
|
|
const slice = array[0..array.len];
|
|
assert(slice.ptr == &array[0]);
|
|
assert(slice.len == array.len);
|
|
|
|
// Slices have array bounds checking. If you try to access something out
|
|
// of bounds, you'll get a safety check failure:
|
|
slice[10] += 1;
|
|
}
|
|
{#code_end#}
|
|
<p>This is one reason we prefer slices to pointers.</p>
|
|
{#code_begin|test|slices#}
|
|
const assert = @import("std").debug.assert;
|
|
const mem = @import("std").mem;
|
|
const fmt = @import("std").fmt;
|
|
|
|
test "using slices for strings" {
|
|
// Zig has no concept of strings. String literals are arrays of u8, and
|
|
// in general the string type is []u8 (slice of u8).
|
|
// Here we implicitly cast [5]u8 to []const u8
|
|
const hello: []const u8 = "hello";
|
|
const world: []const u8 = "世界";
|
|
|
|
var all_together: [100]u8 = undefined;
|
|
// You can use slice syntax on an array to convert an array into a slice.
|
|
const all_together_slice = all_together[0..];
|
|
// String concatenation example.
|
|
const hello_world = try fmt.bufPrint(all_together_slice, "{} {}", hello, world);
|
|
|
|
// Generally, you can use UTF-8 and not worry about whether something is a
|
|
// string. If you don't need to deal with individual characters, no need
|
|
// to decode.
|
|
assert(mem.eql(u8, hello_world, "hello 世界"));
|
|
}
|
|
|
|
test "slice pointer" {
|
|
var array: [10]u8 = undefined;
|
|
const ptr = &array[0];
|
|
|
|
// You can use slicing syntax to convert a pointer into a slice:
|
|
const slice = ptr[0..5];
|
|
slice[2] = 3;
|
|
assert(slice[2] == 3);
|
|
// The slice is mutable because we sliced a mutable pointer.
|
|
assert(@typeOf(slice) == []u8);
|
|
|
|
// You can also slice a slice:
|
|
const slice2 = slice[2..3];
|
|
assert(slice2.len == 1);
|
|
assert(slice2[0] == 3);
|
|
}
|
|
|
|
test "slice widening" {
|
|
// Zig supports slice widening and slice narrowing. Cast a slice of u8
|
|
// to a slice of anything else, and Zig will perform the length conversion.
|
|
const array align(@alignOf(u32)) = []u8{0x12, 0x12, 0x12, 0x12, 0x13, 0x13, 0x13, 0x13};
|
|
const slice = ([]const u32)(array[0..]);
|
|
assert(slice.len == 2);
|
|
assert(slice[0] == 0x12121212);
|
|
assert(slice[1] == 0x13131313);
|
|
}
|
|
{#code_end#}
|
|
{#see_also|Pointers|for|Arrays#}
|
|
{#header_close#}
|
|
{#header_open|struct#}
|
|
{#code_begin|test|structs#}
|
|
// Declare a struct.
|
|
// Zig gives no guarantees about the order of fields and whether or
|
|
// not there will be padding.
|
|
const Point = struct {
|
|
x: f32,
|
|
y: f32,
|
|
};
|
|
|
|
// Maybe we want to pass it to OpenGL so we want to be particular about
|
|
// how the bytes are arranged.
|
|
const Point2 = packed struct {
|
|
x: f32,
|
|
y: f32,
|
|
};
|
|
|
|
|
|
// Declare an instance of a struct.
|
|
const p = Point {
|
|
.x = 0.12,
|
|
.y = 0.34,
|
|
};
|
|
|
|
// Maybe we're not ready to fill out some of the fields.
|
|
var p2 = Point {
|
|
.x = 0.12,
|
|
.y = undefined,
|
|
};
|
|
|
|
// Structs can have methods
|
|
// Struct methods are not special, they are only namespaced
|
|
// functions that you can call with dot syntax.
|
|
const Vec3 = struct {
|
|
x: f32,
|
|
y: f32,
|
|
z: f32,
|
|
|
|
pub fn init(x: f32, y: f32, z: f32) Vec3 {
|
|
return Vec3 {
|
|
.x = x,
|
|
.y = y,
|
|
.z = z,
|
|
};
|
|
}
|
|
|
|
pub fn dot(self: &const Vec3, other: &const Vec3) f32 {
|
|
return self.x * other.x + self.y * other.y + self.z * other.z;
|
|
}
|
|
};
|
|
|
|
const assert = @import("std").debug.assert;
|
|
test "dot product" {
|
|
const v1 = Vec3.init(1.0, 0.0, 0.0);
|
|
const v2 = Vec3.init(0.0, 1.0, 0.0);
|
|
assert(v1.dot(v2) == 0.0);
|
|
|
|
// Other than being available to call with dot syntax, struct methods are
|
|
// not special. You can reference them as any other declaration inside
|
|
// the struct:
|
|
assert(Vec3.dot(v1, v2) == 0.0);
|
|
}
|
|
|
|
// Structs can have global declarations.
|
|
// Structs can have 0 fields.
|
|
const Empty = struct {
|
|
pub const PI = 3.14;
|
|
};
|
|
test "struct namespaced variable" {
|
|
assert(Empty.PI == 3.14);
|
|
assert(@sizeOf(Empty) == 0);
|
|
|
|
// you can still instantiate an empty struct
|
|
const does_nothing = Empty {};
|
|
}
|
|
|
|
// struct field order is determined by the compiler for optimal performance.
|
|
// however, you can still calculate a struct base pointer given a field pointer:
|
|
fn setYBasedOnX(x: &f32, y: f32) void {
|
|
const point = @fieldParentPtr(Point, "x", x);
|
|
point.y = y;
|
|
}
|
|
test "field parent pointer" {
|
|
var point = Point {
|
|
.x = 0.1234,
|
|
.y = 0.5678,
|
|
};
|
|
setYBasedOnX(&point.x, 0.9);
|
|
assert(point.y == 0.9);
|
|
}
|
|
|
|
// You can return a struct from a function. This is how we do generics
|
|
// in Zig:
|
|
fn LinkedList(comptime T: type) type {
|
|
return struct {
|
|
pub const Node = struct {
|
|
prev: ?&Node,
|
|
next: ?&Node,
|
|
data: T,
|
|
};
|
|
|
|
first: ?&Node,
|
|
last: ?&Node,
|
|
len: usize,
|
|
};
|
|
}
|
|
|
|
test "linked list" {
|
|
// Functions called at compile-time are memoized. This means you can
|
|
// do this:
|
|
assert(LinkedList(i32) == LinkedList(i32));
|
|
|
|
var list = LinkedList(i32) {
|
|
.first = null,
|
|
.last = null,
|
|
.len = 0,
|
|
};
|
|
assert(list.len == 0);
|
|
|
|
// Since types are first class values you can instantiate the type
|
|
// by assigning it to a variable:
|
|
const ListOfInts = LinkedList(i32);
|
|
assert(ListOfInts == LinkedList(i32));
|
|
|
|
var node = ListOfInts.Node {
|
|
.prev = null,
|
|
.next = null,
|
|
.data = 1234,
|
|
};
|
|
var list2 = LinkedList(i32) {
|
|
.first = &node,
|
|
.last = &node,
|
|
.len = 1,
|
|
};
|
|
assert((??list2.first).data == 1234);
|
|
}
|
|
{#code_end#}
|
|
{#see_also|comptime|@fieldParentPtr#}
|
|
{#header_close#}
|
|
{#header_open|enum#}
|
|
{#code_begin|test|enums#}
|
|
const assert = @import("std").debug.assert;
|
|
const mem = @import("std").mem;
|
|
|
|
// Declare an enum.
|
|
const Type = enum {
|
|
Ok,
|
|
NotOk,
|
|
};
|
|
|
|
// Declare a specific instance of the enum variant.
|
|
const c = Type.Ok;
|
|
|
|
// If you want access to the ordinal value of an enum, you
|
|
// can specify the tag type.
|
|
const Value = enum(u2) {
|
|
Zero,
|
|
One,
|
|
Two,
|
|
};
|
|
|
|
// Now you can cast between u2 and Value.
|
|
// The ordinal value starts from 0, counting up for each member.
|
|
test "enum ordinal value" {
|
|
assert(u2(Value.Zero) == 0);
|
|
assert(u2(Value.One) == 1);
|
|
assert(u2(Value.Two) == 2);
|
|
}
|
|
|
|
// You can override the ordinal value for an enum.
|
|
const Value2 = enum(u32) {
|
|
Hundred = 100,
|
|
Thousand = 1000,
|
|
Million = 1000000,
|
|
};
|
|
test "set enum ordinal value" {
|
|
assert(u32(Value2.Hundred) == 100);
|
|
assert(u32(Value2.Thousand) == 1000);
|
|
assert(u32(Value2.Million) == 1000000);
|
|
}
|
|
|
|
// Enums can have methods, the same as structs and unions.
|
|
// Enum methods are not special, they are only namespaced
|
|
// functions that you can call with dot syntax.
|
|
const Suit = enum {
|
|
Clubs,
|
|
Spades,
|
|
Diamonds,
|
|
Hearts,
|
|
|
|
pub fn isClubs(self: Suit) bool {
|
|
return self == Suit.Clubs;
|
|
}
|
|
};
|
|
test "enum method" {
|
|
const p = Suit.Spades;
|
|
assert(!p.isClubs());
|
|
}
|
|
|
|
// An enum variant of different types can be switched upon.
|
|
const Foo = enum {
|
|
String,
|
|
Number,
|
|
None,
|
|
};
|
|
test "enum variant switch" {
|
|
const p = Foo.Number;
|
|
const what_is_it = switch (p) {
|
|
Foo.String => "this is a string",
|
|
Foo.Number => "this is a number",
|
|
Foo.None => "this is a none",
|
|
};
|
|
assert(mem.eql(u8, what_is_it, "this is a number"));
|
|
}
|
|
|
|
// @TagType can be used to access the integer tag type of an enum.
|
|
const Small = enum {
|
|
One,
|
|
Two,
|
|
Three,
|
|
Four,
|
|
};
|
|
test "@TagType" {
|
|
assert(@TagType(Small) == u2);
|
|
}
|
|
|
|
// @memberCount tells how many fields an enum has:
|
|
test "@memberCount" {
|
|
assert(@memberCount(Small) == 4);
|
|
}
|
|
|
|
// @memberName tells the name of a field in an enum:
|
|
test "@memberName" {
|
|
assert(mem.eql(u8, @memberName(Small, 1), "Two"));
|
|
}
|
|
|
|
// @tagName gives a []const u8 representation of an enum value:
|
|
test "@tagName" {
|
|
assert(mem.eql(u8, @tagName(Small.Three), "Three"));
|
|
}
|
|
{#code_end#}
|
|
{#header_open|extern enum#}
|
|
<p>
|
|
By default, enums are not guaranteed to be compatible with the C ABI:
|
|
</p>
|
|
{#code_begin|obj_err|parameter of type 'Foo' not allowed in function with calling convention 'ccc'#}
|
|
const Foo = enum { A, B, C };
|
|
export fn entry(foo: Foo) void { }
|
|
{#code_end#}
|
|
<p>
|
|
For a C-ABI-compatible enum, use <code class="zig">extern enum</code>:
|
|
</p>
|
|
{#code_begin|obj#}
|
|
const Foo = extern enum { A, B, C };
|
|
export fn entry(foo: Foo) void { }
|
|
{#code_end#}
|
|
{#header_close#}
|
|
{#header_open|packed enum#}
|
|
<p>By default, the size of enums is not guaranteed.</p>
|
|
<p><code>packed enum</code> causes the size of the enum to be the same as the size of the integer tag type
|
|
of the enum:</p>
|
|
{#code_begin|test#}
|
|
const std = @import("std");
|
|
|
|
test "packed enum" {
|
|
const Number = packed enum(u8) {
|
|
One,
|
|
Two,
|
|
Three,
|
|
};
|
|
std.debug.assert(@sizeOf(Number) == @sizeOf(u8));
|
|
}
|
|
{#code_end#}
|
|
{#header_close#}
|
|
{#see_also|@memberName|@memberCount|@tagName|@sizeOf#}
|
|
{#header_close#}
|
|
{#header_open|union#}
|
|
{#code_begin|test|union#}
|
|
const assert = @import("std").debug.assert;
|
|
const mem = @import("std").mem;
|
|
|
|
// A union has only 1 active field at a time.
|
|
const Payload = union {
|
|
Int: i64,
|
|
Float: f64,
|
|
Bool: bool,
|
|
};
|
|
test "simple union" {
|
|
var payload = Payload {.Int = 1234};
|
|
// payload.Float = 12.34; // ERROR! field not active
|
|
assert(payload.Int == 1234);
|
|
// You can activate another field by assigning the entire union.
|
|
payload = Payload {.Float = 12.34};
|
|
assert(payload.Float == 12.34);
|
|
}
|
|
|
|
// Unions can be given an enum tag type:
|
|
const ComplexTypeTag = enum { Ok, NotOk };
|
|
const ComplexType = union(ComplexTypeTag) {
|
|
Ok: u8,
|
|
NotOk: void,
|
|
};
|
|
|
|
// Declare a specific instance of the union variant.
|
|
test "declare union value" {
|
|
const c = ComplexType { .Ok = 0 };
|
|
assert(ComplexTypeTag(c) == ComplexTypeTag.Ok);
|
|
}
|
|
|
|
// @TagType can be used to access the enum tag type of a union.
|
|
test "@TagType" {
|
|
assert(@TagType(ComplexType) == ComplexTypeTag);
|
|
}
|
|
|
|
// Unions can be made to infer the enum tag type.
|
|
const Foo = union(enum) {
|
|
String: []const u8,
|
|
Number: u64,
|
|
|
|
// void can be omitted when inferring enum tag type.
|
|
None,
|
|
};
|
|
test "union variant switch" {
|
|
const p = Foo { .Number = 54 };
|
|
const what_is_it = switch (p) {
|
|
// Capture by reference
|
|
Foo.String => |*x| blk: {
|
|
break :blk "this is a string";
|
|
},
|
|
|
|
// Capture by value
|
|
Foo.Number => |x| blk: {
|
|
assert(x == 54);
|
|
break :blk "this is a number";
|
|
},
|
|
|
|
Foo.None => blk: {
|
|
break :blk "this is a none";
|
|
},
|
|
};
|
|
assert(mem.eql(u8, what_is_it, "this is a number"));
|
|
}
|
|
|
|
// Unions can have methods just like structs and enums:
|
|
|
|
const Variant = union(enum) {
|
|
Int: i32,
|
|
Bool: bool,
|
|
|
|
fn truthy(self: &const Variant) bool {
|
|
return switch (*self) {
|
|
Variant.Int => |x_int| x_int != 0,
|
|
Variant.Bool => |x_bool| x_bool,
|
|
};
|
|
}
|
|
};
|
|
|
|
test "union method" {
|
|
var v1 = Variant { .Int = 1 };
|
|
var v2 = Variant { .Bool = false };
|
|
|
|
assert(v1.truthy());
|
|
assert(!v2.truthy());
|
|
}
|
|
|
|
|
|
const Small = union {
|
|
A: i32,
|
|
B: bool,
|
|
C: u8,
|
|
};
|
|
|
|
// @memberCount tells how many fields a union has:
|
|
test "@memberCount" {
|
|
assert(@memberCount(Small) == 3);
|
|
}
|
|
|
|
// @memberName tells the name of a field in an enum:
|
|
test "@memberName" {
|
|
assert(mem.eql(u8, @memberName(Small, 1), "B"));
|
|
}
|
|
|
|
// @tagName gives a []const u8 representation of an enum value,
|
|
// but only if the union has an enum tag type.
|
|
const Small2 = union(enum) {
|
|
A: i32,
|
|
B: bool,
|
|
C: u8,
|
|
};
|
|
test "@tagName" {
|
|
assert(mem.eql(u8, @tagName(Small2.C), "C"));
|
|
}
|
|
{#code_end#}
|
|
<p>
|
|
Unions with an enum tag are generated as a struct with a tag field and union field. Zig
|
|
sorts the order of the tag and union field by the largest alignment.
|
|
</p>
|
|
{#header_close#}
|
|
{#header_open|switch#}
|
|
{#code_begin|test|switch#}
|
|
const assert = @import("std").debug.assert;
|
|
const builtin = @import("builtin");
|
|
|
|
test "switch simple" {
|
|
const a: u64 = 10;
|
|
const zz: u64 = 103;
|
|
|
|
// All branches of a switch expression must be able to be coerced to a
|
|
// common type.
|
|
//
|
|
// Branches cannot fallthrough. If fallthrough behavior is desired, combine
|
|
// the cases and use an if.
|
|
const b = switch (a) {
|
|
// Multiple cases can be combined via a ','
|
|
1, 2, 3 => 0,
|
|
|
|
// Ranges can be specified using the ... syntax. These are inclusive
|
|
// both ends.
|
|
5 ... 100 => 1,
|
|
|
|
// Branches can be arbitrarily complex.
|
|
101 => blk: {
|
|
const c: u64 = 5;
|
|
break :blk c * 2 + 1;
|
|
},
|
|
|
|
// Switching on arbitrary expressions is allowed as long as the
|
|
// expression is known at compile-time.
|
|
zz => zz,
|
|
comptime blk: {
|
|
const d: u32 = 5;
|
|
const e: u32 = 100;
|
|
break :blk d + e;
|
|
} => 107,
|
|
|
|
// The else branch catches everything not already captured.
|
|
// Else branches are mandatory unless the entire range of values
|
|
// is handled.
|
|
else => 9,
|
|
};
|
|
|
|
assert(b == 1);
|
|
}
|
|
|
|
test "switch enum" {
|
|
const Item = union(enum) {
|
|
A: u32,
|
|
C: struct { x: u8, y: u8 },
|
|
D,
|
|
};
|
|
|
|
var a = Item { .A = 3 };
|
|
|
|
// Switching on more complex enums is allowed.
|
|
const b = switch (a) {
|
|
// A capture group is allowed on a match, and will return the enum
|
|
// value matched.
|
|
Item.A => |item| item,
|
|
|
|
// A reference to the matched value can be obtained using `*` syntax.
|
|
Item.C => |*item| blk: {
|
|
(*item).x += 1;
|
|
break :blk 6;
|
|
},
|
|
|
|
// No else is required if the types cases was exhaustively handled
|
|
Item.D => 8,
|
|
};
|
|
|
|
assert(b == 3);
|
|
}
|
|
|
|
// Switch expressions can be used outside a function:
|
|
const os_msg = switch (builtin.os) {
|
|
builtin.Os.linux => "we found a linux user",
|
|
else => "not a linux user",
|
|
};
|
|
|
|
// Inside a function, switch statements implicitly are compile-time
|
|
// evaluated if the target expression is compile-time known.
|
|
test "switch inside function" {
|
|
switch (builtin.os) {
|
|
builtin.Os.fuchsia => {
|
|
// On an OS other than fuchsia, block is not even analyzed,
|
|
// so this compile error is not triggered.
|
|
// On fuchsia this compile error would be triggered.
|
|
@compileError("windows not supported");
|
|
},
|
|
else => {},
|
|
}
|
|
}
|
|
{#code_end#}
|
|
{#see_also|comptime|enum|@compileError|Compile Variables#}
|
|
{#header_close#}
|
|
{#header_open|while#}
|
|
{#code_begin|test|while#}
|
|
const assert = @import("std").debug.assert;
|
|
|
|
test "while basic" {
|
|
// A while loop is used to repeatedly execute an expression until
|
|
// some condition is no longer true.
|
|
var i: usize = 0;
|
|
while (i < 10) {
|
|
i += 1;
|
|
}
|
|
assert(i == 10);
|
|
}
|
|
|
|
test "while break" {
|
|
// You can use break to exit a while loop early.
|
|
var i: usize = 0;
|
|
while (true) {
|
|
if (i == 10)
|
|
break;
|
|
i += 1;
|
|
}
|
|
assert(i == 10);
|
|
}
|
|
|
|
test "while continue" {
|
|
// You can use continue to jump back to the beginning of the loop.
|
|
var i: usize = 0;
|
|
while (true) {
|
|
i += 1;
|
|
if (i < 10)
|
|
continue;
|
|
break;
|
|
}
|
|
assert(i == 10);
|
|
}
|
|
|
|
test "while loop continuation expression" {
|
|
// You can give an expression to the while loop to execute when
|
|
// the loop is continued. This is respected by the continue control flow.
|
|
var i: usize = 0;
|
|
while (i < 10) : (i += 1) {}
|
|
assert(i == 10);
|
|
}
|
|
|
|
test "while loop continuation expression, more complicated" {
|
|
// More complex blocks can be used as an expression in the loop continue
|
|
// expression.
|
|
var i1: usize = 1;
|
|
var j1: usize = 1;
|
|
while (i1 * j1 < 2000) : ({ i1 *= 2; j1 *= 3; }) {
|
|
const my_ij1 = i1 * j1;
|
|
assert(my_ij1 < 2000);
|
|
}
|
|
}
|
|
|
|
test "while else" {
|
|
assert(rangeHasNumber(0, 10, 5));
|
|
assert(!rangeHasNumber(0, 10, 15));
|
|
}
|
|
|
|
fn rangeHasNumber(begin: usize, end: usize, number: usize) bool {
|
|
var i = begin;
|
|
// While loops are expressions. The result of the expression is the
|
|
// result of the else clause of a while loop, which is executed when
|
|
// the condition of the while loop is tested as false.
|
|
return while (i < end) : (i += 1) {
|
|
if (i == number) {
|
|
// break expressions, like return expressions, accept a value
|
|
// parameter. This is the result of the while expression.
|
|
// When you break from a while loop, the else branch is not
|
|
// evaluated.
|
|
break true;
|
|
}
|
|
} else false;
|
|
}
|
|
|
|
test "while null capture" {
|
|
// Just like if expressions, while loops can take a nullable as the
|
|
// condition and capture the payload. When null is encountered the loop
|
|
// exits.
|
|
var sum1: u32 = 0;
|
|
numbers_left = 3;
|
|
while (eventuallyNullSequence()) |value| {
|
|
sum1 += value;
|
|
}
|
|
assert(sum1 == 3);
|
|
|
|
// The else branch is allowed on nullable iteration. In this case, it will
|
|
// be executed on the first null value encountered.
|
|
var sum2: u32 = 0;
|
|
numbers_left = 3;
|
|
while (eventuallyNullSequence()) |value| {
|
|
sum2 += value;
|
|
} else {
|
|
assert(sum1 == 3);
|
|
}
|
|
|
|
// Just like if expressions, while loops can also take an error union as
|
|
// the condition and capture the payload or the error code. When the
|
|
// condition results in an error code the else branch is evaluated and
|
|
// the loop is finished.
|
|
var sum3: u32 = 0;
|
|
numbers_left = 3;
|
|
while (eventuallyErrorSequence()) |value| {
|
|
sum3 += value;
|
|
} else |err| {
|
|
assert(err == error.ReachedZero);
|
|
}
|
|
}
|
|
|
|
var numbers_left: u32 = undefined;
|
|
fn eventuallyNullSequence() ?u32 {
|
|
return if (numbers_left == 0) null else blk: {
|
|
numbers_left -= 1;
|
|
break :blk numbers_left;
|
|
};
|
|
}
|
|
|
|
fn eventuallyErrorSequence() error!u32 {
|
|
return if (numbers_left == 0) error.ReachedZero else blk: {
|
|
numbers_left -= 1;
|
|
break :blk numbers_left;
|
|
};
|
|
}
|
|
|
|
test "inline while loop" {
|
|
// While loops can be inlined. This causes the loop to be unrolled, which
|
|
// allows the code to do some things which only work at compile time,
|
|
// such as use types as first class values.
|
|
comptime var i = 0;
|
|
var sum: usize = 0;
|
|
inline while (i < 3) : (i += 1) {
|
|
const T = switch (i) {
|
|
0 => f32,
|
|
1 => i8,
|
|
2 => bool,
|
|
else => unreachable,
|
|
};
|
|
sum += typeNameLength(T);
|
|
}
|
|
assert(sum == 9);
|
|
}
|
|
|
|
fn typeNameLength(comptime T: type) usize {
|
|
return @typeName(T).len;
|
|
}
|
|
{#code_end#}
|
|
{#see_also|if|Nullables|Errors|comptime|unreachable#}
|
|
{#header_close#}
|
|
{#header_open|for#}
|
|
{#code_begin|test|for#}
|
|
const assert = @import("std").debug.assert;
|
|
|
|
test "for basics" {
|
|
const items = []i32 { 4, 5, 3, 4, 0 };
|
|
var sum: i32 = 0;
|
|
|
|
// For loops iterate over slices and arrays.
|
|
for (items) |value| {
|
|
// Break and continue are supported.
|
|
if (value == 0) {
|
|
continue;
|
|
}
|
|
sum += value;
|
|
}
|
|
assert(sum == 16);
|
|
|
|
// To iterate over a portion of a slice, reslice.
|
|
for (items[0..1]) |value| {
|
|
sum += value;
|
|
}
|
|
assert(sum == 20);
|
|
|
|
// To access the index of iteration, specify a second capture value.
|
|
// This is zero-indexed.
|
|
var sum2: i32 = 0;
|
|
for (items) |value, i| {
|
|
assert(@typeOf(i) == usize);
|
|
sum2 += i32(i);
|
|
}
|
|
assert(sum2 == 10);
|
|
}
|
|
|
|
test "for reference" {
|
|
var items = []i32 { 3, 4, 2 };
|
|
|
|
// Iterate over the slice by reference by
|
|
// specifying that the capture value is a pointer.
|
|
for (items) |*value| {
|
|
*value += 1;
|
|
}
|
|
|
|
assert(items[0] == 4);
|
|
assert(items[1] == 5);
|
|
assert(items[2] == 3);
|
|
}
|
|
|
|
test "for else" {
|
|
// For allows an else attached to it, the same as a while loop.
|
|
var items = []?i32 { 3, 4, null, 5 };
|
|
|
|
// For loops can also be used as expressions.
|
|
var sum: i32 = 0;
|
|
const result = for (items) |value| {
|
|
if (value == null) {
|
|
break 9;
|
|
} else {
|
|
sum += ??value;
|
|
}
|
|
} else blk: {
|
|
assert(sum == 7);
|
|
break :blk sum;
|
|
};
|
|
}
|
|
|
|
|
|
test "inline for loop" {
|
|
const nums = []i32{2, 4, 6};
|
|
// For loops can be inlined. This causes the loop to be unrolled, which
|
|
// allows the code to do some things which only work at compile time,
|
|
// such as use types as first class values.
|
|
// The capture value and iterator value of inlined for loops are
|
|
// compile-time known.
|
|
var sum: usize = 0;
|
|
inline for (nums) |i| {
|
|
const T = switch (i) {
|
|
2 => f32,
|
|
4 => i8,
|
|
6 => bool,
|
|
else => unreachable,
|
|
};
|
|
sum += typeNameLength(T);
|
|
}
|
|
assert(sum == 9);
|
|
}
|
|
|
|
fn typeNameLength(comptime T: type) usize {
|
|
return @typeName(T).len;
|
|
}
|
|
{#code_end#}
|
|
{#see_also|while|comptime|Arrays|Slices#}
|
|
{#header_close#}
|
|
{#header_open|if#}
|
|
{#code_begin|test|if#}
|
|
// If expressions have three uses, corresponding to the three types:
|
|
// * bool
|
|
// * ?T
|
|
// * error!T
|
|
|
|
const assert = @import("std").debug.assert;
|
|
|
|
test "if boolean" {
|
|
// If expressions test boolean conditions.
|
|
const a: u32 = 5;
|
|
const b: u32 = 4;
|
|
if (a != b) {
|
|
assert(true);
|
|
} else if (a == 9) {
|
|
unreachable;
|
|
} else {
|
|
unreachable;
|
|
}
|
|
|
|
// If expressions are used instead of a ternary expression.
|
|
const result = if (a != b) 47 else 3089;
|
|
assert(result == 47);
|
|
}
|
|
|
|
test "if nullable" {
|
|
// If expressions test for null.
|
|
|
|
const a: ?u32 = 0;
|
|
if (a) |value| {
|
|
assert(value == 0);
|
|
} else {
|
|
unreachable;
|
|
}
|
|
|
|
const b: ?u32 = null;
|
|
if (b) |value| {
|
|
unreachable;
|
|
} else {
|
|
assert(true);
|
|
}
|
|
|
|
// The else is not required.
|
|
if (a) |value| {
|
|
assert(value == 0);
|
|
}
|
|
|
|
// To test against null only, use the binary equality operator.
|
|
if (b == null) {
|
|
assert(true);
|
|
}
|
|
|
|
// Access the value by reference using a pointer capture.
|
|
var c: ?u32 = 3;
|
|
if (c) |*value| {
|
|
*value = 2;
|
|
}
|
|
|
|
if (c) |value| {
|
|
assert(value == 2);
|
|
} else {
|
|
unreachable;
|
|
}
|
|
}
|
|
|
|
test "if error union" {
|
|
// If expressions test for errors.
|
|
// Note the |err| capture on the else.
|
|
|
|
const a: error!u32 = 0;
|
|
if (a) |value| {
|
|
assert(value == 0);
|
|
} else |err| {
|
|
unreachable;
|
|
}
|
|
|
|
const b: error!u32 = error.BadValue;
|
|
if (b) |value| {
|
|
unreachable;
|
|
} else |err| {
|
|
assert(err == error.BadValue);
|
|
}
|
|
|
|
// The else and |err| capture is strictly required.
|
|
if (a) |value| {
|
|
assert(value == 0);
|
|
} else |_| {}
|
|
|
|
// To check only the error value, use an empty block expression.
|
|
if (b) |_| {} else |err| {
|
|
assert(err == error.BadValue);
|
|
}
|
|
|
|
// Access the value by reference using a pointer capture.
|
|
var c: error!u32 = 3;
|
|
if (c) |*value| {
|
|
*value = 9;
|
|
} else |err| {
|
|
unreachable;
|
|
}
|
|
|
|
if (c) |value| {
|
|
assert(value == 9);
|
|
} else |err| {
|
|
unreachable;
|
|
}
|
|
}
|
|
{#code_end#}
|
|
{#see_also|Nullables|Errors#}
|
|
{#header_close#}
|
|
{#header_open|defer#}
|
|
{#code_begin|test|defer#}
|
|
const std = @import("std");
|
|
const assert = std.debug.assert;
|
|
const warn = std.debug.warn;
|
|
|
|
// defer will execute an expression at the end of the current scope.
|
|
fn deferExample() usize {
|
|
var a: usize = 1;
|
|
|
|
{
|
|
defer a = 2;
|
|
a = 1;
|
|
}
|
|
assert(a == 2);
|
|
|
|
a = 5;
|
|
return a;
|
|
}
|
|
|
|
test "defer basics" {
|
|
assert(deferExample() == 5);
|
|
}
|
|
|
|
// If multiple defer statements are specified, they will be executed in
|
|
// the reverse order they were run.
|
|
fn deferUnwindExample() void {
|
|
warn("\n");
|
|
|
|
defer {
|
|
warn("1 ");
|
|
}
|
|
defer {
|
|
warn("2 ");
|
|
}
|
|
if (false) {
|
|
// defers are not run if they are never executed.
|
|
defer {
|
|
warn("3 ");
|
|
}
|
|
}
|
|
}
|
|
|
|
test "defer unwinding" {
|
|
deferUnwindExample();
|
|
}
|
|
|
|
// The errdefer keyword is similar to defer, but will only execute if the
|
|
// scope returns with an error.
|
|
//
|
|
// This is especially useful in allowing a function to clean up properly
|
|
// on error, and replaces goto error handling tactics as seen in c.
|
|
fn deferErrorExample(is_error: bool) !void {
|
|
warn("\nstart of function\n");
|
|
|
|
// This will always be executed on exit
|
|
defer {
|
|
warn("end of function\n");
|
|
}
|
|
|
|
errdefer {
|
|
warn("encountered an error!\n");
|
|
}
|
|
|
|
if (is_error) {
|
|
return error.DeferError;
|
|
}
|
|
}
|
|
|
|
test "errdefer unwinding" {
|
|
_ = deferErrorExample(false);
|
|
_ = deferErrorExample(true);
|
|
}
|
|
{#code_end#}
|
|
{#see_also|Errors#}
|
|
{#header_close#}
|
|
{#header_open|unreachable#}
|
|
<p>
|
|
In <code>Debug</code> and <code>ReleaseSafe</code> mode, and when using <code>zig test</code>,
|
|
<code>unreachable</code> emits a call to <code>panic</code> with the message <code>reached unreachable code</code>.
|
|
</p>
|
|
<p>
|
|
In <code>ReleaseFast</code> mode, the optimizer uses the assumption that <code>unreachable</code> code
|
|
will never be hit to perform optimizations. However, <code>zig test</code> even in <code>ReleaseFast</code> mode
|
|
still emits <code>unreachable</code> as calls to <code>panic</code>.
|
|
</p>
|
|
{#header_open|Basics#}
|
|
{#code_begin|test#}
|
|
// unreachable is used to assert that control flow will never happen upon a
|
|
// particular location:
|
|
test "basic math" {
|
|
const x = 1;
|
|
const y = 2;
|
|
if (x + y != 3) {
|
|
unreachable;
|
|
}
|
|
}
|
|
{#code_end#}
|
|
<p>In fact, this is how assert is implemented:</p>
|
|
{#code_begin|test_err#}
|
|
fn assert(ok: bool) void {
|
|
if (!ok) unreachable; // assertion failure
|
|
}
|
|
|
|
// This test will fail because we hit unreachable.
|
|
test "this will fail" {
|
|
assert(false);
|
|
}
|
|
{#code_end#}
|
|
{#header_close#}
|
|
{#header_open|At Compile-Time#}
|
|
{#code_begin|test_err|unreachable code#}
|
|
const assert = @import("std").debug.assert;
|
|
|
|
test "type of unreachable" {
|
|
comptime {
|
|
// The type of unreachable is noreturn.
|
|
|
|
// However this assertion will still fail because
|
|
// evaluating unreachable at compile-time is a compile error.
|
|
|
|
assert(@typeOf(unreachable) == noreturn);
|
|
}
|
|
}
|
|
{#code_end#}
|
|
{#see_also|Zig Test|Build Mode|comptime#}
|
|
{#header_close#}
|
|
{#header_close#}
|
|
{#header_open|noreturn#}
|
|
<p>
|
|
<code>noreturn</code> is the type of:
|
|
</p>
|
|
<ul>
|
|
<li><code>break</code></li>
|
|
<li><code>continue</code></li>
|
|
<li><code>return</code></li>
|
|
<li><code>unreachable</code></li>
|
|
<li><code>while (true) {}</code></li>
|
|
</ul>
|
|
<p>When resolving types together, such as <code>if</code> clauses or <code>switch</code> prongs,
|
|
the <code>noreturn</code> type is compatible with every other type. Consider:
|
|
</p>
|
|
{#code_begin|test#}
|
|
fn foo(condition: bool, b: u32) void {
|
|
const a = if (condition) b else return;
|
|
@panic("do something with a");
|
|
}
|
|
test "noreturn" {
|
|
foo(false, 1);
|
|
}
|
|
{#code_end#}
|
|
<p>Another use case for <code>noreturn</code> is the <code>exit</code> function:</p>
|
|
{#code_begin|test#}
|
|
{#target_windows#}
|
|
pub extern "kernel32" stdcallcc fn ExitProcess(exit_code: c_uint) noreturn;
|
|
|
|
test "foo" {
|
|
const value = bar() catch ExitProcess(1);
|
|
assert(value == 1234);
|
|
}
|
|
|
|
fn bar() error!u32 {
|
|
return 1234;
|
|
}
|
|
|
|
const assert = @import("std").debug.assert;
|
|
{#code_end#}
|
|
{#header_close#}
|
|
{#header_open|Functions#}
|
|
{#code_begin|test|functions#}
|
|
const assert = @import("std").debug.assert;
|
|
|
|
// Functions are declared like this
|
|
fn add(a: i8, b: i8) i8 {
|
|
if (a == 0) {
|
|
// You can still return manually if needed.
|
|
return b;
|
|
}
|
|
|
|
return a + b;
|
|
}
|
|
|
|
// The export specifier makes a function externally visible in the generated
|
|
// object file, and makes it use the C ABI.
|
|
export fn sub(a: i8, b: i8) i8 { return a - b; }
|
|
|
|
// The extern specifier is used to declare a function that will be resolved
|
|
// at link time, when linking statically, or at runtime, when linking
|
|
// dynamically.
|
|
// The stdcallcc specifier changes the calling convention of the function.
|
|
extern "kernel32" stdcallcc fn ExitProcess(exit_code: u32) noreturn;
|
|
extern "c" fn atan2(a: f64, b: f64) f64;
|
|
|
|
// The @setCold builtin tells the optimizer that a function is rarely called.
|
|
fn abort() noreturn {
|
|
@setCold(true);
|
|
while (true) {}
|
|
}
|
|
|
|
// nakedcc makes a function not have any function prologue or epilogue.
|
|
// This can be useful when integrating with assembly.
|
|
nakedcc fn _start() noreturn {
|
|
abort();
|
|
}
|
|
|
|
// The pub specifier allows the function to be visible when importing.
|
|
// Another file can use @import and call sub2
|
|
pub fn sub2(a: i8, b: i8) i8 { return a - b; }
|
|
|
|
// Functions can be used as values and are equivalent to pointers.
|
|
const call2_op = fn (a: i8, b: i8) i8;
|
|
fn do_op(fn_call: call2_op, op1: i8, op2: i8) i8 {
|
|
return fn_call(op1, op2);
|
|
}
|
|
|
|
test "function" {
|
|
assert(do_op(add, 5, 6) == 11);
|
|
assert(do_op(sub2, 5, 6) == -1);
|
|
}
|
|
{#code_end#}
|
|
<p>Function values are like pointers:</p>
|
|
{#code_begin|obj#}
|
|
const assert = @import("std").debug.assert;
|
|
|
|
comptime {
|
|
assert(@typeOf(foo) == fn()void);
|
|
assert(@sizeOf(fn()void) == @sizeOf(?fn()void));
|
|
}
|
|
|
|
fn foo() void { }
|
|
{#code_end#}
|
|
{#header_open|Pass-by-value Parameters#}
|
|
<p>
|
|
In Zig, structs, unions, and enums with payloads cannot be passed by value
|
|
to a function.
|
|
</p>
|
|
{#code_begin|test_err|not copyable; cannot pass by value#}
|
|
const Foo = struct {
|
|
x: i32,
|
|
};
|
|
|
|
fn bar(foo: Foo) void {}
|
|
|
|
test "pass aggregate type by value to function" {
|
|
bar(Foo {.x = 12,});
|
|
}
|
|
{#code_end#}
|
|
<p>
|
|
Instead, one must use <code>&const</code>. Zig allows implicitly casting something
|
|
to a const pointer to it:
|
|
</p>
|
|
{#code_begin|test#}
|
|
const Foo = struct {
|
|
x: i32,
|
|
};
|
|
|
|
fn bar(foo: &const Foo) void {}
|
|
|
|
test "implicitly cast to const pointer" {
|
|
bar(Foo {.x = 12,});
|
|
}
|
|
{#code_end#}
|
|
<p>
|
|
However,
|
|
the C ABI does allow passing structs and unions by value. So functions which
|
|
use the C calling convention may pass structs and unions by value.
|
|
</p>
|
|
{#header_close#}
|
|
{#header_open|Function Reflection#}
|
|
{#code_begin|test#}
|
|
const assert = @import("std").debug.assert;
|
|
|
|
test "fn reflection" {
|
|
assert(@typeOf(assert).ReturnType == void);
|
|
assert(@typeOf(assert).is_var_args == false);
|
|
}
|
|
{#code_end#}
|
|
{#header_close#}
|
|
{#header_close#}
|
|
{#header_open|Errors#}
|
|
{#header_open|Error Set Type#}
|
|
<p>
|
|
An error set is like an {#link|enum#}.
|
|
However, each error name across the entire compilation gets assigned an unsigned integer
|
|
greater than 0. You are allowed to declare the same error name more than once, and if you do, it
|
|
gets assigned the same integer value.
|
|
</p>
|
|
<p>
|
|
The number of unique error values across the entire compilation should determine the size of the error set type.
|
|
However right now it is hard coded to be a <code>u16</code>. See <a href="https://github.com/zig-lang/zig/issues/786">#768</a>.
|
|
</p>
|
|
<p>
|
|
You can implicitly cast an error from a subset to its superset:
|
|
</p>
|
|
{#code_begin|test#}
|
|
const std = @import("std");
|
|
|
|
const FileOpenError = error {
|
|
AccessDenied,
|
|
OutOfMemory,
|
|
FileNotFound,
|
|
};
|
|
|
|
const AllocationError = error {
|
|
OutOfMemory,
|
|
};
|
|
|
|
test "implicit cast subset to superset" {
|
|
const err = foo(AllocationError.OutOfMemory);
|
|
std.debug.assert(err == FileOpenError.OutOfMemory);
|
|
}
|
|
|
|
fn foo(err: AllocationError) FileOpenError {
|
|
return err;
|
|
}
|
|
{#code_end#}
|
|
<p>
|
|
But you cannot implicitly cast an error from a superset to a subset:
|
|
</p>
|
|
{#code_begin|test_err|not a member of destination error set#}
|
|
const FileOpenError = error {
|
|
AccessDenied,
|
|
OutOfMemory,
|
|
FileNotFound,
|
|
};
|
|
|
|
const AllocationError = error {
|
|
OutOfMemory,
|
|
};
|
|
|
|
test "implicit cast superset to subset" {
|
|
foo(FileOpenError.OutOfMemory) catch {};
|
|
}
|
|
|
|
fn foo(err: FileOpenError) AllocationError {
|
|
return err;
|
|
}
|
|
{#code_end#}
|
|
<p>
|
|
There is a shortcut for declaring an error set with only 1 value, and then getting that value:
|
|
</p>
|
|
{#code_begin|syntax#}
|
|
const err = error.FileNotFound;
|
|
{#code_end#}
|
|
<p>This is equivalent to:</p>
|
|
{#code_begin|syntax#}
|
|
const err = (error {FileNotFound}).FileNotFound;
|
|
{#code_end#}
|
|
<p>
|
|
This becomes useful when using {#link|Inferred Error Sets#}.
|
|
</p>
|
|
{#header_open|The Global Error Set#}
|
|
<p><code>error</code> refers to the global error set.
|
|
This is the error set that contains all errors in the entire compilation unit.
|
|
It is a superset of all other error sets and a subset of none of them.
|
|
</p>
|
|
<p>
|
|
You can implicitly cast any error set to the global one, and you can explicitly
|
|
cast an error of global error set to a non-global one. This inserts a language-level
|
|
assert to make sure the error value is in fact in the destination error set.
|
|
</p>
|
|
<p>
|
|
The global error set should generally be avoided because it prevents the
|
|
compiler from knowing what errors are possible at compile-time. Knowing
|
|
the error set at compile-time is better for generated documentation and
|
|
helpful error messages, such as forgetting a possible error value in a {#link|switch#}.
|
|
</p>
|
|
{#header_close#}
|
|
{#header_close#}
|
|
{#header_open|Error Union Type#}
|
|
<p>
|
|
An error set type and normal type can be combined with the <code>!</code>
|
|
binary operator to form an error union type. You are likely to use an
|
|
error union type more often than an error set type by itself.
|
|
</p>
|
|
<p>
|
|
Here is a function to parse a string into a 64-bit integer:
|
|
</p>
|
|
{#code_begin|test#}
|
|
pub fn parseU64(buf: []const u8, radix: u8) !u64 {
|
|
var x: u64 = 0;
|
|
|
|
for (buf) |c| {
|
|
const digit = charToDigit(c);
|
|
|
|
if (digit >= radix) {
|
|
return error.InvalidChar;
|
|
}
|
|
|
|
// x *= radix
|
|
if (@mulWithOverflow(u64, x, radix, &x)) {
|
|
return error.Overflow;
|
|
}
|
|
|
|
// x += digit
|
|
if (@addWithOverflow(u64, x, digit, &x)) {
|
|
return error.Overflow;
|
|
}
|
|
}
|
|
|
|
return x;
|
|
}
|
|
|
|
fn charToDigit(c: u8) u8 {
|
|
return switch (c) {
|
|
'0' ... '9' => c - '0',
|
|
'A' ... 'Z' => c - 'A' + 10,
|
|
'a' ... 'z' => c - 'a' + 10,
|
|
else => @maxValue(u8),
|
|
};
|
|
}
|
|
|
|
test "parse u64" {
|
|
const result = try parseU64("1234", 10);
|
|
@import("std").debug.assert(result == 1234);
|
|
}
|
|
{#code_end#}
|
|
<p>
|
|
Notice the return type is <code>!u64</code>. This means that the function
|
|
either returns an unsigned 64 bit integer, or an error. We left off the error set
|
|
to the left of the <code>!</code>, so the error set is inferred.
|
|
</p>
|
|
<p>
|
|
Within the function definition, you can see some return statements that return
|
|
an error, and at the bottom a return statement that returns a <code>u64</code>.
|
|
Both types implicitly cast to <code>error!u64</code>.
|
|
</p>
|
|
<p>
|
|
What it looks like to use this function varies depending on what you're
|
|
trying to do. One of the following:
|
|
</p>
|
|
<ul>
|
|
<li>You want to provide a default value if it returned an error.</li>
|
|
<li>If it returned an error then you want to return the same error.</li>
|
|
<li>You know with complete certainty it will not return an error, so want to unconditionally unwrap it.</li>
|
|
<li>You want to take a different action for each possible error.</li>
|
|
</ul>
|
|
<p>If you want to provide a default value, you can use the <code>catch</code> binary operator:</p>
|
|
{#code_begin|syntax#}
|
|
fn doAThing(str: []u8) void {
|
|
const number = parseU64(str, 10) catch 13;
|
|
// ...
|
|
}
|
|
{#code_end#}
|
|
<p>
|
|
In this code, <code>number</code> will be equal to the successfully parsed string, or
|
|
a default value of 13. The type of the right hand side of the binary <code>catch</code> operator must
|
|
match the unwrapped error union type, or be of type <code>noreturn</code>.
|
|
</p>
|
|
<p>Let's say you wanted to return the error if you got one, otherwise continue with the
|
|
function logic:</p>
|
|
{#code_begin|syntax#}
|
|
fn doAThing(str: []u8) !void {
|
|
const number = parseU64(str, 10) catch |err| return err;
|
|
// ...
|
|
}
|
|
{#code_end#}
|
|
<p>
|
|
There is a shortcut for this. The <code>try</code> expression:
|
|
</p>
|
|
{#code_begin|syntax#}
|
|
fn doAThing(str: []u8) !void {
|
|
const number = try parseU64(str, 10);
|
|
// ...
|
|
}
|
|
{#code_end#}
|
|
<p>
|
|
<code>try</code> evaluates an error union expression. If it is an error, it returns
|
|
from the current function with the same error. Otherwise, the expression results in
|
|
the unwrapped value.
|
|
</p>
|
|
<p>
|
|
Maybe you know with complete certainty that an expression will never be an error.
|
|
In this case you can do this:
|
|
</p>
|
|
{#code_begin|syntax#}const number = parseU64("1234", 10) catch unreachable;{#code_end#}
|
|
<p>
|
|
Here we know for sure that "1234" will parse successfully. So we put the
|
|
<code>unreachable</code> value on the right hand side. <code>unreachable</code> generates
|
|
a panic in Debug and ReleaseSafe modes and undefined behavior in ReleaseFast mode. So, while we're debugging the
|
|
application, if there <em>was</em> a surprise error here, the application would crash
|
|
appropriately.
|
|
</p>
|
|
<p>
|
|
Finally, you may want to take a different action for every situation. For that, we combine
|
|
the <code>if</code> and <code>switch</code> expression:
|
|
</p>
|
|
{#code_begin|syntax#}
|
|
fn doAThing(str: []u8) void {
|
|
if (parseU64(str, 10)) |number| {
|
|
doSomethingWithNumber(number);
|
|
} else |err| switch (err) {
|
|
error.Overflow => {
|
|
// handle overflow...
|
|
},
|
|
// we promise that InvalidChar won't happen (or crash in debug mode if it does)
|
|
error.InvalidChar => unreachable,
|
|
}
|
|
}
|
|
{#code_end#}
|
|
<p>
|
|
The other component to error handling is defer statements.
|
|
In addition to an unconditional <code>defer</code>, Zig has <code>errdefer</code>,
|
|
which evaluates the deferred expression on block exit path if and only if
|
|
the function returned with an error from the block.
|
|
</p>
|
|
<p>
|
|
Example:
|
|
</p>
|
|
{#code_begin|syntax#}
|
|
fn createFoo(param: i32) !Foo {
|
|
const foo = try tryToAllocateFoo();
|
|
// now we have allocated foo. we need to free it if the function fails.
|
|
// but we want to return it if the function succeeds.
|
|
errdefer deallocateFoo(foo);
|
|
|
|
const tmp_buf = allocateTmpBuffer() ?? return error.OutOfMemory;
|
|
// tmp_buf is truly a temporary resource, and we for sure want to clean it up
|
|
// before this block leaves scope
|
|
defer deallocateTmpBuffer(tmp_buf);
|
|
|
|
if (param > 1337) return error.InvalidParam;
|
|
|
|
// here the errdefer will not run since we're returning success from the function.
|
|
// but the defer will run!
|
|
return foo;
|
|
}
|
|
{#code_end#}
|
|
<p>
|
|
The neat thing about this is that you get robust error handling without
|
|
the verbosity and cognitive overhead of trying to make sure every exit path
|
|
is covered. The deallocation code is always directly following the allocation code.
|
|
</p>
|
|
<p>
|
|
A couple of other tidbits about error handling:
|
|
</p>
|
|
<ul>
|
|
<li>These primitives give enough expressiveness that it's completely practical
|
|
to have failing to check for an error be a compile error. If you really want
|
|
to ignore the error, you can add <code>catch unreachable</code> and
|
|
get the added benefit of crashing in Debug and ReleaseSafe modes if your assumption was wrong.
|
|
</li>
|
|
<li>
|
|
Since Zig understands error types, it can pre-weight branches in favor of
|
|
errors not occuring. Just a small optimization benefit that is not available
|
|
in other languages.
|
|
</li>
|
|
</ul>
|
|
{#see_also|defer|if|switch#}
|
|
|
|
<p>An error union is created with the <code>!</code> binary operator.
|
|
You can use compile-time reflection to access the child type of an error union:</p>
|
|
{#code_begin|test#}
|
|
const assert = @import("std").debug.assert;
|
|
|
|
test "error union" {
|
|
var foo: error!i32 = undefined;
|
|
|
|
// Implicitly cast from child type of an error union:
|
|
foo = 1234;
|
|
|
|
// Implicitly cast from an error set:
|
|
foo = error.SomeError;
|
|
|
|
// Use compile-time reflection to access the payload type of an error union:
|
|
comptime assert(@typeOf(foo).Payload == i32);
|
|
|
|
// Use compile-time reflection to access the error set type of an error union:
|
|
comptime assert(@typeOf(foo).ErrorSet == error);
|
|
}
|
|
{#code_end#}
|
|
<p>TODO the <code>||</code> operator for error sets</p>
|
|
{#header_open|Inferred Error Sets#}
|
|
<p>TODO</p>
|
|
{#header_close#}
|
|
{#header_close#}
|
|
{#header_open|Error Return Traces#}
|
|
<p>TODO</p>
|
|
{#header_close#}
|
|
{#header_close#}
|
|
{#header_open|Nullables#}
|
|
<p>
|
|
One area that Zig provides safety without compromising efficiency or
|
|
readability is with the nullable type.
|
|
</p>
|
|
<p>
|
|
The question mark symbolizes the nullable type. You can convert a type to a nullable
|
|
type by putting a question mark in front of it, like this:
|
|
</p>
|
|
{#code_begin|syntax#}
|
|
// normal integer
|
|
const normal_int: i32 = 1234;
|
|
|
|
// nullable integer
|
|
const nullable_int: ?i32 = 5678;
|
|
{#code_end#}
|
|
<p>
|
|
Now the variable <code>nullable_int</code> could be an <code>i32</code>, or <code>null</code>.
|
|
</p>
|
|
<p>
|
|
Instead of integers, let's talk about pointers. Null references are the source of many runtime
|
|
exceptions, and even stand accused of being
|
|
<a href="https://www.lucidchart.com/techblog/2015/08/31/the-worst-mistake-of-computer-science/">the worst mistake of computer science</a>.
|
|
</p>
|
|
<p>Zig does not have them.</p>
|
|
<p>
|
|
Instead, you can use a nullable pointer. This secretly compiles down to a normal pointer,
|
|
since we know we can use 0 as the null value for the nullable type. But the compiler
|
|
can check your work and make sure you don't assign null to something that can't be null.
|
|
</p>
|
|
<p>
|
|
Typically the downside of not having null is that it makes the code more verbose to
|
|
write. But, let's compare some equivalent C code and Zig code.
|
|
</p>
|
|
<p>
|
|
Task: call malloc, if the result is null, return null.
|
|
</p>
|
|
<p>C code</p>
|
|
<pre><code class="cpp">// malloc prototype included for reference
|
|
void *malloc(size_t size);
|
|
|
|
struct Foo *do_a_thing(void) {
|
|
char *ptr = malloc(1234);
|
|
if (!ptr) return NULL;
|
|
// ...
|
|
}</code></pre>
|
|
<p>Zig code</p>
|
|
{#code_begin|syntax#}
|
|
// malloc prototype included for reference
|
|
extern fn malloc(size: size_t) ?&u8;
|
|
|
|
fn doAThing() ?&Foo {
|
|
const ptr = malloc(1234) ?? return null;
|
|
// ...
|
|
}
|
|
{#code_end#}
|
|
<p>
|
|
Here, Zig is at least as convenient, if not more, than C. And, the type of "ptr"
|
|
is <code>&u8</code> <em>not</em> <code>?&u8</code>. The <code>??</code> operator
|
|
unwrapped the nullable type and therefore <code>ptr</code> is guaranteed to be non-null everywhere
|
|
it is used in the function.
|
|
</p>
|
|
<p>
|
|
The other form of checking against NULL you might see looks like this:
|
|
</p>
|
|
<pre><code class="cpp">void do_a_thing(struct Foo *foo) {
|
|
// do some stuff
|
|
|
|
if (foo) {
|
|
do_something_with_foo(foo);
|
|
}
|
|
|
|
// do some stuff
|
|
}</code></pre>
|
|
<p>
|
|
In Zig you can accomplish the same thing:
|
|
</p>
|
|
{#code_begin|syntax#}
|
|
fn doAThing(nullable_foo: ?&Foo) void {
|
|
// do some stuff
|
|
|
|
if (nullable_foo) |foo| {
|
|
doSomethingWithFoo(foo);
|
|
}
|
|
|
|
// do some stuff
|
|
}
|
|
{#code_end#}
|
|
<p>
|
|
Once again, the notable thing here is that inside the if block,
|
|
<code>foo</code> is no longer a nullable pointer, it is a pointer, which
|
|
cannot be null.
|
|
</p>
|
|
<p>
|
|
One benefit to this is that functions which take pointers as arguments can
|
|
be annotated with the "nonnull" attribute - <code>__attribute__((nonnull))</code> in
|
|
<a href="https://gcc.gnu.org/onlinedocs/gcc-4.0.0/gcc/Function-Attributes.html">GCC</a>.
|
|
The optimizer can sometimes make better decisions knowing that pointer arguments
|
|
cannot be null.
|
|
</p>
|
|
{#header_open|Nullable Type#}
|
|
<p>A nullable is created by putting <code>?</code> in front of a type. You can use compile-time
|
|
reflection to access the child type of a nullable:</p>
|
|
{#code_begin|test#}
|
|
const assert = @import("std").debug.assert;
|
|
|
|
test "nullable type" {
|
|
// Declare a nullable and implicitly cast from null:
|
|
var foo: ?i32 = null;
|
|
|
|
// Implicitly cast from child type of a nullable
|
|
foo = 1234;
|
|
|
|
// Use compile-time reflection to access the child type of the nullable:
|
|
comptime assert(@typeOf(foo).Child == i32);
|
|
}
|
|
{#code_end#}
|
|
{#header_close#}
|
|
{#header_close#}
|
|
{#header_open|Casting#}
|
|
<p>TODO: explain implicit vs explicit casting</p>
|
|
<p>TODO: resolve peer types builtin</p>
|
|
<p>TODO: truncate builtin</p>
|
|
<p>TODO: bitcast builtin</p>
|
|
<p>TODO: int to ptr builtin</p>
|
|
<p>TODO: ptr to int builtin</p>
|
|
<p>TODO: ptrcast builtin</p>
|
|
<p>TODO: explain number literals vs concrete types</p>
|
|
{#header_close#}
|
|
{#header_open|void#}
|
|
<p>TODO: assigning void has no codegen</p>
|
|
<p>TODO: hashmap with void becomes a set</p>
|
|
<p>TODO: difference between c_void and void</p>
|
|
<p>TODO: void is the default return value of functions</p>
|
|
<p>TODO: functions require assigning the return value</p>
|
|
{#header_close#}
|
|
{#header_open|this#}
|
|
<p>TODO: example of this referring to Self struct</p>
|
|
<p>TODO: example of this referring to recursion function</p>
|
|
<p>TODO: example of this referring to basic block for @setRuntimeSafety</p>
|
|
{#header_close#}
|
|
{#header_open|comptime#}
|
|
<p>
|
|
Zig places importance on the concept of whether an expression is known at compile-time.
|
|
There are a few different places this concept is used, and these building blocks are used
|
|
to keep the language small, readable, and powerful.
|
|
</p>
|
|
{#header_open|Introducing the Compile-Time Concept#}
|
|
{#header_open|Compile-Time Parameters#}
|
|
<p>
|
|
Compile-time parameters is how Zig implements generics. It is compile-time duck typing.
|
|
</p>
|
|
{#code_begin|syntax#}
|
|
fn max(comptime T: type, a: T, b: T) T {
|
|
return if (a > b) a else b;
|
|
}
|
|
fn gimmeTheBiggerFloat(a: f32, b: f32) f32 {
|
|
return max(f32, a, b);
|
|
}
|
|
fn gimmeTheBiggerInteger(a: u64, b: u64) u64 {
|
|
return max(u64, a, b);
|
|
}
|
|
{#code_end#}
|
|
<p>
|
|
In Zig, types are first-class citizens. They can be assigned to variables, passed as parameters to functions,
|
|
and returned from functions. However, they can only be used in expressions which are known at <em>compile-time</em>,
|
|
which is why the parameter <code>T</code> in the above snippet must be marked with <code>comptime</code>.
|
|
</p>
|
|
<p>
|
|
A <code>comptime</code> parameter means that:
|
|
</p>
|
|
<ul>
|
|
<li>At the callsite, the value must be known at compile-time, or it is a compile error.</li>
|
|
<li>In the function definition, the value is known at compile-time.</li>
|
|
</ul>
|
|
<p>
|
|
</p>
|
|
<p>
|
|
For example, if we were to introduce another function to the above snippet:
|
|
</p>
|
|
{#code_begin|test_err|unable to evaluate constant expression#}
|
|
fn max(comptime T: type, a: T, b: T) T {
|
|
return if (a > b) a else b;
|
|
}
|
|
test "try to pass a runtime type" {
|
|
foo(false);
|
|
}
|
|
fn foo(condition: bool) void {
|
|
const result = max(
|
|
if (condition) f32 else u64,
|
|
1234,
|
|
5678);
|
|
}
|
|
{#code_end#}
|
|
<p>
|
|
This is an error because the programmer attempted to pass a value only known at run-time
|
|
to a function which expects a value known at compile-time.
|
|
</p>
|
|
<p>
|
|
Another way to get an error is if we pass a type that violates the type checker when the
|
|
function is analyzed. This is what it means to have <em>compile-time duck typing</em>.
|
|
</p>
|
|
<p>
|
|
For example:
|
|
</p>
|
|
{#code_begin|test_err|operator not allowed for type 'bool'#}
|
|
fn max(comptime T: type, a: T, b: T) T {
|
|
return if (a > b) a else b;
|
|
}
|
|
test "try to compare bools" {
|
|
_ = max(bool, true, false);
|
|
}
|
|
{#code_end#}
|
|
<p>
|
|
On the flip side, inside the function definition with the <code>comptime</code> parameter, the
|
|
value is known at compile-time. This means that we actually could make this work for the bool type
|
|
if we wanted to:
|
|
</p>
|
|
{#code_begin|test#}
|
|
fn max(comptime T: type, a: T, b: T) T {
|
|
if (T == bool) {
|
|
return a or b;
|
|
} else if (a > b) {
|
|
return a;
|
|
} else {
|
|
return b;
|
|
}
|
|
}
|
|
test "try to compare bools" {
|
|
@import("std").debug.assert(max(bool, false, true) == true);
|
|
}
|
|
{#code_end#}
|
|
<p>
|
|
This works because Zig implicitly inlines <code>if</code> expressions when the condition
|
|
is known at compile-time, and the compiler guarantees that it will skip analysis of
|
|
the branch not taken.
|
|
</p>
|
|
<p>
|
|
This means that the actual function generated for <code>max</code> in this situation looks like
|
|
this:
|
|
</p>
|
|
{#code_begin|syntax#}
|
|
fn max(a: bool, b: bool) bool {
|
|
return a or b;
|
|
}
|
|
{#code_end#}
|
|
<p>
|
|
All the code that dealt with compile-time known values is eliminated and we are left with only
|
|
the necessary run-time code to accomplish the task.
|
|
</p>
|
|
<p>
|
|
This works the same way for <code>switch</code> expressions - they are implicitly inlined
|
|
when the target expression is compile-time known.
|
|
</p>
|
|
{#header_close#}
|
|
{#header_open|Compile-Time Variables#}
|
|
<p>
|
|
In Zig, the programmer can label variables as <code>comptime</code>. This guarantees to the compiler
|
|
that every load and store of the variable is performed at compile-time. Any violation of this results in a
|
|
compile error.
|
|
</p>
|
|
<p>
|
|
This combined with the fact that we can <code>inline</code> loops allows us to write
|
|
a function which is partially evaluated at compile-time and partially at run-time.
|
|
</p>
|
|
<p>
|
|
For example:
|
|
</p>
|
|
{#code_begin|test|comptime_vars#}
|
|
const assert = @import("std").debug.assert;
|
|
|
|
const CmdFn = struct {
|
|
name: []const u8,
|
|
func: fn(i32) i32,
|
|
};
|
|
|
|
const cmd_fns = []CmdFn{
|
|
CmdFn {.name = "one", .func = one},
|
|
CmdFn {.name = "two", .func = two},
|
|
CmdFn {.name = "three", .func = three},
|
|
};
|
|
fn one(value: i32) i32 { return value + 1; }
|
|
fn two(value: i32) i32 { return value + 2; }
|
|
fn three(value: i32) i32 { return value + 3; }
|
|
|
|
fn performFn(comptime prefix_char: u8, start_value: i32) i32 {
|
|
var result: i32 = start_value;
|
|
comptime var i = 0;
|
|
inline while (i < cmd_fns.len) : (i += 1) {
|
|
if (cmd_fns[i].name[0] == prefix_char) {
|
|
result = cmd_fns[i].func(result);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
test "perform fn" {
|
|
assert(performFn('t', 1) == 6);
|
|
assert(performFn('o', 0) == 1);
|
|
assert(performFn('w', 99) == 99);
|
|
}
|
|
{#code_end#}
|
|
<p>
|
|
This example is a bit contrived, because the compile-time evaluation component is unnecessary;
|
|
this code would work fine if it was all done at run-time. But it does end up generating
|
|
different code. In this example, the function <code>performFn</code> is generated three different times,
|
|
for the different values of <code>prefix_char</code> provided:
|
|
</p>
|
|
{#code_begin|syntax#}
|
|
// From the line:
|
|
// assert(performFn('t', 1) == 6);
|
|
fn performFn(start_value: i32) i32 {
|
|
var result: i32 = start_value;
|
|
result = two(result);
|
|
result = three(result);
|
|
return result;
|
|
}
|
|
{#code_end#}
|
|
{#code_begin|syntax#}
|
|
// From the line:
|
|
// assert(performFn('o', 0) == 1);
|
|
fn performFn(start_value: i32) i32 {
|
|
var result: i32 = start_value;
|
|
result = one(result);
|
|
return result;
|
|
}
|
|
{#code_end#}
|
|
{#code_begin|syntax#}
|
|
// From the line:
|
|
// assert(performFn('w', 99) == 99);
|
|
fn performFn(start_value: i32) i32 {
|
|
var result: i32 = start_value;
|
|
return result;
|
|
}
|
|
{#code_end#}
|
|
<p>
|
|
Note that this happens even in a debug build; in a release build these generated functions still
|
|
pass through rigorous LLVM optimizations. The important thing to note, however, is not that this
|
|
is a way to write more optimized code, but that it is a way to make sure that what <em>should</em> happen
|
|
at compile-time, <em>does</em> happen at compile-time. This catches more errors and as demonstrated
|
|
later in this article, allows expressiveness that in other languages requires using macros,
|
|
generated code, or a preprocessor to accomplish.
|
|
</p>
|
|
{#header_close#}
|
|
{#header_open|Compile-Time Expressions#}
|
|
<p>
|
|
In Zig, it matters whether a given expression is known at compile-time or run-time. A programmer can
|
|
use a <code>comptime</code> expression to guarantee that the expression will be evaluated at compile-time.
|
|
If this cannot be accomplished, the compiler will emit an error. For example:
|
|
</p>
|
|
{#code_begin|test_err|unable to evaluate constant expression#}
|
|
extern fn exit() noreturn;
|
|
|
|
test "foo" {
|
|
comptime {
|
|
exit();
|
|
}
|
|
}
|
|
{#code_end#}
|
|
<p>
|
|
It doesn't make sense that a program could call <code>exit()</code> (or any other external function)
|
|
at compile-time, so this is a compile error. However, a <code>comptime</code> expression does much
|
|
more than sometimes cause a compile error.
|
|
</p>
|
|
<p>
|
|
Within a <code>comptime</code> expression:
|
|
</p>
|
|
<ul>
|
|
<li>All variables are <code>comptime</code> variables.</li>
|
|
<li>All <code>if</code>, <code>while</code>, <code>for</code>, and <code>switch</code>
|
|
expressions are evaluated at compile-time, or emit a compile error if this is not possible.</li>
|
|
<li>All function calls cause the compiler to interpret the function at compile-time, emitting a
|
|
compile error if the function tries to do something that has global run-time side effects.</li>
|
|
</ul>
|
|
<p>
|
|
This means that a programmer can create a function which is called both at compile-time and run-time, with
|
|
no modification to the function required.
|
|
</p>
|
|
<p>
|
|
Let's look at an example:
|
|
</p>
|
|
{#code_begin|test#}
|
|
const assert = @import("std").debug.assert;
|
|
|
|
fn fibonacci(index: u32) u32 {
|
|
if (index < 2) return index;
|
|
return fibonacci(index - 1) + fibonacci(index - 2);
|
|
}
|
|
|
|
test "fibonacci" {
|
|
// test fibonacci at run-time
|
|
assert(fibonacci(7) == 13);
|
|
|
|
// test fibonacci at compile-time
|
|
comptime {
|
|
assert(fibonacci(7) == 13);
|
|
}
|
|
}
|
|
{#code_end#}
|
|
<p>
|
|
Imagine if we had forgotten the base case of the recursive function and tried to run the tests:
|
|
</p>
|
|
{#code_begin|test_err|operation caused overflow#}
|
|
const assert = @import("std").debug.assert;
|
|
|
|
fn fibonacci(index: u32) u32 {
|
|
//if (index < 2) return index;
|
|
return fibonacci(index - 1) + fibonacci(index - 2);
|
|
}
|
|
|
|
test "fibonacci" {
|
|
comptime {
|
|
assert(fibonacci(7) == 13);
|
|
}
|
|
}
|
|
{#code_end#}
|
|
<p>
|
|
The compiler produces an error which is a stack trace from trying to evaluate the
|
|
function at compile-time.
|
|
</p>
|
|
<p>
|
|
Luckily, we used an unsigned integer, and so when we tried to subtract 1 from 0, it triggered
|
|
undefined behavior, which is always a compile error if the compiler knows it happened.
|
|
But what would have happened if we used a signed integer?
|
|
</p>
|
|
{#code_begin|test_err|evaluation exceeded 1000 backwards branches#}
|
|
const assert = @import("std").debug.assert;
|
|
|
|
fn fibonacci(index: i32) i32 {
|
|
//if (index < 2) return index;
|
|
return fibonacci(index - 1) + fibonacci(index - 2);
|
|
}
|
|
|
|
test "fibonacci" {
|
|
comptime {
|
|
assert(fibonacci(7) == 13);
|
|
}
|
|
}
|
|
{#code_end#}
|
|
<p>
|
|
The compiler noticed that evaluating this function at compile-time took a long time,
|
|
and thus emitted a compile error and gave up. If the programmer wants to increase
|
|
the budget for compile-time computation, they can use a built-in function called
|
|
{#link|@setEvalBranchQuota#} to change the default number 1000 to something else.
|
|
</p>
|
|
<p>
|
|
What if we fix the base case, but put the wrong value in the <code>assert</code> line?
|
|
</p>
|
|
{#code_begin|test_err|encountered @panic at compile-time#}
|
|
const assert = @import("std").debug.assert;
|
|
|
|
fn fibonacci(index: i32) i32 {
|
|
if (index < 2) return index;
|
|
return fibonacci(index - 1) + fibonacci(index - 2);
|
|
}
|
|
|
|
test "fibonacci" {
|
|
comptime {
|
|
assert(fibonacci(7) == 99999);
|
|
}
|
|
}
|
|
{#code_end#}
|
|
<p>
|
|
What happened is Zig started interpreting the <code>assert</code> function with the
|
|
parameter <code>ok</code> set to <code>false</code>. When the interpreter hit
|
|
<code>unreachable</code> it emitted a compile error, because reaching unreachable
|
|
code is undefined behavior, and undefined behavior causes a compile error if it is detected
|
|
at compile-time.
|
|
</p>
|
|
|
|
<p>
|
|
In the global scope (outside of any function), all expressions are implicitly
|
|
<code>comptime</code> expressions. This means that we can use functions to
|
|
initialize complex static data. For example:
|
|
</p>
|
|
{#code_begin|test#}
|
|
const first_25_primes = firstNPrimes(25);
|
|
const sum_of_first_25_primes = sum(first_25_primes);
|
|
|
|
fn firstNPrimes(comptime n: usize) [n]i32 {
|
|
var prime_list: [n]i32 = undefined;
|
|
var next_index: usize = 0;
|
|
var test_number: i32 = 2;
|
|
while (next_index < prime_list.len) : (test_number += 1) {
|
|
var test_prime_index: usize = 0;
|
|
var is_prime = true;
|
|
while (test_prime_index < next_index) : (test_prime_index += 1) {
|
|
if (test_number % prime_list[test_prime_index] == 0) {
|
|
is_prime = false;
|
|
break;
|
|
}
|
|
}
|
|
if (is_prime) {
|
|
prime_list[next_index] = test_number;
|
|
next_index += 1;
|
|
}
|
|
}
|
|
return prime_list;
|
|
}
|
|
|
|
fn sum(numbers: []const i32) i32 {
|
|
var result: i32 = 0;
|
|
for (numbers) |x| {
|
|
result += x;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
test "variable values" {
|
|
@import("std").debug.assert(sum_of_first_25_primes == 1060);
|
|
}
|
|
{#code_end#}
|
|
<p>
|
|
When we compile this program, Zig generates the constants
|
|
with the answer pre-computed. Here are the lines from the generated LLVM IR:
|
|
</p>
|
|
<pre><code class="llvm">@0 = internal unnamed_addr constant [25 x i32] [i32 2, i32 3, i32 5, i32 7, i32 11, i32 13, i32 17, i32 19, i32 23, i32 29, i32 31, i32 37, i32 41, i32 43, i32 47, i32 53, i32 59, i32 61, i32 67, i32 71, i32 73, i32 79, i32 83, i32 89, i32 97]
|
|
@1 = internal unnamed_addr constant i32 1060</code></pre>
|
|
<p>
|
|
Note that we did not have to do anything special with the syntax of these functions. For example,
|
|
we could call the <code>sum</code> function as is with a slice of numbers whose length and values were
|
|
only known at run-time.
|
|
</p>
|
|
{#header_close#}
|
|
{#header_close#}
|
|
{#header_open|Generic Data Structures#}
|
|
<p>
|
|
Zig uses these capabilities to implement generic data structures without introducing any
|
|
special-case syntax. If you followed along so far, you may already know how to create a
|
|
generic data structure.
|
|
</p>
|
|
<p>
|
|
Here is an example of a generic <code>List</code> data structure, that we will instantiate with
|
|
the type <code>i32</code>. In Zig we refer to the type as <code>List(i32)</code>.
|
|
</p>
|
|
{#code_begin|syntax#}
|
|
fn List(comptime T: type) type {
|
|
return struct {
|
|
items: []T,
|
|
len: usize,
|
|
};
|
|
}
|
|
{#code_end#}
|
|
<p>
|
|
That's it. It's a function that returns an anonymous <code>struct</code>. For the purposes of error messages
|
|
and debugging, Zig infers the name <code>"List(i32)"</code> from the function name and parameters invoked when creating
|
|
the anonymous struct.
|
|
</p>
|
|
<p>
|
|
To keep the language small and uniform, all aggregate types in Zig are anonymous. To give a type
|
|
a name, we assign it to a constant:
|
|
</p>
|
|
{#code_begin|syntax#}
|
|
const Node = struct {
|
|
next: &Node,
|
|
name: []u8,
|
|
};
|
|
{#code_end#}
|
|
<p>
|
|
This works because all top level declarations are order-independent, and as long as there isn't
|
|
an actual infinite regression, values can refer to themselves, directly or indirectly. In this case,
|
|
<code>Node</code> refers to itself as a pointer, which is not actually an infinite regression, so
|
|
it works fine.
|
|
</p>
|
|
{#header_close#}
|
|
{#header_open|Case Study: printf in Zig#}
|
|
<p>
|
|
Putting all of this together, let's see how <code>printf</code> works in Zig.
|
|
</p>
|
|
{#code_begin|exe|printf#}
|
|
const warn = @import("std").debug.warn;
|
|
|
|
const a_number: i32 = 1234;
|
|
const a_string = "foobar";
|
|
|
|
pub fn main() void {
|
|
warn("here is a string: '{}' here is a number: {}\n", a_string, a_number);
|
|
}
|
|
{#code_end#}
|
|
|
|
<p>
|
|
Let's crack open the implementation of this and see how it works:
|
|
</p>
|
|
|
|
{#code_begin|syntax#}
|
|
/// Calls print and then flushes the buffer.
|
|
pub fn printf(self: &OutStream, comptime format: []const u8, args: ...) error!void {
|
|
const State = enum {
|
|
Start,
|
|
OpenBrace,
|
|
CloseBrace,
|
|
};
|
|
|
|
comptime var start_index: usize = 0;
|
|
comptime var state = State.Start;
|
|
comptime var next_arg: usize = 0;
|
|
|
|
inline for (format) |c, i| {
|
|
switch (state) {
|
|
State.Start => switch (c) {
|
|
'{' => {
|
|
if (start_index < i) try self.write(format[start_index..i]);
|
|
state = State.OpenBrace;
|
|
},
|
|
'}' => {
|
|
if (start_index < i) try self.write(format[start_index..i]);
|
|
state = State.CloseBrace;
|
|
},
|
|
else => {},
|
|
},
|
|
State.OpenBrace => switch (c) {
|
|
'{' => {
|
|
state = State.Start;
|
|
start_index = i;
|
|
},
|
|
'}' => {
|
|
try self.printValue(args[next_arg]);
|
|
next_arg += 1;
|
|
state = State.Start;
|
|
start_index = i + 1;
|
|
},
|
|
else => @compileError("Unknown format character: " ++ c),
|
|
},
|
|
State.CloseBrace => switch (c) {
|
|
'}' => {
|
|
state = State.Start;
|
|
start_index = i;
|
|
},
|
|
else => @compileError("Single '}' encountered in format string"),
|
|
},
|
|
}
|
|
}
|
|
comptime {
|
|
if (args.len != next_arg) {
|
|
@compileError("Unused arguments");
|
|
}
|
|
if (state != State.Start) {
|
|
@compileError("Incomplete format string: " ++ format);
|
|
}
|
|
}
|
|
if (start_index < format.len) {
|
|
try self.write(format[start_index..format.len]);
|
|
}
|
|
try self.flush();
|
|
}
|
|
{#code_end#}
|
|
<p>
|
|
This is a proof of concept implementation; the actual function in the standard library has more
|
|
formatting capabilities.
|
|
</p>
|
|
<p>
|
|
Note that this is not hard-coded into the Zig compiler; this is userland code in the standard library.
|
|
</p>
|
|
<p>
|
|
When this function is analyzed from our example code above, Zig partially evaluates the function
|
|
and emits a function that actually looks like this:
|
|
</p>
|
|
{#code_begin|syntax#}
|
|
pub fn printf(self: &OutStream, arg0: i32, arg1: []const u8) !void {
|
|
try self.write("here is a string: '");
|
|
try self.printValue(arg0);
|
|
try self.write("' here is a number: ");
|
|
try self.printValue(arg1);
|
|
try self.write("\n");
|
|
try self.flush();
|
|
}
|
|
{#code_end#}
|
|
<p>
|
|
<code>printValue</code> is a function that takes a parameter of any type, and does different things depending
|
|
on the type:
|
|
</p>
|
|
{#code_begin|syntax#}
|
|
pub fn printValue(self: &OutStream, value: var) !void {
|
|
const T = @typeOf(value);
|
|
if (@isInteger(T)) {
|
|
return self.printInt(T, value);
|
|
} else if (@isFloat(T)) {
|
|
return self.printFloat(T, value);
|
|
} else if (@canImplicitCast([]const u8, value)) {
|
|
const casted_value = ([]const u8)(value);
|
|
return self.write(casted_value);
|
|
} else {
|
|
@compileError("Unable to print type '" ++ @typeName(T) ++ "'");
|
|
}
|
|
}
|
|
{#code_end#}
|
|
<p>
|
|
And now, what happens if we give too many arguments to <code>printf</code>?
|
|
</p>
|
|
{#code_begin|test_err|Unused arguments#}
|
|
const warn = @import("std").debug.warn;
|
|
|
|
const a_number: i32 = 1234;
|
|
const a_string = "foobar";
|
|
|
|
test "printf too many arguments" {
|
|
warn("here is a string: '{}' here is a number: {}\n",
|
|
a_string, a_number, a_number);
|
|
}
|
|
{#code_end#}
|
|
<p>
|
|
Zig gives programmers the tools needed to protect themselves against their own mistakes.
|
|
</p>
|
|
<p>
|
|
Zig doesn't care whether the format argument is a string literal,
|
|
only that it is a compile-time known value that is implicitly castable to a <code>[]const u8</code>:
|
|
</p>
|
|
{#code_begin|exe|printf#}
|
|
const warn = @import("std").debug.warn;
|
|
|
|
const a_number: i32 = 1234;
|
|
const a_string = "foobar";
|
|
const fmt = "here is a string: '{}' here is a number: {}\n";
|
|
|
|
pub fn main() void {
|
|
warn(fmt, a_string, a_number);
|
|
}
|
|
{#code_end#}
|
|
<p>
|
|
This works fine.
|
|
</p>
|
|
<p>
|
|
Zig does not special case string formatting in the compiler and instead exposes enough power to accomplish this
|
|
task in userland. It does so without introducing another language on top of Zig, such as
|
|
a macro language or a preprocessor language. It's Zig all the way down.
|
|
</p>
|
|
<p>TODO: suggestion to not use inline unless necessary</p>
|
|
{#header_close#}
|
|
{#header_close#}
|
|
{#header_open|inline#}
|
|
<p>TODO: inline while</p>
|
|
<p>TODO: inline for</p>
|
|
<p>TODO: suggestion to not use inline unless necessary</p>
|
|
{#header_close#}
|
|
{#header_open|Assembly#}
|
|
<p>TODO: example of inline assembly</p>
|
|
<p>TODO: example of module level assembly</p>
|
|
<p>TODO: example of using inline assembly return value</p>
|
|
<p>TODO: example of using inline assembly assigning values to variables</p>
|
|
{#header_close#}
|
|
{#header_open|Atomics#}
|
|
<p>TODO: @fence()</p>
|
|
<p>TODO: @atomic rmw</p>
|
|
<p>TODO: builtin atomic memory ordering enum</p>
|
|
{#header_close#}
|
|
{#header_open|Builtin Functions#}
|
|
<p>
|
|
Builtin functions are provided by the compiler and are prefixed with <code>@</code>.
|
|
The <code>comptime</code> keyword on a parameter means that the parameter must be known
|
|
at compile time.
|
|
</p>
|
|
{#header_open|@addWithOverflow#}
|
|
<pre><code class="zig">@addWithOverflow(comptime T: type, a: T, b: T, result: &T) -> bool</code></pre>
|
|
<p>
|
|
Performs <code>*result = a + b</code>. If overflow or underflow occurs,
|
|
stores the overflowed bits in <code>result</code> and returns <code>true</code>.
|
|
If no overflow or underflow occurs, returns <code>false</code>.
|
|
</p>
|
|
{#header_close#}
|
|
{#header_open|@ArgType#}
|
|
<p>TODO</p>
|
|
{#header_close#}
|
|
{#header_open|@atomicRmw#}
|
|
<pre><code class="zig">@atomicRmw(comptime T: type, ptr: &T, comptime op: builtin.AtomicRmwOp, operand: T, comptime ordering: builtin.AtomicOrder) -> T</code></pre>
|
|
<p>
|
|
This builtin function atomically modifies memory and then returns the previous value.
|
|
</p>
|
|
<p>
|
|
<code>T</code> must be a pointer type, a <code>bool</code>,
|
|
or an integer whose bit count meets these requirements:
|
|
</p>
|
|
<ul>
|
|
<li>At least 8</li>
|
|
<li>At most the same as usize</li>
|
|
<li>Power of 2</li>
|
|
</ul>
|
|
<p>
|
|
TODO right now bool is not accepted. Also I think we could make non powers of 2 work fine, maybe
|
|
we can remove this restriction
|
|
</p>
|
|
{#header_close#}
|
|
{#header_open|@bitCast#}
|
|
<pre><code class="zig">@bitCast(comptime DestType: type, value: var) -> DestType</code></pre>
|
|
<p>
|
|
Converts a value of one type to another type.
|
|
</p>
|
|
<p>
|
|
Asserts that <code>@sizeOf(@typeOf(value)) == @sizeOf(DestType)</code>.
|
|
</p>
|
|
<p>
|
|
Asserts that <code>@typeId(DestType) != @import("builtin").TypeId.Pointer</code>. Use <code>@ptrCast</code> or <code>@intToPtr</code> if you need this.
|
|
</p>
|
|
<p>
|
|
Can be used for these things for example:
|
|
</p>
|
|
<ul>
|
|
<li>Convert <code>f32</code> to <code>u32</code> bits</li>
|
|
<li>Convert <code>i32</code> to <code>u32</code> preserving twos complement</li>
|
|
</ul>
|
|
<p>
|
|
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.
|
|
</p>
|
|
{#header_close#}
|
|
{#header_open|@breakpoint#}
|
|
<pre><code class="zig">@breakpoint()</code></pre>
|
|
<p>
|
|
This function inserts a platform-specific debug trap instruction which causes
|
|
debuggers to break there.
|
|
</p>
|
|
<p>
|
|
This function is only valid within function scope.
|
|
</p>
|
|
|
|
{#header_close#}
|
|
{#header_open|@alignCast#}
|
|
<pre><code class="zig">@alignCast(comptime alignment: u29, ptr: var) -> var</code></pre>
|
|
<p>
|
|
<code>ptr</code> can be <code>&T</code>, <code>fn()</code>, <code>?&T</code>,
|
|
<code>?fn()</code>, or <code>[]T</code>. It returns the same type as <code>ptr</code>
|
|
except with the alignment adjusted to the new value.
|
|
</p>
|
|
<p>A {#link|pointer alignment safety check|Incorrect Pointer Alignment#} is added
|
|
to the generated code to make sure the pointer is aligned as promised.</p>
|
|
|
|
{#header_close#}
|
|
{#header_open|@alignOf#}
|
|
<pre><code class="zig">@alignOf(comptime T: type) -> (number literal)</code></pre>
|
|
<p>
|
|
This function returns the number of bytes that this type should be aligned to
|
|
for the current target to match the C ABI. When the child type of a pointer has
|
|
this alignment, the alignment can be omitted from the type.
|
|
</p>
|
|
<pre><code class="zig">const assert = @import("std").debug.assert;
|
|
comptime {
|
|
assert(&u32 == &align(@alignOf(u32)) u32);
|
|
}</code></pre>
|
|
<p>
|
|
The result is a target-specific compile time constant. It is guaranteed to be
|
|
less than or equal to {#link|@sizeOf(T)|@sizeOf#}.
|
|
</p>
|
|
{#see_also|Alignment#}
|
|
{#header_close#}
|
|
{#header_open|@cDefine#}
|
|
<pre><code class="zig">@cDefine(comptime name: []u8, value)</code></pre>
|
|
<p>
|
|
This function can only occur inside <code>@cImport</code>.
|
|
</p>
|
|
<p>
|
|
This appends <code>#define $name $value</code> to the <code>@cImport</code>
|
|
temporary buffer.
|
|
</p>
|
|
<p>
|
|
To define without a value, like this:
|
|
</p>
|
|
<pre><code class="c">#define _GNU_SOURCE</code></pre>
|
|
<p>
|
|
Use the void value, like this:
|
|
</p>
|
|
<pre><code class="zig">@cDefine("_GNU_SOURCE", {})</code></pre>
|
|
{#see_also|Import from C Header File|@cInclude|@cImport|@cUndef|void#}
|
|
{#header_close#}
|
|
{#header_open|@cImport#}
|
|
<pre><code class="zig">@cImport(expression) -> (namespace)</code></pre>
|
|
<p>
|
|
This function parses C code and imports the functions, types, variables, and
|
|
compatible macro definitions into the result namespace.
|
|
</p>
|
|
<p>
|
|
<code>expression</code> is interpreted at compile time. The builtin functions
|
|
<code>@cInclude</code>, <code>@cDefine</code>, and <code>@cUndef</code> work
|
|
within this expression, appending to a temporary buffer which is then parsed as C code.
|
|
</p>
|
|
<p>
|
|
Usually you should only have one <code>@cImport</code> in your entire application, because it saves the compiler
|
|
from invoking clang multiple times, and prevents inline functions from being duplicated.
|
|
</p>
|
|
<p>
|
|
Reasons for having multiple <code>@cImport</code> expressions would be:
|
|
</p>
|
|
<ul>
|
|
<li>To avoid a symbol collision, for example if foo.h and bar.h both <code>#define CONNECTION_COUNT</code></li>
|
|
<li>To analyze the C code with different preprocessor defines</li>
|
|
</ul>
|
|
{#see_also|Import from C Header File|@cInclude|@cDefine|@cUndef#}
|
|
{#header_close#}
|
|
{#header_open|@cInclude#}
|
|
<pre><code class="zig">@cInclude(comptime path: []u8)</code></pre>
|
|
<p>
|
|
This function can only occur inside <code>@cImport</code>.
|
|
</p>
|
|
<p>
|
|
This appends <code>#include <$path>\n</code> to the <code>c_import</code>
|
|
temporary buffer.
|
|
</p>
|
|
{#see_also|Import from C Header File|@cImport|@cDefine|@cUndef#}
|
|
{#header_close#}
|
|
{#header_open|@cUndef#}
|
|
<pre><code class="zig">@cUndef(comptime name: []u8)</code></pre>
|
|
<p>
|
|
This function can only occur inside <code>@cImport</code>.
|
|
</p>
|
|
<p>
|
|
This appends <code>#undef $name</code> to the <code>@cImport</code>
|
|
temporary buffer.
|
|
</p>
|
|
{#see_also|Import from C Header File|@cImport|@cDefine|@cInclude#}
|
|
{#header_close#}
|
|
{#header_open|@canImplicitCast#}
|
|
<pre><code class="zig">@canImplicitCast(comptime T: type, value) -> bool</code></pre>
|
|
<p>
|
|
Returns whether a value can be implicitly casted to a given type.
|
|
</p>
|
|
{#header_close#}
|
|
{#header_open|@clz#}
|
|
<pre><code class="zig">@clz(x: T) -> U</code></pre>
|
|
<p>
|
|
This function counts the number of leading zeroes in <code>x</code> which is an integer
|
|
type <code>T</code>.
|
|
</p>
|
|
<p>
|
|
The return type <code>U</code> is an unsigned integer with the minimum number
|
|
of bits that can represent the value <code>T.bit_count</code>.
|
|
</p>
|
|
<p>
|
|
If <code>x</code> is zero, <code>@clz</code> returns <code>T.bit_count</code>.
|
|
</p>
|
|
|
|
{#header_close#}
|
|
{#header_open|@cmpxchg#}
|
|
<pre><code class="zig">@cmpxchg(ptr: &T, cmp: T, new: T, success_order: AtomicOrder, fail_order: AtomicOrder) -> bool</code></pre>
|
|
<p>
|
|
This function performs an atomic compare exchange operation.
|
|
</p>
|
|
<p>
|
|
<code>AtomicOrder</code> can be found with <code>@import("builtin").AtomicOrder</code>.
|
|
</p>
|
|
<p><code>@typeOf(ptr).alignment</code> must be <code>>= @sizeOf(T).</code></p>
|
|
{#see_also|Compile Variables#}
|
|
{#header_close#}
|
|
{#header_open|@compileError#}
|
|
<pre><code class="zig">@compileError(comptime msg: []u8)</code></pre>
|
|
<p>
|
|
This function, when semantically analyzed, causes a compile error with the
|
|
message <code>msg</code>.
|
|
</p>
|
|
<p>
|
|
There are several ways that code avoids being semantically checked, such as
|
|
using <code>if</code> or <code>switch</code> with compile time constants,
|
|
and <code>comptime</code> functions.
|
|
</p>
|
|
{#header_close#}
|
|
{#header_open|@compileLog#}
|
|
<pre><code class="zig">@compileLog(args: ...)</code></pre>
|
|
<p>
|
|
This function prints the arguments passed to it at compile-time.
|
|
</p>
|
|
<p>
|
|
To prevent accidentally leaving compile log statements in a codebase,
|
|
a compilation error is added to the build, pointing to the compile
|
|
log statement. This error prevents code from being generated, but
|
|
does not otherwise interfere with analysis.
|
|
</p>
|
|
<p>
|
|
This function can be used to do "printf debugging" on
|
|
compile-time executing code.
|
|
</p>
|
|
{#code_begin|test_err|found compile log statement#}
|
|
const warn = @import("std").debug.warn;
|
|
|
|
const num1 = blk: {
|
|
var val1: i32 = 99;
|
|
@compileLog("comptime val1 = ", val1);
|
|
val1 = val1 + 1;
|
|
break :blk val1;
|
|
};
|
|
|
|
test "main" {
|
|
@compileLog("comptime in main");
|
|
|
|
warn("Runtime in main, num1 = {}.\n", num1);
|
|
}
|
|
{#code_end#}
|
|
</p>
|
|
<p>
|
|
will ouput:
|
|
</p>
|
|
<p>
|
|
If all <code>@compileLog</code> calls are removed or
|
|
not encountered by analysis, the
|
|
program compiles successfully and the generated executable prints:
|
|
</p>
|
|
{#code_begin|test#}
|
|
const warn = @import("std").debug.warn;
|
|
|
|
const num1 = blk: {
|
|
var val1: i32 = 99;
|
|
val1 = val1 + 1;
|
|
break :blk val1;
|
|
};
|
|
|
|
test "main" {
|
|
warn("Runtime in main, num1 = {}.\n", num1);
|
|
}
|
|
{#code_end#}
|
|
{#header_close#}
|
|
{#header_open|@ctz#}
|
|
<pre><code class="zig">@ctz(x: T) -> U</code></pre>
|
|
<p>
|
|
This function counts the number of trailing zeroes in <code>x</code> which is an integer
|
|
type <code>T</code>.
|
|
</p>
|
|
<p>
|
|
The return type <code>U</code> is an unsigned integer with the minimum number
|
|
of bits that can represent the value <code>T.bit_count</code>.
|
|
</p>
|
|
<p>
|
|
If <code>x</code> is zero, <code>@ctz</code> returns <code>T.bit_count</code>.
|
|
</p>
|
|
{#header_close#}
|
|
{#header_open|@divExact#}
|
|
<pre><code class="zig">@divExact(numerator: T, denominator: T) -> T</code></pre>
|
|
<p>
|
|
Exact division. Caller guarantees <code>denominator != 0</code> and
|
|
<code>@divTrunc(numerator, denominator) * denominator == numerator</code>.
|
|
</p>
|
|
<ul>
|
|
<li><code>@divExact(6, 3) == 2</code></li>
|
|
<li><code>@divExact(a, b) * b == a</code></li>
|
|
</ul>
|
|
<p>For a function that returns a possible error code, use <code>@import("std").math.divExact</code>.</p>
|
|
{#see_also|@divTrunc|@divFloor#}
|
|
{#header_close#}
|
|
{#header_open|@divFloor#}
|
|
<pre><code class="zig">@divFloor(numerator: T, denominator: T) -> T</code></pre>
|
|
<p>
|
|
Floored division. Rounds toward negative infinity. For unsigned integers it is
|
|
the same as <code>numerator / denominator</code>. Caller guarantees <code>denominator != 0</code> and
|
|
<code>!(@typeId(T) == builtin.TypeId.Int and T.is_signed and numerator == @minValue(T) and denominator == -1)</code>.
|
|
</p>
|
|
<ul>
|
|
<li><code>@divFloor(-5, 3) == -2</code></li>
|
|
<li><code>@divFloor(a, b) + @mod(a, b) == a</code></li>
|
|
</ul>
|
|
<p>For a function that returns a possible error code, use <code>@import("std").math.divFloor</code>.</p>
|
|
{#see_also|@divTrunc|@divExact#}
|
|
{#header_close#}
|
|
{#header_open|@divTrunc#}
|
|
<pre><code class="zig">@divTrunc(numerator: T, denominator: T) -> T</code></pre>
|
|
<p>
|
|
Truncated division. Rounds toward zero. For unsigned integers it is
|
|
the same as <code>numerator / denominator</code>. Caller guarantees <code>denominator != 0</code> and
|
|
<code>!(@typeId(T) == builtin.TypeId.Int and T.is_signed and numerator == @minValue(T) and denominator == -1)</code>.
|
|
</p>
|
|
<ul>
|
|
<li><code>@divTrunc(-5, 3) == -1</code></li>
|
|
<li><code>@divTrunc(a, b) + @rem(a, b) == a</code></li>
|
|
</ul>
|
|
<p>For a function that returns a possible error code, use <code>@import("std").math.divTrunc</code>.</p>
|
|
{#see_also|@divFloor|@divExact#}
|
|
{#header_close#}
|
|
{#header_open|@embedFile#}
|
|
<pre><code class="zig">@embedFile(comptime path: []const u8) -> [X]u8</code></pre>
|
|
<p>
|
|
This function returns a compile time constant fixed-size array with length
|
|
equal to the byte count of the file given by <code>path</code>. The contents of the array
|
|
are the contents of the file.
|
|
</p>
|
|
<p>
|
|
<code>path</code> is absolute or relative to the current file, just like <code>@import</code>.
|
|
</p>
|
|
{#see_also|@import#}
|
|
{#header_close#}
|
|
{#header_open|@export#}
|
|
<pre><code class="zig">@export(comptime name: []const u8, target: var, linkage: builtin.GlobalLinkage) -> []const u8</code></pre>
|
|
<p>
|
|
Creates a symbol in the output object file.
|
|
</p>
|
|
{#header_close#}
|
|
{#header_open|@tagName#}
|
|
<pre><code class="zig">@tagName(value: var) -> []const u8</code></pre>
|
|
<p>
|
|
Converts an enum value or union value to a slice of bytes representing the name.
|
|
</p>
|
|
{#header_close#}
|
|
{#header_open|@TagType#}
|
|
<pre><code class="zig">@TagType(T: type) -> type</code></pre>
|
|
<p>
|
|
For an enum, returns the integer type that is used to store the enumeration value.
|
|
</p>
|
|
<p>
|
|
For a union, returns the enum type that is used to store the tag value.
|
|
</p>
|
|
{#header_close#}
|
|
{#header_open|@errorName#}
|
|
<pre><code class="zig">@errorName(err: error) -> []u8</code></pre>
|
|
<p>
|
|
This function returns the string representation of an error. If an error
|
|
declaration is:
|
|
</p>
|
|
<pre><code class="zig">error OutOfMem</code></pre>
|
|
<p>
|
|
Then the string representation is <code>"OutOfMem"</code>.
|
|
</p>
|
|
<p>
|
|
If there are no calls to <code>@errorName</code> in an entire application,
|
|
or all calls have a compile-time known value for <code>err</code>, then no
|
|
error name table will be generated.
|
|
</p>
|
|
{#header_close#}
|
|
{#header_open|@errorReturnTrace#}
|
|
<pre><code class="zig">@errorReturnTrace() -> ?&builtin.StackTrace</code></pre>
|
|
<p>
|
|
If the binary is built with error return tracing, and this function is invoked in a
|
|
function that calls a function with an error or error union return type, returns a
|
|
stack trace object. Otherwise returns `null`.
|
|
</p>
|
|
{#header_close#}
|
|
{#header_open|@fence#}
|
|
<pre><code class="zig">@fence(order: AtomicOrder)</code></pre>
|
|
<p>
|
|
The <code>fence</code> function is used to introduce happens-before edges between operations.
|
|
</p>
|
|
<p>
|
|
<code>AtomicOrder</code> can be found with <code>@import("builtin").AtomicOrder</code>.
|
|
</p>
|
|
{#see_also|Compile Variables#}
|
|
{#header_close#}
|
|
{#header_open|@fieldParentPtr#}
|
|
<pre><code class="zig">@fieldParentPtr(comptime ParentType: type, comptime field_name: []const u8,
|
|
field_ptr: &T) -> &ParentType</code></pre>
|
|
<p>
|
|
Given a pointer to a field, returns the base pointer of a struct.
|
|
</p>
|
|
{#header_close#}
|
|
{#header_open|@frameAddress#}
|
|
<pre><code class="zig">@frameAddress()</code></pre>
|
|
<p>
|
|
This function returns the base pointer of the current stack frame.
|
|
</p>
|
|
<p>
|
|
The implications of this are target specific and not consistent across all
|
|
platforms. The frame address may not be available in release mode due to
|
|
aggressive optimizations.
|
|
</p>
|
|
<p>
|
|
This function is only valid within function scope.
|
|
</p>
|
|
{#header_close#}
|
|
{#header_open|@import#}
|
|
<pre><code class="zig">@import(comptime path: []u8) -> (namespace)</code></pre>
|
|
<p>
|
|
This function finds a zig file corresponding to <code>path</code> and imports all the
|
|
public top level declarations into the resulting namespace.
|
|
</p>
|
|
<p>
|
|
<code>path</code> can be a relative or absolute path, or it can be the name of a package.
|
|
If it is a relative path, it is relative to the file that contains the <code>@import</code>
|
|
function call.
|
|
</p>
|
|
<p>
|
|
The following packages are always available:
|
|
</p>
|
|
<ul>
|
|
<li><code>@import("std")</code> - Zig Standard Library</li>
|
|
<li><code>@import("builtin")</code> - Compiler-provided types and variables</li>
|
|
</ul>
|
|
{#see_also|Compile Variables|@embedFile#}
|
|
{#header_close#}
|
|
{#header_open|@inlineCall#}
|
|
<pre><code class="zig">@inlineCall(function: X, args: ...) -> Y</code></pre>
|
|
<p>
|
|
This calls a function, in the same way that invoking an expression with parentheses does:
|
|
</p>
|
|
{#code_begin|test#}
|
|
const assert = @import("std").debug.assert;
|
|
|
|
test "inline function call" {
|
|
assert(@inlineCall(add, 3, 9) == 12);
|
|
}
|
|
|
|
fn add(a: i32, b: i32) i32 { return a + b; }
|
|
{#code_end#}
|
|
<p>
|
|
Unlike a normal function call, however, <code>@inlineCall</code> guarantees that the call
|
|
will be inlined. If the call cannot be inlined, a compile error is emitted.
|
|
</p>
|
|
{#see_also|@noInlineCall#}
|
|
{#header_close#}
|
|
{#header_open|@intToPtr#}
|
|
<pre><code class="zig">@intToPtr(comptime DestType: type, int: usize) -> DestType</code></pre>
|
|
<p>
|
|
Converts an integer to a pointer. To convert the other way, use {#link|@ptrToInt#}.
|
|
</p>
|
|
{#header_close#}
|
|
{#header_open|@IntType#}
|
|
<pre><code class="zig">@IntType(comptime is_signed: bool, comptime bit_count: u8) -> type</code></pre>
|
|
<p>
|
|
This function returns an integer type with the given signness and bit count.
|
|
</p>
|
|
{#header_close#}
|
|
{#header_open|@maxValue#}
|
|
<pre><code class="zig">@maxValue(comptime T: type) -> (number literal)</code></pre>
|
|
<p>
|
|
This function returns the maximum value of the integer type <code>T</code>.
|
|
</p>
|
|
<p>
|
|
The result is a compile time constant.
|
|
</p>
|
|
{#header_close#}
|
|
{#header_open|@memberCount#}
|
|
<pre><code class="zig">@memberCount(comptime T: type) -> (number literal)</code></pre>
|
|
<p>
|
|
This function returns the number of members in a struct, enum, or union type.
|
|
</p>
|
|
<p>
|
|
The result is a compile time constant.
|
|
</p>
|
|
<p>
|
|
It does not include functions, variables, or constants.
|
|
</p>
|
|
{#header_close#}
|
|
{#header_open|@memberName#}
|
|
<pre><code class="zig">@memberName(comptime T: type, comptime index: usize) -> [N]u8</code></pre>
|
|
<p>Returns the field name of a struct, union, or enum.</p>
|
|
<p>
|
|
The result is a compile time constant.
|
|
</p>
|
|
<p>
|
|
It does not include functions, variables, or constants.
|
|
</p>
|
|
{#header_close#}
|
|
{#header_open|@memberType#}
|
|
<pre><code class="zig">@memberType(comptime T: type, comptime index: usize) -> type</code></pre>
|
|
<p>Returns the field type of a struct or union.</p>
|
|
{#header_close#}
|
|
{#header_open|@memcpy#}
|
|
<pre><code class="zig">@memcpy(noalias dest: &u8, noalias source: &const u8, byte_count: usize)</code></pre>
|
|
<p>
|
|
This function copies bytes from one region of memory to another. <code>dest</code> and
|
|
<code>source</code> are both pointers and must not overlap.
|
|
</p>
|
|
<p>
|
|
This function is a low level intrinsic with no safety mechanisms. Most code
|
|
should not use this function, instead using something like this:
|
|
</p>
|
|
<pre><code class="zig">for (source[0...byte_count]) |b, i| dest[i] = b;</code></pre>
|
|
<p>
|
|
The optimizer is intelligent enough to turn the above snippet into a memcpy.
|
|
</p>
|
|
<p>There is also a standard library function for this:</p>
|
|
<pre><code class="zig">const mem = @import("std").mem;
|
|
mem.copy(u8, dest[0...byte_count], source[0...byte_count]);</code></pre>
|
|
{#header_close#}
|
|
{#header_open|@memset#}
|
|
<pre><code class="zig">@memset(dest: &u8, c: u8, byte_count: usize)</code></pre>
|
|
<p>
|
|
This function sets a region of memory to <code>c</code>. <code>dest</code> is a pointer.
|
|
</p>
|
|
<p>
|
|
This function is a low level intrinsic with no safety mechanisms. Most
|
|
code should not use this function, instead using something like this:
|
|
</p>
|
|
<pre><code class="zig">for (dest[0...byte_count]) |*b| *b = c;</code></pre>
|
|
<p>
|
|
The optimizer is intelligent enough to turn the above snippet into a memset.
|
|
</p>
|
|
<p>There is also a standard library function for this:</p>
|
|
<pre><code>const mem = @import("std").mem;
|
|
mem.set(u8, dest, c);</code></pre>
|
|
{#header_close#}
|
|
{#header_open|@minValue#}
|
|
<pre><code class="zig">@minValue(comptime T: type) -> (number literal)</code></pre>
|
|
<p>
|
|
This function returns the minimum value of the integer type T.
|
|
</p>
|
|
<p>
|
|
The result is a compile time constant.
|
|
</p>
|
|
{#header_close#}
|
|
{#header_open|@mod#}
|
|
<pre><code class="zig">@mod(numerator: T, denominator: T) -> T</code></pre>
|
|
<p>
|
|
Modulus division. For unsigned integers this is the same as
|
|
<code>numerator % denominator</code>. Caller guarantees <code>denominator > 0</code>.
|
|
</p>
|
|
<ul>
|
|
<li><code>@mod(-5, 3) == 1</code></li>
|
|
<li><code>@divFloor(a, b) + @mod(a, b) == a</code></li>
|
|
</ul>
|
|
<p>For a function that returns an error code, see <code>@import("std").math.mod</code>.</p>
|
|
{#see_also|@rem#}
|
|
{#header_close#}
|
|
{#header_open|@mulWithOverflow#}
|
|
<pre><code class="zig">@mulWithOverflow(comptime T: type, a: T, b: T, result: &T) -> bool</code></pre>
|
|
<p>
|
|
Performs <code>*result = a * b</code>. If overflow or underflow occurs,
|
|
stores the overflowed bits in <code>result</code> and returns <code>true</code>.
|
|
If no overflow or underflow occurs, returns <code>false</code>.
|
|
</p>
|
|
{#header_close#}
|
|
{#header_open|@noInlineCall#}
|
|
<pre><code class="zig">@noInlineCall(function: var, args: ...) -> var</code></pre>
|
|
<p>
|
|
This calls a function, in the same way that invoking an expression with parentheses does:
|
|
</p>
|
|
<pre><code class="zig">const assert = @import("std").debug.assert;
|
|
test "noinline function call" {
|
|
assert(@noInlineCall(add, 3, 9) == 12);
|
|
}
|
|
|
|
fn add(a: i32, b: i32) -> i32 { a + b }</code></pre>
|
|
<p>
|
|
Unlike a normal function call, however, <code>@noInlineCall</code> guarantees that the call
|
|
will not be inlined. If the call must be inlined, a compile error is emitted.
|
|
</p>
|
|
{#see_also|@inlineCall#}
|
|
{#header_close#}
|
|
{#header_open|@offsetOf#}
|
|
<pre><code class="zig">@offsetOf(comptime T: type, comptime field_name: [] const u8) -> (number literal)</code></pre>
|
|
<p>
|
|
This function returns the byte offset of a field relative to its containing struct.
|
|
</p>
|
|
{#header_close#}
|
|
{#header_open|@OpaqueType#}
|
|
<pre><code class="zig">@OpaqueType() -> type</code></pre>
|
|
<p>
|
|
Creates a new type with an unknown size and alignment.
|
|
</p>
|
|
<p>
|
|
This is typically used for type safety when interacting with C code that does not expose struct details.
|
|
Example:
|
|
</p>
|
|
{#code_begin|test_err|expected type '&Derp', found '&Wat'#}
|
|
const Derp = @OpaqueType();
|
|
const Wat = @OpaqueType();
|
|
|
|
extern fn bar(d: &Derp) void;
|
|
export fn foo(w: &Wat) void {
|
|
bar(w);
|
|
}
|
|
|
|
test "call foo" {
|
|
foo(undefined);
|
|
}
|
|
{#code_end#}
|
|
{#header_close#}
|
|
{#header_open|@panic#}
|
|
<pre><code class="zig">@panic(message: []const u8) -> noreturn</code></pre>
|
|
<p>
|
|
Invokes the panic handler function. By default the panic handler function
|
|
calls the public <code>panic</code> function exposed in the root source file, or
|
|
if there is not one specified, invokes the one provided in <code>std/special/panic.zig</code>.
|
|
</p>
|
|
<p>Generally it is better to use <code>@import("std").debug.panic</code>.
|
|
However, <code>@panic</code> can be useful for 2 scenarios:
|
|
</p>
|
|
<ul>
|
|
<li>From library code, calling the programmer's panic function if they exposed one in the root source file.</li>
|
|
<li>When mixing C and Zig code, calling the canonical panic implementation across multiple .o files.</li>
|
|
</ul>
|
|
{#see_also|Root Source File#}
|
|
{#header_close#}
|
|
{#header_open|@ptrCast#}
|
|
<pre><code class="zig">@ptrCast(comptime DestType: type, value: var) -> DestType</code></pre>
|
|
<p>
|
|
Converts a pointer of one type to a pointer of another type.
|
|
</p>
|
|
{#header_close#}
|
|
{#header_open|@ptrToInt#}
|
|
<pre><code class="zig">@ptrToInt(value: var) -> usize</code></pre>
|
|
<p>
|
|
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:
|
|
</p>
|
|
<ul>
|
|
<li><code>&T</code></li>
|
|
<li><code>?&T</code></li>
|
|
<li><code>fn()</code></li>
|
|
<li><code>?fn()</code></li>
|
|
</ul>
|
|
<p>To convert the other way, use {#link|@intToPtr#}</p>
|
|
|
|
{#header_close#}
|
|
{#header_open|@rem#}
|
|
<pre><code class="zig">@rem(numerator: T, denominator: T) -> T</code></pre>
|
|
<p>
|
|
Remainder division. For unsigned integers this is the same as
|
|
<code>numerator % denominator</code>. Caller guarantees <code>denominator > 0</code>.
|
|
</p>
|
|
<ul>
|
|
<li><code>@rem(-5, 3) == -2</code></li>
|
|
<li><code>@divTrunc(a, b) + @rem(a, b) == a</code></li>
|
|
</ul>
|
|
<p>For a function that returns an error code, see <code>@import("std").math.rem</code>.</p>
|
|
{#see_also|@mod#}
|
|
{#header_close#}
|
|
{#header_open|@returnAddress#}
|
|
<pre><code class="zig">@returnAddress()</code></pre>
|
|
<p>
|
|
This function returns a pointer to the return address of the current stack
|
|
frame.
|
|
</p>
|
|
<p>
|
|
The implications of this are target specific and not consistent across
|
|
all platforms.
|
|
</p>
|
|
<p>
|
|
This function is only valid within function scope.
|
|
</p>
|
|
{#header_close#}
|
|
{#header_open|@setAlignStack#}
|
|
<pre><code class="zig">@setAlignStack(comptime alignment: u29)</code></pre>
|
|
<p>
|
|
Ensures that a function will have a stack alignment of at least <code>alignment</code> bytes.
|
|
</p>
|
|
{#header_close#}
|
|
{#header_open|@setCold#}
|
|
<pre><code class="zig">@setCold(is_cold: bool)</code></pre>
|
|
<p>
|
|
Tells the optimizer that a function is rarely called.
|
|
</p>
|
|
{#header_close#}
|
|
{#header_open|@setRuntimeSafety#}
|
|
<pre><code class="zig">@setRuntimeSafety(safety_on: bool)</code></pre>
|
|
<p>
|
|
Sets whether runtime safety checks are on for the scope that contains the function call.
|
|
</p>
|
|
|
|
{#header_close#}
|
|
{#header_open|@setEvalBranchQuota#}
|
|
<pre><code class="zig">@setEvalBranchQuota(new_quota: usize)</code></pre>
|
|
<p>
|
|
Changes the maximum number of backwards branches that compile-time code
|
|
execution can use before giving up and making a compile error.
|
|
</p>
|
|
<p>
|
|
If the <code>new_quota</code> is smaller than the default quota (<code>1000</code>) or
|
|
a previously explicitly set quota, it is ignored.
|
|
</p>
|
|
<p>
|
|
Example:
|
|
</p>
|
|
{#code_begin|test_err|evaluation exceeded 1000 backwards branches#}
|
|
test "foo" {
|
|
comptime {
|
|
var i = 0;
|
|
while (i < 1001) : (i += 1) {}
|
|
}
|
|
}
|
|
{#code_end#}
|
|
<p>Now we use <code class="zig">@setEvalBranchQuota</code>:</p>
|
|
{#code_begin|test#}
|
|
test "foo" {
|
|
comptime {
|
|
@setEvalBranchQuota(1001);
|
|
var i = 0;
|
|
while (i < 1001) : (i += 1) {}
|
|
}
|
|
}
|
|
{#code_end#}
|
|
|
|
{#see_also|comptime#}
|
|
{#header_close#}
|
|
{#header_open|@setFloatMode#}
|
|
<pre><code class="zig">@setFloatMode(scope, mode: @import("builtin").FloatMode)</code></pre>
|
|
<p>
|
|
Sets the floating point mode for a given scope. Possible values are:
|
|
</p>
|
|
{#code_begin|syntax#}
|
|
pub const FloatMode = enum {
|
|
Optimized,
|
|
Strict,
|
|
};
|
|
{#code_end#}
|
|
<ul>
|
|
<li>
|
|
<code>Optimized</code> (default) - Floating point operations may do all of the following:
|
|
<ul>
|
|
<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>
|
|
<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>
|
|
<li>Treat the sign of a zero argument or result as insignificant.</li>
|
|
<li>Use the reciprocal of an argument rather than perform division.</li>
|
|
<li>Perform floating-point contraction (e.g. fusing a multiply followed by an addition into a fused multiply-and-add).</li>
|
|
<li>Perform algebraically equivalent transformations that may change results in floating point (e.g. reassociate).</li>
|
|
</ul>
|
|
This is equivalent to <code>-ffast-math</code> in GCC.
|
|
</li>
|
|
<li>
|
|
<code>Strict</code> - Floating point operations follow strict IEEE compliance.
|
|
</li>
|
|
</ul>
|
|
{#see_also|Floating Point Operations#}
|
|
{#header_close#}
|
|
{#header_open|@setGlobalLinkage#}
|
|
<pre><code class="zig">@setGlobalLinkage(global_variable_name, comptime linkage: GlobalLinkage)</code></pre>
|
|
<p>
|
|
<code>GlobalLinkage</code> can be found with <code>@import("builtin").GlobalLinkage</code>.
|
|
</p>
|
|
{#see_also|Compile Variables#}
|
|
{#header_close#}
|
|
{#header_open|@setGlobalSection#}
|
|
<pre><code class="zig">@setGlobalSection(global_variable_name, comptime section_name: []const u8) -> bool</code></pre>
|
|
<p>
|
|
Puts the global variable in the specified section.
|
|
</p>
|
|
{#header_close#}
|
|
{#header_open|@shlExact#}
|
|
<pre><code class="zig">@shlExact(value: T, shift_amt: Log2T) -> T</code></pre>
|
|
<p>
|
|
Performs the left shift operation (<code><<</code>). Caller guarantees
|
|
that the shift will not shift any 1 bits out.
|
|
</p>
|
|
<p>
|
|
The type of <code>shift_amt</code> is an unsigned integer with <code>log2(T.bit_count)</code> bits.
|
|
This is because <code>shift_amt >= T.bit_count</code> is undefined behavior.
|
|
</p>
|
|
{#see_also|@shrExact|@shlWithOverflow#}
|
|
{#header_close#}
|
|
{#header_open|@shlWithOverflow#}
|
|
<pre><code class="zig">@shlWithOverflow(comptime T: type, a: T, shift_amt: Log2T, result: &T) -> bool</code></pre>
|
|
<p>
|
|
Performs <code>*result = a << b</code>. If overflow or underflow occurs,
|
|
stores the overflowed bits in <code>result</code> and returns <code>true</code>.
|
|
If no overflow or underflow occurs, returns <code>false</code>.
|
|
</p>
|
|
<p>
|
|
The type of <code>shift_amt</code> is an unsigned integer with <code>log2(T.bit_count)</code> bits.
|
|
This is because <code>shift_amt >= T.bit_count</code> is undefined behavior.
|
|
</p>
|
|
{#see_also|@shlExact|@shrExact#}
|
|
{#header_close#}
|
|
{#header_open|@shrExact#}
|
|
<pre><code class="zig">@shrExact(value: T, shift_amt: Log2T) -> T</code></pre>
|
|
<p>
|
|
Performs the right shift operation (<code>>></code>). Caller guarantees
|
|
that the shift will not shift any 1 bits out.
|
|
</p>
|
|
<p>
|
|
The type of <code>shift_amt</code> is an unsigned integer with <code>log2(T.bit_count)</code> bits.
|
|
This is because <code>shift_amt >= T.bit_count</code> is undefined behavior.
|
|
</p>
|
|
{#see_also|@shlExact|@shlWithOverflow#}
|
|
{#header_close#}
|
|
{#header_open|@sizeOf#}
|
|
<pre><code class="zig">@sizeOf(comptime T: type) -> (number literal)</code></pre>
|
|
<p>
|
|
This function returns the number of bytes it takes to store <code>T</code> in memory.
|
|
</p>
|
|
<p>
|
|
The result is a target-specific compile time constant.
|
|
</p>
|
|
{#header_close#}
|
|
{#header_open|@subWithOverflow#}
|
|
<pre><code class="zig">@subWithOverflow(comptime T: type, a: T, b: T, result: &T) -> bool</code></pre>
|
|
<p>
|
|
Performs <code>*result = a - b</code>. If overflow or underflow occurs,
|
|
stores the overflowed bits in <code>result</code> and returns <code>true</code>.
|
|
If no overflow or underflow occurs, returns <code>false</code>.
|
|
</p>
|
|
{#header_close#}
|
|
{#header_open|@truncate#}
|
|
<pre><code class="zig">@truncate(comptime T: type, integer) -> T</code></pre>
|
|
<p>
|
|
This function truncates bits from an integer type, resulting in a smaller
|
|
integer type.
|
|
</p>
|
|
<p>
|
|
The following produces a crash in debug mode and undefined behavior in
|
|
release mode:
|
|
</p>
|
|
<pre><code class="zig">const a: u16 = 0xabcd;
|
|
const b: u8 = u8(a);</code></pre>
|
|
<p>
|
|
However this is well defined and working code:
|
|
</p>
|
|
<pre><code class="zig">const a: u16 = 0xabcd;
|
|
const b: u8 = @truncate(u8, a);
|
|
// b is now 0xcd</code></pre>
|
|
<p>
|
|
This function always truncates the significant bits of the integer, regardless
|
|
of endianness on the target platform.
|
|
</p>
|
|
|
|
{#header_close#}
|
|
{#header_open|@typeId#}
|
|
<pre><code class="zig">@typeId(comptime T: type) -> @import("builtin").TypeId</code></pre>
|
|
<p>
|
|
Returns which kind of type something is. Possible values:
|
|
</p>
|
|
{#code_begin|syntax#}
|
|
pub const TypeId = enum {
|
|
Type,
|
|
Void,
|
|
Bool,
|
|
NoReturn,
|
|
Int,
|
|
Float,
|
|
Pointer,
|
|
Array,
|
|
Struct,
|
|
FloatLiteral,
|
|
IntLiteral,
|
|
UndefinedLiteral,
|
|
NullLiteral,
|
|
Nullable,
|
|
ErrorUnion,
|
|
Error,
|
|
Enum,
|
|
Union,
|
|
Fn,
|
|
Namespace,
|
|
Block,
|
|
BoundFn,
|
|
ArgTuple,
|
|
Opaque,
|
|
};
|
|
{#code_end#}
|
|
{#header_close#}
|
|
{#header_open|@typeName#}
|
|
<pre><code class="zig">@typeName(T: type) -> []u8</code></pre>
|
|
<p>
|
|
This function returns the string representation of a type.
|
|
</p>
|
|
|
|
{#header_close#}
|
|
{#header_open|@typeOf#}
|
|
<pre><code class="zig">@typeOf(expression) -> type</code></pre>
|
|
<p>
|
|
This function returns a compile-time constant, which is the type of the
|
|
expression passed as an argument. The expression is evaluated.
|
|
</p>
|
|
|
|
{#header_close#}
|
|
{#header_close#}
|
|
{#header_open|Build Mode#}
|
|
<p>
|
|
Zig has three build modes:
|
|
</p>
|
|
<ul>
|
|
<li>{#link|Debug#} (default)</li>
|
|
<li>{#link|ReleaseFast#}</li>
|
|
<li>{#link|ReleaseSafe#}</li>
|
|
</ul>
|
|
<p>
|
|
To add standard build options to a <code>build.zig</code> file:
|
|
</p>
|
|
{#code_begin|syntax#}
|
|
const Builder = @import("std").build.Builder;
|
|
|
|
pub fn build(b: &Builder) void {
|
|
const exe = b.addExecutable("example", "example.zig");
|
|
exe.setBuildMode(b.standardReleaseOptions());
|
|
b.default_step.dependOn(&exe.step);
|
|
}
|
|
{#code_end#}
|
|
<p>
|
|
This causes these options to be available:
|
|
</p>
|
|
<pre><code class="shell"> -Drelease-safe=(bool) optimizations on and safety on
|
|
-Drelease-fast=(bool) optimizations on and safety off</code></pre>
|
|
{#header_open|Debug#}
|
|
<pre><code class="shell">$ zig build-exe example.zig</code></pre>
|
|
<ul>
|
|
<li>Fast compilation speed</li>
|
|
<li>Safety checks enabled</li>
|
|
<li>Slow runtime performance</li>
|
|
</ul>
|
|
{#header_close#}
|
|
{#header_open|ReleaseFast#}
|
|
<pre><code class="shell">$ zig build-exe example.zig --release-fast</code></pre>
|
|
<ul>
|
|
<li>Fast runtime performance</li>
|
|
<li>Safety checks disabled</li>
|
|
<li>Slow compilation speed</li>
|
|
</ul>
|
|
{#header_close#}
|
|
{#header_open|ReleaseSafe#}
|
|
<pre><code class="shell">$ zig build-exe example.zig --release-safe</code></pre>
|
|
<ul>
|
|
<li>Medium runtime performance</li>
|
|
<li>Safety checks enabled</li>
|
|
<li>Slow compilation speed</li>
|
|
</ul>
|
|
{#see_also|Compile Variables|Zig Build System|Undefined Behavior#}
|
|
{#header_close#}
|
|
{#header_close#}
|
|
{#header_open|Undefined Behavior#}
|
|
<p>
|
|
Zig has many instances of undefined behavior. If undefined behavior is
|
|
detected at compile-time, Zig emits an error. Most undefined behavior that
|
|
cannot be detected at compile-time can be detected at runtime. In these cases,
|
|
Zig has safety checks. Safety checks can be disabled on a per-block basis
|
|
with <code>@setRuntimeSafety</code>. The {#link|ReleaseFast#}
|
|
build mode disables all safety checks in order to facilitate optimizations.
|
|
</p>
|
|
<p>
|
|
When a safety check fails, Zig crashes with a stack trace, like this:
|
|
</p>
|
|
{#code_begin|test_err|reached unreachable code#}
|
|
test "safety check" {
|
|
unreachable;
|
|
}
|
|
{#code_end#}
|
|
{#header_open|Reaching Unreachable Code#}
|
|
<p>At compile-time:</p>
|
|
{#code_begin|test_err|unable to evaluate constant expression#}
|
|
comptime {
|
|
assert(false);
|
|
}
|
|
fn assert(ok: bool) void {
|
|
if (!ok) unreachable; // assertion failure
|
|
}
|
|
{#code_end#}
|
|
<p>At runtime crashes with the message <code>reached unreachable code</code> and a stack trace.</p>
|
|
{#header_close#}
|
|
{#header_open|Index out of Bounds#}
|
|
<p>At compile-time:</p>
|
|
{#code_begin|test_err|index 5 outside array of size 5#}
|
|
comptime {
|
|
const array = "hello";
|
|
const garbage = array[5];
|
|
}
|
|
{#code_end#}
|
|
<p>At runtime crashes with the message <code>index out of bounds</code> and a stack trace.</p>
|
|
{#header_close#}
|
|
{#header_open|Cast Negative Number to Unsigned Integer#}
|
|
<p>At compile-time:</p>
|
|
{#code_begin|test_err|attempt to cast negative value to unsigned integer#}
|
|
comptime {
|
|
const value: i32 = -1;
|
|
const unsigned = u32(value);
|
|
}
|
|
{#code_end#}
|
|
<p>At runtime crashes with the message <code>attempt to cast negative value to unsigned integer</code> and a stack trace.</p>
|
|
<p>
|
|
If you are trying to obtain the maximum value of an unsigned integer, use <code>@maxValue(T)</code>,
|
|
where <code>T</code> is the integer type, such as <code>u32</code>.
|
|
</p>
|
|
{#header_close#}
|
|
{#header_open|Cast Truncates Data#}
|
|
<p>At compile-time:</p>
|
|
{#code_begin|test_err|cast from 'u16' to 'u8' truncates bits#}
|
|
comptime {
|
|
const spartan_count: u16 = 300;
|
|
const byte = u8(spartan_count);
|
|
}
|
|
{#code_end#}
|
|
<p>At runtime crashes with the message <code>integer cast truncated bits</code> and a stack trace.</p>
|
|
<p>
|
|
If you are trying to truncate bits, use <code>@truncate(T, value)</code>,
|
|
where <code>T</code> is the integer type, such as <code>u32</code>, and <code>value</code>
|
|
is the value you want to truncate.
|
|
</p>
|
|
{#header_close#}
|
|
{#header_open|Integer Overflow#}
|
|
{#header_open|Default Operations#}
|
|
<p>The following operators can cause integer overflow:</p>
|
|
<ul>
|
|
<li><code>+</code> (addition)</li>
|
|
<li><code>-</code> (subtraction)</li>
|
|
<li><code>-</code> (negation)</li>
|
|
<li><code>*</code> (multiplication)</li>
|
|
<li><code>/</code> (division)</li>
|
|
<li><code>@divTrunc</code> (division)</li>
|
|
<li><code>@divFloor</code> (division)</li>
|
|
<li><code>@divExact</code> (division)</li>
|
|
</ul>
|
|
<p>Example with addition at compile-time:</p>
|
|
{#code_begin|test_err|operation caused overflow#}
|
|
comptime {
|
|
var byte: u8 = 255;
|
|
byte += 1;
|
|
}
|
|
{#code_end#}
|
|
<p>At runtime crashes with the message <code>integer overflow</code> and a stack trace.</p>
|
|
{#header_close#}
|
|
{#header_open|Standard Library Math Functions#}
|
|
<p>These functions provided by the standard library return possible errors.</p>
|
|
<ul>
|
|
<li><code>@import("std").math.add</code></li>
|
|
<li><code>@import("std").math.sub</code></li>
|
|
<li><code>@import("std").math.mul</code></li>
|
|
<li><code>@import("std").math.divTrunc</code></li>
|
|
<li><code>@import("std").math.divFloor</code></li>
|
|
<li><code>@import("std").math.divExact</code></li>
|
|
<li><code>@import("std").math.shl</code></li>
|
|
</ul>
|
|
<p>Example of catching an overflow for addition:</p>
|
|
{#code_begin|exe_err#}
|
|
const math = @import("std").math;
|
|
const warn = @import("std").debug.warn;
|
|
pub fn main() !void {
|
|
var byte: u8 = 255;
|
|
|
|
byte = if (math.add(u8, byte, 1)) |result| result else |err| {
|
|
warn("unable to add one: {}\n", @errorName(err));
|
|
return err;
|
|
};
|
|
|
|
warn("result: {}\n", byte);
|
|
}
|
|
{#code_end#}
|
|
{#header_close#}
|
|
{#header_open|Builtin Overflow Functions#}
|
|
<p>
|
|
These builtins return a <code>bool</code> of whether or not overflow
|
|
occurred, as well as returning the overflowed bits:
|
|
</p>
|
|
<ul>
|
|
<li><code>@addWithOverflow</code></li>
|
|
<li><code>@subWithOverflow</code></li>
|
|
<li><code>@mulWithOverflow</code></li>
|
|
<li><code>@shlWithOverflow</code></li>
|
|
</ul>
|
|
<p>
|
|
Example of <code>@addWithOverflow</code>:
|
|
</p>
|
|
{#code_begin|exe#}
|
|
const warn = @import("std").debug.warn;
|
|
pub fn main() void {
|
|
var byte: u8 = 255;
|
|
|
|
var result: u8 = undefined;
|
|
if (@addWithOverflow(u8, byte, 10, &result)) {
|
|
warn("overflowed result: {}\n", result);
|
|
} else {
|
|
warn("result: {}\n", result);
|
|
}
|
|
}
|
|
{#code_end#}
|
|
{#header_close#}
|
|
{#header_open|Wrapping Operations#}
|
|
<p>
|
|
These operations have guaranteed wraparound semantics.
|
|
</p>
|
|
<ul>
|
|
<li><code>+%</code> (wraparound addition)</li>
|
|
<li><code>-%</code> (wraparound subtraction)</li>
|
|
<li><code>-%</code> (wraparound negation)</li>
|
|
<li><code>*%</code> (wraparound multiplication)</li>
|
|
</ul>
|
|
{#code_begin|test#}
|
|
const assert = @import("std").debug.assert;
|
|
|
|
test "wraparound addition and subtraction" {
|
|
const x: i32 = @maxValue(i32);
|
|
const min_val = x +% 1;
|
|
assert(min_val == @minValue(i32));
|
|
const max_val = min_val -% 1;
|
|
assert(max_val == @maxValue(i32));
|
|
}
|
|
{#code_end#}
|
|
{#header_close#}
|
|
{#header_close#}
|
|
{#header_open|Exact Left Shift Overflow#}
|
|
<p>At compile-time:</p>
|
|
{#code_begin|test_err|operation caused overflow#}
|
|
comptime {
|
|
const x = @shlExact(u8(0b01010101), 2);
|
|
}
|
|
{#code_end#}
|
|
<p>At runtime crashes with the message <code>left shift overflowed bits</code> and a stack trace.</p>
|
|
{#header_close#}
|
|
{#header_open|Exact Right Shift Overflow#}
|
|
<p>At compile-time:</p>
|
|
{#code_begin|test_err|exact shift shifted out 1 bits#}
|
|
comptime {
|
|
const x = @shrExact(u8(0b10101010), 2);
|
|
}
|
|
{#code_end#}
|
|
<p>At runtime crashes with the message <code>right shift overflowed bits</code> and a stack trace.</p>
|
|
{#header_close#}
|
|
{#header_open|Division by Zero#}
|
|
<p>At compile-time:</p>
|
|
{#code_begin|test_err|division by zero#}
|
|
comptime {
|
|
const a: i32 = 1;
|
|
const b: i32 = 0;
|
|
const c = a / b;
|
|
}
|
|
{#code_end#}
|
|
<p>At runtime crashes with the message <code>division by zero</code> and a stack trace.</p>
|
|
|
|
{#header_close#}
|
|
{#header_open|Remainder Division by Zero#}
|
|
<p>At compile-time:</p>
|
|
{#code_begin|test_err|division by zero#}
|
|
comptime {
|
|
const a: i32 = 10;
|
|
const b: i32 = 0;
|
|
const c = a % b;
|
|
}
|
|
{#code_end#}
|
|
<p>At runtime crashes with the message <code>remainder division by zero</code> and a stack trace.</p>
|
|
|
|
{#header_close#}
|
|
{#header_open|Exact Division Remainder#}
|
|
<p>TODO</p>
|
|
{#header_close#}
|
|
{#header_open|Slice Widen Remainder#}
|
|
<p>TODO</p>
|
|
{#header_close#}
|
|
{#header_open|Attempt to Unwrap Null#}
|
|
<p>At compile-time:</p>
|
|
{#code_begin|test_err|unable to unwrap null#}
|
|
comptime {
|
|
const nullable_number: ?i32 = null;
|
|
const number = ??nullable_number;
|
|
}
|
|
{#code_end#}
|
|
<p>At runtime crashes with the message <code>attempt to unwrap null</code> and a stack trace.</p>
|
|
<p>One way to avoid this crash is to test for null instead of assuming non-null, with
|
|
the <code>if</code> expression:</p>
|
|
{#code_begin|exe|test#}
|
|
const warn = @import("std").debug.warn;
|
|
pub fn main() void {
|
|
const nullable_number: ?i32 = null;
|
|
|
|
if (nullable_number) |number| {
|
|
warn("got number: {}\n", number);
|
|
} else {
|
|
warn("it's null\n");
|
|
}
|
|
}
|
|
{#code_end#}
|
|
{#header_close#}
|
|
{#header_open|Attempt to Unwrap Error#}
|
|
<p>At compile-time:</p>
|
|
{#code_begin|test_err|caught unexpected error 'UnableToReturnNumber'#}
|
|
comptime {
|
|
const number = getNumberOrFail() catch unreachable;
|
|
}
|
|
|
|
fn getNumberOrFail() !i32 {
|
|
return error.UnableToReturnNumber;
|
|
}
|
|
{#code_end#}
|
|
<p>At runtime crashes with the message <code>attempt to unwrap error: ErrorCode</code> and a stack trace.</p>
|
|
<p>One way to avoid this crash is to test for an error instead of assuming a successful result, with
|
|
the <code>if</code> expression:</p>
|
|
{#code_begin|exe#}
|
|
const warn = @import("std").debug.warn;
|
|
|
|
pub fn main() void {
|
|
const result = getNumberOrFail();
|
|
|
|
if (result) |number| {
|
|
warn("got number: {}\n", number);
|
|
} else |err| {
|
|
warn("got error: {}\n", @errorName(err));
|
|
}
|
|
}
|
|
|
|
fn getNumberOrFail() !i32 {
|
|
return error.UnableToReturnNumber;
|
|
}
|
|
{#code_end#}
|
|
{#header_close#}
|
|
{#header_open|Invalid Error Code#}
|
|
<p>At compile-time:</p>
|
|
{#code_begin|test_err|integer value 11 represents no error#}
|
|
comptime {
|
|
const err = error.AnError;
|
|
const number = u32(err) + 10;
|
|
const invalid_err = error(number);
|
|
}
|
|
{#code_end#}
|
|
<p>At runtime crashes with the message <code>invalid error code</code> and a stack trace.</p>
|
|
{#header_close#}
|
|
{#header_open|Invalid Enum Cast#}
|
|
<p>TODO</p>
|
|
|
|
{#header_close#}
|
|
{#header_open|Incorrect Pointer Alignment#}
|
|
<p>TODO</p>
|
|
|
|
{#header_close#}
|
|
{#header_open|Wrong Union Field Access#}
|
|
<p>TODO</p>
|
|
|
|
{#header_close#}
|
|
{#header_close#}
|
|
{#header_open|Memory#}
|
|
<p>TODO: explain no default allocator in zig</p>
|
|
<p>TODO: show how to use the allocator interface</p>
|
|
<p>TODO: mention debug allocator</p>
|
|
<p>TODO: importance of checking for allocation failure</p>
|
|
<p>TODO: mention overcommit and the OOM Killer</p>
|
|
<p>TODO: mention recursion</p>
|
|
{#see_also|Pointers#}
|
|
|
|
{#header_close#}
|
|
{#header_open|Compile Variables#}
|
|
<p>
|
|
Compile variables are accessible by importing the <code>"builtin"</code> package,
|
|
which the compiler makes available to every Zig source file. It contains
|
|
compile-time constants such as the current target, endianness, and release mode.
|
|
</p>
|
|
{#code_begin|syntax#}
|
|
const builtin = @import("builtin");
|
|
const separator = if (builtin.os == builtin.Os.windows) '\\' else '/';
|
|
{#code_end#}
|
|
<p>
|
|
Example of what is imported with <code>@import("builtin")</code>:
|
|
</p>
|
|
{#code_begin|syntax#}
|
|
pub const StackTrace = struct {
|
|
index: usize,
|
|
instruction_addresses: []usize,
|
|
};
|
|
|
|
pub const Os = enum {
|
|
freestanding,
|
|
ananas,
|
|
cloudabi,
|
|
dragonfly,
|
|
freebsd,
|
|
fuchsia,
|
|
ios,
|
|
kfreebsd,
|
|
linux,
|
|
lv2,
|
|
macosx,
|
|
netbsd,
|
|
openbsd,
|
|
solaris,
|
|
windows,
|
|
haiku,
|
|
minix,
|
|
rtems,
|
|
nacl,
|
|
cnk,
|
|
bitrig,
|
|
aix,
|
|
cuda,
|
|
nvcl,
|
|
amdhsa,
|
|
ps4,
|
|
elfiamcu,
|
|
tvos,
|
|
watchos,
|
|
mesa3d,
|
|
contiki,
|
|
zen,
|
|
};
|
|
|
|
pub const Arch = enum {
|
|
armv8_2a,
|
|
armv8_1a,
|
|
armv8,
|
|
armv8r,
|
|
armv8m_baseline,
|
|
armv8m_mainline,
|
|
armv7,
|
|
armv7em,
|
|
armv7m,
|
|
armv7s,
|
|
armv7k,
|
|
armv7ve,
|
|
armv6,
|
|
armv6m,
|
|
armv6k,
|
|
armv6t2,
|
|
armv5,
|
|
armv5te,
|
|
armv4t,
|
|
armeb,
|
|
aarch64,
|
|
aarch64_be,
|
|
avr,
|
|
bpfel,
|
|
bpfeb,
|
|
hexagon,
|
|
mips,
|
|
mipsel,
|
|
mips64,
|
|
mips64el,
|
|
msp430,
|
|
nios2,
|
|
powerpc,
|
|
powerpc64,
|
|
powerpc64le,
|
|
r600,
|
|
amdgcn,
|
|
riscv32,
|
|
riscv64,
|
|
sparc,
|
|
sparcv9,
|
|
sparcel,
|
|
s390x,
|
|
tce,
|
|
tcele,
|
|
thumb,
|
|
thumbeb,
|
|
i386,
|
|
x86_64,
|
|
xcore,
|
|
nvptx,
|
|
nvptx64,
|
|
le32,
|
|
le64,
|
|
amdil,
|
|
amdil64,
|
|
hsail,
|
|
hsail64,
|
|
spir,
|
|
spir64,
|
|
kalimbav3,
|
|
kalimbav4,
|
|
kalimbav5,
|
|
shave,
|
|
lanai,
|
|
wasm32,
|
|
wasm64,
|
|
renderscript32,
|
|
renderscript64,
|
|
};
|
|
|
|
pub const Environ = enum {
|
|
unknown,
|
|
gnu,
|
|
gnuabi64,
|
|
gnueabi,
|
|
gnueabihf,
|
|
gnux32,
|
|
code16,
|
|
eabi,
|
|
eabihf,
|
|
android,
|
|
musl,
|
|
musleabi,
|
|
musleabihf,
|
|
msvc,
|
|
itanium,
|
|
cygnus,
|
|
amdopencl,
|
|
coreclr,
|
|
opencl,
|
|
};
|
|
|
|
pub const ObjectFormat = enum {
|
|
unknown,
|
|
coff,
|
|
elf,
|
|
macho,
|
|
wasm,
|
|
};
|
|
|
|
pub const GlobalLinkage = enum {
|
|
Internal,
|
|
Strong,
|
|
Weak,
|
|
LinkOnce,
|
|
};
|
|
|
|
pub const AtomicOrder = enum {
|
|
Unordered,
|
|
Monotonic,
|
|
Acquire,
|
|
Release,
|
|
AcqRel,
|
|
SeqCst,
|
|
};
|
|
|
|
pub const Mode = enum {
|
|
Debug,
|
|
ReleaseSafe,
|
|
ReleaseFast,
|
|
};
|
|
|
|
pub const TypeId = enum {
|
|
Type,
|
|
Void,
|
|
Bool,
|
|
NoReturn,
|
|
Int,
|
|
Float,
|
|
Pointer,
|
|
Array,
|
|
Struct,
|
|
FloatLiteral,
|
|
IntLiteral,
|
|
UndefinedLiteral,
|
|
NullLiteral,
|
|
Nullable,
|
|
ErrorUnion,
|
|
Error,
|
|
Enum,
|
|
Union,
|
|
Fn,
|
|
Namespace,
|
|
Block,
|
|
BoundFn,
|
|
ArgTuple,
|
|
Opaque,
|
|
};
|
|
|
|
pub const FloatMode = enum {
|
|
Optimized,
|
|
Strict,
|
|
};
|
|
|
|
pub const Endian = enum {
|
|
Big,
|
|
Little,
|
|
};
|
|
|
|
pub const endian = Endian.Little;
|
|
pub const is_test = false;
|
|
pub const os = Os.linux;
|
|
pub const arch = Arch.x86_64;
|
|
pub const environ = Environ.gnu;
|
|
pub const object_format = ObjectFormat.elf;
|
|
pub const mode = Mode.Debug;
|
|
pub const link_libc = false;
|
|
pub const have_error_return_tracing = true;
|
|
{#code_end#}
|
|
{#see_also|Build Mode#}
|
|
{#header_close#}
|
|
{#header_open|Root Source File#}
|
|
<p>TODO: explain how root source file finds other files</p>
|
|
<p>TODO: pub fn main</p>
|
|
<p>TODO: pub fn panic</p>
|
|
<p>TODO: if linking with libc you can use export fn main</p>
|
|
<p>TODO: order independent top level declarations</p>
|
|
<p>TODO: lazy analysis</p>
|
|
<p>TODO: using comptime { _ = @import() }</p>
|
|
{#header_close#}
|
|
{#header_open|Zig Test#}
|
|
<p>TODO: basic usage</p>
|
|
<p>TODO: lazy analysis</p>
|
|
<p>TODO: --test-filter</p>
|
|
<p>TODO: --test-name-prefix</p>
|
|
<p>TODO: testing in releasefast and releasesafe mode. assert still works</p>
|
|
{#header_close#}
|
|
{#header_open|Zig Build System#}
|
|
<p>TODO: explain purpose, it's supposed to replace make/cmake</p>
|
|
<p>TODO: example of building a zig executable</p>
|
|
<p>TODO: example of building a C library</p>
|
|
{#header_close#}
|
|
{#header_open|C#}
|
|
<p>
|
|
Although Zig is independent of C, and, unlike most other languages, does not depend on libc,
|
|
Zig acknowledges the importance of interacting with existing C code.
|
|
</p>
|
|
<p>
|
|
There are a few ways that Zig facilitates C interop.
|
|
</p>
|
|
{#header_open|C Type Primitives#}
|
|
<p>
|
|
These have guaranteed C ABI compatibility and can be used like any other type.
|
|
</p>
|
|
<ul>
|
|
<li><code>c_short</code></li>
|
|
<li><code>c_ushort</code></li>
|
|
<li><code>c_int</code></li>
|
|
<li><code>c_uint</code></li>
|
|
<li><code>c_long</code></li>
|
|
<li><code>c_ulong</code></li>
|
|
<li><code>c_longlong</code></li>
|
|
<li><code>c_ulonglong</code></li>
|
|
<li><code>c_longdouble</code></li>
|
|
<li><code>c_void</code></li>
|
|
</ul>
|
|
{#see_also|Primitive Types#}
|
|
{#header_close#}
|
|
{#header_open|C String Literals#}
|
|
{#code_begin|exe#}
|
|
{#link_libc#}
|
|
extern fn puts(&const u8) void;
|
|
|
|
pub fn main() void {
|
|
puts(c"this has a null terminator");
|
|
puts(
|
|
c\\and so
|
|
c\\does this
|
|
c\\multiline C string literal
|
|
);
|
|
}
|
|
{#code_end#}
|
|
{#see_also|String Literals#}
|
|
{#header_close#}
|
|
{#header_open|Import from C Header File#}
|
|
<p>
|
|
The <code>@cImport</code> builtin function can be used
|
|
to directly import symbols from .h files:
|
|
</p>
|
|
{#code_begin|exe#}
|
|
{#link_libc#}
|
|
const c = @cImport({
|
|
// See https://github.com/zig-lang/zig/issues/515
|
|
@cDefine("_NO_CRT_STDIO_INLINE", "1");
|
|
@cInclude("stdio.h");
|
|
});
|
|
pub fn main() void {
|
|
_ = c.printf(c"hello\n");
|
|
}
|
|
{#code_end#}
|
|
<p>
|
|
The <code>@cImport</code> function takes an expression as a parameter.
|
|
This expression is evaluated at compile-time and is used to control
|
|
preprocessor directives and include multiple .h files:
|
|
</p>
|
|
{#code_begin|syntax#}
|
|
const builtin = @import("builtin");
|
|
|
|
const c = @cImport({
|
|
@cDefine("NDEBUG", builtin.mode == builtin.Mode.ReleaseFast);
|
|
if (something) {
|
|
@cDefine("_GNU_SOURCE", {});
|
|
}
|
|
@cInclude("stdlib.h");
|
|
if (something) {
|
|
@cUndef("_GNU_SOURCE");
|
|
}
|
|
@cInclude("soundio.h");
|
|
});
|
|
{#code_end#}
|
|
{#see_also|@cImport|@cInclude|@cDefine|@cUndef|@import#}
|
|
{#header_close#}
|
|
{#header_open|Mixing Object Files#}
|
|
<p>
|
|
You can mix Zig object files with any other object files that respect the C ABI. Example:
|
|
</p>
|
|
<p class="file">base64.zig</p>
|
|
{#code_begin|syntax#}
|
|
const base64 = @import("std").base64;
|
|
|
|
export fn decode_base_64(dest_ptr: &u8, dest_len: usize,
|
|
source_ptr: &const u8, source_len: usize) usize
|
|
{
|
|
const src = source_ptr[0..source_len];
|
|
const dest = dest_ptr[0..dest_len];
|
|
const base64_decoder = base64.standard_decoder_unsafe;
|
|
const decoded_size = base64_decoder.calcSize(src);
|
|
base64_decoder.decode(dest[0..decoded_size], src);
|
|
return decoded_size;
|
|
}
|
|
{#code_end#}
|
|
<p class="file">test.c</p>
|
|
<pre><code class="cpp">// This header is generated by zig from base64.zig
|
|
#include "base64.h"
|
|
|
|
#include <string.h>
|
|
#include <stdio.h>
|
|
|
|
int main(int argc, char **argv) {
|
|
const char *encoded = "YWxsIHlvdXIgYmFzZSBhcmUgYmVsb25nIHRvIHVz";
|
|
char buf[200];
|
|
|
|
size_t len = decode_base_64(buf, 200, encoded, strlen(encoded));
|
|
buf[len] = 0;
|
|
puts(buf);
|
|
|
|
return 0;
|
|
}</code></pre>
|
|
<p class="file">build.zig</p>
|
|
{#code_begin|syntax#}
|
|
const Builder = @import("std").build.Builder;
|
|
|
|
pub fn build(b: &Builder) void {
|
|
const obj = b.addObject("base64", "base64.zig");
|
|
|
|
const exe = b.addCExecutable("test");
|
|
exe.addCompileFlags([][]const u8 {
|
|
"-std=c99",
|
|
});
|
|
exe.addSourceFile("test.c");
|
|
exe.addObject(obj);
|
|
exe.setOutputPath(".");
|
|
|
|
b.default_step.dependOn(&exe.step);
|
|
}
|
|
{#code_end#}
|
|
{#header_close#}
|
|
{#header_open|Terminal#}
|
|
<pre><code class="shell">$ zig build
|
|
$ ./test
|
|
all your base are belong to us</code></pre>
|
|
{#see_also|Targets|Zig Build System#}
|
|
{#header_close#}
|
|
{#header_close#}
|
|
{#header_open|Targets#}
|
|
<p>
|
|
Zig supports generating code for all targets that LLVM supports. Here is
|
|
what it looks like to execute <code>zig targets</code> on a Linux x86_64
|
|
computer:
|
|
</p>
|
|
<pre><code class="shell">$ zig targets
|
|
Architectures:
|
|
armv8_2a
|
|
armv8_1a
|
|
armv8
|
|
armv8r
|
|
armv8m_baseline
|
|
armv8m_mainline
|
|
armv7
|
|
armv7em
|
|
armv7m
|
|
armv7s
|
|
armv7k
|
|
armv7ve
|
|
armv6
|
|
armv6m
|
|
armv6k
|
|
armv6t2
|
|
armv5
|
|
armv5te
|
|
armv4t
|
|
armeb
|
|
aarch64
|
|
aarch64_be
|
|
avr
|
|
bpfel
|
|
bpfeb
|
|
hexagon
|
|
mips
|
|
mipsel
|
|
mips64
|
|
mips64el
|
|
msp430
|
|
nios2
|
|
powerpc
|
|
powerpc64
|
|
powerpc64le
|
|
r600
|
|
amdgcn
|
|
riscv32
|
|
riscv64
|
|
sparc
|
|
sparcv9
|
|
sparcel
|
|
s390x
|
|
tce
|
|
tcele
|
|
thumb
|
|
thumbeb
|
|
i386
|
|
x86_64 (native)
|
|
xcore
|
|
nvptx
|
|
nvptx64
|
|
le32
|
|
le64
|
|
amdil
|
|
amdil64
|
|
hsail
|
|
hsail64
|
|
spir
|
|
spir64
|
|
kalimbav3
|
|
kalimbav4
|
|
kalimbav5
|
|
shave
|
|
lanai
|
|
wasm32
|
|
wasm64
|
|
renderscript32
|
|
renderscript64
|
|
|
|
Operating Systems:
|
|
freestanding
|
|
ananas
|
|
cloudabi
|
|
dragonfly
|
|
freebsd
|
|
fuchsia
|
|
ios
|
|
kfreebsd
|
|
linux (native)
|
|
lv2
|
|
macosx
|
|
netbsd
|
|
openbsd
|
|
solaris
|
|
windows
|
|
haiku
|
|
minix
|
|
rtems
|
|
nacl
|
|
cnk
|
|
bitrig
|
|
aix
|
|
cuda
|
|
nvcl
|
|
amdhsa
|
|
ps4
|
|
elfiamcu
|
|
tvos
|
|
watchos
|
|
mesa3d
|
|
contiki
|
|
zen
|
|
|
|
Environments:
|
|
unknown
|
|
gnu (native)
|
|
gnuabi64
|
|
gnueabi
|
|
gnueabihf
|
|
gnux32
|
|
code16
|
|
eabi
|
|
eabihf
|
|
android
|
|
musl
|
|
musleabi
|
|
musleabihf
|
|
msvc
|
|
itanium
|
|
cygnus
|
|
amdopencl
|
|
coreclr
|
|
opencl</code></pre>
|
|
<p>
|
|
The Zig Standard Library (<code>@import("std")</code>) has architecture, environment, and operating sytsem
|
|
abstractions, and thus takes additional work to support more platforms. It currently supports
|
|
Linux x86_64. Not all standard library code requires operating system abstractions, however,
|
|
so things such as generic data structures work an all above platforms.
|
|
</p>
|
|
{#header_close#}
|
|
{#header_open|Style Guide#}
|
|
<p>
|
|
These coding conventions are not enforced by the compiler, but they are shipped in
|
|
this documentation along with the compiler in order to provide a point of
|
|
reference, should anyone wish to point to an authority on agreed upon Zig
|
|
coding style.
|
|
</p>
|
|
{#header_open|Whitespace#}
|
|
<ul>
|
|
<li>
|
|
4 space indentation
|
|
</li>
|
|
<li>
|
|
Open braces on same line, unless you need to wrap.
|
|
</li>
|
|
<li>If a list of things is longer than 2, put each item on its own line and
|
|
exercise the abilty to put an extra comma at the end.
|
|
</li>
|
|
<li>
|
|
Line length: aim for 100; use common sense.
|
|
</li>
|
|
</ul>
|
|
{#header_close#}
|
|
{#header_open|Names#}
|
|
<p>
|
|
Roughly speaking: <code>camelCaseFunctionName</code>, <code>TitleCaseTypeName</code>,
|
|
<code>snake_case_variable_name</code>. More precisely:
|
|
</p>
|
|
<ul>
|
|
<li>
|
|
If <code>x</code> is a <code>struct</code> (or an alias of a <code>struct</code>),
|
|
then <code>x</code> should be <code>TitleCase</code>.
|
|
</li>
|
|
<li>
|
|
If <code>x</code> otherwise identifies a type, <code>x</code> should have <code>snake_case</code>.
|
|
</li>
|
|
<li>
|
|
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>.
|
|
</li>
|
|
<li>
|
|
If <code>x</code> is otherwise callable, then <code>x</code> should be <code>camelCase</code>.
|
|
</li>
|
|
<li>
|
|
Otherwise, <code>x</code> should be <code>snake_case</code>.
|
|
</li>
|
|
</ul>
|
|
<p>
|
|
Acronyms, initialisms, proper nouns, or any other word that has capitalization
|
|
rules in written English are subject to naming conventions just like any other
|
|
word. Even acronyms that are only 2 letters long are subject to these
|
|
conventions.
|
|
</p>
|
|
<p>
|
|
These are general rules of thumb; if it makes sense to do something different,
|
|
do what makes sense. For example, if there is an established convention such as
|
|
<code>ENOENT</code>, follow the established convention.
|
|
</p>
|
|
{#header_close#}
|
|
{#header_open|Examples#}
|
|
{#code_begin|syntax#}
|
|
const namespace_name = @import("dir_name/file_name.zig");
|
|
var global_var: i32 = undefined;
|
|
const const_name = 42;
|
|
const primitive_type_alias = f32;
|
|
const string_alias = []u8;
|
|
|
|
const StructName = struct {};
|
|
const StructAlias = StructName;
|
|
|
|
fn functionName(param_name: TypeName) void {
|
|
var functionPointer = functionName;
|
|
functionPointer();
|
|
functionPointer = otherFunction;
|
|
functionPointer();
|
|
}
|
|
const functionAlias = functionName;
|
|
|
|
fn ListTemplateFunction(comptime ChildType: type, comptime fixed_size: usize) type {
|
|
return List(ChildType, fixed_size);
|
|
}
|
|
|
|
fn ShortList(comptime T: type, comptime n: usize) type {
|
|
return struct {
|
|
field_name: [n]T,
|
|
fn methodName() void {}
|
|
};
|
|
}
|
|
|
|
// The word XML loses its casing when used in Zig identifiers.
|
|
const xml_document =
|
|
\\<?xml version="1.0" encoding="UTF-8"?>
|
|
\\<document>
|
|
\\</document>
|
|
;
|
|
const XmlParser = struct {};
|
|
|
|
// The initials BE (Big Endian) are just another word in Zig identifier names.
|
|
fn readU32Be() u32 {}
|
|
{#code_end#}
|
|
<p>
|
|
See the Zig Standard Library for more examples.
|
|
</p>
|
|
{#header_close#}
|
|
{#header_close#}
|
|
{#header_open|Source Encoding#}
|
|
<p>Zig source code is encoded in UTF-8. An invalid UTF-8 byte sequence results in a compile error.</p>
|
|
<p>Throughout all zig source code (including in comments), some codepoints are never allowed:</p>
|
|
<ul>
|
|
<li>Ascii control characters, except for U+000a (LF): U+0000 - U+0009, U+000b - U+0001f, U+007f. (Note that Windows line endings (CRLF) are not allowed, and hard tabs are not allowed.)</li>
|
|
<li>Non-Ascii Unicode line endings: U+0085 (NEL), U+2028 (LS), U+2029 (PS).</li>
|
|
</ul>
|
|
<p>The codepoint U+000a (LF) (which is encoded as the single-byte value 0x0a) is the line terminator character. This character always terminates a line of zig source code (except possbly the last line of the file).</p>
|
|
<p>For some discussion on the rationale behind these design decisions, see <a href="https://github.com/zig-lang/zig/issues/663">issue #663</a></p>
|
|
{#header_close#}
|
|
{#header_open|Grammar#}
|
|
<pre><code class="nohighlight">Root = many(TopLevelItem) EOF
|
|
|
|
TopLevelItem = CompTimeExpression(Block) | TopLevelDecl | TestDecl
|
|
|
|
TestDecl = "test" String Block
|
|
|
|
TopLevelDecl = option("pub") (FnDef | ExternDecl | GlobalVarDecl | UseDecl)
|
|
|
|
GlobalVarDecl = option("export") VariableDeclaration ";"
|
|
|
|
LocalVarDecl = option("comptime") VariableDeclaration
|
|
|
|
VariableDeclaration = ("var" | "const") Symbol option(":" TypeExpr) option("align" "(" Expression ")") option("section" "(" Expression ")") "=" Expression
|
|
|
|
ContainerMember = (ContainerField | FnDef | GlobalVarDecl)
|
|
|
|
ContainerField = Symbol option(":" PrefixOpExpression) option("=" PrefixOpExpression) ","
|
|
|
|
UseDecl = "use" Expression ";"
|
|
|
|
ExternDecl = "extern" option(String) (FnProto | VariableDeclaration) ";"
|
|
|
|
FnProto = option("nakedcc" | "stdcallcc" | "extern" | ("async" option("<" Expression ">"))) "fn" option(Symbol) ParamDeclList option("align" "(" Expression ")") option("section" "(" Expression ")") option("!") (TypeExpr | "var")
|
|
|
|
FnDef = option("inline" | "export") FnProto Block
|
|
|
|
ParamDeclList = "(" list(ParamDecl, ",") ")"
|
|
|
|
ParamDecl = option("noalias" | "comptime") option(Symbol ":") (TypeExpr | "var" | "...")
|
|
|
|
Block = option(Symbol ":") "{" many(Statement) "}"
|
|
|
|
Statement = LocalVarDecl ";" | Defer(Block) | Defer(Expression) ";" | BlockExpression(Block) | Expression ";" | ";"
|
|
|
|
TypeExpr = (PrefixOpExpression "!" PrefixOpExpression) | PrefixOpExpression
|
|
|
|
BlockOrExpression = Block | Expression
|
|
|
|
Expression = TryExpression | ReturnExpression | BreakExpression | AssignmentExpression | CancelExpression | ResumeExpression
|
|
|
|
AsmExpression = "asm" option("volatile") "(" String option(AsmOutput) ")"
|
|
|
|
AsmOutput = ":" list(AsmOutputItem, ",") option(AsmInput)
|
|
|
|
AsmInput = ":" list(AsmInputItem, ",") option(AsmClobbers)
|
|
|
|
AsmOutputItem = "[" Symbol "]" String "(" (Symbol | "->" TypeExpr) ")"
|
|
|
|
AsmInputItem = "[" Symbol "]" String "(" Expression ")"
|
|
|
|
AsmClobbers= ":" list(String, ",")
|
|
|
|
UnwrapExpression = BoolOrExpression (UnwrapNullable | UnwrapError) | BoolOrExpression
|
|
|
|
UnwrapNullable = "??" Expression
|
|
|
|
UnwrapError = "catch" option("|" Symbol "|") Expression
|
|
|
|
AssignmentExpression = UnwrapExpression AssignmentOperator UnwrapExpression | UnwrapExpression
|
|
|
|
AssignmentOperator = "=" | "*=" | "/=" | "%=" | "+=" | "-=" | "<<=" | ">>=" | "&=" | "^=" | "|=" | "*%=" | "+%=" | "-%="
|
|
|
|
BlockExpression(body) = Block | IfExpression(body) | IfErrorExpression(body) | TestExpression(body) | WhileExpression(body) | ForExpression(body) | SwitchExpression | CompTimeExpression(body) | SuspendExpression(body)
|
|
|
|
CompTimeExpression(body) = "comptime" body
|
|
|
|
SwitchExpression = "switch" "(" Expression ")" "{" many(SwitchProng) "}"
|
|
|
|
SwitchProng = (list(SwitchItem, ",") | "else") "=>" option("|" option("*") Symbol "|") Expression ","
|
|
|
|
SwitchItem = Expression | (Expression "..." Expression)
|
|
|
|
ForExpression(body) = option(Symbol ":") option("inline") "for" "(" Expression ")" option("|" option("*") Symbol option("," Symbol) "|") body option("else" BlockExpression(body))
|
|
|
|
BoolOrExpression = BoolAndExpression "or" BoolOrExpression | BoolAndExpression
|
|
|
|
ReturnExpression = "return" option(Expression)
|
|
|
|
TryExpression = "try" Expression
|
|
|
|
AwaitExpression = "await" Expression
|
|
|
|
BreakExpression = "break" option(":" Symbol) option(Expression)
|
|
|
|
CancelExpression = "cancel" Expression;
|
|
|
|
ResumeExpression = "resume" Expression;
|
|
|
|
Defer(body) = ("defer" | "deferror") body
|
|
|
|
IfExpression(body) = "if" "(" Expression ")" body option("else" BlockExpression(body))
|
|
|
|
SuspendExpression(body) = "suspend" option(("|" Symbol "|" body))
|
|
|
|
IfErrorExpression(body) = "if" "(" Expression ")" option("|" option("*") Symbol "|") body "else" "|" Symbol "|" BlockExpression(body)
|
|
|
|
TestExpression(body) = "if" "(" Expression ")" option("|" option("*") Symbol "|") body option("else" BlockExpression(body))
|
|
|
|
WhileExpression(body) = option(Symbol ":") option("inline") "while" "(" Expression ")" option("|" option("*") Symbol "|") option(":" "(" Expression ")") body option("else" option("|" Symbol "|") BlockExpression(body))
|
|
|
|
BoolAndExpression = ComparisonExpression "and" BoolAndExpression | ComparisonExpression
|
|
|
|
ComparisonExpression = BinaryOrExpression ComparisonOperator BinaryOrExpression | BinaryOrExpression
|
|
|
|
ComparisonOperator = "==" | "!=" | "<" | ">" | "<=" | ">="
|
|
|
|
BinaryOrExpression = BinaryXorExpression "|" BinaryOrExpression | BinaryXorExpression
|
|
|
|
BinaryXorExpression = BinaryAndExpression "^" BinaryXorExpression | BinaryAndExpression
|
|
|
|
BinaryAndExpression = BitShiftExpression "&" BinaryAndExpression | BitShiftExpression
|
|
|
|
BitShiftExpression = AdditionExpression BitShiftOperator BitShiftExpression | AdditionExpression
|
|
|
|
BitShiftOperator = "<<" | ">>"
|
|
|
|
AdditionExpression = MultiplyExpression AdditionOperator AdditionExpression | MultiplyExpression
|
|
|
|
AdditionOperator = "+" | "-" | "++" | "+%" | "-%"
|
|
|
|
MultiplyExpression = CurlySuffixExpression MultiplyOperator MultiplyExpression | CurlySuffixExpression
|
|
|
|
CurlySuffixExpression = TypeExpr option(ContainerInitExpression)
|
|
|
|
MultiplyOperator = "||" | "*" | "/" | "%" | "**" | "*%"
|
|
|
|
PrefixOpExpression = PrefixOp TypeExpr | SuffixOpExpression
|
|
|
|
SuffixOpExpression = ("async" option("<" SuffixOpExpression ">") SuffixOpExpression FnCallExpression) | PrimaryExpression option(FnCallExpression | ArrayAccessExpression | FieldAccessExpression | SliceExpression)
|
|
|
|
FieldAccessExpression = "." Symbol
|
|
|
|
FnCallExpression = "(" list(Expression, ",") ")"
|
|
|
|
ArrayAccessExpression = "[" Expression "]"
|
|
|
|
SliceExpression = "[" Expression ".." option(Expression) "]"
|
|
|
|
ContainerInitExpression = "{" ContainerInitBody "}"
|
|
|
|
ContainerInitBody = list(StructLiteralField, ",") | list(Expression, ",")
|
|
|
|
StructLiteralField = "." Symbol "=" Expression
|
|
|
|
PrefixOp = "!" | "-" | "~" | "*" | ("&" option("align" "(" Expression option(":" Integer ":" Integer) ")" ) option("const") option("volatile")) | "?" | "??" | "-%" | "try" | "await"
|
|
|
|
PrimaryExpression = Integer | Float | String | CharLiteral | KeywordLiteral | GroupedExpression | BlockExpression(BlockOrExpression) | Symbol | ("@" Symbol FnCallExpression) | ArrayType | FnProto | AsmExpression | ContainerDecl | ("continue" option(":" Symbol)) | ErrorSetDecl | PromiseType
|
|
|
|
PromiseType = "promise" option("->" TypeExpr)
|
|
|
|
ArrayType : "[" option(Expression) "]" option("align" "(" Expression option(":" Integer ":" Integer) ")")) option("const") option("volatile") TypeExpr
|
|
|
|
GroupedExpression = "(" Expression ")"
|
|
|
|
KeywordLiteral = "true" | "false" | "null" | "undefined" | "error" | "this" | "unreachable" | "suspend"
|
|
|
|
ErrorSetDecl = "error" "{" list(Symbol, ",") "}"
|
|
|
|
ContainerDecl = option("extern" | "packed")
|
|
("struct" option(GroupedExpression) | "union" option("enum" option(GroupedExpression) | GroupedExpression) | ("enum" option(GroupedExpression)))
|
|
"{" many(ContainerMember) "}"</code></pre>
|
|
{#header_close#}
|
|
{#header_open|Zen#}
|
|
<ul>
|
|
<li>Communicate intent precisely.</li>
|
|
<li>Edge cases matter.</li>
|
|
<li>Favor reading code over writing code.</li>
|
|
<li>Only one obvious way to do things.</li>
|
|
<li>Runtime crashes are better than bugs.</li>
|
|
<li>Compile errors are better than runtime crashes.</li>
|
|
<li>Incremental improvements.</li>
|
|
<li>Avoid local maximums.</li>
|
|
<li>Reduce the amount one must remember.</li>
|
|
<li>Minimize energy spent on coding style.</li>
|
|
<li>Together we serve end users.</li>
|
|
</ul>
|
|
{#header_close#}
|
|
</div>
|
|
<script>
|
|
/*! highlight.js v9.12.0 | BSD3 License | git.io/hljslicense */
|
|
!function(e){var n="object"==typeof window&&window||"object"==typeof self&&self;"undefined"!=typeof exports?e(exports):n&&(n.hljs=e({}),"function"==typeof define&&define.amd&&define([],function(){return n.hljs}))}(function(e){function n(e){return e.replace(/&/g,"&").replace(/</g,"<").replace(/>/g,">")}function t(e){return e.nodeName.toLowerCase()}function r(e,n){var t=e&&e.exec(n);return t&&0===t.index}function a(e){return k.test(e)}function i(e){var n,t,r,i,o=e.className+" ";if(o+=e.parentNode?e.parentNode.className:"",t=B.exec(o))return w(t[1])?t[1]:"no-highlight";for(o=o.split(/\s+/),n=0,r=o.length;r>n;n++)if(i=o[n],a(i)||w(i))return i}function o(e){var n,t={},r=Array.prototype.slice.call(arguments,1);for(n in e)t[n]=e[n];return r.forEach(function(e){for(n in e)t[n]=e[n]}),t}function u(e){var n=[];return function r(e,a){for(var i=e.firstChild;i;i=i.nextSibling)3===i.nodeType?a+=i.nodeValue.length:1===i.nodeType&&(n.push({event:"start",offset:a,node:i}),a=r(i,a),t(i).match(/br|hr|img|input/)||n.push({event:"stop",offset:a,node:i}));return a}(e,0),n}function c(e,r,a){function i(){return e.length&&r.length?e[0].offset!==r[0].offset?e[0].offset<r[0].offset?e:r:"start"===r[0].event?e:r:e.length?e:r}function o(e){function r(e){return" "+e.nodeName+'="'+n(e.value).replace('"',""")+'"'}s+="<"+t(e)+E.map.call(e.attributes,r).join("")+">"}function u(e){s+="</"+t(e)+">"}function c(e){("start"===e.event?o:u)(e.node)}for(var l=0,s="",f=[];e.length||r.length;){var g=i();if(s+=n(a.substring(l,g[0].offset)),l=g[0].offset,g===e){f.reverse().forEach(u);do c(g.splice(0,1)[0]),g=i();while(g===e&&g.length&&g[0].offset===l);f.reverse().forEach(o)}else"start"===g[0].event?f.push(g[0].node):f.pop(),c(g.splice(0,1)[0])}return s+n(a.substr(l))}function l(e){return e.v&&!e.cached_variants&&(e.cached_variants=e.v.map(function(n){return o(e,{v:null},n)})),e.cached_variants||e.eW&&[o(e)]||[e]}function s(e){function n(e){return e&&e.source||e}function t(t,r){return new RegExp(n(t),"m"+(e.cI?"i":"")+(r?"g":""))}function r(a,i){if(!a.compiled){if(a.compiled=!0,a.k=a.k||a.bK,a.k){var o={},u=function(n,t){e.cI&&(t=t.toLowerCase()),t.split(" ").forEach(function(e){var t=e.split("|");o[t[0]]=[n,t[1]?Number(t[1]):1]})};"string"==typeof a.k?u("keyword",a.k):x(a.k).forEach(function(e){u(e,a.k[e])}),a.k=o}a.lR=t(a.l||/\w+/,!0),i&&(a.bK&&(a.b="\\b("+a.bK.split(" ").join("|")+")\\b"),a.b||(a.b=/\B|\b/),a.bR=t(a.b),a.e||a.eW||(a.e=/\B|\b/),a.e&&(a.eR=t(a.e)),a.tE=n(a.e)||"",a.eW&&i.tE&&(a.tE+=(a.e?"|":"")+i.tE)),a.i&&(a.iR=t(a.i)),null==a.r&&(a.r=1),a.c||(a.c=[]),a.c=Array.prototype.concat.apply([],a.c.map(function(e){return l("self"===e?a:e)})),a.c.forEach(function(e){r(e,a)}),a.starts&&r(a.starts,i);var c=a.c.map(function(e){return e.bK?"\\.?("+e.b+")\\.?":e.b}).concat([a.tE,a.i]).map(n).filter(Boolean);a.t=c.length?t(c.join("|"),!0):{exec:function(){return null}}}}r(e)}function f(e,t,a,i){function o(e,n){var t,a;for(t=0,a=n.c.length;a>t;t++)if(r(n.c[t].bR,e))return n.c[t]}function u(e,n){if(r(e.eR,n)){for(;e.endsParent&&e.parent;)e=e.parent;return e}return e.eW?u(e.parent,n):void 0}function c(e,n){return!a&&r(n.iR,e)}function l(e,n){var t=N.cI?n[0].toLowerCase():n[0];return e.k.hasOwnProperty(t)&&e.k[t]}function p(e,n,t,r){var a=r?"":I.classPrefix,i='<span class="'+a,o=t?"":C;return i+=e+'">',i+n+o}function h(){var e,t,r,a;if(!E.k)return n(k);for(a="",t=0,E.lR.lastIndex=0,r=E.lR.exec(k);r;)a+=n(k.substring(t,r.index)),e=l(E,r),e?(B+=e[1],a+=p(e[0],n(r[0]))):a+=n(r[0]),t=E.lR.lastIndex,r=E.lR.exec(k);return a+n(k.substr(t))}function d(){var e="string"==typeof E.sL;if(e&&!y[E.sL])return n(k);var t=e?f(E.sL,k,!0,x[E.sL]):g(k,E.sL.length?E.sL:void 0);return E.r>0&&(B+=t.r),e&&(x[E.sL]=t.top),p(t.language,t.value,!1,!0)}function b(){L+=null!=E.sL?d():h(),k=""}function v(e){L+=e.cN?p(e.cN,"",!0):"",E=Object.create(e,{parent:{value:E}})}function m(e,n){if(k+=e,null==n)return b(),0;var t=o(n,E);if(t)return t.skip?k+=n:(t.eB&&(k+=n),b(),t.rB||t.eB||(k=n)),v(t,n),t.rB?0:n.length;var r=u(E,n);if(r){var a=E;a.skip?k+=n:(a.rE||a.eE||(k+=n),b(),a.eE&&(k=n));do E.cN&&(L+=C),E.skip||(B+=E.r),E=E.parent;while(E!==r.parent);return r.starts&&v(r.starts,""),a.rE?0:n.length}if(c(n,E))throw new Error('Illegal lexeme "'+n+'" for mode "'+(E.cN||"<unnamed>")+'"');return k+=n,n.length||1}var N=w(e);if(!N)throw new Error('Unknown language: "'+e+'"');s(N);var R,E=i||N,x={},L="";for(R=E;R!==N;R=R.parent)R.cN&&(L=p(R.cN,"",!0)+L);var k="",B=0;try{for(var M,j,O=0;;){if(E.t.lastIndex=O,M=E.t.exec(t),!M)break;j=m(t.substring(O,M.index),M[0]),O=M.index+j}for(m(t.substr(O)),R=E;R.parent;R=R.parent)R.cN&&(L+=C);return{r:B,value:L,language:e,top:E}}catch(T){if(T.message&&-1!==T.message.indexOf("Illegal"))return{r:0,value:n(t)};throw T}}function g(e,t){t=t||I.languages||x(y);var r={r:0,value:n(e)},a=r;return t.filter(w).forEach(function(n){var t=f(n,e,!1);t.language=n,t.r>a.r&&(a=t),t.r>r.r&&(a=r,r=t)}),a.language&&(r.second_best=a),r}function p(e){return I.tabReplace||I.useBR?e.replace(M,function(e,n){return I.useBR&&"\n"===e?"<br>":I.tabReplace?n.replace(/\t/g,I.tabReplace):""}):e}function h(e,n,t){var r=n?L[n]:t,a=[e.trim()];return e.match(/\bhljs\b/)||a.push("hljs"),-1===e.indexOf(r)&&a.push(r),a.join(" ").trim()}function d(e){var n,t,r,o,l,s=i(e);a(s)||(I.useBR?(n=document.createElementNS("http://www.w3.org/1999/xhtml","div"),n.innerHTML=e.innerHTML.replace(/\n/g,"").replace(/<br[ \/]*>/g,"\n")):n=e,l=n.textContent,r=s?f(s,l,!0):g(l),t=u(n),t.length&&(o=document.createElementNS("http://www.w3.org/1999/xhtml","div"),o.innerHTML=r.value,r.value=c(t,u(o),l)),r.value=p(r.value),e.innerHTML=r.value,e.className=h(e.className,s,r.language),e.result={language:r.language,re:r.r},r.second_best&&(e.second_best={language:r.second_best.language,re:r.second_best.r}))}function b(e){I=o(I,e)}function v(){if(!v.called){v.called=!0;var e=document.querySelectorAll("pre code");E.forEach.call(e,d)}}function m(){addEventListener("DOMContentLoaded",v,!1),addEventListener("load",v,!1)}function N(n,t){var r=y[n]=t(e);r.aliases&&r.aliases.forEach(function(e){L[e]=n})}function R(){return x(y)}function w(e){return e=(e||"").toLowerCase(),y[e]||y[L[e]]}var E=[],x=Object.keys,y={},L={},k=/^(no-?highlight|plain|text)$/i,B=/\blang(?:uage)?-([\w-]+)\b/i,M=/((^(<[^>]+>|\t|)+|(?:\n)))/gm,C="</span>",I={classPrefix:"hljs-",tabReplace:null,useBR:!1,languages:void 0};return e.highlight=f,e.highlightAuto=g,e.fixMarkup=p,e.highlightBlock=d,e.configure=b,e.initHighlighting=v,e.initHighlightingOnLoad=m,e.registerLanguage=N,e.listLanguages=R,e.getLanguage=w,e.inherit=o,e.IR="[a-zA-Z]\\w*",e.UIR="[a-zA-Z_]\\w*",e.NR="\\b\\d+(\\.\\d+)?",e.CNR="(-?)(\\b0[xX][a-fA-F0-9]+|(\\b\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?)",e.BNR="\\b(0b[01]+)",e.RSR="!|!=|!==|%|%=|&|&&|&=|\\*|\\*=|\\+|\\+=|,|-|-=|/=|/|:|;|<<|<<=|<=|<|===|==|=|>>>=|>>=|>=|>>>|>>|>|\\?|\\[|\\{|\\(|\\^|\\^=|\\||\\|=|\\|\\||~",e.BE={b:"\\\\[\\s\\S]",r:0},e.ASM={cN:"string",b:"'",e:"'",i:"\\n",c:[e.BE]},e.QSM={cN:"string",b:'"',e:'"',i:"\\n",c:[e.BE]},e.PWM={b:/\b(a|an|the|are|I'm|isn't|don't|doesn't|won't|but|just|should|pretty|simply|enough|gonna|going|wtf|so|such|will|you|your|they|like|more)\b/},e.C=function(n,t,r){var a=e.inherit({cN:"comment",b:n,e:t,c:[]},r||{});return a.c.push(e.PWM),a.c.push({cN:"doctag",b:"(?:TODO|FIXME|NOTE|BUG|XXX):",r:0}),a},e.CLCM=e.C("//","$"),e.CBCM=e.C("/\\*","\\*/"),e.HCM=e.C("#","$"),e.NM={cN:"number",b:e.NR,r:0},e.CNM={cN:"number",b:e.CNR,r:0},e.BNM={cN:"number",b:e.BNR,r:0},e.CSSNM={cN:"number",b:e.NR+"(%|em|ex|ch|rem|vw|vh|vmin|vmax|cm|mm|in|pt|pc|px|deg|grad|rad|turn|s|ms|Hz|kHz|dpi|dpcm|dppx)?",r:0},e.RM={cN:"regexp",b:/\//,e:/\/[gimuy]*/,i:/\n/,c:[e.BE,{b:/\[/,e:/\]/,r:0,c:[e.BE]}]},e.TM={cN:"title",b:e.IR,r:0},e.UTM={cN:"title",b:e.UIR,r:0},e.METHOD_GUARD={b:"\\.\\s*"+e.UIR,r:0},e});hljs.registerLanguage("cpp",function(t){var e={cN:"keyword",b:"\\b[a-z\\d_]*_t\\b"},r={cN:"string",v:[{b:'(u8?|U)?L?"',e:'"',i:"\\n",c:[t.BE]},{b:'(u8?|U)?R"',e:'"',c:[t.BE]},{b:"'\\\\?.",e:"'",i:"."}]},s={cN:"number",v:[{b:"\\b(0b[01']+)"},{b:"(-?)\\b([\\d']+(\\.[\\d']*)?|\\.[\\d']+)(u|U|l|L|ul|UL|f|F|b|B)"},{b:"(-?)(\\b0[xX][a-fA-F0-9']+|(\\b[\\d']+(\\.[\\d']*)?|\\.[\\d']+)([eE][-+]?[\\d']+)?)"}],r:0},i={cN:"meta",b:/#\s*[a-z]+\b/,e:/$/,k:{"meta-keyword":"if else elif endif define undef warning error line pragma ifdef ifndef include"},c:[{b:/\\\n/,r:0},t.inherit(r,{cN:"meta-string"}),{cN:"meta-string",b:/<[^\n>]*>/,e:/$/,i:"\\n"},t.CLCM,t.CBCM]},a=t.IR+"\\s*\\(",c={keyword:"int float while private char catch import module export virtual operator sizeof dynamic_cast|10 typedef const_cast|10 const for static_cast|10 union namespace unsigned long volatile static protected bool template mutable if public friend do goto auto void enum else break extern using asm case typeid short reinterpret_cast|10 default double register explicit signed typename try this switch continue inline delete alignof constexpr decltype noexcept static_assert thread_local restrict _Bool complex _Complex _Imaginary atomic_bool atomic_char atomic_schar atomic_uchar atomic_short atomic_ushort atomic_int atomic_uint atomic_long atomic_ulong atomic_llong atomic_ullong new throw return and or not",built_in:"std string cin cout cerr clog stdin stdout stderr stringstream istringstream ostringstream auto_ptr deque list queue stack vector map set bitset multiset multimap unordered_set unordered_map unordered_multiset unordered_multimap array shared_ptr abort abs acos asin atan2 atan calloc ceil cosh cos exit exp fabs floor fmod fprintf fputs free frexp fscanf isalnum isalpha iscntrl isdigit isgraph islower isprint ispunct isspace isupper isxdigit tolower toupper labs ldexp log10 log malloc realloc memchr memcmp memcpy memset modf pow printf putchar puts scanf sinh sin snprintf sprintf sqrt sscanf strcat strchr strcmp strcpy strcspn strlen strncat strncmp strncpy strpbrk strrchr strspn strstr tanh tan vfprintf vprintf vsprintf endl initializer_list unique_ptr",literal:"true false nullptr NULL"},n=[e,t.CLCM,t.CBCM,s,r];return{aliases:["c","cc","h","c++","h++","hpp"],k:c,i:"</",c:n.concat([i,{b:"\\b(deque|list|queue|stack|vector|map|set|bitset|multiset|multimap|unordered_map|unordered_set|unordered_multiset|unordered_multimap|array)\\s*<",e:">",k:c,c:["self",e]},{b:t.IR+"::",k:c},{v:[{b:/=/,e:/;/},{b:/\(/,e:/\)/},{bK:"new throw return else",e:/;/}],k:c,c:n.concat([{b:/\(/,e:/\)/,k:c,c:n.concat(["self"]),r:0}]),r:0},{cN:"function",b:"("+t.IR+"[\\*&\\s]+)+"+a,rB:!0,e:/[{;=]/,eE:!0,k:c,i:/[^\w\s\*&]/,c:[{b:a,rB:!0,c:[t.TM],r:0},{cN:"params",b:/\(/,e:/\)/,k:c,r:0,c:[t.CLCM,t.CBCM,r,s,e]},t.CLCM,t.CBCM,i]},{cN:"class",bK:"class struct",e:/[{;:]/,c:[{b:/</,e:/>/,c:["self"]},t.TM]}]),exports:{preprocessor:i,strings:r,k:c}}});hljs.registerLanguage("llvm",function(e){var n="([-a-zA-Z$._][\\w\\-$.]*)";return{k:"begin end true false declare define global constant private linker_private internal available_externally linkonce linkonce_odr weak weak_odr appending dllimport dllexport common default hidden protected extern_weak external thread_local zeroinitializer undef null to tail target triple datalayout volatile nuw nsw nnan ninf nsz arcp fast exact inbounds align addrspace section alias module asm sideeffect gc dbg linker_private_weak attributes blockaddress initialexec localdynamic localexec prefix unnamed_addr ccc fastcc coldcc x86_stdcallcc x86_fastcallcc arm_apcscc arm_aapcscc arm_aapcs_vfpcc ptx_device ptx_kernel intel_ocl_bicc msp430_intrcc spir_func spir_kernel x86_64_sysvcc x86_64_win64cc x86_thiscallcc cc c signext zeroext inreg sret nounwind noreturn noalias nocapture byval nest readnone readonly inlinehint noinline alwaysinline optsize ssp sspreq noredzone noimplicitfloat naked builtin cold nobuiltin noduplicate nonlazybind optnone returns_twice sanitize_address sanitize_memory sanitize_thread sspstrong uwtable returned type opaque eq ne slt sgt sle sge ult ugt ule uge oeq one olt ogt ole oge ord uno ueq une x acq_rel acquire alignstack atomic catch cleanup filter inteldialect max min monotonic nand personality release seq_cst singlethread umax umin unordered xchg add fadd sub fsub mul fmul udiv sdiv fdiv urem srem frem shl lshr ashr and or xor icmp fcmp phi call trunc zext sext fptrunc fpext uitofp sitofp fptoui fptosi inttoptr ptrtoint bitcast addrspacecast select va_arg ret br switch invoke unwind unreachable indirectbr landingpad resume malloc alloca free load store getelementptr extractelement insertelement shufflevector getresult extractvalue insertvalue atomicrmw cmpxchg fence argmemonly double",c:[{cN:"keyword",b:"i\\d+"},e.C(";","\\n",{r:0}),e.QSM,{cN:"string",v:[{b:'"',e:'[^\\\\]"'}],r:0},{cN:"title",v:[{b:"@"+n},{b:"@\\d+"},{b:"!"+n},{b:"!\\d+"+n}]},{cN:"symbol",v:[{b:"%"+n},{b:"%\\d+"},{b:"#\\d+"}]},{cN:"number",v:[{b:"0[xX][a-fA-F0-9]+"},{b:"-?\\d+(?:[.]\\d+)?(?:[eE][-+]?\\d+(?:[.]\\d+)?)?"}],r:0}]}});hljs.registerLanguage("bash",function(e){var t={cN:"variable",v:[{b:/\$[\w\d#@][\w\d_]*/},{b:/\$\{(.*?)}/}]},s={cN:"string",b:/"/,e:/"/,c:[e.BE,t,{cN:"variable",b:/\$\(/,e:/\)/,c:[e.BE]}]},a={cN:"string",b:/'/,e:/'/};return{aliases:["sh","zsh"],l:/\b-?[a-z\._]+\b/,k:{keyword:"if then else elif fi for while in do done case esac function",literal:"true false",built_in:"break cd continue eval exec exit export getopts hash pwd readonly return shift test times trap umask unset alias bind builtin caller command declare echo enable help let local logout mapfile printf read readarray source type typeset ulimit unalias set shopt autoload bg bindkey bye cap chdir clone comparguments compcall compctl compdescribe compfiles compgroups compquote comptags comptry compvalues dirs disable disown echotc echoti emulate fc fg float functions getcap getln history integer jobs kill limit log noglob popd print pushd pushln rehash sched setcap setopt stat suspend ttyctl unfunction unhash unlimit unsetopt vared wait whence where which zcompile zformat zftp zle zmodload zparseopts zprof zpty zregexparse zsocket zstyle ztcp",_:"-ne -eq -lt -gt -f -d -e -s -l -a"},c:[{cN:"meta",b:/^#![^\n]+sh\s*$/,r:10},{cN:"function",b:/\w[\w\d_]*\s*\(\s*\)\s*\{/,rB:!0,c:[e.inherit(e.TM,{b:/\w[\w\d_]*/})],r:0},e.HCM,s,a,t]}});hljs.registerLanguage("shell",function(s){return{aliases:["console"],c:[{cN:"meta",b:"^\\s{0,3}[\\w\\d\\[\\]()@-]*[>%$#]",starts:{e:"$",sL:"bash"}}]}});
|
|
</script>
|
|
<script>
|
|
hljs.registerLanguage("zig", function(t) {
|
|
var e = {
|
|
cN: "keyword",
|
|
b: "\\b[a-z\\d_]*_t\\b"
|
|
},
|
|
r = {
|
|
cN: "string",
|
|
v: [{
|
|
b: '(u8?|U)?L?"',
|
|
e: '"',
|
|
i: "\\n",
|
|
c: [t.BE]
|
|
}, {
|
|
b: '(u8?|U)?R"',
|
|
e: '"',
|
|
c: [t.BE]
|
|
}, {
|
|
b: "'\\\\?.",
|
|
e: "'",
|
|
i: "."
|
|
}]
|
|
},
|
|
s = {
|
|
cN: "number",
|
|
v: [{
|
|
b: "\\b(0b[01']+)"
|
|
}, {
|
|
b: "(-?)\\b([\\d']+(\\.[\\d']*)?|\\.[\\d']+)(u|U|l|L|ul|UL|f|F|b|B)"
|
|
}, {
|
|
b: "(-?)(\\b0[xX][a-fA-F0-9']+|(\\b[\\d']+(\\.[\\d']*)?|\\.[\\d']+)([eE][-+]?[\\d']+)?)"
|
|
}],
|
|
r: 0
|
|
},
|
|
i = {
|
|
cN: "meta",
|
|
b: /#\s*[a-z]+\b/,
|
|
e: /$/,
|
|
k: {
|
|
"meta-keyword": "zzzzzzdisable"
|
|
},
|
|
c: [{
|
|
b: /\\\n/,
|
|
r: 0
|
|
}, t.inherit(r, {
|
|
cN: "meta-string"
|
|
}), {
|
|
cN: "meta-string",
|
|
b: /<[^\n>]*>/,
|
|
e: /$/,
|
|
i: "\\n"
|
|
}, t.CLCM, t.CBCM]
|
|
},
|
|
a = t.IR + "\\s*\\(",
|
|
c = {
|
|
keyword: "const align var extern stdcallcc nakedcc volatile export pub noalias inline struct packed enum union break return try catch test continue unreachable comptime and or asm defer errdefer if else switch while for fn use bool f32 f64 void type noreturn error i8 u8 i16 u16 i32 u32 i64 u64 isize usize i8w u8w i16w i32w u32w i64w u64w isizew usizew c_short c_ushort c_int c_uint c_long c_ulong c_longlong c_ulonglong",
|
|
built_in: "breakpoint returnAddress frameAddress fieldParentPtr setFloatMode IntType OpaqueType compileError compileLog setCold setRuntimeSafety setEvalBranchQuota offsetOf memcpy inlineCall setGlobalLinkage setGlobalSection divTrunc divFloor enumTagName intToPtr ptrToInt panic canImplicitCast ptrCast bitCast rem mod memset sizeOf alignOf alignCast maxValue minValue memberCount memberName memberType typeOf addWithOverflow subWithOverflow mulWithOverflow shlWithOverflow shlExact shrExact cInclude cDefine cUndef ctz clz import cImport errorName embedFile cmpxchg fence divExact truncate atomicRmw",
|
|
literal: "true false null undefined"
|
|
},
|
|
n = [e, t.CLCM, t.CBCM, s, r];
|
|
return {
|
|
aliases: ["c", "cc", "h", "c++", "h++", "hpp"],
|
|
k: c,
|
|
i: "</",
|
|
c: n.concat([i, {
|
|
b: "\\b(deque|list|queue|stack|vector|map|set|bitset|multiset|multimap|unordered_map|unordered_set|unordered_multiset|unordered_multimap|array)\\s*<",
|
|
e: ">",
|
|
k: c,
|
|
c: ["self", e]
|
|
}, {
|
|
b: t.IR + "::",
|
|
k: c
|
|
}, {
|
|
v: [{
|
|
b: /=/,
|
|
e: /;/
|
|
}, {
|
|
b: /\(/,
|
|
e: /\)/
|
|
}, {
|
|
bK: "new throw return else",
|
|
e: /;/
|
|
}],
|
|
k: c,
|
|
c: n.concat([{
|
|
b: /\(/,
|
|
e: /\)/,
|
|
k: c,
|
|
c: n.concat(["self"]),
|
|
r: 0
|
|
}]),
|
|
r: 0
|
|
}, {
|
|
cN: "function",
|
|
b: "(" + t.IR + "[\\*&\\s]+)+" + a,
|
|
rB: !0,
|
|
e: /[{;=]/,
|
|
eE: !0,
|
|
k: c,
|
|
i: /[^\w\s\*&]/,
|
|
c: [{
|
|
b: a,
|
|
rB: !0,
|
|
c: [t.TM],
|
|
r: 0
|
|
}, {
|
|
cN: "params",
|
|
b: /\(/,
|
|
e: /\)/,
|
|
k: c,
|
|
r: 0,
|
|
c: [t.CLCM, t.CBCM, r, s, e]
|
|
}, t.CLCM, t.CBCM, i]
|
|
}, {
|
|
cN: "class",
|
|
bK: "class struct",
|
|
e: /[{;:]/,
|
|
c: [{
|
|
b: /</,
|
|
e: />/,
|
|
c: ["self"]
|
|
}, t.TM]
|
|
}]),
|
|
exports: {
|
|
preprocessor: i,
|
|
strings: r,
|
|
k: c
|
|
}
|
|
}
|
|
});
|
|
hljs.initHighlightingOnLoad();
|
|
</script>
|
|
</body>
|
|
</html>
|