Unnamed: 0
int64 0
0
| repo_id
stringlengths 5
186
| file_path
stringlengths 15
223
| content
stringlengths 1
32.8M
⌀ |
|---|---|---|---|
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/math/powi.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>math/powi.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-comment">// Based on Rust, which is licensed under the MIT license.</span>
</span>
<span class="line" id="L2"><span class="tok-comment">// https://github.com/rust-lang/rust/blob/360432f1e8794de58cd94f34c9c17ad65871e5b5/LICENSE-MIT</span>
</span>
<span class="line" id="L3"><span class="tok-comment">//</span>
</span>
<span class="line" id="L4"><span class="tok-comment">// https://github.com/rust-lang/rust/blob/360432f1e8794de58cd94f34c9c17ad65871e5b5/src/libcore/num/mod.rs#L3423</span>
</span>
<span class="line" id="L5"></span>
<span class="line" id="L6"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../std.zig"</span>);</span>
<span class="line" id="L7"><span class="tok-kw">const</span> math = std.math;</span>
<span class="line" id="L8"><span class="tok-kw">const</span> assert = std.debug.assert;</span>
<span class="line" id="L9"><span class="tok-kw">const</span> testing = std.testing;</span>
<span class="line" id="L10"></span>
<span class="line" id="L11"><span class="tok-comment">/// Returns the power of x raised by the integer y (x^y).</span></span>
<span class="line" id="L12"><span class="tok-comment">///</span></span>
<span class="line" id="L13"><span class="tok-comment">/// Errors:</span></span>
<span class="line" id="L14"><span class="tok-comment">/// - Overflow: Integer overflow or Infinity</span></span>
<span class="line" id="L15"><span class="tok-comment">/// - Underflow: Absolute value of result smaller than 1</span></span>
<span class="line" id="L16"><span class="tok-comment">/// Edge case rules ordered by precedence:</span></span>
<span class="line" id="L17"><span class="tok-comment">/// - powi(T, x, 0) = 1 unless T is i1, i0, u0</span></span>
<span class="line" id="L18"><span class="tok-comment">/// - powi(T, 0, x) = 0 when x > 0</span></span>
<span class="line" id="L19"><span class="tok-comment">/// - powi(T, 0, x) = Overflow</span></span>
<span class="line" id="L20"><span class="tok-comment">/// - powi(T, 1, y) = 1</span></span>
<span class="line" id="L21"><span class="tok-comment">/// - powi(T, -1, y) = -1 for y an odd integer</span></span>
<span class="line" id="L22"><span class="tok-comment">/// - powi(T, -1, y) = 1 unless T is i1, i0, u0</span></span>
<span class="line" id="L23"><span class="tok-comment">/// - powi(T, -1, y) = Overflow</span></span>
<span class="line" id="L24"><span class="tok-comment">/// - powi(T, x, y) = Overflow when y >= @bitSizeOf(x)</span></span>
<span class="line" id="L25"><span class="tok-comment">/// - powi(T, x, y) = Underflow when y < 0</span></span>
<span class="line" id="L26"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">powi</span>(<span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>, x: T, y: T) (<span class="tok-kw">error</span>{</span>
<span class="line" id="L27"> Overflow,</span>
<span class="line" id="L28"> Underflow,</span>
<span class="line" id="L29">}!T) {</span>
<span class="line" id="L30"> <span class="tok-kw">const</span> bit_size = <span class="tok-builtin">@typeInfo</span>(T).Int.bits;</span>
<span class="line" id="L31"></span>
<span class="line" id="L32"> <span class="tok-comment">// `y & 1 == 0` won't compile when `does_one_overflow`.</span>
</span>
<span class="line" id="L33"> <span class="tok-kw">const</span> does_one_overflow = math.maxInt(T) < <span class="tok-number">1</span>;</span>
<span class="line" id="L34"> <span class="tok-kw">const</span> is_y_even = !does_one_overflow <span class="tok-kw">and</span> y & <span class="tok-number">1</span> == <span class="tok-number">0</span>;</span>
<span class="line" id="L35"></span>
<span class="line" id="L36"> <span class="tok-kw">if</span> (x == <span class="tok-number">1</span> <span class="tok-kw">or</span> y == <span class="tok-number">0</span> <span class="tok-kw">or</span> (x == -<span class="tok-number">1</span> <span class="tok-kw">and</span> is_y_even)) {</span>
<span class="line" id="L37"> <span class="tok-kw">if</span> (does_one_overflow) {</span>
<span class="line" id="L38"> <span class="tok-kw">return</span> <span class="tok-kw">error</span>.Overflow;</span>
<span class="line" id="L39"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L40"> <span class="tok-kw">return</span> <span class="tok-number">1</span>;</span>
<span class="line" id="L41"> }</span>
<span class="line" id="L42"> }</span>
<span class="line" id="L43"></span>
<span class="line" id="L44"> <span class="tok-kw">if</span> (x == -<span class="tok-number">1</span>) {</span>
<span class="line" id="L45"> <span class="tok-kw">return</span> -<span class="tok-number">1</span>;</span>
<span class="line" id="L46"> }</span>
<span class="line" id="L47"></span>
<span class="line" id="L48"> <span class="tok-kw">if</span> (x == <span class="tok-number">0</span>) {</span>
<span class="line" id="L49"> <span class="tok-kw">if</span> (y > <span class="tok-number">0</span>) {</span>
<span class="line" id="L50"> <span class="tok-kw">return</span> <span class="tok-number">0</span>;</span>
<span class="line" id="L51"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L52"> <span class="tok-comment">// Infinity/NaN, not overflow in strict sense</span>
</span>
<span class="line" id="L53"> <span class="tok-kw">return</span> <span class="tok-kw">error</span>.Overflow;</span>
<span class="line" id="L54"> }</span>
<span class="line" id="L55"> }</span>
<span class="line" id="L56"> <span class="tok-comment">// x >= 2 or x <= -2 from this point</span>
</span>
<span class="line" id="L57"> <span class="tok-kw">if</span> (y >= bit_size) {</span>
<span class="line" id="L58"> <span class="tok-kw">return</span> <span class="tok-kw">error</span>.Overflow;</span>
<span class="line" id="L59"> }</span>
<span class="line" id="L60"> <span class="tok-kw">if</span> (y < <span class="tok-number">0</span>) {</span>
<span class="line" id="L61"> <span class="tok-kw">return</span> <span class="tok-kw">error</span>.Underflow;</span>
<span class="line" id="L62"> }</span>
<span class="line" id="L63"></span>
<span class="line" id="L64"> <span class="tok-comment">// invariant :</span>
</span>
<span class="line" id="L65"> <span class="tok-comment">// return value = powi(T, base, exp) * acc;</span>
</span>
<span class="line" id="L66"></span>
<span class="line" id="L67"> <span class="tok-kw">var</span> base = x;</span>
<span class="line" id="L68"> <span class="tok-kw">var</span> exp = y;</span>
<span class="line" id="L69"> <span class="tok-kw">var</span> acc: T = <span class="tok-kw">if</span> (does_one_overflow) <span class="tok-kw">unreachable</span> <span class="tok-kw">else</span> <span class="tok-number">1</span>;</span>
<span class="line" id="L70"></span>
<span class="line" id="L71"> <span class="tok-kw">while</span> (exp > <span class="tok-number">1</span>) {</span>
<span class="line" id="L72"> <span class="tok-kw">if</span> (exp & <span class="tok-number">1</span> == <span class="tok-number">1</span>) {</span>
<span class="line" id="L73"> <span class="tok-kw">const</span> ov = <span class="tok-builtin">@mulWithOverflow</span>(acc, base);</span>
<span class="line" id="L74"> <span class="tok-kw">if</span> (ov[<span class="tok-number">1</span>] != <span class="tok-number">0</span>) <span class="tok-kw">return</span> <span class="tok-kw">error</span>.Overflow;</span>
<span class="line" id="L75"> acc = ov[<span class="tok-number">0</span>];</span>
<span class="line" id="L76"> }</span>
<span class="line" id="L77"></span>
<span class="line" id="L78"> exp >>= <span class="tok-number">1</span>;</span>
<span class="line" id="L79"></span>
<span class="line" id="L80"> <span class="tok-kw">const</span> ov = <span class="tok-builtin">@mulWithOverflow</span>(base, base);</span>
<span class="line" id="L81"> <span class="tok-kw">if</span> (ov[<span class="tok-number">1</span>] != <span class="tok-number">0</span>) <span class="tok-kw">return</span> <span class="tok-kw">error</span>.Overflow;</span>
<span class="line" id="L82"> base = ov[<span class="tok-number">0</span>];</span>
<span class="line" id="L83"> }</span>
<span class="line" id="L84"></span>
<span class="line" id="L85"> <span class="tok-kw">if</span> (exp == <span class="tok-number">1</span>) {</span>
<span class="line" id="L86"> <span class="tok-kw">const</span> ov = <span class="tok-builtin">@mulWithOverflow</span>(acc, base);</span>
<span class="line" id="L87"> <span class="tok-kw">if</span> (ov[<span class="tok-number">1</span>] != <span class="tok-number">0</span>) <span class="tok-kw">return</span> <span class="tok-kw">error</span>.Overflow;</span>
<span class="line" id="L88"> acc = ov[<span class="tok-number">0</span>];</span>
<span class="line" id="L89"> }</span>
<span class="line" id="L90"></span>
<span class="line" id="L91"> <span class="tok-kw">return</span> acc;</span>
<span class="line" id="L92">}</span>
<span class="line" id="L93"></span>
<span class="line" id="L94"><span class="tok-kw">test</span> <span class="tok-str">"math.powi"</span> {</span>
<span class="line" id="L95"> <span class="tok-kw">try</span> testing.expectError(<span class="tok-kw">error</span>.Overflow, powi(<span class="tok-type">i8</span>, -<span class="tok-number">66</span>, <span class="tok-number">6</span>));</span>
<span class="line" id="L96"> <span class="tok-kw">try</span> testing.expectError(<span class="tok-kw">error</span>.Overflow, powi(<span class="tok-type">i16</span>, -<span class="tok-number">13</span>, <span class="tok-number">13</span>));</span>
<span class="line" id="L97"> <span class="tok-kw">try</span> testing.expectError(<span class="tok-kw">error</span>.Overflow, powi(<span class="tok-type">i32</span>, -<span class="tok-number">32</span>, <span class="tok-number">21</span>));</span>
<span class="line" id="L98"> <span class="tok-kw">try</span> testing.expectError(<span class="tok-kw">error</span>.Overflow, powi(<span class="tok-type">i64</span>, -<span class="tok-number">24</span>, <span class="tok-number">61</span>));</span>
<span class="line" id="L99"> <span class="tok-kw">try</span> testing.expectError(<span class="tok-kw">error</span>.Overflow, powi(<span class="tok-type">i17</span>, -<span class="tok-number">15</span>, <span class="tok-number">15</span>));</span>
<span class="line" id="L100"> <span class="tok-kw">try</span> testing.expectError(<span class="tok-kw">error</span>.Overflow, powi(<span class="tok-type">i42</span>, -<span class="tok-number">6</span>, <span class="tok-number">40</span>));</span>
<span class="line" id="L101"></span>
<span class="line" id="L102"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> powi(<span class="tok-type">i8</span>, -<span class="tok-number">5</span>, <span class="tok-number">3</span>)) == -<span class="tok-number">125</span>);</span>
<span class="line" id="L103"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> powi(<span class="tok-type">i16</span>, -<span class="tok-number">16</span>, <span class="tok-number">3</span>)) == -<span class="tok-number">4096</span>);</span>
<span class="line" id="L104"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> powi(<span class="tok-type">i32</span>, -<span class="tok-number">91</span>, <span class="tok-number">3</span>)) == -<span class="tok-number">753571</span>);</span>
<span class="line" id="L105"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> powi(<span class="tok-type">i64</span>, -<span class="tok-number">36</span>, <span class="tok-number">6</span>)) == <span class="tok-number">2176782336</span>);</span>
<span class="line" id="L106"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> powi(<span class="tok-type">i17</span>, -<span class="tok-number">2</span>, <span class="tok-number">15</span>)) == -<span class="tok-number">32768</span>);</span>
<span class="line" id="L107"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> powi(<span class="tok-type">i42</span>, -<span class="tok-number">5</span>, <span class="tok-number">7</span>)) == -<span class="tok-number">78125</span>);</span>
<span class="line" id="L108"></span>
<span class="line" id="L109"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> powi(<span class="tok-type">u8</span>, <span class="tok-number">6</span>, <span class="tok-number">2</span>)) == <span class="tok-number">36</span>);</span>
<span class="line" id="L110"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> powi(<span class="tok-type">u16</span>, <span class="tok-number">5</span>, <span class="tok-number">4</span>)) == <span class="tok-number">625</span>);</span>
<span class="line" id="L111"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> powi(<span class="tok-type">u32</span>, <span class="tok-number">12</span>, <span class="tok-number">6</span>)) == <span class="tok-number">2985984</span>);</span>
<span class="line" id="L112"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> powi(<span class="tok-type">u64</span>, <span class="tok-number">34</span>, <span class="tok-number">2</span>)) == <span class="tok-number">1156</span>);</span>
<span class="line" id="L113"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> powi(<span class="tok-type">u17</span>, <span class="tok-number">16</span>, <span class="tok-number">3</span>)) == <span class="tok-number">4096</span>);</span>
<span class="line" id="L114"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> powi(<span class="tok-type">u42</span>, <span class="tok-number">34</span>, <span class="tok-number">6</span>)) == <span class="tok-number">1544804416</span>);</span>
<span class="line" id="L115"></span>
<span class="line" id="L116"> <span class="tok-kw">try</span> testing.expectError(<span class="tok-kw">error</span>.Overflow, powi(<span class="tok-type">i8</span>, <span class="tok-number">120</span>, <span class="tok-number">7</span>));</span>
<span class="line" id="L117"> <span class="tok-kw">try</span> testing.expectError(<span class="tok-kw">error</span>.Overflow, powi(<span class="tok-type">i16</span>, <span class="tok-number">73</span>, <span class="tok-number">15</span>));</span>
<span class="line" id="L118"> <span class="tok-kw">try</span> testing.expectError(<span class="tok-kw">error</span>.Overflow, powi(<span class="tok-type">i32</span>, <span class="tok-number">23</span>, <span class="tok-number">31</span>));</span>
<span class="line" id="L119"> <span class="tok-kw">try</span> testing.expectError(<span class="tok-kw">error</span>.Overflow, powi(<span class="tok-type">i64</span>, <span class="tok-number">68</span>, <span class="tok-number">61</span>));</span>
<span class="line" id="L120"> <span class="tok-kw">try</span> testing.expectError(<span class="tok-kw">error</span>.Overflow, powi(<span class="tok-type">i17</span>, <span class="tok-number">15</span>, <span class="tok-number">15</span>));</span>
<span class="line" id="L121"> <span class="tok-kw">try</span> testing.expectError(<span class="tok-kw">error</span>.Overflow, powi(<span class="tok-type">i42</span>, <span class="tok-number">121312</span>, <span class="tok-number">41</span>));</span>
<span class="line" id="L122"></span>
<span class="line" id="L123"> <span class="tok-kw">try</span> testing.expectError(<span class="tok-kw">error</span>.Overflow, powi(<span class="tok-type">u8</span>, <span class="tok-number">123</span>, <span class="tok-number">7</span>));</span>
<span class="line" id="L124"> <span class="tok-kw">try</span> testing.expectError(<span class="tok-kw">error</span>.Overflow, powi(<span class="tok-type">u16</span>, <span class="tok-number">2313</span>, <span class="tok-number">15</span>));</span>
<span class="line" id="L125"> <span class="tok-kw">try</span> testing.expectError(<span class="tok-kw">error</span>.Overflow, powi(<span class="tok-type">u32</span>, <span class="tok-number">8968</span>, <span class="tok-number">31</span>));</span>
<span class="line" id="L126"> <span class="tok-kw">try</span> testing.expectError(<span class="tok-kw">error</span>.Overflow, powi(<span class="tok-type">u64</span>, <span class="tok-number">2342</span>, <span class="tok-number">63</span>));</span>
<span class="line" id="L127"> <span class="tok-kw">try</span> testing.expectError(<span class="tok-kw">error</span>.Overflow, powi(<span class="tok-type">u17</span>, <span class="tok-number">2723</span>, <span class="tok-number">16</span>));</span>
<span class="line" id="L128"> <span class="tok-kw">try</span> testing.expectError(<span class="tok-kw">error</span>.Overflow, powi(<span class="tok-type">u42</span>, <span class="tok-number">8234</span>, <span class="tok-number">41</span>));</span>
<span class="line" id="L129"></span>
<span class="line" id="L130"> <span class="tok-kw">const</span> minInt = std.math.minInt;</span>
<span class="line" id="L131"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> powi(<span class="tok-type">i8</span>, -<span class="tok-number">2</span>, <span class="tok-number">7</span>)) == minInt(<span class="tok-type">i8</span>));</span>
<span class="line" id="L132"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> powi(<span class="tok-type">i16</span>, -<span class="tok-number">2</span>, <span class="tok-number">15</span>)) == minInt(<span class="tok-type">i16</span>));</span>
<span class="line" id="L133"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> powi(<span class="tok-type">i32</span>, -<span class="tok-number">2</span>, <span class="tok-number">31</span>)) == minInt(<span class="tok-type">i32</span>));</span>
<span class="line" id="L134"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> powi(<span class="tok-type">i64</span>, -<span class="tok-number">2</span>, <span class="tok-number">63</span>)) == minInt(<span class="tok-type">i64</span>));</span>
<span class="line" id="L135"></span>
<span class="line" id="L136"> <span class="tok-kw">try</span> testing.expectError(<span class="tok-kw">error</span>.Underflow, powi(<span class="tok-type">i8</span>, <span class="tok-number">6</span>, -<span class="tok-number">2</span>));</span>
<span class="line" id="L137"> <span class="tok-kw">try</span> testing.expectError(<span class="tok-kw">error</span>.Underflow, powi(<span class="tok-type">i16</span>, <span class="tok-number">5</span>, -<span class="tok-number">4</span>));</span>
<span class="line" id="L138"> <span class="tok-kw">try</span> testing.expectError(<span class="tok-kw">error</span>.Underflow, powi(<span class="tok-type">i32</span>, <span class="tok-number">12</span>, -<span class="tok-number">6</span>));</span>
<span class="line" id="L139"> <span class="tok-kw">try</span> testing.expectError(<span class="tok-kw">error</span>.Underflow, powi(<span class="tok-type">i64</span>, <span class="tok-number">34</span>, -<span class="tok-number">2</span>));</span>
<span class="line" id="L140"> <span class="tok-kw">try</span> testing.expectError(<span class="tok-kw">error</span>.Underflow, powi(<span class="tok-type">i17</span>, <span class="tok-number">16</span>, -<span class="tok-number">3</span>));</span>
<span class="line" id="L141"> <span class="tok-kw">try</span> testing.expectError(<span class="tok-kw">error</span>.Underflow, powi(<span class="tok-type">i42</span>, <span class="tok-number">34</span>, -<span class="tok-number">6</span>));</span>
<span class="line" id="L142">}</span>
<span class="line" id="L143"></span>
<span class="line" id="L144"><span class="tok-kw">test</span> <span class="tok-str">"math.powi.special"</span> {</span>
<span class="line" id="L145"> <span class="tok-kw">try</span> testing.expectError(<span class="tok-kw">error</span>.Overflow, powi(<span class="tok-type">i8</span>, -<span class="tok-number">2</span>, <span class="tok-number">8</span>));</span>
<span class="line" id="L146"> <span class="tok-kw">try</span> testing.expectError(<span class="tok-kw">error</span>.Overflow, powi(<span class="tok-type">i16</span>, -<span class="tok-number">2</span>, <span class="tok-number">16</span>));</span>
<span class="line" id="L147"> <span class="tok-kw">try</span> testing.expectError(<span class="tok-kw">error</span>.Overflow, powi(<span class="tok-type">i32</span>, -<span class="tok-number">2</span>, <span class="tok-number">32</span>));</span>
<span class="line" id="L148"> <span class="tok-kw">try</span> testing.expectError(<span class="tok-kw">error</span>.Overflow, powi(<span class="tok-type">i64</span>, -<span class="tok-number">2</span>, <span class="tok-number">64</span>));</span>
<span class="line" id="L149"> <span class="tok-kw">try</span> testing.expectError(<span class="tok-kw">error</span>.Overflow, powi(<span class="tok-type">i17</span>, -<span class="tok-number">2</span>, <span class="tok-number">17</span>));</span>
<span class="line" id="L150"> <span class="tok-kw">try</span> testing.expectError(<span class="tok-kw">error</span>.Overflow, powi(<span class="tok-type">i17</span>, -<span class="tok-number">2</span>, <span class="tok-number">16</span>));</span>
<span class="line" id="L151"> <span class="tok-kw">try</span> testing.expectError(<span class="tok-kw">error</span>.Overflow, powi(<span class="tok-type">i42</span>, -<span class="tok-number">2</span>, <span class="tok-number">42</span>));</span>
<span class="line" id="L152"></span>
<span class="line" id="L153"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> powi(<span class="tok-type">i8</span>, -<span class="tok-number">1</span>, <span class="tok-number">3</span>)) == -<span class="tok-number">1</span>);</span>
<span class="line" id="L154"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> powi(<span class="tok-type">i16</span>, -<span class="tok-number">1</span>, <span class="tok-number">2</span>)) == <span class="tok-number">1</span>);</span>
<span class="line" id="L155"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> powi(<span class="tok-type">i32</span>, -<span class="tok-number">1</span>, <span class="tok-number">16</span>)) == <span class="tok-number">1</span>);</span>
<span class="line" id="L156"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> powi(<span class="tok-type">i64</span>, -<span class="tok-number">1</span>, <span class="tok-number">6</span>)) == <span class="tok-number">1</span>);</span>
<span class="line" id="L157"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> powi(<span class="tok-type">i17</span>, -<span class="tok-number">1</span>, <span class="tok-number">15</span>)) == -<span class="tok-number">1</span>);</span>
<span class="line" id="L158"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> powi(<span class="tok-type">i42</span>, -<span class="tok-number">1</span>, <span class="tok-number">7</span>)) == -<span class="tok-number">1</span>);</span>
<span class="line" id="L159"></span>
<span class="line" id="L160"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> powi(<span class="tok-type">u8</span>, <span class="tok-number">1</span>, <span class="tok-number">2</span>)) == <span class="tok-number">1</span>);</span>
<span class="line" id="L161"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> powi(<span class="tok-type">u16</span>, <span class="tok-number">1</span>, <span class="tok-number">4</span>)) == <span class="tok-number">1</span>);</span>
<span class="line" id="L162"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> powi(<span class="tok-type">u32</span>, <span class="tok-number">1</span>, <span class="tok-number">6</span>)) == <span class="tok-number">1</span>);</span>
<span class="line" id="L163"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> powi(<span class="tok-type">u64</span>, <span class="tok-number">1</span>, <span class="tok-number">2</span>)) == <span class="tok-number">1</span>);</span>
<span class="line" id="L164"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> powi(<span class="tok-type">u17</span>, <span class="tok-number">1</span>, <span class="tok-number">3</span>)) == <span class="tok-number">1</span>);</span>
<span class="line" id="L165"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> powi(<span class="tok-type">u42</span>, <span class="tok-number">1</span>, <span class="tok-number">6</span>)) == <span class="tok-number">1</span>);</span>
<span class="line" id="L166"></span>
<span class="line" id="L167"> <span class="tok-kw">try</span> testing.expectError(<span class="tok-kw">error</span>.Overflow, powi(<span class="tok-type">i8</span>, <span class="tok-number">2</span>, <span class="tok-number">7</span>));</span>
<span class="line" id="L168"> <span class="tok-kw">try</span> testing.expectError(<span class="tok-kw">error</span>.Overflow, powi(<span class="tok-type">i16</span>, <span class="tok-number">2</span>, <span class="tok-number">15</span>));</span>
<span class="line" id="L169"> <span class="tok-kw">try</span> testing.expectError(<span class="tok-kw">error</span>.Overflow, powi(<span class="tok-type">i32</span>, <span class="tok-number">2</span>, <span class="tok-number">31</span>));</span>
<span class="line" id="L170"> <span class="tok-kw">try</span> testing.expectError(<span class="tok-kw">error</span>.Overflow, powi(<span class="tok-type">i64</span>, <span class="tok-number">2</span>, <span class="tok-number">63</span>));</span>
<span class="line" id="L171"> <span class="tok-kw">try</span> testing.expectError(<span class="tok-kw">error</span>.Overflow, powi(<span class="tok-type">i17</span>, <span class="tok-number">2</span>, <span class="tok-number">16</span>));</span>
<span class="line" id="L172"> <span class="tok-kw">try</span> testing.expectError(<span class="tok-kw">error</span>.Overflow, powi(<span class="tok-type">i42</span>, <span class="tok-number">2</span>, <span class="tok-number">41</span>));</span>
<span class="line" id="L173"></span>
<span class="line" id="L174"> <span class="tok-kw">try</span> testing.expectError(<span class="tok-kw">error</span>.Overflow, powi(<span class="tok-type">u8</span>, <span class="tok-number">2</span>, <span class="tok-number">8</span>));</span>
<span class="line" id="L175"> <span class="tok-kw">try</span> testing.expectError(<span class="tok-kw">error</span>.Overflow, powi(<span class="tok-type">u16</span>, <span class="tok-number">2</span>, <span class="tok-number">16</span>));</span>
<span class="line" id="L176"> <span class="tok-kw">try</span> testing.expectError(<span class="tok-kw">error</span>.Overflow, powi(<span class="tok-type">u32</span>, <span class="tok-number">2</span>, <span class="tok-number">32</span>));</span>
<span class="line" id="L177"> <span class="tok-kw">try</span> testing.expectError(<span class="tok-kw">error</span>.Overflow, powi(<span class="tok-type">u64</span>, <span class="tok-number">2</span>, <span class="tok-number">64</span>));</span>
<span class="line" id="L178"> <span class="tok-kw">try</span> testing.expectError(<span class="tok-kw">error</span>.Overflow, powi(<span class="tok-type">u17</span>, <span class="tok-number">2</span>, <span class="tok-number">17</span>));</span>
<span class="line" id="L179"> <span class="tok-kw">try</span> testing.expectError(<span class="tok-kw">error</span>.Overflow, powi(<span class="tok-type">u42</span>, <span class="tok-number">2</span>, <span class="tok-number">42</span>));</span>
<span class="line" id="L180"></span>
<span class="line" id="L181"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> powi(<span class="tok-type">u8</span>, <span class="tok-number">6</span>, <span class="tok-number">0</span>)) == <span class="tok-number">1</span>);</span>
<span class="line" id="L182"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> powi(<span class="tok-type">u16</span>, <span class="tok-number">5</span>, <span class="tok-number">0</span>)) == <span class="tok-number">1</span>);</span>
<span class="line" id="L183"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> powi(<span class="tok-type">u32</span>, <span class="tok-number">12</span>, <span class="tok-number">0</span>)) == <span class="tok-number">1</span>);</span>
<span class="line" id="L184"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> powi(<span class="tok-type">u64</span>, <span class="tok-number">34</span>, <span class="tok-number">0</span>)) == <span class="tok-number">1</span>);</span>
<span class="line" id="L185"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> powi(<span class="tok-type">u17</span>, <span class="tok-number">16</span>, <span class="tok-number">0</span>)) == <span class="tok-number">1</span>);</span>
<span class="line" id="L186"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> powi(<span class="tok-type">u42</span>, <span class="tok-number">34</span>, <span class="tok-number">0</span>)) == <span class="tok-number">1</span>);</span>
<span class="line" id="L187">}</span>
<span class="line" id="L188"></span>
<span class="line" id="L189"><span class="tok-kw">test</span> <span class="tok-str">"math.powi.narrow"</span> {</span>
<span class="line" id="L190"> <span class="tok-kw">try</span> testing.expectError(<span class="tok-kw">error</span>.Overflow, powi(<span class="tok-type">u0</span>, <span class="tok-number">0</span>, <span class="tok-number">0</span>));</span>
<span class="line" id="L191"> <span class="tok-kw">try</span> testing.expectError(<span class="tok-kw">error</span>.Overflow, powi(<span class="tok-type">i0</span>, <span class="tok-number">0</span>, <span class="tok-number">0</span>));</span>
<span class="line" id="L192"> <span class="tok-kw">try</span> testing.expectError(<span class="tok-kw">error</span>.Overflow, powi(<span class="tok-type">i1</span>, <span class="tok-number">0</span>, <span class="tok-number">0</span>));</span>
<span class="line" id="L193"> <span class="tok-kw">try</span> testing.expectError(<span class="tok-kw">error</span>.Overflow, powi(<span class="tok-type">i1</span>, -<span class="tok-number">1</span>, <span class="tok-number">0</span>));</span>
<span class="line" id="L194"> <span class="tok-kw">try</span> testing.expectError(<span class="tok-kw">error</span>.Overflow, powi(<span class="tok-type">i1</span>, <span class="tok-number">0</span>, -<span class="tok-number">1</span>));</span>
<span class="line" id="L195"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> powi(<span class="tok-type">i1</span>, -<span class="tok-number">1</span>, -<span class="tok-number">1</span>)) == -<span class="tok-number">1</span>);</span>
<span class="line" id="L196">}</span>
<span class="line" id="L197"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/math/cbrt.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>math/cbrt.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-comment">// Ported from musl, which is licensed under the MIT license:</span>
</span>
<span class="line" id="L2"><span class="tok-comment">// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT</span>
</span>
<span class="line" id="L3"><span class="tok-comment">//</span>
</span>
<span class="line" id="L4"><span class="tok-comment">// https://git.musl-libc.org/cgit/musl/tree/src/math/cbrtf.c</span>
</span>
<span class="line" id="L5"><span class="tok-comment">// https://git.musl-libc.org/cgit/musl/tree/src/math/cbrt.c</span>
</span>
<span class="line" id="L6"></span>
<span class="line" id="L7"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../std.zig"</span>);</span>
<span class="line" id="L8"><span class="tok-kw">const</span> math = std.math;</span>
<span class="line" id="L9"><span class="tok-kw">const</span> expect = std.testing.expect;</span>
<span class="line" id="L10"></span>
<span class="line" id="L11"><span class="tok-comment">/// Returns the cube root of x.</span></span>
<span class="line" id="L12"><span class="tok-comment">///</span></span>
<span class="line" id="L13"><span class="tok-comment">/// Special Cases:</span></span>
<span class="line" id="L14"><span class="tok-comment">/// - cbrt(+-0) = +-0</span></span>
<span class="line" id="L15"><span class="tok-comment">/// - cbrt(+-inf) = +-inf</span></span>
<span class="line" id="L16"><span class="tok-comment">/// - cbrt(nan) = nan</span></span>
<span class="line" id="L17"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">cbrt</span>(x: <span class="tok-kw">anytype</span>) <span class="tok-builtin">@TypeOf</span>(x) {</span>
<span class="line" id="L18"> <span class="tok-kw">const</span> T = <span class="tok-builtin">@TypeOf</span>(x);</span>
<span class="line" id="L19"> <span class="tok-kw">return</span> <span class="tok-kw">switch</span> (T) {</span>
<span class="line" id="L20"> <span class="tok-type">f32</span> => cbrt32(x),</span>
<span class="line" id="L21"> <span class="tok-type">f64</span> => cbrt64(x),</span>
<span class="line" id="L22"> <span class="tok-kw">else</span> => <span class="tok-builtin">@compileError</span>(<span class="tok-str">"cbrt not implemented for "</span> ++ <span class="tok-builtin">@typeName</span>(T)),</span>
<span class="line" id="L23"> };</span>
<span class="line" id="L24">}</span>
<span class="line" id="L25"></span>
<span class="line" id="L26"><span class="tok-kw">fn</span> <span class="tok-fn">cbrt32</span>(x: <span class="tok-type">f32</span>) <span class="tok-type">f32</span> {</span>
<span class="line" id="L27"> <span class="tok-kw">const</span> B1: <span class="tok-type">u32</span> = <span class="tok-number">709958130</span>; <span class="tok-comment">// (127 - 127.0 / 3 - 0.03306235651) * 2^23</span>
</span>
<span class="line" id="L28"> <span class="tok-kw">const</span> B2: <span class="tok-type">u32</span> = <span class="tok-number">642849266</span>; <span class="tok-comment">// (127 - 127.0 / 3 - 24 / 3 - 0.03306235651) * 2^23</span>
</span>
<span class="line" id="L29"></span>
<span class="line" id="L30"> <span class="tok-kw">var</span> u = <span class="tok-builtin">@as</span>(<span class="tok-type">u32</span>, <span class="tok-builtin">@bitCast</span>(x));</span>
<span class="line" id="L31"> <span class="tok-kw">var</span> hx = u & <span class="tok-number">0x7FFFFFFF</span>;</span>
<span class="line" id="L32"></span>
<span class="line" id="L33"> <span class="tok-comment">// cbrt(nan, inf) = itself</span>
</span>
<span class="line" id="L34"> <span class="tok-kw">if</span> (hx >= <span class="tok-number">0x7F800000</span>) {</span>
<span class="line" id="L35"> <span class="tok-kw">return</span> x + x;</span>
<span class="line" id="L36"> }</span>
<span class="line" id="L37"></span>
<span class="line" id="L38"> <span class="tok-comment">// cbrt to ~5bits</span>
</span>
<span class="line" id="L39"> <span class="tok-kw">if</span> (hx < <span class="tok-number">0x00800000</span>) {</span>
<span class="line" id="L40"> <span class="tok-comment">// cbrt(+-0) = itself</span>
</span>
<span class="line" id="L41"> <span class="tok-kw">if</span> (hx == <span class="tok-number">0</span>) {</span>
<span class="line" id="L42"> <span class="tok-kw">return</span> x;</span>
<span class="line" id="L43"> }</span>
<span class="line" id="L44"> u = <span class="tok-builtin">@as</span>(<span class="tok-type">u32</span>, <span class="tok-builtin">@bitCast</span>(x * <span class="tok-number">0x1.0p24</span>));</span>
<span class="line" id="L45"> hx = u & <span class="tok-number">0x7FFFFFFF</span>;</span>
<span class="line" id="L46"> hx = hx / <span class="tok-number">3</span> + B2;</span>
<span class="line" id="L47"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L48"> hx = hx / <span class="tok-number">3</span> + B1;</span>
<span class="line" id="L49"> }</span>
<span class="line" id="L50"></span>
<span class="line" id="L51"> u &= <span class="tok-number">0x80000000</span>;</span>
<span class="line" id="L52"> u |= hx;</span>
<span class="line" id="L53"></span>
<span class="line" id="L54"> <span class="tok-comment">// first step newton to 16 bits</span>
</span>
<span class="line" id="L55"> <span class="tok-kw">var</span> t: <span class="tok-type">f64</span> = <span class="tok-builtin">@as</span>(<span class="tok-type">f32</span>, <span class="tok-builtin">@bitCast</span>(u));</span>
<span class="line" id="L56"> <span class="tok-kw">var</span> r: <span class="tok-type">f64</span> = t * t * t;</span>
<span class="line" id="L57"> t = t * (<span class="tok-builtin">@as</span>(<span class="tok-type">f64</span>, x) + x + r) / (x + r + r);</span>
<span class="line" id="L58"></span>
<span class="line" id="L59"> <span class="tok-comment">// second step newton to 47 bits</span>
</span>
<span class="line" id="L60"> r = t * t * t;</span>
<span class="line" id="L61"> t = t * (<span class="tok-builtin">@as</span>(<span class="tok-type">f64</span>, x) + x + r) / (x + r + r);</span>
<span class="line" id="L62"></span>
<span class="line" id="L63"> <span class="tok-kw">return</span> <span class="tok-builtin">@as</span>(<span class="tok-type">f32</span>, <span class="tok-builtin">@floatCast</span>(t));</span>
<span class="line" id="L64">}</span>
<span class="line" id="L65"></span>
<span class="line" id="L66"><span class="tok-kw">fn</span> <span class="tok-fn">cbrt64</span>(x: <span class="tok-type">f64</span>) <span class="tok-type">f64</span> {</span>
<span class="line" id="L67"> <span class="tok-kw">const</span> B1: <span class="tok-type">u32</span> = <span class="tok-number">715094163</span>; <span class="tok-comment">// (1023 - 1023 / 3 - 0.03306235651 * 2^20</span>
</span>
<span class="line" id="L68"> <span class="tok-kw">const</span> B2: <span class="tok-type">u32</span> = <span class="tok-number">696219795</span>; <span class="tok-comment">// (1023 - 1023 / 3 - 54 / 3 - 0.03306235651 * 2^20</span>
</span>
<span class="line" id="L69"></span>
<span class="line" id="L70"> <span class="tok-comment">// |1 / cbrt(x) - p(x)| < 2^(23.5)</span>
</span>
<span class="line" id="L71"> <span class="tok-kw">const</span> P0: <span class="tok-type">f64</span> = <span class="tok-number">1.87595182427177009643</span>;</span>
<span class="line" id="L72"> <span class="tok-kw">const</span> P1: <span class="tok-type">f64</span> = -<span class="tok-number">1.88497979543377169875</span>;</span>
<span class="line" id="L73"> <span class="tok-kw">const</span> P2: <span class="tok-type">f64</span> = <span class="tok-number">1.621429720105354466140</span>;</span>
<span class="line" id="L74"> <span class="tok-kw">const</span> P3: <span class="tok-type">f64</span> = -<span class="tok-number">0.758397934778766047437</span>;</span>
<span class="line" id="L75"> <span class="tok-kw">const</span> P4: <span class="tok-type">f64</span> = <span class="tok-number">0.145996192886612446982</span>;</span>
<span class="line" id="L76"></span>
<span class="line" id="L77"> <span class="tok-kw">var</span> u = <span class="tok-builtin">@as</span>(<span class="tok-type">u64</span>, <span class="tok-builtin">@bitCast</span>(x));</span>
<span class="line" id="L78"> <span class="tok-kw">var</span> hx = <span class="tok-builtin">@as</span>(<span class="tok-type">u32</span>, <span class="tok-builtin">@intCast</span>(u >> <span class="tok-number">32</span>)) & <span class="tok-number">0x7FFFFFFF</span>;</span>
<span class="line" id="L79"></span>
<span class="line" id="L80"> <span class="tok-comment">// cbrt(nan, inf) = itself</span>
</span>
<span class="line" id="L81"> <span class="tok-kw">if</span> (hx >= <span class="tok-number">0x7FF00000</span>) {</span>
<span class="line" id="L82"> <span class="tok-kw">return</span> x + x;</span>
<span class="line" id="L83"> }</span>
<span class="line" id="L84"></span>
<span class="line" id="L85"> <span class="tok-comment">// cbrt to ~5bits</span>
</span>
<span class="line" id="L86"> <span class="tok-kw">if</span> (hx < <span class="tok-number">0x00100000</span>) {</span>
<span class="line" id="L87"> u = <span class="tok-builtin">@as</span>(<span class="tok-type">u64</span>, <span class="tok-builtin">@bitCast</span>(x * <span class="tok-number">0x1.0p54</span>));</span>
<span class="line" id="L88"> hx = <span class="tok-builtin">@as</span>(<span class="tok-type">u32</span>, <span class="tok-builtin">@intCast</span>(u >> <span class="tok-number">32</span>)) & <span class="tok-number">0x7FFFFFFF</span>;</span>
<span class="line" id="L89"></span>
<span class="line" id="L90"> <span class="tok-comment">// cbrt(0) is itself</span>
</span>
<span class="line" id="L91"> <span class="tok-kw">if</span> (hx == <span class="tok-number">0</span>) {</span>
<span class="line" id="L92"> <span class="tok-kw">return</span> <span class="tok-number">0</span>;</span>
<span class="line" id="L93"> }</span>
<span class="line" id="L94"> hx = hx / <span class="tok-number">3</span> + B2;</span>
<span class="line" id="L95"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L96"> hx = hx / <span class="tok-number">3</span> + B1;</span>
<span class="line" id="L97"> }</span>
<span class="line" id="L98"></span>
<span class="line" id="L99"> u &= <span class="tok-number">1</span> << <span class="tok-number">63</span>;</span>
<span class="line" id="L100"> u |= <span class="tok-builtin">@as</span>(<span class="tok-type">u64</span>, hx) << <span class="tok-number">32</span>;</span>
<span class="line" id="L101"> <span class="tok-kw">var</span> t = <span class="tok-builtin">@as</span>(<span class="tok-type">f64</span>, <span class="tok-builtin">@bitCast</span>(u));</span>
<span class="line" id="L102"></span>
<span class="line" id="L103"> <span class="tok-comment">// cbrt to 23 bits</span>
</span>
<span class="line" id="L104"> <span class="tok-comment">// cbrt(x) = t * cbrt(x / t^3) ~= t * P(t^3 / x)</span>
</span>
<span class="line" id="L105"> <span class="tok-kw">var</span> r = (t * t) * (t / x);</span>
<span class="line" id="L106"> t = t * ((P0 + r * (P1 + r * P2)) + ((r * r) * r) * (P3 + r * P4));</span>
<span class="line" id="L107"></span>
<span class="line" id="L108"> <span class="tok-comment">// Round t away from 0 to 23 bits</span>
</span>
<span class="line" id="L109"> u = <span class="tok-builtin">@as</span>(<span class="tok-type">u64</span>, <span class="tok-builtin">@bitCast</span>(t));</span>
<span class="line" id="L110"> u = (u + <span class="tok-number">0x80000000</span>) & <span class="tok-number">0xFFFFFFFFC0000000</span>;</span>
<span class="line" id="L111"> t = <span class="tok-builtin">@as</span>(<span class="tok-type">f64</span>, <span class="tok-builtin">@bitCast</span>(u));</span>
<span class="line" id="L112"></span>
<span class="line" id="L113"> <span class="tok-comment">// one step newton to 53 bits</span>
</span>
<span class="line" id="L114"> <span class="tok-kw">const</span> s = t * t;</span>
<span class="line" id="L115"> <span class="tok-kw">var</span> q = x / s;</span>
<span class="line" id="L116"> <span class="tok-kw">var</span> w = t + t;</span>
<span class="line" id="L117"> q = (q - t) / (w + q);</span>
<span class="line" id="L118"></span>
<span class="line" id="L119"> <span class="tok-kw">return</span> t + t * q;</span>
<span class="line" id="L120">}</span>
<span class="line" id="L121"></span>
<span class="line" id="L122"><span class="tok-kw">test</span> <span class="tok-str">"math.cbrt"</span> {</span>
<span class="line" id="L123"> <span class="tok-kw">try</span> expect(cbrt(<span class="tok-builtin">@as</span>(<span class="tok-type">f32</span>, <span class="tok-number">0.0</span>)) == cbrt32(<span class="tok-number">0.0</span>));</span>
<span class="line" id="L124"> <span class="tok-kw">try</span> expect(cbrt(<span class="tok-builtin">@as</span>(<span class="tok-type">f64</span>, <span class="tok-number">0.0</span>)) == cbrt64(<span class="tok-number">0.0</span>));</span>
<span class="line" id="L125">}</span>
<span class="line" id="L126"></span>
<span class="line" id="L127"><span class="tok-kw">test</span> <span class="tok-str">"math.cbrt32"</span> {</span>
<span class="line" id="L128"> <span class="tok-kw">const</span> epsilon = <span class="tok-number">0.000001</span>;</span>
<span class="line" id="L129"></span>
<span class="line" id="L130"> <span class="tok-kw">try</span> expect(cbrt32(<span class="tok-number">0.0</span>) == <span class="tok-number">0.0</span>);</span>
<span class="line" id="L131"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f32</span>, cbrt32(<span class="tok-number">0.2</span>), <span class="tok-number">0.584804</span>, epsilon));</span>
<span class="line" id="L132"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f32</span>, cbrt32(<span class="tok-number">0.8923</span>), <span class="tok-number">0.962728</span>, epsilon));</span>
<span class="line" id="L133"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f32</span>, cbrt32(<span class="tok-number">1.5</span>), <span class="tok-number">1.144714</span>, epsilon));</span>
<span class="line" id="L134"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f32</span>, cbrt32(<span class="tok-number">37.45</span>), <span class="tok-number">3.345676</span>, epsilon));</span>
<span class="line" id="L135"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f32</span>, cbrt32(<span class="tok-number">123123.234375</span>), <span class="tok-number">49.748501</span>, epsilon));</span>
<span class="line" id="L136">}</span>
<span class="line" id="L137"></span>
<span class="line" id="L138"><span class="tok-kw">test</span> <span class="tok-str">"math.cbrt64"</span> {</span>
<span class="line" id="L139"> <span class="tok-kw">const</span> epsilon = <span class="tok-number">0.000001</span>;</span>
<span class="line" id="L140"></span>
<span class="line" id="L141"> <span class="tok-kw">try</span> expect(cbrt64(<span class="tok-number">0.0</span>) == <span class="tok-number">0.0</span>);</span>
<span class="line" id="L142"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f64</span>, cbrt64(<span class="tok-number">0.2</span>), <span class="tok-number">0.584804</span>, epsilon));</span>
<span class="line" id="L143"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f64</span>, cbrt64(<span class="tok-number">0.8923</span>), <span class="tok-number">0.962728</span>, epsilon));</span>
<span class="line" id="L144"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f64</span>, cbrt64(<span class="tok-number">1.5</span>), <span class="tok-number">1.144714</span>, epsilon));</span>
<span class="line" id="L145"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f64</span>, cbrt64(<span class="tok-number">37.45</span>), <span class="tok-number">3.345676</span>, epsilon));</span>
<span class="line" id="L146"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f64</span>, cbrt64(<span class="tok-number">123123.234375</span>), <span class="tok-number">49.748501</span>, epsilon));</span>
<span class="line" id="L147">}</span>
<span class="line" id="L148"></span>
<span class="line" id="L149"><span class="tok-kw">test</span> <span class="tok-str">"math.cbrt.special"</span> {</span>
<span class="line" id="L150"> <span class="tok-kw">try</span> expect(cbrt32(<span class="tok-number">0.0</span>) == <span class="tok-number">0.0</span>);</span>
<span class="line" id="L151"> <span class="tok-kw">try</span> expect(cbrt32(-<span class="tok-number">0.0</span>) == -<span class="tok-number">0.0</span>);</span>
<span class="line" id="L152"> <span class="tok-kw">try</span> expect(math.isPositiveInf(cbrt32(math.inf(<span class="tok-type">f32</span>))));</span>
<span class="line" id="L153"> <span class="tok-kw">try</span> expect(math.isNegativeInf(cbrt32(-math.inf(<span class="tok-type">f32</span>))));</span>
<span class="line" id="L154"> <span class="tok-kw">try</span> expect(math.isNan(cbrt32(math.nan(<span class="tok-type">f32</span>))));</span>
<span class="line" id="L155">}</span>
<span class="line" id="L156"></span>
<span class="line" id="L157"><span class="tok-kw">test</span> <span class="tok-str">"math.cbrt64.special"</span> {</span>
<span class="line" id="L158"> <span class="tok-kw">try</span> expect(cbrt64(<span class="tok-number">0.0</span>) == <span class="tok-number">0.0</span>);</span>
<span class="line" id="L159"> <span class="tok-kw">try</span> expect(cbrt64(-<span class="tok-number">0.0</span>) == -<span class="tok-number">0.0</span>);</span>
<span class="line" id="L160"> <span class="tok-kw">try</span> expect(math.isPositiveInf(cbrt64(math.inf(<span class="tok-type">f64</span>))));</span>
<span class="line" id="L161"> <span class="tok-kw">try</span> expect(math.isNegativeInf(cbrt64(-math.inf(<span class="tok-type">f64</span>))));</span>
<span class="line" id="L162"> <span class="tok-kw">try</span> expect(math.isNan(cbrt64(math.nan(<span class="tok-type">f64</span>))));</span>
<span class="line" id="L163">}</span>
<span class="line" id="L164"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/math/float.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>math/float.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../std.zig"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> assert = std.debug.assert;</span>
<span class="line" id="L3"><span class="tok-kw">const</span> expect = std.testing.expect;</span>
<span class="line" id="L4"></span>
<span class="line" id="L5"><span class="tok-comment">/// Creates a raw "1.0" mantissa for floating point type T. Used to dedupe f80 logic.</span></span>
<span class="line" id="L6"><span class="tok-kw">inline</span> <span class="tok-kw">fn</span> <span class="tok-fn">mantissaOne</span>(<span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>) <span class="tok-type">comptime_int</span> {</span>
<span class="line" id="L7"> <span class="tok-kw">return</span> <span class="tok-kw">if</span> (<span class="tok-builtin">@typeInfo</span>(T).Float.bits == <span class="tok-number">80</span>) <span class="tok-number">1</span> << floatFractionalBits(T) <span class="tok-kw">else</span> <span class="tok-number">0</span>;</span>
<span class="line" id="L8">}</span>
<span class="line" id="L9"></span>
<span class="line" id="L10"><span class="tok-comment">/// Creates floating point type T from an unbiased exponent and raw mantissa.</span></span>
<span class="line" id="L11"><span class="tok-kw">inline</span> <span class="tok-kw">fn</span> <span class="tok-fn">reconstructFloat</span>(<span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>, <span class="tok-kw">comptime</span> exponent: <span class="tok-type">comptime_int</span>, <span class="tok-kw">comptime</span> mantissa: <span class="tok-type">comptime_int</span>) T {</span>
<span class="line" id="L12"> <span class="tok-kw">const</span> TBits = <span class="tok-builtin">@Type</span>(.{ .Int = .{ .signedness = .unsigned, .bits = <span class="tok-builtin">@bitSizeOf</span>(T) } });</span>
<span class="line" id="L13"> <span class="tok-kw">const</span> biased_exponent = <span class="tok-builtin">@as</span>(TBits, exponent + floatExponentMax(T));</span>
<span class="line" id="L14"> <span class="tok-kw">return</span> <span class="tok-builtin">@as</span>(T, <span class="tok-builtin">@bitCast</span>((biased_exponent << floatMantissaBits(T)) | <span class="tok-builtin">@as</span>(TBits, mantissa)));</span>
<span class="line" id="L15">}</span>
<span class="line" id="L16"></span>
<span class="line" id="L17"><span class="tok-comment">/// Returns the number of bits in the exponent of floating point type T.</span></span>
<span class="line" id="L18"><span class="tok-kw">pub</span> <span class="tok-kw">inline</span> <span class="tok-kw">fn</span> <span class="tok-fn">floatExponentBits</span>(<span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>) <span class="tok-type">comptime_int</span> {</span>
<span class="line" id="L19"> <span class="tok-kw">comptime</span> assert(<span class="tok-builtin">@typeInfo</span>(T) == .Float);</span>
<span class="line" id="L20"></span>
<span class="line" id="L21"> <span class="tok-kw">return</span> <span class="tok-kw">switch</span> (<span class="tok-builtin">@typeInfo</span>(T).Float.bits) {</span>
<span class="line" id="L22"> <span class="tok-number">16</span> => <span class="tok-number">5</span>,</span>
<span class="line" id="L23"> <span class="tok-number">32</span> => <span class="tok-number">8</span>,</span>
<span class="line" id="L24"> <span class="tok-number">64</span> => <span class="tok-number">11</span>,</span>
<span class="line" id="L25"> <span class="tok-number">80</span> => <span class="tok-number">15</span>,</span>
<span class="line" id="L26"> <span class="tok-number">128</span> => <span class="tok-number">15</span>,</span>
<span class="line" id="L27"> <span class="tok-kw">else</span> => <span class="tok-builtin">@compileError</span>(<span class="tok-str">"unknown floating point type "</span> ++ <span class="tok-builtin">@typeName</span>(T)),</span>
<span class="line" id="L28"> };</span>
<span class="line" id="L29">}</span>
<span class="line" id="L30"></span>
<span class="line" id="L31"><span class="tok-comment">/// Returns the number of bits in the mantissa of floating point type T.</span></span>
<span class="line" id="L32"><span class="tok-kw">pub</span> <span class="tok-kw">inline</span> <span class="tok-kw">fn</span> <span class="tok-fn">floatMantissaBits</span>(<span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>) <span class="tok-type">comptime_int</span> {</span>
<span class="line" id="L33"> <span class="tok-kw">comptime</span> assert(<span class="tok-builtin">@typeInfo</span>(T) == .Float);</span>
<span class="line" id="L34"></span>
<span class="line" id="L35"> <span class="tok-kw">return</span> <span class="tok-kw">switch</span> (<span class="tok-builtin">@typeInfo</span>(T).Float.bits) {</span>
<span class="line" id="L36"> <span class="tok-number">16</span> => <span class="tok-number">10</span>,</span>
<span class="line" id="L37"> <span class="tok-number">32</span> => <span class="tok-number">23</span>,</span>
<span class="line" id="L38"> <span class="tok-number">64</span> => <span class="tok-number">52</span>,</span>
<span class="line" id="L39"> <span class="tok-number">80</span> => <span class="tok-number">64</span>,</span>
<span class="line" id="L40"> <span class="tok-number">128</span> => <span class="tok-number">112</span>,</span>
<span class="line" id="L41"> <span class="tok-kw">else</span> => <span class="tok-builtin">@compileError</span>(<span class="tok-str">"unknown floating point type "</span> ++ <span class="tok-builtin">@typeName</span>(T)),</span>
<span class="line" id="L42"> };</span>
<span class="line" id="L43">}</span>
<span class="line" id="L44"></span>
<span class="line" id="L45"><span class="tok-comment">/// Returns the number of fractional bits in the mantissa of floating point type T.</span></span>
<span class="line" id="L46"><span class="tok-kw">pub</span> <span class="tok-kw">inline</span> <span class="tok-kw">fn</span> <span class="tok-fn">floatFractionalBits</span>(<span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>) <span class="tok-type">comptime_int</span> {</span>
<span class="line" id="L47"> <span class="tok-kw">comptime</span> assert(<span class="tok-builtin">@typeInfo</span>(T) == .Float);</span>
<span class="line" id="L48"></span>
<span class="line" id="L49"> <span class="tok-comment">// standard IEEE floats have an implicit 0.m or 1.m integer part</span>
</span>
<span class="line" id="L50"> <span class="tok-comment">// f80 is special and has an explicitly stored bit in the MSB</span>
</span>
<span class="line" id="L51"> <span class="tok-comment">// this function corresponds to `MANT_DIG - 1' from C</span>
</span>
<span class="line" id="L52"> <span class="tok-kw">return</span> <span class="tok-kw">switch</span> (<span class="tok-builtin">@typeInfo</span>(T).Float.bits) {</span>
<span class="line" id="L53"> <span class="tok-number">16</span> => <span class="tok-number">10</span>,</span>
<span class="line" id="L54"> <span class="tok-number">32</span> => <span class="tok-number">23</span>,</span>
<span class="line" id="L55"> <span class="tok-number">64</span> => <span class="tok-number">52</span>,</span>
<span class="line" id="L56"> <span class="tok-number">80</span> => <span class="tok-number">63</span>,</span>
<span class="line" id="L57"> <span class="tok-number">128</span> => <span class="tok-number">112</span>,</span>
<span class="line" id="L58"> <span class="tok-kw">else</span> => <span class="tok-builtin">@compileError</span>(<span class="tok-str">"unknown floating point type "</span> ++ <span class="tok-builtin">@typeName</span>(T)),</span>
<span class="line" id="L59"> };</span>
<span class="line" id="L60">}</span>
<span class="line" id="L61"></span>
<span class="line" id="L62"><span class="tok-comment">/// Returns the minimum exponent that can represent</span></span>
<span class="line" id="L63"><span class="tok-comment">/// a normalised value in floating point type T.</span></span>
<span class="line" id="L64"><span class="tok-kw">pub</span> <span class="tok-kw">inline</span> <span class="tok-kw">fn</span> <span class="tok-fn">floatExponentMin</span>(<span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>) <span class="tok-type">comptime_int</span> {</span>
<span class="line" id="L65"> <span class="tok-kw">return</span> -floatExponentMax(T) + <span class="tok-number">1</span>;</span>
<span class="line" id="L66">}</span>
<span class="line" id="L67"></span>
<span class="line" id="L68"><span class="tok-comment">/// Returns the maximum exponent that can represent</span></span>
<span class="line" id="L69"><span class="tok-comment">/// a normalised value in floating point type T.</span></span>
<span class="line" id="L70"><span class="tok-kw">pub</span> <span class="tok-kw">inline</span> <span class="tok-kw">fn</span> <span class="tok-fn">floatExponentMax</span>(<span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>) <span class="tok-type">comptime_int</span> {</span>
<span class="line" id="L71"> <span class="tok-kw">return</span> (<span class="tok-number">1</span> << (floatExponentBits(T) - <span class="tok-number">1</span>)) - <span class="tok-number">1</span>;</span>
<span class="line" id="L72">}</span>
<span class="line" id="L73"></span>
<span class="line" id="L74"><span class="tok-comment">/// Returns the smallest subnormal number representable in floating point type T.</span></span>
<span class="line" id="L75"><span class="tok-kw">pub</span> <span class="tok-kw">inline</span> <span class="tok-kw">fn</span> <span class="tok-fn">floatTrueMin</span>(<span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>) T {</span>
<span class="line" id="L76"> <span class="tok-kw">return</span> reconstructFloat(T, floatExponentMin(T) - <span class="tok-number">1</span>, <span class="tok-number">1</span>);</span>
<span class="line" id="L77">}</span>
<span class="line" id="L78"></span>
<span class="line" id="L79"><span class="tok-comment">/// Returns the smallest normal number representable in floating point type T.</span></span>
<span class="line" id="L80"><span class="tok-kw">pub</span> <span class="tok-kw">inline</span> <span class="tok-kw">fn</span> <span class="tok-fn">floatMin</span>(<span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>) T {</span>
<span class="line" id="L81"> <span class="tok-kw">return</span> reconstructFloat(T, floatExponentMin(T), mantissaOne(T));</span>
<span class="line" id="L82">}</span>
<span class="line" id="L83"></span>
<span class="line" id="L84"><span class="tok-comment">/// Returns the largest normal number representable in floating point type T.</span></span>
<span class="line" id="L85"><span class="tok-kw">pub</span> <span class="tok-kw">inline</span> <span class="tok-kw">fn</span> <span class="tok-fn">floatMax</span>(<span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>) T {</span>
<span class="line" id="L86"> <span class="tok-kw">const</span> all1s_mantissa = (<span class="tok-number">1</span> << floatMantissaBits(T)) - <span class="tok-number">1</span>;</span>
<span class="line" id="L87"> <span class="tok-kw">return</span> reconstructFloat(T, floatExponentMax(T), all1s_mantissa);</span>
<span class="line" id="L88">}</span>
<span class="line" id="L89"></span>
<span class="line" id="L90"><span class="tok-comment">/// Returns the machine epsilon of floating point type T.</span></span>
<span class="line" id="L91"><span class="tok-kw">pub</span> <span class="tok-kw">inline</span> <span class="tok-kw">fn</span> <span class="tok-fn">floatEps</span>(<span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>) T {</span>
<span class="line" id="L92"> <span class="tok-kw">return</span> reconstructFloat(T, -floatFractionalBits(T), mantissaOne(T));</span>
<span class="line" id="L93">}</span>
<span class="line" id="L94"></span>
<span class="line" id="L95"><span class="tok-comment">/// Returns the value inf for floating point type T.</span></span>
<span class="line" id="L96"><span class="tok-kw">pub</span> <span class="tok-kw">inline</span> <span class="tok-kw">fn</span> <span class="tok-fn">inf</span>(<span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>) T {</span>
<span class="line" id="L97"> <span class="tok-kw">return</span> reconstructFloat(T, floatExponentMax(T) + <span class="tok-number">1</span>, mantissaOne(T));</span>
<span class="line" id="L98">}</span>
<span class="line" id="L99"></span>
<span class="line" id="L100"><span class="tok-kw">test</span> <span class="tok-str">"float bits"</span> {</span>
<span class="line" id="L101"> <span class="tok-kw">inline</span> <span class="tok-kw">for</span> ([_]<span class="tok-type">type</span>{ <span class="tok-type">f16</span>, <span class="tok-type">f32</span>, <span class="tok-type">f64</span>, <span class="tok-type">f80</span>, <span class="tok-type">f128</span>, <span class="tok-type">c_longdouble</span> }) |T| {</span>
<span class="line" id="L102"> <span class="tok-comment">// (1 +) for the sign bit, since it is separate from the other bits</span>
</span>
<span class="line" id="L103"> <span class="tok-kw">const</span> size = <span class="tok-number">1</span> + floatExponentBits(T) + floatMantissaBits(T);</span>
<span class="line" id="L104"> <span class="tok-kw">try</span> expect(<span class="tok-builtin">@bitSizeOf</span>(T) == size);</span>
<span class="line" id="L105"></span>
<span class="line" id="L106"> <span class="tok-comment">// for machine epsilon, assert expmin <= -prec <= expmax</span>
</span>
<span class="line" id="L107"> <span class="tok-kw">try</span> expect(floatExponentMin(T) <= -floatFractionalBits(T));</span>
<span class="line" id="L108"> <span class="tok-kw">try</span> expect(-floatFractionalBits(T) <= floatExponentMax(T));</span>
<span class="line" id="L109"> }</span>
<span class="line" id="L110">}</span>
<span class="line" id="L111"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/math/copysign.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>math/copysign.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../std.zig"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> math = std.math;</span>
<span class="line" id="L3"><span class="tok-kw">const</span> expect = std.testing.expect;</span>
<span class="line" id="L4"></span>
<span class="line" id="L5"><span class="tok-comment">/// Returns a value with the magnitude of `magnitude` and the sign of `sign`.</span></span>
<span class="line" id="L6"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">copysign</span>(magnitude: <span class="tok-kw">anytype</span>, sign: <span class="tok-builtin">@TypeOf</span>(magnitude)) <span class="tok-builtin">@TypeOf</span>(magnitude) {</span>
<span class="line" id="L7"> <span class="tok-kw">const</span> T = <span class="tok-builtin">@TypeOf</span>(magnitude);</span>
<span class="line" id="L8"> <span class="tok-kw">const</span> TBits = std.meta.Int(.unsigned, <span class="tok-builtin">@typeInfo</span>(T).Float.bits);</span>
<span class="line" id="L9"> <span class="tok-kw">const</span> sign_bit_mask = <span class="tok-builtin">@as</span>(TBits, <span class="tok-number">1</span>) << (<span class="tok-builtin">@bitSizeOf</span>(T) - <span class="tok-number">1</span>);</span>
<span class="line" id="L10"> <span class="tok-kw">const</span> mag = <span class="tok-builtin">@as</span>(TBits, <span class="tok-builtin">@bitCast</span>(magnitude)) & ~sign_bit_mask;</span>
<span class="line" id="L11"> <span class="tok-kw">const</span> sgn = <span class="tok-builtin">@as</span>(TBits, <span class="tok-builtin">@bitCast</span>(sign)) & sign_bit_mask;</span>
<span class="line" id="L12"> <span class="tok-kw">return</span> <span class="tok-builtin">@as</span>(T, <span class="tok-builtin">@bitCast</span>(mag | sgn));</span>
<span class="line" id="L13">}</span>
<span class="line" id="L14"></span>
<span class="line" id="L15"><span class="tok-kw">test</span> <span class="tok-str">"math.copysign"</span> {</span>
<span class="line" id="L16"> <span class="tok-kw">inline</span> <span class="tok-kw">for</span> ([_]<span class="tok-type">type</span>{ <span class="tok-type">f16</span>, <span class="tok-type">f32</span>, <span class="tok-type">f64</span>, <span class="tok-type">f80</span>, <span class="tok-type">f128</span> }) |T| {</span>
<span class="line" id="L17"> <span class="tok-kw">try</span> expect(copysign(<span class="tok-builtin">@as</span>(T, <span class="tok-number">1.0</span>), <span class="tok-builtin">@as</span>(T, <span class="tok-number">1.0</span>)) == <span class="tok-number">1.0</span>);</span>
<span class="line" id="L18"> <span class="tok-kw">try</span> expect(copysign(<span class="tok-builtin">@as</span>(T, <span class="tok-number">2.0</span>), <span class="tok-builtin">@as</span>(T, -<span class="tok-number">2.0</span>)) == -<span class="tok-number">2.0</span>);</span>
<span class="line" id="L19"> <span class="tok-kw">try</span> expect(copysign(<span class="tok-builtin">@as</span>(T, -<span class="tok-number">3.0</span>), <span class="tok-builtin">@as</span>(T, <span class="tok-number">3.0</span>)) == <span class="tok-number">3.0</span>);</span>
<span class="line" id="L20"> <span class="tok-kw">try</span> expect(copysign(<span class="tok-builtin">@as</span>(T, -<span class="tok-number">4.0</span>), <span class="tok-builtin">@as</span>(T, -<span class="tok-number">4.0</span>)) == -<span class="tok-number">4.0</span>);</span>
<span class="line" id="L21"> <span class="tok-kw">try</span> expect(copysign(<span class="tok-builtin">@as</span>(T, <span class="tok-number">5.0</span>), <span class="tok-builtin">@as</span>(T, -<span class="tok-number">500.0</span>)) == -<span class="tok-number">5.0</span>);</span>
<span class="line" id="L22"> <span class="tok-kw">try</span> expect(copysign(math.inf(T), <span class="tok-builtin">@as</span>(T, -<span class="tok-number">0.0</span>)) == -math.inf(T));</span>
<span class="line" id="L23"> <span class="tok-kw">try</span> expect(copysign(<span class="tok-builtin">@as</span>(T, <span class="tok-number">6.0</span>), -math.nan(T)) == -<span class="tok-number">6.0</span>);</span>
<span class="line" id="L24"> }</span>
<span class="line" id="L25">}</span>
<span class="line" id="L26"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/math/gcd.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>math/gcd.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-comment">//! Greatest common divisor (https://mathworld.wolfram.com/GreatestCommonDivisor.html)</span></span>
<span class="line" id="L2"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"std"</span>);</span>
<span class="line" id="L3"><span class="tok-kw">const</span> expectEqual = std.testing.expectEqual;</span>
<span class="line" id="L4"></span>
<span class="line" id="L5"><span class="tok-comment">/// Returns the greatest common divisor (GCD) of two unsigned integers (a and b) which are not both zero.</span></span>
<span class="line" id="L6"><span class="tok-comment">/// For example, the GCD of 8 and 12 is 4, that is, gcd(8, 12) == 4.</span></span>
<span class="line" id="L7"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">gcd</span>(a: <span class="tok-kw">anytype</span>, b: <span class="tok-kw">anytype</span>) <span class="tok-builtin">@TypeOf</span>(a, b) {</span>
<span class="line" id="L8"></span>
<span class="line" id="L9"> <span class="tok-comment">// only unsigned integers are allowed and not both must be zero</span>
</span>
<span class="line" id="L10"> <span class="tok-kw">comptime</span> <span class="tok-kw">switch</span> (<span class="tok-builtin">@typeInfo</span>(<span class="tok-builtin">@TypeOf</span>(a, b))) {</span>
<span class="line" id="L11"> .Int => |int| std.debug.assert(int.signedness == .unsigned),</span>
<span class="line" id="L12"> .ComptimeInt => {</span>
<span class="line" id="L13"> std.debug.assert(a >= <span class="tok-number">0</span>);</span>
<span class="line" id="L14"> std.debug.assert(b >= <span class="tok-number">0</span>);</span>
<span class="line" id="L15"> },</span>
<span class="line" id="L16"> <span class="tok-kw">else</span> => <span class="tok-kw">unreachable</span>,</span>
<span class="line" id="L17"> };</span>
<span class="line" id="L18"> std.debug.assert(a != <span class="tok-number">0</span> <span class="tok-kw">or</span> b != <span class="tok-number">0</span>);</span>
<span class="line" id="L19"></span>
<span class="line" id="L20"> <span class="tok-comment">// if one of them is zero, the other is returned</span>
</span>
<span class="line" id="L21"> <span class="tok-kw">if</span> (a == <span class="tok-number">0</span>) <span class="tok-kw">return</span> b;</span>
<span class="line" id="L22"> <span class="tok-kw">if</span> (b == <span class="tok-number">0</span>) <span class="tok-kw">return</span> a;</span>
<span class="line" id="L23"></span>
<span class="line" id="L24"> <span class="tok-comment">// init vars</span>
</span>
<span class="line" id="L25"> <span class="tok-kw">var</span> x: <span class="tok-builtin">@TypeOf</span>(a, b) = a;</span>
<span class="line" id="L26"> <span class="tok-kw">var</span> y: <span class="tok-builtin">@TypeOf</span>(a, b) = b;</span>
<span class="line" id="L27"> <span class="tok-kw">var</span> m: <span class="tok-builtin">@TypeOf</span>(a, b) = a;</span>
<span class="line" id="L28"></span>
<span class="line" id="L29"> <span class="tok-comment">// using the Euclidean algorithm (https://mathworld.wolfram.com/EuclideanAlgorithm.html)</span>
</span>
<span class="line" id="L30"> <span class="tok-kw">while</span> (y != <span class="tok-number">0</span>) {</span>
<span class="line" id="L31"> m = x % y;</span>
<span class="line" id="L32"> x = y;</span>
<span class="line" id="L33"> y = m;</span>
<span class="line" id="L34"> }</span>
<span class="line" id="L35"> <span class="tok-kw">return</span> x;</span>
<span class="line" id="L36">}</span>
<span class="line" id="L37"></span>
<span class="line" id="L38"><span class="tok-kw">test</span> <span class="tok-str">"gcd"</span> {</span>
<span class="line" id="L39"> <span class="tok-kw">try</span> expectEqual(gcd(<span class="tok-number">0</span>, <span class="tok-number">5</span>), <span class="tok-number">5</span>);</span>
<span class="line" id="L40"> <span class="tok-kw">try</span> expectEqual(gcd(<span class="tok-number">5</span>, <span class="tok-number">0</span>), <span class="tok-number">5</span>);</span>
<span class="line" id="L41"> <span class="tok-kw">try</span> expectEqual(gcd(<span class="tok-number">8</span>, <span class="tok-number">12</span>), <span class="tok-number">4</span>);</span>
<span class="line" id="L42"> <span class="tok-kw">try</span> expectEqual(gcd(<span class="tok-number">12</span>, <span class="tok-number">8</span>), <span class="tok-number">4</span>);</span>
<span class="line" id="L43"> <span class="tok-kw">try</span> expectEqual(gcd(<span class="tok-number">33</span>, <span class="tok-number">77</span>), <span class="tok-number">11</span>);</span>
<span class="line" id="L44"> <span class="tok-kw">try</span> expectEqual(gcd(<span class="tok-number">77</span>, <span class="tok-number">33</span>), <span class="tok-number">11</span>);</span>
<span class="line" id="L45"> <span class="tok-kw">try</span> expectEqual(gcd(<span class="tok-number">49865</span>, <span class="tok-number">69811</span>), <span class="tok-number">9973</span>);</span>
<span class="line" id="L46"> <span class="tok-kw">try</span> expectEqual(gcd(<span class="tok-number">300_000</span>, <span class="tok-number">2_300_000</span>), <span class="tok-number">100_000</span>);</span>
<span class="line" id="L47"> <span class="tok-kw">try</span> expectEqual(gcd(<span class="tok-number">90000000_000_000_000_000_000</span>, <span class="tok-number">2</span>), <span class="tok-number">2</span>);</span>
<span class="line" id="L48">}</span>
<span class="line" id="L49"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/math/big.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>math/big.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../std.zig"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> assert = std.debug.assert;</span>
<span class="line" id="L3"></span>
<span class="line" id="L4"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> Rational = <span class="tok-builtin">@import</span>(<span class="tok-str">"big/rational.zig"</span>).Rational;</span>
<span class="line" id="L5"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> int = <span class="tok-builtin">@import</span>(<span class="tok-str">"big/int.zig"</span>);</span>
<span class="line" id="L6"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> Limb = <span class="tok-type">usize</span>;</span>
<span class="line" id="L7"><span class="tok-kw">const</span> limb_info = <span class="tok-builtin">@typeInfo</span>(Limb).Int;</span>
<span class="line" id="L8"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> SignedLimb = std.meta.Int(.signed, limb_info.bits);</span>
<span class="line" id="L9"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> DoubleLimb = std.meta.Int(.unsigned, <span class="tok-number">2</span> * limb_info.bits);</span>
<span class="line" id="L10"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> HalfLimb = std.meta.Int(.unsigned, limb_info.bits / <span class="tok-number">2</span>);</span>
<span class="line" id="L11"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> SignedDoubleLimb = std.meta.Int(.signed, <span class="tok-number">2</span> * limb_info.bits);</span>
<span class="line" id="L12"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> Log2Limb = std.math.Log2Int(Limb);</span>
<span class="line" id="L13"></span>
<span class="line" id="L14"><span class="tok-kw">comptime</span> {</span>
<span class="line" id="L15"> assert(std.math.floorPowerOfTwo(<span class="tok-type">usize</span>, limb_info.bits) == limb_info.bits);</span>
<span class="line" id="L16"> assert(limb_info.signedness == .unsigned);</span>
<span class="line" id="L17">}</span>
<span class="line" id="L18"></span>
<span class="line" id="L19"><span class="tok-kw">test</span> {</span>
<span class="line" id="L20"> _ = int;</span>
<span class="line" id="L21"> _ = Rational;</span>
<span class="line" id="L22"> _ = Limb;</span>
<span class="line" id="L23"> _ = SignedLimb;</span>
<span class="line" id="L24"> _ = DoubleLimb;</span>
<span class="line" id="L25"> _ = SignedDoubleLimb;</span>
<span class="line" id="L26"> _ = Log2Limb;</span>
<span class="line" id="L27">}</span>
<span class="line" id="L28"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/math/pow.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>math/pow.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-comment">// Ported from go, which is licensed under a BSD-3 license.</span>
</span>
<span class="line" id="L2"><span class="tok-comment">// https://golang.org/LICENSE</span>
</span>
<span class="line" id="L3"><span class="tok-comment">//</span>
</span>
<span class="line" id="L4"><span class="tok-comment">// https://golang.org/src/math/pow.go</span>
</span>
<span class="line" id="L5"></span>
<span class="line" id="L6"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../std.zig"</span>);</span>
<span class="line" id="L7"><span class="tok-kw">const</span> math = std.math;</span>
<span class="line" id="L8"><span class="tok-kw">const</span> expect = std.testing.expect;</span>
<span class="line" id="L9"></span>
<span class="line" id="L10"><span class="tok-comment">/// Returns x raised to the power of y (x^y).</span></span>
<span class="line" id="L11"><span class="tok-comment">///</span></span>
<span class="line" id="L12"><span class="tok-comment">/// Special Cases:</span></span>
<span class="line" id="L13"><span class="tok-comment">/// - pow(x, +-0) = 1 for any x</span></span>
<span class="line" id="L14"><span class="tok-comment">/// - pow(1, y) = 1 for any y</span></span>
<span class="line" id="L15"><span class="tok-comment">/// - pow(x, 1) = x for any x</span></span>
<span class="line" id="L16"><span class="tok-comment">/// - pow(nan, y) = nan</span></span>
<span class="line" id="L17"><span class="tok-comment">/// - pow(x, nan) = nan</span></span>
<span class="line" id="L18"><span class="tok-comment">/// - pow(+-0, y) = +-inf for y an odd integer < 0</span></span>
<span class="line" id="L19"><span class="tok-comment">/// - pow(+-0, -inf) = +inf</span></span>
<span class="line" id="L20"><span class="tok-comment">/// - pow(+-0, +inf) = +0</span></span>
<span class="line" id="L21"><span class="tok-comment">/// - pow(+-0, y) = +inf for finite y < 0 and not an odd integer</span></span>
<span class="line" id="L22"><span class="tok-comment">/// - pow(+-0, y) = +-0 for y an odd integer > 0</span></span>
<span class="line" id="L23"><span class="tok-comment">/// - pow(+-0, y) = +0 for finite y > 0 and not an odd integer</span></span>
<span class="line" id="L24"><span class="tok-comment">/// - pow(-1, +-inf) = 1</span></span>
<span class="line" id="L25"><span class="tok-comment">/// - pow(x, +inf) = +inf for |x| > 1</span></span>
<span class="line" id="L26"><span class="tok-comment">/// - pow(x, -inf) = +0 for |x| > 1</span></span>
<span class="line" id="L27"><span class="tok-comment">/// - pow(x, +inf) = +0 for |x| < 1</span></span>
<span class="line" id="L28"><span class="tok-comment">/// - pow(x, -inf) = +inf for |x| < 1</span></span>
<span class="line" id="L29"><span class="tok-comment">/// - pow(+inf, y) = +inf for y > 0</span></span>
<span class="line" id="L30"><span class="tok-comment">/// - pow(+inf, y) = +0 for y < 0</span></span>
<span class="line" id="L31"><span class="tok-comment">/// - pow(-inf, y) = pow(-0, -y)</span></span>
<span class="line" id="L32"><span class="tok-comment">/// - pow(x, y) = nan for finite x < 0 and finite non-integer y</span></span>
<span class="line" id="L33"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">pow</span>(<span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>, x: T, y: T) T {</span>
<span class="line" id="L34"> <span class="tok-kw">if</span> (<span class="tok-builtin">@typeInfo</span>(T) == .Int) {</span>
<span class="line" id="L35"> <span class="tok-kw">return</span> math.powi(T, x, y) <span class="tok-kw">catch</span> <span class="tok-kw">unreachable</span>;</span>
<span class="line" id="L36"> }</span>
<span class="line" id="L37"></span>
<span class="line" id="L38"> <span class="tok-kw">if</span> (T != <span class="tok-type">f32</span> <span class="tok-kw">and</span> T != <span class="tok-type">f64</span>) {</span>
<span class="line" id="L39"> <span class="tok-builtin">@compileError</span>(<span class="tok-str">"pow not implemented for "</span> ++ <span class="tok-builtin">@typeName</span>(T));</span>
<span class="line" id="L40"> }</span>
<span class="line" id="L41"></span>
<span class="line" id="L42"> <span class="tok-comment">// pow(x, +-0) = 1 for all x</span>
</span>
<span class="line" id="L43"> <span class="tok-comment">// pow(1, y) = 1 for all y</span>
</span>
<span class="line" id="L44"> <span class="tok-kw">if</span> (y == <span class="tok-number">0</span> <span class="tok-kw">or</span> x == <span class="tok-number">1</span>) {</span>
<span class="line" id="L45"> <span class="tok-kw">return</span> <span class="tok-number">1</span>;</span>
<span class="line" id="L46"> }</span>
<span class="line" id="L47"></span>
<span class="line" id="L48"> <span class="tok-comment">// pow(nan, y) = nan for all y</span>
</span>
<span class="line" id="L49"> <span class="tok-comment">// pow(x, nan) = nan for all x</span>
</span>
<span class="line" id="L50"> <span class="tok-kw">if</span> (math.isNan(x) <span class="tok-kw">or</span> math.isNan(y)) {</span>
<span class="line" id="L51"> <span class="tok-kw">return</span> math.nan(T);</span>
<span class="line" id="L52"> }</span>
<span class="line" id="L53"></span>
<span class="line" id="L54"> <span class="tok-comment">// pow(x, 1) = x for all x</span>
</span>
<span class="line" id="L55"> <span class="tok-kw">if</span> (y == <span class="tok-number">1</span>) {</span>
<span class="line" id="L56"> <span class="tok-kw">return</span> x;</span>
<span class="line" id="L57"> }</span>
<span class="line" id="L58"></span>
<span class="line" id="L59"> <span class="tok-kw">if</span> (x == <span class="tok-number">0</span>) {</span>
<span class="line" id="L60"> <span class="tok-kw">if</span> (y < <span class="tok-number">0</span>) {</span>
<span class="line" id="L61"> <span class="tok-comment">// pow(+-0, y) = +- 0 for y an odd integer</span>
</span>
<span class="line" id="L62"> <span class="tok-kw">if</span> (isOddInteger(y)) {</span>
<span class="line" id="L63"> <span class="tok-kw">return</span> math.copysign(math.inf(T), x);</span>
<span class="line" id="L64"> }</span>
<span class="line" id="L65"> <span class="tok-comment">// pow(+-0, y) = +inf for y an even integer</span>
</span>
<span class="line" id="L66"> <span class="tok-kw">else</span> {</span>
<span class="line" id="L67"> <span class="tok-kw">return</span> math.inf(T);</span>
<span class="line" id="L68"> }</span>
<span class="line" id="L69"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L70"> <span class="tok-kw">if</span> (isOddInteger(y)) {</span>
<span class="line" id="L71"> <span class="tok-kw">return</span> x;</span>
<span class="line" id="L72"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L73"> <span class="tok-kw">return</span> <span class="tok-number">0</span>;</span>
<span class="line" id="L74"> }</span>
<span class="line" id="L75"> }</span>
<span class="line" id="L76"> }</span>
<span class="line" id="L77"></span>
<span class="line" id="L78"> <span class="tok-kw">if</span> (math.isInf(y)) {</span>
<span class="line" id="L79"> <span class="tok-comment">// pow(-1, inf) = 1 for all x</span>
</span>
<span class="line" id="L80"> <span class="tok-kw">if</span> (x == -<span class="tok-number">1</span>) {</span>
<span class="line" id="L81"> <span class="tok-kw">return</span> <span class="tok-number">1.0</span>;</span>
<span class="line" id="L82"> }</span>
<span class="line" id="L83"> <span class="tok-comment">// pow(x, +inf) = +0 for |x| < 1</span>
</span>
<span class="line" id="L84"> <span class="tok-comment">// pow(x, -inf) = +0 for |x| > 1</span>
</span>
<span class="line" id="L85"> <span class="tok-kw">else</span> <span class="tok-kw">if</span> ((<span class="tok-builtin">@fabs</span>(x) < <span class="tok-number">1</span>) == math.isPositiveInf(y)) {</span>
<span class="line" id="L86"> <span class="tok-kw">return</span> <span class="tok-number">0</span>;</span>
<span class="line" id="L87"> }</span>
<span class="line" id="L88"> <span class="tok-comment">// pow(x, -inf) = +inf for |x| < 1</span>
</span>
<span class="line" id="L89"> <span class="tok-comment">// pow(x, +inf) = +inf for |x| > 1</span>
</span>
<span class="line" id="L90"> <span class="tok-kw">else</span> {</span>
<span class="line" id="L91"> <span class="tok-kw">return</span> math.inf(T);</span>
<span class="line" id="L92"> }</span>
<span class="line" id="L93"> }</span>
<span class="line" id="L94"></span>
<span class="line" id="L95"> <span class="tok-kw">if</span> (math.isInf(x)) {</span>
<span class="line" id="L96"> <span class="tok-kw">if</span> (math.isNegativeInf(x)) {</span>
<span class="line" id="L97"> <span class="tok-kw">return</span> pow(T, <span class="tok-number">1</span> / x, -y);</span>
<span class="line" id="L98"> }</span>
<span class="line" id="L99"> <span class="tok-comment">// pow(+inf, y) = +0 for y < 0</span>
</span>
<span class="line" id="L100"> <span class="tok-kw">else</span> <span class="tok-kw">if</span> (y < <span class="tok-number">0</span>) {</span>
<span class="line" id="L101"> <span class="tok-kw">return</span> <span class="tok-number">0</span>;</span>
<span class="line" id="L102"> }</span>
<span class="line" id="L103"> <span class="tok-comment">// pow(+inf, y) = +0 for y > 0</span>
</span>
<span class="line" id="L104"> <span class="tok-kw">else</span> <span class="tok-kw">if</span> (y > <span class="tok-number">0</span>) {</span>
<span class="line" id="L105"> <span class="tok-kw">return</span> math.inf(T);</span>
<span class="line" id="L106"> }</span>
<span class="line" id="L107"> }</span>
<span class="line" id="L108"></span>
<span class="line" id="L109"> <span class="tok-comment">// special case sqrt</span>
</span>
<span class="line" id="L110"> <span class="tok-kw">if</span> (y == <span class="tok-number">0.5</span>) {</span>
<span class="line" id="L111"> <span class="tok-kw">return</span> <span class="tok-builtin">@sqrt</span>(x);</span>
<span class="line" id="L112"> }</span>
<span class="line" id="L113"></span>
<span class="line" id="L114"> <span class="tok-kw">if</span> (y == -<span class="tok-number">0.5</span>) {</span>
<span class="line" id="L115"> <span class="tok-kw">return</span> <span class="tok-number">1</span> / <span class="tok-builtin">@sqrt</span>(x);</span>
<span class="line" id="L116"> }</span>
<span class="line" id="L117"></span>
<span class="line" id="L118"> <span class="tok-kw">const</span> r1 = math.modf(<span class="tok-builtin">@fabs</span>(y));</span>
<span class="line" id="L119"> <span class="tok-kw">var</span> yi = r1.ipart;</span>
<span class="line" id="L120"> <span class="tok-kw">var</span> yf = r1.fpart;</span>
<span class="line" id="L121"></span>
<span class="line" id="L122"> <span class="tok-kw">if</span> (yf != <span class="tok-number">0</span> <span class="tok-kw">and</span> x < <span class="tok-number">0</span>) {</span>
<span class="line" id="L123"> <span class="tok-kw">return</span> math.nan(T);</span>
<span class="line" id="L124"> }</span>
<span class="line" id="L125"> <span class="tok-kw">if</span> (yi >= <span class="tok-number">1</span> << (<span class="tok-builtin">@typeInfo</span>(T).Float.bits - <span class="tok-number">1</span>)) {</span>
<span class="line" id="L126"> <span class="tok-kw">return</span> <span class="tok-builtin">@exp</span>(y * <span class="tok-builtin">@log</span>(x));</span>
<span class="line" id="L127"> }</span>
<span class="line" id="L128"></span>
<span class="line" id="L129"> <span class="tok-comment">// a = a1 * 2^ae</span>
</span>
<span class="line" id="L130"> <span class="tok-kw">var</span> a1: T = <span class="tok-number">1.0</span>;</span>
<span class="line" id="L131"> <span class="tok-kw">var</span> ae: <span class="tok-type">i32</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L132"></span>
<span class="line" id="L133"> <span class="tok-comment">// a *= x^yf</span>
</span>
<span class="line" id="L134"> <span class="tok-kw">if</span> (yf != <span class="tok-number">0</span>) {</span>
<span class="line" id="L135"> <span class="tok-kw">if</span> (yf > <span class="tok-number">0.5</span>) {</span>
<span class="line" id="L136"> yf -= <span class="tok-number">1</span>;</span>
<span class="line" id="L137"> yi += <span class="tok-number">1</span>;</span>
<span class="line" id="L138"> }</span>
<span class="line" id="L139"> a1 = <span class="tok-builtin">@exp</span>(yf * <span class="tok-builtin">@log</span>(x));</span>
<span class="line" id="L140"> }</span>
<span class="line" id="L141"></span>
<span class="line" id="L142"> <span class="tok-comment">// a *= x^yi</span>
</span>
<span class="line" id="L143"> <span class="tok-kw">const</span> r2 = math.frexp(x);</span>
<span class="line" id="L144"> <span class="tok-kw">var</span> xe = r2.exponent;</span>
<span class="line" id="L145"> <span class="tok-kw">var</span> x1 = r2.significand;</span>
<span class="line" id="L146"></span>
<span class="line" id="L147"> <span class="tok-kw">var</span> i = <span class="tok-builtin">@as</span>(std.meta.Int(.signed, <span class="tok-builtin">@typeInfo</span>(T).Float.bits), <span class="tok-builtin">@intFromFloat</span>(yi));</span>
<span class="line" id="L148"> <span class="tok-kw">while</span> (i != <span class="tok-number">0</span>) : (i >>= <span class="tok-number">1</span>) {</span>
<span class="line" id="L149"> <span class="tok-kw">const</span> overflow_shift = math.floatExponentBits(T) + <span class="tok-number">1</span>;</span>
<span class="line" id="L150"> <span class="tok-kw">if</span> (xe < -(<span class="tok-number">1</span> << overflow_shift) <span class="tok-kw">or</span> (<span class="tok-number">1</span> << overflow_shift) < xe) {</span>
<span class="line" id="L151"> <span class="tok-comment">// catch xe before it overflows the left shift below</span>
</span>
<span class="line" id="L152"> <span class="tok-comment">// Since i != 0 it has at least one bit still set, so ae will accumulate xe</span>
</span>
<span class="line" id="L153"> <span class="tok-comment">// on at least one more iteration, ae += xe is a lower bound on ae</span>
</span>
<span class="line" id="L154"> <span class="tok-comment">// the lower bound on ae exceeds the size of a float exp</span>
</span>
<span class="line" id="L155"> <span class="tok-comment">// so the final call to Ldexp will produce under/overflow (0/Inf)</span>
</span>
<span class="line" id="L156"> ae += xe;</span>
<span class="line" id="L157"> <span class="tok-kw">break</span>;</span>
<span class="line" id="L158"> }</span>
<span class="line" id="L159"> <span class="tok-kw">if</span> (i & <span class="tok-number">1</span> == <span class="tok-number">1</span>) {</span>
<span class="line" id="L160"> a1 *= x1;</span>
<span class="line" id="L161"> ae += xe;</span>
<span class="line" id="L162"> }</span>
<span class="line" id="L163"> x1 *= x1;</span>
<span class="line" id="L164"> xe <<= <span class="tok-number">1</span>;</span>
<span class="line" id="L165"> <span class="tok-kw">if</span> (x1 < <span class="tok-number">0.5</span>) {</span>
<span class="line" id="L166"> x1 += x1;</span>
<span class="line" id="L167"> xe -= <span class="tok-number">1</span>;</span>
<span class="line" id="L168"> }</span>
<span class="line" id="L169"> }</span>
<span class="line" id="L170"></span>
<span class="line" id="L171"> <span class="tok-comment">// a *= a1 * 2^ae</span>
</span>
<span class="line" id="L172"> <span class="tok-kw">if</span> (y < <span class="tok-number">0</span>) {</span>
<span class="line" id="L173"> a1 = <span class="tok-number">1</span> / a1;</span>
<span class="line" id="L174"> ae = -ae;</span>
<span class="line" id="L175"> }</span>
<span class="line" id="L176"></span>
<span class="line" id="L177"> <span class="tok-kw">return</span> math.scalbn(a1, ae);</span>
<span class="line" id="L178">}</span>
<span class="line" id="L179"></span>
<span class="line" id="L180"><span class="tok-kw">fn</span> <span class="tok-fn">isOddInteger</span>(x: <span class="tok-type">f64</span>) <span class="tok-type">bool</span> {</span>
<span class="line" id="L181"> <span class="tok-kw">const</span> r = math.modf(x);</span>
<span class="line" id="L182"> <span class="tok-kw">return</span> r.fpart == <span class="tok-number">0.0</span> <span class="tok-kw">and</span> <span class="tok-builtin">@as</span>(<span class="tok-type">i64</span>, <span class="tok-builtin">@intFromFloat</span>(r.ipart)) & <span class="tok-number">1</span> == <span class="tok-number">1</span>;</span>
<span class="line" id="L183">}</span>
<span class="line" id="L184"></span>
<span class="line" id="L185"><span class="tok-kw">test</span> <span class="tok-str">"math.pow"</span> {</span>
<span class="line" id="L186"> <span class="tok-kw">const</span> epsilon = <span class="tok-number">0.000001</span>;</span>
<span class="line" id="L187"></span>
<span class="line" id="L188"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f32</span>, pow(<span class="tok-type">f32</span>, <span class="tok-number">0.0</span>, <span class="tok-number">3.3</span>), <span class="tok-number">0.0</span>, epsilon));</span>
<span class="line" id="L189"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f32</span>, pow(<span class="tok-type">f32</span>, <span class="tok-number">0.8923</span>, <span class="tok-number">3.3</span>), <span class="tok-number">0.686572</span>, epsilon));</span>
<span class="line" id="L190"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f32</span>, pow(<span class="tok-type">f32</span>, <span class="tok-number">0.2</span>, <span class="tok-number">3.3</span>), <span class="tok-number">0.004936</span>, epsilon));</span>
<span class="line" id="L191"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f32</span>, pow(<span class="tok-type">f32</span>, <span class="tok-number">1.5</span>, <span class="tok-number">3.3</span>), <span class="tok-number">3.811546</span>, epsilon));</span>
<span class="line" id="L192"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f32</span>, pow(<span class="tok-type">f32</span>, <span class="tok-number">37.45</span>, <span class="tok-number">3.3</span>), <span class="tok-number">155736.703125</span>, epsilon));</span>
<span class="line" id="L193"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f32</span>, pow(<span class="tok-type">f32</span>, <span class="tok-number">89.123</span>, <span class="tok-number">3.3</span>), <span class="tok-number">2722489.5</span>, epsilon));</span>
<span class="line" id="L194"></span>
<span class="line" id="L195"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f64</span>, pow(<span class="tok-type">f64</span>, <span class="tok-number">0.0</span>, <span class="tok-number">3.3</span>), <span class="tok-number">0.0</span>, epsilon));</span>
<span class="line" id="L196"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f64</span>, pow(<span class="tok-type">f64</span>, <span class="tok-number">0.8923</span>, <span class="tok-number">3.3</span>), <span class="tok-number">0.686572</span>, epsilon));</span>
<span class="line" id="L197"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f64</span>, pow(<span class="tok-type">f64</span>, <span class="tok-number">0.2</span>, <span class="tok-number">3.3</span>), <span class="tok-number">0.004936</span>, epsilon));</span>
<span class="line" id="L198"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f64</span>, pow(<span class="tok-type">f64</span>, <span class="tok-number">1.5</span>, <span class="tok-number">3.3</span>), <span class="tok-number">3.811546</span>, epsilon));</span>
<span class="line" id="L199"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f64</span>, pow(<span class="tok-type">f64</span>, <span class="tok-number">37.45</span>, <span class="tok-number">3.3</span>), <span class="tok-number">155736.7160616</span>, epsilon));</span>
<span class="line" id="L200"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f64</span>, pow(<span class="tok-type">f64</span>, <span class="tok-number">89.123</span>, <span class="tok-number">3.3</span>), <span class="tok-number">2722490.231436</span>, epsilon));</span>
<span class="line" id="L201">}</span>
<span class="line" id="L202"></span>
<span class="line" id="L203"><span class="tok-kw">test</span> <span class="tok-str">"math.pow.special"</span> {</span>
<span class="line" id="L204"> <span class="tok-kw">const</span> epsilon = <span class="tok-number">0.000001</span>;</span>
<span class="line" id="L205"></span>
<span class="line" id="L206"> <span class="tok-kw">try</span> expect(pow(<span class="tok-type">f32</span>, <span class="tok-number">4</span>, <span class="tok-number">0.0</span>) == <span class="tok-number">1.0</span>);</span>
<span class="line" id="L207"> <span class="tok-kw">try</span> expect(pow(<span class="tok-type">f32</span>, <span class="tok-number">7</span>, -<span class="tok-number">0.0</span>) == <span class="tok-number">1.0</span>);</span>
<span class="line" id="L208"> <span class="tok-kw">try</span> expect(pow(<span class="tok-type">f32</span>, <span class="tok-number">45</span>, <span class="tok-number">1.0</span>) == <span class="tok-number">45</span>);</span>
<span class="line" id="L209"> <span class="tok-kw">try</span> expect(pow(<span class="tok-type">f32</span>, -<span class="tok-number">45</span>, <span class="tok-number">1.0</span>) == -<span class="tok-number">45</span>);</span>
<span class="line" id="L210"> <span class="tok-kw">try</span> expect(math.isNan(pow(<span class="tok-type">f32</span>, math.nan(<span class="tok-type">f32</span>), <span class="tok-number">5.0</span>)));</span>
<span class="line" id="L211"> <span class="tok-kw">try</span> expect(math.isPositiveInf(pow(<span class="tok-type">f32</span>, -math.inf(<span class="tok-type">f32</span>), <span class="tok-number">0.5</span>)));</span>
<span class="line" id="L212"> <span class="tok-kw">try</span> expect(math.isPositiveInf(pow(<span class="tok-type">f32</span>, -<span class="tok-number">0</span>, -<span class="tok-number">0.5</span>)));</span>
<span class="line" id="L213"> <span class="tok-kw">try</span> expect(pow(<span class="tok-type">f32</span>, -<span class="tok-number">0</span>, <span class="tok-number">0.5</span>) == <span class="tok-number">0</span>);</span>
<span class="line" id="L214"> <span class="tok-kw">try</span> expect(math.isNan(pow(<span class="tok-type">f32</span>, <span class="tok-number">5.0</span>, math.nan(<span class="tok-type">f32</span>))));</span>
<span class="line" id="L215"> <span class="tok-kw">try</span> expect(math.isPositiveInf(pow(<span class="tok-type">f32</span>, <span class="tok-number">0.0</span>, -<span class="tok-number">1.0</span>)));</span>
<span class="line" id="L216"> <span class="tok-comment">//expect(math.isNegativeInf(pow(f32, -0.0, -3.0))); TODO is this required?</span>
</span>
<span class="line" id="L217"> <span class="tok-kw">try</span> expect(math.isPositiveInf(pow(<span class="tok-type">f32</span>, <span class="tok-number">0.0</span>, -math.inf(<span class="tok-type">f32</span>))));</span>
<span class="line" id="L218"> <span class="tok-kw">try</span> expect(math.isPositiveInf(pow(<span class="tok-type">f32</span>, -<span class="tok-number">0.0</span>, -math.inf(<span class="tok-type">f32</span>))));</span>
<span class="line" id="L219"> <span class="tok-kw">try</span> expect(pow(<span class="tok-type">f32</span>, <span class="tok-number">0.0</span>, math.inf(<span class="tok-type">f32</span>)) == <span class="tok-number">0.0</span>);</span>
<span class="line" id="L220"> <span class="tok-kw">try</span> expect(pow(<span class="tok-type">f32</span>, -<span class="tok-number">0.0</span>, math.inf(<span class="tok-type">f32</span>)) == <span class="tok-number">0.0</span>);</span>
<span class="line" id="L221"> <span class="tok-kw">try</span> expect(math.isPositiveInf(pow(<span class="tok-type">f32</span>, <span class="tok-number">0.0</span>, -<span class="tok-number">2.0</span>)));</span>
<span class="line" id="L222"> <span class="tok-kw">try</span> expect(math.isPositiveInf(pow(<span class="tok-type">f32</span>, -<span class="tok-number">0.0</span>, -<span class="tok-number">2.0</span>)));</span>
<span class="line" id="L223"> <span class="tok-kw">try</span> expect(pow(<span class="tok-type">f32</span>, <span class="tok-number">0.0</span>, <span class="tok-number">1.0</span>) == <span class="tok-number">0.0</span>);</span>
<span class="line" id="L224"> <span class="tok-kw">try</span> expect(pow(<span class="tok-type">f32</span>, -<span class="tok-number">0.0</span>, <span class="tok-number">1.0</span>) == -<span class="tok-number">0.0</span>);</span>
<span class="line" id="L225"> <span class="tok-kw">try</span> expect(pow(<span class="tok-type">f32</span>, <span class="tok-number">0.0</span>, <span class="tok-number">2.0</span>) == <span class="tok-number">0.0</span>);</span>
<span class="line" id="L226"> <span class="tok-kw">try</span> expect(pow(<span class="tok-type">f32</span>, -<span class="tok-number">0.0</span>, <span class="tok-number">2.0</span>) == <span class="tok-number">0.0</span>);</span>
<span class="line" id="L227"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f32</span>, pow(<span class="tok-type">f32</span>, -<span class="tok-number">1.0</span>, math.inf(<span class="tok-type">f32</span>)), <span class="tok-number">1.0</span>, epsilon));</span>
<span class="line" id="L228"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f32</span>, pow(<span class="tok-type">f32</span>, -<span class="tok-number">1.0</span>, -math.inf(<span class="tok-type">f32</span>)), <span class="tok-number">1.0</span>, epsilon));</span>
<span class="line" id="L229"> <span class="tok-kw">try</span> expect(math.isPositiveInf(pow(<span class="tok-type">f32</span>, <span class="tok-number">1.2</span>, math.inf(<span class="tok-type">f32</span>))));</span>
<span class="line" id="L230"> <span class="tok-kw">try</span> expect(math.isPositiveInf(pow(<span class="tok-type">f32</span>, -<span class="tok-number">1.2</span>, math.inf(<span class="tok-type">f32</span>))));</span>
<span class="line" id="L231"> <span class="tok-kw">try</span> expect(pow(<span class="tok-type">f32</span>, <span class="tok-number">1.2</span>, -math.inf(<span class="tok-type">f32</span>)) == <span class="tok-number">0.0</span>);</span>
<span class="line" id="L232"> <span class="tok-kw">try</span> expect(pow(<span class="tok-type">f32</span>, -<span class="tok-number">1.2</span>, -math.inf(<span class="tok-type">f32</span>)) == <span class="tok-number">0.0</span>);</span>
<span class="line" id="L233"> <span class="tok-kw">try</span> expect(pow(<span class="tok-type">f32</span>, <span class="tok-number">0.2</span>, math.inf(<span class="tok-type">f32</span>)) == <span class="tok-number">0.0</span>);</span>
<span class="line" id="L234"> <span class="tok-kw">try</span> expect(pow(<span class="tok-type">f32</span>, -<span class="tok-number">0.2</span>, math.inf(<span class="tok-type">f32</span>)) == <span class="tok-number">0.0</span>);</span>
<span class="line" id="L235"> <span class="tok-kw">try</span> expect(math.isPositiveInf(pow(<span class="tok-type">f32</span>, <span class="tok-number">0.2</span>, -math.inf(<span class="tok-type">f32</span>))));</span>
<span class="line" id="L236"> <span class="tok-kw">try</span> expect(math.isPositiveInf(pow(<span class="tok-type">f32</span>, -<span class="tok-number">0.2</span>, -math.inf(<span class="tok-type">f32</span>))));</span>
<span class="line" id="L237"> <span class="tok-kw">try</span> expect(math.isPositiveInf(pow(<span class="tok-type">f32</span>, math.inf(<span class="tok-type">f32</span>), <span class="tok-number">1.0</span>)));</span>
<span class="line" id="L238"> <span class="tok-kw">try</span> expect(pow(<span class="tok-type">f32</span>, math.inf(<span class="tok-type">f32</span>), -<span class="tok-number">1.0</span>) == <span class="tok-number">0.0</span>);</span>
<span class="line" id="L239"> <span class="tok-comment">//expect(pow(f32, -math.inf(f32), 5.0) == pow(f32, -0.0, -5.0)); TODO support negative 0?</span>
</span>
<span class="line" id="L240"> <span class="tok-kw">try</span> expect(pow(<span class="tok-type">f32</span>, -math.inf(<span class="tok-type">f32</span>), -<span class="tok-number">5.2</span>) == pow(<span class="tok-type">f32</span>, -<span class="tok-number">0.0</span>, <span class="tok-number">5.2</span>));</span>
<span class="line" id="L241"> <span class="tok-kw">try</span> expect(math.isNan(pow(<span class="tok-type">f32</span>, -<span class="tok-number">1.0</span>, <span class="tok-number">1.2</span>)));</span>
<span class="line" id="L242"> <span class="tok-kw">try</span> expect(math.isNan(pow(<span class="tok-type">f32</span>, -<span class="tok-number">12.4</span>, <span class="tok-number">78.5</span>)));</span>
<span class="line" id="L243">}</span>
<span class="line" id="L244"></span>
<span class="line" id="L245"><span class="tok-kw">test</span> <span class="tok-str">"math.pow.overflow"</span> {</span>
<span class="line" id="L246"> <span class="tok-kw">try</span> expect(math.isPositiveInf(pow(<span class="tok-type">f64</span>, <span class="tok-number">2</span>, <span class="tok-number">1</span> << <span class="tok-number">32</span>)));</span>
<span class="line" id="L247"> <span class="tok-kw">try</span> expect(pow(<span class="tok-type">f64</span>, <span class="tok-number">2</span>, -(<span class="tok-number">1</span> << <span class="tok-number">32</span>)) == <span class="tok-number">0</span>);</span>
<span class="line" id="L248"> <span class="tok-kw">try</span> expect(math.isNegativeInf(pow(<span class="tok-type">f64</span>, -<span class="tok-number">2</span>, (<span class="tok-number">1</span> << <span class="tok-number">32</span>) + <span class="tok-number">1</span>)));</span>
<span class="line" id="L249"> <span class="tok-kw">try</span> expect(pow(<span class="tok-type">f64</span>, <span class="tok-number">0.5</span>, <span class="tok-number">1</span> << <span class="tok-number">45</span>) == <span class="tok-number">0</span>);</span>
<span class="line" id="L250"> <span class="tok-kw">try</span> expect(math.isPositiveInf(pow(<span class="tok-type">f64</span>, <span class="tok-number">0.5</span>, -(<span class="tok-number">1</span> << <span class="tok-number">45</span>))));</span>
<span class="line" id="L251">}</span>
<span class="line" id="L252"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/math/ldexp.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>math/ldexp.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"std"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> math = std.math;</span>
<span class="line" id="L3"><span class="tok-kw">const</span> Log2Int = std.math.Log2Int;</span>
<span class="line" id="L4"><span class="tok-kw">const</span> assert = std.debug.assert;</span>
<span class="line" id="L5"><span class="tok-kw">const</span> expect = std.testing.expect;</span>
<span class="line" id="L6"></span>
<span class="line" id="L7"><span class="tok-comment">/// Returns x * 2^n.</span></span>
<span class="line" id="L8"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">ldexp</span>(x: <span class="tok-kw">anytype</span>, n: <span class="tok-type">i32</span>) <span class="tok-builtin">@TypeOf</span>(x) {</span>
<span class="line" id="L9"> <span class="tok-kw">const</span> T = <span class="tok-builtin">@TypeOf</span>(x);</span>
<span class="line" id="L10"> <span class="tok-kw">const</span> TBits = std.meta.Int(.unsigned, <span class="tok-builtin">@typeInfo</span>(T).Float.bits);</span>
<span class="line" id="L11"></span>
<span class="line" id="L12"> <span class="tok-kw">const</span> exponent_bits = math.floatExponentBits(T);</span>
<span class="line" id="L13"> <span class="tok-kw">const</span> mantissa_bits = math.floatMantissaBits(T);</span>
<span class="line" id="L14"> <span class="tok-kw">const</span> fractional_bits = math.floatFractionalBits(T);</span>
<span class="line" id="L15"></span>
<span class="line" id="L16"> <span class="tok-kw">const</span> max_biased_exponent = <span class="tok-number">2</span> * math.floatExponentMax(T);</span>
<span class="line" id="L17"> <span class="tok-kw">const</span> mantissa_mask = <span class="tok-builtin">@as</span>(TBits, (<span class="tok-number">1</span> << mantissa_bits) - <span class="tok-number">1</span>);</span>
<span class="line" id="L18"></span>
<span class="line" id="L19"> <span class="tok-kw">const</span> repr = <span class="tok-builtin">@as</span>(TBits, <span class="tok-builtin">@bitCast</span>(x));</span>
<span class="line" id="L20"> <span class="tok-kw">const</span> sign_bit = repr & (<span class="tok-number">1</span> << (exponent_bits + mantissa_bits));</span>
<span class="line" id="L21"></span>
<span class="line" id="L22"> <span class="tok-kw">if</span> (math.isNan(x) <span class="tok-kw">or</span> !math.isFinite(x))</span>
<span class="line" id="L23"> <span class="tok-kw">return</span> x;</span>
<span class="line" id="L24"></span>
<span class="line" id="L25"> <span class="tok-kw">var</span> exponent: <span class="tok-type">i32</span> = <span class="tok-builtin">@as</span>(<span class="tok-type">i32</span>, <span class="tok-builtin">@intCast</span>((repr << <span class="tok-number">1</span>) >> (mantissa_bits + <span class="tok-number">1</span>)));</span>
<span class="line" id="L26"> <span class="tok-kw">if</span> (exponent == <span class="tok-number">0</span>)</span>
<span class="line" id="L27"> exponent += (<span class="tok-builtin">@as</span>(<span class="tok-type">i32</span>, exponent_bits) + <span class="tok-builtin">@intFromBool</span>(T == <span class="tok-type">f80</span>)) - <span class="tok-builtin">@clz</span>(repr << <span class="tok-number">1</span>);</span>
<span class="line" id="L28"></span>
<span class="line" id="L29"> <span class="tok-kw">if</span> (n >= <span class="tok-number">0</span>) {</span>
<span class="line" id="L30"> <span class="tok-kw">if</span> (n > max_biased_exponent - exponent) {</span>
<span class="line" id="L31"> <span class="tok-comment">// Overflow. Return +/- inf</span>
</span>
<span class="line" id="L32"> <span class="tok-kw">return</span> <span class="tok-builtin">@as</span>(T, <span class="tok-builtin">@bitCast</span>(<span class="tok-builtin">@as</span>(TBits, <span class="tok-builtin">@bitCast</span>(math.inf(T))) | sign_bit));</span>
<span class="line" id="L33"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (exponent + n <= <span class="tok-number">0</span>) {</span>
<span class="line" id="L34"> <span class="tok-comment">// Result is subnormal</span>
</span>
<span class="line" id="L35"> <span class="tok-kw">return</span> <span class="tok-builtin">@as</span>(T, <span class="tok-builtin">@bitCast</span>((repr << <span class="tok-builtin">@as</span>(Log2Int(TBits), <span class="tok-builtin">@intCast</span>(n))) | sign_bit));</span>
<span class="line" id="L36"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (exponent <= <span class="tok-number">0</span>) {</span>
<span class="line" id="L37"> <span class="tok-comment">// Result is normal, but needs shifting</span>
</span>
<span class="line" id="L38"> <span class="tok-kw">var</span> result = <span class="tok-builtin">@as</span>(TBits, <span class="tok-builtin">@intCast</span>(n + exponent)) << mantissa_bits;</span>
<span class="line" id="L39"> result |= (repr << <span class="tok-builtin">@as</span>(Log2Int(TBits), <span class="tok-builtin">@intCast</span>(<span class="tok-number">1</span> - exponent))) & mantissa_mask;</span>
<span class="line" id="L40"> <span class="tok-kw">return</span> <span class="tok-builtin">@as</span>(T, <span class="tok-builtin">@bitCast</span>(result | sign_bit));</span>
<span class="line" id="L41"> }</span>
<span class="line" id="L42"></span>
<span class="line" id="L43"> <span class="tok-comment">// Result needs no shifting</span>
</span>
<span class="line" id="L44"> <span class="tok-kw">return</span> <span class="tok-builtin">@as</span>(T, <span class="tok-builtin">@bitCast</span>(repr + (<span class="tok-builtin">@as</span>(TBits, <span class="tok-builtin">@intCast</span>(n)) << mantissa_bits)));</span>
<span class="line" id="L45"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L46"> <span class="tok-kw">if</span> (n <= -exponent) {</span>
<span class="line" id="L47"> <span class="tok-kw">if</span> (n < -(mantissa_bits + exponent))</span>
<span class="line" id="L48"> <span class="tok-kw">return</span> <span class="tok-builtin">@as</span>(T, <span class="tok-builtin">@bitCast</span>(sign_bit)); <span class="tok-comment">// Severe underflow. Return +/- 0</span>
</span>
<span class="line" id="L49"></span>
<span class="line" id="L50"> <span class="tok-comment">// Result underflowed, we need to shift and round</span>
</span>
<span class="line" id="L51"> <span class="tok-kw">const</span> shift = <span class="tok-builtin">@as</span>(Log2Int(TBits), <span class="tok-builtin">@intCast</span>(<span class="tok-builtin">@min</span>(-n, -(exponent + n) + <span class="tok-number">1</span>)));</span>
<span class="line" id="L52"> <span class="tok-kw">const</span> exact_tie: <span class="tok-type">bool</span> = <span class="tok-builtin">@ctz</span>(repr) == shift - <span class="tok-number">1</span>;</span>
<span class="line" id="L53"> <span class="tok-kw">var</span> result = repr & mantissa_mask;</span>
<span class="line" id="L54"></span>
<span class="line" id="L55"> <span class="tok-kw">if</span> (T != <span class="tok-type">f80</span>) <span class="tok-comment">// Include integer bit</span>
</span>
<span class="line" id="L56"> result |= <span class="tok-builtin">@as</span>(TBits, <span class="tok-builtin">@intFromBool</span>(exponent > <span class="tok-number">0</span>)) << fractional_bits;</span>
<span class="line" id="L57"> result = <span class="tok-builtin">@as</span>(TBits, <span class="tok-builtin">@intCast</span>((result >> (shift - <span class="tok-number">1</span>))));</span>
<span class="line" id="L58"></span>
<span class="line" id="L59"> <span class="tok-comment">// Round result, including round-to-even for exact ties</span>
</span>
<span class="line" id="L60"> result = ((result + <span class="tok-number">1</span>) >> <span class="tok-number">1</span>) & ~<span class="tok-builtin">@as</span>(TBits, <span class="tok-builtin">@intFromBool</span>(exact_tie));</span>
<span class="line" id="L61"> <span class="tok-kw">return</span> <span class="tok-builtin">@as</span>(T, <span class="tok-builtin">@bitCast</span>(result | sign_bit));</span>
<span class="line" id="L62"> }</span>
<span class="line" id="L63"></span>
<span class="line" id="L64"> <span class="tok-comment">// Result is exact, and needs no shifting</span>
</span>
<span class="line" id="L65"> <span class="tok-kw">return</span> <span class="tok-builtin">@as</span>(T, <span class="tok-builtin">@bitCast</span>(repr - (<span class="tok-builtin">@as</span>(TBits, <span class="tok-builtin">@intCast</span>(-n)) << mantissa_bits)));</span>
<span class="line" id="L66"> }</span>
<span class="line" id="L67">}</span>
<span class="line" id="L68"></span>
<span class="line" id="L69"><span class="tok-kw">test</span> <span class="tok-str">"math.ldexp"</span> {</span>
<span class="line" id="L70"></span>
<span class="line" id="L71"> <span class="tok-comment">// subnormals</span>
</span>
<span class="line" id="L72"> <span class="tok-kw">try</span> expect(ldexp(<span class="tok-builtin">@as</span>(<span class="tok-type">f16</span>, <span class="tok-number">0x1.1FFp14</span>), -<span class="tok-number">14</span> - <span class="tok-number">9</span> - <span class="tok-number">15</span>) == math.floatTrueMin(<span class="tok-type">f16</span>));</span>
<span class="line" id="L73"> <span class="tok-kw">try</span> expect(ldexp(<span class="tok-builtin">@as</span>(<span class="tok-type">f32</span>, <span class="tok-number">0x1.3FFFFFp-1</span>), -<span class="tok-number">126</span> - <span class="tok-number">22</span>) == math.floatTrueMin(<span class="tok-type">f32</span>));</span>
<span class="line" id="L74"> <span class="tok-kw">try</span> expect(ldexp(<span class="tok-builtin">@as</span>(<span class="tok-type">f64</span>, <span class="tok-number">0x1.7FFFFFFFFFFFFp-1</span>), -<span class="tok-number">1022</span> - <span class="tok-number">51</span>) == math.floatTrueMin(<span class="tok-type">f64</span>));</span>
<span class="line" id="L75"> <span class="tok-kw">try</span> expect(ldexp(<span class="tok-builtin">@as</span>(<span class="tok-type">f80</span>, <span class="tok-number">0x1.7FFFFFFFFFFFFFFEp-1</span>), -<span class="tok-number">16382</span> - <span class="tok-number">62</span>) == math.floatTrueMin(<span class="tok-type">f80</span>));</span>
<span class="line" id="L76"> <span class="tok-kw">try</span> expect(ldexp(<span class="tok-builtin">@as</span>(<span class="tok-type">f128</span>, <span class="tok-number">0x1.7FFFFFFFFFFFFFFFFFFFFFFFFFFFp-1</span>), -<span class="tok-number">16382</span> - <span class="tok-number">111</span>) == math.floatTrueMin(<span class="tok-type">f128</span>));</span>
<span class="line" id="L77"></span>
<span class="line" id="L78"> <span class="tok-kw">try</span> expect(ldexp(math.floatMax(<span class="tok-type">f32</span>), -<span class="tok-number">128</span> - <span class="tok-number">149</span>) > <span class="tok-number">0.0</span>);</span>
<span class="line" id="L79"> <span class="tok-kw">try</span> expect(ldexp(math.floatMax(<span class="tok-type">f32</span>), -<span class="tok-number">128</span> - <span class="tok-number">149</span> - <span class="tok-number">1</span>) == <span class="tok-number">0.0</span>);</span>
<span class="line" id="L80"></span>
<span class="line" id="L81"> <span class="tok-builtin">@setEvalBranchQuota</span>(<span class="tok-number">10_000</span>);</span>
<span class="line" id="L82"></span>
<span class="line" id="L83"> <span class="tok-kw">inline</span> <span class="tok-kw">for</span> ([_]<span class="tok-type">type</span>{ <span class="tok-type">f16</span>, <span class="tok-type">f32</span>, <span class="tok-type">f64</span>, <span class="tok-type">f80</span>, <span class="tok-type">f128</span> }) |T| {</span>
<span class="line" id="L84"> <span class="tok-kw">const</span> fractional_bits = math.floatFractionalBits(T);</span>
<span class="line" id="L85"></span>
<span class="line" id="L86"> <span class="tok-kw">const</span> min_exponent = math.floatExponentMin(T);</span>
<span class="line" id="L87"> <span class="tok-kw">const</span> max_exponent = math.floatExponentMax(T);</span>
<span class="line" id="L88"> <span class="tok-kw">const</span> exponent_bias = max_exponent;</span>
<span class="line" id="L89"></span>
<span class="line" id="L90"> <span class="tok-comment">// basic usage</span>
</span>
<span class="line" id="L91"> <span class="tok-kw">try</span> expect(ldexp(<span class="tok-builtin">@as</span>(T, <span class="tok-number">1.5</span>), <span class="tok-number">4</span>) == <span class="tok-number">24.0</span>);</span>
<span class="line" id="L92"></span>
<span class="line" id="L93"> <span class="tok-comment">// normals -> subnormals</span>
</span>
<span class="line" id="L94"> <span class="tok-kw">try</span> expect(math.isNormal(ldexp(<span class="tok-builtin">@as</span>(T, <span class="tok-number">1.0</span>), min_exponent)));</span>
<span class="line" id="L95"> <span class="tok-kw">try</span> expect(!math.isNormal(ldexp(<span class="tok-builtin">@as</span>(T, <span class="tok-number">1.0</span>), min_exponent - <span class="tok-number">1</span>)));</span>
<span class="line" id="L96"></span>
<span class="line" id="L97"> <span class="tok-comment">// normals -> zero</span>
</span>
<span class="line" id="L98"> <span class="tok-kw">try</span> expect(ldexp(<span class="tok-builtin">@as</span>(T, <span class="tok-number">1.0</span>), min_exponent - fractional_bits) > <span class="tok-number">0.0</span>);</span>
<span class="line" id="L99"> <span class="tok-kw">try</span> expect(ldexp(<span class="tok-builtin">@as</span>(T, <span class="tok-number">1.0</span>), min_exponent - fractional_bits - <span class="tok-number">1</span>) == <span class="tok-number">0.0</span>);</span>
<span class="line" id="L100"></span>
<span class="line" id="L101"> <span class="tok-comment">// subnormals -> zero</span>
</span>
<span class="line" id="L102"> <span class="tok-kw">try</span> expect(ldexp(math.floatTrueMin(T), <span class="tok-number">0</span>) > <span class="tok-number">0.0</span>);</span>
<span class="line" id="L103"> <span class="tok-kw">try</span> expect(ldexp(math.floatTrueMin(T), -<span class="tok-number">1</span>) == <span class="tok-number">0.0</span>);</span>
<span class="line" id="L104"></span>
<span class="line" id="L105"> <span class="tok-comment">// Multiplications might flush the denormals to zero, esp. at</span>
</span>
<span class="line" id="L106"> <span class="tok-comment">// runtime, so we manually construct the constants here instead.</span>
</span>
<span class="line" id="L107"> <span class="tok-kw">const</span> Z = std.meta.Int(.unsigned, <span class="tok-builtin">@bitSizeOf</span>(T));</span>
<span class="line" id="L108"> <span class="tok-kw">const</span> EightTimesTrueMin = <span class="tok-builtin">@as</span>(T, <span class="tok-builtin">@bitCast</span>(<span class="tok-builtin">@as</span>(Z, <span class="tok-number">8</span>)));</span>
<span class="line" id="L109"> <span class="tok-kw">const</span> TwoTimesTrueMin = <span class="tok-builtin">@as</span>(T, <span class="tok-builtin">@bitCast</span>(<span class="tok-builtin">@as</span>(Z, <span class="tok-number">2</span>)));</span>
<span class="line" id="L110"></span>
<span class="line" id="L111"> <span class="tok-comment">// subnormals -> subnormals</span>
</span>
<span class="line" id="L112"> <span class="tok-kw">try</span> expect(ldexp(math.floatTrueMin(T), <span class="tok-number">3</span>) == EightTimesTrueMin);</span>
<span class="line" id="L113"> <span class="tok-kw">try</span> expect(ldexp(EightTimesTrueMin, -<span class="tok-number">2</span>) == TwoTimesTrueMin);</span>
<span class="line" id="L114"> <span class="tok-kw">try</span> expect(ldexp(EightTimesTrueMin, -<span class="tok-number">3</span>) == math.floatTrueMin(T));</span>
<span class="line" id="L115"></span>
<span class="line" id="L116"> <span class="tok-comment">// subnormals -> normals (+)</span>
</span>
<span class="line" id="L117"> <span class="tok-kw">try</span> expect(ldexp(math.floatTrueMin(T), fractional_bits) == math.floatMin(T));</span>
<span class="line" id="L118"> <span class="tok-kw">try</span> expect(ldexp(math.floatTrueMin(T), fractional_bits - <span class="tok-number">1</span>) == math.floatMin(T) * <span class="tok-number">0.5</span>);</span>
<span class="line" id="L119"></span>
<span class="line" id="L120"> <span class="tok-comment">// subnormals -> normals (-)</span>
</span>
<span class="line" id="L121"> <span class="tok-kw">try</span> expect(ldexp(-math.floatTrueMin(T), fractional_bits) == -math.floatMin(T));</span>
<span class="line" id="L122"> <span class="tok-kw">try</span> expect(ldexp(-math.floatTrueMin(T), fractional_bits - <span class="tok-number">1</span>) == -math.floatMin(T) * <span class="tok-number">0.5</span>);</span>
<span class="line" id="L123"></span>
<span class="line" id="L124"> <span class="tok-comment">// subnormals -> float limits (+inf)</span>
</span>
<span class="line" id="L125"> <span class="tok-kw">try</span> expect(math.isFinite(ldexp(math.floatTrueMin(T), max_exponent + exponent_bias + fractional_bits - <span class="tok-number">1</span>)));</span>
<span class="line" id="L126"> <span class="tok-kw">try</span> expect(ldexp(math.floatTrueMin(T), max_exponent + exponent_bias + fractional_bits) == math.inf(T));</span>
<span class="line" id="L127"></span>
<span class="line" id="L128"> <span class="tok-comment">// subnormals -> float limits (-inf)</span>
</span>
<span class="line" id="L129"> <span class="tok-kw">try</span> expect(math.isFinite(ldexp(-math.floatTrueMin(T), max_exponent + exponent_bias + fractional_bits - <span class="tok-number">1</span>)));</span>
<span class="line" id="L130"> <span class="tok-kw">try</span> expect(ldexp(-math.floatTrueMin(T), max_exponent + exponent_bias + fractional_bits) == -math.inf(T));</span>
<span class="line" id="L131"></span>
<span class="line" id="L132"> <span class="tok-comment">// infinity -> infinity</span>
</span>
<span class="line" id="L133"> <span class="tok-kw">try</span> expect(ldexp(math.inf(T), math.maxInt(<span class="tok-type">i32</span>)) == math.inf(T));</span>
<span class="line" id="L134"> <span class="tok-kw">try</span> expect(ldexp(math.inf(T), math.minInt(<span class="tok-type">i32</span>)) == math.inf(T));</span>
<span class="line" id="L135"> <span class="tok-kw">try</span> expect(ldexp(math.inf(T), max_exponent) == math.inf(T));</span>
<span class="line" id="L136"> <span class="tok-kw">try</span> expect(ldexp(math.inf(T), min_exponent) == math.inf(T));</span>
<span class="line" id="L137"> <span class="tok-kw">try</span> expect(ldexp(-math.inf(T), math.maxInt(<span class="tok-type">i32</span>)) == -math.inf(T));</span>
<span class="line" id="L138"> <span class="tok-kw">try</span> expect(ldexp(-math.inf(T), math.minInt(<span class="tok-type">i32</span>)) == -math.inf(T));</span>
<span class="line" id="L139"></span>
<span class="line" id="L140"> <span class="tok-comment">// extremely large n</span>
</span>
<span class="line" id="L141"> <span class="tok-kw">try</span> expect(ldexp(math.floatMax(T), math.maxInt(<span class="tok-type">i32</span>)) == math.inf(T));</span>
<span class="line" id="L142"> <span class="tok-kw">try</span> expect(ldexp(math.floatMax(T), -math.maxInt(<span class="tok-type">i32</span>)) == <span class="tok-number">0.0</span>);</span>
<span class="line" id="L143"> <span class="tok-kw">try</span> expect(ldexp(math.floatMax(T), math.minInt(<span class="tok-type">i32</span>)) == <span class="tok-number">0.0</span>);</span>
<span class="line" id="L144"> <span class="tok-kw">try</span> expect(ldexp(math.floatTrueMin(T), math.maxInt(<span class="tok-type">i32</span>)) == math.inf(T));</span>
<span class="line" id="L145"> <span class="tok-kw">try</span> expect(ldexp(math.floatTrueMin(T), -math.maxInt(<span class="tok-type">i32</span>)) == <span class="tok-number">0.0</span>);</span>
<span class="line" id="L146"> <span class="tok-kw">try</span> expect(ldexp(math.floatTrueMin(T), math.minInt(<span class="tok-type">i32</span>)) == <span class="tok-number">0.0</span>);</span>
<span class="line" id="L147"> }</span>
<span class="line" id="L148">}</span>
<span class="line" id="L149"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/math/expo2.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>math/expo2.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-comment">// Ported from musl, which is licensed under the MIT license:</span>
</span>
<span class="line" id="L2"><span class="tok-comment">// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT</span>
</span>
<span class="line" id="L3"><span class="tok-comment">//</span>
</span>
<span class="line" id="L4"><span class="tok-comment">// https://git.musl-libc.org/cgit/musl/tree/src/math/__expo2f.c</span>
</span>
<span class="line" id="L5"><span class="tok-comment">// https://git.musl-libc.org/cgit/musl/tree/src/math/__expo2.c</span>
</span>
<span class="line" id="L6"></span>
<span class="line" id="L7"><span class="tok-kw">const</span> math = <span class="tok-builtin">@import</span>(<span class="tok-str">"../math.zig"</span>);</span>
<span class="line" id="L8"></span>
<span class="line" id="L9"><span class="tok-comment">/// Returns exp(x) / 2 for x >= log(maxFloat(T)).</span></span>
<span class="line" id="L10"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">expo2</span>(x: <span class="tok-kw">anytype</span>) <span class="tok-builtin">@TypeOf</span>(x) {</span>
<span class="line" id="L11"> <span class="tok-kw">const</span> T = <span class="tok-builtin">@TypeOf</span>(x);</span>
<span class="line" id="L12"> <span class="tok-kw">return</span> <span class="tok-kw">switch</span> (T) {</span>
<span class="line" id="L13"> <span class="tok-type">f32</span> => expo2f(x),</span>
<span class="line" id="L14"> <span class="tok-type">f64</span> => expo2d(x),</span>
<span class="line" id="L15"> <span class="tok-kw">else</span> => <span class="tok-builtin">@compileError</span>(<span class="tok-str">"expo2 not implemented for "</span> ++ <span class="tok-builtin">@typeName</span>(T)),</span>
<span class="line" id="L16"> };</span>
<span class="line" id="L17">}</span>
<span class="line" id="L18"></span>
<span class="line" id="L19"><span class="tok-kw">fn</span> <span class="tok-fn">expo2f</span>(x: <span class="tok-type">f32</span>) <span class="tok-type">f32</span> {</span>
<span class="line" id="L20"> <span class="tok-kw">const</span> k: <span class="tok-type">u32</span> = <span class="tok-number">235</span>;</span>
<span class="line" id="L21"> <span class="tok-kw">const</span> kln2 = <span class="tok-number">0x1.45C778p+7</span>;</span>
<span class="line" id="L22"></span>
<span class="line" id="L23"> <span class="tok-kw">const</span> u = (<span class="tok-number">0x7F</span> + k / <span class="tok-number">2</span>) << <span class="tok-number">23</span>;</span>
<span class="line" id="L24"> <span class="tok-kw">const</span> scale = <span class="tok-builtin">@as</span>(<span class="tok-type">f32</span>, <span class="tok-builtin">@bitCast</span>(u));</span>
<span class="line" id="L25"> <span class="tok-kw">return</span> <span class="tok-builtin">@exp</span>(x - kln2) * scale * scale;</span>
<span class="line" id="L26">}</span>
<span class="line" id="L27"></span>
<span class="line" id="L28"><span class="tok-kw">fn</span> <span class="tok-fn">expo2d</span>(x: <span class="tok-type">f64</span>) <span class="tok-type">f64</span> {</span>
<span class="line" id="L29"> <span class="tok-kw">const</span> k: <span class="tok-type">u32</span> = <span class="tok-number">2043</span>;</span>
<span class="line" id="L30"> <span class="tok-kw">const</span> kln2 = <span class="tok-number">0x1.62066151ADD8BP+10</span>;</span>
<span class="line" id="L31"></span>
<span class="line" id="L32"> <span class="tok-kw">const</span> u = (<span class="tok-number">0x3FF</span> + k / <span class="tok-number">2</span>) << <span class="tok-number">20</span>;</span>
<span class="line" id="L33"> <span class="tok-kw">const</span> scale = <span class="tok-builtin">@as</span>(<span class="tok-type">f64</span>, <span class="tok-builtin">@bitCast</span>(<span class="tok-builtin">@as</span>(<span class="tok-type">u64</span>, u) << <span class="tok-number">32</span>));</span>
<span class="line" id="L34"> <span class="tok-kw">return</span> <span class="tok-builtin">@exp</span>(x - kln2) * scale * scale;</span>
<span class="line" id="L35">}</span>
<span class="line" id="L36"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/math/asinh.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>math/asinh.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-comment">// Ported from musl, which is licensed under the MIT license:</span>
</span>
<span class="line" id="L2"><span class="tok-comment">// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT</span>
</span>
<span class="line" id="L3"><span class="tok-comment">//</span>
</span>
<span class="line" id="L4"><span class="tok-comment">// https://git.musl-libc.org/cgit/musl/tree/src/math/asinhf.c</span>
</span>
<span class="line" id="L5"><span class="tok-comment">// https://git.musl-libc.org/cgit/musl/tree/src/math/asinh.c</span>
</span>
<span class="line" id="L6"></span>
<span class="line" id="L7"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../std.zig"</span>);</span>
<span class="line" id="L8"><span class="tok-kw">const</span> math = std.math;</span>
<span class="line" id="L9"><span class="tok-kw">const</span> expect = std.testing.expect;</span>
<span class="line" id="L10"><span class="tok-kw">const</span> maxInt = std.math.maxInt;</span>
<span class="line" id="L11"></span>
<span class="line" id="L12"><span class="tok-comment">/// Returns the hyperbolic arc-sin of x.</span></span>
<span class="line" id="L13"><span class="tok-comment">///</span></span>
<span class="line" id="L14"><span class="tok-comment">/// Special Cases:</span></span>
<span class="line" id="L15"><span class="tok-comment">/// - asinh(+-0) = +-0</span></span>
<span class="line" id="L16"><span class="tok-comment">/// - asinh(+-inf) = +-inf</span></span>
<span class="line" id="L17"><span class="tok-comment">/// - asinh(nan) = nan</span></span>
<span class="line" id="L18"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">asinh</span>(x: <span class="tok-kw">anytype</span>) <span class="tok-builtin">@TypeOf</span>(x) {</span>
<span class="line" id="L19"> <span class="tok-kw">const</span> T = <span class="tok-builtin">@TypeOf</span>(x);</span>
<span class="line" id="L20"> <span class="tok-kw">return</span> <span class="tok-kw">switch</span> (T) {</span>
<span class="line" id="L21"> <span class="tok-type">f32</span> => asinh32(x),</span>
<span class="line" id="L22"> <span class="tok-type">f64</span> => asinh64(x),</span>
<span class="line" id="L23"> <span class="tok-kw">else</span> => <span class="tok-builtin">@compileError</span>(<span class="tok-str">"asinh not implemented for "</span> ++ <span class="tok-builtin">@typeName</span>(T)),</span>
<span class="line" id="L24"> };</span>
<span class="line" id="L25">}</span>
<span class="line" id="L26"></span>
<span class="line" id="L27"><span class="tok-comment">// asinh(x) = sign(x) * log(|x| + sqrt(x * x + 1)) ~= x - x^3/6 + o(x^5)</span>
</span>
<span class="line" id="L28"><span class="tok-kw">fn</span> <span class="tok-fn">asinh32</span>(x: <span class="tok-type">f32</span>) <span class="tok-type">f32</span> {</span>
<span class="line" id="L29"> <span class="tok-kw">const</span> u = <span class="tok-builtin">@as</span>(<span class="tok-type">u32</span>, <span class="tok-builtin">@bitCast</span>(x));</span>
<span class="line" id="L30"> <span class="tok-kw">const</span> i = u & <span class="tok-number">0x7FFFFFFF</span>;</span>
<span class="line" id="L31"> <span class="tok-kw">const</span> s = i >> <span class="tok-number">31</span>;</span>
<span class="line" id="L32"></span>
<span class="line" id="L33"> <span class="tok-kw">var</span> rx = <span class="tok-builtin">@as</span>(<span class="tok-type">f32</span>, <span class="tok-builtin">@bitCast</span>(i)); <span class="tok-comment">// |x|</span>
</span>
<span class="line" id="L34"></span>
<span class="line" id="L35"> <span class="tok-comment">// TODO: Shouldn't need this explicit check.</span>
</span>
<span class="line" id="L36"> <span class="tok-kw">if</span> (math.isNegativeInf(x)) {</span>
<span class="line" id="L37"> <span class="tok-kw">return</span> x;</span>
<span class="line" id="L38"> }</span>
<span class="line" id="L39"></span>
<span class="line" id="L40"> <span class="tok-comment">// |x| >= 0x1p12 or inf or nan</span>
</span>
<span class="line" id="L41"> <span class="tok-kw">if</span> (i >= <span class="tok-number">0x3F800000</span> + (<span class="tok-number">12</span> << <span class="tok-number">23</span>)) {</span>
<span class="line" id="L42"> rx = <span class="tok-builtin">@log</span>(rx) + <span class="tok-number">0.69314718055994530941723212145817656</span>;</span>
<span class="line" id="L43"> }</span>
<span class="line" id="L44"> <span class="tok-comment">// |x| >= 2</span>
</span>
<span class="line" id="L45"> <span class="tok-kw">else</span> <span class="tok-kw">if</span> (i >= <span class="tok-number">0x3F800000</span> + (<span class="tok-number">1</span> << <span class="tok-number">23</span>)) {</span>
<span class="line" id="L46"> rx = <span class="tok-builtin">@log</span>(<span class="tok-number">2</span> * x + <span class="tok-number">1</span> / (<span class="tok-builtin">@sqrt</span>(x * x + <span class="tok-number">1</span>) + x));</span>
<span class="line" id="L47"> }</span>
<span class="line" id="L48"> <span class="tok-comment">// |x| >= 0x1p-12, up to 1.6ulp error</span>
</span>
<span class="line" id="L49"> <span class="tok-kw">else</span> <span class="tok-kw">if</span> (i >= <span class="tok-number">0x3F800000</span> - (<span class="tok-number">12</span> << <span class="tok-number">23</span>)) {</span>
<span class="line" id="L50"> rx = math.log1p(x + x * x / (<span class="tok-builtin">@sqrt</span>(x * x + <span class="tok-number">1</span>) + <span class="tok-number">1</span>));</span>
<span class="line" id="L51"> }</span>
<span class="line" id="L52"> <span class="tok-comment">// |x| < 0x1p-12, inexact if x != 0</span>
</span>
<span class="line" id="L53"> <span class="tok-kw">else</span> {</span>
<span class="line" id="L54"> math.doNotOptimizeAway(x + <span class="tok-number">0x1.0p120</span>);</span>
<span class="line" id="L55"> }</span>
<span class="line" id="L56"></span>
<span class="line" id="L57"> <span class="tok-kw">return</span> <span class="tok-kw">if</span> (s != <span class="tok-number">0</span>) -rx <span class="tok-kw">else</span> rx;</span>
<span class="line" id="L58">}</span>
<span class="line" id="L59"></span>
<span class="line" id="L60"><span class="tok-kw">fn</span> <span class="tok-fn">asinh64</span>(x: <span class="tok-type">f64</span>) <span class="tok-type">f64</span> {</span>
<span class="line" id="L61"> <span class="tok-kw">const</span> u = <span class="tok-builtin">@as</span>(<span class="tok-type">u64</span>, <span class="tok-builtin">@bitCast</span>(x));</span>
<span class="line" id="L62"> <span class="tok-kw">const</span> e = (u >> <span class="tok-number">52</span>) & <span class="tok-number">0x7FF</span>;</span>
<span class="line" id="L63"> <span class="tok-kw">const</span> s = e >> <span class="tok-number">63</span>;</span>
<span class="line" id="L64"></span>
<span class="line" id="L65"> <span class="tok-kw">var</span> rx = <span class="tok-builtin">@as</span>(<span class="tok-type">f64</span>, <span class="tok-builtin">@bitCast</span>(u & (maxInt(<span class="tok-type">u64</span>) >> <span class="tok-number">1</span>))); <span class="tok-comment">// |x|</span>
</span>
<span class="line" id="L66"></span>
<span class="line" id="L67"> <span class="tok-kw">if</span> (math.isNegativeInf(x)) {</span>
<span class="line" id="L68"> <span class="tok-kw">return</span> x;</span>
<span class="line" id="L69"> }</span>
<span class="line" id="L70"></span>
<span class="line" id="L71"> <span class="tok-comment">// |x| >= 0x1p26 or inf or nan</span>
</span>
<span class="line" id="L72"> <span class="tok-kw">if</span> (e >= <span class="tok-number">0x3FF</span> + <span class="tok-number">26</span>) {</span>
<span class="line" id="L73"> rx = <span class="tok-builtin">@log</span>(rx) + <span class="tok-number">0.693147180559945309417232121458176568</span>;</span>
<span class="line" id="L74"> }</span>
<span class="line" id="L75"> <span class="tok-comment">// |x| >= 2</span>
</span>
<span class="line" id="L76"> <span class="tok-kw">else</span> <span class="tok-kw">if</span> (e >= <span class="tok-number">0x3FF</span> + <span class="tok-number">1</span>) {</span>
<span class="line" id="L77"> rx = <span class="tok-builtin">@log</span>(<span class="tok-number">2</span> * x + <span class="tok-number">1</span> / (<span class="tok-builtin">@sqrt</span>(x * x + <span class="tok-number">1</span>) + x));</span>
<span class="line" id="L78"> }</span>
<span class="line" id="L79"> <span class="tok-comment">// |x| >= 0x1p-12, up to 1.6ulp error</span>
</span>
<span class="line" id="L80"> <span class="tok-kw">else</span> <span class="tok-kw">if</span> (e >= <span class="tok-number">0x3FF</span> - <span class="tok-number">26</span>) {</span>
<span class="line" id="L81"> rx = math.log1p(x + x * x / (<span class="tok-builtin">@sqrt</span>(x * x + <span class="tok-number">1</span>) + <span class="tok-number">1</span>));</span>
<span class="line" id="L82"> }</span>
<span class="line" id="L83"> <span class="tok-comment">// |x| < 0x1p-12, inexact if x != 0</span>
</span>
<span class="line" id="L84"> <span class="tok-kw">else</span> {</span>
<span class="line" id="L85"> math.doNotOptimizeAway(x + <span class="tok-number">0x1.0p120</span>);</span>
<span class="line" id="L86"> }</span>
<span class="line" id="L87"></span>
<span class="line" id="L88"> <span class="tok-kw">return</span> <span class="tok-kw">if</span> (s != <span class="tok-number">0</span>) -rx <span class="tok-kw">else</span> rx;</span>
<span class="line" id="L89">}</span>
<span class="line" id="L90"></span>
<span class="line" id="L91"><span class="tok-kw">test</span> <span class="tok-str">"math.asinh"</span> {</span>
<span class="line" id="L92"> <span class="tok-kw">try</span> expect(asinh(<span class="tok-builtin">@as</span>(<span class="tok-type">f32</span>, <span class="tok-number">0.0</span>)) == asinh32(<span class="tok-number">0.0</span>));</span>
<span class="line" id="L93"> <span class="tok-kw">try</span> expect(asinh(<span class="tok-builtin">@as</span>(<span class="tok-type">f64</span>, <span class="tok-number">0.0</span>)) == asinh64(<span class="tok-number">0.0</span>));</span>
<span class="line" id="L94">}</span>
<span class="line" id="L95"></span>
<span class="line" id="L96"><span class="tok-kw">test</span> <span class="tok-str">"math.asinh32"</span> {</span>
<span class="line" id="L97"> <span class="tok-kw">const</span> epsilon = <span class="tok-number">0.000001</span>;</span>
<span class="line" id="L98"></span>
<span class="line" id="L99"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f32</span>, asinh32(<span class="tok-number">0.0</span>), <span class="tok-number">0.0</span>, epsilon));</span>
<span class="line" id="L100"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f32</span>, asinh32(-<span class="tok-number">0.2</span>), -<span class="tok-number">0.198690</span>, epsilon));</span>
<span class="line" id="L101"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f32</span>, asinh32(<span class="tok-number">0.2</span>), <span class="tok-number">0.198690</span>, epsilon));</span>
<span class="line" id="L102"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f32</span>, asinh32(<span class="tok-number">0.8923</span>), <span class="tok-number">0.803133</span>, epsilon));</span>
<span class="line" id="L103"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f32</span>, asinh32(<span class="tok-number">1.5</span>), <span class="tok-number">1.194763</span>, epsilon));</span>
<span class="line" id="L104"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f32</span>, asinh32(<span class="tok-number">37.45</span>), <span class="tok-number">4.316332</span>, epsilon));</span>
<span class="line" id="L105"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f32</span>, asinh32(<span class="tok-number">89.123</span>), <span class="tok-number">5.183196</span>, epsilon));</span>
<span class="line" id="L106"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f32</span>, asinh32(<span class="tok-number">123123.234375</span>), <span class="tok-number">12.414088</span>, epsilon));</span>
<span class="line" id="L107">}</span>
<span class="line" id="L108"></span>
<span class="line" id="L109"><span class="tok-kw">test</span> <span class="tok-str">"math.asinh64"</span> {</span>
<span class="line" id="L110"> <span class="tok-kw">const</span> epsilon = <span class="tok-number">0.000001</span>;</span>
<span class="line" id="L111"></span>
<span class="line" id="L112"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f64</span>, asinh64(<span class="tok-number">0.0</span>), <span class="tok-number">0.0</span>, epsilon));</span>
<span class="line" id="L113"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f64</span>, asinh64(-<span class="tok-number">0.2</span>), -<span class="tok-number">0.198690</span>, epsilon));</span>
<span class="line" id="L114"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f64</span>, asinh64(<span class="tok-number">0.2</span>), <span class="tok-number">0.198690</span>, epsilon));</span>
<span class="line" id="L115"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f64</span>, asinh64(<span class="tok-number">0.8923</span>), <span class="tok-number">0.803133</span>, epsilon));</span>
<span class="line" id="L116"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f64</span>, asinh64(<span class="tok-number">1.5</span>), <span class="tok-number">1.194763</span>, epsilon));</span>
<span class="line" id="L117"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f64</span>, asinh64(<span class="tok-number">37.45</span>), <span class="tok-number">4.316332</span>, epsilon));</span>
<span class="line" id="L118"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f64</span>, asinh64(<span class="tok-number">89.123</span>), <span class="tok-number">5.183196</span>, epsilon));</span>
<span class="line" id="L119"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f64</span>, asinh64(<span class="tok-number">123123.234375</span>), <span class="tok-number">12.414088</span>, epsilon));</span>
<span class="line" id="L120">}</span>
<span class="line" id="L121"></span>
<span class="line" id="L122"><span class="tok-kw">test</span> <span class="tok-str">"math.asinh32.special"</span> {</span>
<span class="line" id="L123"> <span class="tok-kw">try</span> expect(asinh32(<span class="tok-number">0.0</span>) == <span class="tok-number">0.0</span>);</span>
<span class="line" id="L124"> <span class="tok-kw">try</span> expect(asinh32(-<span class="tok-number">0.0</span>) == -<span class="tok-number">0.0</span>);</span>
<span class="line" id="L125"> <span class="tok-kw">try</span> expect(math.isPositiveInf(asinh32(math.inf(<span class="tok-type">f32</span>))));</span>
<span class="line" id="L126"> <span class="tok-kw">try</span> expect(math.isNegativeInf(asinh32(-math.inf(<span class="tok-type">f32</span>))));</span>
<span class="line" id="L127"> <span class="tok-kw">try</span> expect(math.isNan(asinh32(math.nan(<span class="tok-type">f32</span>))));</span>
<span class="line" id="L128">}</span>
<span class="line" id="L129"></span>
<span class="line" id="L130"><span class="tok-kw">test</span> <span class="tok-str">"math.asinh64.special"</span> {</span>
<span class="line" id="L131"> <span class="tok-kw">try</span> expect(asinh64(<span class="tok-number">0.0</span>) == <span class="tok-number">0.0</span>);</span>
<span class="line" id="L132"> <span class="tok-kw">try</span> expect(asinh64(-<span class="tok-number">0.0</span>) == -<span class="tok-number">0.0</span>);</span>
<span class="line" id="L133"> <span class="tok-kw">try</span> expect(math.isPositiveInf(asinh64(math.inf(<span class="tok-type">f64</span>))));</span>
<span class="line" id="L134"> <span class="tok-kw">try</span> expect(math.isNegativeInf(asinh64(-math.inf(<span class="tok-type">f64</span>))));</span>
<span class="line" id="L135"> <span class="tok-kw">try</span> expect(math.isNan(asinh64(math.nan(<span class="tok-type">f64</span>))));</span>
<span class="line" id="L136">}</span>
<span class="line" id="L137"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/math/acosh.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>math/acosh.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-comment">// Ported from musl, which is licensed under the MIT license:</span>
</span>
<span class="line" id="L2"><span class="tok-comment">// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT</span>
</span>
<span class="line" id="L3"><span class="tok-comment">//</span>
</span>
<span class="line" id="L4"><span class="tok-comment">// https://git.musl-libc.org/cgit/musl/tree/src/math/acoshf.c</span>
</span>
<span class="line" id="L5"><span class="tok-comment">// https://git.musl-libc.org/cgit/musl/tree/src/math/acosh.c</span>
</span>
<span class="line" id="L6"></span>
<span class="line" id="L7"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../std.zig"</span>);</span>
<span class="line" id="L8"><span class="tok-kw">const</span> math = std.math;</span>
<span class="line" id="L9"><span class="tok-kw">const</span> expect = std.testing.expect;</span>
<span class="line" id="L10"></span>
<span class="line" id="L11"><span class="tok-comment">/// Returns the hyperbolic arc-cosine of x.</span></span>
<span class="line" id="L12"><span class="tok-comment">///</span></span>
<span class="line" id="L13"><span class="tok-comment">/// Special cases:</span></span>
<span class="line" id="L14"><span class="tok-comment">/// - acosh(x) = snan if x < 1</span></span>
<span class="line" id="L15"><span class="tok-comment">/// - acosh(nan) = nan</span></span>
<span class="line" id="L16"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">acosh</span>(x: <span class="tok-kw">anytype</span>) <span class="tok-builtin">@TypeOf</span>(x) {</span>
<span class="line" id="L17"> <span class="tok-kw">const</span> T = <span class="tok-builtin">@TypeOf</span>(x);</span>
<span class="line" id="L18"> <span class="tok-kw">return</span> <span class="tok-kw">switch</span> (T) {</span>
<span class="line" id="L19"> <span class="tok-type">f32</span> => acosh32(x),</span>
<span class="line" id="L20"> <span class="tok-type">f64</span> => acosh64(x),</span>
<span class="line" id="L21"> <span class="tok-kw">else</span> => <span class="tok-builtin">@compileError</span>(<span class="tok-str">"acosh not implemented for "</span> ++ <span class="tok-builtin">@typeName</span>(T)),</span>
<span class="line" id="L22"> };</span>
<span class="line" id="L23">}</span>
<span class="line" id="L24"></span>
<span class="line" id="L25"><span class="tok-comment">// acosh(x) = log(x + sqrt(x * x - 1))</span>
</span>
<span class="line" id="L26"><span class="tok-kw">fn</span> <span class="tok-fn">acosh32</span>(x: <span class="tok-type">f32</span>) <span class="tok-type">f32</span> {</span>
<span class="line" id="L27"> <span class="tok-kw">const</span> u = <span class="tok-builtin">@as</span>(<span class="tok-type">u32</span>, <span class="tok-builtin">@bitCast</span>(x));</span>
<span class="line" id="L28"> <span class="tok-kw">const</span> i = u & <span class="tok-number">0x7FFFFFFF</span>;</span>
<span class="line" id="L29"></span>
<span class="line" id="L30"> <span class="tok-comment">// |x| < 2, invalid if x < 1 or nan</span>
</span>
<span class="line" id="L31"> <span class="tok-kw">if</span> (i < <span class="tok-number">0x3F800000</span> + (<span class="tok-number">1</span> << <span class="tok-number">23</span>)) {</span>
<span class="line" id="L32"> <span class="tok-kw">return</span> math.log1p(x - <span class="tok-number">1</span> + <span class="tok-builtin">@sqrt</span>((x - <span class="tok-number">1</span>) * (x - <span class="tok-number">1</span>) + <span class="tok-number">2</span> * (x - <span class="tok-number">1</span>)));</span>
<span class="line" id="L33"> }</span>
<span class="line" id="L34"> <span class="tok-comment">// |x| < 0x1p12</span>
</span>
<span class="line" id="L35"> <span class="tok-kw">else</span> <span class="tok-kw">if</span> (i < <span class="tok-number">0x3F800000</span> + (<span class="tok-number">12</span> << <span class="tok-number">23</span>)) {</span>
<span class="line" id="L36"> <span class="tok-kw">return</span> <span class="tok-builtin">@log</span>(<span class="tok-number">2</span> * x - <span class="tok-number">1</span> / (x + <span class="tok-builtin">@sqrt</span>(x * x - <span class="tok-number">1</span>)));</span>
<span class="line" id="L37"> }</span>
<span class="line" id="L38"> <span class="tok-comment">// |x| >= 0x1p12</span>
</span>
<span class="line" id="L39"> <span class="tok-kw">else</span> {</span>
<span class="line" id="L40"> <span class="tok-kw">return</span> <span class="tok-builtin">@log</span>(x) + <span class="tok-number">0.693147180559945309417232121458176568</span>;</span>
<span class="line" id="L41"> }</span>
<span class="line" id="L42">}</span>
<span class="line" id="L43"></span>
<span class="line" id="L44"><span class="tok-kw">fn</span> <span class="tok-fn">acosh64</span>(x: <span class="tok-type">f64</span>) <span class="tok-type">f64</span> {</span>
<span class="line" id="L45"> <span class="tok-kw">const</span> u = <span class="tok-builtin">@as</span>(<span class="tok-type">u64</span>, <span class="tok-builtin">@bitCast</span>(x));</span>
<span class="line" id="L46"> <span class="tok-kw">const</span> e = (u >> <span class="tok-number">52</span>) & <span class="tok-number">0x7FF</span>;</span>
<span class="line" id="L47"></span>
<span class="line" id="L48"> <span class="tok-comment">// |x| < 2, invalid if x < 1 or nan</span>
</span>
<span class="line" id="L49"> <span class="tok-kw">if</span> (e < <span class="tok-number">0x3FF</span> + <span class="tok-number">1</span>) {</span>
<span class="line" id="L50"> <span class="tok-kw">return</span> math.log1p(x - <span class="tok-number">1</span> + <span class="tok-builtin">@sqrt</span>((x - <span class="tok-number">1</span>) * (x - <span class="tok-number">1</span>) + <span class="tok-number">2</span> * (x - <span class="tok-number">1</span>)));</span>
<span class="line" id="L51"> }</span>
<span class="line" id="L52"> <span class="tok-comment">// |x| < 0x1p26</span>
</span>
<span class="line" id="L53"> <span class="tok-kw">else</span> <span class="tok-kw">if</span> (e < <span class="tok-number">0x3FF</span> + <span class="tok-number">26</span>) {</span>
<span class="line" id="L54"> <span class="tok-kw">return</span> <span class="tok-builtin">@log</span>(<span class="tok-number">2</span> * x - <span class="tok-number">1</span> / (x + <span class="tok-builtin">@sqrt</span>(x * x - <span class="tok-number">1</span>)));</span>
<span class="line" id="L55"> }</span>
<span class="line" id="L56"> <span class="tok-comment">// |x| >= 0x1p26 or nan</span>
</span>
<span class="line" id="L57"> <span class="tok-kw">else</span> {</span>
<span class="line" id="L58"> <span class="tok-kw">return</span> <span class="tok-builtin">@log</span>(x) + <span class="tok-number">0.693147180559945309417232121458176568</span>;</span>
<span class="line" id="L59"> }</span>
<span class="line" id="L60">}</span>
<span class="line" id="L61"></span>
<span class="line" id="L62"><span class="tok-kw">test</span> <span class="tok-str">"math.acosh"</span> {</span>
<span class="line" id="L63"> <span class="tok-kw">try</span> expect(acosh(<span class="tok-builtin">@as</span>(<span class="tok-type">f32</span>, <span class="tok-number">1.5</span>)) == acosh32(<span class="tok-number">1.5</span>));</span>
<span class="line" id="L64"> <span class="tok-kw">try</span> expect(acosh(<span class="tok-builtin">@as</span>(<span class="tok-type">f64</span>, <span class="tok-number">1.5</span>)) == acosh64(<span class="tok-number">1.5</span>));</span>
<span class="line" id="L65">}</span>
<span class="line" id="L66"></span>
<span class="line" id="L67"><span class="tok-kw">test</span> <span class="tok-str">"math.acosh32"</span> {</span>
<span class="line" id="L68"> <span class="tok-kw">const</span> epsilon = <span class="tok-number">0.000001</span>;</span>
<span class="line" id="L69"></span>
<span class="line" id="L70"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f32</span>, acosh32(<span class="tok-number">1.5</span>), <span class="tok-number">0.962424</span>, epsilon));</span>
<span class="line" id="L71"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f32</span>, acosh32(<span class="tok-number">37.45</span>), <span class="tok-number">4.315976</span>, epsilon));</span>
<span class="line" id="L72"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f32</span>, acosh32(<span class="tok-number">89.123</span>), <span class="tok-number">5.183133</span>, epsilon));</span>
<span class="line" id="L73"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f32</span>, acosh32(<span class="tok-number">123123.234375</span>), <span class="tok-number">12.414088</span>, epsilon));</span>
<span class="line" id="L74">}</span>
<span class="line" id="L75"></span>
<span class="line" id="L76"><span class="tok-kw">test</span> <span class="tok-str">"math.acosh64"</span> {</span>
<span class="line" id="L77"> <span class="tok-kw">const</span> epsilon = <span class="tok-number">0.000001</span>;</span>
<span class="line" id="L78"></span>
<span class="line" id="L79"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f64</span>, acosh64(<span class="tok-number">1.5</span>), <span class="tok-number">0.962424</span>, epsilon));</span>
<span class="line" id="L80"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f64</span>, acosh64(<span class="tok-number">37.45</span>), <span class="tok-number">4.315976</span>, epsilon));</span>
<span class="line" id="L81"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f64</span>, acosh64(<span class="tok-number">89.123</span>), <span class="tok-number">5.183133</span>, epsilon));</span>
<span class="line" id="L82"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f64</span>, acosh64(<span class="tok-number">123123.234375</span>), <span class="tok-number">12.414088</span>, epsilon));</span>
<span class="line" id="L83">}</span>
<span class="line" id="L84"></span>
<span class="line" id="L85"><span class="tok-kw">test</span> <span class="tok-str">"math.acosh32.special"</span> {</span>
<span class="line" id="L86"> <span class="tok-kw">try</span> expect(math.isNan(acosh32(math.nan(<span class="tok-type">f32</span>))));</span>
<span class="line" id="L87"> <span class="tok-kw">try</span> expect(math.isSignalNan(acosh32(<span class="tok-number">0.5</span>)));</span>
<span class="line" id="L88">}</span>
<span class="line" id="L89"></span>
<span class="line" id="L90"><span class="tok-kw">test</span> <span class="tok-str">"math.acosh64.special"</span> {</span>
<span class="line" id="L91"> <span class="tok-kw">try</span> expect(math.isNan(acosh64(math.nan(<span class="tok-type">f64</span>))));</span>
<span class="line" id="L92"> <span class="tok-kw">try</span> expect(math.isSignalNan(acosh64(<span class="tok-number">0.5</span>)));</span>
<span class="line" id="L93">}</span>
<span class="line" id="L94"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/math/scalbn.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>math/scalbn.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"std"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> expect = std.testing.expect;</span>
<span class="line" id="L3"></span>
<span class="line" id="L4"><span class="tok-comment">/// Returns a * FLT_RADIX ^ exp.</span></span>
<span class="line" id="L5"><span class="tok-comment">///</span></span>
<span class="line" id="L6"><span class="tok-comment">/// Zig only supports binary base IEEE-754 floats. Hence FLT_RADIX=2, and this is an alias for ldexp.</span></span>
<span class="line" id="L7"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> scalbn = <span class="tok-builtin">@import</span>(<span class="tok-str">"ldexp.zig"</span>).ldexp;</span>
<span class="line" id="L8"></span>
<span class="line" id="L9"><span class="tok-kw">test</span> <span class="tok-str">"math.scalbn"</span> {</span>
<span class="line" id="L10"> <span class="tok-comment">// Verify we are using base 2.</span>
</span>
<span class="line" id="L11"> <span class="tok-kw">try</span> expect(scalbn(<span class="tok-builtin">@as</span>(<span class="tok-type">f16</span>, <span class="tok-number">1.5</span>), <span class="tok-number">4</span>) == <span class="tok-number">24.0</span>);</span>
<span class="line" id="L12"> <span class="tok-kw">try</span> expect(scalbn(<span class="tok-builtin">@as</span>(<span class="tok-type">f32</span>, <span class="tok-number">1.5</span>), <span class="tok-number">4</span>) == <span class="tok-number">24.0</span>);</span>
<span class="line" id="L13"> <span class="tok-kw">try</span> expect(scalbn(<span class="tok-builtin">@as</span>(<span class="tok-type">f64</span>, <span class="tok-number">1.5</span>), <span class="tok-number">4</span>) == <span class="tok-number">24.0</span>);</span>
<span class="line" id="L14"> <span class="tok-kw">try</span> expect(scalbn(<span class="tok-builtin">@as</span>(<span class="tok-type">f128</span>, <span class="tok-number">1.5</span>), <span class="tok-number">4</span>) == <span class="tok-number">24.0</span>);</span>
<span class="line" id="L15">}</span>
<span class="line" id="L16"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/math/isfinite.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>math/isfinite.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../std.zig"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> math = std.math;</span>
<span class="line" id="L3"><span class="tok-kw">const</span> expect = std.testing.expect;</span>
<span class="line" id="L4"></span>
<span class="line" id="L5"><span class="tok-comment">/// Returns whether x is a finite value.</span></span>
<span class="line" id="L6"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">isFinite</span>(x: <span class="tok-kw">anytype</span>) <span class="tok-type">bool</span> {</span>
<span class="line" id="L7"> <span class="tok-kw">const</span> T = <span class="tok-builtin">@TypeOf</span>(x);</span>
<span class="line" id="L8"> <span class="tok-kw">const</span> TBits = std.meta.Int(.unsigned, <span class="tok-builtin">@typeInfo</span>(T).Float.bits);</span>
<span class="line" id="L9"> <span class="tok-kw">const</span> remove_sign = ~<span class="tok-builtin">@as</span>(TBits, <span class="tok-number">0</span>) >> <span class="tok-number">1</span>;</span>
<span class="line" id="L10"> <span class="tok-kw">return</span> <span class="tok-builtin">@as</span>(TBits, <span class="tok-builtin">@bitCast</span>(x)) & remove_sign < <span class="tok-builtin">@as</span>(TBits, <span class="tok-builtin">@bitCast</span>(math.inf(T)));</span>
<span class="line" id="L11">}</span>
<span class="line" id="L12"></span>
<span class="line" id="L13"><span class="tok-kw">test</span> <span class="tok-str">"math.isFinite"</span> {</span>
<span class="line" id="L14"> <span class="tok-kw">inline</span> <span class="tok-kw">for</span> ([_]<span class="tok-type">type</span>{ <span class="tok-type">f16</span>, <span class="tok-type">f32</span>, <span class="tok-type">f64</span>, <span class="tok-type">f80</span>, <span class="tok-type">f128</span> }) |T| {</span>
<span class="line" id="L15"> <span class="tok-comment">// normals</span>
</span>
<span class="line" id="L16"> <span class="tok-kw">try</span> expect(isFinite(<span class="tok-builtin">@as</span>(T, <span class="tok-number">1.0</span>)));</span>
<span class="line" id="L17"> <span class="tok-kw">try</span> expect(isFinite(-<span class="tok-builtin">@as</span>(T, <span class="tok-number">1.0</span>)));</span>
<span class="line" id="L18"></span>
<span class="line" id="L19"> <span class="tok-comment">// zero & subnormals</span>
</span>
<span class="line" id="L20"> <span class="tok-kw">try</span> expect(isFinite(<span class="tok-builtin">@as</span>(T, <span class="tok-number">0.0</span>)));</span>
<span class="line" id="L21"> <span class="tok-kw">try</span> expect(isFinite(<span class="tok-builtin">@as</span>(T, -<span class="tok-number">0.0</span>)));</span>
<span class="line" id="L22"> <span class="tok-kw">try</span> expect(isFinite(math.floatTrueMin(T)));</span>
<span class="line" id="L23"></span>
<span class="line" id="L24"> <span class="tok-comment">// other float limits</span>
</span>
<span class="line" id="L25"> <span class="tok-kw">try</span> expect(isFinite(math.floatMin(T)));</span>
<span class="line" id="L26"> <span class="tok-kw">try</span> expect(isFinite(math.floatMax(T)));</span>
<span class="line" id="L27"></span>
<span class="line" id="L28"> <span class="tok-comment">// inf & nan</span>
</span>
<span class="line" id="L29"> <span class="tok-kw">try</span> expect(!isFinite(math.inf(T)));</span>
<span class="line" id="L30"> <span class="tok-kw">try</span> expect(!isFinite(-math.inf(T)));</span>
<span class="line" id="L31"> <span class="tok-kw">try</span> expect(!isFinite(math.nan(T)));</span>
<span class="line" id="L32"> <span class="tok-kw">try</span> expect(!isFinite(-math.nan(T)));</span>
<span class="line" id="L33"> }</span>
<span class="line" id="L34">}</span>
<span class="line" id="L35"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/math/atan.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>math/atan.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-comment">// Ported from musl, which is licensed under the MIT license:</span>
</span>
<span class="line" id="L2"><span class="tok-comment">// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT</span>
</span>
<span class="line" id="L3"><span class="tok-comment">//</span>
</span>
<span class="line" id="L4"><span class="tok-comment">// https://git.musl-libc.org/cgit/musl/tree/src/math/atanf.c</span>
</span>
<span class="line" id="L5"><span class="tok-comment">// https://git.musl-libc.org/cgit/musl/tree/src/math/atan.c</span>
</span>
<span class="line" id="L6"></span>
<span class="line" id="L7"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../std.zig"</span>);</span>
<span class="line" id="L8"><span class="tok-kw">const</span> math = std.math;</span>
<span class="line" id="L9"><span class="tok-kw">const</span> expect = std.testing.expect;</span>
<span class="line" id="L10"></span>
<span class="line" id="L11"><span class="tok-comment">/// Returns the arc-tangent of x.</span></span>
<span class="line" id="L12"><span class="tok-comment">///</span></span>
<span class="line" id="L13"><span class="tok-comment">/// Special Cases:</span></span>
<span class="line" id="L14"><span class="tok-comment">/// - atan(+-0) = +-0</span></span>
<span class="line" id="L15"><span class="tok-comment">/// - atan(+-inf) = +-pi/2</span></span>
<span class="line" id="L16"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">atan</span>(x: <span class="tok-kw">anytype</span>) <span class="tok-builtin">@TypeOf</span>(x) {</span>
<span class="line" id="L17"> <span class="tok-kw">const</span> T = <span class="tok-builtin">@TypeOf</span>(x);</span>
<span class="line" id="L18"> <span class="tok-kw">return</span> <span class="tok-kw">switch</span> (T) {</span>
<span class="line" id="L19"> <span class="tok-type">f32</span> => atan32(x),</span>
<span class="line" id="L20"> <span class="tok-type">f64</span> => atan64(x),</span>
<span class="line" id="L21"> <span class="tok-kw">else</span> => <span class="tok-builtin">@compileError</span>(<span class="tok-str">"atan not implemented for "</span> ++ <span class="tok-builtin">@typeName</span>(T)),</span>
<span class="line" id="L22"> };</span>
<span class="line" id="L23">}</span>
<span class="line" id="L24"></span>
<span class="line" id="L25"><span class="tok-kw">fn</span> <span class="tok-fn">atan32</span>(x_: <span class="tok-type">f32</span>) <span class="tok-type">f32</span> {</span>
<span class="line" id="L26"> <span class="tok-kw">const</span> atanhi = [_]<span class="tok-type">f32</span>{</span>
<span class="line" id="L27"> <span class="tok-number">4.6364760399e-01</span>, <span class="tok-comment">// atan(0.5)hi</span>
</span>
<span class="line" id="L28"> <span class="tok-number">7.8539812565e-01</span>, <span class="tok-comment">// atan(1.0)hi</span>
</span>
<span class="line" id="L29"> <span class="tok-number">9.8279368877e-01</span>, <span class="tok-comment">// atan(1.5)hi</span>
</span>
<span class="line" id="L30"> <span class="tok-number">1.5707962513e+00</span>, <span class="tok-comment">// atan(inf)hi</span>
</span>
<span class="line" id="L31"> };</span>
<span class="line" id="L32"></span>
<span class="line" id="L33"> <span class="tok-kw">const</span> atanlo = [_]<span class="tok-type">f32</span>{</span>
<span class="line" id="L34"> <span class="tok-number">5.0121582440e-09</span>, <span class="tok-comment">// atan(0.5)lo</span>
</span>
<span class="line" id="L35"> <span class="tok-number">3.7748947079e-08</span>, <span class="tok-comment">// atan(1.0)lo</span>
</span>
<span class="line" id="L36"> <span class="tok-number">3.4473217170e-08</span>, <span class="tok-comment">// atan(1.5)lo</span>
</span>
<span class="line" id="L37"> <span class="tok-number">7.5497894159e-08</span>, <span class="tok-comment">// atan(inf)lo</span>
</span>
<span class="line" id="L38"> };</span>
<span class="line" id="L39"></span>
<span class="line" id="L40"> <span class="tok-kw">const</span> aT = [_]<span class="tok-type">f32</span>{</span>
<span class="line" id="L41"> <span class="tok-number">3.3333328366e-01</span>,</span>
<span class="line" id="L42"> -<span class="tok-number">1.9999158382e-01</span>,</span>
<span class="line" id="L43"> <span class="tok-number">1.4253635705e-01</span>,</span>
<span class="line" id="L44"> -<span class="tok-number">1.0648017377e-01</span>,</span>
<span class="line" id="L45"> <span class="tok-number">6.1687607318e-02</span>,</span>
<span class="line" id="L46"> };</span>
<span class="line" id="L47"></span>
<span class="line" id="L48"> <span class="tok-kw">var</span> x = x_;</span>
<span class="line" id="L49"> <span class="tok-kw">var</span> ix: <span class="tok-type">u32</span> = <span class="tok-builtin">@as</span>(<span class="tok-type">u32</span>, <span class="tok-builtin">@bitCast</span>(x));</span>
<span class="line" id="L50"> <span class="tok-kw">const</span> sign = ix >> <span class="tok-number">31</span>;</span>
<span class="line" id="L51"> ix &= <span class="tok-number">0x7FFFFFFF</span>;</span>
<span class="line" id="L52"></span>
<span class="line" id="L53"> <span class="tok-comment">// |x| >= 2^26</span>
</span>
<span class="line" id="L54"> <span class="tok-kw">if</span> (ix >= <span class="tok-number">0x4C800000</span>) {</span>
<span class="line" id="L55"> <span class="tok-kw">if</span> (math.isNan(x)) {</span>
<span class="line" id="L56"> <span class="tok-kw">return</span> x;</span>
<span class="line" id="L57"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L58"> <span class="tok-kw">const</span> z = atanhi[<span class="tok-number">3</span>] + <span class="tok-number">0x1.0p-120</span>;</span>
<span class="line" id="L59"> <span class="tok-kw">return</span> <span class="tok-kw">if</span> (sign != <span class="tok-number">0</span>) -z <span class="tok-kw">else</span> z;</span>
<span class="line" id="L60"> }</span>
<span class="line" id="L61"> }</span>
<span class="line" id="L62"></span>
<span class="line" id="L63"> <span class="tok-kw">var</span> id: ?<span class="tok-type">usize</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L64"></span>
<span class="line" id="L65"> <span class="tok-comment">// |x| < 0.4375</span>
</span>
<span class="line" id="L66"> <span class="tok-kw">if</span> (ix < <span class="tok-number">0x3EE00000</span>) {</span>
<span class="line" id="L67"> <span class="tok-comment">// |x| < 2^(-12)</span>
</span>
<span class="line" id="L68"> <span class="tok-kw">if</span> (ix < <span class="tok-number">0x39800000</span>) {</span>
<span class="line" id="L69"> <span class="tok-kw">if</span> (ix < <span class="tok-number">0x00800000</span>) {</span>
<span class="line" id="L70"> math.doNotOptimizeAway(x * x);</span>
<span class="line" id="L71"> }</span>
<span class="line" id="L72"> <span class="tok-kw">return</span> x;</span>
<span class="line" id="L73"> }</span>
<span class="line" id="L74"> id = <span class="tok-null">null</span>;</span>
<span class="line" id="L75"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L76"> x = <span class="tok-builtin">@fabs</span>(x);</span>
<span class="line" id="L77"> <span class="tok-comment">// |x| < 1.1875</span>
</span>
<span class="line" id="L78"> <span class="tok-kw">if</span> (ix < <span class="tok-number">0x3F980000</span>) {</span>
<span class="line" id="L79"> <span class="tok-comment">// 7/16 <= |x| < 11/16</span>
</span>
<span class="line" id="L80"> <span class="tok-kw">if</span> (ix < <span class="tok-number">0x3F300000</span>) {</span>
<span class="line" id="L81"> id = <span class="tok-number">0</span>;</span>
<span class="line" id="L82"> x = (<span class="tok-number">2.0</span> * x - <span class="tok-number">1.0</span>) / (<span class="tok-number">2.0</span> + x);</span>
<span class="line" id="L83"> }</span>
<span class="line" id="L84"> <span class="tok-comment">// 11/16 <= |x| < 19/16</span>
</span>
<span class="line" id="L85"> <span class="tok-kw">else</span> {</span>
<span class="line" id="L86"> id = <span class="tok-number">1</span>;</span>
<span class="line" id="L87"> x = (x - <span class="tok-number">1.0</span>) / (x + <span class="tok-number">1.0</span>);</span>
<span class="line" id="L88"> }</span>
<span class="line" id="L89"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L90"> <span class="tok-comment">// |x| < 2.4375</span>
</span>
<span class="line" id="L91"> <span class="tok-kw">if</span> (ix < <span class="tok-number">0x401C0000</span>) {</span>
<span class="line" id="L92"> id = <span class="tok-number">2</span>;</span>
<span class="line" id="L93"> x = (x - <span class="tok-number">1.5</span>) / (<span class="tok-number">1.0</span> + <span class="tok-number">1.5</span> * x);</span>
<span class="line" id="L94"> }</span>
<span class="line" id="L95"> <span class="tok-comment">// 2.4375 <= |x| < 2^26</span>
</span>
<span class="line" id="L96"> <span class="tok-kw">else</span> {</span>
<span class="line" id="L97"> id = <span class="tok-number">3</span>;</span>
<span class="line" id="L98"> x = -<span class="tok-number">1.0</span> / x;</span>
<span class="line" id="L99"> }</span>
<span class="line" id="L100"> }</span>
<span class="line" id="L101"> }</span>
<span class="line" id="L102"></span>
<span class="line" id="L103"> <span class="tok-kw">const</span> z = x * x;</span>
<span class="line" id="L104"> <span class="tok-kw">const</span> w = z * z;</span>
<span class="line" id="L105"> <span class="tok-kw">const</span> s1 = z * (aT[<span class="tok-number">0</span>] + w * (aT[<span class="tok-number">2</span>] + w * aT[<span class="tok-number">4</span>]));</span>
<span class="line" id="L106"> <span class="tok-kw">const</span> s2 = w * (aT[<span class="tok-number">1</span>] + w * aT[<span class="tok-number">3</span>]);</span>
<span class="line" id="L107"></span>
<span class="line" id="L108"> <span class="tok-kw">if</span> (id) |id_value| {</span>
<span class="line" id="L109"> <span class="tok-kw">const</span> zz = atanhi[id_value] - ((x * (s1 + s2) - atanlo[id_value]) - x);</span>
<span class="line" id="L110"> <span class="tok-kw">return</span> <span class="tok-kw">if</span> (sign != <span class="tok-number">0</span>) -zz <span class="tok-kw">else</span> zz;</span>
<span class="line" id="L111"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L112"> <span class="tok-kw">return</span> x - x * (s1 + s2);</span>
<span class="line" id="L113"> }</span>
<span class="line" id="L114">}</span>
<span class="line" id="L115"></span>
<span class="line" id="L116"><span class="tok-kw">fn</span> <span class="tok-fn">atan64</span>(x_: <span class="tok-type">f64</span>) <span class="tok-type">f64</span> {</span>
<span class="line" id="L117"> <span class="tok-kw">const</span> atanhi = [_]<span class="tok-type">f64</span>{</span>
<span class="line" id="L118"> <span class="tok-number">4.63647609000806093515e-01</span>, <span class="tok-comment">// atan(0.5)hi</span>
</span>
<span class="line" id="L119"> <span class="tok-number">7.85398163397448278999e-01</span>, <span class="tok-comment">// atan(1.0)hi</span>
</span>
<span class="line" id="L120"> <span class="tok-number">9.82793723247329054082e-01</span>, <span class="tok-comment">// atan(1.5)hi</span>
</span>
<span class="line" id="L121"> <span class="tok-number">1.57079632679489655800e+00</span>, <span class="tok-comment">// atan(inf)hi</span>
</span>
<span class="line" id="L122"> };</span>
<span class="line" id="L123"></span>
<span class="line" id="L124"> <span class="tok-kw">const</span> atanlo = [_]<span class="tok-type">f64</span>{</span>
<span class="line" id="L125"> <span class="tok-number">2.26987774529616870924e-17</span>, <span class="tok-comment">// atan(0.5)lo</span>
</span>
<span class="line" id="L126"> <span class="tok-number">3.06161699786838301793e-17</span>, <span class="tok-comment">// atan(1.0)lo</span>
</span>
<span class="line" id="L127"> <span class="tok-number">1.39033110312309984516e-17</span>, <span class="tok-comment">// atan(1.5)lo</span>
</span>
<span class="line" id="L128"> <span class="tok-number">6.12323399573676603587e-17</span>, <span class="tok-comment">// atan(inf)lo</span>
</span>
<span class="line" id="L129"> };</span>
<span class="line" id="L130"></span>
<span class="line" id="L131"> <span class="tok-kw">const</span> aT = [_]<span class="tok-type">f64</span>{</span>
<span class="line" id="L132"> <span class="tok-number">3.33333333333329318027e-01</span>,</span>
<span class="line" id="L133"> -<span class="tok-number">1.99999999998764832476e-01</span>,</span>
<span class="line" id="L134"> <span class="tok-number">1.42857142725034663711e-01</span>,</span>
<span class="line" id="L135"> -<span class="tok-number">1.11111104054623557880e-01</span>,</span>
<span class="line" id="L136"> <span class="tok-number">9.09088713343650656196e-02</span>,</span>
<span class="line" id="L137"> -<span class="tok-number">7.69187620504482999495e-02</span>,</span>
<span class="line" id="L138"> <span class="tok-number">6.66107313738753120669e-02</span>,</span>
<span class="line" id="L139"> -<span class="tok-number">5.83357013379057348645e-02</span>,</span>
<span class="line" id="L140"> <span class="tok-number">4.97687799461593236017e-02</span>,</span>
<span class="line" id="L141"> -<span class="tok-number">3.65315727442169155270e-02</span>,</span>
<span class="line" id="L142"> <span class="tok-number">1.62858201153657823623e-02</span>,</span>
<span class="line" id="L143"> };</span>
<span class="line" id="L144"></span>
<span class="line" id="L145"> <span class="tok-kw">var</span> x = x_;</span>
<span class="line" id="L146"> <span class="tok-kw">var</span> ux = <span class="tok-builtin">@as</span>(<span class="tok-type">u64</span>, <span class="tok-builtin">@bitCast</span>(x));</span>
<span class="line" id="L147"> <span class="tok-kw">var</span> ix = <span class="tok-builtin">@as</span>(<span class="tok-type">u32</span>, <span class="tok-builtin">@intCast</span>(ux >> <span class="tok-number">32</span>));</span>
<span class="line" id="L148"> <span class="tok-kw">const</span> sign = ix >> <span class="tok-number">31</span>;</span>
<span class="line" id="L149"> ix &= <span class="tok-number">0x7FFFFFFF</span>;</span>
<span class="line" id="L150"></span>
<span class="line" id="L151"> <span class="tok-comment">// |x| >= 2^66</span>
</span>
<span class="line" id="L152"> <span class="tok-kw">if</span> (ix >= <span class="tok-number">0x44100000</span>) {</span>
<span class="line" id="L153"> <span class="tok-kw">if</span> (math.isNan(x)) {</span>
<span class="line" id="L154"> <span class="tok-kw">return</span> x;</span>
<span class="line" id="L155"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L156"> <span class="tok-kw">const</span> z = atanhi[<span class="tok-number">3</span>] + <span class="tok-number">0x1.0p-120</span>;</span>
<span class="line" id="L157"> <span class="tok-kw">return</span> <span class="tok-kw">if</span> (sign != <span class="tok-number">0</span>) -z <span class="tok-kw">else</span> z;</span>
<span class="line" id="L158"> }</span>
<span class="line" id="L159"> }</span>
<span class="line" id="L160"></span>
<span class="line" id="L161"> <span class="tok-kw">var</span> id: ?<span class="tok-type">usize</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L162"></span>
<span class="line" id="L163"> <span class="tok-comment">// |x| < 0.4375</span>
</span>
<span class="line" id="L164"> <span class="tok-kw">if</span> (ix < <span class="tok-number">0x3FDC0000</span>) {</span>
<span class="line" id="L165"> <span class="tok-comment">// |x| < 2^(-27)</span>
</span>
<span class="line" id="L166"> <span class="tok-kw">if</span> (ix < <span class="tok-number">0x3E400000</span>) {</span>
<span class="line" id="L167"> <span class="tok-kw">if</span> (ix < <span class="tok-number">0x00100000</span>) {</span>
<span class="line" id="L168"> math.doNotOptimizeAway(<span class="tok-builtin">@as</span>(<span class="tok-type">f32</span>, <span class="tok-builtin">@floatCast</span>(x)));</span>
<span class="line" id="L169"> }</span>
<span class="line" id="L170"> <span class="tok-kw">return</span> x;</span>
<span class="line" id="L171"> }</span>
<span class="line" id="L172"> id = <span class="tok-null">null</span>;</span>
<span class="line" id="L173"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L174"> x = <span class="tok-builtin">@fabs</span>(x);</span>
<span class="line" id="L175"> <span class="tok-comment">// |x| < 1.1875</span>
</span>
<span class="line" id="L176"> <span class="tok-kw">if</span> (ix < <span class="tok-number">0x3FF30000</span>) {</span>
<span class="line" id="L177"> <span class="tok-comment">// 7/16 <= |x| < 11/16</span>
</span>
<span class="line" id="L178"> <span class="tok-kw">if</span> (ix < <span class="tok-number">0x3FE60000</span>) {</span>
<span class="line" id="L179"> id = <span class="tok-number">0</span>;</span>
<span class="line" id="L180"> x = (<span class="tok-number">2.0</span> * x - <span class="tok-number">1.0</span>) / (<span class="tok-number">2.0</span> + x);</span>
<span class="line" id="L181"> }</span>
<span class="line" id="L182"> <span class="tok-comment">// 11/16 <= |x| < 19/16</span>
</span>
<span class="line" id="L183"> <span class="tok-kw">else</span> {</span>
<span class="line" id="L184"> id = <span class="tok-number">1</span>;</span>
<span class="line" id="L185"> x = (x - <span class="tok-number">1.0</span>) / (x + <span class="tok-number">1.0</span>);</span>
<span class="line" id="L186"> }</span>
<span class="line" id="L187"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L188"> <span class="tok-comment">// |x| < 2.4375</span>
</span>
<span class="line" id="L189"> <span class="tok-kw">if</span> (ix < <span class="tok-number">0x40038000</span>) {</span>
<span class="line" id="L190"> id = <span class="tok-number">2</span>;</span>
<span class="line" id="L191"> x = (x - <span class="tok-number">1.5</span>) / (<span class="tok-number">1.0</span> + <span class="tok-number">1.5</span> * x);</span>
<span class="line" id="L192"> }</span>
<span class="line" id="L193"> <span class="tok-comment">// 2.4375 <= |x| < 2^66</span>
</span>
<span class="line" id="L194"> <span class="tok-kw">else</span> {</span>
<span class="line" id="L195"> id = <span class="tok-number">3</span>;</span>
<span class="line" id="L196"> x = -<span class="tok-number">1.0</span> / x;</span>
<span class="line" id="L197"> }</span>
<span class="line" id="L198"> }</span>
<span class="line" id="L199"> }</span>
<span class="line" id="L200"></span>
<span class="line" id="L201"> <span class="tok-kw">const</span> z = x * x;</span>
<span class="line" id="L202"> <span class="tok-kw">const</span> w = z * z;</span>
<span class="line" id="L203"> <span class="tok-kw">const</span> s1 = z * (aT[<span class="tok-number">0</span>] + w * (aT[<span class="tok-number">2</span>] + w * (aT[<span class="tok-number">4</span>] + w * (aT[<span class="tok-number">6</span>] + w * (aT[<span class="tok-number">8</span>] + w * aT[<span class="tok-number">10</span>])))));</span>
<span class="line" id="L204"> <span class="tok-kw">const</span> s2 = w * (aT[<span class="tok-number">1</span>] + w * (aT[<span class="tok-number">3</span>] + w * (aT[<span class="tok-number">5</span>] + w * (aT[<span class="tok-number">7</span>] + w * aT[<span class="tok-number">9</span>]))));</span>
<span class="line" id="L205"></span>
<span class="line" id="L206"> <span class="tok-kw">if</span> (id) |id_value| {</span>
<span class="line" id="L207"> <span class="tok-kw">const</span> zz = atanhi[id_value] - ((x * (s1 + s2) - atanlo[id_value]) - x);</span>
<span class="line" id="L208"> <span class="tok-kw">return</span> <span class="tok-kw">if</span> (sign != <span class="tok-number">0</span>) -zz <span class="tok-kw">else</span> zz;</span>
<span class="line" id="L209"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L210"> <span class="tok-kw">return</span> x - x * (s1 + s2);</span>
<span class="line" id="L211"> }</span>
<span class="line" id="L212">}</span>
<span class="line" id="L213"></span>
<span class="line" id="L214"><span class="tok-kw">test</span> <span class="tok-str">"math.atan"</span> {</span>
<span class="line" id="L215"> <span class="tok-kw">try</span> expect(<span class="tok-builtin">@as</span>(<span class="tok-type">u32</span>, <span class="tok-builtin">@bitCast</span>(atan(<span class="tok-builtin">@as</span>(<span class="tok-type">f32</span>, <span class="tok-number">0.2</span>)))) == <span class="tok-builtin">@as</span>(<span class="tok-type">u32</span>, <span class="tok-builtin">@bitCast</span>(atan32(<span class="tok-number">0.2</span>))));</span>
<span class="line" id="L216"> <span class="tok-kw">try</span> expect(atan(<span class="tok-builtin">@as</span>(<span class="tok-type">f64</span>, <span class="tok-number">0.2</span>)) == atan64(<span class="tok-number">0.2</span>));</span>
<span class="line" id="L217">}</span>
<span class="line" id="L218"></span>
<span class="line" id="L219"><span class="tok-kw">test</span> <span class="tok-str">"math.atan32"</span> {</span>
<span class="line" id="L220"> <span class="tok-kw">const</span> epsilon = <span class="tok-number">0.000001</span>;</span>
<span class="line" id="L221"></span>
<span class="line" id="L222"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f32</span>, atan32(<span class="tok-number">0.2</span>), <span class="tok-number">0.197396</span>, epsilon));</span>
<span class="line" id="L223"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f32</span>, atan32(-<span class="tok-number">0.2</span>), -<span class="tok-number">0.197396</span>, epsilon));</span>
<span class="line" id="L224"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f32</span>, atan32(<span class="tok-number">0.3434</span>), <span class="tok-number">0.330783</span>, epsilon));</span>
<span class="line" id="L225"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f32</span>, atan32(<span class="tok-number">0.8923</span>), <span class="tok-number">0.728545</span>, epsilon));</span>
<span class="line" id="L226"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f32</span>, atan32(<span class="tok-number">1.5</span>), <span class="tok-number">0.982794</span>, epsilon));</span>
<span class="line" id="L227">}</span>
<span class="line" id="L228"></span>
<span class="line" id="L229"><span class="tok-kw">test</span> <span class="tok-str">"math.atan64"</span> {</span>
<span class="line" id="L230"> <span class="tok-kw">const</span> epsilon = <span class="tok-number">0.000001</span>;</span>
<span class="line" id="L231"></span>
<span class="line" id="L232"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f64</span>, atan64(<span class="tok-number">0.2</span>), <span class="tok-number">0.197396</span>, epsilon));</span>
<span class="line" id="L233"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f64</span>, atan64(-<span class="tok-number">0.2</span>), -<span class="tok-number">0.197396</span>, epsilon));</span>
<span class="line" id="L234"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f64</span>, atan64(<span class="tok-number">0.3434</span>), <span class="tok-number">0.330783</span>, epsilon));</span>
<span class="line" id="L235"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f64</span>, atan64(<span class="tok-number">0.8923</span>), <span class="tok-number">0.728545</span>, epsilon));</span>
<span class="line" id="L236"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f64</span>, atan64(<span class="tok-number">1.5</span>), <span class="tok-number">0.982794</span>, epsilon));</span>
<span class="line" id="L237">}</span>
<span class="line" id="L238"></span>
<span class="line" id="L239"><span class="tok-kw">test</span> <span class="tok-str">"math.atan32.special"</span> {</span>
<span class="line" id="L240"> <span class="tok-kw">const</span> epsilon = <span class="tok-number">0.000001</span>;</span>
<span class="line" id="L241"></span>
<span class="line" id="L242"> <span class="tok-kw">try</span> expect(atan32(<span class="tok-number">0.0</span>) == <span class="tok-number">0.0</span>);</span>
<span class="line" id="L243"> <span class="tok-kw">try</span> expect(atan32(-<span class="tok-number">0.0</span>) == -<span class="tok-number">0.0</span>);</span>
<span class="line" id="L244"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f32</span>, atan32(math.inf(<span class="tok-type">f32</span>)), math.pi / <span class="tok-number">2.0</span>, epsilon));</span>
<span class="line" id="L245"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f32</span>, atan32(-math.inf(<span class="tok-type">f32</span>)), -math.pi / <span class="tok-number">2.0</span>, epsilon));</span>
<span class="line" id="L246">}</span>
<span class="line" id="L247"></span>
<span class="line" id="L248"><span class="tok-kw">test</span> <span class="tok-str">"math.atan64.special"</span> {</span>
<span class="line" id="L249"> <span class="tok-kw">const</span> epsilon = <span class="tok-number">0.000001</span>;</span>
<span class="line" id="L250"></span>
<span class="line" id="L251"> <span class="tok-kw">try</span> expect(atan64(<span class="tok-number">0.0</span>) == <span class="tok-number">0.0</span>);</span>
<span class="line" id="L252"> <span class="tok-kw">try</span> expect(atan64(-<span class="tok-number">0.0</span>) == -<span class="tok-number">0.0</span>);</span>
<span class="line" id="L253"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f64</span>, atan64(math.inf(<span class="tok-type">f64</span>)), math.pi / <span class="tok-number">2.0</span>, epsilon));</span>
<span class="line" id="L254"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f64</span>, atan64(-math.inf(<span class="tok-type">f64</span>)), -math.pi / <span class="tok-number">2.0</span>, epsilon));</span>
<span class="line" id="L255">}</span>
<span class="line" id="L256"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/math/log10.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>math/log10.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../std.zig"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> builtin = <span class="tok-builtin">@import</span>(<span class="tok-str">"builtin"</span>);</span>
<span class="line" id="L3"><span class="tok-kw">const</span> math = std.math;</span>
<span class="line" id="L4"><span class="tok-kw">const</span> testing = std.testing;</span>
<span class="line" id="L5"><span class="tok-kw">const</span> maxInt = std.math.maxInt;</span>
<span class="line" id="L6"><span class="tok-kw">const</span> assert = std.debug.assert;</span>
<span class="line" id="L7"><span class="tok-kw">const</span> Log2Int = std.math.Log2Int;</span>
<span class="line" id="L8"></span>
<span class="line" id="L9"><span class="tok-comment">/// Returns the base-10 logarithm of x.</span></span>
<span class="line" id="L10"><span class="tok-comment">///</span></span>
<span class="line" id="L11"><span class="tok-comment">/// Special Cases:</span></span>
<span class="line" id="L12"><span class="tok-comment">/// - log10(+inf) = +inf</span></span>
<span class="line" id="L13"><span class="tok-comment">/// - log10(0) = -inf</span></span>
<span class="line" id="L14"><span class="tok-comment">/// - log10(x) = nan if x < 0</span></span>
<span class="line" id="L15"><span class="tok-comment">/// - log10(nan) = nan</span></span>
<span class="line" id="L16"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">log10</span>(x: <span class="tok-kw">anytype</span>) <span class="tok-builtin">@TypeOf</span>(x) {</span>
<span class="line" id="L17"> <span class="tok-kw">const</span> T = <span class="tok-builtin">@TypeOf</span>(x);</span>
<span class="line" id="L18"> <span class="tok-kw">switch</span> (<span class="tok-builtin">@typeInfo</span>(T)) {</span>
<span class="line" id="L19"> .ComptimeFloat => {</span>
<span class="line" id="L20"> <span class="tok-kw">return</span> <span class="tok-builtin">@as</span>(<span class="tok-type">comptime_float</span>, <span class="tok-builtin">@log10</span>(x));</span>
<span class="line" id="L21"> },</span>
<span class="line" id="L22"> .Float => <span class="tok-kw">return</span> <span class="tok-builtin">@log10</span>(x),</span>
<span class="line" id="L23"> .ComptimeInt => {</span>
<span class="line" id="L24"> <span class="tok-kw">return</span> <span class="tok-builtin">@as</span>(<span class="tok-type">comptime_int</span>, <span class="tok-builtin">@floor</span>(<span class="tok-builtin">@log10</span>(<span class="tok-builtin">@as</span>(<span class="tok-type">f64</span>, x))));</span>
<span class="line" id="L25"> },</span>
<span class="line" id="L26"> .Int => |IntType| <span class="tok-kw">switch</span> (IntType.signedness) {</span>
<span class="line" id="L27"> .signed => <span class="tok-builtin">@compileError</span>(<span class="tok-str">"log10 not implemented for signed integers"</span>),</span>
<span class="line" id="L28"> .unsigned => <span class="tok-kw">return</span> log10_int(x),</span>
<span class="line" id="L29"> },</span>
<span class="line" id="L30"> <span class="tok-kw">else</span> => <span class="tok-builtin">@compileError</span>(<span class="tok-str">"log10 not implemented for "</span> ++ <span class="tok-builtin">@typeName</span>(T)),</span>
<span class="line" id="L31"> }</span>
<span class="line" id="L32">}</span>
<span class="line" id="L33"></span>
<span class="line" id="L34"><span class="tok-comment">// Based on Rust, which is licensed under the MIT license.</span>
</span>
<span class="line" id="L35"><span class="tok-comment">// https://github.com/rust-lang/rust/blob/f63ccaf25f74151a5d8ce057904cd944074b01d2/LICENSE-MIT</span>
</span>
<span class="line" id="L36"><span class="tok-comment">//</span>
</span>
<span class="line" id="L37"><span class="tok-comment">// https://github.com/rust-lang/rust/blob/f63ccaf25f74151a5d8ce057904cd944074b01d2/library/core/src/num/int_log10.rs</span>
</span>
<span class="line" id="L38"></span>
<span class="line" id="L39"><span class="tok-comment">/// Return the log base 10 of integer value x, rounding down to the</span></span>
<span class="line" id="L40"><span class="tok-comment">/// nearest integer.</span></span>
<span class="line" id="L41"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">log10_int</span>(x: <span class="tok-kw">anytype</span>) Log2Int(<span class="tok-builtin">@TypeOf</span>(x)) {</span>
<span class="line" id="L42"> <span class="tok-kw">const</span> T = <span class="tok-builtin">@TypeOf</span>(x);</span>
<span class="line" id="L43"> <span class="tok-kw">const</span> OutT = Log2Int(T);</span>
<span class="line" id="L44"> <span class="tok-kw">if</span> (<span class="tok-builtin">@typeInfo</span>(T) != .Int <span class="tok-kw">or</span> <span class="tok-builtin">@typeInfo</span>(T).Int.signedness != .unsigned)</span>
<span class="line" id="L45"> <span class="tok-builtin">@compileError</span>(<span class="tok-str">"log10_int requires an unsigned integer, found "</span> ++ <span class="tok-builtin">@typeName</span>(T));</span>
<span class="line" id="L46"></span>
<span class="line" id="L47"> assert(x != <span class="tok-number">0</span>);</span>
<span class="line" id="L48"></span>
<span class="line" id="L49"> <span class="tok-kw">const</span> bit_size = <span class="tok-builtin">@typeInfo</span>(T).Int.bits;</span>
<span class="line" id="L50"></span>
<span class="line" id="L51"> <span class="tok-kw">if</span> (bit_size <= <span class="tok-number">8</span>) {</span>
<span class="line" id="L52"> <span class="tok-kw">return</span> <span class="tok-builtin">@as</span>(OutT, <span class="tok-builtin">@intCast</span>(log10_int_u8(x)));</span>
<span class="line" id="L53"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (bit_size <= <span class="tok-number">16</span>) {</span>
<span class="line" id="L54"> <span class="tok-kw">return</span> <span class="tok-builtin">@as</span>(OutT, <span class="tok-builtin">@intCast</span>(less_than_5(x)));</span>
<span class="line" id="L55"> }</span>
<span class="line" id="L56"></span>
<span class="line" id="L57"> <span class="tok-kw">var</span> val = x;</span>
<span class="line" id="L58"> <span class="tok-kw">var</span> log: <span class="tok-type">u32</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L59"></span>
<span class="line" id="L60"> <span class="tok-kw">inline</span> <span class="tok-kw">for</span> (<span class="tok-number">0</span>..<span class="tok-number">11</span>) |i| {</span>
<span class="line" id="L61"> <span class="tok-comment">// Unnecessary branches should be removed by the compiler</span>
</span>
<span class="line" id="L62"> <span class="tok-kw">if</span> (bit_size > (<span class="tok-number">1</span> << (<span class="tok-number">11</span> - i)) * <span class="tok-number">5</span> * <span class="tok-builtin">@log2</span>(<span class="tok-number">10.0</span>) <span class="tok-kw">and</span> val >= pow10((<span class="tok-number">1</span> << (<span class="tok-number">11</span> - i)) * <span class="tok-number">5</span>)) {</span>
<span class="line" id="L63"> <span class="tok-kw">const</span> num_digits = (<span class="tok-number">1</span> << (<span class="tok-number">11</span> - i)) * <span class="tok-number">5</span>;</span>
<span class="line" id="L64"> val /= pow10(num_digits);</span>
<span class="line" id="L65"> log += num_digits;</span>
<span class="line" id="L66"> }</span>
<span class="line" id="L67"> }</span>
<span class="line" id="L68"></span>
<span class="line" id="L69"> <span class="tok-kw">if</span> (val >= pow10(<span class="tok-number">5</span>)) {</span>
<span class="line" id="L70"> val /= pow10(<span class="tok-number">5</span>);</span>
<span class="line" id="L71"> log += <span class="tok-number">5</span>;</span>
<span class="line" id="L72"> }</span>
<span class="line" id="L73"></span>
<span class="line" id="L74"> <span class="tok-kw">return</span> <span class="tok-builtin">@as</span>(OutT, <span class="tok-builtin">@intCast</span>(log + less_than_5(<span class="tok-builtin">@as</span>(<span class="tok-type">u32</span>, <span class="tok-builtin">@intCast</span>(val)))));</span>
<span class="line" id="L75">}</span>
<span class="line" id="L76"></span>
<span class="line" id="L77"><span class="tok-kw">fn</span> <span class="tok-fn">pow10</span>(<span class="tok-kw">comptime</span> y: <span class="tok-type">comptime_int</span>) <span class="tok-type">comptime_int</span> {</span>
<span class="line" id="L78"> <span class="tok-kw">if</span> (y == <span class="tok-number">0</span>) <span class="tok-kw">return</span> <span class="tok-number">1</span>;</span>
<span class="line" id="L79"></span>
<span class="line" id="L80"> <span class="tok-kw">var</span> squaring = <span class="tok-number">0</span>;</span>
<span class="line" id="L81"> <span class="tok-kw">var</span> s = <span class="tok-number">1</span>;</span>
<span class="line" id="L82"></span>
<span class="line" id="L83"> <span class="tok-kw">while</span> (s <= y) : (s <<= <span class="tok-number">1</span>) {</span>
<span class="line" id="L84"> squaring += <span class="tok-number">1</span>;</span>
<span class="line" id="L85"> }</span>
<span class="line" id="L86"></span>
<span class="line" id="L87"> squaring -= <span class="tok-number">1</span>;</span>
<span class="line" id="L88"></span>
<span class="line" id="L89"> <span class="tok-kw">var</span> result = <span class="tok-number">10</span>;</span>
<span class="line" id="L90"></span>
<span class="line" id="L91"> <span class="tok-kw">for</span> (<span class="tok-number">0</span>..squaring) |_| {</span>
<span class="line" id="L92"> result *= result;</span>
<span class="line" id="L93"> }</span>
<span class="line" id="L94"></span>
<span class="line" id="L95"> <span class="tok-kw">const</span> rest_exp = y - (<span class="tok-number">1</span> << squaring);</span>
<span class="line" id="L96"></span>
<span class="line" id="L97"> <span class="tok-kw">return</span> result * pow10(rest_exp);</span>
<span class="line" id="L98">}</span>
<span class="line" id="L99"></span>
<span class="line" id="L100"><span class="tok-kw">inline</span> <span class="tok-kw">fn</span> <span class="tok-fn">log10_int_u8</span>(x: <span class="tok-type">u8</span>) <span class="tok-type">u32</span> {</span>
<span class="line" id="L101"> <span class="tok-comment">// For better performance, avoid branches by assembling the solution</span>
</span>
<span class="line" id="L102"> <span class="tok-comment">// in the bits above the low 8 bits.</span>
</span>
<span class="line" id="L103"></span>
<span class="line" id="L104"> <span class="tok-comment">// Adding c1 to val gives 10 in the top bits for val < 10, 11 for val >= 10</span>
</span>
<span class="line" id="L105"> <span class="tok-kw">const</span> C1: <span class="tok-type">u32</span> = <span class="tok-number">0b11_00000000</span> - <span class="tok-number">10</span>; <span class="tok-comment">// 758</span>
</span>
<span class="line" id="L106"> <span class="tok-comment">// Adding c2 to val gives 01 in the top bits for val < 100, 10 for val >= 100</span>
</span>
<span class="line" id="L107"> <span class="tok-kw">const</span> C2: <span class="tok-type">u32</span> = <span class="tok-number">0b10_00000000</span> - <span class="tok-number">100</span>; <span class="tok-comment">// 412</span>
</span>
<span class="line" id="L108"></span>
<span class="line" id="L109"> <span class="tok-comment">// Value of top bits:</span>
</span>
<span class="line" id="L110"> <span class="tok-comment">// +c1 +c2 1&2</span>
</span>
<span class="line" id="L111"> <span class="tok-comment">// 0..=9 10 01 00 = 0</span>
</span>
<span class="line" id="L112"> <span class="tok-comment">// 10..=99 11 01 01 = 1</span>
</span>
<span class="line" id="L113"> <span class="tok-comment">// 100..=255 11 10 10 = 2</span>
</span>
<span class="line" id="L114"> <span class="tok-kw">return</span> ((x + C1) & (x + C2)) >> <span class="tok-number">8</span>;</span>
<span class="line" id="L115">}</span>
<span class="line" id="L116"></span>
<span class="line" id="L117"><span class="tok-kw">inline</span> <span class="tok-kw">fn</span> <span class="tok-fn">less_than_5</span>(x: <span class="tok-type">u32</span>) <span class="tok-type">u32</span> {</span>
<span class="line" id="L118"> <span class="tok-comment">// Similar to log10u8, when adding one of these constants to val,</span>
</span>
<span class="line" id="L119"> <span class="tok-comment">// we get two possible bit patterns above the low 17 bits,</span>
</span>
<span class="line" id="L120"> <span class="tok-comment">// depending on whether val is below or above the threshold.</span>
</span>
<span class="line" id="L121"> <span class="tok-kw">const</span> C1: <span class="tok-type">u32</span> = <span class="tok-number">0b011_00000000000000000</span> - <span class="tok-number">10</span>; <span class="tok-comment">// 393206</span>
</span>
<span class="line" id="L122"> <span class="tok-kw">const</span> C2: <span class="tok-type">u32</span> = <span class="tok-number">0b100_00000000000000000</span> - <span class="tok-number">100</span>; <span class="tok-comment">// 524188</span>
</span>
<span class="line" id="L123"> <span class="tok-kw">const</span> C3: <span class="tok-type">u32</span> = <span class="tok-number">0b111_00000000000000000</span> - <span class="tok-number">1000</span>; <span class="tok-comment">// 916504</span>
</span>
<span class="line" id="L124"> <span class="tok-kw">const</span> C4: <span class="tok-type">u32</span> = <span class="tok-number">0b100_00000000000000000</span> - <span class="tok-number">10000</span>; <span class="tok-comment">// 514288</span>
</span>
<span class="line" id="L125"></span>
<span class="line" id="L126"> <span class="tok-comment">// Value of top bits:</span>
</span>
<span class="line" id="L127"> <span class="tok-comment">// +c1 +c2 1&2 +c3 +c4 3&4 ^</span>
</span>
<span class="line" id="L128"> <span class="tok-comment">// 0..=9 010 011 010 110 011 010 000 = 0</span>
</span>
<span class="line" id="L129"> <span class="tok-comment">// 10..=99 011 011 011 110 011 010 001 = 1</span>
</span>
<span class="line" id="L130"> <span class="tok-comment">// 100..=999 011 100 000 110 011 010 010 = 2</span>
</span>
<span class="line" id="L131"> <span class="tok-comment">// 1000..=9999 011 100 000 111 011 011 011 = 3</span>
</span>
<span class="line" id="L132"> <span class="tok-comment">// 10000..=99999 011 100 000 111 100 100 100 = 4</span>
</span>
<span class="line" id="L133"> <span class="tok-kw">return</span> (((x + C1) & (x + C2)) ^ ((x + C3) & (x + C4))) >> <span class="tok-number">17</span>;</span>
<span class="line" id="L134">}</span>
<span class="line" id="L135"></span>
<span class="line" id="L136"><span class="tok-kw">fn</span> <span class="tok-fn">oldlog10</span>(x: <span class="tok-kw">anytype</span>) <span class="tok-type">u8</span> {</span>
<span class="line" id="L137"> <span class="tok-kw">return</span> <span class="tok-builtin">@as</span>(<span class="tok-type">u8</span>, <span class="tok-builtin">@intFromFloat</span>(<span class="tok-builtin">@log10</span>(<span class="tok-builtin">@as</span>(<span class="tok-type">f64</span>, <span class="tok-builtin">@floatFromInt</span>(x)))));</span>
<span class="line" id="L138">}</span>
<span class="line" id="L139"></span>
<span class="line" id="L140"><span class="tok-kw">test</span> <span class="tok-str">"oldlog10 doesn't work"</span> {</span>
<span class="line" id="L141"> <span class="tok-kw">try</span> testing.expect(<span class="tok-number">14</span> != oldlog10(pow10(<span class="tok-number">15</span>) - <span class="tok-number">1</span>));</span>
<span class="line" id="L142"></span>
<span class="line" id="L143"> <span class="tok-comment">// log10(10**15 -1) should indeed be 14</span>
</span>
<span class="line" id="L144"> <span class="tok-kw">try</span> testing.expect(<span class="tok-number">14</span> == log10_int(<span class="tok-builtin">@as</span>(<span class="tok-type">u64</span>, pow10(<span class="tok-number">15</span>) - <span class="tok-number">1</span>)));</span>
<span class="line" id="L145">}</span>
<span class="line" id="L146"></span>
<span class="line" id="L147"><span class="tok-kw">test</span> <span class="tok-str">"log10_int vs old implementation"</span> {</span>
<span class="line" id="L148"> <span class="tok-kw">if</span> (builtin.zig_backend == .stage2_wasm) <span class="tok-kw">return</span> <span class="tok-kw">error</span>.SkipZigTest; <span class="tok-comment">// TODO</span>
</span>
<span class="line" id="L149"> <span class="tok-kw">if</span> (builtin.zig_backend == .stage2_c) <span class="tok-kw">return</span> <span class="tok-kw">error</span>.SkipZigTest; <span class="tok-comment">// TODO</span>
</span>
<span class="line" id="L150"> <span class="tok-kw">if</span> (builtin.zig_backend == .stage2_x86_64) <span class="tok-kw">return</span> <span class="tok-kw">error</span>.SkipZigTest; <span class="tok-comment">// TODO</span>
</span>
<span class="line" id="L151"> <span class="tok-kw">if</span> (builtin.zig_backend == .stage2_aarch64) <span class="tok-kw">return</span> <span class="tok-kw">error</span>.SkipZigTest; <span class="tok-comment">// TODO</span>
</span>
<span class="line" id="L152"> <span class="tok-kw">if</span> (builtin.zig_backend == .stage2_sparc64) <span class="tok-kw">return</span> <span class="tok-kw">error</span>.SkipZigTest; <span class="tok-comment">// TODO</span>
</span>
<span class="line" id="L153"> <span class="tok-kw">if</span> (builtin.zig_backend == .stage2_arm) <span class="tok-kw">return</span> <span class="tok-kw">error</span>.SkipZigTest; <span class="tok-comment">// TODO</span>
</span>
<span class="line" id="L154"> <span class="tok-kw">if</span> (builtin.zig_backend == .stage2_llvm <span class="tok-kw">and</span> <span class="tok-kw">comptime</span> builtin.target.isWasm()) <span class="tok-kw">return</span> <span class="tok-kw">error</span>.SkipZigTest; <span class="tok-comment">// TODO</span>
</span>
<span class="line" id="L155"></span>
<span class="line" id="L156"> <span class="tok-kw">const</span> int_types = .{ <span class="tok-type">u8</span>, <span class="tok-type">u16</span>, <span class="tok-type">u32</span>, <span class="tok-type">u64</span>, <span class="tok-type">u128</span> };</span>
<span class="line" id="L157"></span>
<span class="line" id="L158"> <span class="tok-kw">inline</span> <span class="tok-kw">for</span> (int_types) |T| {</span>
<span class="line" id="L159"> <span class="tok-kw">const</span> last = <span class="tok-builtin">@min</span>(maxInt(T), <span class="tok-number">100_000</span>);</span>
<span class="line" id="L160"> <span class="tok-kw">for</span> (<span class="tok-number">1</span>..last) |i| {</span>
<span class="line" id="L161"> <span class="tok-kw">const</span> x = <span class="tok-builtin">@as</span>(T, <span class="tok-builtin">@intCast</span>(i));</span>
<span class="line" id="L162"> <span class="tok-kw">try</span> testing.expectEqual(oldlog10(x), log10_int(x));</span>
<span class="line" id="L163"> }</span>
<span class="line" id="L164"></span>
<span class="line" id="L165"> <span class="tok-kw">const</span> max_int: T = maxInt(T);</span>
<span class="line" id="L166"> <span class="tok-kw">try</span> testing.expectEqual(oldlog10(max_int), log10_int(max_int));</span>
<span class="line" id="L167"> }</span>
<span class="line" id="L168">}</span>
<span class="line" id="L169"></span>
<span class="line" id="L170"><span class="tok-kw">test</span> <span class="tok-str">"log10_int close to powers of 10"</span> {</span>
<span class="line" id="L171"> <span class="tok-kw">if</span> (builtin.zig_backend == .stage2_wasm) <span class="tok-kw">return</span> <span class="tok-kw">error</span>.SkipZigTest; <span class="tok-comment">// TODO</span>
</span>
<span class="line" id="L172"> <span class="tok-kw">if</span> (builtin.zig_backend == .stage2_c) <span class="tok-kw">return</span> <span class="tok-kw">error</span>.SkipZigTest; <span class="tok-comment">// TODO</span>
</span>
<span class="line" id="L173"> <span class="tok-kw">if</span> (builtin.zig_backend == .stage2_x86_64) <span class="tok-kw">return</span> <span class="tok-kw">error</span>.SkipZigTest; <span class="tok-comment">// TODO</span>
</span>
<span class="line" id="L174"> <span class="tok-kw">if</span> (builtin.zig_backend == .stage2_aarch64) <span class="tok-kw">return</span> <span class="tok-kw">error</span>.SkipZigTest; <span class="tok-comment">// TODO</span>
</span>
<span class="line" id="L175"> <span class="tok-kw">if</span> (builtin.zig_backend == .stage2_sparc64) <span class="tok-kw">return</span> <span class="tok-kw">error</span>.SkipZigTest; <span class="tok-comment">// TODO</span>
</span>
<span class="line" id="L176"> <span class="tok-kw">if</span> (builtin.zig_backend == .stage2_arm) <span class="tok-kw">return</span> <span class="tok-kw">error</span>.SkipZigTest; <span class="tok-comment">// TODO</span>
</span>
<span class="line" id="L177"> <span class="tok-kw">if</span> (builtin.zig_backend == .stage2_llvm <span class="tok-kw">and</span> <span class="tok-kw">comptime</span> builtin.target.isWasm()) <span class="tok-kw">return</span> <span class="tok-kw">error</span>.SkipZigTest; <span class="tok-comment">// TODO</span>
</span>
<span class="line" id="L178"></span>
<span class="line" id="L179"> <span class="tok-kw">const</span> int_types = .{ <span class="tok-type">u8</span>, <span class="tok-type">u16</span>, <span class="tok-type">u32</span>, <span class="tok-type">u64</span>, <span class="tok-type">u128</span>, <span class="tok-type">u256</span>, <span class="tok-type">u512</span> };</span>
<span class="line" id="L180"> <span class="tok-kw">const</span> max_log_values: [<span class="tok-number">7</span>]<span class="tok-type">usize</span> = .{ <span class="tok-number">2</span>, <span class="tok-number">4</span>, <span class="tok-number">9</span>, <span class="tok-number">19</span>, <span class="tok-number">38</span>, <span class="tok-number">77</span>, <span class="tok-number">154</span> };</span>
<span class="line" id="L181"></span>
<span class="line" id="L182"> <span class="tok-kw">inline</span> <span class="tok-kw">for</span> (int_types, max_log_values) |T, expected_max_ilog| {</span>
<span class="line" id="L183"> <span class="tok-kw">const</span> max_val: T = maxInt(T);</span>
<span class="line" id="L184"></span>
<span class="line" id="L185"> <span class="tok-kw">try</span> testing.expectEqual(expected_max_ilog, log10_int(max_val));</span>
<span class="line" id="L186"></span>
<span class="line" id="L187"> <span class="tok-kw">for</span> (<span class="tok-number">0</span>..(expected_max_ilog + <span class="tok-number">1</span>)) |idx| {</span>
<span class="line" id="L188"> <span class="tok-kw">const</span> i = <span class="tok-builtin">@as</span>(T, <span class="tok-builtin">@intCast</span>(idx));</span>
<span class="line" id="L189"> <span class="tok-kw">const</span> p: T = <span class="tok-kw">try</span> math.powi(T, <span class="tok-number">10</span>, i);</span>
<span class="line" id="L190"></span>
<span class="line" id="L191"> <span class="tok-kw">const</span> b = <span class="tok-builtin">@as</span>(Log2Int(T), <span class="tok-builtin">@intCast</span>(i));</span>
<span class="line" id="L192"></span>
<span class="line" id="L193"> <span class="tok-kw">if</span> (p >= <span class="tok-number">10</span>) {</span>
<span class="line" id="L194"> <span class="tok-kw">try</span> testing.expectEqual(b - <span class="tok-number">1</span>, log10_int(p - <span class="tok-number">9</span>));</span>
<span class="line" id="L195"> <span class="tok-kw">try</span> testing.expectEqual(b - <span class="tok-number">1</span>, log10_int(p - <span class="tok-number">1</span>));</span>
<span class="line" id="L196"> }</span>
<span class="line" id="L197"></span>
<span class="line" id="L198"> <span class="tok-kw">try</span> testing.expectEqual(b, log10_int(p));</span>
<span class="line" id="L199"> <span class="tok-kw">try</span> testing.expectEqual(b, log10_int(p + <span class="tok-number">1</span>));</span>
<span class="line" id="L200"> <span class="tok-kw">if</span> (p >= <span class="tok-number">10</span>) {</span>
<span class="line" id="L201"> <span class="tok-kw">try</span> testing.expectEqual(b, log10_int(p + <span class="tok-number">9</span>));</span>
<span class="line" id="L202"> }</span>
<span class="line" id="L203"> }</span>
<span class="line" id="L204"> }</span>
<span class="line" id="L205">}</span>
<span class="line" id="L206"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/math/isnormal.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>math/isnormal.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../std.zig"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> math = std.math;</span>
<span class="line" id="L3"><span class="tok-kw">const</span> expect = std.testing.expect;</span>
<span class="line" id="L4"></span>
<span class="line" id="L5"><span class="tok-comment">/// Returns whether x is neither zero, subnormal, infinity, or NaN.</span></span>
<span class="line" id="L6"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">isNormal</span>(x: <span class="tok-kw">anytype</span>) <span class="tok-type">bool</span> {</span>
<span class="line" id="L7"> <span class="tok-kw">const</span> T = <span class="tok-builtin">@TypeOf</span>(x);</span>
<span class="line" id="L8"> <span class="tok-kw">const</span> TBits = std.meta.Int(.unsigned, <span class="tok-builtin">@typeInfo</span>(T).Float.bits);</span>
<span class="line" id="L9"></span>
<span class="line" id="L10"> <span class="tok-kw">const</span> increment_exp = <span class="tok-number">1</span> << math.floatMantissaBits(T);</span>
<span class="line" id="L11"> <span class="tok-kw">const</span> remove_sign = ~<span class="tok-builtin">@as</span>(TBits, <span class="tok-number">0</span>) >> <span class="tok-number">1</span>;</span>
<span class="line" id="L12"></span>
<span class="line" id="L13"> <span class="tok-comment">// We add 1 to the exponent, and if it overflows to 0 or becomes 1,</span>
</span>
<span class="line" id="L14"> <span class="tok-comment">// then it was all zeroes (subnormal) or all ones (special, inf/nan).</span>
</span>
<span class="line" id="L15"> <span class="tok-comment">// The sign bit is removed because all ones would overflow into it.</span>
</span>
<span class="line" id="L16"> <span class="tok-comment">// For f80, even though it has an explicit integer part stored,</span>
</span>
<span class="line" id="L17"> <span class="tok-comment">// the exponent effectively takes priority if mismatching.</span>
</span>
<span class="line" id="L18"> <span class="tok-kw">const</span> value = <span class="tok-builtin">@as</span>(TBits, <span class="tok-builtin">@bitCast</span>(x)) +% increment_exp;</span>
<span class="line" id="L19"> <span class="tok-kw">return</span> value & remove_sign >= (increment_exp << <span class="tok-number">1</span>);</span>
<span class="line" id="L20">}</span>
<span class="line" id="L21"></span>
<span class="line" id="L22"><span class="tok-kw">test</span> <span class="tok-str">"math.isNormal"</span> {</span>
<span class="line" id="L23"> <span class="tok-comment">// TODO add `c_longdouble' when math.inf(T) supports it</span>
</span>
<span class="line" id="L24"> <span class="tok-kw">inline</span> <span class="tok-kw">for</span> ([_]<span class="tok-type">type</span>{ <span class="tok-type">f16</span>, <span class="tok-type">f32</span>, <span class="tok-type">f64</span>, <span class="tok-type">f80</span>, <span class="tok-type">f128</span> }) |T| {</span>
<span class="line" id="L25"> <span class="tok-kw">const</span> TBits = std.meta.Int(.unsigned, <span class="tok-builtin">@bitSizeOf</span>(T));</span>
<span class="line" id="L26"></span>
<span class="line" id="L27"> <span class="tok-comment">// normals</span>
</span>
<span class="line" id="L28"> <span class="tok-kw">try</span> expect(isNormal(<span class="tok-builtin">@as</span>(T, <span class="tok-number">1.0</span>)));</span>
<span class="line" id="L29"> <span class="tok-kw">try</span> expect(isNormal(math.floatMin(T)));</span>
<span class="line" id="L30"> <span class="tok-kw">try</span> expect(isNormal(math.floatMax(T)));</span>
<span class="line" id="L31"></span>
<span class="line" id="L32"> <span class="tok-comment">// subnormals</span>
</span>
<span class="line" id="L33"> <span class="tok-kw">try</span> expect(!isNormal(<span class="tok-builtin">@as</span>(T, -<span class="tok-number">0.0</span>)));</span>
<span class="line" id="L34"> <span class="tok-kw">try</span> expect(!isNormal(<span class="tok-builtin">@as</span>(T, <span class="tok-number">0.0</span>)));</span>
<span class="line" id="L35"> <span class="tok-kw">try</span> expect(!isNormal(<span class="tok-builtin">@as</span>(T, math.floatTrueMin(T))));</span>
<span class="line" id="L36"></span>
<span class="line" id="L37"> <span class="tok-comment">// largest subnormal</span>
</span>
<span class="line" id="L38"> <span class="tok-kw">try</span> expect(!isNormal(<span class="tok-builtin">@as</span>(T, <span class="tok-builtin">@bitCast</span>(~(~<span class="tok-builtin">@as</span>(TBits, <span class="tok-number">0</span>) << math.floatFractionalBits(T))))));</span>
<span class="line" id="L39"></span>
<span class="line" id="L40"> <span class="tok-comment">// non-finite numbers</span>
</span>
<span class="line" id="L41"> <span class="tok-kw">try</span> expect(!isNormal(-math.inf(T)));</span>
<span class="line" id="L42"> <span class="tok-kw">try</span> expect(!isNormal(math.inf(T)));</span>
<span class="line" id="L43"> <span class="tok-kw">try</span> expect(!isNormal(math.nan(T)));</span>
<span class="line" id="L44"></span>
<span class="line" id="L45"> <span class="tok-comment">// overflow edge-case (described in implementation, also see #10133)</span>
</span>
<span class="line" id="L46"> <span class="tok-kw">try</span> expect(!isNormal(<span class="tok-builtin">@as</span>(T, <span class="tok-builtin">@bitCast</span>(~<span class="tok-builtin">@as</span>(TBits, <span class="tok-number">0</span>)))));</span>
<span class="line" id="L47"> }</span>
<span class="line" id="L48">}</span>
<span class="line" id="L49"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/math/frexp.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>math/frexp.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-comment">// Ported from musl, which is MIT licensed:</span>
</span>
<span class="line" id="L2"><span class="tok-comment">// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT</span>
</span>
<span class="line" id="L3"><span class="tok-comment">//</span>
</span>
<span class="line" id="L4"><span class="tok-comment">// https://git.musl-libc.org/cgit/musl/tree/src/math/frexpl.c</span>
</span>
<span class="line" id="L5"><span class="tok-comment">// https://git.musl-libc.org/cgit/musl/tree/src/math/frexpf.c</span>
</span>
<span class="line" id="L6"><span class="tok-comment">// https://git.musl-libc.org/cgit/musl/tree/src/math/frexp.c</span>
</span>
<span class="line" id="L7"></span>
<span class="line" id="L8"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../std.zig"</span>);</span>
<span class="line" id="L9"><span class="tok-kw">const</span> math = std.math;</span>
<span class="line" id="L10"><span class="tok-kw">const</span> expect = std.testing.expect;</span>
<span class="line" id="L11"></span>
<span class="line" id="L12"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">Frexp</span>(<span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>) <span class="tok-type">type</span> {</span>
<span class="line" id="L13"> <span class="tok-kw">return</span> <span class="tok-kw">struct</span> {</span>
<span class="line" id="L14"> significand: T,</span>
<span class="line" id="L15"> exponent: <span class="tok-type">i32</span>,</span>
<span class="line" id="L16"> };</span>
<span class="line" id="L17">}</span>
<span class="line" id="L18"></span>
<span class="line" id="L19"><span class="tok-comment">/// Breaks x into a normalized fraction and an integral power of two.</span></span>
<span class="line" id="L20"><span class="tok-comment">/// f == frac * 2^exp, with |frac| in the interval [0.5, 1).</span></span>
<span class="line" id="L21"><span class="tok-comment">///</span></span>
<span class="line" id="L22"><span class="tok-comment">/// Special Cases:</span></span>
<span class="line" id="L23"><span class="tok-comment">/// - frexp(+-0) = +-0, 0</span></span>
<span class="line" id="L24"><span class="tok-comment">/// - frexp(+-inf) = +-inf, 0</span></span>
<span class="line" id="L25"><span class="tok-comment">/// - frexp(nan) = nan, undefined</span></span>
<span class="line" id="L26"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">frexp</span>(x: <span class="tok-kw">anytype</span>) Frexp(<span class="tok-builtin">@TypeOf</span>(x)) {</span>
<span class="line" id="L27"> <span class="tok-kw">const</span> T = <span class="tok-builtin">@TypeOf</span>(x);</span>
<span class="line" id="L28"> <span class="tok-kw">return</span> <span class="tok-kw">switch</span> (T) {</span>
<span class="line" id="L29"> <span class="tok-type">f32</span> => frexp32(x),</span>
<span class="line" id="L30"> <span class="tok-type">f64</span> => frexp64(x),</span>
<span class="line" id="L31"> <span class="tok-type">f128</span> => frexp128(x),</span>
<span class="line" id="L32"> <span class="tok-kw">else</span> => <span class="tok-builtin">@compileError</span>(<span class="tok-str">"frexp not implemented for "</span> ++ <span class="tok-builtin">@typeName</span>(T)),</span>
<span class="line" id="L33"> };</span>
<span class="line" id="L34">}</span>
<span class="line" id="L35"></span>
<span class="line" id="L36"><span class="tok-comment">// TODO: unify all these implementations using generics</span>
</span>
<span class="line" id="L37"></span>
<span class="line" id="L38"><span class="tok-kw">fn</span> <span class="tok-fn">frexp32</span>(x: <span class="tok-type">f32</span>) Frexp(<span class="tok-type">f32</span>) {</span>
<span class="line" id="L39"> <span class="tok-kw">var</span> result: Frexp(<span class="tok-type">f32</span>) = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L40"></span>
<span class="line" id="L41"> <span class="tok-kw">var</span> y = <span class="tok-builtin">@as</span>(<span class="tok-type">u32</span>, <span class="tok-builtin">@bitCast</span>(x));</span>
<span class="line" id="L42"> <span class="tok-kw">const</span> e = <span class="tok-builtin">@as</span>(<span class="tok-type">i32</span>, <span class="tok-builtin">@intCast</span>(y >> <span class="tok-number">23</span>)) & <span class="tok-number">0xFF</span>;</span>
<span class="line" id="L43"></span>
<span class="line" id="L44"> <span class="tok-kw">if</span> (e == <span class="tok-number">0</span>) {</span>
<span class="line" id="L45"> <span class="tok-kw">if</span> (x != <span class="tok-number">0</span>) {</span>
<span class="line" id="L46"> <span class="tok-comment">// subnormal</span>
</span>
<span class="line" id="L47"> result = frexp32(x * <span class="tok-number">0x1.0p64</span>);</span>
<span class="line" id="L48"> result.exponent -= <span class="tok-number">64</span>;</span>
<span class="line" id="L49"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L50"> <span class="tok-comment">// frexp(+-0) = (+-0, 0)</span>
</span>
<span class="line" id="L51"> result.significand = x;</span>
<span class="line" id="L52"> result.exponent = <span class="tok-number">0</span>;</span>
<span class="line" id="L53"> }</span>
<span class="line" id="L54"> <span class="tok-kw">return</span> result;</span>
<span class="line" id="L55"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (e == <span class="tok-number">0xFF</span>) {</span>
<span class="line" id="L56"> <span class="tok-comment">// frexp(nan) = (nan, undefined)</span>
</span>
<span class="line" id="L57"> result.significand = x;</span>
<span class="line" id="L58"> result.exponent = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L59"></span>
<span class="line" id="L60"> <span class="tok-comment">// frexp(+-inf) = (+-inf, 0)</span>
</span>
<span class="line" id="L61"> <span class="tok-kw">if</span> (math.isInf(x)) {</span>
<span class="line" id="L62"> result.exponent = <span class="tok-number">0</span>;</span>
<span class="line" id="L63"> }</span>
<span class="line" id="L64"></span>
<span class="line" id="L65"> <span class="tok-kw">return</span> result;</span>
<span class="line" id="L66"> }</span>
<span class="line" id="L67"></span>
<span class="line" id="L68"> result.exponent = e - <span class="tok-number">0x7E</span>;</span>
<span class="line" id="L69"> y &= <span class="tok-number">0x807FFFFF</span>;</span>
<span class="line" id="L70"> y |= <span class="tok-number">0x3F000000</span>;</span>
<span class="line" id="L71"> result.significand = <span class="tok-builtin">@as</span>(<span class="tok-type">f32</span>, <span class="tok-builtin">@bitCast</span>(y));</span>
<span class="line" id="L72"> <span class="tok-kw">return</span> result;</span>
<span class="line" id="L73">}</span>
<span class="line" id="L74"></span>
<span class="line" id="L75"><span class="tok-kw">fn</span> <span class="tok-fn">frexp64</span>(x: <span class="tok-type">f64</span>) Frexp(<span class="tok-type">f64</span>) {</span>
<span class="line" id="L76"> <span class="tok-kw">var</span> result: Frexp(<span class="tok-type">f64</span>) = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L77"></span>
<span class="line" id="L78"> <span class="tok-kw">var</span> y = <span class="tok-builtin">@as</span>(<span class="tok-type">u64</span>, <span class="tok-builtin">@bitCast</span>(x));</span>
<span class="line" id="L79"> <span class="tok-kw">const</span> e = <span class="tok-builtin">@as</span>(<span class="tok-type">i32</span>, <span class="tok-builtin">@intCast</span>(y >> <span class="tok-number">52</span>)) & <span class="tok-number">0x7FF</span>;</span>
<span class="line" id="L80"></span>
<span class="line" id="L81"> <span class="tok-kw">if</span> (e == <span class="tok-number">0</span>) {</span>
<span class="line" id="L82"> <span class="tok-kw">if</span> (x != <span class="tok-number">0</span>) {</span>
<span class="line" id="L83"> <span class="tok-comment">// subnormal</span>
</span>
<span class="line" id="L84"> result = frexp64(x * <span class="tok-number">0x1.0p64</span>);</span>
<span class="line" id="L85"> result.exponent -= <span class="tok-number">64</span>;</span>
<span class="line" id="L86"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L87"> <span class="tok-comment">// frexp(+-0) = (+-0, 0)</span>
</span>
<span class="line" id="L88"> result.significand = x;</span>
<span class="line" id="L89"> result.exponent = <span class="tok-number">0</span>;</span>
<span class="line" id="L90"> }</span>
<span class="line" id="L91"> <span class="tok-kw">return</span> result;</span>
<span class="line" id="L92"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (e == <span class="tok-number">0x7FF</span>) {</span>
<span class="line" id="L93"> <span class="tok-comment">// frexp(nan) = (nan, undefined)</span>
</span>
<span class="line" id="L94"> result.significand = x;</span>
<span class="line" id="L95"> result.exponent = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L96"></span>
<span class="line" id="L97"> <span class="tok-comment">// frexp(+-inf) = (+-inf, 0)</span>
</span>
<span class="line" id="L98"> <span class="tok-kw">if</span> (math.isInf(x)) {</span>
<span class="line" id="L99"> result.exponent = <span class="tok-number">0</span>;</span>
<span class="line" id="L100"> }</span>
<span class="line" id="L101"></span>
<span class="line" id="L102"> <span class="tok-kw">return</span> result;</span>
<span class="line" id="L103"> }</span>
<span class="line" id="L104"></span>
<span class="line" id="L105"> result.exponent = e - <span class="tok-number">0x3FE</span>;</span>
<span class="line" id="L106"> y &= <span class="tok-number">0x800FFFFFFFFFFFFF</span>;</span>
<span class="line" id="L107"> y |= <span class="tok-number">0x3FE0000000000000</span>;</span>
<span class="line" id="L108"> result.significand = <span class="tok-builtin">@as</span>(<span class="tok-type">f64</span>, <span class="tok-builtin">@bitCast</span>(y));</span>
<span class="line" id="L109"> <span class="tok-kw">return</span> result;</span>
<span class="line" id="L110">}</span>
<span class="line" id="L111"></span>
<span class="line" id="L112"><span class="tok-kw">fn</span> <span class="tok-fn">frexp128</span>(x: <span class="tok-type">f128</span>) Frexp(<span class="tok-type">f128</span>) {</span>
<span class="line" id="L113"> <span class="tok-kw">var</span> result: Frexp(<span class="tok-type">f128</span>) = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L114"></span>
<span class="line" id="L115"> <span class="tok-kw">var</span> y = <span class="tok-builtin">@as</span>(<span class="tok-type">u128</span>, <span class="tok-builtin">@bitCast</span>(x));</span>
<span class="line" id="L116"> <span class="tok-kw">const</span> e = <span class="tok-builtin">@as</span>(<span class="tok-type">i32</span>, <span class="tok-builtin">@intCast</span>(y >> <span class="tok-number">112</span>)) & <span class="tok-number">0x7FFF</span>;</span>
<span class="line" id="L117"></span>
<span class="line" id="L118"> <span class="tok-kw">if</span> (e == <span class="tok-number">0</span>) {</span>
<span class="line" id="L119"> <span class="tok-kw">if</span> (x != <span class="tok-number">0</span>) {</span>
<span class="line" id="L120"> <span class="tok-comment">// subnormal</span>
</span>
<span class="line" id="L121"> result = frexp128(x * <span class="tok-number">0x1.0p120</span>);</span>
<span class="line" id="L122"> result.exponent -= <span class="tok-number">120</span>;</span>
<span class="line" id="L123"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L124"> <span class="tok-comment">// frexp(+-0) = (+-0, 0)</span>
</span>
<span class="line" id="L125"> result.significand = x;</span>
<span class="line" id="L126"> result.exponent = <span class="tok-number">0</span>;</span>
<span class="line" id="L127"> }</span>
<span class="line" id="L128"> <span class="tok-kw">return</span> result;</span>
<span class="line" id="L129"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (e == <span class="tok-number">0x7FFF</span>) {</span>
<span class="line" id="L130"> <span class="tok-comment">// frexp(nan) = (nan, undefined)</span>
</span>
<span class="line" id="L131"> result.significand = x;</span>
<span class="line" id="L132"> result.exponent = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L133"></span>
<span class="line" id="L134"> <span class="tok-comment">// frexp(+-inf) = (+-inf, 0)</span>
</span>
<span class="line" id="L135"> <span class="tok-kw">if</span> (math.isInf(x)) {</span>
<span class="line" id="L136"> result.exponent = <span class="tok-number">0</span>;</span>
<span class="line" id="L137"> }</span>
<span class="line" id="L138"></span>
<span class="line" id="L139"> <span class="tok-kw">return</span> result;</span>
<span class="line" id="L140"> }</span>
<span class="line" id="L141"></span>
<span class="line" id="L142"> result.exponent = e - <span class="tok-number">0x3FFE</span>;</span>
<span class="line" id="L143"> y &= <span class="tok-number">0x8000FFFFFFFFFFFFFFFFFFFFFFFFFFFF</span>;</span>
<span class="line" id="L144"> y |= <span class="tok-number">0x3FFE0000000000000000000000000000</span>;</span>
<span class="line" id="L145"> result.significand = <span class="tok-builtin">@as</span>(<span class="tok-type">f128</span>, <span class="tok-builtin">@bitCast</span>(y));</span>
<span class="line" id="L146"> <span class="tok-kw">return</span> result;</span>
<span class="line" id="L147">}</span>
<span class="line" id="L148"></span>
<span class="line" id="L149"><span class="tok-kw">test</span> <span class="tok-str">"type dispatch"</span> {</span>
<span class="line" id="L150"> <span class="tok-kw">const</span> a = frexp(<span class="tok-builtin">@as</span>(<span class="tok-type">f32</span>, <span class="tok-number">1.3</span>));</span>
<span class="line" id="L151"> <span class="tok-kw">const</span> b = frexp32(<span class="tok-number">1.3</span>);</span>
<span class="line" id="L152"> <span class="tok-kw">try</span> expect(a.significand == b.significand <span class="tok-kw">and</span> a.exponent == b.exponent);</span>
<span class="line" id="L153"></span>
<span class="line" id="L154"> <span class="tok-kw">const</span> c = frexp(<span class="tok-builtin">@as</span>(<span class="tok-type">f64</span>, <span class="tok-number">1.3</span>));</span>
<span class="line" id="L155"> <span class="tok-kw">const</span> d = frexp64(<span class="tok-number">1.3</span>);</span>
<span class="line" id="L156"> <span class="tok-kw">try</span> expect(c.significand == d.significand <span class="tok-kw">and</span> c.exponent == d.exponent);</span>
<span class="line" id="L157"></span>
<span class="line" id="L158"> <span class="tok-kw">const</span> e = frexp(<span class="tok-builtin">@as</span>(<span class="tok-type">f128</span>, <span class="tok-number">1.3</span>));</span>
<span class="line" id="L159"> <span class="tok-kw">const</span> f = frexp128(<span class="tok-number">1.3</span>);</span>
<span class="line" id="L160"> <span class="tok-kw">try</span> expect(e.significand == f.significand <span class="tok-kw">and</span> e.exponent == f.exponent);</span>
<span class="line" id="L161">}</span>
<span class="line" id="L162"></span>
<span class="line" id="L163"><span class="tok-kw">test</span> <span class="tok-str">"32"</span> {</span>
<span class="line" id="L164"> <span class="tok-kw">const</span> epsilon = <span class="tok-number">0.000001</span>;</span>
<span class="line" id="L165"> <span class="tok-kw">var</span> r: Frexp(<span class="tok-type">f32</span>) = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L166"></span>
<span class="line" id="L167"> r = frexp32(<span class="tok-number">1.3</span>);</span>
<span class="line" id="L168"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f32</span>, r.significand, <span class="tok-number">0.65</span>, epsilon) <span class="tok-kw">and</span> r.exponent == <span class="tok-number">1</span>);</span>
<span class="line" id="L169"></span>
<span class="line" id="L170"> r = frexp32(<span class="tok-number">78.0234</span>);</span>
<span class="line" id="L171"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f32</span>, r.significand, <span class="tok-number">0.609558</span>, epsilon) <span class="tok-kw">and</span> r.exponent == <span class="tok-number">7</span>);</span>
<span class="line" id="L172">}</span>
<span class="line" id="L173"></span>
<span class="line" id="L174"><span class="tok-kw">test</span> <span class="tok-str">"64"</span> {</span>
<span class="line" id="L175"> <span class="tok-kw">const</span> epsilon = <span class="tok-number">0.000001</span>;</span>
<span class="line" id="L176"> <span class="tok-kw">var</span> r: Frexp(<span class="tok-type">f64</span>) = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L177"></span>
<span class="line" id="L178"> r = frexp64(<span class="tok-number">1.3</span>);</span>
<span class="line" id="L179"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f64</span>, r.significand, <span class="tok-number">0.65</span>, epsilon) <span class="tok-kw">and</span> r.exponent == <span class="tok-number">1</span>);</span>
<span class="line" id="L180"></span>
<span class="line" id="L181"> r = frexp64(<span class="tok-number">78.0234</span>);</span>
<span class="line" id="L182"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f64</span>, r.significand, <span class="tok-number">0.609558</span>, epsilon) <span class="tok-kw">and</span> r.exponent == <span class="tok-number">7</span>);</span>
<span class="line" id="L183">}</span>
<span class="line" id="L184"></span>
<span class="line" id="L185"><span class="tok-kw">test</span> <span class="tok-str">"128"</span> {</span>
<span class="line" id="L186"> <span class="tok-kw">const</span> epsilon = <span class="tok-number">0.000001</span>;</span>
<span class="line" id="L187"> <span class="tok-kw">var</span> r: Frexp(<span class="tok-type">f128</span>) = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L188"></span>
<span class="line" id="L189"> r = frexp128(<span class="tok-number">1.3</span>);</span>
<span class="line" id="L190"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f128</span>, r.significand, <span class="tok-number">0.65</span>, epsilon) <span class="tok-kw">and</span> r.exponent == <span class="tok-number">1</span>);</span>
<span class="line" id="L191"></span>
<span class="line" id="L192"> r = frexp128(<span class="tok-number">78.0234</span>);</span>
<span class="line" id="L193"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f128</span>, r.significand, <span class="tok-number">0.609558</span>, epsilon) <span class="tok-kw">and</span> r.exponent == <span class="tok-number">7</span>);</span>
<span class="line" id="L194">}</span>
<span class="line" id="L195"></span>
<span class="line" id="L196"><span class="tok-kw">test</span> <span class="tok-str">"32 special"</span> {</span>
<span class="line" id="L197"> <span class="tok-kw">var</span> r: Frexp(<span class="tok-type">f32</span>) = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L198"></span>
<span class="line" id="L199"> r = frexp32(<span class="tok-number">0.0</span>);</span>
<span class="line" id="L200"> <span class="tok-kw">try</span> expect(r.significand == <span class="tok-number">0.0</span> <span class="tok-kw">and</span> r.exponent == <span class="tok-number">0</span>);</span>
<span class="line" id="L201"></span>
<span class="line" id="L202"> r = frexp32(-<span class="tok-number">0.0</span>);</span>
<span class="line" id="L203"> <span class="tok-kw">try</span> expect(r.significand == -<span class="tok-number">0.0</span> <span class="tok-kw">and</span> r.exponent == <span class="tok-number">0</span>);</span>
<span class="line" id="L204"></span>
<span class="line" id="L205"> r = frexp32(math.inf(<span class="tok-type">f32</span>));</span>
<span class="line" id="L206"> <span class="tok-kw">try</span> expect(math.isPositiveInf(r.significand) <span class="tok-kw">and</span> r.exponent == <span class="tok-number">0</span>);</span>
<span class="line" id="L207"></span>
<span class="line" id="L208"> r = frexp32(-math.inf(<span class="tok-type">f32</span>));</span>
<span class="line" id="L209"> <span class="tok-kw">try</span> expect(math.isNegativeInf(r.significand) <span class="tok-kw">and</span> r.exponent == <span class="tok-number">0</span>);</span>
<span class="line" id="L210"></span>
<span class="line" id="L211"> r = frexp32(math.nan(<span class="tok-type">f32</span>));</span>
<span class="line" id="L212"> <span class="tok-kw">try</span> expect(math.isNan(r.significand));</span>
<span class="line" id="L213">}</span>
<span class="line" id="L214"></span>
<span class="line" id="L215"><span class="tok-kw">test</span> <span class="tok-str">"64 special"</span> {</span>
<span class="line" id="L216"> <span class="tok-kw">var</span> r: Frexp(<span class="tok-type">f64</span>) = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L217"></span>
<span class="line" id="L218"> r = frexp64(<span class="tok-number">0.0</span>);</span>
<span class="line" id="L219"> <span class="tok-kw">try</span> expect(r.significand == <span class="tok-number">0.0</span> <span class="tok-kw">and</span> r.exponent == <span class="tok-number">0</span>);</span>
<span class="line" id="L220"></span>
<span class="line" id="L221"> r = frexp64(-<span class="tok-number">0.0</span>);</span>
<span class="line" id="L222"> <span class="tok-kw">try</span> expect(r.significand == -<span class="tok-number">0.0</span> <span class="tok-kw">and</span> r.exponent == <span class="tok-number">0</span>);</span>
<span class="line" id="L223"></span>
<span class="line" id="L224"> r = frexp64(math.inf(<span class="tok-type">f64</span>));</span>
<span class="line" id="L225"> <span class="tok-kw">try</span> expect(math.isPositiveInf(r.significand) <span class="tok-kw">and</span> r.exponent == <span class="tok-number">0</span>);</span>
<span class="line" id="L226"></span>
<span class="line" id="L227"> r = frexp64(-math.inf(<span class="tok-type">f64</span>));</span>
<span class="line" id="L228"> <span class="tok-kw">try</span> expect(math.isNegativeInf(r.significand) <span class="tok-kw">and</span> r.exponent == <span class="tok-number">0</span>);</span>
<span class="line" id="L229"></span>
<span class="line" id="L230"> r = frexp64(math.nan(<span class="tok-type">f64</span>));</span>
<span class="line" id="L231"> <span class="tok-kw">try</span> expect(math.isNan(r.significand));</span>
<span class="line" id="L232">}</span>
<span class="line" id="L233"></span>
<span class="line" id="L234"><span class="tok-kw">test</span> <span class="tok-str">"128 special"</span> {</span>
<span class="line" id="L235"> <span class="tok-kw">var</span> r: Frexp(<span class="tok-type">f128</span>) = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L236"></span>
<span class="line" id="L237"> r = frexp128(<span class="tok-number">0.0</span>);</span>
<span class="line" id="L238"> <span class="tok-kw">try</span> expect(r.significand == <span class="tok-number">0.0</span> <span class="tok-kw">and</span> r.exponent == <span class="tok-number">0</span>);</span>
<span class="line" id="L239"></span>
<span class="line" id="L240"> r = frexp128(-<span class="tok-number">0.0</span>);</span>
<span class="line" id="L241"> <span class="tok-kw">try</span> expect(r.significand == -<span class="tok-number">0.0</span> <span class="tok-kw">and</span> r.exponent == <span class="tok-number">0</span>);</span>
<span class="line" id="L242"></span>
<span class="line" id="L243"> r = frexp128(math.inf(<span class="tok-type">f128</span>));</span>
<span class="line" id="L244"> <span class="tok-kw">try</span> expect(math.isPositiveInf(r.significand) <span class="tok-kw">and</span> r.exponent == <span class="tok-number">0</span>);</span>
<span class="line" id="L245"></span>
<span class="line" id="L246"> r = frexp128(-math.inf(<span class="tok-type">f128</span>));</span>
<span class="line" id="L247"> <span class="tok-kw">try</span> expect(math.isNegativeInf(r.significand) <span class="tok-kw">and</span> r.exponent == <span class="tok-number">0</span>);</span>
<span class="line" id="L248"></span>
<span class="line" id="L249"> r = frexp128(math.nan(<span class="tok-type">f128</span>));</span>
<span class="line" id="L250"> <span class="tok-kw">try</span> expect(math.isNan(r.significand));</span>
<span class="line" id="L251">}</span>
<span class="line" id="L252"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/math/atanh.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>math/atanh.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-comment">// Ported from musl, which is licensed under the MIT license:</span>
</span>
<span class="line" id="L2"><span class="tok-comment">// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT</span>
</span>
<span class="line" id="L3"><span class="tok-comment">//</span>
</span>
<span class="line" id="L4"><span class="tok-comment">// https://git.musl-libc.org/cgit/musl/tree/src/math/atanhf.c</span>
</span>
<span class="line" id="L5"><span class="tok-comment">// https://git.musl-libc.org/cgit/musl/tree/src/math/atanh.c</span>
</span>
<span class="line" id="L6"></span>
<span class="line" id="L7"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../std.zig"</span>);</span>
<span class="line" id="L8"><span class="tok-kw">const</span> math = std.math;</span>
<span class="line" id="L9"><span class="tok-kw">const</span> expect = std.testing.expect;</span>
<span class="line" id="L10"><span class="tok-kw">const</span> maxInt = std.math.maxInt;</span>
<span class="line" id="L11"></span>
<span class="line" id="L12"><span class="tok-comment">/// Returns the hyperbolic arc-tangent of x.</span></span>
<span class="line" id="L13"><span class="tok-comment">///</span></span>
<span class="line" id="L14"><span class="tok-comment">/// Special Cases:</span></span>
<span class="line" id="L15"><span class="tok-comment">/// - atanh(+-1) = +-inf with signal</span></span>
<span class="line" id="L16"><span class="tok-comment">/// - atanh(x) = nan if |x| > 1 with signal</span></span>
<span class="line" id="L17"><span class="tok-comment">/// - atanh(nan) = nan</span></span>
<span class="line" id="L18"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">atanh</span>(x: <span class="tok-kw">anytype</span>) <span class="tok-builtin">@TypeOf</span>(x) {</span>
<span class="line" id="L19"> <span class="tok-kw">const</span> T = <span class="tok-builtin">@TypeOf</span>(x);</span>
<span class="line" id="L20"> <span class="tok-kw">return</span> <span class="tok-kw">switch</span> (T) {</span>
<span class="line" id="L21"> <span class="tok-type">f32</span> => atanh_32(x),</span>
<span class="line" id="L22"> <span class="tok-type">f64</span> => atanh_64(x),</span>
<span class="line" id="L23"> <span class="tok-kw">else</span> => <span class="tok-builtin">@compileError</span>(<span class="tok-str">"atanh not implemented for "</span> ++ <span class="tok-builtin">@typeName</span>(T)),</span>
<span class="line" id="L24"> };</span>
<span class="line" id="L25">}</span>
<span class="line" id="L26"></span>
<span class="line" id="L27"><span class="tok-comment">// atanh(x) = log((1 + x) / (1 - x)) / 2 = log1p(2x / (1 - x)) / 2 ~= x + x^3 / 3 + o(x^5)</span>
</span>
<span class="line" id="L28"><span class="tok-kw">fn</span> <span class="tok-fn">atanh_32</span>(x: <span class="tok-type">f32</span>) <span class="tok-type">f32</span> {</span>
<span class="line" id="L29"> <span class="tok-kw">const</span> u = <span class="tok-builtin">@as</span>(<span class="tok-type">u32</span>, <span class="tok-builtin">@bitCast</span>(x));</span>
<span class="line" id="L30"> <span class="tok-kw">const</span> i = u & <span class="tok-number">0x7FFFFFFF</span>;</span>
<span class="line" id="L31"> <span class="tok-kw">const</span> s = u >> <span class="tok-number">31</span>;</span>
<span class="line" id="L32"></span>
<span class="line" id="L33"> <span class="tok-kw">var</span> y = <span class="tok-builtin">@as</span>(<span class="tok-type">f32</span>, <span class="tok-builtin">@bitCast</span>(i)); <span class="tok-comment">// |x|</span>
</span>
<span class="line" id="L34"></span>
<span class="line" id="L35"> <span class="tok-kw">if</span> (y == <span class="tok-number">1.0</span>) {</span>
<span class="line" id="L36"> <span class="tok-kw">return</span> math.copysign(math.inf(<span class="tok-type">f32</span>), x);</span>
<span class="line" id="L37"> }</span>
<span class="line" id="L38"></span>
<span class="line" id="L39"> <span class="tok-kw">if</span> (u < <span class="tok-number">0x3F800000</span> - (<span class="tok-number">1</span> << <span class="tok-number">23</span>)) {</span>
<span class="line" id="L40"> <span class="tok-kw">if</span> (u < <span class="tok-number">0x3F800000</span> - (<span class="tok-number">32</span> << <span class="tok-number">23</span>)) {</span>
<span class="line" id="L41"> <span class="tok-comment">// underflow</span>
</span>
<span class="line" id="L42"> <span class="tok-kw">if</span> (u < (<span class="tok-number">1</span> << <span class="tok-number">23</span>)) {</span>
<span class="line" id="L43"> math.doNotOptimizeAway(y * y);</span>
<span class="line" id="L44"> }</span>
<span class="line" id="L45"> }</span>
<span class="line" id="L46"> <span class="tok-comment">// |x| < 0.5</span>
</span>
<span class="line" id="L47"> <span class="tok-kw">else</span> {</span>
<span class="line" id="L48"> y = <span class="tok-number">0.5</span> * math.log1p(<span class="tok-number">2</span> * y + <span class="tok-number">2</span> * y * y / (<span class="tok-number">1</span> - y));</span>
<span class="line" id="L49"> }</span>
<span class="line" id="L50"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L51"> y = <span class="tok-number">0.5</span> * math.log1p(<span class="tok-number">2</span> * (y / (<span class="tok-number">1</span> - y)));</span>
<span class="line" id="L52"> }</span>
<span class="line" id="L53"></span>
<span class="line" id="L54"> <span class="tok-kw">return</span> <span class="tok-kw">if</span> (s != <span class="tok-number">0</span>) -y <span class="tok-kw">else</span> y;</span>
<span class="line" id="L55">}</span>
<span class="line" id="L56"></span>
<span class="line" id="L57"><span class="tok-kw">fn</span> <span class="tok-fn">atanh_64</span>(x: <span class="tok-type">f64</span>) <span class="tok-type">f64</span> {</span>
<span class="line" id="L58"> <span class="tok-kw">const</span> u = <span class="tok-builtin">@as</span>(<span class="tok-type">u64</span>, <span class="tok-builtin">@bitCast</span>(x));</span>
<span class="line" id="L59"> <span class="tok-kw">const</span> e = (u >> <span class="tok-number">52</span>) & <span class="tok-number">0x7FF</span>;</span>
<span class="line" id="L60"> <span class="tok-kw">const</span> s = u >> <span class="tok-number">63</span>;</span>
<span class="line" id="L61"></span>
<span class="line" id="L62"> <span class="tok-kw">var</span> y = <span class="tok-builtin">@as</span>(<span class="tok-type">f64</span>, <span class="tok-builtin">@bitCast</span>(u & (maxInt(<span class="tok-type">u64</span>) >> <span class="tok-number">1</span>))); <span class="tok-comment">// |x|</span>
</span>
<span class="line" id="L63"></span>
<span class="line" id="L64"> <span class="tok-kw">if</span> (y == <span class="tok-number">1.0</span>) {</span>
<span class="line" id="L65"> <span class="tok-kw">return</span> math.copysign(math.inf(<span class="tok-type">f64</span>), x);</span>
<span class="line" id="L66"> }</span>
<span class="line" id="L67"></span>
<span class="line" id="L68"> <span class="tok-kw">if</span> (e < <span class="tok-number">0x3FF</span> - <span class="tok-number">1</span>) {</span>
<span class="line" id="L69"> <span class="tok-kw">if</span> (e < <span class="tok-number">0x3FF</span> - <span class="tok-number">32</span>) {</span>
<span class="line" id="L70"> <span class="tok-comment">// underflow</span>
</span>
<span class="line" id="L71"> <span class="tok-kw">if</span> (e == <span class="tok-number">0</span>) {</span>
<span class="line" id="L72"> math.doNotOptimizeAway(<span class="tok-builtin">@as</span>(<span class="tok-type">f32</span>, <span class="tok-builtin">@floatCast</span>(y)));</span>
<span class="line" id="L73"> }</span>
<span class="line" id="L74"> }</span>
<span class="line" id="L75"> <span class="tok-comment">// |x| < 0.5</span>
</span>
<span class="line" id="L76"> <span class="tok-kw">else</span> {</span>
<span class="line" id="L77"> y = <span class="tok-number">0.5</span> * math.log1p(<span class="tok-number">2</span> * y + <span class="tok-number">2</span> * y * y / (<span class="tok-number">1</span> - y));</span>
<span class="line" id="L78"> }</span>
<span class="line" id="L79"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L80"> y = <span class="tok-number">0.5</span> * math.log1p(<span class="tok-number">2</span> * (y / (<span class="tok-number">1</span> - y)));</span>
<span class="line" id="L81"> }</span>
<span class="line" id="L82"></span>
<span class="line" id="L83"> <span class="tok-kw">return</span> <span class="tok-kw">if</span> (s != <span class="tok-number">0</span>) -y <span class="tok-kw">else</span> y;</span>
<span class="line" id="L84">}</span>
<span class="line" id="L85"></span>
<span class="line" id="L86"><span class="tok-kw">test</span> <span class="tok-str">"math.atanh"</span> {</span>
<span class="line" id="L87"> <span class="tok-kw">try</span> expect(atanh(<span class="tok-builtin">@as</span>(<span class="tok-type">f32</span>, <span class="tok-number">0.0</span>)) == atanh_32(<span class="tok-number">0.0</span>));</span>
<span class="line" id="L88"> <span class="tok-kw">try</span> expect(atanh(<span class="tok-builtin">@as</span>(<span class="tok-type">f64</span>, <span class="tok-number">0.0</span>)) == atanh_64(<span class="tok-number">0.0</span>));</span>
<span class="line" id="L89">}</span>
<span class="line" id="L90"></span>
<span class="line" id="L91"><span class="tok-kw">test</span> <span class="tok-str">"math.atanh_32"</span> {</span>
<span class="line" id="L92"> <span class="tok-kw">const</span> epsilon = <span class="tok-number">0.000001</span>;</span>
<span class="line" id="L93"></span>
<span class="line" id="L94"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f32</span>, atanh_32(<span class="tok-number">0.0</span>), <span class="tok-number">0.0</span>, epsilon));</span>
<span class="line" id="L95"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f32</span>, atanh_32(<span class="tok-number">0.2</span>), <span class="tok-number">0.202733</span>, epsilon));</span>
<span class="line" id="L96"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f32</span>, atanh_32(<span class="tok-number">0.8923</span>), <span class="tok-number">1.433099</span>, epsilon));</span>
<span class="line" id="L97">}</span>
<span class="line" id="L98"></span>
<span class="line" id="L99"><span class="tok-kw">test</span> <span class="tok-str">"math.atanh_64"</span> {</span>
<span class="line" id="L100"> <span class="tok-kw">const</span> epsilon = <span class="tok-number">0.000001</span>;</span>
<span class="line" id="L101"></span>
<span class="line" id="L102"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f64</span>, atanh_64(<span class="tok-number">0.0</span>), <span class="tok-number">0.0</span>, epsilon));</span>
<span class="line" id="L103"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f64</span>, atanh_64(<span class="tok-number">0.2</span>), <span class="tok-number">0.202733</span>, epsilon));</span>
<span class="line" id="L104"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f64</span>, atanh_64(<span class="tok-number">0.8923</span>), <span class="tok-number">1.433099</span>, epsilon));</span>
<span class="line" id="L105">}</span>
<span class="line" id="L106"></span>
<span class="line" id="L107"><span class="tok-kw">test</span> <span class="tok-str">"math.atanh32.special"</span> {</span>
<span class="line" id="L108"> <span class="tok-kw">try</span> expect(math.isPositiveInf(atanh_32(<span class="tok-number">1</span>)));</span>
<span class="line" id="L109"> <span class="tok-kw">try</span> expect(math.isNegativeInf(atanh_32(-<span class="tok-number">1</span>)));</span>
<span class="line" id="L110"> <span class="tok-kw">try</span> expect(math.isSignalNan(atanh_32(<span class="tok-number">1.5</span>)));</span>
<span class="line" id="L111"> <span class="tok-kw">try</span> expect(math.isSignalNan(atanh_32(-<span class="tok-number">1.5</span>)));</span>
<span class="line" id="L112"> <span class="tok-kw">try</span> expect(math.isNan(atanh_32(math.nan(<span class="tok-type">f32</span>))));</span>
<span class="line" id="L113">}</span>
<span class="line" id="L114"></span>
<span class="line" id="L115"><span class="tok-kw">test</span> <span class="tok-str">"math.atanh64.special"</span> {</span>
<span class="line" id="L116"> <span class="tok-kw">try</span> expect(math.isPositiveInf(atanh_64(<span class="tok-number">1</span>)));</span>
<span class="line" id="L117"> <span class="tok-kw">try</span> expect(math.isNegativeInf(atanh_64(-<span class="tok-number">1</span>)));</span>
<span class="line" id="L118"> <span class="tok-kw">try</span> expect(math.isSignalNan(atanh_64(<span class="tok-number">1.5</span>)));</span>
<span class="line" id="L119"> <span class="tok-kw">try</span> expect(math.isSignalNan(atanh_64(-<span class="tok-number">1.5</span>)));</span>
<span class="line" id="L120"> <span class="tok-kw">try</span> expect(math.isNan(atanh_64(math.nan(<span class="tok-type">f64</span>))));</span>
<span class="line" id="L121">}</span>
<span class="line" id="L122"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/math/sinh.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>math/sinh.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-comment">// Ported from musl, which is licensed under the MIT license:</span>
</span>
<span class="line" id="L2"><span class="tok-comment">// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT</span>
</span>
<span class="line" id="L3"><span class="tok-comment">//</span>
</span>
<span class="line" id="L4"><span class="tok-comment">// https://git.musl-libc.org/cgit/musl/tree/src/math/sinhf.c</span>
</span>
<span class="line" id="L5"><span class="tok-comment">// https://git.musl-libc.org/cgit/musl/tree/src/math/sinh.c</span>
</span>
<span class="line" id="L6"></span>
<span class="line" id="L7"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../std.zig"</span>);</span>
<span class="line" id="L8"><span class="tok-kw">const</span> math = std.math;</span>
<span class="line" id="L9"><span class="tok-kw">const</span> expect = std.testing.expect;</span>
<span class="line" id="L10"><span class="tok-kw">const</span> expo2 = <span class="tok-builtin">@import</span>(<span class="tok-str">"expo2.zig"</span>).expo2;</span>
<span class="line" id="L11"><span class="tok-kw">const</span> maxInt = std.math.maxInt;</span>
<span class="line" id="L12"></span>
<span class="line" id="L13"><span class="tok-comment">/// Returns the hyperbolic sine of x.</span></span>
<span class="line" id="L14"><span class="tok-comment">///</span></span>
<span class="line" id="L15"><span class="tok-comment">/// Special Cases:</span></span>
<span class="line" id="L16"><span class="tok-comment">/// - sinh(+-0) = +-0</span></span>
<span class="line" id="L17"><span class="tok-comment">/// - sinh(+-inf) = +-inf</span></span>
<span class="line" id="L18"><span class="tok-comment">/// - sinh(nan) = nan</span></span>
<span class="line" id="L19"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">sinh</span>(x: <span class="tok-kw">anytype</span>) <span class="tok-builtin">@TypeOf</span>(x) {</span>
<span class="line" id="L20"> <span class="tok-kw">const</span> T = <span class="tok-builtin">@TypeOf</span>(x);</span>
<span class="line" id="L21"> <span class="tok-kw">return</span> <span class="tok-kw">switch</span> (T) {</span>
<span class="line" id="L22"> <span class="tok-type">f32</span> => sinh32(x),</span>
<span class="line" id="L23"> <span class="tok-type">f64</span> => sinh64(x),</span>
<span class="line" id="L24"> <span class="tok-kw">else</span> => <span class="tok-builtin">@compileError</span>(<span class="tok-str">"sinh not implemented for "</span> ++ <span class="tok-builtin">@typeName</span>(T)),</span>
<span class="line" id="L25"> };</span>
<span class="line" id="L26">}</span>
<span class="line" id="L27"></span>
<span class="line" id="L28"><span class="tok-comment">// sinh(x) = (exp(x) - 1 / exp(x)) / 2</span>
</span>
<span class="line" id="L29"><span class="tok-comment">// = (exp(x) - 1 + (exp(x) - 1) / exp(x)) / 2</span>
</span>
<span class="line" id="L30"><span class="tok-comment">// = x + x^3 / 6 + o(x^5)</span>
</span>
<span class="line" id="L31"><span class="tok-kw">fn</span> <span class="tok-fn">sinh32</span>(x: <span class="tok-type">f32</span>) <span class="tok-type">f32</span> {</span>
<span class="line" id="L32"> <span class="tok-kw">const</span> u = <span class="tok-builtin">@as</span>(<span class="tok-type">u32</span>, <span class="tok-builtin">@bitCast</span>(x));</span>
<span class="line" id="L33"> <span class="tok-kw">const</span> ux = u & <span class="tok-number">0x7FFFFFFF</span>;</span>
<span class="line" id="L34"> <span class="tok-kw">const</span> ax = <span class="tok-builtin">@as</span>(<span class="tok-type">f32</span>, <span class="tok-builtin">@bitCast</span>(ux));</span>
<span class="line" id="L35"></span>
<span class="line" id="L36"> <span class="tok-kw">if</span> (x == <span class="tok-number">0.0</span> <span class="tok-kw">or</span> math.isNan(x)) {</span>
<span class="line" id="L37"> <span class="tok-kw">return</span> x;</span>
<span class="line" id="L38"> }</span>
<span class="line" id="L39"></span>
<span class="line" id="L40"> <span class="tok-kw">var</span> h: <span class="tok-type">f32</span> = <span class="tok-number">0.5</span>;</span>
<span class="line" id="L41"> <span class="tok-kw">if</span> (u >> <span class="tok-number">31</span> != <span class="tok-number">0</span>) {</span>
<span class="line" id="L42"> h = -h;</span>
<span class="line" id="L43"> }</span>
<span class="line" id="L44"></span>
<span class="line" id="L45"> <span class="tok-comment">// |x| < log(FLT_MAX)</span>
</span>
<span class="line" id="L46"> <span class="tok-kw">if</span> (ux < <span class="tok-number">0x42B17217</span>) {</span>
<span class="line" id="L47"> <span class="tok-kw">const</span> t = math.expm1(ax);</span>
<span class="line" id="L48"> <span class="tok-kw">if</span> (ux < <span class="tok-number">0x3F800000</span>) {</span>
<span class="line" id="L49"> <span class="tok-kw">if</span> (ux < <span class="tok-number">0x3F800000</span> - (<span class="tok-number">12</span> << <span class="tok-number">23</span>)) {</span>
<span class="line" id="L50"> <span class="tok-kw">return</span> x;</span>
<span class="line" id="L51"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L52"> <span class="tok-kw">return</span> h * (<span class="tok-number">2</span> * t - t * t / (t + <span class="tok-number">1</span>));</span>
<span class="line" id="L53"> }</span>
<span class="line" id="L54"> }</span>
<span class="line" id="L55"> <span class="tok-kw">return</span> h * (t + t / (t + <span class="tok-number">1</span>));</span>
<span class="line" id="L56"> }</span>
<span class="line" id="L57"></span>
<span class="line" id="L58"> <span class="tok-comment">// |x| > log(FLT_MAX) or nan</span>
</span>
<span class="line" id="L59"> <span class="tok-kw">return</span> <span class="tok-number">2</span> * h * expo2(ax);</span>
<span class="line" id="L60">}</span>
<span class="line" id="L61"></span>
<span class="line" id="L62"><span class="tok-kw">fn</span> <span class="tok-fn">sinh64</span>(x: <span class="tok-type">f64</span>) <span class="tok-type">f64</span> {</span>
<span class="line" id="L63"> <span class="tok-kw">const</span> u = <span class="tok-builtin">@as</span>(<span class="tok-type">u64</span>, <span class="tok-builtin">@bitCast</span>(x));</span>
<span class="line" id="L64"> <span class="tok-kw">const</span> w = <span class="tok-builtin">@as</span>(<span class="tok-type">u32</span>, <span class="tok-builtin">@intCast</span>(u >> <span class="tok-number">32</span>)) & (maxInt(<span class="tok-type">u32</span>) >> <span class="tok-number">1</span>);</span>
<span class="line" id="L65"> <span class="tok-kw">const</span> ax = <span class="tok-builtin">@as</span>(<span class="tok-type">f64</span>, <span class="tok-builtin">@bitCast</span>(u & (maxInt(<span class="tok-type">u64</span>) >> <span class="tok-number">1</span>)));</span>
<span class="line" id="L66"></span>
<span class="line" id="L67"> <span class="tok-kw">if</span> (x == <span class="tok-number">0.0</span> <span class="tok-kw">or</span> math.isNan(x)) {</span>
<span class="line" id="L68"> <span class="tok-kw">return</span> x;</span>
<span class="line" id="L69"> }</span>
<span class="line" id="L70"></span>
<span class="line" id="L71"> <span class="tok-kw">var</span> h: <span class="tok-type">f32</span> = <span class="tok-number">0.5</span>;</span>
<span class="line" id="L72"> <span class="tok-kw">if</span> (u >> <span class="tok-number">63</span> != <span class="tok-number">0</span>) {</span>
<span class="line" id="L73"> h = -h;</span>
<span class="line" id="L74"> }</span>
<span class="line" id="L75"></span>
<span class="line" id="L76"> <span class="tok-comment">// |x| < log(FLT_MAX)</span>
</span>
<span class="line" id="L77"> <span class="tok-kw">if</span> (w < <span class="tok-number">0x40862E42</span>) {</span>
<span class="line" id="L78"> <span class="tok-kw">const</span> t = math.expm1(ax);</span>
<span class="line" id="L79"> <span class="tok-kw">if</span> (w < <span class="tok-number">0x3FF00000</span>) {</span>
<span class="line" id="L80"> <span class="tok-kw">if</span> (w < <span class="tok-number">0x3FF00000</span> - (<span class="tok-number">26</span> << <span class="tok-number">20</span>)) {</span>
<span class="line" id="L81"> <span class="tok-kw">return</span> x;</span>
<span class="line" id="L82"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L83"> <span class="tok-kw">return</span> h * (<span class="tok-number">2</span> * t - t * t / (t + <span class="tok-number">1</span>));</span>
<span class="line" id="L84"> }</span>
<span class="line" id="L85"> }</span>
<span class="line" id="L86"> <span class="tok-comment">// NOTE: |x| > log(0x1p26) + eps could be h * exp(x)</span>
</span>
<span class="line" id="L87"> <span class="tok-kw">return</span> h * (t + t / (t + <span class="tok-number">1</span>));</span>
<span class="line" id="L88"> }</span>
<span class="line" id="L89"></span>
<span class="line" id="L90"> <span class="tok-comment">// |x| > log(DBL_MAX) or nan</span>
</span>
<span class="line" id="L91"> <span class="tok-kw">return</span> <span class="tok-number">2</span> * h * expo2(ax);</span>
<span class="line" id="L92">}</span>
<span class="line" id="L93"></span>
<span class="line" id="L94"><span class="tok-kw">test</span> <span class="tok-str">"math.sinh"</span> {</span>
<span class="line" id="L95"> <span class="tok-kw">try</span> expect(sinh(<span class="tok-builtin">@as</span>(<span class="tok-type">f32</span>, <span class="tok-number">1.5</span>)) == sinh32(<span class="tok-number">1.5</span>));</span>
<span class="line" id="L96"> <span class="tok-kw">try</span> expect(sinh(<span class="tok-builtin">@as</span>(<span class="tok-type">f64</span>, <span class="tok-number">1.5</span>)) == sinh64(<span class="tok-number">1.5</span>));</span>
<span class="line" id="L97">}</span>
<span class="line" id="L98"></span>
<span class="line" id="L99"><span class="tok-kw">test</span> <span class="tok-str">"math.sinh32"</span> {</span>
<span class="line" id="L100"> <span class="tok-kw">const</span> epsilon = <span class="tok-number">0.000001</span>;</span>
<span class="line" id="L101"></span>
<span class="line" id="L102"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f32</span>, sinh32(<span class="tok-number">0.0</span>), <span class="tok-number">0.0</span>, epsilon));</span>
<span class="line" id="L103"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f32</span>, sinh32(<span class="tok-number">0.2</span>), <span class="tok-number">0.201336</span>, epsilon));</span>
<span class="line" id="L104"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f32</span>, sinh32(<span class="tok-number">0.8923</span>), <span class="tok-number">1.015512</span>, epsilon));</span>
<span class="line" id="L105"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f32</span>, sinh32(<span class="tok-number">1.5</span>), <span class="tok-number">2.129279</span>, epsilon));</span>
<span class="line" id="L106"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f32</span>, sinh32(-<span class="tok-number">0.0</span>), -<span class="tok-number">0.0</span>, epsilon));</span>
<span class="line" id="L107"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f32</span>, sinh32(-<span class="tok-number">0.2</span>), -<span class="tok-number">0.201336</span>, epsilon));</span>
<span class="line" id="L108"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f32</span>, sinh32(-<span class="tok-number">0.8923</span>), -<span class="tok-number">1.015512</span>, epsilon));</span>
<span class="line" id="L109"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f32</span>, sinh32(-<span class="tok-number">1.5</span>), -<span class="tok-number">2.129279</span>, epsilon));</span>
<span class="line" id="L110">}</span>
<span class="line" id="L111"></span>
<span class="line" id="L112"><span class="tok-kw">test</span> <span class="tok-str">"math.sinh64"</span> {</span>
<span class="line" id="L113"> <span class="tok-kw">const</span> epsilon = <span class="tok-number">0.000001</span>;</span>
<span class="line" id="L114"></span>
<span class="line" id="L115"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f64</span>, sinh64(<span class="tok-number">0.0</span>), <span class="tok-number">0.0</span>, epsilon));</span>
<span class="line" id="L116"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f64</span>, sinh64(<span class="tok-number">0.2</span>), <span class="tok-number">0.201336</span>, epsilon));</span>
<span class="line" id="L117"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f64</span>, sinh64(<span class="tok-number">0.8923</span>), <span class="tok-number">1.015512</span>, epsilon));</span>
<span class="line" id="L118"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f64</span>, sinh64(<span class="tok-number">1.5</span>), <span class="tok-number">2.129279</span>, epsilon));</span>
<span class="line" id="L119"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f64</span>, sinh64(-<span class="tok-number">0.0</span>), -<span class="tok-number">0.0</span>, epsilon));</span>
<span class="line" id="L120"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f64</span>, sinh64(-<span class="tok-number">0.2</span>), -<span class="tok-number">0.201336</span>, epsilon));</span>
<span class="line" id="L121"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f64</span>, sinh64(-<span class="tok-number">0.8923</span>), -<span class="tok-number">1.015512</span>, epsilon));</span>
<span class="line" id="L122"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f64</span>, sinh64(-<span class="tok-number">1.5</span>), -<span class="tok-number">2.129279</span>, epsilon));</span>
<span class="line" id="L123">}</span>
<span class="line" id="L124"></span>
<span class="line" id="L125"><span class="tok-kw">test</span> <span class="tok-str">"math.sinh32.special"</span> {</span>
<span class="line" id="L126"> <span class="tok-kw">try</span> expect(sinh32(<span class="tok-number">0.0</span>) == <span class="tok-number">0.0</span>);</span>
<span class="line" id="L127"> <span class="tok-kw">try</span> expect(sinh32(-<span class="tok-number">0.0</span>) == -<span class="tok-number">0.0</span>);</span>
<span class="line" id="L128"> <span class="tok-kw">try</span> expect(math.isPositiveInf(sinh32(math.inf(<span class="tok-type">f32</span>))));</span>
<span class="line" id="L129"> <span class="tok-kw">try</span> expect(math.isNegativeInf(sinh32(-math.inf(<span class="tok-type">f32</span>))));</span>
<span class="line" id="L130"> <span class="tok-kw">try</span> expect(math.isNan(sinh32(math.nan(<span class="tok-type">f32</span>))));</span>
<span class="line" id="L131">}</span>
<span class="line" id="L132"></span>
<span class="line" id="L133"><span class="tok-kw">test</span> <span class="tok-str">"math.sinh64.special"</span> {</span>
<span class="line" id="L134"> <span class="tok-kw">try</span> expect(sinh64(<span class="tok-number">0.0</span>) == <span class="tok-number">0.0</span>);</span>
<span class="line" id="L135"> <span class="tok-kw">try</span> expect(sinh64(-<span class="tok-number">0.0</span>) == -<span class="tok-number">0.0</span>);</span>
<span class="line" id="L136"> <span class="tok-kw">try</span> expect(math.isPositiveInf(sinh64(math.inf(<span class="tok-type">f64</span>))));</span>
<span class="line" id="L137"> <span class="tok-kw">try</span> expect(math.isNegativeInf(sinh64(-math.inf(<span class="tok-type">f64</span>))));</span>
<span class="line" id="L138"> <span class="tok-kw">try</span> expect(math.isNan(sinh64(math.nan(<span class="tok-type">f64</span>))));</span>
<span class="line" id="L139">}</span>
<span class="line" id="L140"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/math/expm1.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>math/expm1.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-comment">// Ported from musl, which is licensed under the MIT license:</span>
</span>
<span class="line" id="L2"><span class="tok-comment">// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT</span>
</span>
<span class="line" id="L3"><span class="tok-comment">//</span>
</span>
<span class="line" id="L4"><span class="tok-comment">// https://git.musl-libc.org/cgit/musl/tree/src/math/expmf.c</span>
</span>
<span class="line" id="L5"><span class="tok-comment">// https://git.musl-libc.org/cgit/musl/tree/src/math/expm.c</span>
</span>
<span class="line" id="L6"></span>
<span class="line" id="L7"><span class="tok-comment">// TODO: Updated recently.</span>
</span>
<span class="line" id="L8"></span>
<span class="line" id="L9"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../std.zig"</span>);</span>
<span class="line" id="L10"><span class="tok-kw">const</span> math = std.math;</span>
<span class="line" id="L11"><span class="tok-kw">const</span> expect = std.testing.expect;</span>
<span class="line" id="L12"></span>
<span class="line" id="L13"><span class="tok-comment">/// Returns e raised to the power of x, minus 1 (e^x - 1). This is more accurate than exp(e, x) - 1</span></span>
<span class="line" id="L14"><span class="tok-comment">/// when x is near 0.</span></span>
<span class="line" id="L15"><span class="tok-comment">///</span></span>
<span class="line" id="L16"><span class="tok-comment">/// Special Cases:</span></span>
<span class="line" id="L17"><span class="tok-comment">/// - expm1(+inf) = +inf</span></span>
<span class="line" id="L18"><span class="tok-comment">/// - expm1(-inf) = -1</span></span>
<span class="line" id="L19"><span class="tok-comment">/// - expm1(nan) = nan</span></span>
<span class="line" id="L20"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">expm1</span>(x: <span class="tok-kw">anytype</span>) <span class="tok-builtin">@TypeOf</span>(x) {</span>
<span class="line" id="L21"> <span class="tok-kw">const</span> T = <span class="tok-builtin">@TypeOf</span>(x);</span>
<span class="line" id="L22"> <span class="tok-kw">return</span> <span class="tok-kw">switch</span> (T) {</span>
<span class="line" id="L23"> <span class="tok-type">f32</span> => expm1_32(x),</span>
<span class="line" id="L24"> <span class="tok-type">f64</span> => expm1_64(x),</span>
<span class="line" id="L25"> <span class="tok-kw">else</span> => <span class="tok-builtin">@compileError</span>(<span class="tok-str">"exp1m not implemented for "</span> ++ <span class="tok-builtin">@typeName</span>(T)),</span>
<span class="line" id="L26"> };</span>
<span class="line" id="L27">}</span>
<span class="line" id="L28"></span>
<span class="line" id="L29"><span class="tok-kw">fn</span> <span class="tok-fn">expm1_32</span>(x_: <span class="tok-type">f32</span>) <span class="tok-type">f32</span> {</span>
<span class="line" id="L30"> <span class="tok-kw">if</span> (math.isNan(x_))</span>
<span class="line" id="L31"> <span class="tok-kw">return</span> math.nan(<span class="tok-type">f32</span>);</span>
<span class="line" id="L32"></span>
<span class="line" id="L33"> <span class="tok-kw">const</span> o_threshold: <span class="tok-type">f32</span> = <span class="tok-number">8.8721679688e+01</span>;</span>
<span class="line" id="L34"> <span class="tok-kw">const</span> ln2_hi: <span class="tok-type">f32</span> = <span class="tok-number">6.9313812256e-01</span>;</span>
<span class="line" id="L35"> <span class="tok-kw">const</span> ln2_lo: <span class="tok-type">f32</span> = <span class="tok-number">9.0580006145e-06</span>;</span>
<span class="line" id="L36"> <span class="tok-kw">const</span> invln2: <span class="tok-type">f32</span> = <span class="tok-number">1.4426950216e+00</span>;</span>
<span class="line" id="L37"> <span class="tok-kw">const</span> Q1: <span class="tok-type">f32</span> = -<span class="tok-number">3.3333212137e-2</span>;</span>
<span class="line" id="L38"> <span class="tok-kw">const</span> Q2: <span class="tok-type">f32</span> = <span class="tok-number">1.5807170421e-3</span>;</span>
<span class="line" id="L39"></span>
<span class="line" id="L40"> <span class="tok-kw">var</span> x = x_;</span>
<span class="line" id="L41"> <span class="tok-kw">const</span> ux = <span class="tok-builtin">@as</span>(<span class="tok-type">u32</span>, <span class="tok-builtin">@bitCast</span>(x));</span>
<span class="line" id="L42"> <span class="tok-kw">const</span> hx = ux & <span class="tok-number">0x7FFFFFFF</span>;</span>
<span class="line" id="L43"> <span class="tok-kw">const</span> sign = hx >> <span class="tok-number">31</span>;</span>
<span class="line" id="L44"></span>
<span class="line" id="L45"> <span class="tok-comment">// TODO: Shouldn't need this check explicitly.</span>
</span>
<span class="line" id="L46"> <span class="tok-kw">if</span> (math.isNegativeInf(x)) {</span>
<span class="line" id="L47"> <span class="tok-kw">return</span> -<span class="tok-number">1.0</span>;</span>
<span class="line" id="L48"> }</span>
<span class="line" id="L49"></span>
<span class="line" id="L50"> <span class="tok-comment">// |x| >= 27 * ln2</span>
</span>
<span class="line" id="L51"> <span class="tok-kw">if</span> (hx >= <span class="tok-number">0x4195B844</span>) {</span>
<span class="line" id="L52"> <span class="tok-comment">// nan</span>
</span>
<span class="line" id="L53"> <span class="tok-kw">if</span> (hx > <span class="tok-number">0x7F800000</span>) {</span>
<span class="line" id="L54"> <span class="tok-kw">return</span> x;</span>
<span class="line" id="L55"> }</span>
<span class="line" id="L56"> <span class="tok-kw">if</span> (sign != <span class="tok-number">0</span>) {</span>
<span class="line" id="L57"> <span class="tok-kw">return</span> -<span class="tok-number">1</span>;</span>
<span class="line" id="L58"> }</span>
<span class="line" id="L59"> <span class="tok-kw">if</span> (x > o_threshold) {</span>
<span class="line" id="L60"> x *= <span class="tok-number">0x1.0p127</span>;</span>
<span class="line" id="L61"> <span class="tok-kw">return</span> x;</span>
<span class="line" id="L62"> }</span>
<span class="line" id="L63"> }</span>
<span class="line" id="L64"></span>
<span class="line" id="L65"> <span class="tok-kw">var</span> hi: <span class="tok-type">f32</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L66"> <span class="tok-kw">var</span> lo: <span class="tok-type">f32</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L67"> <span class="tok-kw">var</span> c: <span class="tok-type">f32</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L68"> <span class="tok-kw">var</span> k: <span class="tok-type">i32</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L69"></span>
<span class="line" id="L70"> <span class="tok-comment">// |x| > 0.5 * ln2</span>
</span>
<span class="line" id="L71"> <span class="tok-kw">if</span> (hx > <span class="tok-number">0x3EB17218</span>) {</span>
<span class="line" id="L72"> <span class="tok-comment">// |x| < 1.5 * ln2</span>
</span>
<span class="line" id="L73"> <span class="tok-kw">if</span> (hx < <span class="tok-number">0x3F851592</span>) {</span>
<span class="line" id="L74"> <span class="tok-kw">if</span> (sign == <span class="tok-number">0</span>) {</span>
<span class="line" id="L75"> hi = x - ln2_hi;</span>
<span class="line" id="L76"> lo = ln2_lo;</span>
<span class="line" id="L77"> k = <span class="tok-number">1</span>;</span>
<span class="line" id="L78"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L79"> hi = x + ln2_hi;</span>
<span class="line" id="L80"> lo = -ln2_lo;</span>
<span class="line" id="L81"> k = -<span class="tok-number">1</span>;</span>
<span class="line" id="L82"> }</span>
<span class="line" id="L83"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L84"> <span class="tok-kw">var</span> kf = invln2 * x;</span>
<span class="line" id="L85"> <span class="tok-kw">if</span> (sign != <span class="tok-number">0</span>) {</span>
<span class="line" id="L86"> kf -= <span class="tok-number">0.5</span>;</span>
<span class="line" id="L87"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L88"> kf += <span class="tok-number">0.5</span>;</span>
<span class="line" id="L89"> }</span>
<span class="line" id="L90"></span>
<span class="line" id="L91"> k = <span class="tok-builtin">@as</span>(<span class="tok-type">i32</span>, <span class="tok-builtin">@intFromFloat</span>(kf));</span>
<span class="line" id="L92"> <span class="tok-kw">const</span> t = <span class="tok-builtin">@as</span>(<span class="tok-type">f32</span>, <span class="tok-builtin">@floatFromInt</span>(k));</span>
<span class="line" id="L93"> hi = x - t * ln2_hi;</span>
<span class="line" id="L94"> lo = t * ln2_lo;</span>
<span class="line" id="L95"> }</span>
<span class="line" id="L96"></span>
<span class="line" id="L97"> x = hi - lo;</span>
<span class="line" id="L98"> c = (hi - x) - lo;</span>
<span class="line" id="L99"> }</span>
<span class="line" id="L100"> <span class="tok-comment">// |x| < 2^(-25)</span>
</span>
<span class="line" id="L101"> <span class="tok-kw">else</span> <span class="tok-kw">if</span> (hx < <span class="tok-number">0x33000000</span>) {</span>
<span class="line" id="L102"> <span class="tok-kw">if</span> (hx < <span class="tok-number">0x00800000</span>) {</span>
<span class="line" id="L103"> math.doNotOptimizeAway(x * x);</span>
<span class="line" id="L104"> }</span>
<span class="line" id="L105"> <span class="tok-kw">return</span> x;</span>
<span class="line" id="L106"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L107"> k = <span class="tok-number">0</span>;</span>
<span class="line" id="L108"> }</span>
<span class="line" id="L109"></span>
<span class="line" id="L110"> <span class="tok-kw">const</span> hfx = <span class="tok-number">0.5</span> * x;</span>
<span class="line" id="L111"> <span class="tok-kw">const</span> hxs = x * hfx;</span>
<span class="line" id="L112"> <span class="tok-kw">const</span> r1 = <span class="tok-number">1.0</span> + hxs * (Q1 + hxs * Q2);</span>
<span class="line" id="L113"> <span class="tok-kw">const</span> t = <span class="tok-number">3.0</span> - r1 * hfx;</span>
<span class="line" id="L114"> <span class="tok-kw">var</span> e = hxs * ((r1 - t) / (<span class="tok-number">6.0</span> - x * t));</span>
<span class="line" id="L115"></span>
<span class="line" id="L116"> <span class="tok-comment">// c is 0</span>
</span>
<span class="line" id="L117"> <span class="tok-kw">if</span> (k == <span class="tok-number">0</span>) {</span>
<span class="line" id="L118"> <span class="tok-kw">return</span> x - (x * e - hxs);</span>
<span class="line" id="L119"> }</span>
<span class="line" id="L120"></span>
<span class="line" id="L121"> e = x * (e - c) - c;</span>
<span class="line" id="L122"> e -= hxs;</span>
<span class="line" id="L123"></span>
<span class="line" id="L124"> <span class="tok-comment">// exp(x) ~ 2^k (x_reduced - e + 1)</span>
</span>
<span class="line" id="L125"> <span class="tok-kw">if</span> (k == -<span class="tok-number">1</span>) {</span>
<span class="line" id="L126"> <span class="tok-kw">return</span> <span class="tok-number">0.5</span> * (x - e) - <span class="tok-number">0.5</span>;</span>
<span class="line" id="L127"> }</span>
<span class="line" id="L128"> <span class="tok-kw">if</span> (k == <span class="tok-number">1</span>) {</span>
<span class="line" id="L129"> <span class="tok-kw">if</span> (x < -<span class="tok-number">0.25</span>) {</span>
<span class="line" id="L130"> <span class="tok-kw">return</span> -<span class="tok-number">2.0</span> * (e - (x + <span class="tok-number">0.5</span>));</span>
<span class="line" id="L131"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L132"> <span class="tok-kw">return</span> <span class="tok-number">1.0</span> + <span class="tok-number">2.0</span> * (x - e);</span>
<span class="line" id="L133"> }</span>
<span class="line" id="L134"> }</span>
<span class="line" id="L135"></span>
<span class="line" id="L136"> <span class="tok-kw">const</span> twopk = <span class="tok-builtin">@as</span>(<span class="tok-type">f32</span>, <span class="tok-builtin">@bitCast</span>(<span class="tok-builtin">@as</span>(<span class="tok-type">u32</span>, <span class="tok-builtin">@intCast</span>((<span class="tok-number">0x7F</span> +% k) << <span class="tok-number">23</span>))));</span>
<span class="line" id="L137"></span>
<span class="line" id="L138"> <span class="tok-kw">if</span> (k < <span class="tok-number">0</span> <span class="tok-kw">or</span> k > <span class="tok-number">56</span>) {</span>
<span class="line" id="L139"> <span class="tok-kw">var</span> y = x - e + <span class="tok-number">1.0</span>;</span>
<span class="line" id="L140"> <span class="tok-kw">if</span> (k == <span class="tok-number">128</span>) {</span>
<span class="line" id="L141"> y = y * <span class="tok-number">2.0</span> * <span class="tok-number">0x1.0p127</span>;</span>
<span class="line" id="L142"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L143"> y = y * twopk;</span>
<span class="line" id="L144"> }</span>
<span class="line" id="L145"></span>
<span class="line" id="L146"> <span class="tok-kw">return</span> y - <span class="tok-number">1.0</span>;</span>
<span class="line" id="L147"> }</span>
<span class="line" id="L148"></span>
<span class="line" id="L149"> <span class="tok-kw">const</span> uf = <span class="tok-builtin">@as</span>(<span class="tok-type">f32</span>, <span class="tok-builtin">@bitCast</span>(<span class="tok-builtin">@as</span>(<span class="tok-type">u32</span>, <span class="tok-builtin">@intCast</span>(<span class="tok-number">0x7F</span> -% k)) << <span class="tok-number">23</span>));</span>
<span class="line" id="L150"> <span class="tok-kw">if</span> (k < <span class="tok-number">23</span>) {</span>
<span class="line" id="L151"> <span class="tok-kw">return</span> (x - e + (<span class="tok-number">1</span> - uf)) * twopk;</span>
<span class="line" id="L152"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L153"> <span class="tok-kw">return</span> (x - (e + uf) + <span class="tok-number">1</span>) * twopk;</span>
<span class="line" id="L154"> }</span>
<span class="line" id="L155">}</span>
<span class="line" id="L156"></span>
<span class="line" id="L157"><span class="tok-kw">fn</span> <span class="tok-fn">expm1_64</span>(x_: <span class="tok-type">f64</span>) <span class="tok-type">f64</span> {</span>
<span class="line" id="L158"> <span class="tok-kw">if</span> (math.isNan(x_))</span>
<span class="line" id="L159"> <span class="tok-kw">return</span> math.nan(<span class="tok-type">f64</span>);</span>
<span class="line" id="L160"></span>
<span class="line" id="L161"> <span class="tok-kw">const</span> o_threshold: <span class="tok-type">f64</span> = <span class="tok-number">7.09782712893383973096e+02</span>;</span>
<span class="line" id="L162"> <span class="tok-kw">const</span> ln2_hi: <span class="tok-type">f64</span> = <span class="tok-number">6.93147180369123816490e-01</span>;</span>
<span class="line" id="L163"> <span class="tok-kw">const</span> ln2_lo: <span class="tok-type">f64</span> = <span class="tok-number">1.90821492927058770002e-10</span>;</span>
<span class="line" id="L164"> <span class="tok-kw">const</span> invln2: <span class="tok-type">f64</span> = <span class="tok-number">1.44269504088896338700e+00</span>;</span>
<span class="line" id="L165"> <span class="tok-kw">const</span> Q1: <span class="tok-type">f64</span> = -<span class="tok-number">3.33333333333331316428e-02</span>;</span>
<span class="line" id="L166"> <span class="tok-kw">const</span> Q2: <span class="tok-type">f64</span> = <span class="tok-number">1.58730158725481460165e-03</span>;</span>
<span class="line" id="L167"> <span class="tok-kw">const</span> Q3: <span class="tok-type">f64</span> = -<span class="tok-number">7.93650757867487942473e-05</span>;</span>
<span class="line" id="L168"> <span class="tok-kw">const</span> Q4: <span class="tok-type">f64</span> = <span class="tok-number">4.00821782732936239552e-06</span>;</span>
<span class="line" id="L169"> <span class="tok-kw">const</span> Q5: <span class="tok-type">f64</span> = -<span class="tok-number">2.01099218183624371326e-07</span>;</span>
<span class="line" id="L170"></span>
<span class="line" id="L171"> <span class="tok-kw">var</span> x = x_;</span>
<span class="line" id="L172"> <span class="tok-kw">const</span> ux = <span class="tok-builtin">@as</span>(<span class="tok-type">u64</span>, <span class="tok-builtin">@bitCast</span>(x));</span>
<span class="line" id="L173"> <span class="tok-kw">const</span> hx = <span class="tok-builtin">@as</span>(<span class="tok-type">u32</span>, <span class="tok-builtin">@intCast</span>(ux >> <span class="tok-number">32</span>)) & <span class="tok-number">0x7FFFFFFF</span>;</span>
<span class="line" id="L174"> <span class="tok-kw">const</span> sign = ux >> <span class="tok-number">63</span>;</span>
<span class="line" id="L175"></span>
<span class="line" id="L176"> <span class="tok-kw">if</span> (math.isNegativeInf(x)) {</span>
<span class="line" id="L177"> <span class="tok-kw">return</span> -<span class="tok-number">1.0</span>;</span>
<span class="line" id="L178"> }</span>
<span class="line" id="L179"></span>
<span class="line" id="L180"> <span class="tok-comment">// |x| >= 56 * ln2</span>
</span>
<span class="line" id="L181"> <span class="tok-kw">if</span> (hx >= <span class="tok-number">0x4043687A</span>) {</span>
<span class="line" id="L182"> <span class="tok-comment">// exp1md(nan) = nan</span>
</span>
<span class="line" id="L183"> <span class="tok-kw">if</span> (hx > <span class="tok-number">0x7FF00000</span>) {</span>
<span class="line" id="L184"> <span class="tok-kw">return</span> x;</span>
<span class="line" id="L185"> }</span>
<span class="line" id="L186"> <span class="tok-comment">// exp1md(-ve) = -1</span>
</span>
<span class="line" id="L187"> <span class="tok-kw">if</span> (sign != <span class="tok-number">0</span>) {</span>
<span class="line" id="L188"> <span class="tok-kw">return</span> -<span class="tok-number">1</span>;</span>
<span class="line" id="L189"> }</span>
<span class="line" id="L190"> <span class="tok-kw">if</span> (x > o_threshold) {</span>
<span class="line" id="L191"> math.raiseOverflow();</span>
<span class="line" id="L192"> <span class="tok-kw">return</span> math.inf(<span class="tok-type">f64</span>);</span>
<span class="line" id="L193"> }</span>
<span class="line" id="L194"> }</span>
<span class="line" id="L195"></span>
<span class="line" id="L196"> <span class="tok-kw">var</span> hi: <span class="tok-type">f64</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L197"> <span class="tok-kw">var</span> lo: <span class="tok-type">f64</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L198"> <span class="tok-kw">var</span> c: <span class="tok-type">f64</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L199"> <span class="tok-kw">var</span> k: <span class="tok-type">i32</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L200"></span>
<span class="line" id="L201"> <span class="tok-comment">// |x| > 0.5 * ln2</span>
</span>
<span class="line" id="L202"> <span class="tok-kw">if</span> (hx > <span class="tok-number">0x3FD62E42</span>) {</span>
<span class="line" id="L203"> <span class="tok-comment">// |x| < 1.5 * ln2</span>
</span>
<span class="line" id="L204"> <span class="tok-kw">if</span> (hx < <span class="tok-number">0x3FF0A2B2</span>) {</span>
<span class="line" id="L205"> <span class="tok-kw">if</span> (sign == <span class="tok-number">0</span>) {</span>
<span class="line" id="L206"> hi = x - ln2_hi;</span>
<span class="line" id="L207"> lo = ln2_lo;</span>
<span class="line" id="L208"> k = <span class="tok-number">1</span>;</span>
<span class="line" id="L209"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L210"> hi = x + ln2_hi;</span>
<span class="line" id="L211"> lo = -ln2_lo;</span>
<span class="line" id="L212"> k = -<span class="tok-number">1</span>;</span>
<span class="line" id="L213"> }</span>
<span class="line" id="L214"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L215"> <span class="tok-kw">var</span> kf = invln2 * x;</span>
<span class="line" id="L216"> <span class="tok-kw">if</span> (sign != <span class="tok-number">0</span>) {</span>
<span class="line" id="L217"> kf -= <span class="tok-number">0.5</span>;</span>
<span class="line" id="L218"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L219"> kf += <span class="tok-number">0.5</span>;</span>
<span class="line" id="L220"> }</span>
<span class="line" id="L221"></span>
<span class="line" id="L222"> k = <span class="tok-builtin">@as</span>(<span class="tok-type">i32</span>, <span class="tok-builtin">@intFromFloat</span>(kf));</span>
<span class="line" id="L223"> <span class="tok-kw">const</span> t = <span class="tok-builtin">@as</span>(<span class="tok-type">f64</span>, <span class="tok-builtin">@floatFromInt</span>(k));</span>
<span class="line" id="L224"> hi = x - t * ln2_hi;</span>
<span class="line" id="L225"> lo = t * ln2_lo;</span>
<span class="line" id="L226"> }</span>
<span class="line" id="L227"></span>
<span class="line" id="L228"> x = hi - lo;</span>
<span class="line" id="L229"> c = (hi - x) - lo;</span>
<span class="line" id="L230"> }</span>
<span class="line" id="L231"> <span class="tok-comment">// |x| < 2^(-54)</span>
</span>
<span class="line" id="L232"> <span class="tok-kw">else</span> <span class="tok-kw">if</span> (hx < <span class="tok-number">0x3C900000</span>) {</span>
<span class="line" id="L233"> <span class="tok-kw">if</span> (hx < <span class="tok-number">0x00100000</span>) {</span>
<span class="line" id="L234"> math.doNotOptimizeAway(<span class="tok-builtin">@as</span>(<span class="tok-type">f32</span>, <span class="tok-builtin">@floatCast</span>(x)));</span>
<span class="line" id="L235"> }</span>
<span class="line" id="L236"> <span class="tok-kw">return</span> x;</span>
<span class="line" id="L237"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L238"> k = <span class="tok-number">0</span>;</span>
<span class="line" id="L239"> }</span>
<span class="line" id="L240"></span>
<span class="line" id="L241"> <span class="tok-kw">const</span> hfx = <span class="tok-number">0.5</span> * x;</span>
<span class="line" id="L242"> <span class="tok-kw">const</span> hxs = x * hfx;</span>
<span class="line" id="L243"> <span class="tok-kw">const</span> r1 = <span class="tok-number">1.0</span> + hxs * (Q1 + hxs * (Q2 + hxs * (Q3 + hxs * (Q4 + hxs * Q5))));</span>
<span class="line" id="L244"> <span class="tok-kw">const</span> t = <span class="tok-number">3.0</span> - r1 * hfx;</span>
<span class="line" id="L245"> <span class="tok-kw">var</span> e = hxs * ((r1 - t) / (<span class="tok-number">6.0</span> - x * t));</span>
<span class="line" id="L246"></span>
<span class="line" id="L247"> <span class="tok-comment">// c is 0</span>
</span>
<span class="line" id="L248"> <span class="tok-kw">if</span> (k == <span class="tok-number">0</span>) {</span>
<span class="line" id="L249"> <span class="tok-kw">return</span> x - (x * e - hxs);</span>
<span class="line" id="L250"> }</span>
<span class="line" id="L251"></span>
<span class="line" id="L252"> e = x * (e - c) - c;</span>
<span class="line" id="L253"> e -= hxs;</span>
<span class="line" id="L254"></span>
<span class="line" id="L255"> <span class="tok-comment">// exp(x) ~ 2^k (x_reduced - e + 1)</span>
</span>
<span class="line" id="L256"> <span class="tok-kw">if</span> (k == -<span class="tok-number">1</span>) {</span>
<span class="line" id="L257"> <span class="tok-kw">return</span> <span class="tok-number">0.5</span> * (x - e) - <span class="tok-number">0.5</span>;</span>
<span class="line" id="L258"> }</span>
<span class="line" id="L259"> <span class="tok-kw">if</span> (k == <span class="tok-number">1</span>) {</span>
<span class="line" id="L260"> <span class="tok-kw">if</span> (x < -<span class="tok-number">0.25</span>) {</span>
<span class="line" id="L261"> <span class="tok-kw">return</span> -<span class="tok-number">2.0</span> * (e - (x + <span class="tok-number">0.5</span>));</span>
<span class="line" id="L262"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L263"> <span class="tok-kw">return</span> <span class="tok-number">1.0</span> + <span class="tok-number">2.0</span> * (x - e);</span>
<span class="line" id="L264"> }</span>
<span class="line" id="L265"> }</span>
<span class="line" id="L266"></span>
<span class="line" id="L267"> <span class="tok-kw">const</span> twopk = <span class="tok-builtin">@as</span>(<span class="tok-type">f64</span>, <span class="tok-builtin">@bitCast</span>(<span class="tok-builtin">@as</span>(<span class="tok-type">u64</span>, <span class="tok-builtin">@intCast</span>(<span class="tok-number">0x3FF</span> +% k)) << <span class="tok-number">52</span>));</span>
<span class="line" id="L268"></span>
<span class="line" id="L269"> <span class="tok-kw">if</span> (k < <span class="tok-number">0</span> <span class="tok-kw">or</span> k > <span class="tok-number">56</span>) {</span>
<span class="line" id="L270"> <span class="tok-kw">var</span> y = x - e + <span class="tok-number">1.0</span>;</span>
<span class="line" id="L271"> <span class="tok-kw">if</span> (k == <span class="tok-number">1024</span>) {</span>
<span class="line" id="L272"> y = y * <span class="tok-number">2.0</span> * <span class="tok-number">0x1.0p1023</span>;</span>
<span class="line" id="L273"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L274"> y = y * twopk;</span>
<span class="line" id="L275"> }</span>
<span class="line" id="L276"></span>
<span class="line" id="L277"> <span class="tok-kw">return</span> y - <span class="tok-number">1.0</span>;</span>
<span class="line" id="L278"> }</span>
<span class="line" id="L279"></span>
<span class="line" id="L280"> <span class="tok-kw">const</span> uf = <span class="tok-builtin">@as</span>(<span class="tok-type">f64</span>, <span class="tok-builtin">@bitCast</span>(<span class="tok-builtin">@as</span>(<span class="tok-type">u64</span>, <span class="tok-builtin">@intCast</span>(<span class="tok-number">0x3FF</span> -% k)) << <span class="tok-number">52</span>));</span>
<span class="line" id="L281"> <span class="tok-kw">if</span> (k < <span class="tok-number">20</span>) {</span>
<span class="line" id="L282"> <span class="tok-kw">return</span> (x - e + (<span class="tok-number">1</span> - uf)) * twopk;</span>
<span class="line" id="L283"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L284"> <span class="tok-kw">return</span> (x - (e + uf) + <span class="tok-number">1</span>) * twopk;</span>
<span class="line" id="L285"> }</span>
<span class="line" id="L286">}</span>
<span class="line" id="L287"></span>
<span class="line" id="L288"><span class="tok-kw">test</span> <span class="tok-str">"math.exp1m"</span> {</span>
<span class="line" id="L289"> <span class="tok-kw">try</span> expect(expm1(<span class="tok-builtin">@as</span>(<span class="tok-type">f32</span>, <span class="tok-number">0.0</span>)) == expm1_32(<span class="tok-number">0.0</span>));</span>
<span class="line" id="L290"> <span class="tok-kw">try</span> expect(expm1(<span class="tok-builtin">@as</span>(<span class="tok-type">f64</span>, <span class="tok-number">0.0</span>)) == expm1_64(<span class="tok-number">0.0</span>));</span>
<span class="line" id="L291">}</span>
<span class="line" id="L292"></span>
<span class="line" id="L293"><span class="tok-kw">test</span> <span class="tok-str">"math.expm1_32"</span> {</span>
<span class="line" id="L294"> <span class="tok-kw">const</span> epsilon = <span class="tok-number">0.000001</span>;</span>
<span class="line" id="L295"></span>
<span class="line" id="L296"> <span class="tok-kw">try</span> expect(expm1_32(<span class="tok-number">0.0</span>) == <span class="tok-number">0.0</span>);</span>
<span class="line" id="L297"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f32</span>, expm1_32(<span class="tok-number">0.0</span>), <span class="tok-number">0.0</span>, epsilon));</span>
<span class="line" id="L298"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f32</span>, expm1_32(<span class="tok-number">0.2</span>), <span class="tok-number">0.221403</span>, epsilon));</span>
<span class="line" id="L299"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f32</span>, expm1_32(<span class="tok-number">0.8923</span>), <span class="tok-number">1.440737</span>, epsilon));</span>
<span class="line" id="L300"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f32</span>, expm1_32(<span class="tok-number">1.5</span>), <span class="tok-number">3.481689</span>, epsilon));</span>
<span class="line" id="L301">}</span>
<span class="line" id="L302"></span>
<span class="line" id="L303"><span class="tok-kw">test</span> <span class="tok-str">"math.expm1_64"</span> {</span>
<span class="line" id="L304"> <span class="tok-kw">const</span> epsilon = <span class="tok-number">0.000001</span>;</span>
<span class="line" id="L305"></span>
<span class="line" id="L306"> <span class="tok-kw">try</span> expect(expm1_64(<span class="tok-number">0.0</span>) == <span class="tok-number">0.0</span>);</span>
<span class="line" id="L307"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f64</span>, expm1_64(<span class="tok-number">0.0</span>), <span class="tok-number">0.0</span>, epsilon));</span>
<span class="line" id="L308"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f64</span>, expm1_64(<span class="tok-number">0.2</span>), <span class="tok-number">0.221403</span>, epsilon));</span>
<span class="line" id="L309"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f64</span>, expm1_64(<span class="tok-number">0.8923</span>), <span class="tok-number">1.440737</span>, epsilon));</span>
<span class="line" id="L310"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f64</span>, expm1_64(<span class="tok-number">1.5</span>), <span class="tok-number">3.481689</span>, epsilon));</span>
<span class="line" id="L311">}</span>
<span class="line" id="L312"></span>
<span class="line" id="L313"><span class="tok-kw">test</span> <span class="tok-str">"math.expm1_32.special"</span> {</span>
<span class="line" id="L314"> <span class="tok-kw">try</span> expect(math.isPositiveInf(expm1_32(math.inf(<span class="tok-type">f32</span>))));</span>
<span class="line" id="L315"> <span class="tok-kw">try</span> expect(expm1_32(-math.inf(<span class="tok-type">f32</span>)) == -<span class="tok-number">1.0</span>);</span>
<span class="line" id="L316"> <span class="tok-kw">try</span> expect(math.isNan(expm1_32(math.nan(<span class="tok-type">f32</span>))));</span>
<span class="line" id="L317">}</span>
<span class="line" id="L318"></span>
<span class="line" id="L319"><span class="tok-kw">test</span> <span class="tok-str">"math.expm1_64.special"</span> {</span>
<span class="line" id="L320"> <span class="tok-kw">try</span> expect(math.isPositiveInf(expm1_64(math.inf(<span class="tok-type">f64</span>))));</span>
<span class="line" id="L321"> <span class="tok-kw">try</span> expect(expm1_64(-math.inf(<span class="tok-type">f64</span>)) == -<span class="tok-number">1.0</span>);</span>
<span class="line" id="L322"> <span class="tok-kw">try</span> expect(math.isNan(expm1_64(math.nan(<span class="tok-type">f64</span>))));</span>
<span class="line" id="L323">}</span>
<span class="line" id="L324"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/math/log1p.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>math/log1p.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-comment">// Ported from musl, which is licensed under the MIT license:</span>
</span>
<span class="line" id="L2"><span class="tok-comment">// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT</span>
</span>
<span class="line" id="L3"><span class="tok-comment">//</span>
</span>
<span class="line" id="L4"><span class="tok-comment">// https://git.musl-libc.org/cgit/musl/tree/src/math/log1pf.c</span>
</span>
<span class="line" id="L5"><span class="tok-comment">// https://git.musl-libc.org/cgit/musl/tree/src/math/log1p.c</span>
</span>
<span class="line" id="L6"></span>
<span class="line" id="L7"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../std.zig"</span>);</span>
<span class="line" id="L8"><span class="tok-kw">const</span> math = std.math;</span>
<span class="line" id="L9"><span class="tok-kw">const</span> expect = std.testing.expect;</span>
<span class="line" id="L10"></span>
<span class="line" id="L11"><span class="tok-comment">/// Returns the natural logarithm of 1 + x with greater accuracy when x is near zero.</span></span>
<span class="line" id="L12"><span class="tok-comment">///</span></span>
<span class="line" id="L13"><span class="tok-comment">/// Special Cases:</span></span>
<span class="line" id="L14"><span class="tok-comment">/// - log1p(+inf) = +inf</span></span>
<span class="line" id="L15"><span class="tok-comment">/// - log1p(+-0) = +-0</span></span>
<span class="line" id="L16"><span class="tok-comment">/// - log1p(-1) = -inf</span></span>
<span class="line" id="L17"><span class="tok-comment">/// - log1p(x) = nan if x < -1</span></span>
<span class="line" id="L18"><span class="tok-comment">/// - log1p(nan) = nan</span></span>
<span class="line" id="L19"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">log1p</span>(x: <span class="tok-kw">anytype</span>) <span class="tok-builtin">@TypeOf</span>(x) {</span>
<span class="line" id="L20"> <span class="tok-kw">const</span> T = <span class="tok-builtin">@TypeOf</span>(x);</span>
<span class="line" id="L21"> <span class="tok-kw">return</span> <span class="tok-kw">switch</span> (T) {</span>
<span class="line" id="L22"> <span class="tok-type">f32</span> => log1p_32(x),</span>
<span class="line" id="L23"> <span class="tok-type">f64</span> => log1p_64(x),</span>
<span class="line" id="L24"> <span class="tok-kw">else</span> => <span class="tok-builtin">@compileError</span>(<span class="tok-str">"log1p not implemented for "</span> ++ <span class="tok-builtin">@typeName</span>(T)),</span>
<span class="line" id="L25"> };</span>
<span class="line" id="L26">}</span>
<span class="line" id="L27"></span>
<span class="line" id="L28"><span class="tok-kw">fn</span> <span class="tok-fn">log1p_32</span>(x: <span class="tok-type">f32</span>) <span class="tok-type">f32</span> {</span>
<span class="line" id="L29"> <span class="tok-kw">const</span> ln2_hi = <span class="tok-number">6.9313812256e-01</span>;</span>
<span class="line" id="L30"> <span class="tok-kw">const</span> ln2_lo = <span class="tok-number">9.0580006145e-06</span>;</span>
<span class="line" id="L31"> <span class="tok-kw">const</span> Lg1: <span class="tok-type">f32</span> = <span class="tok-number">0xaaaaaa.0p-24</span>;</span>
<span class="line" id="L32"> <span class="tok-kw">const</span> Lg2: <span class="tok-type">f32</span> = <span class="tok-number">0xccce13.0p-25</span>;</span>
<span class="line" id="L33"> <span class="tok-kw">const</span> Lg3: <span class="tok-type">f32</span> = <span class="tok-number">0x91e9ee.0p-25</span>;</span>
<span class="line" id="L34"> <span class="tok-kw">const</span> Lg4: <span class="tok-type">f32</span> = <span class="tok-number">0xf89e26.0p-26</span>;</span>
<span class="line" id="L35"></span>
<span class="line" id="L36"> <span class="tok-kw">const</span> u = <span class="tok-builtin">@as</span>(<span class="tok-type">u32</span>, <span class="tok-builtin">@bitCast</span>(x));</span>
<span class="line" id="L37"> <span class="tok-kw">var</span> ix = u;</span>
<span class="line" id="L38"> <span class="tok-kw">var</span> k: <span class="tok-type">i32</span> = <span class="tok-number">1</span>;</span>
<span class="line" id="L39"> <span class="tok-kw">var</span> f: <span class="tok-type">f32</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L40"> <span class="tok-kw">var</span> c: <span class="tok-type">f32</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L41"></span>
<span class="line" id="L42"> <span class="tok-comment">// 1 + x < sqrt(2)+</span>
</span>
<span class="line" id="L43"> <span class="tok-kw">if</span> (ix < <span class="tok-number">0x3ED413D0</span> <span class="tok-kw">or</span> ix >> <span class="tok-number">31</span> != <span class="tok-number">0</span>) {</span>
<span class="line" id="L44"> <span class="tok-comment">// x <= -1.0</span>
</span>
<span class="line" id="L45"> <span class="tok-kw">if</span> (ix >= <span class="tok-number">0xBF800000</span>) {</span>
<span class="line" id="L46"> <span class="tok-comment">// log1p(-1) = -inf</span>
</span>
<span class="line" id="L47"> <span class="tok-kw">if</span> (x == -<span class="tok-number">1.0</span>) {</span>
<span class="line" id="L48"> <span class="tok-kw">return</span> -math.inf(<span class="tok-type">f32</span>);</span>
<span class="line" id="L49"> }</span>
<span class="line" id="L50"> <span class="tok-comment">// log1p(x < -1) = nan</span>
</span>
<span class="line" id="L51"> <span class="tok-kw">else</span> {</span>
<span class="line" id="L52"> <span class="tok-kw">return</span> math.nan(<span class="tok-type">f32</span>);</span>
<span class="line" id="L53"> }</span>
<span class="line" id="L54"> }</span>
<span class="line" id="L55"> <span class="tok-comment">// |x| < 2^(-24)</span>
</span>
<span class="line" id="L56"> <span class="tok-kw">if</span> ((ix << <span class="tok-number">1</span>) < (<span class="tok-number">0x33800000</span> << <span class="tok-number">1</span>)) {</span>
<span class="line" id="L57"> <span class="tok-comment">// underflow if subnormal</span>
</span>
<span class="line" id="L58"> <span class="tok-kw">if</span> (ix & <span class="tok-number">0x7F800000</span> == <span class="tok-number">0</span>) {</span>
<span class="line" id="L59"> math.doNotOptimizeAway(x * x);</span>
<span class="line" id="L60"> }</span>
<span class="line" id="L61"> <span class="tok-kw">return</span> x;</span>
<span class="line" id="L62"> }</span>
<span class="line" id="L63"> <span class="tok-comment">// sqrt(2) / 2- <= 1 + x < sqrt(2)+</span>
</span>
<span class="line" id="L64"> <span class="tok-kw">if</span> (ix <= <span class="tok-number">0xBE95F619</span>) {</span>
<span class="line" id="L65"> k = <span class="tok-number">0</span>;</span>
<span class="line" id="L66"> c = <span class="tok-number">0</span>;</span>
<span class="line" id="L67"> f = x;</span>
<span class="line" id="L68"> }</span>
<span class="line" id="L69"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (ix >= <span class="tok-number">0x7F800000</span>) {</span>
<span class="line" id="L70"> <span class="tok-kw">return</span> x;</span>
<span class="line" id="L71"> }</span>
<span class="line" id="L72"></span>
<span class="line" id="L73"> <span class="tok-kw">if</span> (k != <span class="tok-number">0</span>) {</span>
<span class="line" id="L74"> <span class="tok-kw">const</span> uf = <span class="tok-number">1</span> + x;</span>
<span class="line" id="L75"> <span class="tok-kw">var</span> iu = <span class="tok-builtin">@as</span>(<span class="tok-type">u32</span>, <span class="tok-builtin">@bitCast</span>(uf));</span>
<span class="line" id="L76"> iu += <span class="tok-number">0x3F800000</span> - <span class="tok-number">0x3F3504F3</span>;</span>
<span class="line" id="L77"> k = <span class="tok-builtin">@as</span>(<span class="tok-type">i32</span>, <span class="tok-builtin">@intCast</span>(iu >> <span class="tok-number">23</span>)) - <span class="tok-number">0x7F</span>;</span>
<span class="line" id="L78"></span>
<span class="line" id="L79"> <span class="tok-comment">// correction to avoid underflow in c / u</span>
</span>
<span class="line" id="L80"> <span class="tok-kw">if</span> (k < <span class="tok-number">25</span>) {</span>
<span class="line" id="L81"> c = <span class="tok-kw">if</span> (k >= <span class="tok-number">2</span>) <span class="tok-number">1</span> - (uf - x) <span class="tok-kw">else</span> x - (uf - <span class="tok-number">1</span>);</span>
<span class="line" id="L82"> c /= uf;</span>
<span class="line" id="L83"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L84"> c = <span class="tok-number">0</span>;</span>
<span class="line" id="L85"> }</span>
<span class="line" id="L86"></span>
<span class="line" id="L87"> <span class="tok-comment">// u into [sqrt(2)/2, sqrt(2)]</span>
</span>
<span class="line" id="L88"> iu = (iu & <span class="tok-number">0x007FFFFF</span>) + <span class="tok-number">0x3F3504F3</span>;</span>
<span class="line" id="L89"> f = <span class="tok-builtin">@as</span>(<span class="tok-type">f32</span>, <span class="tok-builtin">@bitCast</span>(iu)) - <span class="tok-number">1</span>;</span>
<span class="line" id="L90"> }</span>
<span class="line" id="L91"></span>
<span class="line" id="L92"> <span class="tok-kw">const</span> s = f / (<span class="tok-number">2.0</span> + f);</span>
<span class="line" id="L93"> <span class="tok-kw">const</span> z = s * s;</span>
<span class="line" id="L94"> <span class="tok-kw">const</span> w = z * z;</span>
<span class="line" id="L95"> <span class="tok-kw">const</span> t1 = w * (Lg2 + w * Lg4);</span>
<span class="line" id="L96"> <span class="tok-kw">const</span> t2 = z * (Lg1 + w * Lg3);</span>
<span class="line" id="L97"> <span class="tok-kw">const</span> R = t2 + t1;</span>
<span class="line" id="L98"> <span class="tok-kw">const</span> hfsq = <span class="tok-number">0.5</span> * f * f;</span>
<span class="line" id="L99"> <span class="tok-kw">const</span> dk = <span class="tok-builtin">@as</span>(<span class="tok-type">f32</span>, <span class="tok-builtin">@floatFromInt</span>(k));</span>
<span class="line" id="L100"></span>
<span class="line" id="L101"> <span class="tok-kw">return</span> s * (hfsq + R) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;</span>
<span class="line" id="L102">}</span>
<span class="line" id="L103"></span>
<span class="line" id="L104"><span class="tok-kw">fn</span> <span class="tok-fn">log1p_64</span>(x: <span class="tok-type">f64</span>) <span class="tok-type">f64</span> {</span>
<span class="line" id="L105"> <span class="tok-kw">const</span> ln2_hi: <span class="tok-type">f64</span> = <span class="tok-number">6.93147180369123816490e-01</span>;</span>
<span class="line" id="L106"> <span class="tok-kw">const</span> ln2_lo: <span class="tok-type">f64</span> = <span class="tok-number">1.90821492927058770002e-10</span>;</span>
<span class="line" id="L107"> <span class="tok-kw">const</span> Lg1: <span class="tok-type">f64</span> = <span class="tok-number">6.666666666666735130e-01</span>;</span>
<span class="line" id="L108"> <span class="tok-kw">const</span> Lg2: <span class="tok-type">f64</span> = <span class="tok-number">3.999999999940941908e-01</span>;</span>
<span class="line" id="L109"> <span class="tok-kw">const</span> Lg3: <span class="tok-type">f64</span> = <span class="tok-number">2.857142874366239149e-01</span>;</span>
<span class="line" id="L110"> <span class="tok-kw">const</span> Lg4: <span class="tok-type">f64</span> = <span class="tok-number">2.222219843214978396e-01</span>;</span>
<span class="line" id="L111"> <span class="tok-kw">const</span> Lg5: <span class="tok-type">f64</span> = <span class="tok-number">1.818357216161805012e-01</span>;</span>
<span class="line" id="L112"> <span class="tok-kw">const</span> Lg6: <span class="tok-type">f64</span> = <span class="tok-number">1.531383769920937332e-01</span>;</span>
<span class="line" id="L113"> <span class="tok-kw">const</span> Lg7: <span class="tok-type">f64</span> = <span class="tok-number">1.479819860511658591e-01</span>;</span>
<span class="line" id="L114"></span>
<span class="line" id="L115"> <span class="tok-kw">var</span> ix = <span class="tok-builtin">@as</span>(<span class="tok-type">u64</span>, <span class="tok-builtin">@bitCast</span>(x));</span>
<span class="line" id="L116"> <span class="tok-kw">var</span> hx = <span class="tok-builtin">@as</span>(<span class="tok-type">u32</span>, <span class="tok-builtin">@intCast</span>(ix >> <span class="tok-number">32</span>));</span>
<span class="line" id="L117"> <span class="tok-kw">var</span> k: <span class="tok-type">i32</span> = <span class="tok-number">1</span>;</span>
<span class="line" id="L118"> <span class="tok-kw">var</span> c: <span class="tok-type">f64</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L119"> <span class="tok-kw">var</span> f: <span class="tok-type">f64</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L120"></span>
<span class="line" id="L121"> <span class="tok-comment">// 1 + x < sqrt(2)</span>
</span>
<span class="line" id="L122"> <span class="tok-kw">if</span> (hx < <span class="tok-number">0x3FDA827A</span> <span class="tok-kw">or</span> hx >> <span class="tok-number">31</span> != <span class="tok-number">0</span>) {</span>
<span class="line" id="L123"> <span class="tok-comment">// x <= -1.0</span>
</span>
<span class="line" id="L124"> <span class="tok-kw">if</span> (hx >= <span class="tok-number">0xBFF00000</span>) {</span>
<span class="line" id="L125"> <span class="tok-comment">// log1p(-1) = -inf</span>
</span>
<span class="line" id="L126"> <span class="tok-kw">if</span> (x == -<span class="tok-number">1.0</span>) {</span>
<span class="line" id="L127"> <span class="tok-kw">return</span> -math.inf(<span class="tok-type">f64</span>);</span>
<span class="line" id="L128"> }</span>
<span class="line" id="L129"> <span class="tok-comment">// log1p(x < -1) = nan</span>
</span>
<span class="line" id="L130"> <span class="tok-kw">else</span> {</span>
<span class="line" id="L131"> <span class="tok-kw">return</span> math.nan(<span class="tok-type">f64</span>);</span>
<span class="line" id="L132"> }</span>
<span class="line" id="L133"> }</span>
<span class="line" id="L134"> <span class="tok-comment">// |x| < 2^(-53)</span>
</span>
<span class="line" id="L135"> <span class="tok-kw">if</span> ((hx << <span class="tok-number">1</span>) < (<span class="tok-number">0x3CA00000</span> << <span class="tok-number">1</span>)) {</span>
<span class="line" id="L136"> <span class="tok-kw">if</span> ((hx & <span class="tok-number">0x7FF00000</span>) == <span class="tok-number">0</span>) {</span>
<span class="line" id="L137"> math.raiseUnderflow();</span>
<span class="line" id="L138"> }</span>
<span class="line" id="L139"> <span class="tok-kw">return</span> x;</span>
<span class="line" id="L140"> }</span>
<span class="line" id="L141"> <span class="tok-comment">// sqrt(2) / 2- <= 1 + x < sqrt(2)+</span>
</span>
<span class="line" id="L142"> <span class="tok-kw">if</span> (hx <= <span class="tok-number">0xBFD2BEC4</span>) {</span>
<span class="line" id="L143"> k = <span class="tok-number">0</span>;</span>
<span class="line" id="L144"> c = <span class="tok-number">0</span>;</span>
<span class="line" id="L145"> f = x;</span>
<span class="line" id="L146"> }</span>
<span class="line" id="L147"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (hx >= <span class="tok-number">0x7FF00000</span>) {</span>
<span class="line" id="L148"> <span class="tok-kw">return</span> x;</span>
<span class="line" id="L149"> }</span>
<span class="line" id="L150"></span>
<span class="line" id="L151"> <span class="tok-kw">if</span> (k != <span class="tok-number">0</span>) {</span>
<span class="line" id="L152"> <span class="tok-kw">const</span> uf = <span class="tok-number">1</span> + x;</span>
<span class="line" id="L153"> <span class="tok-kw">const</span> hu = <span class="tok-builtin">@as</span>(<span class="tok-type">u64</span>, <span class="tok-builtin">@bitCast</span>(uf));</span>
<span class="line" id="L154"> <span class="tok-kw">var</span> iu = <span class="tok-builtin">@as</span>(<span class="tok-type">u32</span>, <span class="tok-builtin">@intCast</span>(hu >> <span class="tok-number">32</span>));</span>
<span class="line" id="L155"> iu += <span class="tok-number">0x3FF00000</span> - <span class="tok-number">0x3FE6A09E</span>;</span>
<span class="line" id="L156"> k = <span class="tok-builtin">@as</span>(<span class="tok-type">i32</span>, <span class="tok-builtin">@intCast</span>(iu >> <span class="tok-number">20</span>)) - <span class="tok-number">0x3FF</span>;</span>
<span class="line" id="L157"></span>
<span class="line" id="L158"> <span class="tok-comment">// correction to avoid underflow in c / u</span>
</span>
<span class="line" id="L159"> <span class="tok-kw">if</span> (k < <span class="tok-number">54</span>) {</span>
<span class="line" id="L160"> c = <span class="tok-kw">if</span> (k >= <span class="tok-number">2</span>) <span class="tok-number">1</span> - (uf - x) <span class="tok-kw">else</span> x - (uf - <span class="tok-number">1</span>);</span>
<span class="line" id="L161"> c /= uf;</span>
<span class="line" id="L162"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L163"> c = <span class="tok-number">0</span>;</span>
<span class="line" id="L164"> }</span>
<span class="line" id="L165"></span>
<span class="line" id="L166"> <span class="tok-comment">// u into [sqrt(2)/2, sqrt(2)]</span>
</span>
<span class="line" id="L167"> iu = (iu & <span class="tok-number">0x000FFFFF</span>) + <span class="tok-number">0x3FE6A09E</span>;</span>
<span class="line" id="L168"> <span class="tok-kw">const</span> iq = (<span class="tok-builtin">@as</span>(<span class="tok-type">u64</span>, iu) << <span class="tok-number">32</span>) | (hu & <span class="tok-number">0xFFFFFFFF</span>);</span>
<span class="line" id="L169"> f = <span class="tok-builtin">@as</span>(<span class="tok-type">f64</span>, <span class="tok-builtin">@bitCast</span>(iq)) - <span class="tok-number">1</span>;</span>
<span class="line" id="L170"> }</span>
<span class="line" id="L171"></span>
<span class="line" id="L172"> <span class="tok-kw">const</span> hfsq = <span class="tok-number">0.5</span> * f * f;</span>
<span class="line" id="L173"> <span class="tok-kw">const</span> s = f / (<span class="tok-number">2.0</span> + f);</span>
<span class="line" id="L174"> <span class="tok-kw">const</span> z = s * s;</span>
<span class="line" id="L175"> <span class="tok-kw">const</span> w = z * z;</span>
<span class="line" id="L176"> <span class="tok-kw">const</span> t1 = w * (Lg2 + w * (Lg4 + w * Lg6));</span>
<span class="line" id="L177"> <span class="tok-kw">const</span> t2 = z * (Lg1 + w * (Lg3 + w * (Lg5 + w * Lg7)));</span>
<span class="line" id="L178"> <span class="tok-kw">const</span> R = t2 + t1;</span>
<span class="line" id="L179"> <span class="tok-kw">const</span> dk = <span class="tok-builtin">@as</span>(<span class="tok-type">f64</span>, <span class="tok-builtin">@floatFromInt</span>(k));</span>
<span class="line" id="L180"></span>
<span class="line" id="L181"> <span class="tok-kw">return</span> s * (hfsq + R) + (dk * ln2_lo + c) - hfsq + f + dk * ln2_hi;</span>
<span class="line" id="L182">}</span>
<span class="line" id="L183"></span>
<span class="line" id="L184"><span class="tok-kw">test</span> <span class="tok-str">"math.log1p"</span> {</span>
<span class="line" id="L185"> <span class="tok-kw">try</span> expect(log1p(<span class="tok-builtin">@as</span>(<span class="tok-type">f32</span>, <span class="tok-number">0.0</span>)) == log1p_32(<span class="tok-number">0.0</span>));</span>
<span class="line" id="L186"> <span class="tok-kw">try</span> expect(log1p(<span class="tok-builtin">@as</span>(<span class="tok-type">f64</span>, <span class="tok-number">0.0</span>)) == log1p_64(<span class="tok-number">0.0</span>));</span>
<span class="line" id="L187">}</span>
<span class="line" id="L188"></span>
<span class="line" id="L189"><span class="tok-kw">test</span> <span class="tok-str">"math.log1p_32"</span> {</span>
<span class="line" id="L190"> <span class="tok-kw">const</span> epsilon = <span class="tok-number">0.000001</span>;</span>
<span class="line" id="L191"></span>
<span class="line" id="L192"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f32</span>, log1p_32(<span class="tok-number">0.0</span>), <span class="tok-number">0.0</span>, epsilon));</span>
<span class="line" id="L193"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f32</span>, log1p_32(<span class="tok-number">0.2</span>), <span class="tok-number">0.182322</span>, epsilon));</span>
<span class="line" id="L194"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f32</span>, log1p_32(<span class="tok-number">0.8923</span>), <span class="tok-number">0.637793</span>, epsilon));</span>
<span class="line" id="L195"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f32</span>, log1p_32(<span class="tok-number">1.5</span>), <span class="tok-number">0.916291</span>, epsilon));</span>
<span class="line" id="L196"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f32</span>, log1p_32(<span class="tok-number">37.45</span>), <span class="tok-number">3.649359</span>, epsilon));</span>
<span class="line" id="L197"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f32</span>, log1p_32(<span class="tok-number">89.123</span>), <span class="tok-number">4.501175</span>, epsilon));</span>
<span class="line" id="L198"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f32</span>, log1p_32(<span class="tok-number">123123.234375</span>), <span class="tok-number">11.720949</span>, epsilon));</span>
<span class="line" id="L199">}</span>
<span class="line" id="L200"></span>
<span class="line" id="L201"><span class="tok-kw">test</span> <span class="tok-str">"math.log1p_64"</span> {</span>
<span class="line" id="L202"> <span class="tok-kw">const</span> epsilon = <span class="tok-number">0.000001</span>;</span>
<span class="line" id="L203"></span>
<span class="line" id="L204"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f64</span>, log1p_64(<span class="tok-number">0.0</span>), <span class="tok-number">0.0</span>, epsilon));</span>
<span class="line" id="L205"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f64</span>, log1p_64(<span class="tok-number">0.2</span>), <span class="tok-number">0.182322</span>, epsilon));</span>
<span class="line" id="L206"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f64</span>, log1p_64(<span class="tok-number">0.8923</span>), <span class="tok-number">0.637793</span>, epsilon));</span>
<span class="line" id="L207"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f64</span>, log1p_64(<span class="tok-number">1.5</span>), <span class="tok-number">0.916291</span>, epsilon));</span>
<span class="line" id="L208"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f64</span>, log1p_64(<span class="tok-number">37.45</span>), <span class="tok-number">3.649359</span>, epsilon));</span>
<span class="line" id="L209"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f64</span>, log1p_64(<span class="tok-number">89.123</span>), <span class="tok-number">4.501175</span>, epsilon));</span>
<span class="line" id="L210"> <span class="tok-kw">try</span> expect(math.approxEqAbs(<span class="tok-type">f64</span>, log1p_64(<span class="tok-number">123123.234375</span>), <span class="tok-number">11.720949</span>, epsilon));</span>
<span class="line" id="L211">}</span>
<span class="line" id="L212"></span>
<span class="line" id="L213"><span class="tok-kw">test</span> <span class="tok-str">"math.log1p_32.special"</span> {</span>
<span class="line" id="L214"> <span class="tok-kw">try</span> expect(math.isPositiveInf(log1p_32(math.inf(<span class="tok-type">f32</span>))));</span>
<span class="line" id="L215"> <span class="tok-kw">try</span> expect(log1p_32(<span class="tok-number">0.0</span>) == <span class="tok-number">0.0</span>);</span>
<span class="line" id="L216"> <span class="tok-kw">try</span> expect(log1p_32(-<span class="tok-number">0.0</span>) == -<span class="tok-number">0.0</span>);</span>
<span class="line" id="L217"> <span class="tok-kw">try</span> expect(math.isNegativeInf(log1p_32(-<span class="tok-number">1.0</span>)));</span>
<span class="line" id="L218"> <span class="tok-kw">try</span> expect(math.isNan(log1p_32(-<span class="tok-number">2.0</span>)));</span>
<span class="line" id="L219"> <span class="tok-kw">try</span> expect(math.isNan(log1p_32(math.nan(<span class="tok-type">f32</span>))));</span>
<span class="line" id="L220">}</span>
<span class="line" id="L221"></span>
<span class="line" id="L222"><span class="tok-kw">test</span> <span class="tok-str">"math.log1p_64.special"</span> {</span>
<span class="line" id="L223"> <span class="tok-kw">try</span> expect(math.isPositiveInf(log1p_64(math.inf(<span class="tok-type">f64</span>))));</span>
<span class="line" id="L224"> <span class="tok-kw">try</span> expect(log1p_64(<span class="tok-number">0.0</span>) == <span class="tok-number">0.0</span>);</span>
<span class="line" id="L225"> <span class="tok-kw">try</span> expect(log1p_64(-<span class="tok-number">0.0</span>) == -<span class="tok-number">0.0</span>);</span>
<span class="line" id="L226"> <span class="tok-kw">try</span> expect(math.isNegativeInf(log1p_64(-<span class="tok-number">1.0</span>)));</span>
<span class="line" id="L227"> <span class="tok-kw">try</span> expect(math.isNan(log1p_64(-<span class="tok-number">2.0</span>)));</span>
<span class="line" id="L228"> <span class="tok-kw">try</span> expect(math.isNan(log1p_64(math.nan(<span class="tok-type">f64</span>))));</span>
<span class="line" id="L229">}</span>
<span class="line" id="L230"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/math/ln.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>math/ln.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../std.zig"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> math = std.math;</span>
<span class="line" id="L3"><span class="tok-kw">const</span> testing = std.testing;</span>
<span class="line" id="L4"></span>
<span class="line" id="L5"><span class="tok-comment">/// Returns the natural logarithm of x.</span></span>
<span class="line" id="L6"><span class="tok-comment">///</span></span>
<span class="line" id="L7"><span class="tok-comment">/// Special Cases:</span></span>
<span class="line" id="L8"><span class="tok-comment">/// - ln(+inf) = +inf</span></span>
<span class="line" id="L9"><span class="tok-comment">/// - ln(0) = -inf</span></span>
<span class="line" id="L10"><span class="tok-comment">/// - ln(x) = nan if x < 0</span></span>
<span class="line" id="L11"><span class="tok-comment">/// - ln(nan) = nan</span></span>
<span class="line" id="L12"><span class="tok-comment">/// TODO remove this in favor of `@log`.</span></span>
<span class="line" id="L13"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">ln</span>(x: <span class="tok-kw">anytype</span>) <span class="tok-builtin">@TypeOf</span>(x) {</span>
<span class="line" id="L14"> <span class="tok-kw">const</span> T = <span class="tok-builtin">@TypeOf</span>(x);</span>
<span class="line" id="L15"> <span class="tok-kw">switch</span> (<span class="tok-builtin">@typeInfo</span>(T)) {</span>
<span class="line" id="L16"> .ComptimeFloat => {</span>
<span class="line" id="L17"> <span class="tok-kw">return</span> <span class="tok-builtin">@as</span>(<span class="tok-type">comptime_float</span>, <span class="tok-builtin">@log</span>(x));</span>
<span class="line" id="L18"> },</span>
<span class="line" id="L19"> .Float => <span class="tok-kw">return</span> <span class="tok-builtin">@log</span>(x),</span>
<span class="line" id="L20"> .ComptimeInt => {</span>
<span class="line" id="L21"> <span class="tok-kw">return</span> <span class="tok-builtin">@as</span>(<span class="tok-type">comptime_int</span>, <span class="tok-builtin">@floor</span>(<span class="tok-builtin">@log</span>(<span class="tok-builtin">@as</span>(<span class="tok-type">f64</span>, x))));</span>
<span class="line" id="L22"> },</span>
<span class="line" id="L23"> .Int => |IntType| <span class="tok-kw">switch</span> (IntType.signedness) {</span>
<span class="line" id="L24"> .signed => <span class="tok-builtin">@compileError</span>(<span class="tok-str">"ln not implemented for signed integers"</span>),</span>
<span class="line" id="L25"> .unsigned => <span class="tok-kw">return</span> <span class="tok-builtin">@as</span>(T, <span class="tok-builtin">@floor</span>(<span class="tok-builtin">@log</span>(<span class="tok-builtin">@as</span>(<span class="tok-type">f64</span>, x)))),</span>
<span class="line" id="L26"> },</span>
<span class="line" id="L27"> <span class="tok-kw">else</span> => <span class="tok-builtin">@compileError</span>(<span class="tok-str">"ln not implemented for "</span> ++ <span class="tok-builtin">@typeName</span>(T)),</span>
<span class="line" id="L28"> }</span>
<span class="line" id="L29">}</span>
<span class="line" id="L30"></span>
<span class="line" id="L31"><span class="tok-kw">test</span> <span class="tok-str">"math.ln"</span> {</span>
<span class="line" id="L32"> <span class="tok-kw">try</span> testing.expect(ln(<span class="tok-builtin">@as</span>(<span class="tok-type">f32</span>, <span class="tok-number">0.2</span>)) == <span class="tok-builtin">@log</span>(<span class="tok-number">0.2</span>));</span>
<span class="line" id="L33"> <span class="tok-kw">try</span> testing.expect(ln(<span class="tok-builtin">@as</span>(<span class="tok-type">f64</span>, <span class="tok-number">0.2</span>)) == <span class="tok-builtin">@log</span>(<span class="tok-number">0.2</span>));</span>
<span class="line" id="L34">}</span>
<span class="line" id="L35"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/math/ilogb.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>math/ilogb.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-comment">// Ported from musl, which is MIT licensed.</span>
</span>
<span class="line" id="L2"><span class="tok-comment">// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT</span>
</span>
<span class="line" id="L3"><span class="tok-comment">//</span>
</span>
<span class="line" id="L4"><span class="tok-comment">// https://git.musl-libc.org/cgit/musl/tree/src/math/ilogbl.c</span>
</span>
<span class="line" id="L5"><span class="tok-comment">// https://git.musl-libc.org/cgit/musl/tree/src/math/ilogbf.c</span>
</span>
<span class="line" id="L6"><span class="tok-comment">// https://git.musl-libc.org/cgit/musl/tree/src/math/ilogb.c</span>
</span>
<span class="line" id="L7"></span>
<span class="line" id="L8"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../std.zig"</span>);</span>
<span class="line" id="L9"><span class="tok-kw">const</span> math = std.math;</span>
<span class="line" id="L10"><span class="tok-kw">const</span> expect = std.testing.expect;</span>
<span class="line" id="L11"><span class="tok-kw">const</span> maxInt = std.math.maxInt;</span>
<span class="line" id="L12"><span class="tok-kw">const</span> minInt = std.math.minInt;</span>
<span class="line" id="L13"></span>
<span class="line" id="L14"><span class="tok-comment">/// Returns the binary exponent of x as an integer.</span></span>
<span class="line" id="L15"><span class="tok-comment">///</span></span>
<span class="line" id="L16"><span class="tok-comment">/// Special Cases:</span></span>
<span class="line" id="L17"><span class="tok-comment">/// - ilogb(+-inf) = maxInt(i32)</span></span>
<span class="line" id="L18"><span class="tok-comment">/// - ilogb(+-0) = minInt(i32)</span></span>
<span class="line" id="L19"><span class="tok-comment">/// - ilogb(nan) = minInt(i32)</span></span>
<span class="line" id="L20"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">ilogb</span>(x: <span class="tok-kw">anytype</span>) <span class="tok-type">i32</span> {</span>
<span class="line" id="L21"> <span class="tok-kw">const</span> T = <span class="tok-builtin">@TypeOf</span>(x);</span>
<span class="line" id="L22"> <span class="tok-kw">return</span> ilogbX(T, x);</span>
<span class="line" id="L23">}</span>
<span class="line" id="L24"></span>
<span class="line" id="L25"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> fp_ilogbnan = minInt(<span class="tok-type">i32</span>);</span>
<span class="line" id="L26"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> fp_ilogb0 = minInt(<span class="tok-type">i32</span>);</span>
<span class="line" id="L27"></span>
<span class="line" id="L28"><span class="tok-kw">fn</span> <span class="tok-fn">ilogbX</span>(<span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>, x: T) <span class="tok-type">i32</span> {</span>
<span class="line" id="L29"> <span class="tok-kw">const</span> typeWidth = <span class="tok-builtin">@typeInfo</span>(T).Float.bits;</span>
<span class="line" id="L30"> <span class="tok-kw">const</span> significandBits = math.floatMantissaBits(T);</span>
<span class="line" id="L31"> <span class="tok-kw">const</span> exponentBits = math.floatExponentBits(T);</span>
<span class="line" id="L32"></span>
<span class="line" id="L33"> <span class="tok-kw">const</span> Z = std.meta.Int(.unsigned, typeWidth);</span>
<span class="line" id="L34"></span>
<span class="line" id="L35"> <span class="tok-kw">const</span> signBit = (<span class="tok-builtin">@as</span>(Z, <span class="tok-number">1</span>) << (significandBits + exponentBits));</span>
<span class="line" id="L36"> <span class="tok-kw">const</span> maxExponent = ((<span class="tok-number">1</span> << exponentBits) - <span class="tok-number">1</span>);</span>
<span class="line" id="L37"> <span class="tok-kw">const</span> exponentBias = (maxExponent >> <span class="tok-number">1</span>);</span>
<span class="line" id="L38"></span>
<span class="line" id="L39"> <span class="tok-kw">const</span> absMask = signBit - <span class="tok-number">1</span>;</span>
<span class="line" id="L40"></span>
<span class="line" id="L41"> <span class="tok-kw">var</span> u = <span class="tok-builtin">@as</span>(Z, <span class="tok-builtin">@bitCast</span>(x)) & absMask;</span>
<span class="line" id="L42"> <span class="tok-kw">var</span> e = <span class="tok-builtin">@as</span>(<span class="tok-type">i32</span>, <span class="tok-builtin">@intCast</span>(u >> significandBits));</span>
<span class="line" id="L43"></span>
<span class="line" id="L44"> <span class="tok-kw">if</span> (e == <span class="tok-number">0</span>) {</span>
<span class="line" id="L45"> <span class="tok-kw">if</span> (u == <span class="tok-number">0</span>) {</span>
<span class="line" id="L46"> math.raiseInvalid();</span>
<span class="line" id="L47"> <span class="tok-kw">return</span> fp_ilogb0;</span>
<span class="line" id="L48"> }</span>
<span class="line" id="L49"></span>
<span class="line" id="L50"> <span class="tok-comment">// offset sign bit, exponent bits, and integer bit (if present) + bias</span>
</span>
<span class="line" id="L51"> <span class="tok-kw">const</span> offset = <span class="tok-number">1</span> + exponentBits + <span class="tok-builtin">@as</span>(<span class="tok-type">comptime_int</span>, <span class="tok-builtin">@intFromBool</span>(T == <span class="tok-type">f80</span>)) - exponentBias;</span>
<span class="line" id="L52"> <span class="tok-kw">return</span> offset - <span class="tok-builtin">@as</span>(<span class="tok-type">i32</span>, <span class="tok-builtin">@intCast</span>(<span class="tok-builtin">@clz</span>(u)));</span>
<span class="line" id="L53"> }</span>
<span class="line" id="L54"></span>
<span class="line" id="L55"> <span class="tok-kw">if</span> (e == maxExponent) {</span>
<span class="line" id="L56"> math.raiseInvalid();</span>
<span class="line" id="L57"> <span class="tok-kw">if</span> (u > <span class="tok-builtin">@as</span>(Z, <span class="tok-builtin">@bitCast</span>(math.inf(T)))) {</span>
<span class="line" id="L58"> <span class="tok-kw">return</span> fp_ilogbnan; <span class="tok-comment">// u is a NaN</span>
</span>
<span class="line" id="L59"> } <span class="tok-kw">else</span> <span class="tok-kw">return</span> maxInt(<span class="tok-type">i32</span>);</span>
<span class="line" id="L60"> }</span>
<span class="line" id="L61"></span>
<span class="line" id="L62"> <span class="tok-kw">return</span> e - exponentBias;</span>
<span class="line" id="L63">}</span>
<span class="line" id="L64"></span>
<span class="line" id="L65"><span class="tok-kw">test</span> <span class="tok-str">"type dispatch"</span> {</span>
<span class="line" id="L66"> <span class="tok-kw">try</span> expect(ilogb(<span class="tok-builtin">@as</span>(<span class="tok-type">f32</span>, <span class="tok-number">0.2</span>)) == ilogbX(<span class="tok-type">f32</span>, <span class="tok-number">0.2</span>));</span>
<span class="line" id="L67"> <span class="tok-kw">try</span> expect(ilogb(<span class="tok-builtin">@as</span>(<span class="tok-type">f64</span>, <span class="tok-number">0.2</span>)) == ilogbX(<span class="tok-type">f64</span>, <span class="tok-number">0.2</span>));</span>
<span class="line" id="L68">}</span>
<span class="line" id="L69"></span>
<span class="line" id="L70"><span class="tok-kw">test</span> <span class="tok-str">"16"</span> {</span>
<span class="line" id="L71"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f16</span>, <span class="tok-number">0.0</span>) == fp_ilogb0);</span>
<span class="line" id="L72"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f16</span>, <span class="tok-number">0.5</span>) == -<span class="tok-number">1</span>);</span>
<span class="line" id="L73"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f16</span>, <span class="tok-number">0.8923</span>) == -<span class="tok-number">1</span>);</span>
<span class="line" id="L74"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f16</span>, <span class="tok-number">10.0</span>) == <span class="tok-number">3</span>);</span>
<span class="line" id="L75"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f16</span>, -<span class="tok-number">65504</span>) == <span class="tok-number">15</span>);</span>
<span class="line" id="L76"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f16</span>, <span class="tok-number">2398.23</span>) == <span class="tok-number">11</span>);</span>
<span class="line" id="L77"></span>
<span class="line" id="L78"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f16</span>, <span class="tok-number">0x1p-1</span>) == -<span class="tok-number">1</span>);</span>
<span class="line" id="L79"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f16</span>, <span class="tok-number">0x1p-17</span>) == -<span class="tok-number">17</span>);</span>
<span class="line" id="L80"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f16</span>, <span class="tok-number">0x1p-24</span>) == -<span class="tok-number">24</span>);</span>
<span class="line" id="L81">}</span>
<span class="line" id="L82"></span>
<span class="line" id="L83"><span class="tok-kw">test</span> <span class="tok-str">"32"</span> {</span>
<span class="line" id="L84"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f32</span>, <span class="tok-number">0.0</span>) == fp_ilogb0);</span>
<span class="line" id="L85"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f32</span>, <span class="tok-number">0.5</span>) == -<span class="tok-number">1</span>);</span>
<span class="line" id="L86"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f32</span>, <span class="tok-number">0.8923</span>) == -<span class="tok-number">1</span>);</span>
<span class="line" id="L87"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f32</span>, <span class="tok-number">10.0</span>) == <span class="tok-number">3</span>);</span>
<span class="line" id="L88"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f32</span>, -<span class="tok-number">123984</span>) == <span class="tok-number">16</span>);</span>
<span class="line" id="L89"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f32</span>, <span class="tok-number">2398.23</span>) == <span class="tok-number">11</span>);</span>
<span class="line" id="L90"></span>
<span class="line" id="L91"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f32</span>, <span class="tok-number">0x1p-1</span>) == -<span class="tok-number">1</span>);</span>
<span class="line" id="L92"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f32</span>, <span class="tok-number">0x1p-122</span>) == -<span class="tok-number">122</span>);</span>
<span class="line" id="L93"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f32</span>, <span class="tok-number">0x1p-127</span>) == -<span class="tok-number">127</span>);</span>
<span class="line" id="L94">}</span>
<span class="line" id="L95"></span>
<span class="line" id="L96"><span class="tok-kw">test</span> <span class="tok-str">"64"</span> {</span>
<span class="line" id="L97"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f64</span>, <span class="tok-number">0.0</span>) == fp_ilogb0);</span>
<span class="line" id="L98"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f64</span>, <span class="tok-number">0.5</span>) == -<span class="tok-number">1</span>);</span>
<span class="line" id="L99"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f64</span>, <span class="tok-number">0.8923</span>) == -<span class="tok-number">1</span>);</span>
<span class="line" id="L100"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f64</span>, <span class="tok-number">10.0</span>) == <span class="tok-number">3</span>);</span>
<span class="line" id="L101"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f64</span>, -<span class="tok-number">123984</span>) == <span class="tok-number">16</span>);</span>
<span class="line" id="L102"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f64</span>, <span class="tok-number">2398.23</span>) == <span class="tok-number">11</span>);</span>
<span class="line" id="L103"></span>
<span class="line" id="L104"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f64</span>, <span class="tok-number">0x1p-1</span>) == -<span class="tok-number">1</span>);</span>
<span class="line" id="L105"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f64</span>, <span class="tok-number">0x1p-127</span>) == -<span class="tok-number">127</span>);</span>
<span class="line" id="L106"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f64</span>, <span class="tok-number">0x1p-1012</span>) == -<span class="tok-number">1012</span>);</span>
<span class="line" id="L107"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f64</span>, <span class="tok-number">0x1p-1023</span>) == -<span class="tok-number">1023</span>);</span>
<span class="line" id="L108">}</span>
<span class="line" id="L109"></span>
<span class="line" id="L110"><span class="tok-kw">test</span> <span class="tok-str">"80"</span> {</span>
<span class="line" id="L111"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f80</span>, <span class="tok-number">0.0</span>) == fp_ilogb0);</span>
<span class="line" id="L112"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f80</span>, <span class="tok-number">0.5</span>) == -<span class="tok-number">1</span>);</span>
<span class="line" id="L113"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f80</span>, <span class="tok-number">0.8923</span>) == -<span class="tok-number">1</span>);</span>
<span class="line" id="L114"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f80</span>, <span class="tok-number">10.0</span>) == <span class="tok-number">3</span>);</span>
<span class="line" id="L115"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f80</span>, -<span class="tok-number">123984</span>) == <span class="tok-number">16</span>);</span>
<span class="line" id="L116"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f80</span>, <span class="tok-number">2398.23</span>) == <span class="tok-number">11</span>);</span>
<span class="line" id="L117"></span>
<span class="line" id="L118"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f80</span>, <span class="tok-number">0x1p-1</span>) == -<span class="tok-number">1</span>);</span>
<span class="line" id="L119"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f80</span>, <span class="tok-number">0x1p-127</span>) == -<span class="tok-number">127</span>);</span>
<span class="line" id="L120"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f80</span>, <span class="tok-number">0x1p-1023</span>) == -<span class="tok-number">1023</span>);</span>
<span class="line" id="L121"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f80</span>, <span class="tok-number">0x1p-16383</span>) == -<span class="tok-number">16383</span>);</span>
<span class="line" id="L122">}</span>
<span class="line" id="L123"></span>
<span class="line" id="L124"><span class="tok-kw">test</span> <span class="tok-str">"128"</span> {</span>
<span class="line" id="L125"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f128</span>, <span class="tok-number">0.0</span>) == fp_ilogb0);</span>
<span class="line" id="L126"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f128</span>, <span class="tok-number">0.5</span>) == -<span class="tok-number">1</span>);</span>
<span class="line" id="L127"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f128</span>, <span class="tok-number">0.8923</span>) == -<span class="tok-number">1</span>);</span>
<span class="line" id="L128"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f128</span>, <span class="tok-number">10.0</span>) == <span class="tok-number">3</span>);</span>
<span class="line" id="L129"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f128</span>, -<span class="tok-number">123984</span>) == <span class="tok-number">16</span>);</span>
<span class="line" id="L130"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f128</span>, <span class="tok-number">2398.23</span>) == <span class="tok-number">11</span>);</span>
<span class="line" id="L131"></span>
<span class="line" id="L132"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f128</span>, <span class="tok-number">0x1p-1</span>) == -<span class="tok-number">1</span>);</span>
<span class="line" id="L133"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f128</span>, <span class="tok-number">0x1p-127</span>) == -<span class="tok-number">127</span>);</span>
<span class="line" id="L134"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f128</span>, <span class="tok-number">0x1p-1023</span>) == -<span class="tok-number">1023</span>);</span>
<span class="line" id="L135"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f128</span>, <span class="tok-number">0x1p-16383</span>) == -<span class="tok-number">16383</span>);</span>
<span class="line" id="L136">}</span>
<span class="line" id="L137"></span>
<span class="line" id="L138"><span class="tok-kw">test</span> <span class="tok-str">"16 special"</span> {</span>
<span class="line" id="L139"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f16</span>, math.inf(<span class="tok-type">f16</span>)) == maxInt(<span class="tok-type">i32</span>));</span>
<span class="line" id="L140"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f16</span>, -math.inf(<span class="tok-type">f16</span>)) == maxInt(<span class="tok-type">i32</span>));</span>
<span class="line" id="L141"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f16</span>, <span class="tok-number">0.0</span>) == minInt(<span class="tok-type">i32</span>));</span>
<span class="line" id="L142"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f16</span>, math.nan(<span class="tok-type">f16</span>)) == fp_ilogbnan);</span>
<span class="line" id="L143">}</span>
<span class="line" id="L144"></span>
<span class="line" id="L145"><span class="tok-kw">test</span> <span class="tok-str">"32 special"</span> {</span>
<span class="line" id="L146"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f32</span>, math.inf(<span class="tok-type">f32</span>)) == maxInt(<span class="tok-type">i32</span>));</span>
<span class="line" id="L147"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f32</span>, -math.inf(<span class="tok-type">f32</span>)) == maxInt(<span class="tok-type">i32</span>));</span>
<span class="line" id="L148"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f32</span>, <span class="tok-number">0.0</span>) == minInt(<span class="tok-type">i32</span>));</span>
<span class="line" id="L149"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f32</span>, math.nan(<span class="tok-type">f32</span>)) == fp_ilogbnan);</span>
<span class="line" id="L150">}</span>
<span class="line" id="L151"></span>
<span class="line" id="L152"><span class="tok-kw">test</span> <span class="tok-str">"64 special"</span> {</span>
<span class="line" id="L153"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f64</span>, math.inf(<span class="tok-type">f64</span>)) == maxInt(<span class="tok-type">i32</span>));</span>
<span class="line" id="L154"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f64</span>, -math.inf(<span class="tok-type">f64</span>)) == maxInt(<span class="tok-type">i32</span>));</span>
<span class="line" id="L155"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f64</span>, <span class="tok-number">0.0</span>) == minInt(<span class="tok-type">i32</span>));</span>
<span class="line" id="L156"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f64</span>, math.nan(<span class="tok-type">f64</span>)) == fp_ilogbnan);</span>
<span class="line" id="L157">}</span>
<span class="line" id="L158"></span>
<span class="line" id="L159"><span class="tok-kw">test</span> <span class="tok-str">"80 special"</span> {</span>
<span class="line" id="L160"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f80</span>, math.inf(<span class="tok-type">f80</span>)) == maxInt(<span class="tok-type">i32</span>));</span>
<span class="line" id="L161"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f80</span>, -math.inf(<span class="tok-type">f80</span>)) == maxInt(<span class="tok-type">i32</span>));</span>
<span class="line" id="L162"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f80</span>, <span class="tok-number">0.0</span>) == minInt(<span class="tok-type">i32</span>));</span>
<span class="line" id="L163"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f80</span>, math.nan(<span class="tok-type">f80</span>)) == fp_ilogbnan);</span>
<span class="line" id="L164">}</span>
<span class="line" id="L165"></span>
<span class="line" id="L166"><span class="tok-kw">test</span> <span class="tok-str">"128 special"</span> {</span>
<span class="line" id="L167"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f128</span>, math.inf(<span class="tok-type">f128</span>)) == maxInt(<span class="tok-type">i32</span>));</span>
<span class="line" id="L168"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f128</span>, -math.inf(<span class="tok-type">f128</span>)) == maxInt(<span class="tok-type">i32</span>));</span>
<span class="line" id="L169"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f128</span>, <span class="tok-number">0.0</span>) == minInt(<span class="tok-type">i32</span>));</span>
<span class="line" id="L170"> <span class="tok-kw">try</span> expect(ilogbX(<span class="tok-type">f128</span>, math.nan(<span class="tok-type">f128</span>)) == fp_ilogbnan);</span>
<span class="line" id="L171">}</span>
<span class="line" id="L172"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std/math | repos/yazap/docs/src/std/math/complex/cos.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>math/complex/cos.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../../std.zig"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> testing = std.testing;</span>
<span class="line" id="L3"><span class="tok-kw">const</span> math = std.math;</span>
<span class="line" id="L4"><span class="tok-kw">const</span> cmath = math.complex;</span>
<span class="line" id="L5"><span class="tok-kw">const</span> Complex = cmath.Complex;</span>
<span class="line" id="L6"></span>
<span class="line" id="L7"><span class="tok-comment">/// Returns the cosine of z.</span></span>
<span class="line" id="L8"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">cos</span>(z: <span class="tok-kw">anytype</span>) Complex(<span class="tok-builtin">@TypeOf</span>(z.re)) {</span>
<span class="line" id="L9"> <span class="tok-kw">const</span> T = <span class="tok-builtin">@TypeOf</span>(z.re);</span>
<span class="line" id="L10"> <span class="tok-kw">const</span> p = Complex(T).init(-z.im, z.re);</span>
<span class="line" id="L11"> <span class="tok-kw">return</span> cmath.cosh(p);</span>
<span class="line" id="L12">}</span>
<span class="line" id="L13"></span>
<span class="line" id="L14"><span class="tok-kw">const</span> epsilon = <span class="tok-number">0.0001</span>;</span>
<span class="line" id="L15"></span>
<span class="line" id="L16"><span class="tok-kw">test</span> <span class="tok-str">"complex.ccos"</span> {</span>
<span class="line" id="L17"> <span class="tok-kw">const</span> a = Complex(<span class="tok-type">f32</span>).init(<span class="tok-number">5</span>, <span class="tok-number">3</span>);</span>
<span class="line" id="L18"> <span class="tok-kw">const</span> c = cos(a);</span>
<span class="line" id="L19"></span>
<span class="line" id="L20"> <span class="tok-kw">try</span> testing.expect(math.approxEqAbs(<span class="tok-type">f32</span>, c.re, <span class="tok-number">2.855815</span>, epsilon));</span>
<span class="line" id="L21"> <span class="tok-kw">try</span> testing.expect(math.approxEqAbs(<span class="tok-type">f32</span>, c.im, <span class="tok-number">9.606383</span>, epsilon));</span>
<span class="line" id="L22">}</span>
<span class="line" id="L23"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std/math | repos/yazap/docs/src/std/math/complex/cosh.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>math/complex/cosh.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-comment">// Ported from musl, which is licensed under the MIT license:</span>
</span>
<span class="line" id="L2"><span class="tok-comment">// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT</span>
</span>
<span class="line" id="L3"><span class="tok-comment">//</span>
</span>
<span class="line" id="L4"><span class="tok-comment">// https://git.musl-libc.org/cgit/musl/tree/src/complex/ccoshf.c</span>
</span>
<span class="line" id="L5"><span class="tok-comment">// https://git.musl-libc.org/cgit/musl/tree/src/complex/ccosh.c</span>
</span>
<span class="line" id="L6"></span>
<span class="line" id="L7"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../../std.zig"</span>);</span>
<span class="line" id="L8"><span class="tok-kw">const</span> testing = std.testing;</span>
<span class="line" id="L9"><span class="tok-kw">const</span> math = std.math;</span>
<span class="line" id="L10"><span class="tok-kw">const</span> cmath = math.complex;</span>
<span class="line" id="L11"><span class="tok-kw">const</span> Complex = cmath.Complex;</span>
<span class="line" id="L12"></span>
<span class="line" id="L13"><span class="tok-kw">const</span> ldexp_cexp = <span class="tok-builtin">@import</span>(<span class="tok-str">"ldexp.zig"</span>).ldexp_cexp;</span>
<span class="line" id="L14"></span>
<span class="line" id="L15"><span class="tok-comment">/// Returns the hyperbolic arc-cosine of z.</span></span>
<span class="line" id="L16"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">cosh</span>(z: <span class="tok-kw">anytype</span>) Complex(<span class="tok-builtin">@TypeOf</span>(z.re)) {</span>
<span class="line" id="L17"> <span class="tok-kw">const</span> T = <span class="tok-builtin">@TypeOf</span>(z.re);</span>
<span class="line" id="L18"> <span class="tok-kw">return</span> <span class="tok-kw">switch</span> (T) {</span>
<span class="line" id="L19"> <span class="tok-type">f32</span> => cosh32(z),</span>
<span class="line" id="L20"> <span class="tok-type">f64</span> => cosh64(z),</span>
<span class="line" id="L21"> <span class="tok-kw">else</span> => <span class="tok-builtin">@compileError</span>(<span class="tok-str">"cosh not implemented for "</span> ++ <span class="tok-builtin">@typeName</span>(z)),</span>
<span class="line" id="L22"> };</span>
<span class="line" id="L23">}</span>
<span class="line" id="L24"></span>
<span class="line" id="L25"><span class="tok-kw">fn</span> <span class="tok-fn">cosh32</span>(z: Complex(<span class="tok-type">f32</span>)) Complex(<span class="tok-type">f32</span>) {</span>
<span class="line" id="L26"> <span class="tok-kw">const</span> x = z.re;</span>
<span class="line" id="L27"> <span class="tok-kw">const</span> y = z.im;</span>
<span class="line" id="L28"></span>
<span class="line" id="L29"> <span class="tok-kw">const</span> hx = <span class="tok-builtin">@as</span>(<span class="tok-type">u32</span>, <span class="tok-builtin">@bitCast</span>(x));</span>
<span class="line" id="L30"> <span class="tok-kw">const</span> ix = hx & <span class="tok-number">0x7fffffff</span>;</span>
<span class="line" id="L31"></span>
<span class="line" id="L32"> <span class="tok-kw">const</span> hy = <span class="tok-builtin">@as</span>(<span class="tok-type">u32</span>, <span class="tok-builtin">@bitCast</span>(y));</span>
<span class="line" id="L33"> <span class="tok-kw">const</span> iy = hy & <span class="tok-number">0x7fffffff</span>;</span>
<span class="line" id="L34"></span>
<span class="line" id="L35"> <span class="tok-kw">if</span> (ix < <span class="tok-number">0x7f800000</span> <span class="tok-kw">and</span> iy < <span class="tok-number">0x7f800000</span>) {</span>
<span class="line" id="L36"> <span class="tok-kw">if</span> (iy == <span class="tok-number">0</span>) {</span>
<span class="line" id="L37"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f32</span>).init(math.cosh(x), y);</span>
<span class="line" id="L38"> }</span>
<span class="line" id="L39"> <span class="tok-comment">// small x: normal case</span>
</span>
<span class="line" id="L40"> <span class="tok-kw">if</span> (ix < <span class="tok-number">0x41100000</span>) {</span>
<span class="line" id="L41"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f32</span>).init(math.cosh(x) * <span class="tok-builtin">@cos</span>(y), math.sinh(x) * <span class="tok-builtin">@sin</span>(y));</span>
<span class="line" id="L42"> }</span>
<span class="line" id="L43"></span>
<span class="line" id="L44"> <span class="tok-comment">// |x|>= 9, so cosh(x) ~= exp(|x|)</span>
</span>
<span class="line" id="L45"> <span class="tok-kw">if</span> (ix < <span class="tok-number">0x42b17218</span>) {</span>
<span class="line" id="L46"> <span class="tok-comment">// x < 88.7: exp(|x|) won't overflow</span>
</span>
<span class="line" id="L47"> <span class="tok-kw">const</span> h = <span class="tok-builtin">@exp</span>(<span class="tok-builtin">@fabs</span>(x)) * <span class="tok-number">0.5</span>;</span>
<span class="line" id="L48"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f32</span>).init(math.copysign(h, x) * <span class="tok-builtin">@cos</span>(y), h * <span class="tok-builtin">@sin</span>(y));</span>
<span class="line" id="L49"> }</span>
<span class="line" id="L50"> <span class="tok-comment">// x < 192.7: scale to avoid overflow</span>
</span>
<span class="line" id="L51"> <span class="tok-kw">else</span> <span class="tok-kw">if</span> (ix < <span class="tok-number">0x4340b1e7</span>) {</span>
<span class="line" id="L52"> <span class="tok-kw">const</span> v = Complex(<span class="tok-type">f32</span>).init(<span class="tok-builtin">@fabs</span>(x), y);</span>
<span class="line" id="L53"> <span class="tok-kw">const</span> r = ldexp_cexp(v, -<span class="tok-number">1</span>);</span>
<span class="line" id="L54"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f32</span>).init(r.re, r.im * math.copysign(<span class="tok-builtin">@as</span>(<span class="tok-type">f32</span>, <span class="tok-number">1.0</span>), x));</span>
<span class="line" id="L55"> }</span>
<span class="line" id="L56"> <span class="tok-comment">// x >= 192.7: result always overflows</span>
</span>
<span class="line" id="L57"> <span class="tok-kw">else</span> {</span>
<span class="line" id="L58"> <span class="tok-kw">const</span> h = <span class="tok-number">0x1p127</span> * x;</span>
<span class="line" id="L59"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f32</span>).init(h * h * <span class="tok-builtin">@cos</span>(y), h * <span class="tok-builtin">@sin</span>(y));</span>
<span class="line" id="L60"> }</span>
<span class="line" id="L61"> }</span>
<span class="line" id="L62"></span>
<span class="line" id="L63"> <span class="tok-kw">if</span> (ix == <span class="tok-number">0</span> <span class="tok-kw">and</span> iy >= <span class="tok-number">0x7f800000</span>) {</span>
<span class="line" id="L64"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f32</span>).init(y - y, math.copysign(<span class="tok-builtin">@as</span>(<span class="tok-type">f32</span>, <span class="tok-number">0.0</span>), x * (y - y)));</span>
<span class="line" id="L65"> }</span>
<span class="line" id="L66"></span>
<span class="line" id="L67"> <span class="tok-kw">if</span> (iy == <span class="tok-number">0</span> <span class="tok-kw">and</span> ix >= <span class="tok-number">0x7f800000</span>) {</span>
<span class="line" id="L68"> <span class="tok-kw">if</span> (hx & <span class="tok-number">0x7fffff</span> == <span class="tok-number">0</span>) {</span>
<span class="line" id="L69"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f32</span>).init(x * x, math.copysign(<span class="tok-builtin">@as</span>(<span class="tok-type">f32</span>, <span class="tok-number">0.0</span>), x) * y);</span>
<span class="line" id="L70"> }</span>
<span class="line" id="L71"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f32</span>).init(x, math.copysign(<span class="tok-builtin">@as</span>(<span class="tok-type">f32</span>, <span class="tok-number">0.0</span>), (x + x) * y));</span>
<span class="line" id="L72"> }</span>
<span class="line" id="L73"></span>
<span class="line" id="L74"> <span class="tok-kw">if</span> (ix < <span class="tok-number">0x7f800000</span> <span class="tok-kw">and</span> iy >= <span class="tok-number">0x7f800000</span>) {</span>
<span class="line" id="L75"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f32</span>).init(y - y, x * (y - y));</span>
<span class="line" id="L76"> }</span>
<span class="line" id="L77"></span>
<span class="line" id="L78"> <span class="tok-kw">if</span> (ix >= <span class="tok-number">0x7f800000</span> <span class="tok-kw">and</span> (hx & <span class="tok-number">0x7fffff</span>) == <span class="tok-number">0</span>) {</span>
<span class="line" id="L79"> <span class="tok-kw">if</span> (iy >= <span class="tok-number">0x7f800000</span>) {</span>
<span class="line" id="L80"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f32</span>).init(x * x, x * (y - y));</span>
<span class="line" id="L81"> }</span>
<span class="line" id="L82"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f32</span>).init((x * x) * <span class="tok-builtin">@cos</span>(y), x * <span class="tok-builtin">@sin</span>(y));</span>
<span class="line" id="L83"> }</span>
<span class="line" id="L84"></span>
<span class="line" id="L85"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f32</span>).init((x * x) * (y - y), (x + x) * (y - y));</span>
<span class="line" id="L86">}</span>
<span class="line" id="L87"></span>
<span class="line" id="L88"><span class="tok-kw">fn</span> <span class="tok-fn">cosh64</span>(z: Complex(<span class="tok-type">f64</span>)) Complex(<span class="tok-type">f64</span>) {</span>
<span class="line" id="L89"> <span class="tok-kw">const</span> x = z.re;</span>
<span class="line" id="L90"> <span class="tok-kw">const</span> y = z.im;</span>
<span class="line" id="L91"></span>
<span class="line" id="L92"> <span class="tok-kw">const</span> fx = <span class="tok-builtin">@as</span>(<span class="tok-type">u64</span>, <span class="tok-builtin">@bitCast</span>(x));</span>
<span class="line" id="L93"> <span class="tok-kw">const</span> hx = <span class="tok-builtin">@as</span>(<span class="tok-type">u32</span>, <span class="tok-builtin">@intCast</span>(fx >> <span class="tok-number">32</span>));</span>
<span class="line" id="L94"> <span class="tok-kw">const</span> lx = <span class="tok-builtin">@as</span>(<span class="tok-type">u32</span>, <span class="tok-builtin">@truncate</span>(fx));</span>
<span class="line" id="L95"> <span class="tok-kw">const</span> ix = hx & <span class="tok-number">0x7fffffff</span>;</span>
<span class="line" id="L96"></span>
<span class="line" id="L97"> <span class="tok-kw">const</span> fy = <span class="tok-builtin">@as</span>(<span class="tok-type">u64</span>, <span class="tok-builtin">@bitCast</span>(y));</span>
<span class="line" id="L98"> <span class="tok-kw">const</span> hy = <span class="tok-builtin">@as</span>(<span class="tok-type">u32</span>, <span class="tok-builtin">@intCast</span>(fy >> <span class="tok-number">32</span>));</span>
<span class="line" id="L99"> <span class="tok-kw">const</span> ly = <span class="tok-builtin">@as</span>(<span class="tok-type">u32</span>, <span class="tok-builtin">@truncate</span>(fy));</span>
<span class="line" id="L100"> <span class="tok-kw">const</span> iy = hy & <span class="tok-number">0x7fffffff</span>;</span>
<span class="line" id="L101"></span>
<span class="line" id="L102"> <span class="tok-comment">// nearly non-exceptional case where x, y are finite</span>
</span>
<span class="line" id="L103"> <span class="tok-kw">if</span> (ix < <span class="tok-number">0x7ff00000</span> <span class="tok-kw">and</span> iy < <span class="tok-number">0x7ff00000</span>) {</span>
<span class="line" id="L104"> <span class="tok-kw">if</span> (iy | ly == <span class="tok-number">0</span>) {</span>
<span class="line" id="L105"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f64</span>).init(math.cosh(x), x * y);</span>
<span class="line" id="L106"> }</span>
<span class="line" id="L107"> <span class="tok-comment">// small x: normal case</span>
</span>
<span class="line" id="L108"> <span class="tok-kw">if</span> (ix < <span class="tok-number">0x40360000</span>) {</span>
<span class="line" id="L109"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f64</span>).init(math.cosh(x) * <span class="tok-builtin">@cos</span>(y), math.sinh(x) * <span class="tok-builtin">@sin</span>(y));</span>
<span class="line" id="L110"> }</span>
<span class="line" id="L111"></span>
<span class="line" id="L112"> <span class="tok-comment">// |x|>= 22, so cosh(x) ~= exp(|x|)</span>
</span>
<span class="line" id="L113"> <span class="tok-kw">if</span> (ix < <span class="tok-number">0x40862e42</span>) {</span>
<span class="line" id="L114"> <span class="tok-comment">// x < 710: exp(|x|) won't overflow</span>
</span>
<span class="line" id="L115"> <span class="tok-kw">const</span> h = <span class="tok-builtin">@exp</span>(<span class="tok-builtin">@fabs</span>(x)) * <span class="tok-number">0.5</span>;</span>
<span class="line" id="L116"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f64</span>).init(h * <span class="tok-builtin">@cos</span>(y), math.copysign(h, x) * <span class="tok-builtin">@sin</span>(y));</span>
<span class="line" id="L117"> }</span>
<span class="line" id="L118"> <span class="tok-comment">// x < 1455: scale to avoid overflow</span>
</span>
<span class="line" id="L119"> <span class="tok-kw">else</span> <span class="tok-kw">if</span> (ix < <span class="tok-number">0x4096bbaa</span>) {</span>
<span class="line" id="L120"> <span class="tok-kw">const</span> v = Complex(<span class="tok-type">f64</span>).init(<span class="tok-builtin">@fabs</span>(x), y);</span>
<span class="line" id="L121"> <span class="tok-kw">const</span> r = ldexp_cexp(v, -<span class="tok-number">1</span>);</span>
<span class="line" id="L122"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f64</span>).init(r.re, r.im * math.copysign(<span class="tok-builtin">@as</span>(<span class="tok-type">f64</span>, <span class="tok-number">1.0</span>), x));</span>
<span class="line" id="L123"> }</span>
<span class="line" id="L124"> <span class="tok-comment">// x >= 1455: result always overflows</span>
</span>
<span class="line" id="L125"> <span class="tok-kw">else</span> {</span>
<span class="line" id="L126"> <span class="tok-kw">const</span> h = <span class="tok-number">0x1p1023</span>;</span>
<span class="line" id="L127"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f64</span>).init(h * h * <span class="tok-builtin">@cos</span>(y), h * <span class="tok-builtin">@sin</span>(y));</span>
<span class="line" id="L128"> }</span>
<span class="line" id="L129"> }</span>
<span class="line" id="L130"></span>
<span class="line" id="L131"> <span class="tok-kw">if</span> (ix | lx == <span class="tok-number">0</span> <span class="tok-kw">and</span> iy >= <span class="tok-number">0x7ff00000</span>) {</span>
<span class="line" id="L132"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f64</span>).init(y - y, math.copysign(<span class="tok-builtin">@as</span>(<span class="tok-type">f64</span>, <span class="tok-number">0.0</span>), x * (y - y)));</span>
<span class="line" id="L133"> }</span>
<span class="line" id="L134"></span>
<span class="line" id="L135"> <span class="tok-kw">if</span> (iy | ly == <span class="tok-number">0</span> <span class="tok-kw">and</span> ix >= <span class="tok-number">0x7ff00000</span>) {</span>
<span class="line" id="L136"> <span class="tok-kw">if</span> ((hx & <span class="tok-number">0xfffff</span>) | lx == <span class="tok-number">0</span>) {</span>
<span class="line" id="L137"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f64</span>).init(x * x, math.copysign(<span class="tok-builtin">@as</span>(<span class="tok-type">f64</span>, <span class="tok-number">0.0</span>), x) * y);</span>
<span class="line" id="L138"> }</span>
<span class="line" id="L139"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f64</span>).init(x * x, math.copysign(<span class="tok-builtin">@as</span>(<span class="tok-type">f64</span>, <span class="tok-number">0.0</span>), (x + x) * y));</span>
<span class="line" id="L140"> }</span>
<span class="line" id="L141"></span>
<span class="line" id="L142"> <span class="tok-kw">if</span> (ix < <span class="tok-number">0x7ff00000</span> <span class="tok-kw">and</span> iy >= <span class="tok-number">0x7ff00000</span>) {</span>
<span class="line" id="L143"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f64</span>).init(y - y, x * (y - y));</span>
<span class="line" id="L144"> }</span>
<span class="line" id="L145"></span>
<span class="line" id="L146"> <span class="tok-kw">if</span> (ix >= <span class="tok-number">0x7ff00000</span> <span class="tok-kw">and</span> (hx & <span class="tok-number">0xfffff</span>) | lx == <span class="tok-number">0</span>) {</span>
<span class="line" id="L147"> <span class="tok-kw">if</span> (iy >= <span class="tok-number">0x7ff00000</span>) {</span>
<span class="line" id="L148"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f64</span>).init(x * x, x * (y - y));</span>
<span class="line" id="L149"> }</span>
<span class="line" id="L150"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f64</span>).init(x * x * <span class="tok-builtin">@cos</span>(y), x * <span class="tok-builtin">@sin</span>(y));</span>
<span class="line" id="L151"> }</span>
<span class="line" id="L152"></span>
<span class="line" id="L153"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f64</span>).init((x * x) * (y - y), (x + x) * (y - y));</span>
<span class="line" id="L154">}</span>
<span class="line" id="L155"></span>
<span class="line" id="L156"><span class="tok-kw">const</span> epsilon = <span class="tok-number">0.0001</span>;</span>
<span class="line" id="L157"></span>
<span class="line" id="L158"><span class="tok-kw">test</span> <span class="tok-str">"complex.ccosh32"</span> {</span>
<span class="line" id="L159"> <span class="tok-kw">const</span> a = Complex(<span class="tok-type">f32</span>).init(<span class="tok-number">5</span>, <span class="tok-number">3</span>);</span>
<span class="line" id="L160"> <span class="tok-kw">const</span> c = cosh(a);</span>
<span class="line" id="L161"></span>
<span class="line" id="L162"> <span class="tok-kw">try</span> testing.expect(math.approxEqAbs(<span class="tok-type">f32</span>, c.re, -<span class="tok-number">73.467300</span>, epsilon));</span>
<span class="line" id="L163"> <span class="tok-kw">try</span> testing.expect(math.approxEqAbs(<span class="tok-type">f32</span>, c.im, <span class="tok-number">10.471557</span>, epsilon));</span>
<span class="line" id="L164">}</span>
<span class="line" id="L165"></span>
<span class="line" id="L166"><span class="tok-kw">test</span> <span class="tok-str">"complex.ccosh64"</span> {</span>
<span class="line" id="L167"> <span class="tok-kw">const</span> a = Complex(<span class="tok-type">f64</span>).init(<span class="tok-number">5</span>, <span class="tok-number">3</span>);</span>
<span class="line" id="L168"> <span class="tok-kw">const</span> c = cosh(a);</span>
<span class="line" id="L169"></span>
<span class="line" id="L170"> <span class="tok-kw">try</span> testing.expect(math.approxEqAbs(<span class="tok-type">f64</span>, c.re, -<span class="tok-number">73.467300</span>, epsilon));</span>
<span class="line" id="L171"> <span class="tok-kw">try</span> testing.expect(math.approxEqAbs(<span class="tok-type">f64</span>, c.im, <span class="tok-number">10.471557</span>, epsilon));</span>
<span class="line" id="L172">}</span>
<span class="line" id="L173"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std/math | repos/yazap/docs/src/std/math/complex/log.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>math/complex/log.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../../std.zig"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> testing = std.testing;</span>
<span class="line" id="L3"><span class="tok-kw">const</span> math = std.math;</span>
<span class="line" id="L4"><span class="tok-kw">const</span> cmath = math.complex;</span>
<span class="line" id="L5"><span class="tok-kw">const</span> Complex = cmath.Complex;</span>
<span class="line" id="L6"></span>
<span class="line" id="L7"><span class="tok-comment">/// Returns the natural logarithm of z.</span></span>
<span class="line" id="L8"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">log</span>(z: <span class="tok-kw">anytype</span>) Complex(<span class="tok-builtin">@TypeOf</span>(z.re)) {</span>
<span class="line" id="L9"> <span class="tok-kw">const</span> T = <span class="tok-builtin">@TypeOf</span>(z.re);</span>
<span class="line" id="L10"> <span class="tok-kw">const</span> r = cmath.abs(z);</span>
<span class="line" id="L11"> <span class="tok-kw">const</span> phi = cmath.arg(z);</span>
<span class="line" id="L12"></span>
<span class="line" id="L13"> <span class="tok-kw">return</span> Complex(T).init(<span class="tok-builtin">@log</span>(r), phi);</span>
<span class="line" id="L14">}</span>
<span class="line" id="L15"></span>
<span class="line" id="L16"><span class="tok-kw">const</span> epsilon = <span class="tok-number">0.0001</span>;</span>
<span class="line" id="L17"></span>
<span class="line" id="L18"><span class="tok-kw">test</span> <span class="tok-str">"complex.clog"</span> {</span>
<span class="line" id="L19"> <span class="tok-kw">const</span> a = Complex(<span class="tok-type">f32</span>).init(<span class="tok-number">5</span>, <span class="tok-number">3</span>);</span>
<span class="line" id="L20"> <span class="tok-kw">const</span> c = log(a);</span>
<span class="line" id="L21"></span>
<span class="line" id="L22"> <span class="tok-kw">try</span> testing.expect(math.approxEqAbs(<span class="tok-type">f32</span>, c.re, <span class="tok-number">1.763180</span>, epsilon));</span>
<span class="line" id="L23"> <span class="tok-kw">try</span> testing.expect(math.approxEqAbs(<span class="tok-type">f32</span>, c.im, <span class="tok-number">0.540419</span>, epsilon));</span>
<span class="line" id="L24">}</span>
<span class="line" id="L25"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std/math | repos/yazap/docs/src/std/math/complex/tanh.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>math/complex/tanh.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-comment">// Ported from musl, which is licensed under the MIT license:</span>
</span>
<span class="line" id="L2"><span class="tok-comment">// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT</span>
</span>
<span class="line" id="L3"><span class="tok-comment">//</span>
</span>
<span class="line" id="L4"><span class="tok-comment">// https://git.musl-libc.org/cgit/musl/tree/src/complex/ctanhf.c</span>
</span>
<span class="line" id="L5"><span class="tok-comment">// https://git.musl-libc.org/cgit/musl/tree/src/complex/ctanh.c</span>
</span>
<span class="line" id="L6"></span>
<span class="line" id="L7"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../../std.zig"</span>);</span>
<span class="line" id="L8"><span class="tok-kw">const</span> testing = std.testing;</span>
<span class="line" id="L9"><span class="tok-kw">const</span> math = std.math;</span>
<span class="line" id="L10"><span class="tok-kw">const</span> cmath = math.complex;</span>
<span class="line" id="L11"><span class="tok-kw">const</span> Complex = cmath.Complex;</span>
<span class="line" id="L12"></span>
<span class="line" id="L13"><span class="tok-comment">/// Returns the hyperbolic tangent of z.</span></span>
<span class="line" id="L14"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">tanh</span>(z: <span class="tok-kw">anytype</span>) <span class="tok-builtin">@TypeOf</span>(z) {</span>
<span class="line" id="L15"> <span class="tok-kw">const</span> T = <span class="tok-builtin">@TypeOf</span>(z.re);</span>
<span class="line" id="L16"> <span class="tok-kw">return</span> <span class="tok-kw">switch</span> (T) {</span>
<span class="line" id="L17"> <span class="tok-type">f32</span> => tanh32(z),</span>
<span class="line" id="L18"> <span class="tok-type">f64</span> => tanh64(z),</span>
<span class="line" id="L19"> <span class="tok-kw">else</span> => <span class="tok-builtin">@compileError</span>(<span class="tok-str">"tan not implemented for "</span> ++ <span class="tok-builtin">@typeName</span>(z)),</span>
<span class="line" id="L20"> };</span>
<span class="line" id="L21">}</span>
<span class="line" id="L22"></span>
<span class="line" id="L23"><span class="tok-kw">fn</span> <span class="tok-fn">tanh32</span>(z: Complex(<span class="tok-type">f32</span>)) Complex(<span class="tok-type">f32</span>) {</span>
<span class="line" id="L24"> <span class="tok-kw">const</span> x = z.re;</span>
<span class="line" id="L25"> <span class="tok-kw">const</span> y = z.im;</span>
<span class="line" id="L26"></span>
<span class="line" id="L27"> <span class="tok-kw">const</span> hx = <span class="tok-builtin">@as</span>(<span class="tok-type">u32</span>, <span class="tok-builtin">@bitCast</span>(x));</span>
<span class="line" id="L28"> <span class="tok-kw">const</span> ix = hx & <span class="tok-number">0x7fffffff</span>;</span>
<span class="line" id="L29"></span>
<span class="line" id="L30"> <span class="tok-kw">if</span> (ix >= <span class="tok-number">0x7f800000</span>) {</span>
<span class="line" id="L31"> <span class="tok-kw">if</span> (ix & <span class="tok-number">0x7fffff</span> != <span class="tok-number">0</span>) {</span>
<span class="line" id="L32"> <span class="tok-kw">const</span> r = <span class="tok-kw">if</span> (y == <span class="tok-number">0</span>) y <span class="tok-kw">else</span> x * y;</span>
<span class="line" id="L33"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f32</span>).init(x, r);</span>
<span class="line" id="L34"> }</span>
<span class="line" id="L35"> <span class="tok-kw">const</span> xx = <span class="tok-builtin">@as</span>(<span class="tok-type">f32</span>, <span class="tok-builtin">@bitCast</span>(hx - <span class="tok-number">0x40000000</span>));</span>
<span class="line" id="L36"> <span class="tok-kw">const</span> r = <span class="tok-kw">if</span> (math.isInf(y)) y <span class="tok-kw">else</span> <span class="tok-builtin">@sin</span>(y) * <span class="tok-builtin">@cos</span>(y);</span>
<span class="line" id="L37"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f32</span>).init(xx, math.copysign(<span class="tok-builtin">@as</span>(<span class="tok-type">f32</span>, <span class="tok-number">0.0</span>), r));</span>
<span class="line" id="L38"> }</span>
<span class="line" id="L39"></span>
<span class="line" id="L40"> <span class="tok-kw">if</span> (!math.isFinite(y)) {</span>
<span class="line" id="L41"> <span class="tok-kw">const</span> r = <span class="tok-kw">if</span> (ix != <span class="tok-number">0</span>) y - y <span class="tok-kw">else</span> x;</span>
<span class="line" id="L42"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f32</span>).init(r, y - y);</span>
<span class="line" id="L43"> }</span>
<span class="line" id="L44"></span>
<span class="line" id="L45"> <span class="tok-comment">// x >= 11</span>
</span>
<span class="line" id="L46"> <span class="tok-kw">if</span> (ix >= <span class="tok-number">0x41300000</span>) {</span>
<span class="line" id="L47"> <span class="tok-kw">const</span> exp_mx = <span class="tok-builtin">@exp</span>(-<span class="tok-builtin">@fabs</span>(x));</span>
<span class="line" id="L48"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f32</span>).init(math.copysign(<span class="tok-builtin">@as</span>(<span class="tok-type">f32</span>, <span class="tok-number">1.0</span>), x), <span class="tok-number">4</span> * <span class="tok-builtin">@sin</span>(y) * <span class="tok-builtin">@cos</span>(y) * exp_mx * exp_mx);</span>
<span class="line" id="L49"> }</span>
<span class="line" id="L50"></span>
<span class="line" id="L51"> <span class="tok-comment">// Kahan's algorithm</span>
</span>
<span class="line" id="L52"> <span class="tok-kw">const</span> t = <span class="tok-builtin">@tan</span>(y);</span>
<span class="line" id="L53"> <span class="tok-kw">const</span> beta = <span class="tok-number">1.0</span> + t * t;</span>
<span class="line" id="L54"> <span class="tok-kw">const</span> s = math.sinh(x);</span>
<span class="line" id="L55"> <span class="tok-kw">const</span> rho = <span class="tok-builtin">@sqrt</span>(<span class="tok-number">1</span> + s * s);</span>
<span class="line" id="L56"> <span class="tok-kw">const</span> den = <span class="tok-number">1</span> + beta * s * s;</span>
<span class="line" id="L57"></span>
<span class="line" id="L58"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f32</span>).init((beta * rho * s) / den, t / den);</span>
<span class="line" id="L59">}</span>
<span class="line" id="L60"></span>
<span class="line" id="L61"><span class="tok-kw">fn</span> <span class="tok-fn">tanh64</span>(z: Complex(<span class="tok-type">f64</span>)) Complex(<span class="tok-type">f64</span>) {</span>
<span class="line" id="L62"> <span class="tok-kw">const</span> x = z.re;</span>
<span class="line" id="L63"> <span class="tok-kw">const</span> y = z.im;</span>
<span class="line" id="L64"></span>
<span class="line" id="L65"> <span class="tok-kw">const</span> fx = <span class="tok-builtin">@as</span>(<span class="tok-type">u64</span>, <span class="tok-builtin">@bitCast</span>(x));</span>
<span class="line" id="L66"> <span class="tok-comment">// TODO: zig should allow this conversion implicitly because it can notice that the value necessarily</span>
</span>
<span class="line" id="L67"> <span class="tok-comment">// fits in range.</span>
</span>
<span class="line" id="L68"> <span class="tok-kw">const</span> hx = <span class="tok-builtin">@as</span>(<span class="tok-type">u32</span>, <span class="tok-builtin">@intCast</span>(fx >> <span class="tok-number">32</span>));</span>
<span class="line" id="L69"> <span class="tok-kw">const</span> lx = <span class="tok-builtin">@as</span>(<span class="tok-type">u32</span>, <span class="tok-builtin">@truncate</span>(fx));</span>
<span class="line" id="L70"> <span class="tok-kw">const</span> ix = hx & <span class="tok-number">0x7fffffff</span>;</span>
<span class="line" id="L71"></span>
<span class="line" id="L72"> <span class="tok-kw">if</span> (ix >= <span class="tok-number">0x7ff00000</span>) {</span>
<span class="line" id="L73"> <span class="tok-kw">if</span> ((ix & <span class="tok-number">0x7fffff</span>) | lx != <span class="tok-number">0</span>) {</span>
<span class="line" id="L74"> <span class="tok-kw">const</span> r = <span class="tok-kw">if</span> (y == <span class="tok-number">0</span>) y <span class="tok-kw">else</span> x * y;</span>
<span class="line" id="L75"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f64</span>).init(x, r);</span>
<span class="line" id="L76"> }</span>
<span class="line" id="L77"></span>
<span class="line" id="L78"> <span class="tok-kw">const</span> xx = <span class="tok-builtin">@as</span>(<span class="tok-type">f64</span>, <span class="tok-builtin">@bitCast</span>((<span class="tok-builtin">@as</span>(<span class="tok-type">u64</span>, hx - <span class="tok-number">0x40000000</span>) << <span class="tok-number">32</span>) | lx));</span>
<span class="line" id="L79"> <span class="tok-kw">const</span> r = <span class="tok-kw">if</span> (math.isInf(y)) y <span class="tok-kw">else</span> <span class="tok-builtin">@sin</span>(y) * <span class="tok-builtin">@cos</span>(y);</span>
<span class="line" id="L80"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f64</span>).init(xx, math.copysign(<span class="tok-builtin">@as</span>(<span class="tok-type">f64</span>, <span class="tok-number">0.0</span>), r));</span>
<span class="line" id="L81"> }</span>
<span class="line" id="L82"></span>
<span class="line" id="L83"> <span class="tok-kw">if</span> (!math.isFinite(y)) {</span>
<span class="line" id="L84"> <span class="tok-kw">const</span> r = <span class="tok-kw">if</span> (ix != <span class="tok-number">0</span>) y - y <span class="tok-kw">else</span> x;</span>
<span class="line" id="L85"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f64</span>).init(r, y - y);</span>
<span class="line" id="L86"> }</span>
<span class="line" id="L87"></span>
<span class="line" id="L88"> <span class="tok-comment">// x >= 22</span>
</span>
<span class="line" id="L89"> <span class="tok-kw">if</span> (ix >= <span class="tok-number">0x40360000</span>) {</span>
<span class="line" id="L90"> <span class="tok-kw">const</span> exp_mx = <span class="tok-builtin">@exp</span>(-<span class="tok-builtin">@fabs</span>(x));</span>
<span class="line" id="L91"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f64</span>).init(math.copysign(<span class="tok-builtin">@as</span>(<span class="tok-type">f64</span>, <span class="tok-number">1.0</span>), x), <span class="tok-number">4</span> * <span class="tok-builtin">@sin</span>(y) * <span class="tok-builtin">@cos</span>(y) * exp_mx * exp_mx);</span>
<span class="line" id="L92"> }</span>
<span class="line" id="L93"></span>
<span class="line" id="L94"> <span class="tok-comment">// Kahan's algorithm</span>
</span>
<span class="line" id="L95"> <span class="tok-kw">const</span> t = <span class="tok-builtin">@tan</span>(y);</span>
<span class="line" id="L96"> <span class="tok-kw">const</span> beta = <span class="tok-number">1.0</span> + t * t;</span>
<span class="line" id="L97"> <span class="tok-kw">const</span> s = math.sinh(x);</span>
<span class="line" id="L98"> <span class="tok-kw">const</span> rho = <span class="tok-builtin">@sqrt</span>(<span class="tok-number">1</span> + s * s);</span>
<span class="line" id="L99"> <span class="tok-kw">const</span> den = <span class="tok-number">1</span> + beta * s * s;</span>
<span class="line" id="L100"></span>
<span class="line" id="L101"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f64</span>).init((beta * rho * s) / den, t / den);</span>
<span class="line" id="L102">}</span>
<span class="line" id="L103"></span>
<span class="line" id="L104"><span class="tok-kw">const</span> epsilon = <span class="tok-number">0.0001</span>;</span>
<span class="line" id="L105"></span>
<span class="line" id="L106"><span class="tok-kw">test</span> <span class="tok-str">"complex.ctanh32"</span> {</span>
<span class="line" id="L107"> <span class="tok-kw">const</span> a = Complex(<span class="tok-type">f32</span>).init(<span class="tok-number">5</span>, <span class="tok-number">3</span>);</span>
<span class="line" id="L108"> <span class="tok-kw">const</span> c = tanh(a);</span>
<span class="line" id="L109"></span>
<span class="line" id="L110"> <span class="tok-kw">try</span> testing.expect(math.approxEqAbs(<span class="tok-type">f32</span>, c.re, <span class="tok-number">0.999913</span>, epsilon));</span>
<span class="line" id="L111"> <span class="tok-kw">try</span> testing.expect(math.approxEqAbs(<span class="tok-type">f32</span>, c.im, -<span class="tok-number">0.000025</span>, epsilon));</span>
<span class="line" id="L112">}</span>
<span class="line" id="L113"></span>
<span class="line" id="L114"><span class="tok-kw">test</span> <span class="tok-str">"complex.ctanh64"</span> {</span>
<span class="line" id="L115"> <span class="tok-kw">const</span> a = Complex(<span class="tok-type">f64</span>).init(<span class="tok-number">5</span>, <span class="tok-number">3</span>);</span>
<span class="line" id="L116"> <span class="tok-kw">const</span> c = tanh(a);</span>
<span class="line" id="L117"></span>
<span class="line" id="L118"> <span class="tok-kw">try</span> testing.expect(math.approxEqAbs(<span class="tok-type">f64</span>, c.re, <span class="tok-number">0.999913</span>, epsilon));</span>
<span class="line" id="L119"> <span class="tok-kw">try</span> testing.expect(math.approxEqAbs(<span class="tok-type">f64</span>, c.im, -<span class="tok-number">0.000025</span>, epsilon));</span>
<span class="line" id="L120">}</span>
<span class="line" id="L121"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std/math | repos/yazap/docs/src/std/math/complex/asin.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>math/complex/asin.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../../std.zig"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> testing = std.testing;</span>
<span class="line" id="L3"><span class="tok-kw">const</span> math = std.math;</span>
<span class="line" id="L4"><span class="tok-kw">const</span> cmath = math.complex;</span>
<span class="line" id="L5"><span class="tok-kw">const</span> Complex = cmath.Complex;</span>
<span class="line" id="L6"></span>
<span class="line" id="L7"><span class="tok-comment">// Returns the arc-sine of z.</span>
</span>
<span class="line" id="L8"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">asin</span>(z: <span class="tok-kw">anytype</span>) Complex(<span class="tok-builtin">@TypeOf</span>(z.re)) {</span>
<span class="line" id="L9"> <span class="tok-kw">const</span> T = <span class="tok-builtin">@TypeOf</span>(z.re);</span>
<span class="line" id="L10"> <span class="tok-kw">const</span> x = z.re;</span>
<span class="line" id="L11"> <span class="tok-kw">const</span> y = z.im;</span>
<span class="line" id="L12"></span>
<span class="line" id="L13"> <span class="tok-kw">const</span> p = Complex(T).init(<span class="tok-number">1.0</span> - (x - y) * (x + y), -<span class="tok-number">2.0</span> * x * y);</span>
<span class="line" id="L14"> <span class="tok-kw">const</span> q = Complex(T).init(-y, x);</span>
<span class="line" id="L15"> <span class="tok-kw">const</span> r = cmath.log(q.add(cmath.sqrt(p)));</span>
<span class="line" id="L16"></span>
<span class="line" id="L17"> <span class="tok-kw">return</span> Complex(T).init(r.im, -r.re);</span>
<span class="line" id="L18">}</span>
<span class="line" id="L19"></span>
<span class="line" id="L20"><span class="tok-kw">const</span> epsilon = <span class="tok-number">0.0001</span>;</span>
<span class="line" id="L21"></span>
<span class="line" id="L22"><span class="tok-kw">test</span> <span class="tok-str">"complex.casin"</span> {</span>
<span class="line" id="L23"> <span class="tok-kw">const</span> a = Complex(<span class="tok-type">f32</span>).init(<span class="tok-number">5</span>, <span class="tok-number">3</span>);</span>
<span class="line" id="L24"> <span class="tok-kw">const</span> c = asin(a);</span>
<span class="line" id="L25"></span>
<span class="line" id="L26"> <span class="tok-kw">try</span> testing.expect(math.approxEqAbs(<span class="tok-type">f32</span>, c.re, <span class="tok-number">1.023822</span>, epsilon));</span>
<span class="line" id="L27"> <span class="tok-kw">try</span> testing.expect(math.approxEqAbs(<span class="tok-type">f32</span>, c.im, <span class="tok-number">2.452914</span>, epsilon));</span>
<span class="line" id="L28">}</span>
<span class="line" id="L29"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std/math | repos/yazap/docs/src/std/math/complex/exp.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>math/complex/exp.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-comment">// Ported from musl, which is licensed under the MIT license:</span>
</span>
<span class="line" id="L2"><span class="tok-comment">// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT</span>
</span>
<span class="line" id="L3"><span class="tok-comment">//</span>
</span>
<span class="line" id="L4"><span class="tok-comment">// https://git.musl-libc.org/cgit/musl/tree/src/complex/cexpf.c</span>
</span>
<span class="line" id="L5"><span class="tok-comment">// https://git.musl-libc.org/cgit/musl/tree/src/complex/cexp.c</span>
</span>
<span class="line" id="L6"></span>
<span class="line" id="L7"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../../std.zig"</span>);</span>
<span class="line" id="L8"><span class="tok-kw">const</span> testing = std.testing;</span>
<span class="line" id="L9"><span class="tok-kw">const</span> math = std.math;</span>
<span class="line" id="L10"><span class="tok-kw">const</span> cmath = math.complex;</span>
<span class="line" id="L11"><span class="tok-kw">const</span> Complex = cmath.Complex;</span>
<span class="line" id="L12"></span>
<span class="line" id="L13"><span class="tok-kw">const</span> ldexp_cexp = <span class="tok-builtin">@import</span>(<span class="tok-str">"ldexp.zig"</span>).ldexp_cexp;</span>
<span class="line" id="L14"></span>
<span class="line" id="L15"><span class="tok-comment">/// Returns e raised to the power of z (e^z).</span></span>
<span class="line" id="L16"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">exp</span>(z: <span class="tok-kw">anytype</span>) <span class="tok-builtin">@TypeOf</span>(z) {</span>
<span class="line" id="L17"> <span class="tok-kw">const</span> T = <span class="tok-builtin">@TypeOf</span>(z.re);</span>
<span class="line" id="L18"></span>
<span class="line" id="L19"> <span class="tok-kw">return</span> <span class="tok-kw">switch</span> (T) {</span>
<span class="line" id="L20"> <span class="tok-type">f32</span> => exp32(z),</span>
<span class="line" id="L21"> <span class="tok-type">f64</span> => exp64(z),</span>
<span class="line" id="L22"> <span class="tok-kw">else</span> => <span class="tok-builtin">@compileError</span>(<span class="tok-str">"exp not implemented for "</span> ++ <span class="tok-builtin">@typeName</span>(z)),</span>
<span class="line" id="L23"> };</span>
<span class="line" id="L24">}</span>
<span class="line" id="L25"></span>
<span class="line" id="L26"><span class="tok-kw">fn</span> <span class="tok-fn">exp32</span>(z: Complex(<span class="tok-type">f32</span>)) Complex(<span class="tok-type">f32</span>) {</span>
<span class="line" id="L27"> <span class="tok-kw">const</span> exp_overflow = <span class="tok-number">0x42b17218</span>; <span class="tok-comment">// max_exp * ln2 ~= 88.72283955</span>
</span>
<span class="line" id="L28"> <span class="tok-kw">const</span> cexp_overflow = <span class="tok-number">0x43400074</span>; <span class="tok-comment">// (max_exp - min_denom_exp) * ln2</span>
</span>
<span class="line" id="L29"></span>
<span class="line" id="L30"> <span class="tok-kw">const</span> x = z.re;</span>
<span class="line" id="L31"> <span class="tok-kw">const</span> y = z.im;</span>
<span class="line" id="L32"></span>
<span class="line" id="L33"> <span class="tok-kw">const</span> hy = <span class="tok-builtin">@as</span>(<span class="tok-type">u32</span>, <span class="tok-builtin">@bitCast</span>(y)) & <span class="tok-number">0x7fffffff</span>;</span>
<span class="line" id="L34"> <span class="tok-comment">// cexp(x + i0) = exp(x) + i0</span>
</span>
<span class="line" id="L35"> <span class="tok-kw">if</span> (hy == <span class="tok-number">0</span>) {</span>
<span class="line" id="L36"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f32</span>).init(<span class="tok-builtin">@exp</span>(x), y);</span>
<span class="line" id="L37"> }</span>
<span class="line" id="L38"></span>
<span class="line" id="L39"> <span class="tok-kw">const</span> hx = <span class="tok-builtin">@as</span>(<span class="tok-type">u32</span>, <span class="tok-builtin">@bitCast</span>(x));</span>
<span class="line" id="L40"> <span class="tok-comment">// cexp(0 + iy) = cos(y) + isin(y)</span>
</span>
<span class="line" id="L41"> <span class="tok-kw">if</span> ((hx & <span class="tok-number">0x7fffffff</span>) == <span class="tok-number">0</span>) {</span>
<span class="line" id="L42"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f32</span>).init(<span class="tok-builtin">@cos</span>(y), <span class="tok-builtin">@sin</span>(y));</span>
<span class="line" id="L43"> }</span>
<span class="line" id="L44"></span>
<span class="line" id="L45"> <span class="tok-kw">if</span> (hy >= <span class="tok-number">0x7f800000</span>) {</span>
<span class="line" id="L46"> <span class="tok-comment">// cexp(finite|nan +- i inf|nan) = nan + i nan</span>
</span>
<span class="line" id="L47"> <span class="tok-kw">if</span> ((hx & <span class="tok-number">0x7fffffff</span>) != <span class="tok-number">0x7f800000</span>) {</span>
<span class="line" id="L48"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f32</span>).init(y - y, y - y);</span>
<span class="line" id="L49"> } <span class="tok-comment">// cexp(-inf +- i inf|nan) = 0 + i0</span>
</span>
<span class="line" id="L50"> <span class="tok-kw">else</span> <span class="tok-kw">if</span> (hx & <span class="tok-number">0x80000000</span> != <span class="tok-number">0</span>) {</span>
<span class="line" id="L51"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f32</span>).init(<span class="tok-number">0</span>, <span class="tok-number">0</span>);</span>
<span class="line" id="L52"> } <span class="tok-comment">// cexp(+inf +- i inf|nan) = inf + i nan</span>
</span>
<span class="line" id="L53"> <span class="tok-kw">else</span> {</span>
<span class="line" id="L54"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f32</span>).init(x, y - y);</span>
<span class="line" id="L55"> }</span>
<span class="line" id="L56"> }</span>
<span class="line" id="L57"></span>
<span class="line" id="L58"> <span class="tok-comment">// 88.7 <= x <= 192 so must scale</span>
</span>
<span class="line" id="L59"> <span class="tok-kw">if</span> (hx >= exp_overflow <span class="tok-kw">and</span> hx <= cexp_overflow) {</span>
<span class="line" id="L60"> <span class="tok-kw">return</span> ldexp_cexp(z, <span class="tok-number">0</span>);</span>
<span class="line" id="L61"> } <span class="tok-comment">// - x < exp_overflow => exp(x) won't overflow (common)</span>
</span>
<span class="line" id="L62"> <span class="tok-comment">// - x > cexp_overflow, so exp(x) * s overflows for s > 0</span>
</span>
<span class="line" id="L63"> <span class="tok-comment">// - x = +-inf</span>
</span>
<span class="line" id="L64"> <span class="tok-comment">// - x = nan</span>
</span>
<span class="line" id="L65"> <span class="tok-kw">else</span> {</span>
<span class="line" id="L66"> <span class="tok-kw">const</span> exp_x = <span class="tok-builtin">@exp</span>(x);</span>
<span class="line" id="L67"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f32</span>).init(exp_x * <span class="tok-builtin">@cos</span>(y), exp_x * <span class="tok-builtin">@sin</span>(y));</span>
<span class="line" id="L68"> }</span>
<span class="line" id="L69">}</span>
<span class="line" id="L70"></span>
<span class="line" id="L71"><span class="tok-kw">fn</span> <span class="tok-fn">exp64</span>(z: Complex(<span class="tok-type">f64</span>)) Complex(<span class="tok-type">f64</span>) {</span>
<span class="line" id="L72"> <span class="tok-kw">const</span> exp_overflow = <span class="tok-number">0x40862e42</span>; <span class="tok-comment">// high bits of max_exp * ln2 ~= 710</span>
</span>
<span class="line" id="L73"> <span class="tok-kw">const</span> cexp_overflow = <span class="tok-number">0x4096b8e4</span>; <span class="tok-comment">// (max_exp - min_denorm_exp) * ln2</span>
</span>
<span class="line" id="L74"></span>
<span class="line" id="L75"> <span class="tok-kw">const</span> x = z.re;</span>
<span class="line" id="L76"> <span class="tok-kw">const</span> y = z.im;</span>
<span class="line" id="L77"></span>
<span class="line" id="L78"> <span class="tok-kw">const</span> fy = <span class="tok-builtin">@as</span>(<span class="tok-type">u64</span>, <span class="tok-builtin">@bitCast</span>(y));</span>
<span class="line" id="L79"> <span class="tok-kw">const</span> hy = <span class="tok-builtin">@as</span>(<span class="tok-type">u32</span>, <span class="tok-builtin">@intCast</span>((fy >> <span class="tok-number">32</span>) & <span class="tok-number">0x7fffffff</span>));</span>
<span class="line" id="L80"> <span class="tok-kw">const</span> ly = <span class="tok-builtin">@as</span>(<span class="tok-type">u32</span>, <span class="tok-builtin">@truncate</span>(fy));</span>
<span class="line" id="L81"></span>
<span class="line" id="L82"> <span class="tok-comment">// cexp(x + i0) = exp(x) + i0</span>
</span>
<span class="line" id="L83"> <span class="tok-kw">if</span> (hy | ly == <span class="tok-number">0</span>) {</span>
<span class="line" id="L84"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f64</span>).init(<span class="tok-builtin">@exp</span>(x), y);</span>
<span class="line" id="L85"> }</span>
<span class="line" id="L86"></span>
<span class="line" id="L87"> <span class="tok-kw">const</span> fx = <span class="tok-builtin">@as</span>(<span class="tok-type">u64</span>, <span class="tok-builtin">@bitCast</span>(x));</span>
<span class="line" id="L88"> <span class="tok-kw">const</span> hx = <span class="tok-builtin">@as</span>(<span class="tok-type">u32</span>, <span class="tok-builtin">@intCast</span>(fx >> <span class="tok-number">32</span>));</span>
<span class="line" id="L89"> <span class="tok-kw">const</span> lx = <span class="tok-builtin">@as</span>(<span class="tok-type">u32</span>, <span class="tok-builtin">@truncate</span>(fx));</span>
<span class="line" id="L90"></span>
<span class="line" id="L91"> <span class="tok-comment">// cexp(0 + iy) = cos(y) + isin(y)</span>
</span>
<span class="line" id="L92"> <span class="tok-kw">if</span> ((hx & <span class="tok-number">0x7fffffff</span>) | lx == <span class="tok-number">0</span>) {</span>
<span class="line" id="L93"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f64</span>).init(<span class="tok-builtin">@cos</span>(y), <span class="tok-builtin">@sin</span>(y));</span>
<span class="line" id="L94"> }</span>
<span class="line" id="L95"></span>
<span class="line" id="L96"> <span class="tok-kw">if</span> (hy >= <span class="tok-number">0x7ff00000</span>) {</span>
<span class="line" id="L97"> <span class="tok-comment">// cexp(finite|nan +- i inf|nan) = nan + i nan</span>
</span>
<span class="line" id="L98"> <span class="tok-kw">if</span> (lx != <span class="tok-number">0</span> <span class="tok-kw">or</span> (hx & <span class="tok-number">0x7fffffff</span>) != <span class="tok-number">0x7ff00000</span>) {</span>
<span class="line" id="L99"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f64</span>).init(y - y, y - y);</span>
<span class="line" id="L100"> } <span class="tok-comment">// cexp(-inf +- i inf|nan) = 0 + i0</span>
</span>
<span class="line" id="L101"> <span class="tok-kw">else</span> <span class="tok-kw">if</span> (hx & <span class="tok-number">0x80000000</span> != <span class="tok-number">0</span>) {</span>
<span class="line" id="L102"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f64</span>).init(<span class="tok-number">0</span>, <span class="tok-number">0</span>);</span>
<span class="line" id="L103"> } <span class="tok-comment">// cexp(+inf +- i inf|nan) = inf + i nan</span>
</span>
<span class="line" id="L104"> <span class="tok-kw">else</span> {</span>
<span class="line" id="L105"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f64</span>).init(x, y - y);</span>
<span class="line" id="L106"> }</span>
<span class="line" id="L107"> }</span>
<span class="line" id="L108"></span>
<span class="line" id="L109"> <span class="tok-comment">// 709.7 <= x <= 1454.3 so must scale</span>
</span>
<span class="line" id="L110"> <span class="tok-kw">if</span> (hx >= exp_overflow <span class="tok-kw">and</span> hx <= cexp_overflow) {</span>
<span class="line" id="L111"> <span class="tok-kw">return</span> ldexp_cexp(z, <span class="tok-number">0</span>);</span>
<span class="line" id="L112"> } <span class="tok-comment">// - x < exp_overflow => exp(x) won't overflow (common)</span>
</span>
<span class="line" id="L113"> <span class="tok-comment">// - x > cexp_overflow, so exp(x) * s overflows for s > 0</span>
</span>
<span class="line" id="L114"> <span class="tok-comment">// - x = +-inf</span>
</span>
<span class="line" id="L115"> <span class="tok-comment">// - x = nan</span>
</span>
<span class="line" id="L116"> <span class="tok-kw">else</span> {</span>
<span class="line" id="L117"> <span class="tok-kw">const</span> exp_x = <span class="tok-builtin">@exp</span>(x);</span>
<span class="line" id="L118"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f64</span>).init(exp_x * <span class="tok-builtin">@cos</span>(y), exp_x * <span class="tok-builtin">@sin</span>(y));</span>
<span class="line" id="L119"> }</span>
<span class="line" id="L120">}</span>
<span class="line" id="L121"></span>
<span class="line" id="L122"><span class="tok-kw">test</span> <span class="tok-str">"complex.cexp32"</span> {</span>
<span class="line" id="L123"> <span class="tok-kw">const</span> tolerance_f32 = <span class="tok-builtin">@sqrt</span>(math.floatEps(<span class="tok-type">f32</span>));</span>
<span class="line" id="L124"></span>
<span class="line" id="L125"> {</span>
<span class="line" id="L126"> <span class="tok-kw">const</span> a = Complex(<span class="tok-type">f32</span>).init(<span class="tok-number">5</span>, <span class="tok-number">3</span>);</span>
<span class="line" id="L127"> <span class="tok-kw">const</span> c = exp(a);</span>
<span class="line" id="L128"></span>
<span class="line" id="L129"> <span class="tok-kw">try</span> testing.expectApproxEqRel(<span class="tok-builtin">@as</span>(<span class="tok-type">f32</span>, -<span class="tok-number">1.46927917e+02</span>), c.re, tolerance_f32);</span>
<span class="line" id="L130"> <span class="tok-kw">try</span> testing.expectApproxEqRel(<span class="tok-builtin">@as</span>(<span class="tok-type">f32</span>, <span class="tok-number">2.0944065e+01</span>), c.im, tolerance_f32);</span>
<span class="line" id="L131"> }</span>
<span class="line" id="L132"></span>
<span class="line" id="L133"> {</span>
<span class="line" id="L134"> <span class="tok-kw">const</span> a = Complex(<span class="tok-type">f32</span>).init(<span class="tok-number">88.8</span>, <span class="tok-number">0x1p-149</span>);</span>
<span class="line" id="L135"> <span class="tok-kw">const</span> c = exp(a);</span>
<span class="line" id="L136"></span>
<span class="line" id="L137"> <span class="tok-kw">try</span> testing.expectApproxEqAbs(math.inf(<span class="tok-type">f32</span>), c.re, tolerance_f32);</span>
<span class="line" id="L138"> <span class="tok-kw">try</span> testing.expectApproxEqAbs(<span class="tok-builtin">@as</span>(<span class="tok-type">f32</span>, <span class="tok-number">5.15088629e-07</span>), c.im, tolerance_f32);</span>
<span class="line" id="L139"> }</span>
<span class="line" id="L140">}</span>
<span class="line" id="L141"></span>
<span class="line" id="L142"><span class="tok-kw">test</span> <span class="tok-str">"complex.cexp64"</span> {</span>
<span class="line" id="L143"> <span class="tok-kw">const</span> tolerance_f64 = <span class="tok-builtin">@sqrt</span>(math.floatEps(<span class="tok-type">f64</span>));</span>
<span class="line" id="L144"></span>
<span class="line" id="L145"> {</span>
<span class="line" id="L146"> <span class="tok-kw">const</span> a = Complex(<span class="tok-type">f64</span>).init(<span class="tok-number">5</span>, <span class="tok-number">3</span>);</span>
<span class="line" id="L147"> <span class="tok-kw">const</span> c = exp(a);</span>
<span class="line" id="L148"></span>
<span class="line" id="L149"> <span class="tok-kw">try</span> testing.expectApproxEqRel(<span class="tok-builtin">@as</span>(<span class="tok-type">f64</span>, -<span class="tok-number">1.469279139083189e+02</span>), c.re, tolerance_f64);</span>
<span class="line" id="L150"> <span class="tok-kw">try</span> testing.expectApproxEqRel(<span class="tok-builtin">@as</span>(<span class="tok-type">f64</span>, <span class="tok-number">2.094406620874596e+01</span>), c.im, tolerance_f64);</span>
<span class="line" id="L151"> }</span>
<span class="line" id="L152"></span>
<span class="line" id="L153"> {</span>
<span class="line" id="L154"> <span class="tok-kw">const</span> a = Complex(<span class="tok-type">f64</span>).init(<span class="tok-number">709.8</span>, <span class="tok-number">0x1p-1074</span>);</span>
<span class="line" id="L155"> <span class="tok-kw">const</span> c = exp(a);</span>
<span class="line" id="L156"></span>
<span class="line" id="L157"> <span class="tok-kw">try</span> testing.expectApproxEqAbs(math.inf(<span class="tok-type">f64</span>), c.re, tolerance_f64);</span>
<span class="line" id="L158"> <span class="tok-kw">try</span> testing.expectApproxEqAbs(<span class="tok-builtin">@as</span>(<span class="tok-type">f64</span>, <span class="tok-number">9.036659362159884e-16</span>), c.im, tolerance_f64);</span>
<span class="line" id="L159"> }</span>
<span class="line" id="L160">}</span>
<span class="line" id="L161"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std/math | repos/yazap/docs/src/std/math/complex/abs.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>math/complex/abs.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../../std.zig"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> testing = std.testing;</span>
<span class="line" id="L3"><span class="tok-kw">const</span> math = std.math;</span>
<span class="line" id="L4"><span class="tok-kw">const</span> cmath = math.complex;</span>
<span class="line" id="L5"><span class="tok-kw">const</span> Complex = cmath.Complex;</span>
<span class="line" id="L6"></span>
<span class="line" id="L7"><span class="tok-comment">/// Returns the absolute value (modulus) of z.</span></span>
<span class="line" id="L8"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">abs</span>(z: <span class="tok-kw">anytype</span>) <span class="tok-builtin">@TypeOf</span>(z.re) {</span>
<span class="line" id="L9"> <span class="tok-kw">const</span> T = <span class="tok-builtin">@TypeOf</span>(z.re);</span>
<span class="line" id="L10"> <span class="tok-kw">return</span> math.hypot(T, z.re, z.im);</span>
<span class="line" id="L11">}</span>
<span class="line" id="L12"></span>
<span class="line" id="L13"><span class="tok-kw">const</span> epsilon = <span class="tok-number">0.0001</span>;</span>
<span class="line" id="L14"></span>
<span class="line" id="L15"><span class="tok-kw">test</span> <span class="tok-str">"complex.cabs"</span> {</span>
<span class="line" id="L16"> <span class="tok-kw">const</span> a = Complex(<span class="tok-type">f32</span>).init(<span class="tok-number">5</span>, <span class="tok-number">3</span>);</span>
<span class="line" id="L17"> <span class="tok-kw">const</span> c = abs(a);</span>
<span class="line" id="L18"> <span class="tok-kw">try</span> testing.expect(math.approxEqAbs(<span class="tok-type">f32</span>, c, <span class="tok-number">5.83095</span>, epsilon));</span>
<span class="line" id="L19">}</span>
<span class="line" id="L20"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std/math | repos/yazap/docs/src/std/math/complex/conj.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>math/complex/conj.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../../std.zig"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> testing = std.testing;</span>
<span class="line" id="L3"><span class="tok-kw">const</span> math = std.math;</span>
<span class="line" id="L4"><span class="tok-kw">const</span> cmath = math.complex;</span>
<span class="line" id="L5"><span class="tok-kw">const</span> Complex = cmath.Complex;</span>
<span class="line" id="L6"></span>
<span class="line" id="L7"><span class="tok-comment">/// Returns the complex conjugate of z.</span></span>
<span class="line" id="L8"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">conj</span>(z: <span class="tok-kw">anytype</span>) Complex(<span class="tok-builtin">@TypeOf</span>(z.re)) {</span>
<span class="line" id="L9"> <span class="tok-kw">const</span> T = <span class="tok-builtin">@TypeOf</span>(z.re);</span>
<span class="line" id="L10"> <span class="tok-kw">return</span> Complex(T).init(z.re, -z.im);</span>
<span class="line" id="L11">}</span>
<span class="line" id="L12"></span>
<span class="line" id="L13"><span class="tok-kw">test</span> <span class="tok-str">"complex.conj"</span> {</span>
<span class="line" id="L14"> <span class="tok-kw">const</span> a = Complex(<span class="tok-type">f32</span>).init(<span class="tok-number">5</span>, <span class="tok-number">3</span>);</span>
<span class="line" id="L15"> <span class="tok-kw">const</span> c = a.conjugate();</span>
<span class="line" id="L16"></span>
<span class="line" id="L17"> <span class="tok-kw">try</span> testing.expect(c.re == <span class="tok-number">5</span> <span class="tok-kw">and</span> c.im == -<span class="tok-number">3</span>);</span>
<span class="line" id="L18">}</span>
<span class="line" id="L19"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std/math | repos/yazap/docs/src/std/math/complex/acos.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>math/complex/acos.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../../std.zig"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> testing = std.testing;</span>
<span class="line" id="L3"><span class="tok-kw">const</span> math = std.math;</span>
<span class="line" id="L4"><span class="tok-kw">const</span> cmath = math.complex;</span>
<span class="line" id="L5"><span class="tok-kw">const</span> Complex = cmath.Complex;</span>
<span class="line" id="L6"></span>
<span class="line" id="L7"><span class="tok-comment">/// Returns the arc-cosine of z.</span></span>
<span class="line" id="L8"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">acos</span>(z: <span class="tok-kw">anytype</span>) Complex(<span class="tok-builtin">@TypeOf</span>(z.re)) {</span>
<span class="line" id="L9"> <span class="tok-kw">const</span> T = <span class="tok-builtin">@TypeOf</span>(z.re);</span>
<span class="line" id="L10"> <span class="tok-kw">const</span> q = cmath.asin(z);</span>
<span class="line" id="L11"> <span class="tok-kw">return</span> Complex(T).init(<span class="tok-builtin">@as</span>(T, math.pi) / <span class="tok-number">2</span> - q.re, -q.im);</span>
<span class="line" id="L12">}</span>
<span class="line" id="L13"></span>
<span class="line" id="L14"><span class="tok-kw">const</span> epsilon = <span class="tok-number">0.0001</span>;</span>
<span class="line" id="L15"></span>
<span class="line" id="L16"><span class="tok-kw">test</span> <span class="tok-str">"complex.cacos"</span> {</span>
<span class="line" id="L17"> <span class="tok-kw">const</span> a = Complex(<span class="tok-type">f32</span>).init(<span class="tok-number">5</span>, <span class="tok-number">3</span>);</span>
<span class="line" id="L18"> <span class="tok-kw">const</span> c = acos(a);</span>
<span class="line" id="L19"></span>
<span class="line" id="L20"> <span class="tok-kw">try</span> testing.expect(math.approxEqAbs(<span class="tok-type">f32</span>, c.re, <span class="tok-number">0.546975</span>, epsilon));</span>
<span class="line" id="L21"> <span class="tok-kw">try</span> testing.expect(math.approxEqAbs(<span class="tok-type">f32</span>, c.im, -<span class="tok-number">2.452914</span>, epsilon));</span>
<span class="line" id="L22">}</span>
<span class="line" id="L23"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std/math | repos/yazap/docs/src/std/math/complex/sqrt.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>math/complex/sqrt.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-comment">// Ported from musl, which is licensed under the MIT license:</span>
</span>
<span class="line" id="L2"><span class="tok-comment">// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT</span>
</span>
<span class="line" id="L3"><span class="tok-comment">//</span>
</span>
<span class="line" id="L4"><span class="tok-comment">// https://git.musl-libc.org/cgit/musl/tree/src/complex/csqrtf.c</span>
</span>
<span class="line" id="L5"><span class="tok-comment">// https://git.musl-libc.org/cgit/musl/tree/src/complex/csqrt.c</span>
</span>
<span class="line" id="L6"></span>
<span class="line" id="L7"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../../std.zig"</span>);</span>
<span class="line" id="L8"><span class="tok-kw">const</span> testing = std.testing;</span>
<span class="line" id="L9"><span class="tok-kw">const</span> math = std.math;</span>
<span class="line" id="L10"><span class="tok-kw">const</span> cmath = math.complex;</span>
<span class="line" id="L11"><span class="tok-kw">const</span> Complex = cmath.Complex;</span>
<span class="line" id="L12"></span>
<span class="line" id="L13"><span class="tok-comment">/// Returns the square root of z. The real and imaginary parts of the result have the same sign</span></span>
<span class="line" id="L14"><span class="tok-comment">/// as the imaginary part of z.</span></span>
<span class="line" id="L15"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">sqrt</span>(z: <span class="tok-kw">anytype</span>) <span class="tok-builtin">@TypeOf</span>(z) {</span>
<span class="line" id="L16"> <span class="tok-kw">const</span> T = <span class="tok-builtin">@TypeOf</span>(z.re);</span>
<span class="line" id="L17"></span>
<span class="line" id="L18"> <span class="tok-kw">return</span> <span class="tok-kw">switch</span> (T) {</span>
<span class="line" id="L19"> <span class="tok-type">f32</span> => sqrt32(z),</span>
<span class="line" id="L20"> <span class="tok-type">f64</span> => sqrt64(z),</span>
<span class="line" id="L21"> <span class="tok-kw">else</span> => <span class="tok-builtin">@compileError</span>(<span class="tok-str">"sqrt not implemented for "</span> ++ <span class="tok-builtin">@typeName</span>(T)),</span>
<span class="line" id="L22"> };</span>
<span class="line" id="L23">}</span>
<span class="line" id="L24"></span>
<span class="line" id="L25"><span class="tok-kw">fn</span> <span class="tok-fn">sqrt32</span>(z: Complex(<span class="tok-type">f32</span>)) Complex(<span class="tok-type">f32</span>) {</span>
<span class="line" id="L26"> <span class="tok-kw">const</span> x = z.re;</span>
<span class="line" id="L27"> <span class="tok-kw">const</span> y = z.im;</span>
<span class="line" id="L28"></span>
<span class="line" id="L29"> <span class="tok-kw">if</span> (x == <span class="tok-number">0</span> <span class="tok-kw">and</span> y == <span class="tok-number">0</span>) {</span>
<span class="line" id="L30"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f32</span>).init(<span class="tok-number">0</span>, y);</span>
<span class="line" id="L31"> }</span>
<span class="line" id="L32"> <span class="tok-kw">if</span> (math.isInf(y)) {</span>
<span class="line" id="L33"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f32</span>).init(math.inf(<span class="tok-type">f32</span>), y);</span>
<span class="line" id="L34"> }</span>
<span class="line" id="L35"> <span class="tok-kw">if</span> (math.isNan(x)) {</span>
<span class="line" id="L36"> <span class="tok-comment">// raise invalid if y is not nan</span>
</span>
<span class="line" id="L37"> <span class="tok-kw">const</span> t = (y - y) / (y - y);</span>
<span class="line" id="L38"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f32</span>).init(x, t);</span>
<span class="line" id="L39"> }</span>
<span class="line" id="L40"> <span class="tok-kw">if</span> (math.isInf(x)) {</span>
<span class="line" id="L41"> <span class="tok-comment">// sqrt(inf + i nan) = inf + nan i</span>
</span>
<span class="line" id="L42"> <span class="tok-comment">// sqrt(inf + iy) = inf + i0</span>
</span>
<span class="line" id="L43"> <span class="tok-comment">// sqrt(-inf + i nan) = nan +- inf i</span>
</span>
<span class="line" id="L44"> <span class="tok-comment">// sqrt(-inf + iy) = 0 + inf i</span>
</span>
<span class="line" id="L45"> <span class="tok-kw">if</span> (math.signbit(x)) {</span>
<span class="line" id="L46"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f32</span>).init(<span class="tok-builtin">@fabs</span>(x - y), math.copysign(x, y));</span>
<span class="line" id="L47"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L48"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f32</span>).init(x, math.copysign(y - y, y));</span>
<span class="line" id="L49"> }</span>
<span class="line" id="L50"> }</span>
<span class="line" id="L51"></span>
<span class="line" id="L52"> <span class="tok-comment">// y = nan special case is handled fine below</span>
</span>
<span class="line" id="L53"></span>
<span class="line" id="L54"> <span class="tok-comment">// double-precision avoids overflow with correct rounding.</span>
</span>
<span class="line" id="L55"> <span class="tok-kw">const</span> dx = <span class="tok-builtin">@as</span>(<span class="tok-type">f64</span>, x);</span>
<span class="line" id="L56"> <span class="tok-kw">const</span> dy = <span class="tok-builtin">@as</span>(<span class="tok-type">f64</span>, y);</span>
<span class="line" id="L57"></span>
<span class="line" id="L58"> <span class="tok-kw">if</span> (dx >= <span class="tok-number">0</span>) {</span>
<span class="line" id="L59"> <span class="tok-kw">const</span> t = <span class="tok-builtin">@sqrt</span>((dx + math.hypot(<span class="tok-type">f64</span>, dx, dy)) * <span class="tok-number">0.5</span>);</span>
<span class="line" id="L60"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f32</span>).init(</span>
<span class="line" id="L61"> <span class="tok-builtin">@as</span>(<span class="tok-type">f32</span>, <span class="tok-builtin">@floatCast</span>(t)),</span>
<span class="line" id="L62"> <span class="tok-builtin">@as</span>(<span class="tok-type">f32</span>, <span class="tok-builtin">@floatCast</span>(dy / (<span class="tok-number">2.0</span> * t))),</span>
<span class="line" id="L63"> );</span>
<span class="line" id="L64"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L65"> <span class="tok-kw">const</span> t = <span class="tok-builtin">@sqrt</span>((-dx + math.hypot(<span class="tok-type">f64</span>, dx, dy)) * <span class="tok-number">0.5</span>);</span>
<span class="line" id="L66"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f32</span>).init(</span>
<span class="line" id="L67"> <span class="tok-builtin">@as</span>(<span class="tok-type">f32</span>, <span class="tok-builtin">@floatCast</span>(<span class="tok-builtin">@fabs</span>(y) / (<span class="tok-number">2.0</span> * t))),</span>
<span class="line" id="L68"> <span class="tok-builtin">@as</span>(<span class="tok-type">f32</span>, <span class="tok-builtin">@floatCast</span>(math.copysign(t, y))),</span>
<span class="line" id="L69"> );</span>
<span class="line" id="L70"> }</span>
<span class="line" id="L71">}</span>
<span class="line" id="L72"></span>
<span class="line" id="L73"><span class="tok-kw">fn</span> <span class="tok-fn">sqrt64</span>(z: Complex(<span class="tok-type">f64</span>)) Complex(<span class="tok-type">f64</span>) {</span>
<span class="line" id="L74"> <span class="tok-comment">// may encounter overflow for im,re >= DBL_MAX / (1 + sqrt(2))</span>
</span>
<span class="line" id="L75"> <span class="tok-kw">const</span> threshold = <span class="tok-number">0x1.a827999fcef32p+1022</span>;</span>
<span class="line" id="L76"></span>
<span class="line" id="L77"> <span class="tok-kw">var</span> x = z.re;</span>
<span class="line" id="L78"> <span class="tok-kw">var</span> y = z.im;</span>
<span class="line" id="L79"></span>
<span class="line" id="L80"> <span class="tok-kw">if</span> (x == <span class="tok-number">0</span> <span class="tok-kw">and</span> y == <span class="tok-number">0</span>) {</span>
<span class="line" id="L81"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f64</span>).init(<span class="tok-number">0</span>, y);</span>
<span class="line" id="L82"> }</span>
<span class="line" id="L83"> <span class="tok-kw">if</span> (math.isInf(y)) {</span>
<span class="line" id="L84"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f64</span>).init(math.inf(<span class="tok-type">f64</span>), y);</span>
<span class="line" id="L85"> }</span>
<span class="line" id="L86"> <span class="tok-kw">if</span> (math.isNan(x)) {</span>
<span class="line" id="L87"> <span class="tok-comment">// raise invalid if y is not nan</span>
</span>
<span class="line" id="L88"> <span class="tok-kw">const</span> t = (y - y) / (y - y);</span>
<span class="line" id="L89"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f64</span>).init(x, t);</span>
<span class="line" id="L90"> }</span>
<span class="line" id="L91"> <span class="tok-kw">if</span> (math.isInf(x)) {</span>
<span class="line" id="L92"> <span class="tok-comment">// sqrt(inf + i nan) = inf + nan i</span>
</span>
<span class="line" id="L93"> <span class="tok-comment">// sqrt(inf + iy) = inf + i0</span>
</span>
<span class="line" id="L94"> <span class="tok-comment">// sqrt(-inf + i nan) = nan +- inf i</span>
</span>
<span class="line" id="L95"> <span class="tok-comment">// sqrt(-inf + iy) = 0 + inf i</span>
</span>
<span class="line" id="L96"> <span class="tok-kw">if</span> (math.signbit(x)) {</span>
<span class="line" id="L97"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f64</span>).init(<span class="tok-builtin">@fabs</span>(x - y), math.copysign(x, y));</span>
<span class="line" id="L98"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L99"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f64</span>).init(x, math.copysign(y - y, y));</span>
<span class="line" id="L100"> }</span>
<span class="line" id="L101"> }</span>
<span class="line" id="L102"></span>
<span class="line" id="L103"> <span class="tok-comment">// y = nan special case is handled fine below</span>
</span>
<span class="line" id="L104"></span>
<span class="line" id="L105"> <span class="tok-comment">// scale to avoid overflow</span>
</span>
<span class="line" id="L106"> <span class="tok-kw">var</span> scale = <span class="tok-null">false</span>;</span>
<span class="line" id="L107"> <span class="tok-kw">if</span> (<span class="tok-builtin">@fabs</span>(x) >= threshold <span class="tok-kw">or</span> <span class="tok-builtin">@fabs</span>(y) >= threshold) {</span>
<span class="line" id="L108"> x *= <span class="tok-number">0.25</span>;</span>
<span class="line" id="L109"> y *= <span class="tok-number">0.25</span>;</span>
<span class="line" id="L110"> scale = <span class="tok-null">true</span>;</span>
<span class="line" id="L111"> }</span>
<span class="line" id="L112"></span>
<span class="line" id="L113"> <span class="tok-kw">var</span> result: Complex(<span class="tok-type">f64</span>) = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L114"> <span class="tok-kw">if</span> (x >= <span class="tok-number">0</span>) {</span>
<span class="line" id="L115"> <span class="tok-kw">const</span> t = <span class="tok-builtin">@sqrt</span>((x + math.hypot(<span class="tok-type">f64</span>, x, y)) * <span class="tok-number">0.5</span>);</span>
<span class="line" id="L116"> result = Complex(<span class="tok-type">f64</span>).init(t, y / (<span class="tok-number">2.0</span> * t));</span>
<span class="line" id="L117"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L118"> <span class="tok-kw">const</span> t = <span class="tok-builtin">@sqrt</span>((-x + math.hypot(<span class="tok-type">f64</span>, x, y)) * <span class="tok-number">0.5</span>);</span>
<span class="line" id="L119"> result = Complex(<span class="tok-type">f64</span>).init(<span class="tok-builtin">@fabs</span>(y) / (<span class="tok-number">2.0</span> * t), math.copysign(t, y));</span>
<span class="line" id="L120"> }</span>
<span class="line" id="L121"></span>
<span class="line" id="L122"> <span class="tok-kw">if</span> (scale) {</span>
<span class="line" id="L123"> result.re *= <span class="tok-number">2</span>;</span>
<span class="line" id="L124"> result.im *= <span class="tok-number">2</span>;</span>
<span class="line" id="L125"> }</span>
<span class="line" id="L126"></span>
<span class="line" id="L127"> <span class="tok-kw">return</span> result;</span>
<span class="line" id="L128">}</span>
<span class="line" id="L129"></span>
<span class="line" id="L130"><span class="tok-kw">const</span> epsilon = <span class="tok-number">0.0001</span>;</span>
<span class="line" id="L131"></span>
<span class="line" id="L132"><span class="tok-kw">test</span> <span class="tok-str">"complex.csqrt32"</span> {</span>
<span class="line" id="L133"> <span class="tok-kw">const</span> a = Complex(<span class="tok-type">f32</span>).init(<span class="tok-number">5</span>, <span class="tok-number">3</span>);</span>
<span class="line" id="L134"> <span class="tok-kw">const</span> c = sqrt(a);</span>
<span class="line" id="L135"></span>
<span class="line" id="L136"> <span class="tok-kw">try</span> testing.expect(math.approxEqAbs(<span class="tok-type">f32</span>, c.re, <span class="tok-number">2.327117</span>, epsilon));</span>
<span class="line" id="L137"> <span class="tok-kw">try</span> testing.expect(math.approxEqAbs(<span class="tok-type">f32</span>, c.im, <span class="tok-number">0.644574</span>, epsilon));</span>
<span class="line" id="L138">}</span>
<span class="line" id="L139"></span>
<span class="line" id="L140"><span class="tok-kw">test</span> <span class="tok-str">"complex.csqrt64"</span> {</span>
<span class="line" id="L141"> <span class="tok-kw">const</span> a = Complex(<span class="tok-type">f64</span>).init(<span class="tok-number">5</span>, <span class="tok-number">3</span>);</span>
<span class="line" id="L142"> <span class="tok-kw">const</span> c = sqrt(a);</span>
<span class="line" id="L143"></span>
<span class="line" id="L144"> <span class="tok-kw">try</span> testing.expect(math.approxEqAbs(<span class="tok-type">f64</span>, c.re, <span class="tok-number">2.3271175190399496</span>, epsilon));</span>
<span class="line" id="L145"> <span class="tok-kw">try</span> testing.expect(math.approxEqAbs(<span class="tok-type">f64</span>, c.im, <span class="tok-number">0.6445742373246469</span>, epsilon));</span>
<span class="line" id="L146">}</span>
<span class="line" id="L147"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std/math | repos/yazap/docs/src/std/math/complex/pow.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>math/complex/pow.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../../std.zig"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> testing = std.testing;</span>
<span class="line" id="L3"><span class="tok-kw">const</span> math = std.math;</span>
<span class="line" id="L4"><span class="tok-kw">const</span> cmath = math.complex;</span>
<span class="line" id="L5"><span class="tok-kw">const</span> Complex = cmath.Complex;</span>
<span class="line" id="L6"></span>
<span class="line" id="L7"><span class="tok-comment">/// Returns z raised to the complex power of c.</span></span>
<span class="line" id="L8"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">pow</span>(<span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>, z: T, c: T) T {</span>
<span class="line" id="L9"> <span class="tok-kw">const</span> p = cmath.log(z);</span>
<span class="line" id="L10"> <span class="tok-kw">const</span> q = c.mul(p);</span>
<span class="line" id="L11"> <span class="tok-kw">return</span> cmath.exp(q);</span>
<span class="line" id="L12">}</span>
<span class="line" id="L13"></span>
<span class="line" id="L14"><span class="tok-kw">const</span> epsilon = <span class="tok-number">0.0001</span>;</span>
<span class="line" id="L15"></span>
<span class="line" id="L16"><span class="tok-kw">test</span> <span class="tok-str">"complex.cpow"</span> {</span>
<span class="line" id="L17"> <span class="tok-kw">const</span> a = Complex(<span class="tok-type">f32</span>).init(<span class="tok-number">5</span>, <span class="tok-number">3</span>);</span>
<span class="line" id="L18"> <span class="tok-kw">const</span> b = Complex(<span class="tok-type">f32</span>).init(<span class="tok-number">2.3</span>, -<span class="tok-number">1.3</span>);</span>
<span class="line" id="L19"> <span class="tok-kw">const</span> c = pow(Complex(<span class="tok-type">f32</span>), a, b);</span>
<span class="line" id="L20"></span>
<span class="line" id="L21"> <span class="tok-kw">try</span> testing.expect(math.approxEqAbs(<span class="tok-type">f32</span>, c.re, <span class="tok-number">58.049110</span>, epsilon));</span>
<span class="line" id="L22"> <span class="tok-kw">try</span> testing.expect(math.approxEqAbs(<span class="tok-type">f32</span>, c.im, -<span class="tok-number">101.003433</span>, epsilon));</span>
<span class="line" id="L23">}</span>
<span class="line" id="L24"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std/math | repos/yazap/docs/src/std/math/complex/ldexp.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>math/complex/ldexp.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-comment">// Ported from musl, which is licensed under the MIT license:</span>
</span>
<span class="line" id="L2"><span class="tok-comment">// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT</span>
</span>
<span class="line" id="L3"><span class="tok-comment">//</span>
</span>
<span class="line" id="L4"><span class="tok-comment">// https://git.musl-libc.org/cgit/musl/tree/src/complex/__cexpf.c</span>
</span>
<span class="line" id="L5"><span class="tok-comment">// https://git.musl-libc.org/cgit/musl/tree/src/complex/__cexp.c</span>
</span>
<span class="line" id="L6"></span>
<span class="line" id="L7"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../../std.zig"</span>);</span>
<span class="line" id="L8"><span class="tok-kw">const</span> debug = std.debug;</span>
<span class="line" id="L9"><span class="tok-kw">const</span> math = std.math;</span>
<span class="line" id="L10"><span class="tok-kw">const</span> testing = std.testing;</span>
<span class="line" id="L11"><span class="tok-kw">const</span> cmath = math.complex;</span>
<span class="line" id="L12"><span class="tok-kw">const</span> Complex = cmath.Complex;</span>
<span class="line" id="L13"></span>
<span class="line" id="L14"><span class="tok-comment">/// Returns exp(z) scaled to avoid overflow.</span></span>
<span class="line" id="L15"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">ldexp_cexp</span>(z: <span class="tok-kw">anytype</span>, expt: <span class="tok-type">i32</span>) <span class="tok-builtin">@TypeOf</span>(z) {</span>
<span class="line" id="L16"> <span class="tok-kw">const</span> T = <span class="tok-builtin">@TypeOf</span>(z.re);</span>
<span class="line" id="L17"></span>
<span class="line" id="L18"> <span class="tok-kw">return</span> <span class="tok-kw">switch</span> (T) {</span>
<span class="line" id="L19"> <span class="tok-type">f32</span> => ldexp_cexp32(z, expt),</span>
<span class="line" id="L20"> <span class="tok-type">f64</span> => ldexp_cexp64(z, expt),</span>
<span class="line" id="L21"> <span class="tok-kw">else</span> => <span class="tok-kw">unreachable</span>,</span>
<span class="line" id="L22"> };</span>
<span class="line" id="L23">}</span>
<span class="line" id="L24"></span>
<span class="line" id="L25"><span class="tok-kw">fn</span> <span class="tok-fn">frexp_exp32</span>(x: <span class="tok-type">f32</span>, expt: *<span class="tok-type">i32</span>) <span class="tok-type">f32</span> {</span>
<span class="line" id="L26"> <span class="tok-kw">const</span> k = <span class="tok-number">235</span>; <span class="tok-comment">// reduction constant</span>
</span>
<span class="line" id="L27"> <span class="tok-kw">const</span> kln2 = <span class="tok-number">162.88958740</span>; <span class="tok-comment">// k * ln2</span>
</span>
<span class="line" id="L28"></span>
<span class="line" id="L29"> <span class="tok-kw">const</span> exp_x = <span class="tok-builtin">@exp</span>(x - kln2);</span>
<span class="line" id="L30"> <span class="tok-kw">const</span> hx = <span class="tok-builtin">@as</span>(<span class="tok-type">u32</span>, <span class="tok-builtin">@bitCast</span>(exp_x));</span>
<span class="line" id="L31"> <span class="tok-comment">// TODO zig should allow this cast implicitly because it should know the value is in range</span>
</span>
<span class="line" id="L32"> expt.* = <span class="tok-builtin">@as</span>(<span class="tok-type">i32</span>, <span class="tok-builtin">@intCast</span>(hx >> <span class="tok-number">23</span>)) - (<span class="tok-number">0x7f</span> + <span class="tok-number">127</span>) + k;</span>
<span class="line" id="L33"> <span class="tok-kw">return</span> <span class="tok-builtin">@as</span>(<span class="tok-type">f32</span>, <span class="tok-builtin">@bitCast</span>((hx & <span class="tok-number">0x7fffff</span>) | ((<span class="tok-number">0x7f</span> + <span class="tok-number">127</span>) << <span class="tok-number">23</span>)));</span>
<span class="line" id="L34">}</span>
<span class="line" id="L35"></span>
<span class="line" id="L36"><span class="tok-kw">fn</span> <span class="tok-fn">ldexp_cexp32</span>(z: Complex(<span class="tok-type">f32</span>), expt: <span class="tok-type">i32</span>) Complex(<span class="tok-type">f32</span>) {</span>
<span class="line" id="L37"> <span class="tok-kw">var</span> ex_expt: <span class="tok-type">i32</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L38"> <span class="tok-kw">const</span> exp_x = frexp_exp32(z.re, &ex_expt);</span>
<span class="line" id="L39"> <span class="tok-kw">const</span> exptf = expt + ex_expt;</span>
<span class="line" id="L40"></span>
<span class="line" id="L41"> <span class="tok-kw">const</span> half_expt1 = <span class="tok-builtin">@divTrunc</span>(exptf, <span class="tok-number">2</span>);</span>
<span class="line" id="L42"> <span class="tok-kw">const</span> scale1 = <span class="tok-builtin">@as</span>(<span class="tok-type">f32</span>, <span class="tok-builtin">@bitCast</span>((<span class="tok-number">0x7f</span> + half_expt1) << <span class="tok-number">23</span>));</span>
<span class="line" id="L43"></span>
<span class="line" id="L44"> <span class="tok-kw">const</span> half_expt2 = exptf - half_expt1;</span>
<span class="line" id="L45"> <span class="tok-kw">const</span> scale2 = <span class="tok-builtin">@as</span>(<span class="tok-type">f32</span>, <span class="tok-builtin">@bitCast</span>((<span class="tok-number">0x7f</span> + half_expt2) << <span class="tok-number">23</span>));</span>
<span class="line" id="L46"></span>
<span class="line" id="L47"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f32</span>).init(</span>
<span class="line" id="L48"> <span class="tok-builtin">@cos</span>(z.im) * exp_x * scale1 * scale2,</span>
<span class="line" id="L49"> <span class="tok-builtin">@sin</span>(z.im) * exp_x * scale1 * scale2,</span>
<span class="line" id="L50"> );</span>
<span class="line" id="L51">}</span>
<span class="line" id="L52"></span>
<span class="line" id="L53"><span class="tok-kw">fn</span> <span class="tok-fn">frexp_exp64</span>(x: <span class="tok-type">f64</span>, expt: *<span class="tok-type">i32</span>) <span class="tok-type">f64</span> {</span>
<span class="line" id="L54"> <span class="tok-kw">const</span> k = <span class="tok-number">1799</span>; <span class="tok-comment">// reduction constant</span>
</span>
<span class="line" id="L55"> <span class="tok-kw">const</span> kln2 = <span class="tok-number">1246.97177782734161156</span>; <span class="tok-comment">// k * ln2</span>
</span>
<span class="line" id="L56"></span>
<span class="line" id="L57"> <span class="tok-kw">const</span> exp_x = <span class="tok-builtin">@exp</span>(x - kln2);</span>
<span class="line" id="L58"></span>
<span class="line" id="L59"> <span class="tok-kw">const</span> fx = <span class="tok-builtin">@as</span>(<span class="tok-type">u64</span>, <span class="tok-builtin">@bitCast</span>(exp_x));</span>
<span class="line" id="L60"> <span class="tok-kw">const</span> hx = <span class="tok-builtin">@as</span>(<span class="tok-type">u32</span>, <span class="tok-builtin">@intCast</span>(fx >> <span class="tok-number">32</span>));</span>
<span class="line" id="L61"> <span class="tok-kw">const</span> lx = <span class="tok-builtin">@as</span>(<span class="tok-type">u32</span>, <span class="tok-builtin">@truncate</span>(fx));</span>
<span class="line" id="L62"></span>
<span class="line" id="L63"> expt.* = <span class="tok-builtin">@as</span>(<span class="tok-type">i32</span>, <span class="tok-builtin">@intCast</span>(hx >> <span class="tok-number">20</span>)) - (<span class="tok-number">0x3ff</span> + <span class="tok-number">1023</span>) + k;</span>
<span class="line" id="L64"></span>
<span class="line" id="L65"> <span class="tok-kw">const</span> high_word = (hx & <span class="tok-number">0xfffff</span>) | ((<span class="tok-number">0x3ff</span> + <span class="tok-number">1023</span>) << <span class="tok-number">20</span>);</span>
<span class="line" id="L66"> <span class="tok-kw">return</span> <span class="tok-builtin">@as</span>(<span class="tok-type">f64</span>, <span class="tok-builtin">@bitCast</span>((<span class="tok-builtin">@as</span>(<span class="tok-type">u64</span>, high_word) << <span class="tok-number">32</span>) | lx));</span>
<span class="line" id="L67">}</span>
<span class="line" id="L68"></span>
<span class="line" id="L69"><span class="tok-kw">fn</span> <span class="tok-fn">ldexp_cexp64</span>(z: Complex(<span class="tok-type">f64</span>), expt: <span class="tok-type">i32</span>) Complex(<span class="tok-type">f64</span>) {</span>
<span class="line" id="L70"> <span class="tok-kw">var</span> ex_expt: <span class="tok-type">i32</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L71"> <span class="tok-kw">const</span> exp_x = frexp_exp64(z.re, &ex_expt);</span>
<span class="line" id="L72"> <span class="tok-kw">const</span> exptf = <span class="tok-builtin">@as</span>(<span class="tok-type">i64</span>, expt + ex_expt);</span>
<span class="line" id="L73"></span>
<span class="line" id="L74"> <span class="tok-kw">const</span> half_expt1 = <span class="tok-builtin">@divTrunc</span>(exptf, <span class="tok-number">2</span>);</span>
<span class="line" id="L75"> <span class="tok-kw">const</span> scale1 = <span class="tok-builtin">@as</span>(<span class="tok-type">f64</span>, <span class="tok-builtin">@bitCast</span>((<span class="tok-number">0x3ff</span> + half_expt1) << (<span class="tok-number">20</span> + <span class="tok-number">32</span>)));</span>
<span class="line" id="L76"></span>
<span class="line" id="L77"> <span class="tok-kw">const</span> half_expt2 = exptf - half_expt1;</span>
<span class="line" id="L78"> <span class="tok-kw">const</span> scale2 = <span class="tok-builtin">@as</span>(<span class="tok-type">f64</span>, <span class="tok-builtin">@bitCast</span>((<span class="tok-number">0x3ff</span> + half_expt2) << (<span class="tok-number">20</span> + <span class="tok-number">32</span>)));</span>
<span class="line" id="L79"></span>
<span class="line" id="L80"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f64</span>).init(</span>
<span class="line" id="L81"> <span class="tok-builtin">@cos</span>(z.im) * exp_x * scale1 * scale2,</span>
<span class="line" id="L82"> <span class="tok-builtin">@sin</span>(z.im) * exp_x * scale1 * scale2,</span>
<span class="line" id="L83"> );</span>
<span class="line" id="L84">}</span>
<span class="line" id="L85"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std/math | repos/yazap/docs/src/std/math/complex/arg.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>math/complex/arg.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../../std.zig"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> testing = std.testing;</span>
<span class="line" id="L3"><span class="tok-kw">const</span> math = std.math;</span>
<span class="line" id="L4"><span class="tok-kw">const</span> cmath = math.complex;</span>
<span class="line" id="L5"><span class="tok-kw">const</span> Complex = cmath.Complex;</span>
<span class="line" id="L6"></span>
<span class="line" id="L7"><span class="tok-comment">/// Returns the angular component (in radians) of z.</span></span>
<span class="line" id="L8"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">arg</span>(z: <span class="tok-kw">anytype</span>) <span class="tok-builtin">@TypeOf</span>(z.re) {</span>
<span class="line" id="L9"> <span class="tok-kw">const</span> T = <span class="tok-builtin">@TypeOf</span>(z.re);</span>
<span class="line" id="L10"> <span class="tok-kw">return</span> math.atan2(T, z.im, z.re);</span>
<span class="line" id="L11">}</span>
<span class="line" id="L12"></span>
<span class="line" id="L13"><span class="tok-kw">const</span> epsilon = <span class="tok-number">0.0001</span>;</span>
<span class="line" id="L14"></span>
<span class="line" id="L15"><span class="tok-kw">test</span> <span class="tok-str">"complex.carg"</span> {</span>
<span class="line" id="L16"> <span class="tok-kw">const</span> a = Complex(<span class="tok-type">f32</span>).init(<span class="tok-number">5</span>, <span class="tok-number">3</span>);</span>
<span class="line" id="L17"> <span class="tok-kw">const</span> c = arg(a);</span>
<span class="line" id="L18"> <span class="tok-kw">try</span> testing.expect(math.approxEqAbs(<span class="tok-type">f32</span>, c, <span class="tok-number">0.540420</span>, epsilon));</span>
<span class="line" id="L19">}</span>
<span class="line" id="L20"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std/math | repos/yazap/docs/src/std/math/complex/asinh.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>math/complex/asinh.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../../std.zig"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> testing = std.testing;</span>
<span class="line" id="L3"><span class="tok-kw">const</span> math = std.math;</span>
<span class="line" id="L4"><span class="tok-kw">const</span> cmath = math.complex;</span>
<span class="line" id="L5"><span class="tok-kw">const</span> Complex = cmath.Complex;</span>
<span class="line" id="L6"></span>
<span class="line" id="L7"><span class="tok-comment">/// Returns the hyperbolic arc-sine of z.</span></span>
<span class="line" id="L8"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">asinh</span>(z: <span class="tok-kw">anytype</span>) Complex(<span class="tok-builtin">@TypeOf</span>(z.re)) {</span>
<span class="line" id="L9"> <span class="tok-kw">const</span> T = <span class="tok-builtin">@TypeOf</span>(z.re);</span>
<span class="line" id="L10"> <span class="tok-kw">const</span> q = Complex(T).init(-z.im, z.re);</span>
<span class="line" id="L11"> <span class="tok-kw">const</span> r = cmath.asin(q);</span>
<span class="line" id="L12"> <span class="tok-kw">return</span> Complex(T).init(r.im, -r.re);</span>
<span class="line" id="L13">}</span>
<span class="line" id="L14"></span>
<span class="line" id="L15"><span class="tok-kw">const</span> epsilon = <span class="tok-number">0.0001</span>;</span>
<span class="line" id="L16"></span>
<span class="line" id="L17"><span class="tok-kw">test</span> <span class="tok-str">"complex.casinh"</span> {</span>
<span class="line" id="L18"> <span class="tok-kw">const</span> a = Complex(<span class="tok-type">f32</span>).init(<span class="tok-number">5</span>, <span class="tok-number">3</span>);</span>
<span class="line" id="L19"> <span class="tok-kw">const</span> c = asinh(a);</span>
<span class="line" id="L20"></span>
<span class="line" id="L21"> <span class="tok-kw">try</span> testing.expect(math.approxEqAbs(<span class="tok-type">f32</span>, c.re, <span class="tok-number">2.459831</span>, epsilon));</span>
<span class="line" id="L22"> <span class="tok-kw">try</span> testing.expect(math.approxEqAbs(<span class="tok-type">f32</span>, c.im, <span class="tok-number">0.533999</span>, epsilon));</span>
<span class="line" id="L23">}</span>
<span class="line" id="L24"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std/math | repos/yazap/docs/src/std/math/complex/sin.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>math/complex/sin.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../../std.zig"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> testing = std.testing;</span>
<span class="line" id="L3"><span class="tok-kw">const</span> math = std.math;</span>
<span class="line" id="L4"><span class="tok-kw">const</span> cmath = math.complex;</span>
<span class="line" id="L5"><span class="tok-kw">const</span> Complex = cmath.Complex;</span>
<span class="line" id="L6"></span>
<span class="line" id="L7"><span class="tok-comment">/// Returns the sine of z.</span></span>
<span class="line" id="L8"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">sin</span>(z: <span class="tok-kw">anytype</span>) Complex(<span class="tok-builtin">@TypeOf</span>(z.re)) {</span>
<span class="line" id="L9"> <span class="tok-kw">const</span> T = <span class="tok-builtin">@TypeOf</span>(z.re);</span>
<span class="line" id="L10"> <span class="tok-kw">const</span> p = Complex(T).init(-z.im, z.re);</span>
<span class="line" id="L11"> <span class="tok-kw">const</span> q = cmath.sinh(p);</span>
<span class="line" id="L12"> <span class="tok-kw">return</span> Complex(T).init(q.im, -q.re);</span>
<span class="line" id="L13">}</span>
<span class="line" id="L14"></span>
<span class="line" id="L15"><span class="tok-kw">const</span> epsilon = <span class="tok-number">0.0001</span>;</span>
<span class="line" id="L16"></span>
<span class="line" id="L17"><span class="tok-kw">test</span> <span class="tok-str">"complex.csin"</span> {</span>
<span class="line" id="L18"> <span class="tok-kw">const</span> a = Complex(<span class="tok-type">f32</span>).init(<span class="tok-number">5</span>, <span class="tok-number">3</span>);</span>
<span class="line" id="L19"> <span class="tok-kw">const</span> c = sin(a);</span>
<span class="line" id="L20"></span>
<span class="line" id="L21"> <span class="tok-kw">try</span> testing.expect(math.approxEqAbs(<span class="tok-type">f32</span>, c.re, -<span class="tok-number">9.654126</span>, epsilon));</span>
<span class="line" id="L22"> <span class="tok-kw">try</span> testing.expect(math.approxEqAbs(<span class="tok-type">f32</span>, c.im, <span class="tok-number">2.841692</span>, epsilon));</span>
<span class="line" id="L23">}</span>
<span class="line" id="L24"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std/math | repos/yazap/docs/src/std/math/complex/acosh.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>math/complex/acosh.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../../std.zig"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> testing = std.testing;</span>
<span class="line" id="L3"><span class="tok-kw">const</span> math = std.math;</span>
<span class="line" id="L4"><span class="tok-kw">const</span> cmath = math.complex;</span>
<span class="line" id="L5"><span class="tok-kw">const</span> Complex = cmath.Complex;</span>
<span class="line" id="L6"></span>
<span class="line" id="L7"><span class="tok-comment">/// Returns the hyperbolic arc-cosine of z.</span></span>
<span class="line" id="L8"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">acosh</span>(z: <span class="tok-kw">anytype</span>) Complex(<span class="tok-builtin">@TypeOf</span>(z.re)) {</span>
<span class="line" id="L9"> <span class="tok-kw">const</span> T = <span class="tok-builtin">@TypeOf</span>(z.re);</span>
<span class="line" id="L10"> <span class="tok-kw">const</span> q = cmath.acos(z);</span>
<span class="line" id="L11"> <span class="tok-kw">return</span> Complex(T).init(-q.im, q.re);</span>
<span class="line" id="L12">}</span>
<span class="line" id="L13"></span>
<span class="line" id="L14"><span class="tok-kw">const</span> epsilon = <span class="tok-number">0.0001</span>;</span>
<span class="line" id="L15"></span>
<span class="line" id="L16"><span class="tok-kw">test</span> <span class="tok-str">"complex.cacosh"</span> {</span>
<span class="line" id="L17"> <span class="tok-kw">const</span> a = Complex(<span class="tok-type">f32</span>).init(<span class="tok-number">5</span>, <span class="tok-number">3</span>);</span>
<span class="line" id="L18"> <span class="tok-kw">const</span> c = acosh(a);</span>
<span class="line" id="L19"></span>
<span class="line" id="L20"> <span class="tok-kw">try</span> testing.expect(math.approxEqAbs(<span class="tok-type">f32</span>, c.re, <span class="tok-number">2.452914</span>, epsilon));</span>
<span class="line" id="L21"> <span class="tok-kw">try</span> testing.expect(math.approxEqAbs(<span class="tok-type">f32</span>, c.im, <span class="tok-number">0.546975</span>, epsilon));</span>
<span class="line" id="L22">}</span>
<span class="line" id="L23"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std/math | repos/yazap/docs/src/std/math/complex/atan.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>math/complex/atan.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-comment">// Ported from musl, which is licensed under the MIT license:</span>
</span>
<span class="line" id="L2"><span class="tok-comment">// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT</span>
</span>
<span class="line" id="L3"><span class="tok-comment">//</span>
</span>
<span class="line" id="L4"><span class="tok-comment">// https://git.musl-libc.org/cgit/musl/tree/src/complex/catanf.c</span>
</span>
<span class="line" id="L5"><span class="tok-comment">// https://git.musl-libc.org/cgit/musl/tree/src/complex/catan.c</span>
</span>
<span class="line" id="L6"></span>
<span class="line" id="L7"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../../std.zig"</span>);</span>
<span class="line" id="L8"><span class="tok-kw">const</span> testing = std.testing;</span>
<span class="line" id="L9"><span class="tok-kw">const</span> math = std.math;</span>
<span class="line" id="L10"><span class="tok-kw">const</span> cmath = math.complex;</span>
<span class="line" id="L11"><span class="tok-kw">const</span> Complex = cmath.Complex;</span>
<span class="line" id="L12"></span>
<span class="line" id="L13"><span class="tok-comment">/// Returns the arc-tangent of z.</span></span>
<span class="line" id="L14"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">atan</span>(z: <span class="tok-kw">anytype</span>) <span class="tok-builtin">@TypeOf</span>(z) {</span>
<span class="line" id="L15"> <span class="tok-kw">const</span> T = <span class="tok-builtin">@TypeOf</span>(z.re);</span>
<span class="line" id="L16"> <span class="tok-kw">return</span> <span class="tok-kw">switch</span> (T) {</span>
<span class="line" id="L17"> <span class="tok-type">f32</span> => atan32(z),</span>
<span class="line" id="L18"> <span class="tok-type">f64</span> => atan64(z),</span>
<span class="line" id="L19"> <span class="tok-kw">else</span> => <span class="tok-builtin">@compileError</span>(<span class="tok-str">"atan not implemented for "</span> ++ <span class="tok-builtin">@typeName</span>(z)),</span>
<span class="line" id="L20"> };</span>
<span class="line" id="L21">}</span>
<span class="line" id="L22"></span>
<span class="line" id="L23"><span class="tok-kw">fn</span> <span class="tok-fn">redupif32</span>(x: <span class="tok-type">f32</span>) <span class="tok-type">f32</span> {</span>
<span class="line" id="L24"> <span class="tok-kw">const</span> DP1 = <span class="tok-number">3.140625</span>;</span>
<span class="line" id="L25"> <span class="tok-kw">const</span> DP2 = <span class="tok-number">9.67502593994140625e-4</span>;</span>
<span class="line" id="L26"> <span class="tok-kw">const</span> DP3 = <span class="tok-number">1.509957990978376432e-7</span>;</span>
<span class="line" id="L27"></span>
<span class="line" id="L28"> <span class="tok-kw">var</span> t = x / math.pi;</span>
<span class="line" id="L29"> <span class="tok-kw">if</span> (t >= <span class="tok-number">0.0</span>) {</span>
<span class="line" id="L30"> t += <span class="tok-number">0.5</span>;</span>
<span class="line" id="L31"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L32"> t -= <span class="tok-number">0.5</span>;</span>
<span class="line" id="L33"> }</span>
<span class="line" id="L34"></span>
<span class="line" id="L35"> <span class="tok-kw">const</span> u = <span class="tok-builtin">@as</span>(<span class="tok-type">f32</span>, <span class="tok-builtin">@floatFromInt</span>(<span class="tok-builtin">@as</span>(<span class="tok-type">i32</span>, <span class="tok-builtin">@intFromFloat</span>(t))));</span>
<span class="line" id="L36"> <span class="tok-kw">return</span> ((x - u * DP1) - u * DP2) - t * DP3;</span>
<span class="line" id="L37">}</span>
<span class="line" id="L38"></span>
<span class="line" id="L39"><span class="tok-kw">fn</span> <span class="tok-fn">atan32</span>(z: Complex(<span class="tok-type">f32</span>)) Complex(<span class="tok-type">f32</span>) {</span>
<span class="line" id="L40"> <span class="tok-kw">const</span> maxnum = <span class="tok-number">1.0e38</span>;</span>
<span class="line" id="L41"></span>
<span class="line" id="L42"> <span class="tok-kw">const</span> x = z.re;</span>
<span class="line" id="L43"> <span class="tok-kw">const</span> y = z.im;</span>
<span class="line" id="L44"></span>
<span class="line" id="L45"> <span class="tok-kw">if</span> ((x == <span class="tok-number">0.0</span>) <span class="tok-kw">and</span> (y > <span class="tok-number">1.0</span>)) {</span>
<span class="line" id="L46"> <span class="tok-comment">// overflow</span>
</span>
<span class="line" id="L47"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f32</span>).init(maxnum, maxnum);</span>
<span class="line" id="L48"> }</span>
<span class="line" id="L49"></span>
<span class="line" id="L50"> <span class="tok-kw">const</span> x2 = x * x;</span>
<span class="line" id="L51"> <span class="tok-kw">var</span> a = <span class="tok-number">1.0</span> - x2 - (y * y);</span>
<span class="line" id="L52"> <span class="tok-kw">if</span> (a == <span class="tok-number">0.0</span>) {</span>
<span class="line" id="L53"> <span class="tok-comment">// overflow</span>
</span>
<span class="line" id="L54"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f32</span>).init(maxnum, maxnum);</span>
<span class="line" id="L55"> }</span>
<span class="line" id="L56"></span>
<span class="line" id="L57"> <span class="tok-kw">var</span> t = <span class="tok-number">0.5</span> * math.atan2(<span class="tok-type">f32</span>, <span class="tok-number">2.0</span> * x, a);</span>
<span class="line" id="L58"> <span class="tok-kw">var</span> w = redupif32(t);</span>
<span class="line" id="L59"></span>
<span class="line" id="L60"> t = y - <span class="tok-number">1.0</span>;</span>
<span class="line" id="L61"> a = x2 + t * t;</span>
<span class="line" id="L62"> <span class="tok-kw">if</span> (a == <span class="tok-number">0.0</span>) {</span>
<span class="line" id="L63"> <span class="tok-comment">// overflow</span>
</span>
<span class="line" id="L64"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f32</span>).init(maxnum, maxnum);</span>
<span class="line" id="L65"> }</span>
<span class="line" id="L66"></span>
<span class="line" id="L67"> t = y + <span class="tok-number">1.0</span>;</span>
<span class="line" id="L68"> a = (x2 + (t * t)) / a;</span>
<span class="line" id="L69"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f32</span>).init(w, <span class="tok-number">0.25</span> * <span class="tok-builtin">@log</span>(a));</span>
<span class="line" id="L70">}</span>
<span class="line" id="L71"></span>
<span class="line" id="L72"><span class="tok-kw">fn</span> <span class="tok-fn">redupif64</span>(x: <span class="tok-type">f64</span>) <span class="tok-type">f64</span> {</span>
<span class="line" id="L73"> <span class="tok-kw">const</span> DP1 = <span class="tok-number">3.14159265160560607910</span>;</span>
<span class="line" id="L74"> <span class="tok-kw">const</span> DP2 = <span class="tok-number">1.98418714791870343106e-9</span>;</span>
<span class="line" id="L75"> <span class="tok-kw">const</span> DP3 = <span class="tok-number">1.14423774522196636802e-17</span>;</span>
<span class="line" id="L76"></span>
<span class="line" id="L77"> <span class="tok-kw">var</span> t = x / math.pi;</span>
<span class="line" id="L78"> <span class="tok-kw">if</span> (t >= <span class="tok-number">0.0</span>) {</span>
<span class="line" id="L79"> t += <span class="tok-number">0.5</span>;</span>
<span class="line" id="L80"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L81"> t -= <span class="tok-number">0.5</span>;</span>
<span class="line" id="L82"> }</span>
<span class="line" id="L83"></span>
<span class="line" id="L84"> <span class="tok-kw">const</span> u = <span class="tok-builtin">@as</span>(<span class="tok-type">f64</span>, <span class="tok-builtin">@floatFromInt</span>(<span class="tok-builtin">@as</span>(<span class="tok-type">i64</span>, <span class="tok-builtin">@intFromFloat</span>(t))));</span>
<span class="line" id="L85"> <span class="tok-kw">return</span> ((x - u * DP1) - u * DP2) - t * DP3;</span>
<span class="line" id="L86">}</span>
<span class="line" id="L87"></span>
<span class="line" id="L88"><span class="tok-kw">fn</span> <span class="tok-fn">atan64</span>(z: Complex(<span class="tok-type">f64</span>)) Complex(<span class="tok-type">f64</span>) {</span>
<span class="line" id="L89"> <span class="tok-kw">const</span> maxnum = <span class="tok-number">1.0e308</span>;</span>
<span class="line" id="L90"></span>
<span class="line" id="L91"> <span class="tok-kw">const</span> x = z.re;</span>
<span class="line" id="L92"> <span class="tok-kw">const</span> y = z.im;</span>
<span class="line" id="L93"></span>
<span class="line" id="L94"> <span class="tok-kw">if</span> ((x == <span class="tok-number">0.0</span>) <span class="tok-kw">and</span> (y > <span class="tok-number">1.0</span>)) {</span>
<span class="line" id="L95"> <span class="tok-comment">// overflow</span>
</span>
<span class="line" id="L96"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f64</span>).init(maxnum, maxnum);</span>
<span class="line" id="L97"> }</span>
<span class="line" id="L98"></span>
<span class="line" id="L99"> <span class="tok-kw">const</span> x2 = x * x;</span>
<span class="line" id="L100"> <span class="tok-kw">var</span> a = <span class="tok-number">1.0</span> - x2 - (y * y);</span>
<span class="line" id="L101"> <span class="tok-kw">if</span> (a == <span class="tok-number">0.0</span>) {</span>
<span class="line" id="L102"> <span class="tok-comment">// overflow</span>
</span>
<span class="line" id="L103"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f64</span>).init(maxnum, maxnum);</span>
<span class="line" id="L104"> }</span>
<span class="line" id="L105"></span>
<span class="line" id="L106"> <span class="tok-kw">var</span> t = <span class="tok-number">0.5</span> * math.atan2(<span class="tok-type">f64</span>, <span class="tok-number">2.0</span> * x, a);</span>
<span class="line" id="L107"> <span class="tok-kw">var</span> w = redupif64(t);</span>
<span class="line" id="L108"></span>
<span class="line" id="L109"> t = y - <span class="tok-number">1.0</span>;</span>
<span class="line" id="L110"> a = x2 + t * t;</span>
<span class="line" id="L111"> <span class="tok-kw">if</span> (a == <span class="tok-number">0.0</span>) {</span>
<span class="line" id="L112"> <span class="tok-comment">// overflow</span>
</span>
<span class="line" id="L113"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f64</span>).init(maxnum, maxnum);</span>
<span class="line" id="L114"> }</span>
<span class="line" id="L115"></span>
<span class="line" id="L116"> t = y + <span class="tok-number">1.0</span>;</span>
<span class="line" id="L117"> a = (x2 + (t * t)) / a;</span>
<span class="line" id="L118"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f64</span>).init(w, <span class="tok-number">0.25</span> * <span class="tok-builtin">@log</span>(a));</span>
<span class="line" id="L119">}</span>
<span class="line" id="L120"></span>
<span class="line" id="L121"><span class="tok-kw">const</span> epsilon = <span class="tok-number">0.0001</span>;</span>
<span class="line" id="L122"></span>
<span class="line" id="L123"><span class="tok-kw">test</span> <span class="tok-str">"complex.catan32"</span> {</span>
<span class="line" id="L124"> <span class="tok-kw">const</span> a = Complex(<span class="tok-type">f32</span>).init(<span class="tok-number">5</span>, <span class="tok-number">3</span>);</span>
<span class="line" id="L125"> <span class="tok-kw">const</span> c = atan(a);</span>
<span class="line" id="L126"></span>
<span class="line" id="L127"> <span class="tok-kw">try</span> testing.expect(math.approxEqAbs(<span class="tok-type">f32</span>, c.re, <span class="tok-number">1.423679</span>, epsilon));</span>
<span class="line" id="L128"> <span class="tok-kw">try</span> testing.expect(math.approxEqAbs(<span class="tok-type">f32</span>, c.im, <span class="tok-number">0.086569</span>, epsilon));</span>
<span class="line" id="L129">}</span>
<span class="line" id="L130"></span>
<span class="line" id="L131"><span class="tok-kw">test</span> <span class="tok-str">"complex.catan64"</span> {</span>
<span class="line" id="L132"> <span class="tok-kw">const</span> a = Complex(<span class="tok-type">f64</span>).init(<span class="tok-number">5</span>, <span class="tok-number">3</span>);</span>
<span class="line" id="L133"> <span class="tok-kw">const</span> c = atan(a);</span>
<span class="line" id="L134"></span>
<span class="line" id="L135"> <span class="tok-kw">try</span> testing.expect(math.approxEqAbs(<span class="tok-type">f64</span>, c.re, <span class="tok-number">1.423679</span>, epsilon));</span>
<span class="line" id="L136"> <span class="tok-kw">try</span> testing.expect(math.approxEqAbs(<span class="tok-type">f64</span>, c.im, <span class="tok-number">0.086569</span>, epsilon));</span>
<span class="line" id="L137">}</span>
<span class="line" id="L138"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std/math | repos/yazap/docs/src/std/math/complex/atanh.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>math/complex/atanh.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../../std.zig"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> testing = std.testing;</span>
<span class="line" id="L3"><span class="tok-kw">const</span> math = std.math;</span>
<span class="line" id="L4"><span class="tok-kw">const</span> cmath = math.complex;</span>
<span class="line" id="L5"><span class="tok-kw">const</span> Complex = cmath.Complex;</span>
<span class="line" id="L6"></span>
<span class="line" id="L7"><span class="tok-comment">/// Returns the hyperbolic arc-tangent of z.</span></span>
<span class="line" id="L8"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">atanh</span>(z: <span class="tok-kw">anytype</span>) Complex(<span class="tok-builtin">@TypeOf</span>(z.re)) {</span>
<span class="line" id="L9"> <span class="tok-kw">const</span> T = <span class="tok-builtin">@TypeOf</span>(z.re);</span>
<span class="line" id="L10"> <span class="tok-kw">const</span> q = Complex(T).init(-z.im, z.re);</span>
<span class="line" id="L11"> <span class="tok-kw">const</span> r = cmath.atan(q);</span>
<span class="line" id="L12"> <span class="tok-kw">return</span> Complex(T).init(r.im, -r.re);</span>
<span class="line" id="L13">}</span>
<span class="line" id="L14"></span>
<span class="line" id="L15"><span class="tok-kw">const</span> epsilon = <span class="tok-number">0.0001</span>;</span>
<span class="line" id="L16"></span>
<span class="line" id="L17"><span class="tok-kw">test</span> <span class="tok-str">"complex.catanh"</span> {</span>
<span class="line" id="L18"> <span class="tok-kw">const</span> a = Complex(<span class="tok-type">f32</span>).init(<span class="tok-number">5</span>, <span class="tok-number">3</span>);</span>
<span class="line" id="L19"> <span class="tok-kw">const</span> c = atanh(a);</span>
<span class="line" id="L20"></span>
<span class="line" id="L21"> <span class="tok-kw">try</span> testing.expect(math.approxEqAbs(<span class="tok-type">f32</span>, c.re, <span class="tok-number">0.146947</span>, epsilon));</span>
<span class="line" id="L22"> <span class="tok-kw">try</span> testing.expect(math.approxEqAbs(<span class="tok-type">f32</span>, c.im, <span class="tok-number">1.480870</span>, epsilon));</span>
<span class="line" id="L23">}</span>
<span class="line" id="L24"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std/math | repos/yazap/docs/src/std/math/complex/proj.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>math/complex/proj.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../../std.zig"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> testing = std.testing;</span>
<span class="line" id="L3"><span class="tok-kw">const</span> math = std.math;</span>
<span class="line" id="L4"><span class="tok-kw">const</span> cmath = math.complex;</span>
<span class="line" id="L5"><span class="tok-kw">const</span> Complex = cmath.Complex;</span>
<span class="line" id="L6"></span>
<span class="line" id="L7"><span class="tok-comment">/// Returns the projection of z onto the riemann sphere.</span></span>
<span class="line" id="L8"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">proj</span>(z: <span class="tok-kw">anytype</span>) Complex(<span class="tok-builtin">@TypeOf</span>(z.re)) {</span>
<span class="line" id="L9"> <span class="tok-kw">const</span> T = <span class="tok-builtin">@TypeOf</span>(z.re);</span>
<span class="line" id="L10"></span>
<span class="line" id="L11"> <span class="tok-kw">if</span> (math.isInf(z.re) <span class="tok-kw">or</span> math.isInf(z.im)) {</span>
<span class="line" id="L12"> <span class="tok-kw">return</span> Complex(T).init(math.inf(T), math.copysign(<span class="tok-builtin">@as</span>(T, <span class="tok-number">0.0</span>), z.re));</span>
<span class="line" id="L13"> }</span>
<span class="line" id="L14"></span>
<span class="line" id="L15"> <span class="tok-kw">return</span> Complex(T).init(z.re, z.im);</span>
<span class="line" id="L16">}</span>
<span class="line" id="L17"></span>
<span class="line" id="L18"><span class="tok-kw">const</span> epsilon = <span class="tok-number">0.0001</span>;</span>
<span class="line" id="L19"></span>
<span class="line" id="L20"><span class="tok-kw">test</span> <span class="tok-str">"complex.cproj"</span> {</span>
<span class="line" id="L21"> <span class="tok-kw">const</span> a = Complex(<span class="tok-type">f32</span>).init(<span class="tok-number">5</span>, <span class="tok-number">3</span>);</span>
<span class="line" id="L22"> <span class="tok-kw">const</span> c = proj(a);</span>
<span class="line" id="L23"></span>
<span class="line" id="L24"> <span class="tok-kw">try</span> testing.expect(c.re == <span class="tok-number">5</span> <span class="tok-kw">and</span> c.im == <span class="tok-number">3</span>);</span>
<span class="line" id="L25">}</span>
<span class="line" id="L26"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std/math | repos/yazap/docs/src/std/math/complex/sinh.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>math/complex/sinh.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-comment">// Ported from musl, which is licensed under the MIT license:</span>
</span>
<span class="line" id="L2"><span class="tok-comment">// https://git.musl-libc.org/cgit/musl/tree/COPYRIGHT</span>
</span>
<span class="line" id="L3"><span class="tok-comment">//</span>
</span>
<span class="line" id="L4"><span class="tok-comment">// https://git.musl-libc.org/cgit/musl/tree/src/complex/csinhf.c</span>
</span>
<span class="line" id="L5"><span class="tok-comment">// https://git.musl-libc.org/cgit/musl/tree/src/complex/csinh.c</span>
</span>
<span class="line" id="L6"></span>
<span class="line" id="L7"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../../std.zig"</span>);</span>
<span class="line" id="L8"><span class="tok-kw">const</span> testing = std.testing;</span>
<span class="line" id="L9"><span class="tok-kw">const</span> math = std.math;</span>
<span class="line" id="L10"><span class="tok-kw">const</span> cmath = math.complex;</span>
<span class="line" id="L11"><span class="tok-kw">const</span> Complex = cmath.Complex;</span>
<span class="line" id="L12"></span>
<span class="line" id="L13"><span class="tok-kw">const</span> ldexp_cexp = <span class="tok-builtin">@import</span>(<span class="tok-str">"ldexp.zig"</span>).ldexp_cexp;</span>
<span class="line" id="L14"></span>
<span class="line" id="L15"><span class="tok-comment">/// Returns the hyperbolic sine of z.</span></span>
<span class="line" id="L16"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">sinh</span>(z: <span class="tok-kw">anytype</span>) <span class="tok-builtin">@TypeOf</span>(z) {</span>
<span class="line" id="L17"> <span class="tok-kw">const</span> T = <span class="tok-builtin">@TypeOf</span>(z.re);</span>
<span class="line" id="L18"> <span class="tok-kw">return</span> <span class="tok-kw">switch</span> (T) {</span>
<span class="line" id="L19"> <span class="tok-type">f32</span> => sinh32(z),</span>
<span class="line" id="L20"> <span class="tok-type">f64</span> => sinh64(z),</span>
<span class="line" id="L21"> <span class="tok-kw">else</span> => <span class="tok-builtin">@compileError</span>(<span class="tok-str">"tan not implemented for "</span> ++ <span class="tok-builtin">@typeName</span>(z)),</span>
<span class="line" id="L22"> };</span>
<span class="line" id="L23">}</span>
<span class="line" id="L24"></span>
<span class="line" id="L25"><span class="tok-kw">fn</span> <span class="tok-fn">sinh32</span>(z: Complex(<span class="tok-type">f32</span>)) Complex(<span class="tok-type">f32</span>) {</span>
<span class="line" id="L26"> <span class="tok-kw">const</span> x = z.re;</span>
<span class="line" id="L27"> <span class="tok-kw">const</span> y = z.im;</span>
<span class="line" id="L28"></span>
<span class="line" id="L29"> <span class="tok-kw">const</span> hx = <span class="tok-builtin">@as</span>(<span class="tok-type">u32</span>, <span class="tok-builtin">@bitCast</span>(x));</span>
<span class="line" id="L30"> <span class="tok-kw">const</span> ix = hx & <span class="tok-number">0x7fffffff</span>;</span>
<span class="line" id="L31"></span>
<span class="line" id="L32"> <span class="tok-kw">const</span> hy = <span class="tok-builtin">@as</span>(<span class="tok-type">u32</span>, <span class="tok-builtin">@bitCast</span>(y));</span>
<span class="line" id="L33"> <span class="tok-kw">const</span> iy = hy & <span class="tok-number">0x7fffffff</span>;</span>
<span class="line" id="L34"></span>
<span class="line" id="L35"> <span class="tok-kw">if</span> (ix < <span class="tok-number">0x7f800000</span> <span class="tok-kw">and</span> iy < <span class="tok-number">0x7f800000</span>) {</span>
<span class="line" id="L36"> <span class="tok-kw">if</span> (iy == <span class="tok-number">0</span>) {</span>
<span class="line" id="L37"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f32</span>).init(math.sinh(x), y);</span>
<span class="line" id="L38"> }</span>
<span class="line" id="L39"> <span class="tok-comment">// small x: normal case</span>
</span>
<span class="line" id="L40"> <span class="tok-kw">if</span> (ix < <span class="tok-number">0x41100000</span>) {</span>
<span class="line" id="L41"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f32</span>).init(math.sinh(x) * <span class="tok-builtin">@cos</span>(y), math.cosh(x) * <span class="tok-builtin">@sin</span>(y));</span>
<span class="line" id="L42"> }</span>
<span class="line" id="L43"></span>
<span class="line" id="L44"> <span class="tok-comment">// |x|>= 9, so cosh(x) ~= exp(|x|)</span>
</span>
<span class="line" id="L45"> <span class="tok-kw">if</span> (ix < <span class="tok-number">0x42b17218</span>) {</span>
<span class="line" id="L46"> <span class="tok-comment">// x < 88.7: exp(|x|) won't overflow</span>
</span>
<span class="line" id="L47"> <span class="tok-kw">const</span> h = <span class="tok-builtin">@exp</span>(<span class="tok-builtin">@fabs</span>(x)) * <span class="tok-number">0.5</span>;</span>
<span class="line" id="L48"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f32</span>).init(math.copysign(h, x) * <span class="tok-builtin">@cos</span>(y), h * <span class="tok-builtin">@sin</span>(y));</span>
<span class="line" id="L49"> }</span>
<span class="line" id="L50"> <span class="tok-comment">// x < 192.7: scale to avoid overflow</span>
</span>
<span class="line" id="L51"> <span class="tok-kw">else</span> <span class="tok-kw">if</span> (ix < <span class="tok-number">0x4340b1e7</span>) {</span>
<span class="line" id="L52"> <span class="tok-kw">const</span> v = Complex(<span class="tok-type">f32</span>).init(<span class="tok-builtin">@fabs</span>(x), y);</span>
<span class="line" id="L53"> <span class="tok-kw">const</span> r = ldexp_cexp(v, -<span class="tok-number">1</span>);</span>
<span class="line" id="L54"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f32</span>).init(r.re * math.copysign(<span class="tok-builtin">@as</span>(<span class="tok-type">f32</span>, <span class="tok-number">1.0</span>), x), r.im);</span>
<span class="line" id="L55"> }</span>
<span class="line" id="L56"> <span class="tok-comment">// x >= 192.7: result always overflows</span>
</span>
<span class="line" id="L57"> <span class="tok-kw">else</span> {</span>
<span class="line" id="L58"> <span class="tok-kw">const</span> h = <span class="tok-number">0x1p127</span> * x;</span>
<span class="line" id="L59"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f32</span>).init(h * <span class="tok-builtin">@cos</span>(y), h * h * <span class="tok-builtin">@sin</span>(y));</span>
<span class="line" id="L60"> }</span>
<span class="line" id="L61"> }</span>
<span class="line" id="L62"></span>
<span class="line" id="L63"> <span class="tok-kw">if</span> (ix == <span class="tok-number">0</span> <span class="tok-kw">and</span> iy >= <span class="tok-number">0x7f800000</span>) {</span>
<span class="line" id="L64"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f32</span>).init(math.copysign(<span class="tok-builtin">@as</span>(<span class="tok-type">f32</span>, <span class="tok-number">0.0</span>), x * (y - y)), y - y);</span>
<span class="line" id="L65"> }</span>
<span class="line" id="L66"></span>
<span class="line" id="L67"> <span class="tok-kw">if</span> (iy == <span class="tok-number">0</span> <span class="tok-kw">and</span> ix >= <span class="tok-number">0x7f800000</span>) {</span>
<span class="line" id="L68"> <span class="tok-kw">if</span> (hx & <span class="tok-number">0x7fffff</span> == <span class="tok-number">0</span>) {</span>
<span class="line" id="L69"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f32</span>).init(x, y);</span>
<span class="line" id="L70"> }</span>
<span class="line" id="L71"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f32</span>).init(x, math.copysign(<span class="tok-builtin">@as</span>(<span class="tok-type">f32</span>, <span class="tok-number">0.0</span>), y));</span>
<span class="line" id="L72"> }</span>
<span class="line" id="L73"></span>
<span class="line" id="L74"> <span class="tok-kw">if</span> (ix < <span class="tok-number">0x7f800000</span> <span class="tok-kw">and</span> iy >= <span class="tok-number">0x7f800000</span>) {</span>
<span class="line" id="L75"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f32</span>).init(y - y, x * (y - y));</span>
<span class="line" id="L76"> }</span>
<span class="line" id="L77"></span>
<span class="line" id="L78"> <span class="tok-kw">if</span> (ix >= <span class="tok-number">0x7f800000</span> <span class="tok-kw">and</span> (hx & <span class="tok-number">0x7fffff</span>) == <span class="tok-number">0</span>) {</span>
<span class="line" id="L79"> <span class="tok-kw">if</span> (iy >= <span class="tok-number">0x7f800000</span>) {</span>
<span class="line" id="L80"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f32</span>).init(x * x, x * (y - y));</span>
<span class="line" id="L81"> }</span>
<span class="line" id="L82"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f32</span>).init(x * <span class="tok-builtin">@cos</span>(y), math.inf(<span class="tok-type">f32</span>) * <span class="tok-builtin">@sin</span>(y));</span>
<span class="line" id="L83"> }</span>
<span class="line" id="L84"></span>
<span class="line" id="L85"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f32</span>).init((x * x) * (y - y), (x + x) * (y - y));</span>
<span class="line" id="L86">}</span>
<span class="line" id="L87"></span>
<span class="line" id="L88"><span class="tok-kw">fn</span> <span class="tok-fn">sinh64</span>(z: Complex(<span class="tok-type">f64</span>)) Complex(<span class="tok-type">f64</span>) {</span>
<span class="line" id="L89"> <span class="tok-kw">const</span> x = z.re;</span>
<span class="line" id="L90"> <span class="tok-kw">const</span> y = z.im;</span>
<span class="line" id="L91"></span>
<span class="line" id="L92"> <span class="tok-kw">const</span> fx = <span class="tok-builtin">@as</span>(<span class="tok-type">u64</span>, <span class="tok-builtin">@bitCast</span>(x));</span>
<span class="line" id="L93"> <span class="tok-kw">const</span> hx = <span class="tok-builtin">@as</span>(<span class="tok-type">u32</span>, <span class="tok-builtin">@intCast</span>(fx >> <span class="tok-number">32</span>));</span>
<span class="line" id="L94"> <span class="tok-kw">const</span> lx = <span class="tok-builtin">@as</span>(<span class="tok-type">u32</span>, <span class="tok-builtin">@truncate</span>(fx));</span>
<span class="line" id="L95"> <span class="tok-kw">const</span> ix = hx & <span class="tok-number">0x7fffffff</span>;</span>
<span class="line" id="L96"></span>
<span class="line" id="L97"> <span class="tok-kw">const</span> fy = <span class="tok-builtin">@as</span>(<span class="tok-type">u64</span>, <span class="tok-builtin">@bitCast</span>(y));</span>
<span class="line" id="L98"> <span class="tok-kw">const</span> hy = <span class="tok-builtin">@as</span>(<span class="tok-type">u32</span>, <span class="tok-builtin">@intCast</span>(fy >> <span class="tok-number">32</span>));</span>
<span class="line" id="L99"> <span class="tok-kw">const</span> ly = <span class="tok-builtin">@as</span>(<span class="tok-type">u32</span>, <span class="tok-builtin">@truncate</span>(fy));</span>
<span class="line" id="L100"> <span class="tok-kw">const</span> iy = hy & <span class="tok-number">0x7fffffff</span>;</span>
<span class="line" id="L101"></span>
<span class="line" id="L102"> <span class="tok-kw">if</span> (ix < <span class="tok-number">0x7ff00000</span> <span class="tok-kw">and</span> iy < <span class="tok-number">0x7ff00000</span>) {</span>
<span class="line" id="L103"> <span class="tok-kw">if</span> (iy | ly == <span class="tok-number">0</span>) {</span>
<span class="line" id="L104"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f64</span>).init(math.sinh(x), y);</span>
<span class="line" id="L105"> }</span>
<span class="line" id="L106"> <span class="tok-comment">// small x: normal case</span>
</span>
<span class="line" id="L107"> <span class="tok-kw">if</span> (ix < <span class="tok-number">0x40360000</span>) {</span>
<span class="line" id="L108"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f64</span>).init(math.sinh(x) * <span class="tok-builtin">@cos</span>(y), math.cosh(x) * <span class="tok-builtin">@sin</span>(y));</span>
<span class="line" id="L109"> }</span>
<span class="line" id="L110"></span>
<span class="line" id="L111"> <span class="tok-comment">// |x|>= 22, so cosh(x) ~= exp(|x|)</span>
</span>
<span class="line" id="L112"> <span class="tok-kw">if</span> (ix < <span class="tok-number">0x40862e42</span>) {</span>
<span class="line" id="L113"> <span class="tok-comment">// x < 710: exp(|x|) won't overflow</span>
</span>
<span class="line" id="L114"> <span class="tok-kw">const</span> h = <span class="tok-builtin">@exp</span>(<span class="tok-builtin">@fabs</span>(x)) * <span class="tok-number">0.5</span>;</span>
<span class="line" id="L115"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f64</span>).init(math.copysign(h, x) * <span class="tok-builtin">@cos</span>(y), h * <span class="tok-builtin">@sin</span>(y));</span>
<span class="line" id="L116"> }</span>
<span class="line" id="L117"> <span class="tok-comment">// x < 1455: scale to avoid overflow</span>
</span>
<span class="line" id="L118"> <span class="tok-kw">else</span> <span class="tok-kw">if</span> (ix < <span class="tok-number">0x4096bbaa</span>) {</span>
<span class="line" id="L119"> <span class="tok-kw">const</span> v = Complex(<span class="tok-type">f64</span>).init(<span class="tok-builtin">@fabs</span>(x), y);</span>
<span class="line" id="L120"> <span class="tok-kw">const</span> r = ldexp_cexp(v, -<span class="tok-number">1</span>);</span>
<span class="line" id="L121"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f64</span>).init(r.re * math.copysign(<span class="tok-builtin">@as</span>(<span class="tok-type">f64</span>, <span class="tok-number">1.0</span>), x), r.im);</span>
<span class="line" id="L122"> }</span>
<span class="line" id="L123"> <span class="tok-comment">// x >= 1455: result always overflows</span>
</span>
<span class="line" id="L124"> <span class="tok-kw">else</span> {</span>
<span class="line" id="L125"> <span class="tok-kw">const</span> h = <span class="tok-number">0x1p1023</span> * x;</span>
<span class="line" id="L126"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f64</span>).init(h * <span class="tok-builtin">@cos</span>(y), h * h * <span class="tok-builtin">@sin</span>(y));</span>
<span class="line" id="L127"> }</span>
<span class="line" id="L128"> }</span>
<span class="line" id="L129"></span>
<span class="line" id="L130"> <span class="tok-kw">if</span> (ix | lx == <span class="tok-number">0</span> <span class="tok-kw">and</span> iy >= <span class="tok-number">0x7ff00000</span>) {</span>
<span class="line" id="L131"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f64</span>).init(math.copysign(<span class="tok-builtin">@as</span>(<span class="tok-type">f64</span>, <span class="tok-number">0.0</span>), x * (y - y)), y - y);</span>
<span class="line" id="L132"> }</span>
<span class="line" id="L133"></span>
<span class="line" id="L134"> <span class="tok-kw">if</span> (iy | ly == <span class="tok-number">0</span> <span class="tok-kw">and</span> ix >= <span class="tok-number">0x7ff00000</span>) {</span>
<span class="line" id="L135"> <span class="tok-kw">if</span> ((hx & <span class="tok-number">0xfffff</span>) | lx == <span class="tok-number">0</span>) {</span>
<span class="line" id="L136"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f64</span>).init(x, y);</span>
<span class="line" id="L137"> }</span>
<span class="line" id="L138"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f64</span>).init(x, math.copysign(<span class="tok-builtin">@as</span>(<span class="tok-type">f64</span>, <span class="tok-number">0.0</span>), y));</span>
<span class="line" id="L139"> }</span>
<span class="line" id="L140"></span>
<span class="line" id="L141"> <span class="tok-kw">if</span> (ix < <span class="tok-number">0x7ff00000</span> <span class="tok-kw">and</span> iy >= <span class="tok-number">0x7ff00000</span>) {</span>
<span class="line" id="L142"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f64</span>).init(y - y, x * (y - y));</span>
<span class="line" id="L143"> }</span>
<span class="line" id="L144"></span>
<span class="line" id="L145"> <span class="tok-kw">if</span> (ix >= <span class="tok-number">0x7ff00000</span> <span class="tok-kw">and</span> (hx & <span class="tok-number">0xfffff</span>) | lx == <span class="tok-number">0</span>) {</span>
<span class="line" id="L146"> <span class="tok-kw">if</span> (iy >= <span class="tok-number">0x7ff00000</span>) {</span>
<span class="line" id="L147"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f64</span>).init(x * x, x * (y - y));</span>
<span class="line" id="L148"> }</span>
<span class="line" id="L149"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f64</span>).init(x * <span class="tok-builtin">@cos</span>(y), math.inf(<span class="tok-type">f64</span>) * <span class="tok-builtin">@sin</span>(y));</span>
<span class="line" id="L150"> }</span>
<span class="line" id="L151"></span>
<span class="line" id="L152"> <span class="tok-kw">return</span> Complex(<span class="tok-type">f64</span>).init((x * x) * (y - y), (x + x) * (y - y));</span>
<span class="line" id="L153">}</span>
<span class="line" id="L154"></span>
<span class="line" id="L155"><span class="tok-kw">const</span> epsilon = <span class="tok-number">0.0001</span>;</span>
<span class="line" id="L156"></span>
<span class="line" id="L157"><span class="tok-kw">test</span> <span class="tok-str">"complex.csinh32"</span> {</span>
<span class="line" id="L158"> <span class="tok-kw">const</span> a = Complex(<span class="tok-type">f32</span>).init(<span class="tok-number">5</span>, <span class="tok-number">3</span>);</span>
<span class="line" id="L159"> <span class="tok-kw">const</span> c = sinh(a);</span>
<span class="line" id="L160"></span>
<span class="line" id="L161"> <span class="tok-kw">try</span> testing.expect(math.approxEqAbs(<span class="tok-type">f32</span>, c.re, -<span class="tok-number">73.460617</span>, epsilon));</span>
<span class="line" id="L162"> <span class="tok-kw">try</span> testing.expect(math.approxEqAbs(<span class="tok-type">f32</span>, c.im, <span class="tok-number">10.472508</span>, epsilon));</span>
<span class="line" id="L163">}</span>
<span class="line" id="L164"></span>
<span class="line" id="L165"><span class="tok-kw">test</span> <span class="tok-str">"complex.csinh64"</span> {</span>
<span class="line" id="L166"> <span class="tok-kw">const</span> a = Complex(<span class="tok-type">f64</span>).init(<span class="tok-number">5</span>, <span class="tok-number">3</span>);</span>
<span class="line" id="L167"> <span class="tok-kw">const</span> c = sinh(a);</span>
<span class="line" id="L168"></span>
<span class="line" id="L169"> <span class="tok-kw">try</span> testing.expect(math.approxEqAbs(<span class="tok-type">f64</span>, c.re, -<span class="tok-number">73.460617</span>, epsilon));</span>
<span class="line" id="L170"> <span class="tok-kw">try</span> testing.expect(math.approxEqAbs(<span class="tok-type">f64</span>, c.im, <span class="tok-number">10.472508</span>, epsilon));</span>
<span class="line" id="L171">}</span>
<span class="line" id="L172"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std/math | repos/yazap/docs/src/std/math/complex/tan.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>math/complex/tan.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../../std.zig"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> testing = std.testing;</span>
<span class="line" id="L3"><span class="tok-kw">const</span> math = std.math;</span>
<span class="line" id="L4"><span class="tok-kw">const</span> cmath = math.complex;</span>
<span class="line" id="L5"><span class="tok-kw">const</span> Complex = cmath.Complex;</span>
<span class="line" id="L6"></span>
<span class="line" id="L7"><span class="tok-comment">/// Returns the tangent of z.</span></span>
<span class="line" id="L8"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">tan</span>(z: <span class="tok-kw">anytype</span>) Complex(<span class="tok-builtin">@TypeOf</span>(z.re)) {</span>
<span class="line" id="L9"> <span class="tok-kw">const</span> T = <span class="tok-builtin">@TypeOf</span>(z.re);</span>
<span class="line" id="L10"> <span class="tok-kw">const</span> q = Complex(T).init(-z.im, z.re);</span>
<span class="line" id="L11"> <span class="tok-kw">const</span> r = cmath.tanh(q);</span>
<span class="line" id="L12"> <span class="tok-kw">return</span> Complex(T).init(r.im, -r.re);</span>
<span class="line" id="L13">}</span>
<span class="line" id="L14"></span>
<span class="line" id="L15"><span class="tok-kw">const</span> epsilon = <span class="tok-number">0.0001</span>;</span>
<span class="line" id="L16"></span>
<span class="line" id="L17"><span class="tok-kw">test</span> <span class="tok-str">"complex.ctan"</span> {</span>
<span class="line" id="L18"> <span class="tok-kw">const</span> a = Complex(<span class="tok-type">f32</span>).init(<span class="tok-number">5</span>, <span class="tok-number">3</span>);</span>
<span class="line" id="L19"> <span class="tok-kw">const</span> c = tan(a);</span>
<span class="line" id="L20"></span>
<span class="line" id="L21"> <span class="tok-kw">try</span> testing.expect(math.approxEqAbs(<span class="tok-type">f32</span>, c.re, -<span class="tok-number">0.002708233</span>, epsilon));</span>
<span class="line" id="L22"> <span class="tok-kw">try</span> testing.expect(math.approxEqAbs(<span class="tok-type">f32</span>, c.im, <span class="tok-number">1.004165</span>, epsilon));</span>
<span class="line" id="L23">}</span>
<span class="line" id="L24"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std/math | repos/yazap/docs/src/std/math/big/rational.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>math/big/rational.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../../std.zig"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> debug = std.debug;</span>
<span class="line" id="L3"><span class="tok-kw">const</span> math = std.math;</span>
<span class="line" id="L4"><span class="tok-kw">const</span> mem = std.mem;</span>
<span class="line" id="L5"><span class="tok-kw">const</span> testing = std.testing;</span>
<span class="line" id="L6"><span class="tok-kw">const</span> Allocator = mem.Allocator;</span>
<span class="line" id="L7"></span>
<span class="line" id="L8"><span class="tok-kw">const</span> Limb = std.math.big.Limb;</span>
<span class="line" id="L9"><span class="tok-kw">const</span> DoubleLimb = std.math.big.DoubleLimb;</span>
<span class="line" id="L10"><span class="tok-kw">const</span> Int = std.math.big.int.Managed;</span>
<span class="line" id="L11"><span class="tok-kw">const</span> IntConst = std.math.big.int.Const;</span>
<span class="line" id="L12"></span>
<span class="line" id="L13"><span class="tok-comment">/// An arbitrary-precision rational number.</span></span>
<span class="line" id="L14"><span class="tok-comment">///</span></span>
<span class="line" id="L15"><span class="tok-comment">/// Memory is allocated as needed for operations to ensure full precision is kept. The precision</span></span>
<span class="line" id="L16"><span class="tok-comment">/// of a Rational is only bounded by memory.</span></span>
<span class="line" id="L17"><span class="tok-comment">///</span></span>
<span class="line" id="L18"><span class="tok-comment">/// Rational's are always normalized. That is, for a Rational r = p/q where p and q are integers,</span></span>
<span class="line" id="L19"><span class="tok-comment">/// gcd(p, q) = 1 always.</span></span>
<span class="line" id="L20"><span class="tok-comment">///</span></span>
<span class="line" id="L21"><span class="tok-comment">/// TODO rework this to store its own allocator and use a non-managed big int, to avoid double</span></span>
<span class="line" id="L22"><span class="tok-comment">/// allocator storage.</span></span>
<span class="line" id="L23"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> Rational = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L24"> <span class="tok-comment">/// Numerator. Determines the sign of the Rational.</span></span>
<span class="line" id="L25"> p: Int,</span>
<span class="line" id="L26"></span>
<span class="line" id="L27"> <span class="tok-comment">/// Denominator. Sign is ignored.</span></span>
<span class="line" id="L28"> q: Int,</span>
<span class="line" id="L29"></span>
<span class="line" id="L30"> <span class="tok-comment">/// Create a new Rational. A small amount of memory will be allocated on initialization.</span></span>
<span class="line" id="L31"> <span class="tok-comment">/// This will be 2 * Int.default_capacity.</span></span>
<span class="line" id="L32"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">init</span>(a: Allocator) !Rational {</span>
<span class="line" id="L33"> <span class="tok-kw">var</span> p = <span class="tok-kw">try</span> Int.init(a);</span>
<span class="line" id="L34"> <span class="tok-kw">errdefer</span> p.deinit();</span>
<span class="line" id="L35"> <span class="tok-kw">return</span> Rational{</span>
<span class="line" id="L36"> .p = p,</span>
<span class="line" id="L37"> .q = <span class="tok-kw">try</span> Int.initSet(a, <span class="tok-number">1</span>),</span>
<span class="line" id="L38"> };</span>
<span class="line" id="L39"> }</span>
<span class="line" id="L40"></span>
<span class="line" id="L41"> <span class="tok-comment">/// Frees all memory associated with a Rational.</span></span>
<span class="line" id="L42"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">deinit</span>(self: *Rational) <span class="tok-type">void</span> {</span>
<span class="line" id="L43"> self.p.deinit();</span>
<span class="line" id="L44"> self.q.deinit();</span>
<span class="line" id="L45"> }</span>
<span class="line" id="L46"></span>
<span class="line" id="L47"> <span class="tok-comment">/// Set a Rational from a primitive integer type.</span></span>
<span class="line" id="L48"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">setInt</span>(self: *Rational, a: <span class="tok-kw">anytype</span>) !<span class="tok-type">void</span> {</span>
<span class="line" id="L49"> <span class="tok-kw">try</span> self.p.set(a);</span>
<span class="line" id="L50"> <span class="tok-kw">try</span> self.q.set(<span class="tok-number">1</span>);</span>
<span class="line" id="L51"> }</span>
<span class="line" id="L52"></span>
<span class="line" id="L53"> <span class="tok-comment">/// Set a Rational from a string of the form `A/B` where A and B are base-10 integers.</span></span>
<span class="line" id="L54"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">setFloatString</span>(self: *Rational, str: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) !<span class="tok-type">void</span> {</span>
<span class="line" id="L55"> <span class="tok-comment">// TODO: Accept a/b fractions and exponent form</span>
</span>
<span class="line" id="L56"> <span class="tok-kw">if</span> (str.len == <span class="tok-number">0</span>) {</span>
<span class="line" id="L57"> <span class="tok-kw">return</span> <span class="tok-kw">error</span>.InvalidFloatString;</span>
<span class="line" id="L58"> }</span>
<span class="line" id="L59"></span>
<span class="line" id="L60"> <span class="tok-kw">const</span> State = <span class="tok-kw">enum</span> {</span>
<span class="line" id="L61"> Integer,</span>
<span class="line" id="L62"> Fractional,</span>
<span class="line" id="L63"> };</span>
<span class="line" id="L64"></span>
<span class="line" id="L65"> <span class="tok-kw">var</span> state = State.Integer;</span>
<span class="line" id="L66"> <span class="tok-kw">var</span> point: ?<span class="tok-type">usize</span> = <span class="tok-null">null</span>;</span>
<span class="line" id="L67"></span>
<span class="line" id="L68"> <span class="tok-kw">var</span> start: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L69"> <span class="tok-kw">if</span> (str[<span class="tok-number">0</span>] == <span class="tok-str">'-'</span>) {</span>
<span class="line" id="L70"> start += <span class="tok-number">1</span>;</span>
<span class="line" id="L71"> }</span>
<span class="line" id="L72"></span>
<span class="line" id="L73"> <span class="tok-kw">for</span> (str, <span class="tok-number">0</span>..) |c, i| {</span>
<span class="line" id="L74"> <span class="tok-kw">switch</span> (state) {</span>
<span class="line" id="L75"> State.Integer => {</span>
<span class="line" id="L76"> <span class="tok-kw">switch</span> (c) {</span>
<span class="line" id="L77"> <span class="tok-str">'.'</span> => {</span>
<span class="line" id="L78"> state = State.Fractional;</span>
<span class="line" id="L79"> point = i;</span>
<span class="line" id="L80"> },</span>
<span class="line" id="L81"> <span class="tok-str">'0'</span>...<span class="tok-str">'9'</span> => {</span>
<span class="line" id="L82"> <span class="tok-comment">// okay</span>
</span>
<span class="line" id="L83"> },</span>
<span class="line" id="L84"> <span class="tok-kw">else</span> => {</span>
<span class="line" id="L85"> <span class="tok-kw">return</span> <span class="tok-kw">error</span>.InvalidFloatString;</span>
<span class="line" id="L86"> },</span>
<span class="line" id="L87"> }</span>
<span class="line" id="L88"> },</span>
<span class="line" id="L89"> State.Fractional => {</span>
<span class="line" id="L90"> <span class="tok-kw">switch</span> (c) {</span>
<span class="line" id="L91"> <span class="tok-str">'0'</span>...<span class="tok-str">'9'</span> => {</span>
<span class="line" id="L92"> <span class="tok-comment">// okay</span>
</span>
<span class="line" id="L93"> },</span>
<span class="line" id="L94"> <span class="tok-kw">else</span> => {</span>
<span class="line" id="L95"> <span class="tok-kw">return</span> <span class="tok-kw">error</span>.InvalidFloatString;</span>
<span class="line" id="L96"> },</span>
<span class="line" id="L97"> }</span>
<span class="line" id="L98"> },</span>
<span class="line" id="L99"> }</span>
<span class="line" id="L100"> }</span>
<span class="line" id="L101"></span>
<span class="line" id="L102"> <span class="tok-comment">// TODO: batch the multiplies by 10</span>
</span>
<span class="line" id="L103"> <span class="tok-kw">if</span> (point) |i| {</span>
<span class="line" id="L104"> <span class="tok-kw">try</span> self.p.setString(<span class="tok-number">10</span>, str[<span class="tok-number">0</span>..i]);</span>
<span class="line" id="L105"></span>
<span class="line" id="L106"> <span class="tok-kw">const</span> base = IntConst{ .limbs = &[_]Limb{<span class="tok-number">10</span>}, .positive = <span class="tok-null">true</span> };</span>
<span class="line" id="L107"> <span class="tok-kw">var</span> local_buf: [<span class="tok-builtin">@sizeOf</span>(Limb) * Int.default_capacity]<span class="tok-type">u8</span> <span class="tok-kw">align</span>(<span class="tok-builtin">@alignOf</span>(Limb)) = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L108"> <span class="tok-kw">var</span> fba = std.heap.FixedBufferAllocator.init(&local_buf);</span>
<span class="line" id="L109"> <span class="tok-kw">const</span> base_managed = <span class="tok-kw">try</span> base.toManaged(fba.allocator());</span>
<span class="line" id="L110"></span>
<span class="line" id="L111"> <span class="tok-kw">var</span> j: <span class="tok-type">usize</span> = start;</span>
<span class="line" id="L112"> <span class="tok-kw">while</span> (j < str.len - i - <span class="tok-number">1</span>) : (j += <span class="tok-number">1</span>) {</span>
<span class="line" id="L113"> <span class="tok-kw">try</span> self.p.ensureMulCapacity(self.p.toConst(), base);</span>
<span class="line" id="L114"> <span class="tok-kw">try</span> self.p.mul(&self.p, &base_managed);</span>
<span class="line" id="L115"> }</span>
<span class="line" id="L116"></span>
<span class="line" id="L117"> <span class="tok-kw">try</span> self.q.setString(<span class="tok-number">10</span>, str[i + <span class="tok-number">1</span> ..]);</span>
<span class="line" id="L118"> <span class="tok-kw">try</span> self.p.add(&self.p, &self.q);</span>
<span class="line" id="L119"></span>
<span class="line" id="L120"> <span class="tok-kw">try</span> self.q.set(<span class="tok-number">1</span>);</span>
<span class="line" id="L121"> <span class="tok-kw">var</span> k: <span class="tok-type">usize</span> = i + <span class="tok-number">1</span>;</span>
<span class="line" id="L122"> <span class="tok-kw">while</span> (k < str.len) : (k += <span class="tok-number">1</span>) {</span>
<span class="line" id="L123"> <span class="tok-kw">try</span> self.q.mul(&self.q, &base_managed);</span>
<span class="line" id="L124"> }</span>
<span class="line" id="L125"></span>
<span class="line" id="L126"> <span class="tok-kw">try</span> self.reduce();</span>
<span class="line" id="L127"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L128"> <span class="tok-kw">try</span> self.p.setString(<span class="tok-number">10</span>, str[<span class="tok-number">0</span>..]);</span>
<span class="line" id="L129"> <span class="tok-kw">try</span> self.q.set(<span class="tok-number">1</span>);</span>
<span class="line" id="L130"> }</span>
<span class="line" id="L131"> }</span>
<span class="line" id="L132"></span>
<span class="line" id="L133"> <span class="tok-comment">/// Set a Rational from a floating-point value. The rational will have enough precision to</span></span>
<span class="line" id="L134"> <span class="tok-comment">/// completely represent the provided float.</span></span>
<span class="line" id="L135"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">setFloat</span>(self: *Rational, <span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>, f: T) !<span class="tok-type">void</span> {</span>
<span class="line" id="L136"> <span class="tok-comment">// Translated from golang.go/src/math/big/rat.go.</span>
</span>
<span class="line" id="L137"> debug.assert(<span class="tok-builtin">@typeInfo</span>(T) == .Float);</span>
<span class="line" id="L138"></span>
<span class="line" id="L139"> <span class="tok-kw">const</span> UnsignedInt = std.meta.Int(.unsigned, <span class="tok-builtin">@typeInfo</span>(T).Float.bits);</span>
<span class="line" id="L140"> <span class="tok-kw">const</span> f_bits = <span class="tok-builtin">@as</span>(UnsignedInt, <span class="tok-builtin">@bitCast</span>(f));</span>
<span class="line" id="L141"></span>
<span class="line" id="L142"> <span class="tok-kw">const</span> exponent_bits = math.floatExponentBits(T);</span>
<span class="line" id="L143"> <span class="tok-kw">const</span> exponent_bias = (<span class="tok-number">1</span> << (exponent_bits - <span class="tok-number">1</span>)) - <span class="tok-number">1</span>;</span>
<span class="line" id="L144"> <span class="tok-kw">const</span> mantissa_bits = math.floatMantissaBits(T);</span>
<span class="line" id="L145"></span>
<span class="line" id="L146"> <span class="tok-kw">const</span> exponent_mask = (<span class="tok-number">1</span> << exponent_bits) - <span class="tok-number">1</span>;</span>
<span class="line" id="L147"> <span class="tok-kw">const</span> mantissa_mask = (<span class="tok-number">1</span> << mantissa_bits) - <span class="tok-number">1</span>;</span>
<span class="line" id="L148"></span>
<span class="line" id="L149"> <span class="tok-kw">var</span> exponent = <span class="tok-builtin">@as</span>(<span class="tok-type">i16</span>, <span class="tok-builtin">@intCast</span>((f_bits >> mantissa_bits) & exponent_mask));</span>
<span class="line" id="L150"> <span class="tok-kw">var</span> mantissa = f_bits & mantissa_mask;</span>
<span class="line" id="L151"></span>
<span class="line" id="L152"> <span class="tok-kw">switch</span> (exponent) {</span>
<span class="line" id="L153"> exponent_mask => {</span>
<span class="line" id="L154"> <span class="tok-kw">return</span> <span class="tok-kw">error</span>.NonFiniteFloat;</span>
<span class="line" id="L155"> },</span>
<span class="line" id="L156"> <span class="tok-number">0</span> => {</span>
<span class="line" id="L157"> <span class="tok-comment">// denormal</span>
</span>
<span class="line" id="L158"> exponent -= exponent_bias - <span class="tok-number">1</span>;</span>
<span class="line" id="L159"> },</span>
<span class="line" id="L160"> <span class="tok-kw">else</span> => {</span>
<span class="line" id="L161"> <span class="tok-comment">// normal</span>
</span>
<span class="line" id="L162"> mantissa |= <span class="tok-number">1</span> << mantissa_bits;</span>
<span class="line" id="L163"> exponent -= exponent_bias;</span>
<span class="line" id="L164"> },</span>
<span class="line" id="L165"> }</span>
<span class="line" id="L166"></span>
<span class="line" id="L167"> <span class="tok-kw">var</span> shift: <span class="tok-type">i16</span> = mantissa_bits - exponent;</span>
<span class="line" id="L168"></span>
<span class="line" id="L169"> <span class="tok-comment">// factor out powers of two early from rational</span>
</span>
<span class="line" id="L170"> <span class="tok-kw">while</span> (mantissa & <span class="tok-number">1</span> == <span class="tok-number">0</span> <span class="tok-kw">and</span> shift > <span class="tok-number">0</span>) {</span>
<span class="line" id="L171"> mantissa >>= <span class="tok-number">1</span>;</span>
<span class="line" id="L172"> shift -= <span class="tok-number">1</span>;</span>
<span class="line" id="L173"> }</span>
<span class="line" id="L174"></span>
<span class="line" id="L175"> <span class="tok-kw">try</span> self.p.set(mantissa);</span>
<span class="line" id="L176"> self.p.setSign(f >= <span class="tok-number">0</span>);</span>
<span class="line" id="L177"></span>
<span class="line" id="L178"> <span class="tok-kw">try</span> self.q.set(<span class="tok-number">1</span>);</span>
<span class="line" id="L179"> <span class="tok-kw">if</span> (shift >= <span class="tok-number">0</span>) {</span>
<span class="line" id="L180"> <span class="tok-kw">try</span> self.q.shiftLeft(&self.q, <span class="tok-builtin">@as</span>(<span class="tok-type">usize</span>, <span class="tok-builtin">@intCast</span>(shift)));</span>
<span class="line" id="L181"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L182"> <span class="tok-kw">try</span> self.p.shiftLeft(&self.p, <span class="tok-builtin">@as</span>(<span class="tok-type">usize</span>, <span class="tok-builtin">@intCast</span>(-shift)));</span>
<span class="line" id="L183"> }</span>
<span class="line" id="L184"></span>
<span class="line" id="L185"> <span class="tok-kw">try</span> self.reduce();</span>
<span class="line" id="L186"> }</span>
<span class="line" id="L187"></span>
<span class="line" id="L188"> <span class="tok-comment">/// Return a floating-point value that is the closest value to a Rational.</span></span>
<span class="line" id="L189"> <span class="tok-comment">///</span></span>
<span class="line" id="L190"> <span class="tok-comment">/// The result may not be exact if the Rational is too precise or too large for the</span></span>
<span class="line" id="L191"> <span class="tok-comment">/// target type.</span></span>
<span class="line" id="L192"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">toFloat</span>(self: Rational, <span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>) !T {</span>
<span class="line" id="L193"> <span class="tok-comment">// Translated from golang.go/src/math/big/rat.go.</span>
</span>
<span class="line" id="L194"> <span class="tok-comment">// TODO: Indicate whether the result is not exact.</span>
</span>
<span class="line" id="L195"> debug.assert(<span class="tok-builtin">@typeInfo</span>(T) == .Float);</span>
<span class="line" id="L196"></span>
<span class="line" id="L197"> <span class="tok-kw">const</span> fsize = <span class="tok-builtin">@typeInfo</span>(T).Float.bits;</span>
<span class="line" id="L198"> <span class="tok-kw">const</span> BitReprType = std.meta.Int(.unsigned, fsize);</span>
<span class="line" id="L199"></span>
<span class="line" id="L200"> <span class="tok-kw">const</span> msize = math.floatMantissaBits(T);</span>
<span class="line" id="L201"> <span class="tok-kw">const</span> msize1 = msize + <span class="tok-number">1</span>;</span>
<span class="line" id="L202"> <span class="tok-kw">const</span> msize2 = msize1 + <span class="tok-number">1</span>;</span>
<span class="line" id="L203"></span>
<span class="line" id="L204"> <span class="tok-kw">const</span> esize = math.floatExponentBits(T);</span>
<span class="line" id="L205"> <span class="tok-kw">const</span> ebias = (<span class="tok-number">1</span> << (esize - <span class="tok-number">1</span>)) - <span class="tok-number">1</span>;</span>
<span class="line" id="L206"> <span class="tok-kw">const</span> emin = <span class="tok-number">1</span> - ebias;</span>
<span class="line" id="L207"></span>
<span class="line" id="L208"> <span class="tok-kw">if</span> (self.p.eqlZero()) {</span>
<span class="line" id="L209"> <span class="tok-kw">return</span> <span class="tok-number">0</span>;</span>
<span class="line" id="L210"> }</span>
<span class="line" id="L211"></span>
<span class="line" id="L212"> <span class="tok-comment">// 1. left-shift a or sub so that a/b is in [1 << msize1, 1 << (msize2 + 1)]</span>
</span>
<span class="line" id="L213"> <span class="tok-kw">var</span> exp = <span class="tok-builtin">@as</span>(<span class="tok-type">isize</span>, <span class="tok-builtin">@intCast</span>(self.p.bitCountTwosComp())) - <span class="tok-builtin">@as</span>(<span class="tok-type">isize</span>, <span class="tok-builtin">@intCast</span>(self.q.bitCountTwosComp()));</span>
<span class="line" id="L214"></span>
<span class="line" id="L215"> <span class="tok-kw">var</span> a2 = <span class="tok-kw">try</span> self.p.clone();</span>
<span class="line" id="L216"> <span class="tok-kw">defer</span> a2.deinit();</span>
<span class="line" id="L217"></span>
<span class="line" id="L218"> <span class="tok-kw">var</span> b2 = <span class="tok-kw">try</span> self.q.clone();</span>
<span class="line" id="L219"> <span class="tok-kw">defer</span> b2.deinit();</span>
<span class="line" id="L220"></span>
<span class="line" id="L221"> <span class="tok-kw">const</span> shift = msize2 - exp;</span>
<span class="line" id="L222"> <span class="tok-kw">if</span> (shift >= <span class="tok-number">0</span>) {</span>
<span class="line" id="L223"> <span class="tok-kw">try</span> a2.shiftLeft(&a2, <span class="tok-builtin">@as</span>(<span class="tok-type">usize</span>, <span class="tok-builtin">@intCast</span>(shift)));</span>
<span class="line" id="L224"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L225"> <span class="tok-kw">try</span> b2.shiftLeft(&b2, <span class="tok-builtin">@as</span>(<span class="tok-type">usize</span>, <span class="tok-builtin">@intCast</span>(-shift)));</span>
<span class="line" id="L226"> }</span>
<span class="line" id="L227"></span>
<span class="line" id="L228"> <span class="tok-comment">// 2. compute quotient and remainder</span>
</span>
<span class="line" id="L229"> <span class="tok-kw">var</span> q = <span class="tok-kw">try</span> Int.init(self.p.allocator);</span>
<span class="line" id="L230"> <span class="tok-kw">defer</span> q.deinit();</span>
<span class="line" id="L231"></span>
<span class="line" id="L232"> <span class="tok-comment">// unused</span>
</span>
<span class="line" id="L233"> <span class="tok-kw">var</span> r = <span class="tok-kw">try</span> Int.init(self.p.allocator);</span>
<span class="line" id="L234"> <span class="tok-kw">defer</span> r.deinit();</span>
<span class="line" id="L235"></span>
<span class="line" id="L236"> <span class="tok-kw">try</span> Int.divTrunc(&q, &r, &a2, &b2);</span>
<span class="line" id="L237"></span>
<span class="line" id="L238"> <span class="tok-kw">var</span> mantissa = extractLowBits(q, BitReprType);</span>
<span class="line" id="L239"> <span class="tok-kw">var</span> have_rem = r.len() > <span class="tok-number">0</span>;</span>
<span class="line" id="L240"></span>
<span class="line" id="L241"> <span class="tok-comment">// 3. q didn't fit in msize2 bits, redo division b2 << 1</span>
</span>
<span class="line" id="L242"> <span class="tok-kw">if</span> (mantissa >> msize2 == <span class="tok-number">1</span>) {</span>
<span class="line" id="L243"> <span class="tok-kw">if</span> (mantissa & <span class="tok-number">1</span> == <span class="tok-number">1</span>) {</span>
<span class="line" id="L244"> have_rem = <span class="tok-null">true</span>;</span>
<span class="line" id="L245"> }</span>
<span class="line" id="L246"> mantissa >>= <span class="tok-number">1</span>;</span>
<span class="line" id="L247"> exp += <span class="tok-number">1</span>;</span>
<span class="line" id="L248"> }</span>
<span class="line" id="L249"> <span class="tok-kw">if</span> (mantissa >> msize1 != <span class="tok-number">1</span>) {</span>
<span class="line" id="L250"> <span class="tok-comment">// NOTE: This can be hit if the limb size is small (u8/16).</span>
</span>
<span class="line" id="L251"> <span class="tok-builtin">@panic</span>(<span class="tok-str">"unexpected bits in result"</span>);</span>
<span class="line" id="L252"> }</span>
<span class="line" id="L253"></span>
<span class="line" id="L254"> <span class="tok-comment">// 4. Rounding</span>
</span>
<span class="line" id="L255"> <span class="tok-kw">if</span> (emin - msize <= exp <span class="tok-kw">and</span> exp <= emin) {</span>
<span class="line" id="L256"> <span class="tok-comment">// denormal</span>
</span>
<span class="line" id="L257"> <span class="tok-kw">const</span> shift1 = <span class="tok-builtin">@as</span>(math.Log2Int(BitReprType), <span class="tok-builtin">@intCast</span>(emin - (exp - <span class="tok-number">1</span>)));</span>
<span class="line" id="L258"> <span class="tok-kw">const</span> lost_bits = mantissa & ((<span class="tok-builtin">@as</span>(BitReprType, <span class="tok-builtin">@intCast</span>(<span class="tok-number">1</span>)) << shift1) - <span class="tok-number">1</span>);</span>
<span class="line" id="L259"> have_rem = have_rem <span class="tok-kw">or</span> lost_bits != <span class="tok-number">0</span>;</span>
<span class="line" id="L260"> mantissa >>= shift1;</span>
<span class="line" id="L261"> exp = <span class="tok-number">2</span> - ebias;</span>
<span class="line" id="L262"> }</span>
<span class="line" id="L263"></span>
<span class="line" id="L264"> <span class="tok-comment">// round q using round-half-to-even</span>
</span>
<span class="line" id="L265"> <span class="tok-kw">var</span> exact = !have_rem;</span>
<span class="line" id="L266"> <span class="tok-kw">if</span> (mantissa & <span class="tok-number">1</span> != <span class="tok-number">0</span>) {</span>
<span class="line" id="L267"> exact = <span class="tok-null">false</span>;</span>
<span class="line" id="L268"> <span class="tok-kw">if</span> (have_rem <span class="tok-kw">or</span> (mantissa & <span class="tok-number">2</span> != <span class="tok-number">0</span>)) {</span>
<span class="line" id="L269"> mantissa += <span class="tok-number">1</span>;</span>
<span class="line" id="L270"> <span class="tok-kw">if</span> (mantissa >= <span class="tok-number">1</span> << msize2) {</span>
<span class="line" id="L271"> <span class="tok-comment">// 11...1 => 100...0</span>
</span>
<span class="line" id="L272"> mantissa >>= <span class="tok-number">1</span>;</span>
<span class="line" id="L273"> exp += <span class="tok-number">1</span>;</span>
<span class="line" id="L274"> }</span>
<span class="line" id="L275"> }</span>
<span class="line" id="L276"> }</span>
<span class="line" id="L277"> mantissa >>= <span class="tok-number">1</span>;</span>
<span class="line" id="L278"></span>
<span class="line" id="L279"> <span class="tok-kw">const</span> f = math.scalbn(<span class="tok-builtin">@as</span>(T, <span class="tok-builtin">@floatFromInt</span>(mantissa)), <span class="tok-builtin">@as</span>(<span class="tok-type">i32</span>, <span class="tok-builtin">@intCast</span>(exp - msize1)));</span>
<span class="line" id="L280"> <span class="tok-kw">if</span> (math.isInf(f)) {</span>
<span class="line" id="L281"> exact = <span class="tok-null">false</span>;</span>
<span class="line" id="L282"> }</span>
<span class="line" id="L283"></span>
<span class="line" id="L284"> <span class="tok-kw">return</span> <span class="tok-kw">if</span> (self.p.isPositive()) f <span class="tok-kw">else</span> -f;</span>
<span class="line" id="L285"> }</span>
<span class="line" id="L286"></span>
<span class="line" id="L287"> <span class="tok-comment">/// Set a rational from an integer ratio.</span></span>
<span class="line" id="L288"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">setRatio</span>(self: *Rational, p: <span class="tok-kw">anytype</span>, q: <span class="tok-kw">anytype</span>) !<span class="tok-type">void</span> {</span>
<span class="line" id="L289"> <span class="tok-kw">try</span> self.p.set(p);</span>
<span class="line" id="L290"> <span class="tok-kw">try</span> self.q.set(q);</span>
<span class="line" id="L291"></span>
<span class="line" id="L292"> self.p.setSign(<span class="tok-builtin">@intFromBool</span>(self.p.isPositive()) ^ <span class="tok-builtin">@intFromBool</span>(self.q.isPositive()) == <span class="tok-number">0</span>);</span>
<span class="line" id="L293"> self.q.setSign(<span class="tok-null">true</span>);</span>
<span class="line" id="L294"></span>
<span class="line" id="L295"> <span class="tok-kw">try</span> self.reduce();</span>
<span class="line" id="L296"></span>
<span class="line" id="L297"> <span class="tok-kw">if</span> (self.q.eqlZero()) {</span>
<span class="line" id="L298"> <span class="tok-builtin">@panic</span>(<span class="tok-str">"cannot set rational with denominator = 0"</span>);</span>
<span class="line" id="L299"> }</span>
<span class="line" id="L300"> }</span>
<span class="line" id="L301"></span>
<span class="line" id="L302"> <span class="tok-comment">/// Set a Rational directly from an Int.</span></span>
<span class="line" id="L303"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">copyInt</span>(self: *Rational, a: Int) !<span class="tok-type">void</span> {</span>
<span class="line" id="L304"> <span class="tok-kw">try</span> self.p.copy(a.toConst());</span>
<span class="line" id="L305"> <span class="tok-kw">try</span> self.q.set(<span class="tok-number">1</span>);</span>
<span class="line" id="L306"> }</span>
<span class="line" id="L307"></span>
<span class="line" id="L308"> <span class="tok-comment">/// Set a Rational directly from a ratio of two Int's.</span></span>
<span class="line" id="L309"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">copyRatio</span>(self: *Rational, a: Int, b: Int) !<span class="tok-type">void</span> {</span>
<span class="line" id="L310"> <span class="tok-kw">try</span> self.p.copy(a.toConst());</span>
<span class="line" id="L311"> <span class="tok-kw">try</span> self.q.copy(b.toConst());</span>
<span class="line" id="L312"></span>
<span class="line" id="L313"> self.p.setSign(<span class="tok-builtin">@intFromBool</span>(self.p.isPositive()) ^ <span class="tok-builtin">@intFromBool</span>(self.q.isPositive()) == <span class="tok-number">0</span>);</span>
<span class="line" id="L314"> self.q.setSign(<span class="tok-null">true</span>);</span>
<span class="line" id="L315"></span>
<span class="line" id="L316"> <span class="tok-kw">try</span> self.reduce();</span>
<span class="line" id="L317"> }</span>
<span class="line" id="L318"></span>
<span class="line" id="L319"> <span class="tok-comment">/// Make a Rational positive.</span></span>
<span class="line" id="L320"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">abs</span>(r: *Rational) <span class="tok-type">void</span> {</span>
<span class="line" id="L321"> r.p.abs();</span>
<span class="line" id="L322"> }</span>
<span class="line" id="L323"></span>
<span class="line" id="L324"> <span class="tok-comment">/// Negate the sign of a Rational.</span></span>
<span class="line" id="L325"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">negate</span>(r: *Rational) <span class="tok-type">void</span> {</span>
<span class="line" id="L326"> r.p.negate();</span>
<span class="line" id="L327"> }</span>
<span class="line" id="L328"></span>
<span class="line" id="L329"> <span class="tok-comment">/// Efficiently swap a Rational with another. This swaps the limb pointers and a full copy is not</span></span>
<span class="line" id="L330"> <span class="tok-comment">/// performed. The address of the limbs field will not be the same after this function.</span></span>
<span class="line" id="L331"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">swap</span>(r: *Rational, other: *Rational) <span class="tok-type">void</span> {</span>
<span class="line" id="L332"> r.p.swap(&other.p);</span>
<span class="line" id="L333"> r.q.swap(&other.q);</span>
<span class="line" id="L334"> }</span>
<span class="line" id="L335"></span>
<span class="line" id="L336"> <span class="tok-comment">/// Returns math.Order.lt, math.Order.eq, math.Order.gt if a < b, a == b or a</span></span>
<span class="line" id="L337"> <span class="tok-comment">/// > b respectively.</span></span>
<span class="line" id="L338"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">order</span>(a: Rational, b: Rational) !math.Order {</span>
<span class="line" id="L339"> <span class="tok-kw">return</span> cmpInternal(a, b, <span class="tok-null">false</span>);</span>
<span class="line" id="L340"> }</span>
<span class="line" id="L341"></span>
<span class="line" id="L342"> <span class="tok-comment">/// Returns math.Order.lt, math.Order.eq, math.Order.gt if |a| < |b|, |a| ==</span></span>
<span class="line" id="L343"> <span class="tok-comment">/// |b| or |a| > |b| respectively.</span></span>
<span class="line" id="L344"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">orderAbs</span>(a: Rational, b: Rational) !math.Order {</span>
<span class="line" id="L345"> <span class="tok-kw">return</span> cmpInternal(a, b, <span class="tok-null">true</span>);</span>
<span class="line" id="L346"> }</span>
<span class="line" id="L347"></span>
<span class="line" id="L348"> <span class="tok-comment">// p/q > x/y iff p*y > x*q</span>
</span>
<span class="line" id="L349"> <span class="tok-kw">fn</span> <span class="tok-fn">cmpInternal</span>(a: Rational, b: Rational, is_abs: <span class="tok-type">bool</span>) !math.Order {</span>
<span class="line" id="L350"> <span class="tok-comment">// TODO: Would a div compare algorithm of sorts be viable and quicker? Can we avoid</span>
</span>
<span class="line" id="L351"> <span class="tok-comment">// the memory allocations here?</span>
</span>
<span class="line" id="L352"> <span class="tok-kw">var</span> q = <span class="tok-kw">try</span> Int.init(a.p.allocator);</span>
<span class="line" id="L353"> <span class="tok-kw">defer</span> q.deinit();</span>
<span class="line" id="L354"></span>
<span class="line" id="L355"> <span class="tok-kw">var</span> p = <span class="tok-kw">try</span> Int.init(b.p.allocator);</span>
<span class="line" id="L356"> <span class="tok-kw">defer</span> p.deinit();</span>
<span class="line" id="L357"></span>
<span class="line" id="L358"> <span class="tok-kw">try</span> q.mul(&a.p, &b.q);</span>
<span class="line" id="L359"> <span class="tok-kw">try</span> p.mul(&b.p, &a.q);</span>
<span class="line" id="L360"></span>
<span class="line" id="L361"> <span class="tok-kw">return</span> <span class="tok-kw">if</span> (is_abs) q.orderAbs(p) <span class="tok-kw">else</span> q.order(p);</span>
<span class="line" id="L362"> }</span>
<span class="line" id="L363"></span>
<span class="line" id="L364"> <span class="tok-comment">/// rma = a + b.</span></span>
<span class="line" id="L365"> <span class="tok-comment">///</span></span>
<span class="line" id="L366"> <span class="tok-comment">/// rma, a and b may be aliases. However, it is more efficient if rma does not alias a or b.</span></span>
<span class="line" id="L367"> <span class="tok-comment">///</span></span>
<span class="line" id="L368"> <span class="tok-comment">/// Returns an error if memory could not be allocated.</span></span>
<span class="line" id="L369"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">add</span>(rma: *Rational, a: Rational, b: Rational) !<span class="tok-type">void</span> {</span>
<span class="line" id="L370"> <span class="tok-kw">var</span> r = rma;</span>
<span class="line" id="L371"> <span class="tok-kw">var</span> aliased = rma.p.limbs.ptr == a.p.limbs.ptr <span class="tok-kw">or</span> rma.p.limbs.ptr == b.p.limbs.ptr;</span>
<span class="line" id="L372"></span>
<span class="line" id="L373"> <span class="tok-kw">var</span> sr: Rational = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L374"> <span class="tok-kw">if</span> (aliased) {</span>
<span class="line" id="L375"> sr = <span class="tok-kw">try</span> Rational.init(rma.p.allocator);</span>
<span class="line" id="L376"> r = &sr;</span>
<span class="line" id="L377"> aliased = <span class="tok-null">true</span>;</span>
<span class="line" id="L378"> }</span>
<span class="line" id="L379"> <span class="tok-kw">defer</span> <span class="tok-kw">if</span> (aliased) {</span>
<span class="line" id="L380"> rma.swap(r);</span>
<span class="line" id="L381"> r.deinit();</span>
<span class="line" id="L382"> };</span>
<span class="line" id="L383"></span>
<span class="line" id="L384"> <span class="tok-kw">try</span> r.p.mul(&a.p, &b.q);</span>
<span class="line" id="L385"> <span class="tok-kw">try</span> r.q.mul(&b.p, &a.q);</span>
<span class="line" id="L386"> <span class="tok-kw">try</span> r.p.add(&r.p, &r.q);</span>
<span class="line" id="L387"></span>
<span class="line" id="L388"> <span class="tok-kw">try</span> r.q.mul(&a.q, &b.q);</span>
<span class="line" id="L389"> <span class="tok-kw">try</span> r.reduce();</span>
<span class="line" id="L390"> }</span>
<span class="line" id="L391"></span>
<span class="line" id="L392"> <span class="tok-comment">/// rma = a - b.</span></span>
<span class="line" id="L393"> <span class="tok-comment">///</span></span>
<span class="line" id="L394"> <span class="tok-comment">/// rma, a and b may be aliases. However, it is more efficient if rma does not alias a or b.</span></span>
<span class="line" id="L395"> <span class="tok-comment">///</span></span>
<span class="line" id="L396"> <span class="tok-comment">/// Returns an error if memory could not be allocated.</span></span>
<span class="line" id="L397"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">sub</span>(rma: *Rational, a: Rational, b: Rational) !<span class="tok-type">void</span> {</span>
<span class="line" id="L398"> <span class="tok-kw">var</span> r = rma;</span>
<span class="line" id="L399"> <span class="tok-kw">var</span> aliased = rma.p.limbs.ptr == a.p.limbs.ptr <span class="tok-kw">or</span> rma.p.limbs.ptr == b.p.limbs.ptr;</span>
<span class="line" id="L400"></span>
<span class="line" id="L401"> <span class="tok-kw">var</span> sr: Rational = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L402"> <span class="tok-kw">if</span> (aliased) {</span>
<span class="line" id="L403"> sr = <span class="tok-kw">try</span> Rational.init(rma.p.allocator);</span>
<span class="line" id="L404"> r = &sr;</span>
<span class="line" id="L405"> aliased = <span class="tok-null">true</span>;</span>
<span class="line" id="L406"> }</span>
<span class="line" id="L407"> <span class="tok-kw">defer</span> <span class="tok-kw">if</span> (aliased) {</span>
<span class="line" id="L408"> rma.swap(r);</span>
<span class="line" id="L409"> r.deinit();</span>
<span class="line" id="L410"> };</span>
<span class="line" id="L411"></span>
<span class="line" id="L412"> <span class="tok-kw">try</span> r.p.mul(&a.p, &b.q);</span>
<span class="line" id="L413"> <span class="tok-kw">try</span> r.q.mul(&b.p, &a.q);</span>
<span class="line" id="L414"> <span class="tok-kw">try</span> r.p.sub(&r.p, &r.q);</span>
<span class="line" id="L415"></span>
<span class="line" id="L416"> <span class="tok-kw">try</span> r.q.mul(&a.q, &b.q);</span>
<span class="line" id="L417"> <span class="tok-kw">try</span> r.reduce();</span>
<span class="line" id="L418"> }</span>
<span class="line" id="L419"></span>
<span class="line" id="L420"> <span class="tok-comment">/// rma = a * b.</span></span>
<span class="line" id="L421"> <span class="tok-comment">///</span></span>
<span class="line" id="L422"> <span class="tok-comment">/// rma, a and b may be aliases. However, it is more efficient if rma does not alias a or b.</span></span>
<span class="line" id="L423"> <span class="tok-comment">///</span></span>
<span class="line" id="L424"> <span class="tok-comment">/// Returns an error if memory could not be allocated.</span></span>
<span class="line" id="L425"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">mul</span>(r: *Rational, a: Rational, b: Rational) !<span class="tok-type">void</span> {</span>
<span class="line" id="L426"> <span class="tok-kw">try</span> r.p.mul(&a.p, &b.p);</span>
<span class="line" id="L427"> <span class="tok-kw">try</span> r.q.mul(&a.q, &b.q);</span>
<span class="line" id="L428"> <span class="tok-kw">try</span> r.reduce();</span>
<span class="line" id="L429"> }</span>
<span class="line" id="L430"></span>
<span class="line" id="L431"> <span class="tok-comment">/// rma = a / b.</span></span>
<span class="line" id="L432"> <span class="tok-comment">///</span></span>
<span class="line" id="L433"> <span class="tok-comment">/// rma, a and b may be aliases. However, it is more efficient if rma does not alias a or b.</span></span>
<span class="line" id="L434"> <span class="tok-comment">///</span></span>
<span class="line" id="L435"> <span class="tok-comment">/// Returns an error if memory could not be allocated.</span></span>
<span class="line" id="L436"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">div</span>(r: *Rational, a: Rational, b: Rational) !<span class="tok-type">void</span> {</span>
<span class="line" id="L437"> <span class="tok-kw">if</span> (b.p.eqlZero()) {</span>
<span class="line" id="L438"> <span class="tok-builtin">@panic</span>(<span class="tok-str">"division by zero"</span>);</span>
<span class="line" id="L439"> }</span>
<span class="line" id="L440"></span>
<span class="line" id="L441"> <span class="tok-kw">try</span> r.p.mul(&a.p, &b.q);</span>
<span class="line" id="L442"> <span class="tok-kw">try</span> r.q.mul(&b.p, &a.q);</span>
<span class="line" id="L443"> <span class="tok-kw">try</span> r.reduce();</span>
<span class="line" id="L444"> }</span>
<span class="line" id="L445"></span>
<span class="line" id="L446"> <span class="tok-comment">/// Invert the numerator and denominator fields of a Rational. p/q => q/p.</span></span>
<span class="line" id="L447"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">invert</span>(r: *Rational) <span class="tok-type">void</span> {</span>
<span class="line" id="L448"> Int.swap(&r.p, &r.q);</span>
<span class="line" id="L449"> }</span>
<span class="line" id="L450"></span>
<span class="line" id="L451"> <span class="tok-comment">// reduce r/q such that gcd(r, q) = 1</span>
</span>
<span class="line" id="L452"> <span class="tok-kw">fn</span> <span class="tok-fn">reduce</span>(r: *Rational) !<span class="tok-type">void</span> {</span>
<span class="line" id="L453"> <span class="tok-kw">var</span> a = <span class="tok-kw">try</span> Int.init(r.p.allocator);</span>
<span class="line" id="L454"> <span class="tok-kw">defer</span> a.deinit();</span>
<span class="line" id="L455"></span>
<span class="line" id="L456"> <span class="tok-kw">const</span> sign = r.p.isPositive();</span>
<span class="line" id="L457"> r.p.abs();</span>
<span class="line" id="L458"> <span class="tok-kw">try</span> a.gcd(&r.p, &r.q);</span>
<span class="line" id="L459"> r.p.setSign(sign);</span>
<span class="line" id="L460"></span>
<span class="line" id="L461"> <span class="tok-kw">const</span> one = IntConst{ .limbs = &[_]Limb{<span class="tok-number">1</span>}, .positive = <span class="tok-null">true</span> };</span>
<span class="line" id="L462"> <span class="tok-kw">if</span> (a.toConst().order(one) != .eq) {</span>
<span class="line" id="L463"> <span class="tok-kw">var</span> unused = <span class="tok-kw">try</span> Int.init(r.p.allocator);</span>
<span class="line" id="L464"> <span class="tok-kw">defer</span> unused.deinit();</span>
<span class="line" id="L465"></span>
<span class="line" id="L466"> <span class="tok-comment">// TODO: divexact would be useful here</span>
</span>
<span class="line" id="L467"> <span class="tok-comment">// TODO: don't copy r.q for div</span>
</span>
<span class="line" id="L468"> <span class="tok-kw">try</span> Int.divTrunc(&r.p, &unused, &r.p, &a);</span>
<span class="line" id="L469"> <span class="tok-kw">try</span> Int.divTrunc(&r.q, &unused, &r.q, &a);</span>
<span class="line" id="L470"> }</span>
<span class="line" id="L471"> }</span>
<span class="line" id="L472">};</span>
<span class="line" id="L473"></span>
<span class="line" id="L474"><span class="tok-kw">fn</span> <span class="tok-fn">extractLowBits</span>(a: Int, <span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>) T {</span>
<span class="line" id="L475"> debug.assert(<span class="tok-builtin">@typeInfo</span>(T) == .Int);</span>
<span class="line" id="L476"></span>
<span class="line" id="L477"> <span class="tok-kw">const</span> t_bits = <span class="tok-builtin">@typeInfo</span>(T).Int.bits;</span>
<span class="line" id="L478"> <span class="tok-kw">const</span> limb_bits = <span class="tok-builtin">@typeInfo</span>(Limb).Int.bits;</span>
<span class="line" id="L479"> <span class="tok-kw">if</span> (t_bits <= limb_bits) {</span>
<span class="line" id="L480"> <span class="tok-kw">return</span> <span class="tok-builtin">@as</span>(T, <span class="tok-builtin">@truncate</span>(a.limbs[<span class="tok-number">0</span>]));</span>
<span class="line" id="L481"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L482"> <span class="tok-kw">var</span> r: T = <span class="tok-number">0</span>;</span>
<span class="line" id="L483"> <span class="tok-kw">comptime</span> <span class="tok-kw">var</span> i: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L484"></span>
<span class="line" id="L485"> <span class="tok-comment">// Remainder is always 0 since if t_bits >= limb_bits -> Limb | T and both</span>
</span>
<span class="line" id="L486"> <span class="tok-comment">// are powers of two.</span>
</span>
<span class="line" id="L487"> <span class="tok-kw">inline</span> <span class="tok-kw">while</span> (i < t_bits / limb_bits) : (i += <span class="tok-number">1</span>) {</span>
<span class="line" id="L488"> r |= math.shl(T, a.limbs[i], i * limb_bits);</span>
<span class="line" id="L489"> }</span>
<span class="line" id="L490"></span>
<span class="line" id="L491"> <span class="tok-kw">return</span> r;</span>
<span class="line" id="L492"> }</span>
<span class="line" id="L493">}</span>
<span class="line" id="L494"></span>
<span class="line" id="L495"><span class="tok-kw">test</span> <span class="tok-str">"big.rational extractLowBits"</span> {</span>
<span class="line" id="L496"> <span class="tok-kw">var</span> a = <span class="tok-kw">try</span> Int.initSet(testing.allocator, <span class="tok-number">0x11112222333344441234567887654321</span>);</span>
<span class="line" id="L497"> <span class="tok-kw">defer</span> a.deinit();</span>
<span class="line" id="L498"></span>
<span class="line" id="L499"> <span class="tok-kw">const</span> a1 = extractLowBits(a, <span class="tok-type">u8</span>);</span>
<span class="line" id="L500"> <span class="tok-kw">try</span> testing.expect(a1 == <span class="tok-number">0x21</span>);</span>
<span class="line" id="L501"></span>
<span class="line" id="L502"> <span class="tok-kw">const</span> a2 = extractLowBits(a, <span class="tok-type">u16</span>);</span>
<span class="line" id="L503"> <span class="tok-kw">try</span> testing.expect(a2 == <span class="tok-number">0x4321</span>);</span>
<span class="line" id="L504"></span>
<span class="line" id="L505"> <span class="tok-kw">const</span> a3 = extractLowBits(a, <span class="tok-type">u32</span>);</span>
<span class="line" id="L506"> <span class="tok-kw">try</span> testing.expect(a3 == <span class="tok-number">0x87654321</span>);</span>
<span class="line" id="L507"></span>
<span class="line" id="L508"> <span class="tok-kw">const</span> a4 = extractLowBits(a, <span class="tok-type">u64</span>);</span>
<span class="line" id="L509"> <span class="tok-kw">try</span> testing.expect(a4 == <span class="tok-number">0x1234567887654321</span>);</span>
<span class="line" id="L510"></span>
<span class="line" id="L511"> <span class="tok-kw">const</span> a5 = extractLowBits(a, <span class="tok-type">u128</span>);</span>
<span class="line" id="L512"> <span class="tok-kw">try</span> testing.expect(a5 == <span class="tok-number">0x11112222333344441234567887654321</span>);</span>
<span class="line" id="L513">}</span>
<span class="line" id="L514"></span>
<span class="line" id="L515"><span class="tok-kw">test</span> <span class="tok-str">"big.rational set"</span> {</span>
<span class="line" id="L516"> <span class="tok-kw">var</span> a = <span class="tok-kw">try</span> Rational.init(testing.allocator);</span>
<span class="line" id="L517"> <span class="tok-kw">defer</span> a.deinit();</span>
<span class="line" id="L518"></span>
<span class="line" id="L519"> <span class="tok-kw">try</span> a.setInt(<span class="tok-number">5</span>);</span>
<span class="line" id="L520"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> a.p.to(<span class="tok-type">u32</span>)) == <span class="tok-number">5</span>);</span>
<span class="line" id="L521"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> a.q.to(<span class="tok-type">u32</span>)) == <span class="tok-number">1</span>);</span>
<span class="line" id="L522"></span>
<span class="line" id="L523"> <span class="tok-kw">try</span> a.setRatio(<span class="tok-number">7</span>, <span class="tok-number">3</span>);</span>
<span class="line" id="L524"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> a.p.to(<span class="tok-type">u32</span>)) == <span class="tok-number">7</span>);</span>
<span class="line" id="L525"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> a.q.to(<span class="tok-type">u32</span>)) == <span class="tok-number">3</span>);</span>
<span class="line" id="L526"></span>
<span class="line" id="L527"> <span class="tok-kw">try</span> a.setRatio(<span class="tok-number">9</span>, <span class="tok-number">3</span>);</span>
<span class="line" id="L528"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> a.p.to(<span class="tok-type">i32</span>)) == <span class="tok-number">3</span>);</span>
<span class="line" id="L529"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> a.q.to(<span class="tok-type">i32</span>)) == <span class="tok-number">1</span>);</span>
<span class="line" id="L530"></span>
<span class="line" id="L531"> <span class="tok-kw">try</span> a.setRatio(-<span class="tok-number">9</span>, <span class="tok-number">3</span>);</span>
<span class="line" id="L532"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> a.p.to(<span class="tok-type">i32</span>)) == -<span class="tok-number">3</span>);</span>
<span class="line" id="L533"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> a.q.to(<span class="tok-type">i32</span>)) == <span class="tok-number">1</span>);</span>
<span class="line" id="L534"></span>
<span class="line" id="L535"> <span class="tok-kw">try</span> a.setRatio(<span class="tok-number">9</span>, -<span class="tok-number">3</span>);</span>
<span class="line" id="L536"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> a.p.to(<span class="tok-type">i32</span>)) == -<span class="tok-number">3</span>);</span>
<span class="line" id="L537"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> a.q.to(<span class="tok-type">i32</span>)) == <span class="tok-number">1</span>);</span>
<span class="line" id="L538"></span>
<span class="line" id="L539"> <span class="tok-kw">try</span> a.setRatio(-<span class="tok-number">9</span>, -<span class="tok-number">3</span>);</span>
<span class="line" id="L540"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> a.p.to(<span class="tok-type">i32</span>)) == <span class="tok-number">3</span>);</span>
<span class="line" id="L541"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> a.q.to(<span class="tok-type">i32</span>)) == <span class="tok-number">1</span>);</span>
<span class="line" id="L542">}</span>
<span class="line" id="L543"></span>
<span class="line" id="L544"><span class="tok-kw">test</span> <span class="tok-str">"big.rational setFloat"</span> {</span>
<span class="line" id="L545"> <span class="tok-kw">var</span> a = <span class="tok-kw">try</span> Rational.init(testing.allocator);</span>
<span class="line" id="L546"> <span class="tok-kw">defer</span> a.deinit();</span>
<span class="line" id="L547"></span>
<span class="line" id="L548"> <span class="tok-kw">try</span> a.setFloat(<span class="tok-type">f64</span>, <span class="tok-number">2.5</span>);</span>
<span class="line" id="L549"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> a.p.to(<span class="tok-type">i32</span>)) == <span class="tok-number">5</span>);</span>
<span class="line" id="L550"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> a.q.to(<span class="tok-type">i32</span>)) == <span class="tok-number">2</span>);</span>
<span class="line" id="L551"></span>
<span class="line" id="L552"> <span class="tok-kw">try</span> a.setFloat(<span class="tok-type">f32</span>, -<span class="tok-number">2.5</span>);</span>
<span class="line" id="L553"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> a.p.to(<span class="tok-type">i32</span>)) == -<span class="tok-number">5</span>);</span>
<span class="line" id="L554"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> a.q.to(<span class="tok-type">i32</span>)) == <span class="tok-number">2</span>);</span>
<span class="line" id="L555"></span>
<span class="line" id="L556"> <span class="tok-kw">try</span> a.setFloat(<span class="tok-type">f32</span>, <span class="tok-number">3.141593</span>);</span>
<span class="line" id="L557"></span>
<span class="line" id="L558"> <span class="tok-comment">// = 3.14159297943115234375</span>
</span>
<span class="line" id="L559"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> a.p.to(<span class="tok-type">u32</span>)) == <span class="tok-number">3294199</span>);</span>
<span class="line" id="L560"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> a.q.to(<span class="tok-type">u32</span>)) == <span class="tok-number">1048576</span>);</span>
<span class="line" id="L561"></span>
<span class="line" id="L562"> <span class="tok-kw">try</span> a.setFloat(<span class="tok-type">f64</span>, <span class="tok-number">72.141593120712409172417410926841290461290467124</span>);</span>
<span class="line" id="L563"></span>
<span class="line" id="L564"> <span class="tok-comment">// = 72.1415931207124145885245525278151035308837890625</span>
</span>
<span class="line" id="L565"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> a.p.to(<span class="tok-type">u128</span>)) == <span class="tok-number">5076513310880537</span>);</span>
<span class="line" id="L566"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> a.q.to(<span class="tok-type">u128</span>)) == <span class="tok-number">70368744177664</span>);</span>
<span class="line" id="L567">}</span>
<span class="line" id="L568"></span>
<span class="line" id="L569"><span class="tok-kw">test</span> <span class="tok-str">"big.rational setFloatString"</span> {</span>
<span class="line" id="L570"> <span class="tok-kw">var</span> a = <span class="tok-kw">try</span> Rational.init(testing.allocator);</span>
<span class="line" id="L571"> <span class="tok-kw">defer</span> a.deinit();</span>
<span class="line" id="L572"></span>
<span class="line" id="L573"> <span class="tok-kw">try</span> a.setFloatString(<span class="tok-str">"72.14159312071241458852455252781510353"</span>);</span>
<span class="line" id="L574"></span>
<span class="line" id="L575"> <span class="tok-comment">// = 72.1415931207124145885245525278151035308837890625</span>
</span>
<span class="line" id="L576"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> a.p.to(<span class="tok-type">u128</span>)) == <span class="tok-number">7214159312071241458852455252781510353</span>);</span>
<span class="line" id="L577"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> a.q.to(<span class="tok-type">u128</span>)) == <span class="tok-number">100000000000000000000000000000000000</span>);</span>
<span class="line" id="L578">}</span>
<span class="line" id="L579"></span>
<span class="line" id="L580"><span class="tok-kw">test</span> <span class="tok-str">"big.rational toFloat"</span> {</span>
<span class="line" id="L581"> <span class="tok-kw">var</span> a = <span class="tok-kw">try</span> Rational.init(testing.allocator);</span>
<span class="line" id="L582"> <span class="tok-kw">defer</span> a.deinit();</span>
<span class="line" id="L583"></span>
<span class="line" id="L584"> <span class="tok-comment">// = 3.14159297943115234375</span>
</span>
<span class="line" id="L585"> <span class="tok-kw">try</span> a.setRatio(<span class="tok-number">3294199</span>, <span class="tok-number">1048576</span>);</span>
<span class="line" id="L586"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> a.toFloat(<span class="tok-type">f64</span>)) == <span class="tok-number">3.14159297943115234375</span>);</span>
<span class="line" id="L587"></span>
<span class="line" id="L588"> <span class="tok-comment">// = 72.1415931207124145885245525278151035308837890625</span>
</span>
<span class="line" id="L589"> <span class="tok-kw">try</span> a.setRatio(<span class="tok-number">5076513310880537</span>, <span class="tok-number">70368744177664</span>);</span>
<span class="line" id="L590"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> a.toFloat(<span class="tok-type">f64</span>)) == <span class="tok-number">72.141593120712409172417410926841290461290467124</span>);</span>
<span class="line" id="L591">}</span>
<span class="line" id="L592"></span>
<span class="line" id="L593"><span class="tok-kw">test</span> <span class="tok-str">"big.rational set/to Float round-trip"</span> {</span>
<span class="line" id="L594"> <span class="tok-kw">var</span> a = <span class="tok-kw">try</span> Rational.init(testing.allocator);</span>
<span class="line" id="L595"> <span class="tok-kw">defer</span> a.deinit();</span>
<span class="line" id="L596"> <span class="tok-kw">var</span> prng = std.rand.DefaultPrng.init(<span class="tok-number">0x5EED</span>);</span>
<span class="line" id="L597"> <span class="tok-kw">const</span> random = prng.random();</span>
<span class="line" id="L598"> <span class="tok-kw">var</span> i: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L599"> <span class="tok-kw">while</span> (i < <span class="tok-number">512</span>) : (i += <span class="tok-number">1</span>) {</span>
<span class="line" id="L600"> <span class="tok-kw">const</span> r = random.float(<span class="tok-type">f64</span>);</span>
<span class="line" id="L601"> <span class="tok-kw">try</span> a.setFloat(<span class="tok-type">f64</span>, r);</span>
<span class="line" id="L602"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> a.toFloat(<span class="tok-type">f64</span>)) == r);</span>
<span class="line" id="L603"> }</span>
<span class="line" id="L604">}</span>
<span class="line" id="L605"></span>
<span class="line" id="L606"><span class="tok-kw">test</span> <span class="tok-str">"big.rational copy"</span> {</span>
<span class="line" id="L607"> <span class="tok-kw">var</span> a = <span class="tok-kw">try</span> Rational.init(testing.allocator);</span>
<span class="line" id="L608"> <span class="tok-kw">defer</span> a.deinit();</span>
<span class="line" id="L609"></span>
<span class="line" id="L610"> <span class="tok-kw">var</span> b = <span class="tok-kw">try</span> Int.initSet(testing.allocator, <span class="tok-number">5</span>);</span>
<span class="line" id="L611"> <span class="tok-kw">defer</span> b.deinit();</span>
<span class="line" id="L612"></span>
<span class="line" id="L613"> <span class="tok-kw">try</span> a.copyInt(b);</span>
<span class="line" id="L614"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> a.p.to(<span class="tok-type">u32</span>)) == <span class="tok-number">5</span>);</span>
<span class="line" id="L615"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> a.q.to(<span class="tok-type">u32</span>)) == <span class="tok-number">1</span>);</span>
<span class="line" id="L616"></span>
<span class="line" id="L617"> <span class="tok-kw">var</span> c = <span class="tok-kw">try</span> Int.initSet(testing.allocator, <span class="tok-number">7</span>);</span>
<span class="line" id="L618"> <span class="tok-kw">defer</span> c.deinit();</span>
<span class="line" id="L619"> <span class="tok-kw">var</span> d = <span class="tok-kw">try</span> Int.initSet(testing.allocator, <span class="tok-number">3</span>);</span>
<span class="line" id="L620"> <span class="tok-kw">defer</span> d.deinit();</span>
<span class="line" id="L621"></span>
<span class="line" id="L622"> <span class="tok-kw">try</span> a.copyRatio(c, d);</span>
<span class="line" id="L623"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> a.p.to(<span class="tok-type">u32</span>)) == <span class="tok-number">7</span>);</span>
<span class="line" id="L624"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> a.q.to(<span class="tok-type">u32</span>)) == <span class="tok-number">3</span>);</span>
<span class="line" id="L625"></span>
<span class="line" id="L626"> <span class="tok-kw">var</span> e = <span class="tok-kw">try</span> Int.initSet(testing.allocator, <span class="tok-number">9</span>);</span>
<span class="line" id="L627"> <span class="tok-kw">defer</span> e.deinit();</span>
<span class="line" id="L628"> <span class="tok-kw">var</span> f = <span class="tok-kw">try</span> Int.initSet(testing.allocator, <span class="tok-number">3</span>);</span>
<span class="line" id="L629"> <span class="tok-kw">defer</span> f.deinit();</span>
<span class="line" id="L630"></span>
<span class="line" id="L631"> <span class="tok-kw">try</span> a.copyRatio(e, f);</span>
<span class="line" id="L632"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> a.p.to(<span class="tok-type">u32</span>)) == <span class="tok-number">3</span>);</span>
<span class="line" id="L633"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> a.q.to(<span class="tok-type">u32</span>)) == <span class="tok-number">1</span>);</span>
<span class="line" id="L634">}</span>
<span class="line" id="L635"></span>
<span class="line" id="L636"><span class="tok-kw">test</span> <span class="tok-str">"big.rational negate"</span> {</span>
<span class="line" id="L637"> <span class="tok-kw">var</span> a = <span class="tok-kw">try</span> Rational.init(testing.allocator);</span>
<span class="line" id="L638"> <span class="tok-kw">defer</span> a.deinit();</span>
<span class="line" id="L639"></span>
<span class="line" id="L640"> <span class="tok-kw">try</span> a.setInt(-<span class="tok-number">50</span>);</span>
<span class="line" id="L641"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> a.p.to(<span class="tok-type">i32</span>)) == -<span class="tok-number">50</span>);</span>
<span class="line" id="L642"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> a.q.to(<span class="tok-type">i32</span>)) == <span class="tok-number">1</span>);</span>
<span class="line" id="L643"></span>
<span class="line" id="L644"> a.negate();</span>
<span class="line" id="L645"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> a.p.to(<span class="tok-type">i32</span>)) == <span class="tok-number">50</span>);</span>
<span class="line" id="L646"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> a.q.to(<span class="tok-type">i32</span>)) == <span class="tok-number">1</span>);</span>
<span class="line" id="L647"></span>
<span class="line" id="L648"> a.negate();</span>
<span class="line" id="L649"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> a.p.to(<span class="tok-type">i32</span>)) == -<span class="tok-number">50</span>);</span>
<span class="line" id="L650"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> a.q.to(<span class="tok-type">i32</span>)) == <span class="tok-number">1</span>);</span>
<span class="line" id="L651">}</span>
<span class="line" id="L652"></span>
<span class="line" id="L653"><span class="tok-kw">test</span> <span class="tok-str">"big.rational abs"</span> {</span>
<span class="line" id="L654"> <span class="tok-kw">var</span> a = <span class="tok-kw">try</span> Rational.init(testing.allocator);</span>
<span class="line" id="L655"> <span class="tok-kw">defer</span> a.deinit();</span>
<span class="line" id="L656"></span>
<span class="line" id="L657"> <span class="tok-kw">try</span> a.setInt(-<span class="tok-number">50</span>);</span>
<span class="line" id="L658"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> a.p.to(<span class="tok-type">i32</span>)) == -<span class="tok-number">50</span>);</span>
<span class="line" id="L659"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> a.q.to(<span class="tok-type">i32</span>)) == <span class="tok-number">1</span>);</span>
<span class="line" id="L660"></span>
<span class="line" id="L661"> a.abs();</span>
<span class="line" id="L662"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> a.p.to(<span class="tok-type">i32</span>)) == <span class="tok-number">50</span>);</span>
<span class="line" id="L663"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> a.q.to(<span class="tok-type">i32</span>)) == <span class="tok-number">1</span>);</span>
<span class="line" id="L664"></span>
<span class="line" id="L665"> a.abs();</span>
<span class="line" id="L666"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> a.p.to(<span class="tok-type">i32</span>)) == <span class="tok-number">50</span>);</span>
<span class="line" id="L667"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> a.q.to(<span class="tok-type">i32</span>)) == <span class="tok-number">1</span>);</span>
<span class="line" id="L668">}</span>
<span class="line" id="L669"></span>
<span class="line" id="L670"><span class="tok-kw">test</span> <span class="tok-str">"big.rational swap"</span> {</span>
<span class="line" id="L671"> <span class="tok-kw">var</span> a = <span class="tok-kw">try</span> Rational.init(testing.allocator);</span>
<span class="line" id="L672"> <span class="tok-kw">defer</span> a.deinit();</span>
<span class="line" id="L673"> <span class="tok-kw">var</span> b = <span class="tok-kw">try</span> Rational.init(testing.allocator);</span>
<span class="line" id="L674"> <span class="tok-kw">defer</span> b.deinit();</span>
<span class="line" id="L675"></span>
<span class="line" id="L676"> <span class="tok-kw">try</span> a.setRatio(<span class="tok-number">50</span>, <span class="tok-number">23</span>);</span>
<span class="line" id="L677"> <span class="tok-kw">try</span> b.setRatio(<span class="tok-number">17</span>, <span class="tok-number">3</span>);</span>
<span class="line" id="L678"></span>
<span class="line" id="L679"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> a.p.to(<span class="tok-type">u32</span>)) == <span class="tok-number">50</span>);</span>
<span class="line" id="L680"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> a.q.to(<span class="tok-type">u32</span>)) == <span class="tok-number">23</span>);</span>
<span class="line" id="L681"></span>
<span class="line" id="L682"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> b.p.to(<span class="tok-type">u32</span>)) == <span class="tok-number">17</span>);</span>
<span class="line" id="L683"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> b.q.to(<span class="tok-type">u32</span>)) == <span class="tok-number">3</span>);</span>
<span class="line" id="L684"></span>
<span class="line" id="L685"> a.swap(&b);</span>
<span class="line" id="L686"></span>
<span class="line" id="L687"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> a.p.to(<span class="tok-type">u32</span>)) == <span class="tok-number">17</span>);</span>
<span class="line" id="L688"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> a.q.to(<span class="tok-type">u32</span>)) == <span class="tok-number">3</span>);</span>
<span class="line" id="L689"></span>
<span class="line" id="L690"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> b.p.to(<span class="tok-type">u32</span>)) == <span class="tok-number">50</span>);</span>
<span class="line" id="L691"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> b.q.to(<span class="tok-type">u32</span>)) == <span class="tok-number">23</span>);</span>
<span class="line" id="L692">}</span>
<span class="line" id="L693"></span>
<span class="line" id="L694"><span class="tok-kw">test</span> <span class="tok-str">"big.rational order"</span> {</span>
<span class="line" id="L695"> <span class="tok-kw">var</span> a = <span class="tok-kw">try</span> Rational.init(testing.allocator);</span>
<span class="line" id="L696"> <span class="tok-kw">defer</span> a.deinit();</span>
<span class="line" id="L697"> <span class="tok-kw">var</span> b = <span class="tok-kw">try</span> Rational.init(testing.allocator);</span>
<span class="line" id="L698"> <span class="tok-kw">defer</span> b.deinit();</span>
<span class="line" id="L699"></span>
<span class="line" id="L700"> <span class="tok-kw">try</span> a.setRatio(<span class="tok-number">500</span>, <span class="tok-number">231</span>);</span>
<span class="line" id="L701"> <span class="tok-kw">try</span> b.setRatio(<span class="tok-number">18903</span>, <span class="tok-number">8584</span>);</span>
<span class="line" id="L702"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> a.order(b)) == .lt);</span>
<span class="line" id="L703"></span>
<span class="line" id="L704"> <span class="tok-kw">try</span> a.setRatio(<span class="tok-number">890</span>, <span class="tok-number">10</span>);</span>
<span class="line" id="L705"> <span class="tok-kw">try</span> b.setRatio(<span class="tok-number">89</span>, <span class="tok-number">1</span>);</span>
<span class="line" id="L706"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> a.order(b)) == .eq);</span>
<span class="line" id="L707">}</span>
<span class="line" id="L708"></span>
<span class="line" id="L709"><span class="tok-kw">test</span> <span class="tok-str">"big.rational order/orderAbs with negative"</span> {</span>
<span class="line" id="L710"> <span class="tok-kw">var</span> a = <span class="tok-kw">try</span> Rational.init(testing.allocator);</span>
<span class="line" id="L711"> <span class="tok-kw">defer</span> a.deinit();</span>
<span class="line" id="L712"> <span class="tok-kw">var</span> b = <span class="tok-kw">try</span> Rational.init(testing.allocator);</span>
<span class="line" id="L713"> <span class="tok-kw">defer</span> b.deinit();</span>
<span class="line" id="L714"></span>
<span class="line" id="L715"> <span class="tok-kw">try</span> a.setRatio(<span class="tok-number">1</span>, <span class="tok-number">1</span>);</span>
<span class="line" id="L716"> <span class="tok-kw">try</span> b.setRatio(-<span class="tok-number">2</span>, <span class="tok-number">1</span>);</span>
<span class="line" id="L717"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> a.order(b)) == .gt);</span>
<span class="line" id="L718"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> a.orderAbs(b)) == .lt);</span>
<span class="line" id="L719">}</span>
<span class="line" id="L720"></span>
<span class="line" id="L721"><span class="tok-kw">test</span> <span class="tok-str">"big.rational add single-limb"</span> {</span>
<span class="line" id="L722"> <span class="tok-kw">var</span> a = <span class="tok-kw">try</span> Rational.init(testing.allocator);</span>
<span class="line" id="L723"> <span class="tok-kw">defer</span> a.deinit();</span>
<span class="line" id="L724"> <span class="tok-kw">var</span> b = <span class="tok-kw">try</span> Rational.init(testing.allocator);</span>
<span class="line" id="L725"> <span class="tok-kw">defer</span> b.deinit();</span>
<span class="line" id="L726"></span>
<span class="line" id="L727"> <span class="tok-kw">try</span> a.setRatio(<span class="tok-number">500</span>, <span class="tok-number">231</span>);</span>
<span class="line" id="L728"> <span class="tok-kw">try</span> b.setRatio(<span class="tok-number">18903</span>, <span class="tok-number">8584</span>);</span>
<span class="line" id="L729"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> a.order(b)) == .lt);</span>
<span class="line" id="L730"></span>
<span class="line" id="L731"> <span class="tok-kw">try</span> a.setRatio(<span class="tok-number">890</span>, <span class="tok-number">10</span>);</span>
<span class="line" id="L732"> <span class="tok-kw">try</span> b.setRatio(<span class="tok-number">89</span>, <span class="tok-number">1</span>);</span>
<span class="line" id="L733"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> a.order(b)) == .eq);</span>
<span class="line" id="L734">}</span>
<span class="line" id="L735"></span>
<span class="line" id="L736"><span class="tok-kw">test</span> <span class="tok-str">"big.rational add"</span> {</span>
<span class="line" id="L737"> <span class="tok-kw">var</span> a = <span class="tok-kw">try</span> Rational.init(testing.allocator);</span>
<span class="line" id="L738"> <span class="tok-kw">defer</span> a.deinit();</span>
<span class="line" id="L739"> <span class="tok-kw">var</span> b = <span class="tok-kw">try</span> Rational.init(testing.allocator);</span>
<span class="line" id="L740"> <span class="tok-kw">defer</span> b.deinit();</span>
<span class="line" id="L741"> <span class="tok-kw">var</span> r = <span class="tok-kw">try</span> Rational.init(testing.allocator);</span>
<span class="line" id="L742"> <span class="tok-kw">defer</span> r.deinit();</span>
<span class="line" id="L743"></span>
<span class="line" id="L744"> <span class="tok-kw">try</span> a.setRatio(<span class="tok-number">78923</span>, <span class="tok-number">23341</span>);</span>
<span class="line" id="L745"> <span class="tok-kw">try</span> b.setRatio(<span class="tok-number">123097</span>, <span class="tok-number">12441414</span>);</span>
<span class="line" id="L746"> <span class="tok-kw">try</span> a.add(a, b);</span>
<span class="line" id="L747"></span>
<span class="line" id="L748"> <span class="tok-kw">try</span> r.setRatio(<span class="tok-number">984786924199</span>, <span class="tok-number">290395044174</span>);</span>
<span class="line" id="L749"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> a.order(r)) == .eq);</span>
<span class="line" id="L750">}</span>
<span class="line" id="L751"></span>
<span class="line" id="L752"><span class="tok-kw">test</span> <span class="tok-str">"big.rational sub"</span> {</span>
<span class="line" id="L753"> <span class="tok-kw">var</span> a = <span class="tok-kw">try</span> Rational.init(testing.allocator);</span>
<span class="line" id="L754"> <span class="tok-kw">defer</span> a.deinit();</span>
<span class="line" id="L755"> <span class="tok-kw">var</span> b = <span class="tok-kw">try</span> Rational.init(testing.allocator);</span>
<span class="line" id="L756"> <span class="tok-kw">defer</span> b.deinit();</span>
<span class="line" id="L757"> <span class="tok-kw">var</span> r = <span class="tok-kw">try</span> Rational.init(testing.allocator);</span>
<span class="line" id="L758"> <span class="tok-kw">defer</span> r.deinit();</span>
<span class="line" id="L759"></span>
<span class="line" id="L760"> <span class="tok-kw">try</span> a.setRatio(<span class="tok-number">78923</span>, <span class="tok-number">23341</span>);</span>
<span class="line" id="L761"> <span class="tok-kw">try</span> b.setRatio(<span class="tok-number">123097</span>, <span class="tok-number">12441414</span>);</span>
<span class="line" id="L762"> <span class="tok-kw">try</span> a.sub(a, b);</span>
<span class="line" id="L763"></span>
<span class="line" id="L764"> <span class="tok-kw">try</span> r.setRatio(<span class="tok-number">979040510045</span>, <span class="tok-number">290395044174</span>);</span>
<span class="line" id="L765"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> a.order(r)) == .eq);</span>
<span class="line" id="L766">}</span>
<span class="line" id="L767"></span>
<span class="line" id="L768"><span class="tok-kw">test</span> <span class="tok-str">"big.rational mul"</span> {</span>
<span class="line" id="L769"> <span class="tok-kw">var</span> a = <span class="tok-kw">try</span> Rational.init(testing.allocator);</span>
<span class="line" id="L770"> <span class="tok-kw">defer</span> a.deinit();</span>
<span class="line" id="L771"> <span class="tok-kw">var</span> b = <span class="tok-kw">try</span> Rational.init(testing.allocator);</span>
<span class="line" id="L772"> <span class="tok-kw">defer</span> b.deinit();</span>
<span class="line" id="L773"> <span class="tok-kw">var</span> r = <span class="tok-kw">try</span> Rational.init(testing.allocator);</span>
<span class="line" id="L774"> <span class="tok-kw">defer</span> r.deinit();</span>
<span class="line" id="L775"></span>
<span class="line" id="L776"> <span class="tok-kw">try</span> a.setRatio(<span class="tok-number">78923</span>, <span class="tok-number">23341</span>);</span>
<span class="line" id="L777"> <span class="tok-kw">try</span> b.setRatio(<span class="tok-number">123097</span>, <span class="tok-number">12441414</span>);</span>
<span class="line" id="L778"> <span class="tok-kw">try</span> a.mul(a, b);</span>
<span class="line" id="L779"></span>
<span class="line" id="L780"> <span class="tok-kw">try</span> r.setRatio(<span class="tok-number">571481443</span>, <span class="tok-number">17082061422</span>);</span>
<span class="line" id="L781"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> a.order(r)) == .eq);</span>
<span class="line" id="L782">}</span>
<span class="line" id="L783"></span>
<span class="line" id="L784"><span class="tok-kw">test</span> <span class="tok-str">"big.rational div"</span> {</span>
<span class="line" id="L785"> {</span>
<span class="line" id="L786"> <span class="tok-kw">var</span> a = <span class="tok-kw">try</span> Rational.init(testing.allocator);</span>
<span class="line" id="L787"> <span class="tok-kw">defer</span> a.deinit();</span>
<span class="line" id="L788"> <span class="tok-kw">var</span> b = <span class="tok-kw">try</span> Rational.init(testing.allocator);</span>
<span class="line" id="L789"> <span class="tok-kw">defer</span> b.deinit();</span>
<span class="line" id="L790"> <span class="tok-kw">var</span> r = <span class="tok-kw">try</span> Rational.init(testing.allocator);</span>
<span class="line" id="L791"> <span class="tok-kw">defer</span> r.deinit();</span>
<span class="line" id="L792"></span>
<span class="line" id="L793"> <span class="tok-kw">try</span> a.setRatio(<span class="tok-number">78923</span>, <span class="tok-number">23341</span>);</span>
<span class="line" id="L794"> <span class="tok-kw">try</span> b.setRatio(<span class="tok-number">123097</span>, <span class="tok-number">12441414</span>);</span>
<span class="line" id="L795"> <span class="tok-kw">try</span> a.div(a, b);</span>
<span class="line" id="L796"></span>
<span class="line" id="L797"> <span class="tok-kw">try</span> r.setRatio(<span class="tok-number">75531824394</span>, <span class="tok-number">221015929</span>);</span>
<span class="line" id="L798"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> a.order(r)) == .eq);</span>
<span class="line" id="L799"> }</span>
<span class="line" id="L800"></span>
<span class="line" id="L801"> {</span>
<span class="line" id="L802"> <span class="tok-kw">var</span> a = <span class="tok-kw">try</span> Rational.init(testing.allocator);</span>
<span class="line" id="L803"> <span class="tok-kw">defer</span> a.deinit();</span>
<span class="line" id="L804"> <span class="tok-kw">var</span> r = <span class="tok-kw">try</span> Rational.init(testing.allocator);</span>
<span class="line" id="L805"> <span class="tok-kw">defer</span> r.deinit();</span>
<span class="line" id="L806"></span>
<span class="line" id="L807"> <span class="tok-kw">try</span> a.setRatio(<span class="tok-number">78923</span>, <span class="tok-number">23341</span>);</span>
<span class="line" id="L808"> a.invert();</span>
<span class="line" id="L809"></span>
<span class="line" id="L810"> <span class="tok-kw">try</span> r.setRatio(<span class="tok-number">23341</span>, <span class="tok-number">78923</span>);</span>
<span class="line" id="L811"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> a.order(r)) == .eq);</span>
<span class="line" id="L812"></span>
<span class="line" id="L813"> <span class="tok-kw">try</span> a.setRatio(-<span class="tok-number">78923</span>, <span class="tok-number">23341</span>);</span>
<span class="line" id="L814"> a.invert();</span>
<span class="line" id="L815"></span>
<span class="line" id="L816"> <span class="tok-kw">try</span> r.setRatio(-<span class="tok-number">23341</span>, <span class="tok-number">78923</span>);</span>
<span class="line" id="L817"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> a.order(r)) == .eq);</span>
<span class="line" id="L818"> }</span>
<span class="line" id="L819">}</span>
<span class="line" id="L820"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std/math | repos/yazap/docs/src/std/math/big/int.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>math/big/int.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../../std.zig"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> builtin = <span class="tok-builtin">@import</span>(<span class="tok-str">"builtin"</span>);</span>
<span class="line" id="L3"><span class="tok-kw">const</span> math = std.math;</span>
<span class="line" id="L4"><span class="tok-kw">const</span> Limb = std.math.big.Limb;</span>
<span class="line" id="L5"><span class="tok-kw">const</span> limb_bits = <span class="tok-builtin">@typeInfo</span>(Limb).Int.bits;</span>
<span class="line" id="L6"><span class="tok-kw">const</span> HalfLimb = std.math.big.HalfLimb;</span>
<span class="line" id="L7"><span class="tok-kw">const</span> half_limb_bits = <span class="tok-builtin">@typeInfo</span>(HalfLimb).Int.bits;</span>
<span class="line" id="L8"><span class="tok-kw">const</span> DoubleLimb = std.math.big.DoubleLimb;</span>
<span class="line" id="L9"><span class="tok-kw">const</span> SignedDoubleLimb = std.math.big.SignedDoubleLimb;</span>
<span class="line" id="L10"><span class="tok-kw">const</span> Log2Limb = std.math.big.Log2Limb;</span>
<span class="line" id="L11"><span class="tok-kw">const</span> Allocator = std.mem.Allocator;</span>
<span class="line" id="L12"><span class="tok-kw">const</span> mem = std.mem;</span>
<span class="line" id="L13"><span class="tok-kw">const</span> maxInt = std.math.maxInt;</span>
<span class="line" id="L14"><span class="tok-kw">const</span> minInt = std.math.minInt;</span>
<span class="line" id="L15"><span class="tok-kw">const</span> assert = std.debug.assert;</span>
<span class="line" id="L16"><span class="tok-kw">const</span> Endian = std.builtin.Endian;</span>
<span class="line" id="L17"><span class="tok-kw">const</span> Signedness = std.builtin.Signedness;</span>
<span class="line" id="L18"><span class="tok-kw">const</span> native_endian = builtin.cpu.arch.endian();</span>
<span class="line" id="L19"></span>
<span class="line" id="L20"><span class="tok-kw">const</span> debug_safety = <span class="tok-null">false</span>;</span>
<span class="line" id="L21"></span>
<span class="line" id="L22"><span class="tok-comment">/// Returns the number of limbs needed to store `scalar`, which must be a</span></span>
<span class="line" id="L23"><span class="tok-comment">/// primitive integer value.</span></span>
<span class="line" id="L24"><span class="tok-comment">/// Note: A comptime-known upper bound of this value that may be used</span></span>
<span class="line" id="L25"><span class="tok-comment">/// instead if `scalar` is not already comptime-known is</span></span>
<span class="line" id="L26"><span class="tok-comment">/// `calcTwosCompLimbCount(@typeInfo(@TypeOf(scalar)).Int.bits)`</span></span>
<span class="line" id="L27"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">calcLimbLen</span>(scalar: <span class="tok-kw">anytype</span>) <span class="tok-type">usize</span> {</span>
<span class="line" id="L28"> <span class="tok-kw">if</span> (scalar == <span class="tok-number">0</span>) {</span>
<span class="line" id="L29"> <span class="tok-kw">return</span> <span class="tok-number">1</span>;</span>
<span class="line" id="L30"> }</span>
<span class="line" id="L31"></span>
<span class="line" id="L32"> <span class="tok-kw">const</span> w_value = std.math.absCast(scalar);</span>
<span class="line" id="L33"> <span class="tok-kw">return</span> <span class="tok-builtin">@as</span>(<span class="tok-type">usize</span>, <span class="tok-builtin">@intCast</span>(<span class="tok-builtin">@divFloor</span>(<span class="tok-builtin">@as</span>(Limb, <span class="tok-builtin">@intCast</span>(math.log2(w_value))), limb_bits) + <span class="tok-number">1</span>));</span>
<span class="line" id="L34">}</span>
<span class="line" id="L35"></span>
<span class="line" id="L36"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">calcToStringLimbsBufferLen</span>(a_len: <span class="tok-type">usize</span>, base: <span class="tok-type">u8</span>) <span class="tok-type">usize</span> {</span>
<span class="line" id="L37"> <span class="tok-kw">if</span> (math.isPowerOfTwo(base))</span>
<span class="line" id="L38"> <span class="tok-kw">return</span> <span class="tok-number">0</span>;</span>
<span class="line" id="L39"> <span class="tok-kw">return</span> a_len + <span class="tok-number">2</span> + a_len + calcDivLimbsBufferLen(a_len, <span class="tok-number">1</span>);</span>
<span class="line" id="L40">}</span>
<span class="line" id="L41"></span>
<span class="line" id="L42"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">calcDivLimbsBufferLen</span>(a_len: <span class="tok-type">usize</span>, b_len: <span class="tok-type">usize</span>) <span class="tok-type">usize</span> {</span>
<span class="line" id="L43"> <span class="tok-kw">return</span> a_len + b_len + <span class="tok-number">4</span>;</span>
<span class="line" id="L44">}</span>
<span class="line" id="L45"></span>
<span class="line" id="L46"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">calcMulLimbsBufferLen</span>(a_len: <span class="tok-type">usize</span>, b_len: <span class="tok-type">usize</span>, aliases: <span class="tok-type">usize</span>) <span class="tok-type">usize</span> {</span>
<span class="line" id="L47"> <span class="tok-kw">return</span> aliases * <span class="tok-builtin">@max</span>(a_len, b_len);</span>
<span class="line" id="L48">}</span>
<span class="line" id="L49"></span>
<span class="line" id="L50"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">calcMulWrapLimbsBufferLen</span>(bit_count: <span class="tok-type">usize</span>, a_len: <span class="tok-type">usize</span>, b_len: <span class="tok-type">usize</span>, aliases: <span class="tok-type">usize</span>) <span class="tok-type">usize</span> {</span>
<span class="line" id="L51"> <span class="tok-kw">const</span> req_limbs = calcTwosCompLimbCount(bit_count);</span>
<span class="line" id="L52"> <span class="tok-kw">return</span> aliases * <span class="tok-builtin">@min</span>(req_limbs, <span class="tok-builtin">@max</span>(a_len, b_len));</span>
<span class="line" id="L53">}</span>
<span class="line" id="L54"></span>
<span class="line" id="L55"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">calcSetStringLimbsBufferLen</span>(base: <span class="tok-type">u8</span>, string_len: <span class="tok-type">usize</span>) <span class="tok-type">usize</span> {</span>
<span class="line" id="L56"> <span class="tok-kw">const</span> limb_count = calcSetStringLimbCount(base, string_len);</span>
<span class="line" id="L57"> <span class="tok-kw">return</span> calcMulLimbsBufferLen(limb_count, limb_count, <span class="tok-number">2</span>);</span>
<span class="line" id="L58">}</span>
<span class="line" id="L59"></span>
<span class="line" id="L60"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">calcSetStringLimbCount</span>(base: <span class="tok-type">u8</span>, string_len: <span class="tok-type">usize</span>) <span class="tok-type">usize</span> {</span>
<span class="line" id="L61"> <span class="tok-kw">return</span> (string_len + (limb_bits / base - <span class="tok-number">1</span>)) / (limb_bits / base);</span>
<span class="line" id="L62">}</span>
<span class="line" id="L63"></span>
<span class="line" id="L64"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">calcPowLimbsBufferLen</span>(a_bit_count: <span class="tok-type">usize</span>, y: <span class="tok-type">usize</span>) <span class="tok-type">usize</span> {</span>
<span class="line" id="L65"> <span class="tok-comment">// The 2 accounts for the minimum space requirement for llmulacc</span>
</span>
<span class="line" id="L66"> <span class="tok-kw">return</span> <span class="tok-number">2</span> + (a_bit_count * y + (limb_bits - <span class="tok-number">1</span>)) / limb_bits;</span>
<span class="line" id="L67">}</span>
<span class="line" id="L68"></span>
<span class="line" id="L69"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">calcSqrtLimbsBufferLen</span>(a_bit_count: <span class="tok-type">usize</span>) <span class="tok-type">usize</span> {</span>
<span class="line" id="L70"> <span class="tok-kw">const</span> a_limb_count = (a_bit_count - <span class="tok-number">1</span>) / limb_bits + <span class="tok-number">1</span>;</span>
<span class="line" id="L71"> <span class="tok-kw">const</span> shift = (a_bit_count + <span class="tok-number">1</span>) / <span class="tok-number">2</span>;</span>
<span class="line" id="L72"> <span class="tok-kw">const</span> u_s_rem_limb_count = <span class="tok-number">1</span> + ((shift - <span class="tok-number">1</span>) / limb_bits + <span class="tok-number">1</span>);</span>
<span class="line" id="L73"> <span class="tok-kw">return</span> a_limb_count + <span class="tok-number">3</span> * u_s_rem_limb_count + calcDivLimbsBufferLen(a_limb_count, u_s_rem_limb_count);</span>
<span class="line" id="L74">}</span>
<span class="line" id="L75"></span>
<span class="line" id="L76"><span class="tok-comment">// Compute the number of limbs required to store a 2s-complement number of `bit_count` bits.</span>
</span>
<span class="line" id="L77"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">calcTwosCompLimbCount</span>(bit_count: <span class="tok-type">usize</span>) <span class="tok-type">usize</span> {</span>
<span class="line" id="L78"> <span class="tok-kw">return</span> std.math.divCeil(<span class="tok-type">usize</span>, bit_count, <span class="tok-builtin">@bitSizeOf</span>(Limb)) <span class="tok-kw">catch</span> <span class="tok-kw">unreachable</span>;</span>
<span class="line" id="L79">}</span>
<span class="line" id="L80"></span>
<span class="line" id="L81"><span class="tok-comment">/// a + b * c + *carry, sets carry to the overflow bits</span></span>
<span class="line" id="L82"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addMulLimbWithCarry</span>(a: Limb, b: Limb, c: Limb, carry: *Limb) Limb {</span>
<span class="line" id="L83"> <span class="tok-builtin">@setRuntimeSafety</span>(debug_safety);</span>
<span class="line" id="L84"></span>
<span class="line" id="L85"> <span class="tok-comment">// ov1[0] = a + *carry</span>
</span>
<span class="line" id="L86"> <span class="tok-kw">const</span> ov1 = <span class="tok-builtin">@addWithOverflow</span>(a, carry.*);</span>
<span class="line" id="L87"></span>
<span class="line" id="L88"> <span class="tok-comment">// r2 = b * c</span>
</span>
<span class="line" id="L89"> <span class="tok-kw">const</span> bc = <span class="tok-builtin">@as</span>(DoubleLimb, math.mulWide(Limb, b, c));</span>
<span class="line" id="L90"> <span class="tok-kw">const</span> r2 = <span class="tok-builtin">@as</span>(Limb, <span class="tok-builtin">@truncate</span>(bc));</span>
<span class="line" id="L91"> <span class="tok-kw">const</span> c2 = <span class="tok-builtin">@as</span>(Limb, <span class="tok-builtin">@truncate</span>(bc >> limb_bits));</span>
<span class="line" id="L92"></span>
<span class="line" id="L93"> <span class="tok-comment">// ov2[0] = ov1[0] + r2</span>
</span>
<span class="line" id="L94"> <span class="tok-kw">const</span> ov2 = <span class="tok-builtin">@addWithOverflow</span>(ov1[<span class="tok-number">0</span>], r2);</span>
<span class="line" id="L95"></span>
<span class="line" id="L96"> <span class="tok-comment">// This never overflows, c1, c3 are either 0 or 1 and if both are 1 then</span>
</span>
<span class="line" id="L97"> <span class="tok-comment">// c2 is at least <= maxInt(Limb) - 2.</span>
</span>
<span class="line" id="L98"> carry.* = ov1[<span class="tok-number">1</span>] + c2 + ov2[<span class="tok-number">1</span>];</span>
<span class="line" id="L99"></span>
<span class="line" id="L100"> <span class="tok-kw">return</span> ov2[<span class="tok-number">0</span>];</span>
<span class="line" id="L101">}</span>
<span class="line" id="L102"></span>
<span class="line" id="L103"><span class="tok-comment">/// a - b * c - *carry, sets carry to the overflow bits</span></span>
<span class="line" id="L104"><span class="tok-kw">fn</span> <span class="tok-fn">subMulLimbWithBorrow</span>(a: Limb, b: Limb, c: Limb, carry: *Limb) Limb {</span>
<span class="line" id="L105"> <span class="tok-comment">// ov1[0] = a - *carry</span>
</span>
<span class="line" id="L106"> <span class="tok-kw">const</span> ov1 = <span class="tok-builtin">@subWithOverflow</span>(a, carry.*);</span>
<span class="line" id="L107"></span>
<span class="line" id="L108"> <span class="tok-comment">// r2 = b * c</span>
</span>
<span class="line" id="L109"> <span class="tok-kw">const</span> bc = <span class="tok-builtin">@as</span>(DoubleLimb, std.math.mulWide(Limb, b, c));</span>
<span class="line" id="L110"> <span class="tok-kw">const</span> r2 = <span class="tok-builtin">@as</span>(Limb, <span class="tok-builtin">@truncate</span>(bc));</span>
<span class="line" id="L111"> <span class="tok-kw">const</span> c2 = <span class="tok-builtin">@as</span>(Limb, <span class="tok-builtin">@truncate</span>(bc >> limb_bits));</span>
<span class="line" id="L112"></span>
<span class="line" id="L113"> <span class="tok-comment">// ov2[0] = ov1[0] - r2</span>
</span>
<span class="line" id="L114"> <span class="tok-kw">const</span> ov2 = <span class="tok-builtin">@subWithOverflow</span>(ov1[<span class="tok-number">0</span>], r2);</span>
<span class="line" id="L115"> carry.* = ov1[<span class="tok-number">1</span>] + c2 + ov2[<span class="tok-number">1</span>];</span>
<span class="line" id="L116"></span>
<span class="line" id="L117"> <span class="tok-kw">return</span> ov2[<span class="tok-number">0</span>];</span>
<span class="line" id="L118">}</span>
<span class="line" id="L119"></span>
<span class="line" id="L120"><span class="tok-comment">/// Used to indicate either limit of a 2s-complement integer.</span></span>
<span class="line" id="L121"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> TwosCompIntLimit = <span class="tok-kw">enum</span> {</span>
<span class="line" id="L122"> <span class="tok-comment">// The low limit, either 0x00 (unsigned) or (-)0x80 (signed) for an 8-bit integer.</span>
</span>
<span class="line" id="L123"> min,</span>
<span class="line" id="L124"></span>
<span class="line" id="L125"> <span class="tok-comment">// The high limit, either 0xFF (unsigned) or 0x7F (signed) for an 8-bit integer.</span>
</span>
<span class="line" id="L126"> max,</span>
<span class="line" id="L127">};</span>
<span class="line" id="L128"></span>
<span class="line" id="L129"><span class="tok-comment">/// A arbitrary-precision big integer, with a fixed set of mutable limbs.</span></span>
<span class="line" id="L130"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> Mutable = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L131"> <span class="tok-comment">/// Raw digits. These are:</span></span>
<span class="line" id="L132"> <span class="tok-comment">///</span></span>
<span class="line" id="L133"> <span class="tok-comment">/// * Little-endian ordered</span></span>
<span class="line" id="L134"> <span class="tok-comment">/// * limbs.len >= 1</span></span>
<span class="line" id="L135"> <span class="tok-comment">/// * Zero is represented as limbs.len == 1 with limbs[0] == 0.</span></span>
<span class="line" id="L136"> <span class="tok-comment">///</span></span>
<span class="line" id="L137"> <span class="tok-comment">/// Accessing limbs directly should be avoided.</span></span>
<span class="line" id="L138"> <span class="tok-comment">/// These are allocated limbs; the `len` field tells the valid range.</span></span>
<span class="line" id="L139"> limbs: []Limb,</span>
<span class="line" id="L140"> len: <span class="tok-type">usize</span>,</span>
<span class="line" id="L141"> positive: <span class="tok-type">bool</span>,</span>
<span class="line" id="L142"></span>
<span class="line" id="L143"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">toConst</span>(self: Mutable) Const {</span>
<span class="line" id="L144"> <span class="tok-kw">return</span> .{</span>
<span class="line" id="L145"> .limbs = self.limbs[<span class="tok-number">0</span>..self.len],</span>
<span class="line" id="L146"> .positive = self.positive,</span>
<span class="line" id="L147"> };</span>
<span class="line" id="L148"> }</span>
<span class="line" id="L149"></span>
<span class="line" id="L150"> <span class="tok-comment">// TODO: remove after release of 0.11</span>
</span>
<span class="line" id="L151"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> eqZero = <span class="tok-builtin">@compileError</span>(<span class="tok-str">"use eqlZero"</span>);</span>
<span class="line" id="L152"></span>
<span class="line" id="L153"> <span class="tok-comment">/// Returns true if `a == 0`.</span></span>
<span class="line" id="L154"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">eqlZero</span>(self: Mutable) <span class="tok-type">bool</span> {</span>
<span class="line" id="L155"> <span class="tok-kw">return</span> self.toConst().eqlZero();</span>
<span class="line" id="L156"> }</span>
<span class="line" id="L157"></span>
<span class="line" id="L158"> <span class="tok-comment">/// Asserts that the allocator owns the limbs memory. If this is not the case,</span></span>
<span class="line" id="L159"> <span class="tok-comment">/// use `toConst().toManaged()`.</span></span>
<span class="line" id="L160"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">toManaged</span>(self: Mutable, allocator: Allocator) Managed {</span>
<span class="line" id="L161"> <span class="tok-kw">return</span> .{</span>
<span class="line" id="L162"> .allocator = allocator,</span>
<span class="line" id="L163"> .limbs = self.limbs,</span>
<span class="line" id="L164"> .metadata = <span class="tok-kw">if</span> (self.positive)</span>
<span class="line" id="L165"> self.len & ~Managed.sign_bit</span>
<span class="line" id="L166"> <span class="tok-kw">else</span></span>
<span class="line" id="L167"> self.len | Managed.sign_bit,</span>
<span class="line" id="L168"> };</span>
<span class="line" id="L169"> }</span>
<span class="line" id="L170"></span>
<span class="line" id="L171"> <span class="tok-comment">/// `value` is a primitive integer type.</span></span>
<span class="line" id="L172"> <span class="tok-comment">/// Asserts the value fits within the provided `limbs_buffer`.</span></span>
<span class="line" id="L173"> <span class="tok-comment">/// Note: `calcLimbLen` can be used to figure out how big an array to allocate for `limbs_buffer`.</span></span>
<span class="line" id="L174"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">init</span>(limbs_buffer: []Limb, value: <span class="tok-kw">anytype</span>) Mutable {</span>
<span class="line" id="L175"> limbs_buffer[<span class="tok-number">0</span>] = <span class="tok-number">0</span>;</span>
<span class="line" id="L176"> <span class="tok-kw">var</span> self: Mutable = .{</span>
<span class="line" id="L177"> .limbs = limbs_buffer,</span>
<span class="line" id="L178"> .len = <span class="tok-number">1</span>,</span>
<span class="line" id="L179"> .positive = <span class="tok-null">true</span>,</span>
<span class="line" id="L180"> };</span>
<span class="line" id="L181"> self.set(value);</span>
<span class="line" id="L182"> <span class="tok-kw">return</span> self;</span>
<span class="line" id="L183"> }</span>
<span class="line" id="L184"></span>
<span class="line" id="L185"> <span class="tok-comment">/// Copies the value of a Const to an existing Mutable so that they both have the same value.</span></span>
<span class="line" id="L186"> <span class="tok-comment">/// Asserts the value fits in the limbs buffer.</span></span>
<span class="line" id="L187"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">copy</span>(self: *Mutable, other: Const) <span class="tok-type">void</span> {</span>
<span class="line" id="L188"> <span class="tok-kw">if</span> (self.limbs.ptr != other.limbs.ptr) {</span>
<span class="line" id="L189"> <span class="tok-builtin">@memcpy</span>(self.limbs[<span class="tok-number">0</span>..other.limbs.len], other.limbs[<span class="tok-number">0</span>..other.limbs.len]);</span>
<span class="line" id="L190"> }</span>
<span class="line" id="L191"> self.positive = other.positive;</span>
<span class="line" id="L192"> self.len = other.limbs.len;</span>
<span class="line" id="L193"> }</span>
<span class="line" id="L194"></span>
<span class="line" id="L195"> <span class="tok-comment">/// Efficiently swap an Mutable with another. This swaps the limb pointers and a full copy is not</span></span>
<span class="line" id="L196"> <span class="tok-comment">/// performed. The address of the limbs field will not be the same after this function.</span></span>
<span class="line" id="L197"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">swap</span>(self: *Mutable, other: *Mutable) <span class="tok-type">void</span> {</span>
<span class="line" id="L198"> mem.swap(Mutable, self, other);</span>
<span class="line" id="L199"> }</span>
<span class="line" id="L200"></span>
<span class="line" id="L201"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">dump</span>(self: Mutable) <span class="tok-type">void</span> {</span>
<span class="line" id="L202"> <span class="tok-kw">for</span> (self.limbs[<span class="tok-number">0</span>..self.len]) |limb| {</span>
<span class="line" id="L203"> std.debug.print(<span class="tok-str">"{x} "</span>, .{limb});</span>
<span class="line" id="L204"> }</span>
<span class="line" id="L205"> std.debug.print(<span class="tok-str">"capacity={} positive={}\n"</span>, .{ self.limbs.len, self.positive });</span>
<span class="line" id="L206"> }</span>
<span class="line" id="L207"></span>
<span class="line" id="L208"> <span class="tok-comment">/// Clones an Mutable and returns a new Mutable with the same value. The new Mutable is a deep copy and</span></span>
<span class="line" id="L209"> <span class="tok-comment">/// can be modified separately from the original.</span></span>
<span class="line" id="L210"> <span class="tok-comment">/// Asserts that limbs is big enough to store the value.</span></span>
<span class="line" id="L211"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">clone</span>(other: Mutable, limbs: []Limb) Mutable {</span>
<span class="line" id="L212"> <span class="tok-builtin">@memcpy</span>(limbs[<span class="tok-number">0</span>..other.len], other.limbs[<span class="tok-number">0</span>..other.len]);</span>
<span class="line" id="L213"> <span class="tok-kw">return</span> .{</span>
<span class="line" id="L214"> .limbs = limbs,</span>
<span class="line" id="L215"> .len = other.len,</span>
<span class="line" id="L216"> .positive = other.positive,</span>
<span class="line" id="L217"> };</span>
<span class="line" id="L218"> }</span>
<span class="line" id="L219"></span>
<span class="line" id="L220"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">negate</span>(self: *Mutable) <span class="tok-type">void</span> {</span>
<span class="line" id="L221"> self.positive = !self.positive;</span>
<span class="line" id="L222"> }</span>
<span class="line" id="L223"></span>
<span class="line" id="L224"> <span class="tok-comment">/// Modify to become the absolute value</span></span>
<span class="line" id="L225"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">abs</span>(self: *Mutable) <span class="tok-type">void</span> {</span>
<span class="line" id="L226"> self.positive = <span class="tok-null">true</span>;</span>
<span class="line" id="L227"> }</span>
<span class="line" id="L228"></span>
<span class="line" id="L229"> <span class="tok-comment">/// Sets the Mutable to value. Value must be an primitive integer type.</span></span>
<span class="line" id="L230"> <span class="tok-comment">/// Asserts the value fits within the limbs buffer.</span></span>
<span class="line" id="L231"> <span class="tok-comment">/// Note: `calcLimbLen` can be used to figure out how big the limbs buffer</span></span>
<span class="line" id="L232"> <span class="tok-comment">/// needs to be to store a specific value.</span></span>
<span class="line" id="L233"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">set</span>(self: *Mutable, value: <span class="tok-kw">anytype</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L234"> <span class="tok-kw">const</span> T = <span class="tok-builtin">@TypeOf</span>(value);</span>
<span class="line" id="L235"> <span class="tok-kw">const</span> needed_limbs = calcLimbLen(value);</span>
<span class="line" id="L236"> assert(needed_limbs <= self.limbs.len); <span class="tok-comment">// value too big</span>
</span>
<span class="line" id="L237"></span>
<span class="line" id="L238"> self.len = needed_limbs;</span>
<span class="line" id="L239"> self.positive = value >= <span class="tok-number">0</span>;</span>
<span class="line" id="L240"></span>
<span class="line" id="L241"> <span class="tok-kw">switch</span> (<span class="tok-builtin">@typeInfo</span>(T)) {</span>
<span class="line" id="L242"> .Int => |info| {</span>
<span class="line" id="L243"> <span class="tok-kw">var</span> w_value = std.math.absCast(value);</span>
<span class="line" id="L244"></span>
<span class="line" id="L245"> <span class="tok-kw">if</span> (info.bits <= limb_bits) {</span>
<span class="line" id="L246"> self.limbs[<span class="tok-number">0</span>] = w_value;</span>
<span class="line" id="L247"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L248"> <span class="tok-kw">var</span> i: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L249"> <span class="tok-kw">while</span> (<span class="tok-null">true</span>) : (i += <span class="tok-number">1</span>) {</span>
<span class="line" id="L250"> self.limbs[i] = <span class="tok-builtin">@as</span>(Limb, <span class="tok-builtin">@truncate</span>(w_value));</span>
<span class="line" id="L251"> w_value >>= limb_bits;</span>
<span class="line" id="L252"></span>
<span class="line" id="L253"> <span class="tok-kw">if</span> (w_value == <span class="tok-number">0</span>) <span class="tok-kw">break</span>;</span>
<span class="line" id="L254"> }</span>
<span class="line" id="L255"> }</span>
<span class="line" id="L256"> },</span>
<span class="line" id="L257"> .ComptimeInt => {</span>
<span class="line" id="L258"> <span class="tok-kw">comptime</span> <span class="tok-kw">var</span> w_value = std.math.absCast(value);</span>
<span class="line" id="L259"></span>
<span class="line" id="L260"> <span class="tok-kw">if</span> (w_value <= maxInt(Limb)) {</span>
<span class="line" id="L261"> self.limbs[<span class="tok-number">0</span>] = w_value;</span>
<span class="line" id="L262"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L263"> <span class="tok-kw">const</span> mask = (<span class="tok-number">1</span> << limb_bits) - <span class="tok-number">1</span>;</span>
<span class="line" id="L264"></span>
<span class="line" id="L265"> <span class="tok-kw">comptime</span> <span class="tok-kw">var</span> i = <span class="tok-number">0</span>;</span>
<span class="line" id="L266"> <span class="tok-kw">inline</span> <span class="tok-kw">while</span> (<span class="tok-null">true</span>) : (i += <span class="tok-number">1</span>) {</span>
<span class="line" id="L267"> self.limbs[i] = w_value & mask;</span>
<span class="line" id="L268"> w_value >>= limb_bits;</span>
<span class="line" id="L269"></span>
<span class="line" id="L270"> <span class="tok-kw">if</span> (w_value == <span class="tok-number">0</span>) <span class="tok-kw">break</span>;</span>
<span class="line" id="L271"> }</span>
<span class="line" id="L272"> }</span>
<span class="line" id="L273"> },</span>
<span class="line" id="L274"> <span class="tok-kw">else</span> => <span class="tok-builtin">@compileError</span>(<span class="tok-str">"cannot set Mutable using type "</span> ++ <span class="tok-builtin">@typeName</span>(T)),</span>
<span class="line" id="L275"> }</span>
<span class="line" id="L276"> }</span>
<span class="line" id="L277"></span>
<span class="line" id="L278"> <span class="tok-comment">/// Set self from the string representation `value`.</span></span>
<span class="line" id="L279"> <span class="tok-comment">///</span></span>
<span class="line" id="L280"> <span class="tok-comment">/// `value` must contain only digits <= `base` and is case insensitive. Base prefixes are</span></span>
<span class="line" id="L281"> <span class="tok-comment">/// not allowed (e.g. 0x43 should simply be 43). Underscores in the input string are</span></span>
<span class="line" id="L282"> <span class="tok-comment">/// ignored and can be used as digit separators.</span></span>
<span class="line" id="L283"> <span class="tok-comment">///</span></span>
<span class="line" id="L284"> <span class="tok-comment">/// Asserts there is enough memory for the value in `self.limbs`. An upper bound on number of limbs can</span></span>
<span class="line" id="L285"> <span class="tok-comment">/// be determined with `calcSetStringLimbCount`.</span></span>
<span class="line" id="L286"> <span class="tok-comment">/// Asserts the base is in the range [2, 16].</span></span>
<span class="line" id="L287"> <span class="tok-comment">///</span></span>
<span class="line" id="L288"> <span class="tok-comment">/// Returns an error if the value has invalid digits for the requested base.</span></span>
<span class="line" id="L289"> <span class="tok-comment">///</span></span>
<span class="line" id="L290"> <span class="tok-comment">/// `limbs_buffer` is used for temporary storage. The size required can be found with</span></span>
<span class="line" id="L291"> <span class="tok-comment">/// `calcSetStringLimbsBufferLen`.</span></span>
<span class="line" id="L292"> <span class="tok-comment">///</span></span>
<span class="line" id="L293"> <span class="tok-comment">/// If `allocator` is provided, it will be used for temporary storage to improve</span></span>
<span class="line" id="L294"> <span class="tok-comment">/// multiplication performance. `error.OutOfMemory` is handled with a fallback algorithm.</span></span>
<span class="line" id="L295"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">setString</span>(</span>
<span class="line" id="L296"> self: *Mutable,</span>
<span class="line" id="L297"> base: <span class="tok-type">u8</span>,</span>
<span class="line" id="L298"> value: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L299"> limbs_buffer: []Limb,</span>
<span class="line" id="L300"> allocator: ?Allocator,</span>
<span class="line" id="L301"> ) <span class="tok-kw">error</span>{InvalidCharacter}!<span class="tok-type">void</span> {</span>
<span class="line" id="L302"> assert(base >= <span class="tok-number">2</span> <span class="tok-kw">and</span> base <= <span class="tok-number">16</span>);</span>
<span class="line" id="L303"></span>
<span class="line" id="L304"> <span class="tok-kw">var</span> i: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L305"> <span class="tok-kw">var</span> positive = <span class="tok-null">true</span>;</span>
<span class="line" id="L306"> <span class="tok-kw">if</span> (value.len > <span class="tok-number">0</span> <span class="tok-kw">and</span> value[<span class="tok-number">0</span>] == <span class="tok-str">'-'</span>) {</span>
<span class="line" id="L307"> positive = <span class="tok-null">false</span>;</span>
<span class="line" id="L308"> i += <span class="tok-number">1</span>;</span>
<span class="line" id="L309"> }</span>
<span class="line" id="L310"></span>
<span class="line" id="L311"> <span class="tok-kw">const</span> ap_base: Const = .{ .limbs = &[_]Limb{base}, .positive = <span class="tok-null">true</span> };</span>
<span class="line" id="L312"> self.set(<span class="tok-number">0</span>);</span>
<span class="line" id="L313"></span>
<span class="line" id="L314"> <span class="tok-kw">for</span> (value[i..]) |ch| {</span>
<span class="line" id="L315"> <span class="tok-kw">if</span> (ch == <span class="tok-str">'_'</span>) {</span>
<span class="line" id="L316"> <span class="tok-kw">continue</span>;</span>
<span class="line" id="L317"> }</span>
<span class="line" id="L318"> <span class="tok-kw">const</span> d = <span class="tok-kw">try</span> std.fmt.charToDigit(ch, base);</span>
<span class="line" id="L319"> <span class="tok-kw">const</span> ap_d: Const = .{ .limbs = &[_]Limb{d}, .positive = <span class="tok-null">true</span> };</span>
<span class="line" id="L320"></span>
<span class="line" id="L321"> self.mul(self.toConst(), ap_base, limbs_buffer, allocator);</span>
<span class="line" id="L322"> self.add(self.toConst(), ap_d);</span>
<span class="line" id="L323"> }</span>
<span class="line" id="L324"> self.positive = positive;</span>
<span class="line" id="L325"> }</span>
<span class="line" id="L326"></span>
<span class="line" id="L327"> <span class="tok-comment">/// Set self to either bound of a 2s-complement integer.</span></span>
<span class="line" id="L328"> <span class="tok-comment">/// Note: The result is still sign-magnitude, not twos complement! In order to convert the</span></span>
<span class="line" id="L329"> <span class="tok-comment">/// result to twos complement, it is sufficient to take the absolute value.</span></span>
<span class="line" id="L330"> <span class="tok-comment">///</span></span>
<span class="line" id="L331"> <span class="tok-comment">/// Asserts the result fits in `r`. An upper bound on the number of limbs needed by</span></span>
<span class="line" id="L332"> <span class="tok-comment">/// r is `calcTwosCompLimbCount(bit_count)`.</span></span>
<span class="line" id="L333"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">setTwosCompIntLimit</span>(</span>
<span class="line" id="L334"> r: *Mutable,</span>
<span class="line" id="L335"> limit: TwosCompIntLimit,</span>
<span class="line" id="L336"> signedness: Signedness,</span>
<span class="line" id="L337"> bit_count: <span class="tok-type">usize</span>,</span>
<span class="line" id="L338"> ) <span class="tok-type">void</span> {</span>
<span class="line" id="L339"> <span class="tok-comment">// Handle zero-bit types.</span>
</span>
<span class="line" id="L340"> <span class="tok-kw">if</span> (bit_count == <span class="tok-number">0</span>) {</span>
<span class="line" id="L341"> r.set(<span class="tok-number">0</span>);</span>
<span class="line" id="L342"> <span class="tok-kw">return</span>;</span>
<span class="line" id="L343"> }</span>
<span class="line" id="L344"></span>
<span class="line" id="L345"> <span class="tok-kw">const</span> req_limbs = calcTwosCompLimbCount(bit_count);</span>
<span class="line" id="L346"> <span class="tok-kw">const</span> bit = <span class="tok-builtin">@as</span>(Log2Limb, <span class="tok-builtin">@truncate</span>(bit_count - <span class="tok-number">1</span>));</span>
<span class="line" id="L347"> <span class="tok-kw">const</span> signmask = <span class="tok-builtin">@as</span>(Limb, <span class="tok-number">1</span>) << bit; <span class="tok-comment">// 0b0..010..0 where 1 is the sign bit.</span>
</span>
<span class="line" id="L348"> <span class="tok-kw">const</span> mask = (signmask << <span class="tok-number">1</span>) -% <span class="tok-number">1</span>; <span class="tok-comment">// 0b0..011..1 where the leftmost 1 is the sign bit.</span>
</span>
<span class="line" id="L349"></span>
<span class="line" id="L350"> r.positive = <span class="tok-null">true</span>;</span>
<span class="line" id="L351"></span>
<span class="line" id="L352"> <span class="tok-kw">switch</span> (signedness) {</span>
<span class="line" id="L353"> .signed => <span class="tok-kw">switch</span> (limit) {</span>
<span class="line" id="L354"> .min => {</span>
<span class="line" id="L355"> <span class="tok-comment">// Negative bound, signed = -0x80.</span>
</span>
<span class="line" id="L356"> r.len = req_limbs;</span>
<span class="line" id="L357"> <span class="tok-builtin">@memset</span>(r.limbs[<span class="tok-number">0</span> .. r.len - <span class="tok-number">1</span>], <span class="tok-number">0</span>);</span>
<span class="line" id="L358"> r.limbs[r.len - <span class="tok-number">1</span>] = signmask;</span>
<span class="line" id="L359"> r.positive = <span class="tok-null">false</span>;</span>
<span class="line" id="L360"> },</span>
<span class="line" id="L361"> .max => {</span>
<span class="line" id="L362"> <span class="tok-comment">// Positive bound, signed = 0x7F</span>
</span>
<span class="line" id="L363"> <span class="tok-comment">// Note, in this branch we need to normalize because the first bit is</span>
</span>
<span class="line" id="L364"> <span class="tok-comment">// supposed to be 0.</span>
</span>
<span class="line" id="L365"></span>
<span class="line" id="L366"> <span class="tok-comment">// Special case for 1-bit integers.</span>
</span>
<span class="line" id="L367"> <span class="tok-kw">if</span> (bit_count == <span class="tok-number">1</span>) {</span>
<span class="line" id="L368"> r.set(<span class="tok-number">0</span>);</span>
<span class="line" id="L369"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L370"> <span class="tok-kw">const</span> new_req_limbs = calcTwosCompLimbCount(bit_count - <span class="tok-number">1</span>);</span>
<span class="line" id="L371"> <span class="tok-kw">const</span> msb = <span class="tok-builtin">@as</span>(Log2Limb, <span class="tok-builtin">@truncate</span>(bit_count - <span class="tok-number">2</span>));</span>
<span class="line" id="L372"> <span class="tok-kw">const</span> new_signmask = <span class="tok-builtin">@as</span>(Limb, <span class="tok-number">1</span>) << msb; <span class="tok-comment">// 0b0..010..0 where 1 is the sign bit.</span>
</span>
<span class="line" id="L373"> <span class="tok-kw">const</span> new_mask = (new_signmask << <span class="tok-number">1</span>) -% <span class="tok-number">1</span>; <span class="tok-comment">// 0b0..001..1 where the rightmost 0 is the sign bit.</span>
</span>
<span class="line" id="L374"></span>
<span class="line" id="L375"> r.len = new_req_limbs;</span>
<span class="line" id="L376"> <span class="tok-builtin">@memset</span>(r.limbs[<span class="tok-number">0</span> .. r.len - <span class="tok-number">1</span>], maxInt(Limb));</span>
<span class="line" id="L377"> r.limbs[r.len - <span class="tok-number">1</span>] = new_mask;</span>
<span class="line" id="L378"> }</span>
<span class="line" id="L379"> },</span>
<span class="line" id="L380"> },</span>
<span class="line" id="L381"> .unsigned => <span class="tok-kw">switch</span> (limit) {</span>
<span class="line" id="L382"> .min => {</span>
<span class="line" id="L383"> <span class="tok-comment">// Min bound, unsigned = 0x00</span>
</span>
<span class="line" id="L384"> r.set(<span class="tok-number">0</span>);</span>
<span class="line" id="L385"> },</span>
<span class="line" id="L386"> .max => {</span>
<span class="line" id="L387"> <span class="tok-comment">// Max bound, unsigned = 0xFF</span>
</span>
<span class="line" id="L388"> r.len = req_limbs;</span>
<span class="line" id="L389"> <span class="tok-builtin">@memset</span>(r.limbs[<span class="tok-number">0</span> .. r.len - <span class="tok-number">1</span>], maxInt(Limb));</span>
<span class="line" id="L390"> r.limbs[r.len - <span class="tok-number">1</span>] = mask;</span>
<span class="line" id="L391"> },</span>
<span class="line" id="L392"> },</span>
<span class="line" id="L393"> }</span>
<span class="line" id="L394"> }</span>
<span class="line" id="L395"></span>
<span class="line" id="L396"> <span class="tok-comment">/// r = a + scalar</span></span>
<span class="line" id="L397"> <span class="tok-comment">///</span></span>
<span class="line" id="L398"> <span class="tok-comment">/// r and a may be aliases.</span></span>
<span class="line" id="L399"> <span class="tok-comment">/// scalar is a primitive integer type.</span></span>
<span class="line" id="L400"> <span class="tok-comment">///</span></span>
<span class="line" id="L401"> <span class="tok-comment">/// Asserts the result fits in `r`. An upper bound on the number of limbs needed by</span></span>
<span class="line" id="L402"> <span class="tok-comment">/// r is `@max(a.limbs.len, calcLimbLen(scalar)) + 1`.</span></span>
<span class="line" id="L403"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addScalar</span>(r: *Mutable, a: Const, scalar: <span class="tok-kw">anytype</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L404"> <span class="tok-comment">// Normally we could just determine the number of limbs needed with calcLimbLen,</span>
</span>
<span class="line" id="L405"> <span class="tok-comment">// but that is not comptime-known when scalar is not a comptime_int. Instead, we</span>
</span>
<span class="line" id="L406"> <span class="tok-comment">// use calcTwosCompLimbCount for a non-comptime_int scalar, which can be pessimistic</span>
</span>
<span class="line" id="L407"> <span class="tok-comment">// in the case that scalar happens to be small in magnitude within its type, but it</span>
</span>
<span class="line" id="L408"> <span class="tok-comment">// is well worth being able to use the stack and not needing an allocator passed in.</span>
</span>
<span class="line" id="L409"> <span class="tok-comment">// Note that Mutable.init still sets len to calcLimbLen(scalar) in any case.</span>
</span>
<span class="line" id="L410"> <span class="tok-kw">const</span> limb_len = <span class="tok-kw">comptime</span> <span class="tok-kw">switch</span> (<span class="tok-builtin">@typeInfo</span>(<span class="tok-builtin">@TypeOf</span>(scalar))) {</span>
<span class="line" id="L411"> .ComptimeInt => calcLimbLen(scalar),</span>
<span class="line" id="L412"> .Int => |info| calcTwosCompLimbCount(info.bits),</span>
<span class="line" id="L413"> <span class="tok-kw">else</span> => <span class="tok-builtin">@compileError</span>(<span class="tok-str">"expected scalar to be an int"</span>),</span>
<span class="line" id="L414"> };</span>
<span class="line" id="L415"> <span class="tok-kw">var</span> limbs: [limb_len]Limb = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L416"> <span class="tok-kw">const</span> operand = init(&limbs, scalar).toConst();</span>
<span class="line" id="L417"> <span class="tok-kw">return</span> add(r, a, operand);</span>
<span class="line" id="L418"> }</span>
<span class="line" id="L419"></span>
<span class="line" id="L420"> <span class="tok-comment">/// Base implementation for addition. Adds `@max(a.limbs.len, b.limbs.len)` elements from a and b,</span></span>
<span class="line" id="L421"> <span class="tok-comment">/// and returns whether any overflow occurred.</span></span>
<span class="line" id="L422"> <span class="tok-comment">/// r, a and b may be aliases.</span></span>
<span class="line" id="L423"> <span class="tok-comment">///</span></span>
<span class="line" id="L424"> <span class="tok-comment">/// Asserts r has enough elements to hold the result. The upper bound is `@max(a.limbs.len, b.limbs.len)`.</span></span>
<span class="line" id="L425"> <span class="tok-kw">fn</span> <span class="tok-fn">addCarry</span>(r: *Mutable, a: Const, b: Const) <span class="tok-type">bool</span> {</span>
<span class="line" id="L426"> <span class="tok-kw">if</span> (a.eqlZero()) {</span>
<span class="line" id="L427"> r.copy(b);</span>
<span class="line" id="L428"> <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L429"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (b.eqlZero()) {</span>
<span class="line" id="L430"> r.copy(a);</span>
<span class="line" id="L431"> <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L432"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (a.positive != b.positive) {</span>
<span class="line" id="L433"> <span class="tok-kw">if</span> (a.positive) {</span>
<span class="line" id="L434"> <span class="tok-comment">// (a) + (-b) => a - b</span>
</span>
<span class="line" id="L435"> <span class="tok-kw">return</span> r.subCarry(a, b.abs());</span>
<span class="line" id="L436"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L437"> <span class="tok-comment">// (-a) + (b) => b - a</span>
</span>
<span class="line" id="L438"> <span class="tok-kw">return</span> r.subCarry(b, a.abs());</span>
<span class="line" id="L439"> }</span>
<span class="line" id="L440"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L441"> r.positive = a.positive;</span>
<span class="line" id="L442"> <span class="tok-kw">if</span> (a.limbs.len >= b.limbs.len) {</span>
<span class="line" id="L443"> <span class="tok-kw">const</span> c = lladdcarry(r.limbs, a.limbs, b.limbs);</span>
<span class="line" id="L444"> r.normalize(a.limbs.len);</span>
<span class="line" id="L445"> <span class="tok-kw">return</span> c != <span class="tok-number">0</span>;</span>
<span class="line" id="L446"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L447"> <span class="tok-kw">const</span> c = lladdcarry(r.limbs, b.limbs, a.limbs);</span>
<span class="line" id="L448"> r.normalize(b.limbs.len);</span>
<span class="line" id="L449"> <span class="tok-kw">return</span> c != <span class="tok-number">0</span>;</span>
<span class="line" id="L450"> }</span>
<span class="line" id="L451"> }</span>
<span class="line" id="L452"> }</span>
<span class="line" id="L453"></span>
<span class="line" id="L454"> <span class="tok-comment">/// r = a + b</span></span>
<span class="line" id="L455"> <span class="tok-comment">/// r, a and b may be aliases.</span></span>
<span class="line" id="L456"> <span class="tok-comment">///</span></span>
<span class="line" id="L457"> <span class="tok-comment">/// Asserts the result fits in `r`. An upper bound on the number of limbs needed by</span></span>
<span class="line" id="L458"> <span class="tok-comment">/// r is `@max(a.limbs.len, b.limbs.len) + 1`.</span></span>
<span class="line" id="L459"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">add</span>(r: *Mutable, a: Const, b: Const) <span class="tok-type">void</span> {</span>
<span class="line" id="L460"> <span class="tok-kw">if</span> (r.addCarry(a, b)) {</span>
<span class="line" id="L461"> <span class="tok-comment">// Fix up the result. Note that addCarry normalizes by a.limbs.len or b.limbs.len,</span>
</span>
<span class="line" id="L462"> <span class="tok-comment">// so we need to set the length here.</span>
</span>
<span class="line" id="L463"> <span class="tok-kw">const</span> msl = <span class="tok-builtin">@max</span>(a.limbs.len, b.limbs.len);</span>
<span class="line" id="L464"> <span class="tok-comment">// `[add|sub]Carry` normalizes by `msl`, so we need to fix up the result manually here.</span>
</span>
<span class="line" id="L465"> <span class="tok-comment">// Note, the fact that it normalized means that the intermediary limbs are zero here.</span>
</span>
<span class="line" id="L466"> r.len = msl + <span class="tok-number">1</span>;</span>
<span class="line" id="L467"> r.limbs[msl] = <span class="tok-number">1</span>; <span class="tok-comment">// If this panics, there wasn't enough space in `r`.</span>
</span>
<span class="line" id="L468"> }</span>
<span class="line" id="L469"> }</span>
<span class="line" id="L470"></span>
<span class="line" id="L471"> <span class="tok-comment">/// r = a + b with 2s-complement wrapping semantics. Returns whether overflow occurred.</span></span>
<span class="line" id="L472"> <span class="tok-comment">/// r, a and b may be aliases</span></span>
<span class="line" id="L473"> <span class="tok-comment">///</span></span>
<span class="line" id="L474"> <span class="tok-comment">/// Asserts the result fits in `r`. An upper bound on the number of limbs needed by</span></span>
<span class="line" id="L475"> <span class="tok-comment">/// r is `calcTwosCompLimbCount(bit_count)`.</span></span>
<span class="line" id="L476"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addWrap</span>(r: *Mutable, a: Const, b: Const, signedness: Signedness, bit_count: <span class="tok-type">usize</span>) <span class="tok-type">bool</span> {</span>
<span class="line" id="L477"> <span class="tok-kw">const</span> req_limbs = calcTwosCompLimbCount(bit_count);</span>
<span class="line" id="L478"></span>
<span class="line" id="L479"> <span class="tok-comment">// Slice of the upper bits if they exist, these will be ignored and allows us to use addCarry to determine</span>
</span>
<span class="line" id="L480"> <span class="tok-comment">// if an overflow occurred.</span>
</span>
<span class="line" id="L481"> <span class="tok-kw">const</span> x = Const{</span>
<span class="line" id="L482"> .positive = a.positive,</span>
<span class="line" id="L483"> .limbs = a.limbs[<span class="tok-number">0</span>..<span class="tok-builtin">@min</span>(req_limbs, a.limbs.len)],</span>
<span class="line" id="L484"> };</span>
<span class="line" id="L485"></span>
<span class="line" id="L486"> <span class="tok-kw">const</span> y = Const{</span>
<span class="line" id="L487"> .positive = b.positive,</span>
<span class="line" id="L488"> .limbs = b.limbs[<span class="tok-number">0</span>..<span class="tok-builtin">@min</span>(req_limbs, b.limbs.len)],</span>
<span class="line" id="L489"> };</span>
<span class="line" id="L490"></span>
<span class="line" id="L491"> <span class="tok-kw">var</span> carry_truncated = <span class="tok-null">false</span>;</span>
<span class="line" id="L492"> <span class="tok-kw">if</span> (r.addCarry(x, y)) {</span>
<span class="line" id="L493"> <span class="tok-comment">// There are two possibilities here:</span>
</span>
<span class="line" id="L494"> <span class="tok-comment">// - We overflowed req_limbs. In this case, the carry is ignored, as it would be removed by</span>
</span>
<span class="line" id="L495"> <span class="tok-comment">// truncate anyway.</span>
</span>
<span class="line" id="L496"> <span class="tok-comment">// - a and b had less elements than req_limbs, and those were overflowed. This case needs to be handled.</span>
</span>
<span class="line" id="L497"> <span class="tok-comment">// Note: after this we still might need to wrap.</span>
</span>
<span class="line" id="L498"> <span class="tok-kw">const</span> msl = <span class="tok-builtin">@max</span>(a.limbs.len, b.limbs.len);</span>
<span class="line" id="L499"> <span class="tok-kw">if</span> (msl < req_limbs) {</span>
<span class="line" id="L500"> r.limbs[msl] = <span class="tok-number">1</span>;</span>
<span class="line" id="L501"> r.len = req_limbs;</span>
<span class="line" id="L502"> <span class="tok-builtin">@memset</span>(r.limbs[msl + <span class="tok-number">1</span> .. req_limbs], <span class="tok-number">0</span>);</span>
<span class="line" id="L503"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L504"> carry_truncated = <span class="tok-null">true</span>;</span>
<span class="line" id="L505"> }</span>
<span class="line" id="L506"> }</span>
<span class="line" id="L507"></span>
<span class="line" id="L508"> <span class="tok-kw">if</span> (!r.toConst().fitsInTwosComp(signedness, bit_count)) {</span>
<span class="line" id="L509"> r.truncate(r.toConst(), signedness, bit_count);</span>
<span class="line" id="L510"> <span class="tok-kw">return</span> <span class="tok-null">true</span>;</span>
<span class="line" id="L511"> }</span>
<span class="line" id="L512"></span>
<span class="line" id="L513"> <span class="tok-kw">return</span> carry_truncated;</span>
<span class="line" id="L514"> }</span>
<span class="line" id="L515"></span>
<span class="line" id="L516"> <span class="tok-comment">/// r = a + b with 2s-complement saturating semantics.</span></span>
<span class="line" id="L517"> <span class="tok-comment">/// r, a and b may be aliases.</span></span>
<span class="line" id="L518"> <span class="tok-comment">///</span></span>
<span class="line" id="L519"> <span class="tok-comment">/// Assets the result fits in `r`. Upper bound on the number of limbs needed by</span></span>
<span class="line" id="L520"> <span class="tok-comment">/// r is `calcTwosCompLimbCount(bit_count)`.</span></span>
<span class="line" id="L521"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addSat</span>(r: *Mutable, a: Const, b: Const, signedness: Signedness, bit_count: <span class="tok-type">usize</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L522"> <span class="tok-kw">const</span> req_limbs = calcTwosCompLimbCount(bit_count);</span>
<span class="line" id="L523"></span>
<span class="line" id="L524"> <span class="tok-comment">// Slice of the upper bits if they exist, these will be ignored and allows us to use addCarry to determine</span>
</span>
<span class="line" id="L525"> <span class="tok-comment">// if an overflow occurred.</span>
</span>
<span class="line" id="L526"> <span class="tok-kw">const</span> x = Const{</span>
<span class="line" id="L527"> .positive = a.positive,</span>
<span class="line" id="L528"> .limbs = a.limbs[<span class="tok-number">0</span>..<span class="tok-builtin">@min</span>(req_limbs, a.limbs.len)],</span>
<span class="line" id="L529"> };</span>
<span class="line" id="L530"></span>
<span class="line" id="L531"> <span class="tok-kw">const</span> y = Const{</span>
<span class="line" id="L532"> .positive = b.positive,</span>
<span class="line" id="L533"> .limbs = b.limbs[<span class="tok-number">0</span>..<span class="tok-builtin">@min</span>(req_limbs, b.limbs.len)],</span>
<span class="line" id="L534"> };</span>
<span class="line" id="L535"></span>
<span class="line" id="L536"> <span class="tok-kw">if</span> (r.addCarry(x, y)) {</span>
<span class="line" id="L537"> <span class="tok-comment">// There are two possibilities here:</span>
</span>
<span class="line" id="L538"> <span class="tok-comment">// - We overflowed req_limbs, in which case we need to saturate.</span>
</span>
<span class="line" id="L539"> <span class="tok-comment">// - a and b had less elements than req_limbs, and those were overflowed.</span>
</span>
<span class="line" id="L540"> <span class="tok-comment">// Note: In this case, might _also_ need to saturate.</span>
</span>
<span class="line" id="L541"> <span class="tok-kw">const</span> msl = <span class="tok-builtin">@max</span>(a.limbs.len, b.limbs.len);</span>
<span class="line" id="L542"> <span class="tok-kw">if</span> (msl < req_limbs) {</span>
<span class="line" id="L543"> r.limbs[msl] = <span class="tok-number">1</span>;</span>
<span class="line" id="L544"> r.len = req_limbs;</span>
<span class="line" id="L545"> <span class="tok-comment">// Note: Saturation may still be required if msl == req_limbs - 1</span>
</span>
<span class="line" id="L546"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L547"> <span class="tok-comment">// Overflowed req_limbs, definitely saturate.</span>
</span>
<span class="line" id="L548"> r.setTwosCompIntLimit(<span class="tok-kw">if</span> (r.positive) .max <span class="tok-kw">else</span> .min, signedness, bit_count);</span>
<span class="line" id="L549"> }</span>
<span class="line" id="L550"> }</span>
<span class="line" id="L551"></span>
<span class="line" id="L552"> <span class="tok-comment">// Saturate if the result didn't fit.</span>
</span>
<span class="line" id="L553"> r.saturate(r.toConst(), signedness, bit_count);</span>
<span class="line" id="L554"> }</span>
<span class="line" id="L555"></span>
<span class="line" id="L556"> <span class="tok-comment">/// Base implementation for subtraction. Subtracts `@max(a.limbs.len, b.limbs.len)` elements from a and b,</span></span>
<span class="line" id="L557"> <span class="tok-comment">/// and returns whether any overflow occurred.</span></span>
<span class="line" id="L558"> <span class="tok-comment">/// r, a and b may be aliases.</span></span>
<span class="line" id="L559"> <span class="tok-comment">///</span></span>
<span class="line" id="L560"> <span class="tok-comment">/// Asserts r has enough elements to hold the result. The upper bound is `@max(a.limbs.len, b.limbs.len)`.</span></span>
<span class="line" id="L561"> <span class="tok-kw">fn</span> <span class="tok-fn">subCarry</span>(r: *Mutable, a: Const, b: Const) <span class="tok-type">bool</span> {</span>
<span class="line" id="L562"> <span class="tok-kw">if</span> (a.eqlZero()) {</span>
<span class="line" id="L563"> r.copy(b);</span>
<span class="line" id="L564"> r.positive = !b.positive;</span>
<span class="line" id="L565"> <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L566"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (b.eqlZero()) {</span>
<span class="line" id="L567"> r.copy(a);</span>
<span class="line" id="L568"> <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L569"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (a.positive != b.positive) {</span>
<span class="line" id="L570"> <span class="tok-kw">if</span> (a.positive) {</span>
<span class="line" id="L571"> <span class="tok-comment">// (a) - (-b) => a + b</span>
</span>
<span class="line" id="L572"> <span class="tok-kw">return</span> r.addCarry(a, b.abs());</span>
<span class="line" id="L573"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L574"> <span class="tok-comment">// (-a) - (b) => -a + -b</span>
</span>
<span class="line" id="L575"> <span class="tok-kw">return</span> r.addCarry(a, b.negate());</span>
<span class="line" id="L576"> }</span>
<span class="line" id="L577"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (a.positive) {</span>
<span class="line" id="L578"> <span class="tok-kw">if</span> (a.order(b) != .lt) {</span>
<span class="line" id="L579"> <span class="tok-comment">// (a) - (b) => a - b</span>
</span>
<span class="line" id="L580"> <span class="tok-kw">const</span> c = llsubcarry(r.limbs, a.limbs, b.limbs);</span>
<span class="line" id="L581"> r.normalize(a.limbs.len);</span>
<span class="line" id="L582"> r.positive = <span class="tok-null">true</span>;</span>
<span class="line" id="L583"> <span class="tok-kw">return</span> c != <span class="tok-number">0</span>;</span>
<span class="line" id="L584"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L585"> <span class="tok-comment">// (a) - (b) => -b + a => -(b - a)</span>
</span>
<span class="line" id="L586"> <span class="tok-kw">const</span> c = llsubcarry(r.limbs, b.limbs, a.limbs);</span>
<span class="line" id="L587"> r.normalize(b.limbs.len);</span>
<span class="line" id="L588"> r.positive = <span class="tok-null">false</span>;</span>
<span class="line" id="L589"> <span class="tok-kw">return</span> c != <span class="tok-number">0</span>;</span>
<span class="line" id="L590"> }</span>
<span class="line" id="L591"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L592"> <span class="tok-kw">if</span> (a.order(b) == .lt) {</span>
<span class="line" id="L593"> <span class="tok-comment">// (-a) - (-b) => -(a - b)</span>
</span>
<span class="line" id="L594"> <span class="tok-kw">const</span> c = llsubcarry(r.limbs, a.limbs, b.limbs);</span>
<span class="line" id="L595"> r.normalize(a.limbs.len);</span>
<span class="line" id="L596"> r.positive = <span class="tok-null">false</span>;</span>
<span class="line" id="L597"> <span class="tok-kw">return</span> c != <span class="tok-number">0</span>;</span>
<span class="line" id="L598"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L599"> <span class="tok-comment">// (-a) - (-b) => --b + -a => b - a</span>
</span>
<span class="line" id="L600"> <span class="tok-kw">const</span> c = llsubcarry(r.limbs, b.limbs, a.limbs);</span>
<span class="line" id="L601"> r.normalize(b.limbs.len);</span>
<span class="line" id="L602"> r.positive = <span class="tok-null">true</span>;</span>
<span class="line" id="L603"> <span class="tok-kw">return</span> c != <span class="tok-number">0</span>;</span>
<span class="line" id="L604"> }</span>
<span class="line" id="L605"> }</span>
<span class="line" id="L606"> }</span>
<span class="line" id="L607"></span>
<span class="line" id="L608"> <span class="tok-comment">/// r = a - b</span></span>
<span class="line" id="L609"> <span class="tok-comment">///</span></span>
<span class="line" id="L610"> <span class="tok-comment">/// r, a and b may be aliases.</span></span>
<span class="line" id="L611"> <span class="tok-comment">///</span></span>
<span class="line" id="L612"> <span class="tok-comment">/// Asserts the result fits in `r`. An upper bound on the number of limbs needed by</span></span>
<span class="line" id="L613"> <span class="tok-comment">/// r is `@max(a.limbs.len, b.limbs.len) + 1`. The +1 is not needed if both operands are positive.</span></span>
<span class="line" id="L614"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">sub</span>(r: *Mutable, a: Const, b: Const) <span class="tok-type">void</span> {</span>
<span class="line" id="L615"> r.add(a, b.negate());</span>
<span class="line" id="L616"> }</span>
<span class="line" id="L617"></span>
<span class="line" id="L618"> <span class="tok-comment">/// r = a - b with 2s-complement wrapping semantics. Returns whether any overflow occurred.</span></span>
<span class="line" id="L619"> <span class="tok-comment">///</span></span>
<span class="line" id="L620"> <span class="tok-comment">/// r, a and b may be aliases</span></span>
<span class="line" id="L621"> <span class="tok-comment">/// Asserts the result fits in `r`. An upper bound on the number of limbs needed by</span></span>
<span class="line" id="L622"> <span class="tok-comment">/// r is `calcTwosCompLimbCount(bit_count)`.</span></span>
<span class="line" id="L623"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">subWrap</span>(r: *Mutable, a: Const, b: Const, signedness: Signedness, bit_count: <span class="tok-type">usize</span>) <span class="tok-type">bool</span> {</span>
<span class="line" id="L624"> <span class="tok-kw">return</span> r.addWrap(a, b.negate(), signedness, bit_count);</span>
<span class="line" id="L625"> }</span>
<span class="line" id="L626"></span>
<span class="line" id="L627"> <span class="tok-comment">/// r = a - b with 2s-complement saturating semantics.</span></span>
<span class="line" id="L628"> <span class="tok-comment">/// r, a and b may be aliases.</span></span>
<span class="line" id="L629"> <span class="tok-comment">///</span></span>
<span class="line" id="L630"> <span class="tok-comment">/// Assets the result fits in `r`. Upper bound on the number of limbs needed by</span></span>
<span class="line" id="L631"> <span class="tok-comment">/// r is `calcTwosCompLimbCount(bit_count)`.</span></span>
<span class="line" id="L632"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">subSat</span>(r: *Mutable, a: Const, b: Const, signedness: Signedness, bit_count: <span class="tok-type">usize</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L633"> r.addSat(a, b.negate(), signedness, bit_count);</span>
<span class="line" id="L634"> }</span>
<span class="line" id="L635"></span>
<span class="line" id="L636"> <span class="tok-comment">/// rma = a * b</span></span>
<span class="line" id="L637"> <span class="tok-comment">///</span></span>
<span class="line" id="L638"> <span class="tok-comment">/// `rma` may alias with `a` or `b`.</span></span>
<span class="line" id="L639"> <span class="tok-comment">/// `a` and `b` may alias with each other.</span></span>
<span class="line" id="L640"> <span class="tok-comment">///</span></span>
<span class="line" id="L641"> <span class="tok-comment">/// Asserts the result fits in `rma`. An upper bound on the number of limbs needed by</span></span>
<span class="line" id="L642"> <span class="tok-comment">/// rma is given by `a.limbs.len + b.limbs.len`.</span></span>
<span class="line" id="L643"> <span class="tok-comment">///</span></span>
<span class="line" id="L644"> <span class="tok-comment">/// `limbs_buffer` is used for temporary storage. The amount required is given by `calcMulLimbsBufferLen`.</span></span>
<span class="line" id="L645"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">mul</span>(rma: *Mutable, a: Const, b: Const, limbs_buffer: []Limb, allocator: ?Allocator) <span class="tok-type">void</span> {</span>
<span class="line" id="L646"> <span class="tok-kw">var</span> buf_index: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L647"></span>
<span class="line" id="L648"> <span class="tok-kw">const</span> a_copy = <span class="tok-kw">if</span> (rma.limbs.ptr == a.limbs.ptr) blk: {</span>
<span class="line" id="L649"> <span class="tok-kw">const</span> start = buf_index;</span>
<span class="line" id="L650"> <span class="tok-builtin">@memcpy</span>(limbs_buffer[buf_index..][<span class="tok-number">0</span>..a.limbs.len], a.limbs);</span>
<span class="line" id="L651"> buf_index += a.limbs.len;</span>
<span class="line" id="L652"> <span class="tok-kw">break</span> :blk a.toMutable(limbs_buffer[start..buf_index]).toConst();</span>
<span class="line" id="L653"> } <span class="tok-kw">else</span> a;</span>
<span class="line" id="L654"></span>
<span class="line" id="L655"> <span class="tok-kw">const</span> b_copy = <span class="tok-kw">if</span> (rma.limbs.ptr == b.limbs.ptr) blk: {</span>
<span class="line" id="L656"> <span class="tok-kw">const</span> start = buf_index;</span>
<span class="line" id="L657"> <span class="tok-builtin">@memcpy</span>(limbs_buffer[buf_index..][<span class="tok-number">0</span>..b.limbs.len], b.limbs);</span>
<span class="line" id="L658"> buf_index += b.limbs.len;</span>
<span class="line" id="L659"> <span class="tok-kw">break</span> :blk b.toMutable(limbs_buffer[start..buf_index]).toConst();</span>
<span class="line" id="L660"> } <span class="tok-kw">else</span> b;</span>
<span class="line" id="L661"></span>
<span class="line" id="L662"> <span class="tok-kw">return</span> rma.mulNoAlias(a_copy, b_copy, allocator);</span>
<span class="line" id="L663"> }</span>
<span class="line" id="L664"></span>
<span class="line" id="L665"> <span class="tok-comment">/// rma = a * b</span></span>
<span class="line" id="L666"> <span class="tok-comment">///</span></span>
<span class="line" id="L667"> <span class="tok-comment">/// `rma` may not alias with `a` or `b`.</span></span>
<span class="line" id="L668"> <span class="tok-comment">/// `a` and `b` may alias with each other.</span></span>
<span class="line" id="L669"> <span class="tok-comment">///</span></span>
<span class="line" id="L670"> <span class="tok-comment">/// Asserts the result fits in `rma`. An upper bound on the number of limbs needed by</span></span>
<span class="line" id="L671"> <span class="tok-comment">/// rma is given by `a.limbs.len + b.limbs.len`.</span></span>
<span class="line" id="L672"> <span class="tok-comment">///</span></span>
<span class="line" id="L673"> <span class="tok-comment">/// If `allocator` is provided, it will be used for temporary storage to improve</span></span>
<span class="line" id="L674"> <span class="tok-comment">/// multiplication performance. `error.OutOfMemory` is handled with a fallback algorithm.</span></span>
<span class="line" id="L675"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">mulNoAlias</span>(rma: *Mutable, a: Const, b: Const, allocator: ?Allocator) <span class="tok-type">void</span> {</span>
<span class="line" id="L676"> assert(rma.limbs.ptr != a.limbs.ptr); <span class="tok-comment">// illegal aliasing</span>
</span>
<span class="line" id="L677"> assert(rma.limbs.ptr != b.limbs.ptr); <span class="tok-comment">// illegal aliasing</span>
</span>
<span class="line" id="L678"></span>
<span class="line" id="L679"> <span class="tok-kw">if</span> (a.limbs.len == <span class="tok-number">1</span> <span class="tok-kw">and</span> b.limbs.len == <span class="tok-number">1</span>) {</span>
<span class="line" id="L680"> <span class="tok-kw">const</span> ov = <span class="tok-builtin">@mulWithOverflow</span>(a.limbs[<span class="tok-number">0</span>], b.limbs[<span class="tok-number">0</span>]);</span>
<span class="line" id="L681"> rma.limbs[<span class="tok-number">0</span>] = ov[<span class="tok-number">0</span>];</span>
<span class="line" id="L682"> <span class="tok-kw">if</span> (ov[<span class="tok-number">1</span>] == <span class="tok-number">0</span>) {</span>
<span class="line" id="L683"> rma.len = <span class="tok-number">1</span>;</span>
<span class="line" id="L684"> rma.positive = (a.positive == b.positive);</span>
<span class="line" id="L685"> <span class="tok-kw">return</span>;</span>
<span class="line" id="L686"> }</span>
<span class="line" id="L687"> }</span>
<span class="line" id="L688"></span>
<span class="line" id="L689"> <span class="tok-builtin">@memset</span>(rma.limbs[<span class="tok-number">0</span> .. a.limbs.len + b.limbs.len], <span class="tok-number">0</span>);</span>
<span class="line" id="L690"></span>
<span class="line" id="L691"> llmulacc(.add, allocator, rma.limbs, a.limbs, b.limbs);</span>
<span class="line" id="L692"></span>
<span class="line" id="L693"> rma.normalize(a.limbs.len + b.limbs.len);</span>
<span class="line" id="L694"> rma.positive = (a.positive == b.positive);</span>
<span class="line" id="L695"> }</span>
<span class="line" id="L696"></span>
<span class="line" id="L697"> <span class="tok-comment">/// rma = a * b with 2s-complement wrapping semantics.</span></span>
<span class="line" id="L698"> <span class="tok-comment">///</span></span>
<span class="line" id="L699"> <span class="tok-comment">/// `rma` may alias with `a` or `b`.</span></span>
<span class="line" id="L700"> <span class="tok-comment">/// `a` and `b` may alias with each other.</span></span>
<span class="line" id="L701"> <span class="tok-comment">///</span></span>
<span class="line" id="L702"> <span class="tok-comment">/// Asserts the result fits in `rma`. An upper bound on the number of limbs needed by</span></span>
<span class="line" id="L703"> <span class="tok-comment">/// rma is given by `a.limbs.len + b.limbs.len`.</span></span>
<span class="line" id="L704"> <span class="tok-comment">///</span></span>
<span class="line" id="L705"> <span class="tok-comment">/// `limbs_buffer` is used for temporary storage. The amount required is given by `calcMulWrapLimbsBufferLen`.</span></span>
<span class="line" id="L706"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">mulWrap</span>(</span>
<span class="line" id="L707"> rma: *Mutable,</span>
<span class="line" id="L708"> a: Const,</span>
<span class="line" id="L709"> b: Const,</span>
<span class="line" id="L710"> signedness: Signedness,</span>
<span class="line" id="L711"> bit_count: <span class="tok-type">usize</span>,</span>
<span class="line" id="L712"> limbs_buffer: []Limb,</span>
<span class="line" id="L713"> allocator: ?Allocator,</span>
<span class="line" id="L714"> ) <span class="tok-type">void</span> {</span>
<span class="line" id="L715"> <span class="tok-kw">var</span> buf_index: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L716"> <span class="tok-kw">const</span> req_limbs = calcTwosCompLimbCount(bit_count);</span>
<span class="line" id="L717"></span>
<span class="line" id="L718"> <span class="tok-kw">const</span> a_copy = <span class="tok-kw">if</span> (rma.limbs.ptr == a.limbs.ptr) blk: {</span>
<span class="line" id="L719"> <span class="tok-kw">const</span> start = buf_index;</span>
<span class="line" id="L720"> <span class="tok-kw">const</span> a_len = <span class="tok-builtin">@min</span>(req_limbs, a.limbs.len);</span>
<span class="line" id="L721"> <span class="tok-builtin">@memcpy</span>(limbs_buffer[buf_index..][<span class="tok-number">0</span>..a_len], a.limbs[<span class="tok-number">0</span>..a_len]);</span>
<span class="line" id="L722"> buf_index += a_len;</span>
<span class="line" id="L723"> <span class="tok-kw">break</span> :blk a.toMutable(limbs_buffer[start..buf_index]).toConst();</span>
<span class="line" id="L724"> } <span class="tok-kw">else</span> a;</span>
<span class="line" id="L725"></span>
<span class="line" id="L726"> <span class="tok-kw">const</span> b_copy = <span class="tok-kw">if</span> (rma.limbs.ptr == b.limbs.ptr) blk: {</span>
<span class="line" id="L727"> <span class="tok-kw">const</span> start = buf_index;</span>
<span class="line" id="L728"> <span class="tok-kw">const</span> b_len = <span class="tok-builtin">@min</span>(req_limbs, b.limbs.len);</span>
<span class="line" id="L729"> <span class="tok-builtin">@memcpy</span>(limbs_buffer[buf_index..][<span class="tok-number">0</span>..b_len], b.limbs[<span class="tok-number">0</span>..b_len]);</span>
<span class="line" id="L730"> buf_index += b_len;</span>
<span class="line" id="L731"> <span class="tok-kw">break</span> :blk a.toMutable(limbs_buffer[start..buf_index]).toConst();</span>
<span class="line" id="L732"> } <span class="tok-kw">else</span> b;</span>
<span class="line" id="L733"></span>
<span class="line" id="L734"> <span class="tok-kw">return</span> rma.mulWrapNoAlias(a_copy, b_copy, signedness, bit_count, allocator);</span>
<span class="line" id="L735"> }</span>
<span class="line" id="L736"></span>
<span class="line" id="L737"> <span class="tok-comment">/// rma = a * b with 2s-complement wrapping semantics.</span></span>
<span class="line" id="L738"> <span class="tok-comment">///</span></span>
<span class="line" id="L739"> <span class="tok-comment">/// `rma` may not alias with `a` or `b`.</span></span>
<span class="line" id="L740"> <span class="tok-comment">/// `a` and `b` may alias with each other.</span></span>
<span class="line" id="L741"> <span class="tok-comment">///</span></span>
<span class="line" id="L742"> <span class="tok-comment">/// Asserts the result fits in `rma`. An upper bound on the number of limbs needed by</span></span>
<span class="line" id="L743"> <span class="tok-comment">/// rma is given by `a.limbs.len + b.limbs.len`.</span></span>
<span class="line" id="L744"> <span class="tok-comment">///</span></span>
<span class="line" id="L745"> <span class="tok-comment">/// If `allocator` is provided, it will be used for temporary storage to improve</span></span>
<span class="line" id="L746"> <span class="tok-comment">/// multiplication performance. `error.OutOfMemory` is handled with a fallback algorithm.</span></span>
<span class="line" id="L747"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">mulWrapNoAlias</span>(</span>
<span class="line" id="L748"> rma: *Mutable,</span>
<span class="line" id="L749"> a: Const,</span>
<span class="line" id="L750"> b: Const,</span>
<span class="line" id="L751"> signedness: Signedness,</span>
<span class="line" id="L752"> bit_count: <span class="tok-type">usize</span>,</span>
<span class="line" id="L753"> allocator: ?Allocator,</span>
<span class="line" id="L754"> ) <span class="tok-type">void</span> {</span>
<span class="line" id="L755"> assert(rma.limbs.ptr != a.limbs.ptr); <span class="tok-comment">// illegal aliasing</span>
</span>
<span class="line" id="L756"> assert(rma.limbs.ptr != b.limbs.ptr); <span class="tok-comment">// illegal aliasing</span>
</span>
<span class="line" id="L757"></span>
<span class="line" id="L758"> <span class="tok-kw">const</span> req_limbs = calcTwosCompLimbCount(bit_count);</span>
<span class="line" id="L759"></span>
<span class="line" id="L760"> <span class="tok-comment">// We can ignore the upper bits here, those results will be discarded anyway.</span>
</span>
<span class="line" id="L761"> <span class="tok-kw">const</span> a_limbs = a.limbs[<span class="tok-number">0</span>..<span class="tok-builtin">@min</span>(req_limbs, a.limbs.len)];</span>
<span class="line" id="L762"> <span class="tok-kw">const</span> b_limbs = b.limbs[<span class="tok-number">0</span>..<span class="tok-builtin">@min</span>(req_limbs, b.limbs.len)];</span>
<span class="line" id="L763"></span>
<span class="line" id="L764"> <span class="tok-builtin">@memset</span>(rma.limbs[<span class="tok-number">0</span>..req_limbs], <span class="tok-number">0</span>);</span>
<span class="line" id="L765"></span>
<span class="line" id="L766"> llmulacc(.add, allocator, rma.limbs, a_limbs, b_limbs);</span>
<span class="line" id="L767"> rma.normalize(<span class="tok-builtin">@min</span>(req_limbs, a.limbs.len + b.limbs.len));</span>
<span class="line" id="L768"> rma.positive = (a.positive == b.positive);</span>
<span class="line" id="L769"> rma.truncate(rma.toConst(), signedness, bit_count);</span>
<span class="line" id="L770"> }</span>
<span class="line" id="L771"></span>
<span class="line" id="L772"> <span class="tok-comment">/// r = @bitReverse(a) with 2s-complement semantics.</span></span>
<span class="line" id="L773"> <span class="tok-comment">/// r and a may be aliases.</span></span>
<span class="line" id="L774"> <span class="tok-comment">///</span></span>
<span class="line" id="L775"> <span class="tok-comment">/// Asserts the result fits in `r`. Upper bound on the number of limbs needed by</span></span>
<span class="line" id="L776"> <span class="tok-comment">/// r is `calcTwosCompLimbCount(bit_count)`.</span></span>
<span class="line" id="L777"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">bitReverse</span>(r: *Mutable, a: Const, signedness: Signedness, bit_count: <span class="tok-type">usize</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L778"> <span class="tok-kw">if</span> (bit_count == <span class="tok-number">0</span>) <span class="tok-kw">return</span>;</span>
<span class="line" id="L779"></span>
<span class="line" id="L780"> r.copy(a);</span>
<span class="line" id="L781"></span>
<span class="line" id="L782"> <span class="tok-kw">const</span> limbs_required = calcTwosCompLimbCount(bit_count);</span>
<span class="line" id="L783"></span>
<span class="line" id="L784"> <span class="tok-kw">if</span> (!a.positive) {</span>
<span class="line" id="L785"> r.positive = <span class="tok-null">true</span>; <span class="tok-comment">// Negate.</span>
</span>
<span class="line" id="L786"> r.bitNotWrap(r.toConst(), .unsigned, bit_count); <span class="tok-comment">// Bitwise NOT.</span>
</span>
<span class="line" id="L787"> r.addScalar(r.toConst(), <span class="tok-number">1</span>); <span class="tok-comment">// Add one.</span>
</span>
<span class="line" id="L788"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (limbs_required > a.limbs.len) {</span>
<span class="line" id="L789"> <span class="tok-comment">// Zero-extend to our output length</span>
</span>
<span class="line" id="L790"> <span class="tok-kw">for</span> (r.limbs[a.limbs.len..limbs_required]) |*limb| {</span>
<span class="line" id="L791"> limb.* = <span class="tok-number">0</span>;</span>
<span class="line" id="L792"> }</span>
<span class="line" id="L793"> r.len = limbs_required;</span>
<span class="line" id="L794"> }</span>
<span class="line" id="L795"></span>
<span class="line" id="L796"> <span class="tok-comment">// 0b0..01..1000 with @log2(@sizeOf(Limb)) consecutive ones</span>
</span>
<span class="line" id="L797"> <span class="tok-kw">const</span> endian_mask: <span class="tok-type">usize</span> = (<span class="tok-builtin">@sizeOf</span>(Limb) - <span class="tok-number">1</span>) << <span class="tok-number">3</span>;</span>
<span class="line" id="L798"></span>
<span class="line" id="L799"> <span class="tok-kw">var</span> bytes = std.mem.sliceAsBytes(r.limbs);</span>
<span class="line" id="L800"> <span class="tok-kw">var</span> bits = std.packed_int_array.PackedIntSliceEndian(<span class="tok-type">u1</span>, .Little).init(bytes, limbs_required * <span class="tok-builtin">@bitSizeOf</span>(Limb));</span>
<span class="line" id="L801"></span>
<span class="line" id="L802"> <span class="tok-kw">var</span> k: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L803"> <span class="tok-kw">while</span> (k < ((bit_count + <span class="tok-number">1</span>) / <span class="tok-number">2</span>)) : (k += <span class="tok-number">1</span>) {</span>
<span class="line" id="L804"> <span class="tok-kw">var</span> i = k;</span>
<span class="line" id="L805"> <span class="tok-kw">var</span> rev_i = bit_count - i - <span class="tok-number">1</span>;</span>
<span class="line" id="L806"></span>
<span class="line" id="L807"> <span class="tok-comment">// This "endian mask" remaps a low (LE) byte to the corresponding high</span>
</span>
<span class="line" id="L808"> <span class="tok-comment">// (BE) byte in the Limb, without changing which limbs we are indexing</span>
</span>
<span class="line" id="L809"> <span class="tok-kw">if</span> (native_endian == .Big) {</span>
<span class="line" id="L810"> i ^= endian_mask;</span>
<span class="line" id="L811"> rev_i ^= endian_mask;</span>
<span class="line" id="L812"> }</span>
<span class="line" id="L813"></span>
<span class="line" id="L814"> <span class="tok-kw">const</span> bit_i = bits.get(i);</span>
<span class="line" id="L815"> <span class="tok-kw">const</span> bit_rev_i = bits.get(rev_i);</span>
<span class="line" id="L816"> bits.set(i, bit_rev_i);</span>
<span class="line" id="L817"> bits.set(rev_i, bit_i);</span>
<span class="line" id="L818"> }</span>
<span class="line" id="L819"></span>
<span class="line" id="L820"> <span class="tok-comment">// Calculate signed-magnitude representation for output</span>
</span>
<span class="line" id="L821"> <span class="tok-kw">if</span> (signedness == .signed) {</span>
<span class="line" id="L822"> <span class="tok-kw">const</span> last_bit = <span class="tok-kw">switch</span> (native_endian) {</span>
<span class="line" id="L823"> .Little => bits.get(bit_count - <span class="tok-number">1</span>),</span>
<span class="line" id="L824"> .Big => bits.get((bit_count - <span class="tok-number">1</span>) ^ endian_mask),</span>
<span class="line" id="L825"> };</span>
<span class="line" id="L826"> <span class="tok-kw">if</span> (last_bit == <span class="tok-number">1</span>) {</span>
<span class="line" id="L827"> r.bitNotWrap(r.toConst(), .unsigned, bit_count); <span class="tok-comment">// Bitwise NOT.</span>
</span>
<span class="line" id="L828"> r.addScalar(r.toConst(), <span class="tok-number">1</span>); <span class="tok-comment">// Add one.</span>
</span>
<span class="line" id="L829"> r.positive = <span class="tok-null">false</span>; <span class="tok-comment">// Negate.</span>
</span>
<span class="line" id="L830"> }</span>
<span class="line" id="L831"> }</span>
<span class="line" id="L832"> r.normalize(r.len);</span>
<span class="line" id="L833"> }</span>
<span class="line" id="L834"></span>
<span class="line" id="L835"> <span class="tok-comment">/// r = @byteSwap(a) with 2s-complement semantics.</span></span>
<span class="line" id="L836"> <span class="tok-comment">/// r and a may be aliases.</span></span>
<span class="line" id="L837"> <span class="tok-comment">///</span></span>
<span class="line" id="L838"> <span class="tok-comment">/// Asserts the result fits in `r`. Upper bound on the number of limbs needed by</span></span>
<span class="line" id="L839"> <span class="tok-comment">/// r is `calcTwosCompLimbCount(8*byte_count)`.</span></span>
<span class="line" id="L840"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">byteSwap</span>(r: *Mutable, a: Const, signedness: Signedness, byte_count: <span class="tok-type">usize</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L841"> <span class="tok-kw">if</span> (byte_count == <span class="tok-number">0</span>) <span class="tok-kw">return</span>;</span>
<span class="line" id="L842"></span>
<span class="line" id="L843"> r.copy(a);</span>
<span class="line" id="L844"> <span class="tok-kw">const</span> limbs_required = calcTwosCompLimbCount(<span class="tok-number">8</span> * byte_count);</span>
<span class="line" id="L845"></span>
<span class="line" id="L846"> <span class="tok-kw">if</span> (!a.positive) {</span>
<span class="line" id="L847"> r.positive = <span class="tok-null">true</span>; <span class="tok-comment">// Negate.</span>
</span>
<span class="line" id="L848"> r.bitNotWrap(r.toConst(), .unsigned, <span class="tok-number">8</span> * byte_count); <span class="tok-comment">// Bitwise NOT.</span>
</span>
<span class="line" id="L849"> r.addScalar(r.toConst(), <span class="tok-number">1</span>); <span class="tok-comment">// Add one.</span>
</span>
<span class="line" id="L850"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (limbs_required > a.limbs.len) {</span>
<span class="line" id="L851"> <span class="tok-comment">// Zero-extend to our output length</span>
</span>
<span class="line" id="L852"> <span class="tok-kw">for</span> (r.limbs[a.limbs.len..limbs_required]) |*limb| {</span>
<span class="line" id="L853"> limb.* = <span class="tok-number">0</span>;</span>
<span class="line" id="L854"> }</span>
<span class="line" id="L855"> r.len = limbs_required;</span>
<span class="line" id="L856"> }</span>
<span class="line" id="L857"></span>
<span class="line" id="L858"> <span class="tok-comment">// 0b0..01..1 with @log2(@sizeOf(Limb)) trailing ones</span>
</span>
<span class="line" id="L859"> <span class="tok-kw">const</span> endian_mask: <span class="tok-type">usize</span> = <span class="tok-builtin">@sizeOf</span>(Limb) - <span class="tok-number">1</span>;</span>
<span class="line" id="L860"></span>
<span class="line" id="L861"> <span class="tok-kw">var</span> bytes = std.mem.sliceAsBytes(r.limbs);</span>
<span class="line" id="L862"> assert(bytes.len >= byte_count);</span>
<span class="line" id="L863"></span>
<span class="line" id="L864"> <span class="tok-kw">var</span> k: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L865"> <span class="tok-kw">while</span> (k < (byte_count + <span class="tok-number">1</span>) / <span class="tok-number">2</span>) : (k += <span class="tok-number">1</span>) {</span>
<span class="line" id="L866"> <span class="tok-kw">var</span> i = k;</span>
<span class="line" id="L867"> <span class="tok-kw">var</span> rev_i = byte_count - k - <span class="tok-number">1</span>;</span>
<span class="line" id="L868"></span>
<span class="line" id="L869"> <span class="tok-comment">// This "endian mask" remaps a low (LE) byte to the corresponding high</span>
</span>
<span class="line" id="L870"> <span class="tok-comment">// (BE) byte in the Limb, without changing which limbs we are indexing</span>
</span>
<span class="line" id="L871"> <span class="tok-kw">if</span> (native_endian == .Big) {</span>
<span class="line" id="L872"> i ^= endian_mask;</span>
<span class="line" id="L873"> rev_i ^= endian_mask;</span>
<span class="line" id="L874"> }</span>
<span class="line" id="L875"></span>
<span class="line" id="L876"> <span class="tok-kw">const</span> byte_i = bytes[i];</span>
<span class="line" id="L877"> <span class="tok-kw">const</span> byte_rev_i = bytes[rev_i];</span>
<span class="line" id="L878"> bytes[rev_i] = byte_i;</span>
<span class="line" id="L879"> bytes[i] = byte_rev_i;</span>
<span class="line" id="L880"> }</span>
<span class="line" id="L881"></span>
<span class="line" id="L882"> <span class="tok-comment">// Calculate signed-magnitude representation for output</span>
</span>
<span class="line" id="L883"> <span class="tok-kw">if</span> (signedness == .signed) {</span>
<span class="line" id="L884"> <span class="tok-kw">const</span> last_byte = <span class="tok-kw">switch</span> (native_endian) {</span>
<span class="line" id="L885"> .Little => bytes[byte_count - <span class="tok-number">1</span>],</span>
<span class="line" id="L886"> .Big => bytes[(byte_count - <span class="tok-number">1</span>) ^ endian_mask],</span>
<span class="line" id="L887"> };</span>
<span class="line" id="L888"></span>
<span class="line" id="L889"> <span class="tok-kw">if</span> (last_byte & (<span class="tok-number">1</span> << <span class="tok-number">7</span>) != <span class="tok-number">0</span>) { <span class="tok-comment">// Check sign bit of last byte</span>
</span>
<span class="line" id="L890"> r.bitNotWrap(r.toConst(), .unsigned, <span class="tok-number">8</span> * byte_count); <span class="tok-comment">// Bitwise NOT.</span>
</span>
<span class="line" id="L891"> r.addScalar(r.toConst(), <span class="tok-number">1</span>); <span class="tok-comment">// Add one.</span>
</span>
<span class="line" id="L892"> r.positive = <span class="tok-null">false</span>; <span class="tok-comment">// Negate.</span>
</span>
<span class="line" id="L893"> }</span>
<span class="line" id="L894"> }</span>
<span class="line" id="L895"> r.normalize(r.len);</span>
<span class="line" id="L896"> }</span>
<span class="line" id="L897"></span>
<span class="line" id="L898"> <span class="tok-comment">/// r = @popCount(a) with 2s-complement semantics.</span></span>
<span class="line" id="L899"> <span class="tok-comment">/// r and a may be aliases.</span></span>
<span class="line" id="L900"> <span class="tok-comment">///</span></span>
<span class="line" id="L901"> <span class="tok-comment">/// Assets the result fits in `r`. Upper bound on the number of limbs needed by</span></span>
<span class="line" id="L902"> <span class="tok-comment">/// r is `calcTwosCompLimbCount(bit_count)`.</span></span>
<span class="line" id="L903"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">popCount</span>(r: *Mutable, a: Const, bit_count: <span class="tok-type">usize</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L904"> r.copy(a);</span>
<span class="line" id="L905"></span>
<span class="line" id="L906"> <span class="tok-kw">if</span> (!a.positive) {</span>
<span class="line" id="L907"> r.positive = <span class="tok-null">true</span>; <span class="tok-comment">// Negate.</span>
</span>
<span class="line" id="L908"> r.bitNotWrap(r.toConst(), .unsigned, bit_count); <span class="tok-comment">// Bitwise NOT.</span>
</span>
<span class="line" id="L909"> r.addScalar(r.toConst(), <span class="tok-number">1</span>); <span class="tok-comment">// Add one.</span>
</span>
<span class="line" id="L910"> }</span>
<span class="line" id="L911"></span>
<span class="line" id="L912"> <span class="tok-kw">var</span> sum: Limb = <span class="tok-number">0</span>;</span>
<span class="line" id="L913"> <span class="tok-kw">for</span> (r.limbs[<span class="tok-number">0</span>..r.len]) |limb| {</span>
<span class="line" id="L914"> sum += <span class="tok-builtin">@popCount</span>(limb);</span>
<span class="line" id="L915"> }</span>
<span class="line" id="L916"> r.set(sum);</span>
<span class="line" id="L917"> }</span>
<span class="line" id="L918"></span>
<span class="line" id="L919"> <span class="tok-comment">/// rma = a * a</span></span>
<span class="line" id="L920"> <span class="tok-comment">///</span></span>
<span class="line" id="L921"> <span class="tok-comment">/// `rma` may not alias with `a`.</span></span>
<span class="line" id="L922"> <span class="tok-comment">///</span></span>
<span class="line" id="L923"> <span class="tok-comment">/// Asserts the result fits in `rma`. An upper bound on the number of limbs needed by</span></span>
<span class="line" id="L924"> <span class="tok-comment">/// rma is given by `2 * a.limbs.len + 1`.</span></span>
<span class="line" id="L925"> <span class="tok-comment">///</span></span>
<span class="line" id="L926"> <span class="tok-comment">/// If `allocator` is provided, it will be used for temporary storage to improve</span></span>
<span class="line" id="L927"> <span class="tok-comment">/// multiplication performance. `error.OutOfMemory` is handled with a fallback algorithm.</span></span>
<span class="line" id="L928"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">sqrNoAlias</span>(rma: *Mutable, a: Const, opt_allocator: ?Allocator) <span class="tok-type">void</span> {</span>
<span class="line" id="L929"> _ = opt_allocator;</span>
<span class="line" id="L930"> assert(rma.limbs.ptr != a.limbs.ptr); <span class="tok-comment">// illegal aliasing</span>
</span>
<span class="line" id="L931"></span>
<span class="line" id="L932"> <span class="tok-builtin">@memset</span>(rma.limbs, <span class="tok-number">0</span>);</span>
<span class="line" id="L933"></span>
<span class="line" id="L934"> llsquareBasecase(rma.limbs, a.limbs);</span>
<span class="line" id="L935"></span>
<span class="line" id="L936"> rma.normalize(<span class="tok-number">2</span> * a.limbs.len + <span class="tok-number">1</span>);</span>
<span class="line" id="L937"> rma.positive = <span class="tok-null">true</span>;</span>
<span class="line" id="L938"> }</span>
<span class="line" id="L939"></span>
<span class="line" id="L940"> <span class="tok-comment">/// q = a / b (rem r)</span></span>
<span class="line" id="L941"> <span class="tok-comment">///</span></span>
<span class="line" id="L942"> <span class="tok-comment">/// a / b are floored (rounded towards 0).</span></span>
<span class="line" id="L943"> <span class="tok-comment">/// q may alias with a or b.</span></span>
<span class="line" id="L944"> <span class="tok-comment">///</span></span>
<span class="line" id="L945"> <span class="tok-comment">/// Asserts there is enough memory to store q and r.</span></span>
<span class="line" id="L946"> <span class="tok-comment">/// The upper bound for r limb count is `b.limbs.len`.</span></span>
<span class="line" id="L947"> <span class="tok-comment">/// The upper bound for q limb count is given by `a.limbs`.</span></span>
<span class="line" id="L948"> <span class="tok-comment">///</span></span>
<span class="line" id="L949"> <span class="tok-comment">/// `limbs_buffer` is used for temporary storage. The amount required is given by `calcDivLimbsBufferLen`.</span></span>
<span class="line" id="L950"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">divFloor</span>(</span>
<span class="line" id="L951"> q: *Mutable,</span>
<span class="line" id="L952"> r: *Mutable,</span>
<span class="line" id="L953"> a: Const,</span>
<span class="line" id="L954"> b: Const,</span>
<span class="line" id="L955"> limbs_buffer: []Limb,</span>
<span class="line" id="L956"> ) <span class="tok-type">void</span> {</span>
<span class="line" id="L957"> <span class="tok-kw">const</span> sep = a.limbs.len + <span class="tok-number">2</span>;</span>
<span class="line" id="L958"> <span class="tok-kw">var</span> x = a.toMutable(limbs_buffer[<span class="tok-number">0</span>..sep]);</span>
<span class="line" id="L959"> <span class="tok-kw">var</span> y = b.toMutable(limbs_buffer[sep..]);</span>
<span class="line" id="L960"></span>
<span class="line" id="L961"> div(q, r, &x, &y);</span>
<span class="line" id="L962"></span>
<span class="line" id="L963"> <span class="tok-comment">// Note, `div` performs truncating division, which satisfies</span>
</span>
<span class="line" id="L964"> <span class="tok-comment">// @divTrunc(a, b) * b + @rem(a, b) = a</span>
</span>
<span class="line" id="L965"> <span class="tok-comment">// so r = a - @divTrunc(a, b) * b</span>
</span>
<span class="line" id="L966"> <span class="tok-comment">// Note, @rem(a, -b) = @rem(-b, a) = -@rem(a, b) = -@rem(-a, -b)</span>
</span>
<span class="line" id="L967"> <span class="tok-comment">// For divTrunc, we want to perform</span>
</span>
<span class="line" id="L968"> <span class="tok-comment">// @divFloor(a, b) * b + @mod(a, b) = a</span>
</span>
<span class="line" id="L969"> <span class="tok-comment">// Note:</span>
</span>
<span class="line" id="L970"> <span class="tok-comment">// @divFloor(-a, b)</span>
</span>
<span class="line" id="L971"> <span class="tok-comment">// = @divFloor(a, -b)</span>
</span>
<span class="line" id="L972"> <span class="tok-comment">// = -@divCeil(a, b)</span>
</span>
<span class="line" id="L973"> <span class="tok-comment">// = -@divFloor(a + b - 1, b)</span>
</span>
<span class="line" id="L974"> <span class="tok-comment">// = -@divTrunc(a + b - 1, b)</span>
</span>
<span class="line" id="L975"></span>
<span class="line" id="L976"> <span class="tok-comment">// Note (1):</span>
</span>
<span class="line" id="L977"> <span class="tok-comment">// @divTrunc(a + b - 1, b) * b + @rem(a + b - 1, b) = a + b - 1</span>
</span>
<span class="line" id="L978"> <span class="tok-comment">// = @divTrunc(a + b - 1, b) * b + @rem(a - 1, b) = a + b - 1</span>
</span>
<span class="line" id="L979"> <span class="tok-comment">// = @divTrunc(a + b - 1, b) * b + @rem(a - 1, b) - b + 1 = a</span>
</span>
<span class="line" id="L980"></span>
<span class="line" id="L981"> <span class="tok-kw">if</span> (a.positive <span class="tok-kw">and</span> b.positive) {</span>
<span class="line" id="L982"> <span class="tok-comment">// Positive-positive case, don't need to do anything.</span>
</span>
<span class="line" id="L983"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (a.positive <span class="tok-kw">and</span> !b.positive) {</span>
<span class="line" id="L984"> <span class="tok-comment">// a/-b -> q is negative, and so we need to fix flooring.</span>
</span>
<span class="line" id="L985"> <span class="tok-comment">// Subtract one to make the division flooring.</span>
</span>
<span class="line" id="L986"></span>
<span class="line" id="L987"> <span class="tok-comment">// @divFloor(a, -b) * -b + @mod(a, -b) = a</span>
</span>
<span class="line" id="L988"> <span class="tok-comment">// If b divides a exactly, we have @divFloor(a, -b) * -b = a</span>
</span>
<span class="line" id="L989"> <span class="tok-comment">// Else, we have @divFloor(a, -b) * -b > a, so @mod(a, -b) becomes negative</span>
</span>
<span class="line" id="L990"></span>
<span class="line" id="L991"> <span class="tok-comment">// We have:</span>
</span>
<span class="line" id="L992"> <span class="tok-comment">// @divFloor(a, -b) * -b + @mod(a, -b) = a</span>
</span>
<span class="line" id="L993"> <span class="tok-comment">// = -@divTrunc(a + b - 1, b) * -b + @mod(a, -b) = a</span>
</span>
<span class="line" id="L994"> <span class="tok-comment">// = @divTrunc(a + b - 1, b) * b + @mod(a, -b) = a</span>
</span>
<span class="line" id="L995"></span>
<span class="line" id="L996"> <span class="tok-comment">// Substitute a for (1):</span>
</span>
<span class="line" id="L997"> <span class="tok-comment">// @divTrunc(a + b - 1, b) * b + @rem(a - 1, b) - b + 1 = @divTrunc(a + b - 1, b) * b + @mod(a, -b)</span>
</span>
<span class="line" id="L998"> <span class="tok-comment">// Yields:</span>
</span>
<span class="line" id="L999"> <span class="tok-comment">// @mod(a, -b) = @rem(a - 1, b) - b + 1</span>
</span>
<span class="line" id="L1000"> <span class="tok-comment">// Note that `r` holds @rem(a, b) at this point.</span>
</span>
<span class="line" id="L1001"> <span class="tok-comment">//</span>
</span>
<span class="line" id="L1002"> <span class="tok-comment">// If @rem(a, b) is not 0:</span>
</span>
<span class="line" id="L1003"> <span class="tok-comment">// @rem(a - 1, b) = @rem(a, b) - 1</span>
</span>
<span class="line" id="L1004"> <span class="tok-comment">// => @mod(a, -b) = @rem(a, b) - 1 - b + 1 = @rem(a, b) - b</span>
</span>
<span class="line" id="L1005"> <span class="tok-comment">// Else:</span>
</span>
<span class="line" id="L1006"> <span class="tok-comment">// @rem(a - 1, b) = @rem(a + b - 1, b) = @rem(b - 1, b) = b - 1</span>
</span>
<span class="line" id="L1007"> <span class="tok-comment">// => @mod(a, -b) = b - 1 - b + 1 = 0</span>
</span>
<span class="line" id="L1008"> <span class="tok-kw">if</span> (!r.eqlZero()) {</span>
<span class="line" id="L1009"> q.addScalar(q.toConst(), -<span class="tok-number">1</span>);</span>
<span class="line" id="L1010"> r.positive = <span class="tok-null">true</span>;</span>
<span class="line" id="L1011"> r.sub(r.toConst(), y.toConst().abs());</span>
<span class="line" id="L1012"> }</span>
<span class="line" id="L1013"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (!a.positive <span class="tok-kw">and</span> b.positive) {</span>
<span class="line" id="L1014"> <span class="tok-comment">// -a/b -> q is negative, and so we need to fix flooring.</span>
</span>
<span class="line" id="L1015"> <span class="tok-comment">// Subtract one to make the division flooring.</span>
</span>
<span class="line" id="L1016"></span>
<span class="line" id="L1017"> <span class="tok-comment">// @divFloor(-a, b) * b + @mod(-a, b) = a</span>
</span>
<span class="line" id="L1018"> <span class="tok-comment">// If b divides a exactly, we have @divFloor(-a, b) * b = -a</span>
</span>
<span class="line" id="L1019"> <span class="tok-comment">// Else, we have @divFloor(-a, b) * b < -a, so @mod(-a, b) becomes positive</span>
</span>
<span class="line" id="L1020"></span>
<span class="line" id="L1021"> <span class="tok-comment">// We have:</span>
</span>
<span class="line" id="L1022"> <span class="tok-comment">// @divFloor(-a, b) * b + @mod(-a, b) = -a</span>
</span>
<span class="line" id="L1023"> <span class="tok-comment">// = -@divTrunc(a + b - 1, b) * b + @mod(-a, b) = -a</span>
</span>
<span class="line" id="L1024"> <span class="tok-comment">// = @divTrunc(a + b - 1, b) * b - @mod(-a, b) = a</span>
</span>
<span class="line" id="L1025"></span>
<span class="line" id="L1026"> <span class="tok-comment">// Substitute a for (1):</span>
</span>
<span class="line" id="L1027"> <span class="tok-comment">// @divTrunc(a + b - 1, b) * b + @rem(a - 1, b) - b + 1 = @divTrunc(a + b - 1, b) * b - @mod(-a, b)</span>
</span>
<span class="line" id="L1028"> <span class="tok-comment">// Yields:</span>
</span>
<span class="line" id="L1029"> <span class="tok-comment">// @rem(a - 1, b) - b + 1 = -@mod(-a, b)</span>
</span>
<span class="line" id="L1030"> <span class="tok-comment">// => -@mod(-a, b) = @rem(a - 1, b) - b + 1</span>
</span>
<span class="line" id="L1031"> <span class="tok-comment">// => @mod(-a, b) = -(@rem(a - 1, b) - b + 1) = -@rem(a - 1, b) + b - 1</span>
</span>
<span class="line" id="L1032"> <span class="tok-comment">//</span>
</span>
<span class="line" id="L1033"> <span class="tok-comment">// If @rem(a, b) is not 0:</span>
</span>
<span class="line" id="L1034"> <span class="tok-comment">// @rem(a - 1, b) = @rem(a, b) - 1</span>
</span>
<span class="line" id="L1035"> <span class="tok-comment">// => @mod(-a, b) = -(@rem(a, b) - 1) + b - 1 = -@rem(a, b) + 1 + b - 1 = -@rem(a, b) + b</span>
</span>
<span class="line" id="L1036"> <span class="tok-comment">// Else :</span>
</span>
<span class="line" id="L1037"> <span class="tok-comment">// @rem(a - 1, b) = b - 1</span>
</span>
<span class="line" id="L1038"> <span class="tok-comment">// => @mod(-a, b) = -(b - 1) + b - 1 = 0</span>
</span>
<span class="line" id="L1039"> <span class="tok-kw">if</span> (!r.eqlZero()) {</span>
<span class="line" id="L1040"> q.addScalar(q.toConst(), -<span class="tok-number">1</span>);</span>
<span class="line" id="L1041"> r.positive = <span class="tok-null">false</span>;</span>
<span class="line" id="L1042"> r.add(r.toConst(), y.toConst().abs());</span>
<span class="line" id="L1043"> }</span>
<span class="line" id="L1044"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (!a.positive <span class="tok-kw">and</span> !b.positive) {</span>
<span class="line" id="L1045"> <span class="tok-comment">// a/b -> q is positive, don't need to do anything to fix flooring.</span>
</span>
<span class="line" id="L1046"></span>
<span class="line" id="L1047"> <span class="tok-comment">// @divFloor(-a, -b) * -b + @mod(-a, -b) = -a</span>
</span>
<span class="line" id="L1048"> <span class="tok-comment">// If b divides a exactly, we have @divFloor(-a, -b) * -b = -a</span>
</span>
<span class="line" id="L1049"> <span class="tok-comment">// Else, we have @divFloor(-a, -b) * -b > -a, so @mod(-a, -b) becomes negative</span>
</span>
<span class="line" id="L1050"></span>
<span class="line" id="L1051"> <span class="tok-comment">// We have:</span>
</span>
<span class="line" id="L1052"> <span class="tok-comment">// @divFloor(-a, -b) * -b + @mod(-a, -b) = -a</span>
</span>
<span class="line" id="L1053"> <span class="tok-comment">// = @divTrunc(a, b) * -b + @mod(-a, -b) = -a</span>
</span>
<span class="line" id="L1054"> <span class="tok-comment">// = @divTrunc(a, b) * b - @mod(-a, -b) = a</span>
</span>
<span class="line" id="L1055"></span>
<span class="line" id="L1056"> <span class="tok-comment">// We also have:</span>
</span>
<span class="line" id="L1057"> <span class="tok-comment">// @divTrunc(a, b) * b + @rem(a, b) = a</span>
</span>
<span class="line" id="L1058"></span>
<span class="line" id="L1059"> <span class="tok-comment">// Substitute a:</span>
</span>
<span class="line" id="L1060"> <span class="tok-comment">// @divTrunc(a, b) * b + @rem(a, b) = @divTrunc(a, b) * b - @mod(-a, -b)</span>
</span>
<span class="line" id="L1061"> <span class="tok-comment">// => @rem(a, b) = -@mod(-a, -b)</span>
</span>
<span class="line" id="L1062"> <span class="tok-comment">// => @mod(-a, -b) = -@rem(a, b)</span>
</span>
<span class="line" id="L1063"> r.positive = <span class="tok-null">false</span>;</span>
<span class="line" id="L1064"> }</span>
<span class="line" id="L1065"> }</span>
<span class="line" id="L1066"></span>
<span class="line" id="L1067"> <span class="tok-comment">/// q = a / b (rem r)</span></span>
<span class="line" id="L1068"> <span class="tok-comment">///</span></span>
<span class="line" id="L1069"> <span class="tok-comment">/// a / b are truncated (rounded towards -inf).</span></span>
<span class="line" id="L1070"> <span class="tok-comment">/// q may alias with a or b.</span></span>
<span class="line" id="L1071"> <span class="tok-comment">///</span></span>
<span class="line" id="L1072"> <span class="tok-comment">/// Asserts there is enough memory to store q and r.</span></span>
<span class="line" id="L1073"> <span class="tok-comment">/// The upper bound for r limb count is `b.limbs.len`.</span></span>
<span class="line" id="L1074"> <span class="tok-comment">/// The upper bound for q limb count is given by `a.limbs.len`.</span></span>
<span class="line" id="L1075"> <span class="tok-comment">///</span></span>
<span class="line" id="L1076"> <span class="tok-comment">/// `limbs_buffer` is used for temporary storage. The amount required is given by `calcDivLimbsBufferLen`.</span></span>
<span class="line" id="L1077"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">divTrunc</span>(</span>
<span class="line" id="L1078"> q: *Mutable,</span>
<span class="line" id="L1079"> r: *Mutable,</span>
<span class="line" id="L1080"> a: Const,</span>
<span class="line" id="L1081"> b: Const,</span>
<span class="line" id="L1082"> limbs_buffer: []Limb,</span>
<span class="line" id="L1083"> ) <span class="tok-type">void</span> {</span>
<span class="line" id="L1084"> <span class="tok-kw">const</span> sep = a.limbs.len + <span class="tok-number">2</span>;</span>
<span class="line" id="L1085"> <span class="tok-kw">var</span> x = a.toMutable(limbs_buffer[<span class="tok-number">0</span>..sep]);</span>
<span class="line" id="L1086"> <span class="tok-kw">var</span> y = b.toMutable(limbs_buffer[sep..]);</span>
<span class="line" id="L1087"></span>
<span class="line" id="L1088"> div(q, r, &x, &y);</span>
<span class="line" id="L1089"> }</span>
<span class="line" id="L1090"></span>
<span class="line" id="L1091"> <span class="tok-comment">/// r = a << shift, in other words, r = a * 2^shift</span></span>
<span class="line" id="L1092"> <span class="tok-comment">///</span></span>
<span class="line" id="L1093"> <span class="tok-comment">/// r and a may alias.</span></span>
<span class="line" id="L1094"> <span class="tok-comment">///</span></span>
<span class="line" id="L1095"> <span class="tok-comment">/// Asserts there is enough memory to fit the result. The upper bound Limb count is</span></span>
<span class="line" id="L1096"> <span class="tok-comment">/// `a.limbs.len + (shift / (@sizeOf(Limb) * 8))`.</span></span>
<span class="line" id="L1097"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">shiftLeft</span>(r: *Mutable, a: Const, shift: <span class="tok-type">usize</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L1098"> llshl(r.limbs[<span class="tok-number">0</span>..], a.limbs[<span class="tok-number">0</span>..a.limbs.len], shift);</span>
<span class="line" id="L1099"> r.normalize(a.limbs.len + (shift / limb_bits) + <span class="tok-number">1</span>);</span>
<span class="line" id="L1100"> r.positive = a.positive;</span>
<span class="line" id="L1101"> }</span>
<span class="line" id="L1102"></span>
<span class="line" id="L1103"> <span class="tok-comment">/// r = a <<| shift with 2s-complement saturating semantics.</span></span>
<span class="line" id="L1104"> <span class="tok-comment">///</span></span>
<span class="line" id="L1105"> <span class="tok-comment">/// r and a may alias.</span></span>
<span class="line" id="L1106"> <span class="tok-comment">///</span></span>
<span class="line" id="L1107"> <span class="tok-comment">/// Asserts there is enough memory to fit the result. The upper bound Limb count is</span></span>
<span class="line" id="L1108"> <span class="tok-comment">/// r is `calcTwosCompLimbCount(bit_count)`.</span></span>
<span class="line" id="L1109"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">shiftLeftSat</span>(r: *Mutable, a: Const, shift: <span class="tok-type">usize</span>, signedness: Signedness, bit_count: <span class="tok-type">usize</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L1110"> <span class="tok-comment">// Special case: When the argument is negative, but the result is supposed to be unsigned,</span>
</span>
<span class="line" id="L1111"> <span class="tok-comment">// return 0 in all cases.</span>
</span>
<span class="line" id="L1112"> <span class="tok-kw">if</span> (!a.positive <span class="tok-kw">and</span> signedness == .unsigned) {</span>
<span class="line" id="L1113"> r.set(<span class="tok-number">0</span>);</span>
<span class="line" id="L1114"> <span class="tok-kw">return</span>;</span>
<span class="line" id="L1115"> }</span>
<span class="line" id="L1116"></span>
<span class="line" id="L1117"> <span class="tok-comment">// Check whether the shift is going to overflow. This is the case</span>
</span>
<span class="line" id="L1118"> <span class="tok-comment">// when (in 2s complement) any bit above `bit_count - shift` is set in the unshifted value.</span>
</span>
<span class="line" id="L1119"> <span class="tok-comment">// Note, the sign bit is not counted here.</span>
</span>
<span class="line" id="L1120"></span>
<span class="line" id="L1121"> <span class="tok-comment">// Handle shifts larger than the target type. This also deals with</span>
</span>
<span class="line" id="L1122"> <span class="tok-comment">// 0-bit integers.</span>
</span>
<span class="line" id="L1123"> <span class="tok-kw">if</span> (bit_count <= shift) {</span>
<span class="line" id="L1124"> <span class="tok-comment">// In this case, there is only no overflow if `a` is zero.</span>
</span>
<span class="line" id="L1125"> <span class="tok-kw">if</span> (a.eqlZero()) {</span>
<span class="line" id="L1126"> r.set(<span class="tok-number">0</span>);</span>
<span class="line" id="L1127"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L1128"> r.setTwosCompIntLimit(<span class="tok-kw">if</span> (a.positive) .max <span class="tok-kw">else</span> .min, signedness, bit_count);</span>
<span class="line" id="L1129"> }</span>
<span class="line" id="L1130"> <span class="tok-kw">return</span>;</span>
<span class="line" id="L1131"> }</span>
<span class="line" id="L1132"></span>
<span class="line" id="L1133"> <span class="tok-kw">const</span> checkbit = bit_count - shift - <span class="tok-builtin">@intFromBool</span>(signedness == .signed);</span>
<span class="line" id="L1134"> <span class="tok-comment">// If `checkbit` and more significant bits are zero, no overflow will take place.</span>
</span>
<span class="line" id="L1135"></span>
<span class="line" id="L1136"> <span class="tok-kw">if</span> (checkbit >= a.limbs.len * limb_bits) {</span>
<span class="line" id="L1137"> <span class="tok-comment">// `checkbit` is outside the range of a, so definitely no overflow will take place. We</span>
</span>
<span class="line" id="L1138"> <span class="tok-comment">// can defer to a normal shift.</span>
</span>
<span class="line" id="L1139"> <span class="tok-comment">// Note that if `a` is normalized (which we assume), this checks for set bits in the upper limbs.</span>
</span>
<span class="line" id="L1140"></span>
<span class="line" id="L1141"> <span class="tok-comment">// Note, in this case r should already have enough limbs required to perform the normal shift.</span>
</span>
<span class="line" id="L1142"> <span class="tok-comment">// In this case the shift of the most significant limb may still overflow.</span>
</span>
<span class="line" id="L1143"> r.shiftLeft(a, shift);</span>
<span class="line" id="L1144"> <span class="tok-kw">return</span>;</span>
<span class="line" id="L1145"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (checkbit < (a.limbs.len - <span class="tok-number">1</span>) * limb_bits) {</span>
<span class="line" id="L1146"> <span class="tok-comment">// `checkbit` is not in the most significant limb. If `a` is normalized the most significant</span>
</span>
<span class="line" id="L1147"> <span class="tok-comment">// limb will not be zero, so in this case we need to saturate. Note that `a.limbs.len` must be</span>
</span>
<span class="line" id="L1148"> <span class="tok-comment">// at least one according to normalization rules.</span>
</span>
<span class="line" id="L1149"></span>
<span class="line" id="L1150"> r.setTwosCompIntLimit(<span class="tok-kw">if</span> (a.positive) .max <span class="tok-kw">else</span> .min, signedness, bit_count);</span>
<span class="line" id="L1151"> <span class="tok-kw">return</span>;</span>
<span class="line" id="L1152"> }</span>
<span class="line" id="L1153"></span>
<span class="line" id="L1154"> <span class="tok-comment">// Generate a mask with the bits to check in the most significant limb. We'll need to check</span>
</span>
<span class="line" id="L1155"> <span class="tok-comment">// all bits with equal or more significance than checkbit.</span>
</span>
<span class="line" id="L1156"> <span class="tok-comment">// const msb = @truncate(Log2Limb, checkbit);</span>
</span>
<span class="line" id="L1157"> <span class="tok-comment">// const checkmask = (@as(Limb, 1) << msb) -% 1;</span>
</span>
<span class="line" id="L1158"></span>
<span class="line" id="L1159"> <span class="tok-kw">if</span> (a.limbs[a.limbs.len - <span class="tok-number">1</span>] >> <span class="tok-builtin">@as</span>(Log2Limb, <span class="tok-builtin">@truncate</span>(checkbit)) != <span class="tok-number">0</span>) {</span>
<span class="line" id="L1160"> <span class="tok-comment">// Need to saturate.</span>
</span>
<span class="line" id="L1161"> r.setTwosCompIntLimit(<span class="tok-kw">if</span> (a.positive) .max <span class="tok-kw">else</span> .min, signedness, bit_count);</span>
<span class="line" id="L1162"> <span class="tok-kw">return</span>;</span>
<span class="line" id="L1163"> }</span>
<span class="line" id="L1164"></span>
<span class="line" id="L1165"> <span class="tok-comment">// This shift should not be able to overflow, so invoke llshl and normalize manually</span>
</span>
<span class="line" id="L1166"> <span class="tok-comment">// to avoid the extra required limb.</span>
</span>
<span class="line" id="L1167"> llshl(r.limbs[<span class="tok-number">0</span>..], a.limbs[<span class="tok-number">0</span>..a.limbs.len], shift);</span>
<span class="line" id="L1168"> r.normalize(a.limbs.len + (shift / limb_bits));</span>
<span class="line" id="L1169"> r.positive = a.positive;</span>
<span class="line" id="L1170"> }</span>
<span class="line" id="L1171"></span>
<span class="line" id="L1172"> <span class="tok-comment">/// r = a >> shift</span></span>
<span class="line" id="L1173"> <span class="tok-comment">/// r and a may alias.</span></span>
<span class="line" id="L1174"> <span class="tok-comment">///</span></span>
<span class="line" id="L1175"> <span class="tok-comment">/// Asserts there is enough memory to fit the result. The upper bound Limb count is</span></span>
<span class="line" id="L1176"> <span class="tok-comment">/// `a.limbs.len - (shift / (@sizeOf(Limb) * 8))`.</span></span>
<span class="line" id="L1177"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">shiftRight</span>(r: *Mutable, a: Const, shift: <span class="tok-type">usize</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L1178"> <span class="tok-kw">if</span> (a.limbs.len <= shift / limb_bits) {</span>
<span class="line" id="L1179"> <span class="tok-comment">// Shifting negative numbers converges to -1 instead of 0</span>
</span>
<span class="line" id="L1180"> <span class="tok-kw">if</span> (a.positive) {</span>
<span class="line" id="L1181"> r.len = <span class="tok-number">1</span>;</span>
<span class="line" id="L1182"> r.positive = <span class="tok-null">true</span>;</span>
<span class="line" id="L1183"> r.limbs[<span class="tok-number">0</span>] = <span class="tok-number">0</span>;</span>
<span class="line" id="L1184"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L1185"> r.len = <span class="tok-number">1</span>;</span>
<span class="line" id="L1186"> r.positive = <span class="tok-null">false</span>;</span>
<span class="line" id="L1187"> r.limbs[<span class="tok-number">0</span>] = <span class="tok-number">1</span>;</span>
<span class="line" id="L1188"> }</span>
<span class="line" id="L1189"> <span class="tok-kw">return</span>;</span>
<span class="line" id="L1190"> }</span>
<span class="line" id="L1191"></span>
<span class="line" id="L1192"> llshr(r.limbs[<span class="tok-number">0</span>..], a.limbs[<span class="tok-number">0</span>..a.limbs.len], shift);</span>
<span class="line" id="L1193"> r.normalize(a.limbs.len - (shift / limb_bits));</span>
<span class="line" id="L1194"> r.positive = a.positive;</span>
<span class="line" id="L1195"> <span class="tok-comment">// Shifting negative numbers converges to -1 instead of 0</span>
</span>
<span class="line" id="L1196"> <span class="tok-kw">if</span> (!r.positive <span class="tok-kw">and</span> r.len == <span class="tok-number">1</span> <span class="tok-kw">and</span> r.limbs[<span class="tok-number">0</span>] == <span class="tok-number">0</span>) {</span>
<span class="line" id="L1197"> r.limbs[<span class="tok-number">0</span>] = <span class="tok-number">1</span>;</span>
<span class="line" id="L1198"> }</span>
<span class="line" id="L1199"> }</span>
<span class="line" id="L1200"></span>
<span class="line" id="L1201"> <span class="tok-comment">/// r = ~a under 2s complement wrapping semantics.</span></span>
<span class="line" id="L1202"> <span class="tok-comment">/// r may alias with a.</span></span>
<span class="line" id="L1203"> <span class="tok-comment">///</span></span>
<span class="line" id="L1204"> <span class="tok-comment">/// Assets that r has enough limbs to store the result. The upper bound Limb count is</span></span>
<span class="line" id="L1205"> <span class="tok-comment">/// r is `calcTwosCompLimbCount(bit_count)`.</span></span>
<span class="line" id="L1206"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">bitNotWrap</span>(r: *Mutable, a: Const, signedness: Signedness, bit_count: <span class="tok-type">usize</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L1207"> r.copy(a.negate());</span>
<span class="line" id="L1208"> <span class="tok-kw">const</span> negative_one = Const{ .limbs = &.{<span class="tok-number">1</span>}, .positive = <span class="tok-null">false</span> };</span>
<span class="line" id="L1209"> _ = r.addWrap(r.toConst(), negative_one, signedness, bit_count);</span>
<span class="line" id="L1210"> }</span>
<span class="line" id="L1211"></span>
<span class="line" id="L1212"> <span class="tok-comment">/// r = a | b under 2s complement semantics.</span></span>
<span class="line" id="L1213"> <span class="tok-comment">/// r may alias with a or b.</span></span>
<span class="line" id="L1214"> <span class="tok-comment">///</span></span>
<span class="line" id="L1215"> <span class="tok-comment">/// a and b are zero-extended to the longer of a or b.</span></span>
<span class="line" id="L1216"> <span class="tok-comment">///</span></span>
<span class="line" id="L1217"> <span class="tok-comment">/// Asserts that r has enough limbs to store the result. Upper bound is `@max(a.limbs.len, b.limbs.len)`.</span></span>
<span class="line" id="L1218"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">bitOr</span>(r: *Mutable, a: Const, b: Const) <span class="tok-type">void</span> {</span>
<span class="line" id="L1219"> <span class="tok-comment">// Trivial cases, llsignedor does not support zero.</span>
</span>
<span class="line" id="L1220"> <span class="tok-kw">if</span> (a.eqlZero()) {</span>
<span class="line" id="L1221"> r.copy(b);</span>
<span class="line" id="L1222"> <span class="tok-kw">return</span>;</span>
<span class="line" id="L1223"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (b.eqlZero()) {</span>
<span class="line" id="L1224"> r.copy(a);</span>
<span class="line" id="L1225"> <span class="tok-kw">return</span>;</span>
<span class="line" id="L1226"> }</span>
<span class="line" id="L1227"></span>
<span class="line" id="L1228"> <span class="tok-kw">if</span> (a.limbs.len >= b.limbs.len) {</span>
<span class="line" id="L1229"> r.positive = llsignedor(r.limbs, a.limbs, a.positive, b.limbs, b.positive);</span>
<span class="line" id="L1230"> r.normalize(<span class="tok-kw">if</span> (b.positive) a.limbs.len <span class="tok-kw">else</span> b.limbs.len);</span>
<span class="line" id="L1231"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L1232"> r.positive = llsignedor(r.limbs, b.limbs, b.positive, a.limbs, a.positive);</span>
<span class="line" id="L1233"> r.normalize(<span class="tok-kw">if</span> (a.positive) b.limbs.len <span class="tok-kw">else</span> a.limbs.len);</span>
<span class="line" id="L1234"> }</span>
<span class="line" id="L1235"> }</span>
<span class="line" id="L1236"></span>
<span class="line" id="L1237"> <span class="tok-comment">/// r = a & b under 2s complement semantics.</span></span>
<span class="line" id="L1238"> <span class="tok-comment">/// r may alias with a or b.</span></span>
<span class="line" id="L1239"> <span class="tok-comment">///</span></span>
<span class="line" id="L1240"> <span class="tok-comment">/// Asserts that r has enough limbs to store the result.</span></span>
<span class="line" id="L1241"> <span class="tok-comment">/// If a or b is positive, the upper bound is `@min(a.limbs.len, b.limbs.len)`.</span></span>
<span class="line" id="L1242"> <span class="tok-comment">/// If a and b are negative, the upper bound is `@max(a.limbs.len, b.limbs.len) + 1`.</span></span>
<span class="line" id="L1243"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">bitAnd</span>(r: *Mutable, a: Const, b: Const) <span class="tok-type">void</span> {</span>
<span class="line" id="L1244"> <span class="tok-comment">// Trivial cases, llsignedand does not support zero.</span>
</span>
<span class="line" id="L1245"> <span class="tok-kw">if</span> (a.eqlZero()) {</span>
<span class="line" id="L1246"> r.copy(a);</span>
<span class="line" id="L1247"> <span class="tok-kw">return</span>;</span>
<span class="line" id="L1248"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (b.eqlZero()) {</span>
<span class="line" id="L1249"> r.copy(b);</span>
<span class="line" id="L1250"> <span class="tok-kw">return</span>;</span>
<span class="line" id="L1251"> }</span>
<span class="line" id="L1252"></span>
<span class="line" id="L1253"> <span class="tok-kw">if</span> (a.limbs.len >= b.limbs.len) {</span>
<span class="line" id="L1254"> r.positive = llsignedand(r.limbs, a.limbs, a.positive, b.limbs, b.positive);</span>
<span class="line" id="L1255"> r.normalize(<span class="tok-kw">if</span> (a.positive <span class="tok-kw">or</span> b.positive) b.limbs.len <span class="tok-kw">else</span> a.limbs.len + <span class="tok-number">1</span>);</span>
<span class="line" id="L1256"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L1257"> r.positive = llsignedand(r.limbs, b.limbs, b.positive, a.limbs, a.positive);</span>
<span class="line" id="L1258"> r.normalize(<span class="tok-kw">if</span> (a.positive <span class="tok-kw">or</span> b.positive) a.limbs.len <span class="tok-kw">else</span> b.limbs.len + <span class="tok-number">1</span>);</span>
<span class="line" id="L1259"> }</span>
<span class="line" id="L1260"> }</span>
<span class="line" id="L1261"></span>
<span class="line" id="L1262"> <span class="tok-comment">/// r = a ^ b under 2s complement semantics.</span></span>
<span class="line" id="L1263"> <span class="tok-comment">/// r may alias with a or b.</span></span>
<span class="line" id="L1264"> <span class="tok-comment">///</span></span>
<span class="line" id="L1265"> <span class="tok-comment">/// Asserts that r has enough limbs to store the result. If a and b share the same signedness, the</span></span>
<span class="line" id="L1266"> <span class="tok-comment">/// upper bound is `@max(a.limbs.len, b.limbs.len)`. Otherwise, if either a or b is negative</span></span>
<span class="line" id="L1267"> <span class="tok-comment">/// but not both, the upper bound is `@max(a.limbs.len, b.limbs.len) + 1`.</span></span>
<span class="line" id="L1268"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">bitXor</span>(r: *Mutable, a: Const, b: Const) <span class="tok-type">void</span> {</span>
<span class="line" id="L1269"> <span class="tok-comment">// Trivial cases, because llsignedxor does not support negative zero.</span>
</span>
<span class="line" id="L1270"> <span class="tok-kw">if</span> (a.eqlZero()) {</span>
<span class="line" id="L1271"> r.copy(b);</span>
<span class="line" id="L1272"> <span class="tok-kw">return</span>;</span>
<span class="line" id="L1273"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (b.eqlZero()) {</span>
<span class="line" id="L1274"> r.copy(a);</span>
<span class="line" id="L1275"> <span class="tok-kw">return</span>;</span>
<span class="line" id="L1276"> }</span>
<span class="line" id="L1277"></span>
<span class="line" id="L1278"> <span class="tok-kw">if</span> (a.limbs.len > b.limbs.len) {</span>
<span class="line" id="L1279"> r.positive = llsignedxor(r.limbs, a.limbs, a.positive, b.limbs, b.positive);</span>
<span class="line" id="L1280"> r.normalize(a.limbs.len + <span class="tok-builtin">@intFromBool</span>(a.positive != b.positive));</span>
<span class="line" id="L1281"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L1282"> r.positive = llsignedxor(r.limbs, b.limbs, b.positive, a.limbs, a.positive);</span>
<span class="line" id="L1283"> r.normalize(b.limbs.len + <span class="tok-builtin">@intFromBool</span>(a.positive != b.positive));</span>
<span class="line" id="L1284"> }</span>
<span class="line" id="L1285"> }</span>
<span class="line" id="L1286"></span>
<span class="line" id="L1287"> <span class="tok-comment">/// rma may alias x or y.</span></span>
<span class="line" id="L1288"> <span class="tok-comment">/// x and y may alias each other.</span></span>
<span class="line" id="L1289"> <span class="tok-comment">/// Asserts that `rma` has enough limbs to store the result. Upper bound is</span></span>
<span class="line" id="L1290"> <span class="tok-comment">/// `@min(x.limbs.len, y.limbs.len)`.</span></span>
<span class="line" id="L1291"> <span class="tok-comment">///</span></span>
<span class="line" id="L1292"> <span class="tok-comment">/// `limbs_buffer` is used for temporary storage during the operation. When this function returns,</span></span>
<span class="line" id="L1293"> <span class="tok-comment">/// it will have the same length as it had when the function was called.</span></span>
<span class="line" id="L1294"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">gcd</span>(rma: *Mutable, x: Const, y: Const, limbs_buffer: *std.ArrayList(Limb)) !<span class="tok-type">void</span> {</span>
<span class="line" id="L1295"> <span class="tok-kw">const</span> prev_len = limbs_buffer.items.len;</span>
<span class="line" id="L1296"> <span class="tok-kw">defer</span> limbs_buffer.shrinkRetainingCapacity(prev_len);</span>
<span class="line" id="L1297"> <span class="tok-kw">const</span> x_copy = <span class="tok-kw">if</span> (rma.limbs.ptr == x.limbs.ptr) blk: {</span>
<span class="line" id="L1298"> <span class="tok-kw">const</span> start = limbs_buffer.items.len;</span>
<span class="line" id="L1299"> <span class="tok-kw">try</span> limbs_buffer.appendSlice(x.limbs);</span>
<span class="line" id="L1300"> <span class="tok-kw">break</span> :blk x.toMutable(limbs_buffer.items[start..]).toConst();</span>
<span class="line" id="L1301"> } <span class="tok-kw">else</span> x;</span>
<span class="line" id="L1302"> <span class="tok-kw">const</span> y_copy = <span class="tok-kw">if</span> (rma.limbs.ptr == y.limbs.ptr) blk: {</span>
<span class="line" id="L1303"> <span class="tok-kw">const</span> start = limbs_buffer.items.len;</span>
<span class="line" id="L1304"> <span class="tok-kw">try</span> limbs_buffer.appendSlice(y.limbs);</span>
<span class="line" id="L1305"> <span class="tok-kw">break</span> :blk y.toMutable(limbs_buffer.items[start..]).toConst();</span>
<span class="line" id="L1306"> } <span class="tok-kw">else</span> y;</span>
<span class="line" id="L1307"></span>
<span class="line" id="L1308"> <span class="tok-kw">return</span> gcdLehmer(rma, x_copy, y_copy, limbs_buffer);</span>
<span class="line" id="L1309"> }</span>
<span class="line" id="L1310"></span>
<span class="line" id="L1311"> <span class="tok-comment">/// q = a ^ b</span></span>
<span class="line" id="L1312"> <span class="tok-comment">///</span></span>
<span class="line" id="L1313"> <span class="tok-comment">/// r may not alias a.</span></span>
<span class="line" id="L1314"> <span class="tok-comment">///</span></span>
<span class="line" id="L1315"> <span class="tok-comment">/// Asserts that `r` has enough limbs to store the result. Upper bound is</span></span>
<span class="line" id="L1316"> <span class="tok-comment">/// `calcPowLimbsBufferLen(a.bitCountAbs(), b)`.</span></span>
<span class="line" id="L1317"> <span class="tok-comment">///</span></span>
<span class="line" id="L1318"> <span class="tok-comment">/// `limbs_buffer` is used for temporary storage.</span></span>
<span class="line" id="L1319"> <span class="tok-comment">/// The amount required is given by `calcPowLimbsBufferLen`.</span></span>
<span class="line" id="L1320"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">pow</span>(r: *Mutable, a: Const, b: <span class="tok-type">u32</span>, limbs_buffer: []Limb) !<span class="tok-type">void</span> {</span>
<span class="line" id="L1321"> assert(r.limbs.ptr != a.limbs.ptr); <span class="tok-comment">// illegal aliasing</span>
</span>
<span class="line" id="L1322"></span>
<span class="line" id="L1323"> <span class="tok-comment">// Handle all the trivial cases first</span>
</span>
<span class="line" id="L1324"> <span class="tok-kw">switch</span> (b) {</span>
<span class="line" id="L1325"> <span class="tok-number">0</span> => {</span>
<span class="line" id="L1326"> <span class="tok-comment">// a^0 = 1</span>
</span>
<span class="line" id="L1327"> <span class="tok-kw">return</span> r.set(<span class="tok-number">1</span>);</span>
<span class="line" id="L1328"> },</span>
<span class="line" id="L1329"> <span class="tok-number">1</span> => {</span>
<span class="line" id="L1330"> <span class="tok-comment">// a^1 = a</span>
</span>
<span class="line" id="L1331"> <span class="tok-kw">return</span> r.copy(a);</span>
<span class="line" id="L1332"> },</span>
<span class="line" id="L1333"> <span class="tok-kw">else</span> => {},</span>
<span class="line" id="L1334"> }</span>
<span class="line" id="L1335"></span>
<span class="line" id="L1336"> <span class="tok-kw">if</span> (a.eqlZero()) {</span>
<span class="line" id="L1337"> <span class="tok-comment">// 0^b = 0</span>
</span>
<span class="line" id="L1338"> <span class="tok-kw">return</span> r.set(<span class="tok-number">0</span>);</span>
<span class="line" id="L1339"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (a.limbs.len == <span class="tok-number">1</span> <span class="tok-kw">and</span> a.limbs[<span class="tok-number">0</span>] == <span class="tok-number">1</span>) {</span>
<span class="line" id="L1340"> <span class="tok-comment">// 1^b = 1 and -1^b = ±1</span>
</span>
<span class="line" id="L1341"> r.set(<span class="tok-number">1</span>);</span>
<span class="line" id="L1342"> r.positive = a.positive <span class="tok-kw">or</span> (b & <span class="tok-number">1</span>) == <span class="tok-number">0</span>;</span>
<span class="line" id="L1343"> <span class="tok-kw">return</span>;</span>
<span class="line" id="L1344"> }</span>
<span class="line" id="L1345"></span>
<span class="line" id="L1346"> <span class="tok-comment">// Here a>1 and b>1</span>
</span>
<span class="line" id="L1347"> <span class="tok-kw">const</span> needed_limbs = calcPowLimbsBufferLen(a.bitCountAbs(), b);</span>
<span class="line" id="L1348"> assert(r.limbs.len >= needed_limbs);</span>
<span class="line" id="L1349"> assert(limbs_buffer.len >= needed_limbs);</span>
<span class="line" id="L1350"></span>
<span class="line" id="L1351"> llpow(r.limbs, a.limbs, b, limbs_buffer);</span>
<span class="line" id="L1352"></span>
<span class="line" id="L1353"> r.normalize(needed_limbs);</span>
<span class="line" id="L1354"> r.positive = a.positive <span class="tok-kw">or</span> (b & <span class="tok-number">1</span>) == <span class="tok-number">0</span>;</span>
<span class="line" id="L1355"> }</span>
<span class="line" id="L1356"></span>
<span class="line" id="L1357"> <span class="tok-comment">/// r = ⌊√a⌋</span></span>
<span class="line" id="L1358"> <span class="tok-comment">///</span></span>
<span class="line" id="L1359"> <span class="tok-comment">/// r may alias a.</span></span>
<span class="line" id="L1360"> <span class="tok-comment">///</span></span>
<span class="line" id="L1361"> <span class="tok-comment">/// Asserts that `r` has enough limbs to store the result. Upper bound is</span></span>
<span class="line" id="L1362"> <span class="tok-comment">/// `(a.limbs.len - 1) / 2 + 1`.</span></span>
<span class="line" id="L1363"> <span class="tok-comment">///</span></span>
<span class="line" id="L1364"> <span class="tok-comment">/// `limbs_buffer` is used for temporary storage.</span></span>
<span class="line" id="L1365"> <span class="tok-comment">/// The amount required is given by `calcSqrtLimbsBufferLen`.</span></span>
<span class="line" id="L1366"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">sqrt</span>(</span>
<span class="line" id="L1367"> r: *Mutable,</span>
<span class="line" id="L1368"> a: Const,</span>
<span class="line" id="L1369"> limbs_buffer: []Limb,</span>
<span class="line" id="L1370"> ) <span class="tok-type">void</span> {</span>
<span class="line" id="L1371"> <span class="tok-comment">// Brent and Zimmermann, Modern Computer Arithmetic, Algorithm 1.13 SqrtInt</span>
</span>
<span class="line" id="L1372"> <span class="tok-comment">// https://members.loria.fr/PZimmermann/mca/pub226.html</span>
</span>
<span class="line" id="L1373"> <span class="tok-kw">var</span> buf_index: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L1374"> <span class="tok-kw">var</span> t = b: {</span>
<span class="line" id="L1375"> <span class="tok-kw">const</span> start = buf_index;</span>
<span class="line" id="L1376"> buf_index += a.limbs.len;</span>
<span class="line" id="L1377"> <span class="tok-kw">break</span> :b Mutable.init(limbs_buffer[start..buf_index], <span class="tok-number">0</span>);</span>
<span class="line" id="L1378"> };</span>
<span class="line" id="L1379"> <span class="tok-kw">var</span> u = b: {</span>
<span class="line" id="L1380"> <span class="tok-kw">const</span> start = buf_index;</span>
<span class="line" id="L1381"> <span class="tok-kw">const</span> shift = (a.bitCountAbs() + <span class="tok-number">1</span>) / <span class="tok-number">2</span>;</span>
<span class="line" id="L1382"> buf_index += <span class="tok-number">1</span> + ((shift - <span class="tok-number">1</span>) / limb_bits + <span class="tok-number">1</span>);</span>
<span class="line" id="L1383"> <span class="tok-kw">var</span> m = Mutable.init(limbs_buffer[start..buf_index], <span class="tok-number">1</span>);</span>
<span class="line" id="L1384"> m.shiftLeft(m.toConst(), shift); <span class="tok-comment">// u must be >= ⌊√a⌋, and should be as small as possible for efficiency</span>
</span>
<span class="line" id="L1385"> <span class="tok-kw">break</span> :b m;</span>
<span class="line" id="L1386"> };</span>
<span class="line" id="L1387"> <span class="tok-kw">var</span> s = b: {</span>
<span class="line" id="L1388"> <span class="tok-kw">const</span> start = buf_index;</span>
<span class="line" id="L1389"> buf_index += u.limbs.len;</span>
<span class="line" id="L1390"> <span class="tok-kw">break</span> :b u.toConst().toMutable(limbs_buffer[start..buf_index]);</span>
<span class="line" id="L1391"> };</span>
<span class="line" id="L1392"> <span class="tok-kw">var</span> rem = b: {</span>
<span class="line" id="L1393"> <span class="tok-kw">const</span> start = buf_index;</span>
<span class="line" id="L1394"> buf_index += s.limbs.len;</span>
<span class="line" id="L1395"> <span class="tok-kw">break</span> :b Mutable.init(limbs_buffer[start..buf_index], <span class="tok-number">0</span>);</span>
<span class="line" id="L1396"> };</span>
<span class="line" id="L1397"></span>
<span class="line" id="L1398"> <span class="tok-kw">while</span> (<span class="tok-null">true</span>) {</span>
<span class="line" id="L1399"> t.divFloor(&rem, a, s.toConst(), limbs_buffer[buf_index..]);</span>
<span class="line" id="L1400"> t.add(t.toConst(), s.toConst());</span>
<span class="line" id="L1401"> u.shiftRight(t.toConst(), <span class="tok-number">1</span>);</span>
<span class="line" id="L1402"></span>
<span class="line" id="L1403"> <span class="tok-kw">if</span> (u.toConst().order(s.toConst()).compare(.gte)) {</span>
<span class="line" id="L1404"> r.copy(s.toConst());</span>
<span class="line" id="L1405"> <span class="tok-kw">return</span>;</span>
<span class="line" id="L1406"> }</span>
<span class="line" id="L1407"></span>
<span class="line" id="L1408"> <span class="tok-comment">// Avoid copying u to s by swapping u and s</span>
</span>
<span class="line" id="L1409"> <span class="tok-kw">var</span> tmp_s = s;</span>
<span class="line" id="L1410"> s = u;</span>
<span class="line" id="L1411"> u = tmp_s;</span>
<span class="line" id="L1412"> }</span>
<span class="line" id="L1413"> }</span>
<span class="line" id="L1414"></span>
<span class="line" id="L1415"> <span class="tok-comment">/// rma may not alias x or y.</span></span>
<span class="line" id="L1416"> <span class="tok-comment">/// x and y may alias each other.</span></span>
<span class="line" id="L1417"> <span class="tok-comment">/// Asserts that `rma` has enough limbs to store the result. Upper bound is given by `calcGcdNoAliasLimbLen`.</span></span>
<span class="line" id="L1418"> <span class="tok-comment">///</span></span>
<span class="line" id="L1419"> <span class="tok-comment">/// `limbs_buffer` is used for temporary storage during the operation.</span></span>
<span class="line" id="L1420"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">gcdNoAlias</span>(rma: *Mutable, x: Const, y: Const, limbs_buffer: *std.ArrayList(Limb)) !<span class="tok-type">void</span> {</span>
<span class="line" id="L1421"> assert(rma.limbs.ptr != x.limbs.ptr); <span class="tok-comment">// illegal aliasing</span>
</span>
<span class="line" id="L1422"> assert(rma.limbs.ptr != y.limbs.ptr); <span class="tok-comment">// illegal aliasing</span>
</span>
<span class="line" id="L1423"> <span class="tok-kw">return</span> gcdLehmer(rma, x, y, limbs_buffer);</span>
<span class="line" id="L1424"> }</span>
<span class="line" id="L1425"></span>
<span class="line" id="L1426"> <span class="tok-kw">fn</span> <span class="tok-fn">gcdLehmer</span>(result: *Mutable, xa: Const, ya: Const, limbs_buffer: *std.ArrayList(Limb)) !<span class="tok-type">void</span> {</span>
<span class="line" id="L1427"> <span class="tok-kw">var</span> x = <span class="tok-kw">try</span> xa.toManaged(limbs_buffer.allocator);</span>
<span class="line" id="L1428"> <span class="tok-kw">defer</span> x.deinit();</span>
<span class="line" id="L1429"> x.abs();</span>
<span class="line" id="L1430"></span>
<span class="line" id="L1431"> <span class="tok-kw">var</span> y = <span class="tok-kw">try</span> ya.toManaged(limbs_buffer.allocator);</span>
<span class="line" id="L1432"> <span class="tok-kw">defer</span> y.deinit();</span>
<span class="line" id="L1433"> y.abs();</span>
<span class="line" id="L1434"></span>
<span class="line" id="L1435"> <span class="tok-kw">if</span> (x.toConst().order(y.toConst()) == .lt) {</span>
<span class="line" id="L1436"> x.swap(&y);</span>
<span class="line" id="L1437"> }</span>
<span class="line" id="L1438"></span>
<span class="line" id="L1439"> <span class="tok-kw">var</span> t_big = <span class="tok-kw">try</span> Managed.init(limbs_buffer.allocator);</span>
<span class="line" id="L1440"> <span class="tok-kw">defer</span> t_big.deinit();</span>
<span class="line" id="L1441"></span>
<span class="line" id="L1442"> <span class="tok-kw">var</span> r = <span class="tok-kw">try</span> Managed.init(limbs_buffer.allocator);</span>
<span class="line" id="L1443"> <span class="tok-kw">defer</span> r.deinit();</span>
<span class="line" id="L1444"></span>
<span class="line" id="L1445"> <span class="tok-kw">var</span> tmp_x = <span class="tok-kw">try</span> Managed.init(limbs_buffer.allocator);</span>
<span class="line" id="L1446"> <span class="tok-kw">defer</span> tmp_x.deinit();</span>
<span class="line" id="L1447"></span>
<span class="line" id="L1448"> <span class="tok-kw">while</span> (y.len() > <span class="tok-number">1</span> <span class="tok-kw">and</span> !y.eqlZero()) {</span>
<span class="line" id="L1449"> assert(x.isPositive() <span class="tok-kw">and</span> y.isPositive());</span>
<span class="line" id="L1450"> assert(x.len() >= y.len());</span>
<span class="line" id="L1451"></span>
<span class="line" id="L1452"> <span class="tok-kw">var</span> xh: SignedDoubleLimb = x.limbs[x.len() - <span class="tok-number">1</span>];</span>
<span class="line" id="L1453"> <span class="tok-kw">var</span> yh: SignedDoubleLimb = <span class="tok-kw">if</span> (x.len() > y.len()) <span class="tok-number">0</span> <span class="tok-kw">else</span> y.limbs[x.len() - <span class="tok-number">1</span>];</span>
<span class="line" id="L1454"></span>
<span class="line" id="L1455"> <span class="tok-kw">var</span> A: SignedDoubleLimb = <span class="tok-number">1</span>;</span>
<span class="line" id="L1456"> <span class="tok-kw">var</span> B: SignedDoubleLimb = <span class="tok-number">0</span>;</span>
<span class="line" id="L1457"> <span class="tok-kw">var</span> C: SignedDoubleLimb = <span class="tok-number">0</span>;</span>
<span class="line" id="L1458"> <span class="tok-kw">var</span> D: SignedDoubleLimb = <span class="tok-number">1</span>;</span>
<span class="line" id="L1459"></span>
<span class="line" id="L1460"> <span class="tok-kw">while</span> (yh + C != <span class="tok-number">0</span> <span class="tok-kw">and</span> yh + D != <span class="tok-number">0</span>) {</span>
<span class="line" id="L1461"> <span class="tok-kw">const</span> q = <span class="tok-builtin">@divFloor</span>(xh + A, yh + C);</span>
<span class="line" id="L1462"> <span class="tok-kw">const</span> qp = <span class="tok-builtin">@divFloor</span>(xh + B, yh + D);</span>
<span class="line" id="L1463"> <span class="tok-kw">if</span> (q != qp) {</span>
<span class="line" id="L1464"> <span class="tok-kw">break</span>;</span>
<span class="line" id="L1465"> }</span>
<span class="line" id="L1466"></span>
<span class="line" id="L1467"> <span class="tok-kw">var</span> t = A - q * C;</span>
<span class="line" id="L1468"> A = C;</span>
<span class="line" id="L1469"> C = t;</span>
<span class="line" id="L1470"> t = B - q * D;</span>
<span class="line" id="L1471"> B = D;</span>
<span class="line" id="L1472"> D = t;</span>
<span class="line" id="L1473"></span>
<span class="line" id="L1474"> t = xh - q * yh;</span>
<span class="line" id="L1475"> xh = yh;</span>
<span class="line" id="L1476"> yh = t;</span>
<span class="line" id="L1477"> }</span>
<span class="line" id="L1478"></span>
<span class="line" id="L1479"> <span class="tok-kw">if</span> (B == <span class="tok-number">0</span>) {</span>
<span class="line" id="L1480"> <span class="tok-comment">// t_big = x % y, r is unused</span>
</span>
<span class="line" id="L1481"> <span class="tok-kw">try</span> r.divTrunc(&t_big, &x, &y);</span>
<span class="line" id="L1482"> assert(t_big.isPositive());</span>
<span class="line" id="L1483"></span>
<span class="line" id="L1484"> x.swap(&y);</span>
<span class="line" id="L1485"> y.swap(&t_big);</span>
<span class="line" id="L1486"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L1487"> <span class="tok-kw">var</span> storage: [<span class="tok-number">8</span>]Limb = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L1488"> <span class="tok-kw">const</span> Ap = fixedIntFromSignedDoubleLimb(A, storage[<span class="tok-number">0</span>..<span class="tok-number">2</span>]).toManaged(limbs_buffer.allocator);</span>
<span class="line" id="L1489"> <span class="tok-kw">const</span> Bp = fixedIntFromSignedDoubleLimb(B, storage[<span class="tok-number">2</span>..<span class="tok-number">4</span>]).toManaged(limbs_buffer.allocator);</span>
<span class="line" id="L1490"> <span class="tok-kw">const</span> Cp = fixedIntFromSignedDoubleLimb(C, storage[<span class="tok-number">4</span>..<span class="tok-number">6</span>]).toManaged(limbs_buffer.allocator);</span>
<span class="line" id="L1491"> <span class="tok-kw">const</span> Dp = fixedIntFromSignedDoubleLimb(D, storage[<span class="tok-number">6</span>..<span class="tok-number">8</span>]).toManaged(limbs_buffer.allocator);</span>
<span class="line" id="L1492"></span>
<span class="line" id="L1493"> <span class="tok-comment">// t_big = Ax + By</span>
</span>
<span class="line" id="L1494"> <span class="tok-kw">try</span> r.mul(&x, &Ap);</span>
<span class="line" id="L1495"> <span class="tok-kw">try</span> t_big.mul(&y, &Bp);</span>
<span class="line" id="L1496"> <span class="tok-kw">try</span> t_big.add(&r, &t_big);</span>
<span class="line" id="L1497"></span>
<span class="line" id="L1498"> <span class="tok-comment">// u = Cx + Dy, r as u</span>
</span>
<span class="line" id="L1499"> <span class="tok-kw">try</span> tmp_x.copy(x.toConst());</span>
<span class="line" id="L1500"> <span class="tok-kw">try</span> x.mul(&tmp_x, &Cp);</span>
<span class="line" id="L1501"> <span class="tok-kw">try</span> r.mul(&y, &Dp);</span>
<span class="line" id="L1502"> <span class="tok-kw">try</span> r.add(&x, &r);</span>
<span class="line" id="L1503"></span>
<span class="line" id="L1504"> x.swap(&t_big);</span>
<span class="line" id="L1505"> y.swap(&r);</span>
<span class="line" id="L1506"> }</span>
<span class="line" id="L1507"> }</span>
<span class="line" id="L1508"></span>
<span class="line" id="L1509"> <span class="tok-comment">// euclidean algorithm</span>
</span>
<span class="line" id="L1510"> assert(x.toConst().order(y.toConst()) != .lt);</span>
<span class="line" id="L1511"></span>
<span class="line" id="L1512"> <span class="tok-kw">while</span> (!y.toConst().eqlZero()) {</span>
<span class="line" id="L1513"> <span class="tok-kw">try</span> t_big.divTrunc(&r, &x, &y);</span>
<span class="line" id="L1514"> x.swap(&y);</span>
<span class="line" id="L1515"> y.swap(&r);</span>
<span class="line" id="L1516"> }</span>
<span class="line" id="L1517"></span>
<span class="line" id="L1518"> result.copy(x.toConst());</span>
<span class="line" id="L1519"> }</span>
<span class="line" id="L1520"></span>
<span class="line" id="L1521"> <span class="tok-comment">// Truncates by default.</span>
</span>
<span class="line" id="L1522"> <span class="tok-kw">fn</span> <span class="tok-fn">div</span>(q: *Mutable, r: *Mutable, x: *Mutable, y: *Mutable) <span class="tok-type">void</span> {</span>
<span class="line" id="L1523"> assert(!y.eqlZero()); <span class="tok-comment">// division by zero</span>
</span>
<span class="line" id="L1524"> assert(q != r); <span class="tok-comment">// illegal aliasing</span>
</span>
<span class="line" id="L1525"></span>
<span class="line" id="L1526"> <span class="tok-kw">const</span> q_positive = (x.positive == y.positive);</span>
<span class="line" id="L1527"> <span class="tok-kw">const</span> r_positive = x.positive;</span>
<span class="line" id="L1528"></span>
<span class="line" id="L1529"> <span class="tok-kw">if</span> (x.toConst().orderAbs(y.toConst()) == .lt) {</span>
<span class="line" id="L1530"> <span class="tok-comment">// q may alias x so handle r first.</span>
</span>
<span class="line" id="L1531"> r.copy(x.toConst());</span>
<span class="line" id="L1532"> r.positive = r_positive;</span>
<span class="line" id="L1533"></span>
<span class="line" id="L1534"> q.set(<span class="tok-number">0</span>);</span>
<span class="line" id="L1535"> <span class="tok-kw">return</span>;</span>
<span class="line" id="L1536"> }</span>
<span class="line" id="L1537"></span>
<span class="line" id="L1538"> <span class="tok-comment">// Handle trailing zero-words of divisor/dividend. These are not handled in the following</span>
</span>
<span class="line" id="L1539"> <span class="tok-comment">// algorithms.</span>
</span>
<span class="line" id="L1540"> <span class="tok-comment">// Note, there must be a non-zero limb for either.</span>
</span>
<span class="line" id="L1541"> <span class="tok-comment">// const x_trailing = std.mem.indexOfScalar(Limb, x.limbs[0..x.len], 0).?;</span>
</span>
<span class="line" id="L1542"> <span class="tok-comment">// const y_trailing = std.mem.indexOfScalar(Limb, y.limbs[0..y.len], 0).?;</span>
</span>
<span class="line" id="L1543"></span>
<span class="line" id="L1544"> <span class="tok-kw">const</span> x_trailing = <span class="tok-kw">for</span> (x.limbs[<span class="tok-number">0</span>..x.len], <span class="tok-number">0</span>..) |xi, i| {</span>
<span class="line" id="L1545"> <span class="tok-kw">if</span> (xi != <span class="tok-number">0</span>) <span class="tok-kw">break</span> i;</span>
<span class="line" id="L1546"> } <span class="tok-kw">else</span> <span class="tok-kw">unreachable</span>;</span>
<span class="line" id="L1547"></span>
<span class="line" id="L1548"> <span class="tok-kw">const</span> y_trailing = <span class="tok-kw">for</span> (y.limbs[<span class="tok-number">0</span>..y.len], <span class="tok-number">0</span>..) |yi, i| {</span>
<span class="line" id="L1549"> <span class="tok-kw">if</span> (yi != <span class="tok-number">0</span>) <span class="tok-kw">break</span> i;</span>
<span class="line" id="L1550"> } <span class="tok-kw">else</span> <span class="tok-kw">unreachable</span>;</span>
<span class="line" id="L1551"></span>
<span class="line" id="L1552"> <span class="tok-kw">const</span> xy_trailing = <span class="tok-builtin">@min</span>(x_trailing, y_trailing);</span>
<span class="line" id="L1553"></span>
<span class="line" id="L1554"> <span class="tok-kw">if</span> (y.len - xy_trailing == <span class="tok-number">1</span>) {</span>
<span class="line" id="L1555"> <span class="tok-kw">const</span> divisor = y.limbs[y.len - <span class="tok-number">1</span>];</span>
<span class="line" id="L1556"></span>
<span class="line" id="L1557"> <span class="tok-comment">// Optimization for small divisor. By using a half limb we can avoid requiring DoubleLimb</span>
</span>
<span class="line" id="L1558"> <span class="tok-comment">// divisions in the hot code path. This may often require compiler_rt software-emulation.</span>
</span>
<span class="line" id="L1559"> <span class="tok-kw">if</span> (divisor < maxInt(HalfLimb)) {</span>
<span class="line" id="L1560"> lldiv0p5(q.limbs, &r.limbs[<span class="tok-number">0</span>], x.limbs[xy_trailing..x.len], <span class="tok-builtin">@as</span>(HalfLimb, <span class="tok-builtin">@intCast</span>(divisor)));</span>
<span class="line" id="L1561"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L1562"> lldiv1(q.limbs, &r.limbs[<span class="tok-number">0</span>], x.limbs[xy_trailing..x.len], divisor);</span>
<span class="line" id="L1563"> }</span>
<span class="line" id="L1564"></span>
<span class="line" id="L1565"> q.normalize(x.len - xy_trailing);</span>
<span class="line" id="L1566"> q.positive = q_positive;</span>
<span class="line" id="L1567"></span>
<span class="line" id="L1568"> r.len = <span class="tok-number">1</span>;</span>
<span class="line" id="L1569"> r.positive = r_positive;</span>
<span class="line" id="L1570"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L1571"> <span class="tok-comment">// Shrink x, y such that the trailing zero limbs shared between are removed.</span>
</span>
<span class="line" id="L1572"> <span class="tok-kw">var</span> x0 = Mutable{</span>
<span class="line" id="L1573"> .limbs = x.limbs[xy_trailing..],</span>
<span class="line" id="L1574"> .len = x.len - xy_trailing,</span>
<span class="line" id="L1575"> .positive = <span class="tok-null">true</span>,</span>
<span class="line" id="L1576"> };</span>
<span class="line" id="L1577"></span>
<span class="line" id="L1578"> <span class="tok-kw">var</span> y0 = Mutable{</span>
<span class="line" id="L1579"> .limbs = y.limbs[xy_trailing..],</span>
<span class="line" id="L1580"> .len = y.len - xy_trailing,</span>
<span class="line" id="L1581"> .positive = <span class="tok-null">true</span>,</span>
<span class="line" id="L1582"> };</span>
<span class="line" id="L1583"></span>
<span class="line" id="L1584"> divmod(q, r, &x0, &y0);</span>
<span class="line" id="L1585"> q.positive = q_positive;</span>
<span class="line" id="L1586"></span>
<span class="line" id="L1587"> r.positive = r_positive;</span>
<span class="line" id="L1588"> }</span>
<span class="line" id="L1589"></span>
<span class="line" id="L1590"> <span class="tok-kw">if</span> (xy_trailing != <span class="tok-number">0</span> <span class="tok-kw">and</span> r.limbs[r.len - <span class="tok-number">1</span>] != <span class="tok-number">0</span>) {</span>
<span class="line" id="L1591"> <span class="tok-comment">// Manually shift here since we know its limb aligned.</span>
</span>
<span class="line" id="L1592"> mem.copyBackwards(Limb, r.limbs[xy_trailing..], r.limbs[<span class="tok-number">0</span>..r.len]);</span>
<span class="line" id="L1593"> <span class="tok-builtin">@memset</span>(r.limbs[<span class="tok-number">0</span>..xy_trailing], <span class="tok-number">0</span>);</span>
<span class="line" id="L1594"> r.len += xy_trailing;</span>
<span class="line" id="L1595"> }</span>
<span class="line" id="L1596"> }</span>
<span class="line" id="L1597"></span>
<span class="line" id="L1598"> <span class="tok-comment">/// Handbook of Applied Cryptography, 14.20</span></span>
<span class="line" id="L1599"> <span class="tok-comment">///</span></span>
<span class="line" id="L1600"> <span class="tok-comment">/// x = qy + r where 0 <= r < y</span></span>
<span class="line" id="L1601"> <span class="tok-comment">/// y is modified but returned intact.</span></span>
<span class="line" id="L1602"> <span class="tok-kw">fn</span> <span class="tok-fn">divmod</span>(</span>
<span class="line" id="L1603"> q: *Mutable,</span>
<span class="line" id="L1604"> r: *Mutable,</span>
<span class="line" id="L1605"> x: *Mutable,</span>
<span class="line" id="L1606"> y: *Mutable,</span>
<span class="line" id="L1607"> ) <span class="tok-type">void</span> {</span>
<span class="line" id="L1608"> <span class="tok-comment">// 0.</span>
</span>
<span class="line" id="L1609"> <span class="tok-comment">// Normalize so that y[t] > b/2</span>
</span>
<span class="line" id="L1610"> <span class="tok-kw">const</span> lz = <span class="tok-builtin">@clz</span>(y.limbs[y.len - <span class="tok-number">1</span>]);</span>
<span class="line" id="L1611"> <span class="tok-kw">const</span> norm_shift = <span class="tok-kw">if</span> (lz == <span class="tok-number">0</span> <span class="tok-kw">and</span> y.toConst().isOdd())</span>
<span class="line" id="L1612"> limb_bits <span class="tok-comment">// Force an extra limb so that y is even.</span>
</span>
<span class="line" id="L1613"> <span class="tok-kw">else</span></span>
<span class="line" id="L1614"> lz;</span>
<span class="line" id="L1615"></span>
<span class="line" id="L1616"> x.shiftLeft(x.toConst(), norm_shift);</span>
<span class="line" id="L1617"> y.shiftLeft(y.toConst(), norm_shift);</span>
<span class="line" id="L1618"></span>
<span class="line" id="L1619"> <span class="tok-kw">const</span> n = x.len - <span class="tok-number">1</span>;</span>
<span class="line" id="L1620"> <span class="tok-kw">const</span> t = y.len - <span class="tok-number">1</span>;</span>
<span class="line" id="L1621"> <span class="tok-kw">const</span> shift = n - t;</span>
<span class="line" id="L1622"></span>
<span class="line" id="L1623"> <span class="tok-comment">// 1.</span>
</span>
<span class="line" id="L1624"> <span class="tok-comment">// for 0 <= j <= n - t, set q[j] to 0</span>
</span>
<span class="line" id="L1625"> q.len = shift + <span class="tok-number">1</span>;</span>
<span class="line" id="L1626"> q.positive = <span class="tok-null">true</span>;</span>
<span class="line" id="L1627"> <span class="tok-builtin">@memset</span>(q.limbs[<span class="tok-number">0</span>..q.len], <span class="tok-number">0</span>);</span>
<span class="line" id="L1628"></span>
<span class="line" id="L1629"> <span class="tok-comment">// 2.</span>
</span>
<span class="line" id="L1630"> <span class="tok-comment">// while x >= y * b^(n - t):</span>
</span>
<span class="line" id="L1631"> <span class="tok-comment">// x -= y * b^(n - t)</span>
</span>
<span class="line" id="L1632"> <span class="tok-comment">// q[n - t] += 1</span>
</span>
<span class="line" id="L1633"> <span class="tok-comment">// Note, this algorithm is performed only once if y[t] > base/2 and y is even, which we</span>
</span>
<span class="line" id="L1634"> <span class="tok-comment">// enforced in step 0. This means we can replace the while with an if.</span>
</span>
<span class="line" id="L1635"> <span class="tok-comment">// Note, multiplication by b^(n - t) comes down to shifting to the right by n - t limbs.</span>
</span>
<span class="line" id="L1636"> <span class="tok-comment">// We can also replace x >= y * b^(n - t) by x/b^(n - t) >= y, and use shifts for that.</span>
</span>
<span class="line" id="L1637"> {</span>
<span class="line" id="L1638"> <span class="tok-comment">// x >= y * b^(n - t) can be replaced by x/b^(n - t) >= y.</span>
</span>
<span class="line" id="L1639"></span>
<span class="line" id="L1640"> <span class="tok-comment">// 'divide' x by b^(n - t)</span>
</span>
<span class="line" id="L1641"> <span class="tok-kw">var</span> tmp = Mutable{</span>
<span class="line" id="L1642"> .limbs = x.limbs[shift..],</span>
<span class="line" id="L1643"> .len = x.len - shift,</span>
<span class="line" id="L1644"> .positive = <span class="tok-null">true</span>,</span>
<span class="line" id="L1645"> };</span>
<span class="line" id="L1646"></span>
<span class="line" id="L1647"> <span class="tok-kw">if</span> (tmp.toConst().order(y.toConst()) != .lt) {</span>
<span class="line" id="L1648"> <span class="tok-comment">// Perform x -= y * b^(n - t)</span>
</span>
<span class="line" id="L1649"> <span class="tok-comment">// Note, we can subtract y from x[n - t..] and get the result without shifting.</span>
</span>
<span class="line" id="L1650"> <span class="tok-comment">// We can also re-use tmp which already contains the relevant part of x. Note that</span>
</span>
<span class="line" id="L1651"> <span class="tok-comment">// this also edits x.</span>
</span>
<span class="line" id="L1652"> <span class="tok-comment">// Due to the check above, this cannot underflow.</span>
</span>
<span class="line" id="L1653"> tmp.sub(tmp.toConst(), y.toConst());</span>
<span class="line" id="L1654"></span>
<span class="line" id="L1655"> <span class="tok-comment">// tmp.sub normalized tmp, but we need to normalize x now.</span>
</span>
<span class="line" id="L1656"> x.limbs.len = tmp.limbs.len + shift;</span>
<span class="line" id="L1657"></span>
<span class="line" id="L1658"> q.limbs[shift] += <span class="tok-number">1</span>;</span>
<span class="line" id="L1659"> }</span>
<span class="line" id="L1660"> }</span>
<span class="line" id="L1661"></span>
<span class="line" id="L1662"> <span class="tok-comment">// 3.</span>
</span>
<span class="line" id="L1663"> <span class="tok-comment">// for i from n down to t + 1, do</span>
</span>
<span class="line" id="L1664"> <span class="tok-kw">var</span> i = n;</span>
<span class="line" id="L1665"> <span class="tok-kw">while</span> (i >= t + <span class="tok-number">1</span>) : (i -= <span class="tok-number">1</span>) {</span>
<span class="line" id="L1666"> <span class="tok-kw">const</span> k = i - t - <span class="tok-number">1</span>;</span>
<span class="line" id="L1667"> <span class="tok-comment">// 3.1.</span>
</span>
<span class="line" id="L1668"> <span class="tok-comment">// if x_i == y_t:</span>
</span>
<span class="line" id="L1669"> <span class="tok-comment">// q[i - t - 1] = b - 1</span>
</span>
<span class="line" id="L1670"> <span class="tok-comment">// else:</span>
</span>
<span class="line" id="L1671"> <span class="tok-comment">// q[i - t - 1] = (x[i] * b + x[i - 1]) / y[t]</span>
</span>
<span class="line" id="L1672"> <span class="tok-kw">if</span> (x.limbs[i] == y.limbs[t]) {</span>
<span class="line" id="L1673"> q.limbs[k] = maxInt(Limb);</span>
<span class="line" id="L1674"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L1675"> <span class="tok-kw">const</span> q0 = (<span class="tok-builtin">@as</span>(DoubleLimb, x.limbs[i]) << limb_bits) | <span class="tok-builtin">@as</span>(DoubleLimb, x.limbs[i - <span class="tok-number">1</span>]);</span>
<span class="line" id="L1676"> <span class="tok-kw">const</span> n0 = <span class="tok-builtin">@as</span>(DoubleLimb, y.limbs[t]);</span>
<span class="line" id="L1677"> q.limbs[k] = <span class="tok-builtin">@as</span>(Limb, <span class="tok-builtin">@intCast</span>(q0 / n0));</span>
<span class="line" id="L1678"> }</span>
<span class="line" id="L1679"></span>
<span class="line" id="L1680"> <span class="tok-comment">// 3.2</span>
</span>
<span class="line" id="L1681"> <span class="tok-comment">// while q[i - t - 1] * (y[t] * b + y[t - 1] > x[i] * b * b + x[i - 1] + x[i - 2]:</span>
</span>
<span class="line" id="L1682"> <span class="tok-comment">// q[i - t - 1] -= 1</span>
</span>
<span class="line" id="L1683"> <span class="tok-comment">// Note, if y[t] > b / 2 this part is repeated no more than twice.</span>
</span>
<span class="line" id="L1684"></span>
<span class="line" id="L1685"> <span class="tok-comment">// Extract from y.</span>
</span>
<span class="line" id="L1686"> <span class="tok-kw">const</span> y0 = <span class="tok-kw">if</span> (t > <span class="tok-number">0</span>) y.limbs[t - <span class="tok-number">1</span>] <span class="tok-kw">else</span> <span class="tok-number">0</span>;</span>
<span class="line" id="L1687"> <span class="tok-kw">const</span> y1 = y.limbs[t];</span>
<span class="line" id="L1688"></span>
<span class="line" id="L1689"> <span class="tok-comment">// Extract from x.</span>
</span>
<span class="line" id="L1690"> <span class="tok-comment">// Note, big endian.</span>
</span>
<span class="line" id="L1691"> <span class="tok-kw">const</span> tmp0 = [_]Limb{</span>
<span class="line" id="L1692"> x.limbs[i],</span>
<span class="line" id="L1693"> <span class="tok-kw">if</span> (i >= <span class="tok-number">1</span>) x.limbs[i - <span class="tok-number">1</span>] <span class="tok-kw">else</span> <span class="tok-number">0</span>,</span>
<span class="line" id="L1694"> <span class="tok-kw">if</span> (i >= <span class="tok-number">2</span>) x.limbs[i - <span class="tok-number">2</span>] <span class="tok-kw">else</span> <span class="tok-number">0</span>,</span>
<span class="line" id="L1695"> };</span>
<span class="line" id="L1696"></span>
<span class="line" id="L1697"> <span class="tok-kw">while</span> (<span class="tok-null">true</span>) {</span>
<span class="line" id="L1698"> <span class="tok-comment">// Ad-hoc 2x1 multiplication with q[i - t - 1].</span>
</span>
<span class="line" id="L1699"> <span class="tok-comment">// Note, big endian.</span>
</span>
<span class="line" id="L1700"> <span class="tok-kw">var</span> tmp1 = [_]Limb{ <span class="tok-number">0</span>, <span class="tok-null">undefined</span>, <span class="tok-null">undefined</span> };</span>
<span class="line" id="L1701"> tmp1[<span class="tok-number">2</span>] = addMulLimbWithCarry(<span class="tok-number">0</span>, y0, q.limbs[k], &tmp1[<span class="tok-number">0</span>]);</span>
<span class="line" id="L1702"> tmp1[<span class="tok-number">1</span>] = addMulLimbWithCarry(<span class="tok-number">0</span>, y1, q.limbs[k], &tmp1[<span class="tok-number">0</span>]);</span>
<span class="line" id="L1703"></span>
<span class="line" id="L1704"> <span class="tok-comment">// Big-endian compare</span>
</span>
<span class="line" id="L1705"> <span class="tok-kw">if</span> (mem.order(Limb, &tmp1, &tmp0) != .gt)</span>
<span class="line" id="L1706"> <span class="tok-kw">break</span>;</span>
<span class="line" id="L1707"></span>
<span class="line" id="L1708"> q.limbs[k] -= <span class="tok-number">1</span>;</span>
<span class="line" id="L1709"> }</span>
<span class="line" id="L1710"></span>
<span class="line" id="L1711"> <span class="tok-comment">// 3.3.</span>
</span>
<span class="line" id="L1712"> <span class="tok-comment">// x -= q[i - t - 1] * y * b^(i - t - 1)</span>
</span>
<span class="line" id="L1713"> <span class="tok-comment">// Note, we multiply by a single limb here.</span>
</span>
<span class="line" id="L1714"> <span class="tok-comment">// The shift doesn't need to be performed if we add the result of the first multiplication</span>
</span>
<span class="line" id="L1715"> <span class="tok-comment">// to x[i - t - 1].</span>
</span>
<span class="line" id="L1716"> <span class="tok-kw">const</span> underflow = llmulLimb(.sub, x.limbs[k..x.len], y.limbs[<span class="tok-number">0</span>..y.len], q.limbs[k]);</span>
<span class="line" id="L1717"></span>
<span class="line" id="L1718"> <span class="tok-comment">// 3.4.</span>
</span>
<span class="line" id="L1719"> <span class="tok-comment">// if x < 0:</span>
</span>
<span class="line" id="L1720"> <span class="tok-comment">// x += y * b^(i - t - 1)</span>
</span>
<span class="line" id="L1721"> <span class="tok-comment">// q[i - t - 1] -= 1</span>
</span>
<span class="line" id="L1722"> <span class="tok-comment">// Note, we check for x < 0 using the underflow flag from the previous operation.</span>
</span>
<span class="line" id="L1723"> <span class="tok-kw">if</span> (underflow) {</span>
<span class="line" id="L1724"> <span class="tok-comment">// While we didn't properly set the signedness of x, this operation should 'flow' it back to positive.</span>
</span>
<span class="line" id="L1725"> llaccum(.add, x.limbs[k..x.len], y.limbs[<span class="tok-number">0</span>..y.len]);</span>
<span class="line" id="L1726"> q.limbs[k] -= <span class="tok-number">1</span>;</span>
<span class="line" id="L1727"> }</span>
<span class="line" id="L1728"> }</span>
<span class="line" id="L1729"></span>
<span class="line" id="L1730"> x.normalize(x.len);</span>
<span class="line" id="L1731"> q.normalize(q.len);</span>
<span class="line" id="L1732"></span>
<span class="line" id="L1733"> <span class="tok-comment">// De-normalize r and y.</span>
</span>
<span class="line" id="L1734"> r.shiftRight(x.toConst(), norm_shift);</span>
<span class="line" id="L1735"> y.shiftRight(y.toConst(), norm_shift);</span>
<span class="line" id="L1736"> }</span>
<span class="line" id="L1737"></span>
<span class="line" id="L1738"> <span class="tok-comment">/// If a is positive, this passes through to truncate.</span></span>
<span class="line" id="L1739"> <span class="tok-comment">/// If a is negative, then r is set to positive with the bit pattern ~(a - 1).</span></span>
<span class="line" id="L1740"> <span class="tok-comment">/// r may alias a.</span></span>
<span class="line" id="L1741"> <span class="tok-comment">///</span></span>
<span class="line" id="L1742"> <span class="tok-comment">/// Asserts `r` has enough storage to store the result.</span></span>
<span class="line" id="L1743"> <span class="tok-comment">/// The upper bound is `calcTwosCompLimbCount(a.len)`.</span></span>
<span class="line" id="L1744"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">convertToTwosComplement</span>(r: *Mutable, a: Const, signedness: Signedness, bit_count: <span class="tok-type">usize</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L1745"> <span class="tok-kw">if</span> (a.positive) {</span>
<span class="line" id="L1746"> r.truncate(a, signedness, bit_count);</span>
<span class="line" id="L1747"> <span class="tok-kw">return</span>;</span>
<span class="line" id="L1748"> }</span>
<span class="line" id="L1749"></span>
<span class="line" id="L1750"> <span class="tok-kw">const</span> req_limbs = calcTwosCompLimbCount(bit_count);</span>
<span class="line" id="L1751"> <span class="tok-kw">if</span> (req_limbs == <span class="tok-number">0</span> <span class="tok-kw">or</span> a.eqlZero()) {</span>
<span class="line" id="L1752"> r.set(<span class="tok-number">0</span>);</span>
<span class="line" id="L1753"> <span class="tok-kw">return</span>;</span>
<span class="line" id="L1754"> }</span>
<span class="line" id="L1755"></span>
<span class="line" id="L1756"> <span class="tok-kw">const</span> bit = <span class="tok-builtin">@as</span>(Log2Limb, <span class="tok-builtin">@truncate</span>(bit_count - <span class="tok-number">1</span>));</span>
<span class="line" id="L1757"> <span class="tok-kw">const</span> signmask = <span class="tok-builtin">@as</span>(Limb, <span class="tok-number">1</span>) << bit;</span>
<span class="line" id="L1758"> <span class="tok-kw">const</span> mask = (signmask << <span class="tok-number">1</span>) -% <span class="tok-number">1</span>;</span>
<span class="line" id="L1759"></span>
<span class="line" id="L1760"> r.addScalar(a.abs(), -<span class="tok-number">1</span>);</span>
<span class="line" id="L1761"> <span class="tok-kw">if</span> (req_limbs > r.len) {</span>
<span class="line" id="L1762"> <span class="tok-builtin">@memset</span>(r.limbs[r.len..req_limbs], <span class="tok-number">0</span>);</span>
<span class="line" id="L1763"> }</span>
<span class="line" id="L1764"></span>
<span class="line" id="L1765"> assert(r.limbs.len >= req_limbs);</span>
<span class="line" id="L1766"> r.len = req_limbs;</span>
<span class="line" id="L1767"></span>
<span class="line" id="L1768"> llnot(r.limbs[<span class="tok-number">0</span>..r.len]);</span>
<span class="line" id="L1769"> r.limbs[r.len - <span class="tok-number">1</span>] &= mask;</span>
<span class="line" id="L1770"> r.normalize(r.len);</span>
<span class="line" id="L1771"> }</span>
<span class="line" id="L1772"></span>
<span class="line" id="L1773"> <span class="tok-comment">/// Truncate an integer to a number of bits, following 2s-complement semantics.</span></span>
<span class="line" id="L1774"> <span class="tok-comment">/// r may alias a.</span></span>
<span class="line" id="L1775"> <span class="tok-comment">///</span></span>
<span class="line" id="L1776"> <span class="tok-comment">/// Asserts `r` has enough storage to store the result.</span></span>
<span class="line" id="L1777"> <span class="tok-comment">/// The upper bound is `calcTwosCompLimbCount(a.len)`.</span></span>
<span class="line" id="L1778"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">truncate</span>(r: *Mutable, a: Const, signedness: Signedness, bit_count: <span class="tok-type">usize</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L1779"> <span class="tok-kw">const</span> req_limbs = calcTwosCompLimbCount(bit_count);</span>
<span class="line" id="L1780"></span>
<span class="line" id="L1781"> <span class="tok-comment">// Handle 0-bit integers.</span>
</span>
<span class="line" id="L1782"> <span class="tok-kw">if</span> (req_limbs == <span class="tok-number">0</span> <span class="tok-kw">or</span> a.eqlZero()) {</span>
<span class="line" id="L1783"> r.set(<span class="tok-number">0</span>);</span>
<span class="line" id="L1784"> <span class="tok-kw">return</span>;</span>
<span class="line" id="L1785"> }</span>
<span class="line" id="L1786"></span>
<span class="line" id="L1787"> <span class="tok-kw">const</span> bit = <span class="tok-builtin">@as</span>(Log2Limb, <span class="tok-builtin">@truncate</span>(bit_count - <span class="tok-number">1</span>));</span>
<span class="line" id="L1788"> <span class="tok-kw">const</span> signmask = <span class="tok-builtin">@as</span>(Limb, <span class="tok-number">1</span>) << bit; <span class="tok-comment">// 0b0..010...0 where 1 is the sign bit.</span>
</span>
<span class="line" id="L1789"> <span class="tok-kw">const</span> mask = (signmask << <span class="tok-number">1</span>) -% <span class="tok-number">1</span>; <span class="tok-comment">// 0b0..01..1 where the leftmost 1 is the sign bit.</span>
</span>
<span class="line" id="L1790"></span>
<span class="line" id="L1791"> <span class="tok-kw">if</span> (!a.positive) {</span>
<span class="line" id="L1792"> <span class="tok-comment">// Convert the integer from sign-magnitude into twos-complement.</span>
</span>
<span class="line" id="L1793"> <span class="tok-comment">// -x = ~(x - 1)</span>
</span>
<span class="line" id="L1794"> <span class="tok-comment">// Note, we simply take req_limbs * @bitSizeOf(Limb) as the</span>
</span>
<span class="line" id="L1795"> <span class="tok-comment">// target bit count.</span>
</span>
<span class="line" id="L1796"></span>
<span class="line" id="L1797"> r.addScalar(a.abs(), -<span class="tok-number">1</span>);</span>
<span class="line" id="L1798"></span>
<span class="line" id="L1799"> <span class="tok-comment">// Zero-extend the result</span>
</span>
<span class="line" id="L1800"> <span class="tok-kw">if</span> (req_limbs > r.len) {</span>
<span class="line" id="L1801"> <span class="tok-builtin">@memset</span>(r.limbs[r.len..req_limbs], <span class="tok-number">0</span>);</span>
<span class="line" id="L1802"> }</span>
<span class="line" id="L1803"></span>
<span class="line" id="L1804"> <span class="tok-comment">// Truncate to required number of limbs.</span>
</span>
<span class="line" id="L1805"> assert(r.limbs.len >= req_limbs);</span>
<span class="line" id="L1806"> r.len = req_limbs;</span>
<span class="line" id="L1807"></span>
<span class="line" id="L1808"> <span class="tok-comment">// Without truncating, we can already peek at the sign bit of the result here.</span>
</span>
<span class="line" id="L1809"> <span class="tok-comment">// Note that it will be 0 if the result is negative, as we did not apply the flip here.</span>
</span>
<span class="line" id="L1810"> <span class="tok-comment">// If the result is negative, we have</span>
</span>
<span class="line" id="L1811"> <span class="tok-comment">// -(-x & mask)</span>
</span>
<span class="line" id="L1812"> <span class="tok-comment">// = ~(~(x - 1) & mask) + 1</span>
</span>
<span class="line" id="L1813"> <span class="tok-comment">// = ~(~((x - 1) | ~mask)) + 1</span>
</span>
<span class="line" id="L1814"> <span class="tok-comment">// = ((x - 1) | ~mask)) + 1</span>
</span>
<span class="line" id="L1815"> <span class="tok-comment">// Note, this is only valid for the target bits and not the upper bits</span>
</span>
<span class="line" id="L1816"> <span class="tok-comment">// of the most significant limb. Those still need to be cleared.</span>
</span>
<span class="line" id="L1817"> <span class="tok-comment">// Also note that `mask` is zero for all other bits, reducing to the identity.</span>
</span>
<span class="line" id="L1818"> <span class="tok-comment">// This means that we still need to use & mask to clear off the upper bits.</span>
</span>
<span class="line" id="L1819"></span>
<span class="line" id="L1820"> <span class="tok-kw">if</span> (signedness == .signed <span class="tok-kw">and</span> r.limbs[r.len - <span class="tok-number">1</span>] & signmask == <span class="tok-number">0</span>) {</span>
<span class="line" id="L1821"> <span class="tok-comment">// Re-add the one and negate to get the result.</span>
</span>
<span class="line" id="L1822"> r.limbs[r.len - <span class="tok-number">1</span>] &= mask;</span>
<span class="line" id="L1823"> <span class="tok-comment">// Note, addition cannot require extra limbs here as we did a subtraction before.</span>
</span>
<span class="line" id="L1824"> r.addScalar(r.toConst(), <span class="tok-number">1</span>);</span>
<span class="line" id="L1825"> r.normalize(r.len);</span>
<span class="line" id="L1826"> r.positive = <span class="tok-null">false</span>;</span>
<span class="line" id="L1827"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L1828"> llnot(r.limbs[<span class="tok-number">0</span>..r.len]);</span>
<span class="line" id="L1829"> r.limbs[r.len - <span class="tok-number">1</span>] &= mask;</span>
<span class="line" id="L1830"> r.normalize(r.len);</span>
<span class="line" id="L1831"> }</span>
<span class="line" id="L1832"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L1833"> <span class="tok-kw">if</span> (a.limbs.len < req_limbs) {</span>
<span class="line" id="L1834"> <span class="tok-comment">// Integer fits within target bits, no wrapping required.</span>
</span>
<span class="line" id="L1835"> r.copy(a);</span>
<span class="line" id="L1836"> <span class="tok-kw">return</span>;</span>
<span class="line" id="L1837"> }</span>
<span class="line" id="L1838"></span>
<span class="line" id="L1839"> r.copy(.{</span>
<span class="line" id="L1840"> .positive = a.positive,</span>
<span class="line" id="L1841"> .limbs = a.limbs[<span class="tok-number">0</span>..req_limbs],</span>
<span class="line" id="L1842"> });</span>
<span class="line" id="L1843"> r.limbs[r.len - <span class="tok-number">1</span>] &= mask;</span>
<span class="line" id="L1844"> r.normalize(r.len);</span>
<span class="line" id="L1845"></span>
<span class="line" id="L1846"> <span class="tok-kw">if</span> (signedness == .signed <span class="tok-kw">and</span> r.limbs[r.len - <span class="tok-number">1</span>] & signmask != <span class="tok-number">0</span>) {</span>
<span class="line" id="L1847"> <span class="tok-comment">// Convert 2s-complement back to sign-magnitude.</span>
</span>
<span class="line" id="L1848"> <span class="tok-comment">// Sign-extend the upper bits so that they are inverted correctly.</span>
</span>
<span class="line" id="L1849"> r.limbs[r.len - <span class="tok-number">1</span>] |= ~mask;</span>
<span class="line" id="L1850"> llnot(r.limbs[<span class="tok-number">0</span>..r.len]);</span>
<span class="line" id="L1851"></span>
<span class="line" id="L1852"> <span class="tok-comment">// Note, can only overflow if r holds 0xFFF...F which can only happen if</span>
</span>
<span class="line" id="L1853"> <span class="tok-comment">// a holds 0.</span>
</span>
<span class="line" id="L1854"> r.addScalar(r.toConst(), <span class="tok-number">1</span>);</span>
<span class="line" id="L1855"></span>
<span class="line" id="L1856"> r.positive = <span class="tok-null">false</span>;</span>
<span class="line" id="L1857"> }</span>
<span class="line" id="L1858"> }</span>
<span class="line" id="L1859"> }</span>
<span class="line" id="L1860"></span>
<span class="line" id="L1861"> <span class="tok-comment">/// Saturate an integer to a number of bits, following 2s-complement semantics.</span></span>
<span class="line" id="L1862"> <span class="tok-comment">/// r may alias a.</span></span>
<span class="line" id="L1863"> <span class="tok-comment">///</span></span>
<span class="line" id="L1864"> <span class="tok-comment">/// Asserts `r` has enough storage to store the result.</span></span>
<span class="line" id="L1865"> <span class="tok-comment">/// The upper bound is `calcTwosCompLimbCount(a.len)`.</span></span>
<span class="line" id="L1866"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">saturate</span>(r: *Mutable, a: Const, signedness: Signedness, bit_count: <span class="tok-type">usize</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L1867"> <span class="tok-kw">if</span> (!a.fitsInTwosComp(signedness, bit_count)) {</span>
<span class="line" id="L1868"> r.setTwosCompIntLimit(<span class="tok-kw">if</span> (r.positive) .max <span class="tok-kw">else</span> .min, signedness, bit_count);</span>
<span class="line" id="L1869"> }</span>
<span class="line" id="L1870"> }</span>
<span class="line" id="L1871"></span>
<span class="line" id="L1872"> <span class="tok-comment">/// Read the value of `x` from `buffer`</span></span>
<span class="line" id="L1873"> <span class="tok-comment">/// Asserts that `buffer` is large enough to contain a value of bit-size `bit_count`.</span></span>
<span class="line" id="L1874"> <span class="tok-comment">///</span></span>
<span class="line" id="L1875"> <span class="tok-comment">/// The contents of `buffer` are interpreted as if they were the contents of</span></span>
<span class="line" id="L1876"> <span class="tok-comment">/// @ptrCast(*[buffer.len]const u8, &x). Byte ordering is determined by `endian`</span></span>
<span class="line" id="L1877"> <span class="tok-comment">/// and any required padding bits are expected on the MSB end.</span></span>
<span class="line" id="L1878"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">readTwosComplement</span>(</span>
<span class="line" id="L1879"> x: *Mutable,</span>
<span class="line" id="L1880"> buffer: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L1881"> bit_count: <span class="tok-type">usize</span>,</span>
<span class="line" id="L1882"> endian: Endian,</span>
<span class="line" id="L1883"> signedness: Signedness,</span>
<span class="line" id="L1884"> ) <span class="tok-type">void</span> {</span>
<span class="line" id="L1885"> <span class="tok-kw">return</span> readPackedTwosComplement(x, buffer, <span class="tok-number">0</span>, bit_count, endian, signedness);</span>
<span class="line" id="L1886"> }</span>
<span class="line" id="L1887"></span>
<span class="line" id="L1888"> <span class="tok-comment">/// Read the value of `x` from a packed memory `buffer`.</span></span>
<span class="line" id="L1889"> <span class="tok-comment">/// Asserts that `buffer` is large enough to contain a value of bit-size `bit_count`</span></span>
<span class="line" id="L1890"> <span class="tok-comment">/// at offset `bit_offset`.</span></span>
<span class="line" id="L1891"> <span class="tok-comment">///</span></span>
<span class="line" id="L1892"> <span class="tok-comment">/// This is equivalent to loading the value of an integer with `bit_count` bits as</span></span>
<span class="line" id="L1893"> <span class="tok-comment">/// if it were a field in packed memory at the provided bit offset.</span></span>
<span class="line" id="L1894"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">readPackedTwosComplement</span>(</span>
<span class="line" id="L1895"> x: *Mutable,</span>
<span class="line" id="L1896"> buffer: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L1897"> bit_offset: <span class="tok-type">usize</span>,</span>
<span class="line" id="L1898"> bit_count: <span class="tok-type">usize</span>,</span>
<span class="line" id="L1899"> endian: Endian,</span>
<span class="line" id="L1900"> signedness: Signedness,</span>
<span class="line" id="L1901"> ) <span class="tok-type">void</span> {</span>
<span class="line" id="L1902"> <span class="tok-kw">if</span> (bit_count == <span class="tok-number">0</span>) {</span>
<span class="line" id="L1903"> x.limbs[<span class="tok-number">0</span>] = <span class="tok-number">0</span>;</span>
<span class="line" id="L1904"> x.len = <span class="tok-number">1</span>;</span>
<span class="line" id="L1905"> x.positive = <span class="tok-null">true</span>;</span>
<span class="line" id="L1906"> <span class="tok-kw">return</span>;</span>
<span class="line" id="L1907"> }</span>
<span class="line" id="L1908"></span>
<span class="line" id="L1909"> <span class="tok-comment">// Check whether the input is negative</span>
</span>
<span class="line" id="L1910"> <span class="tok-kw">var</span> positive = <span class="tok-null">true</span>;</span>
<span class="line" id="L1911"> <span class="tok-kw">if</span> (signedness == .signed) {</span>
<span class="line" id="L1912"> <span class="tok-kw">const</span> total_bits = bit_offset + bit_count;</span>
<span class="line" id="L1913"> <span class="tok-kw">var</span> last_byte = <span class="tok-kw">switch</span> (endian) {</span>
<span class="line" id="L1914"> .Little => ((total_bits + <span class="tok-number">7</span>) / <span class="tok-number">8</span>) - <span class="tok-number">1</span>,</span>
<span class="line" id="L1915"> .Big => buffer.len - ((total_bits + <span class="tok-number">7</span>) / <span class="tok-number">8</span>),</span>
<span class="line" id="L1916"> };</span>
<span class="line" id="L1917"></span>
<span class="line" id="L1918"> <span class="tok-kw">const</span> sign_bit = <span class="tok-builtin">@as</span>(<span class="tok-type">u8</span>, <span class="tok-number">1</span>) << <span class="tok-builtin">@as</span>(<span class="tok-type">u3</span>, <span class="tok-builtin">@intCast</span>((total_bits - <span class="tok-number">1</span>) % <span class="tok-number">8</span>));</span>
<span class="line" id="L1919"> positive = ((buffer[last_byte] & sign_bit) == <span class="tok-number">0</span>);</span>
<span class="line" id="L1920"> }</span>
<span class="line" id="L1921"></span>
<span class="line" id="L1922"> <span class="tok-comment">// Copy all complete limbs</span>
</span>
<span class="line" id="L1923"> <span class="tok-kw">var</span> carry: <span class="tok-type">u1</span> = <span class="tok-number">1</span>;</span>
<span class="line" id="L1924"> <span class="tok-kw">var</span> limb_index: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L1925"> <span class="tok-kw">var</span> bit_index: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L1926"> <span class="tok-kw">while</span> (limb_index < bit_count / <span class="tok-builtin">@bitSizeOf</span>(Limb)) : (limb_index += <span class="tok-number">1</span>) {</span>
<span class="line" id="L1927"> <span class="tok-comment">// Read one Limb of bits</span>
</span>
<span class="line" id="L1928"> <span class="tok-kw">var</span> limb = mem.readPackedInt(Limb, buffer, bit_index + bit_offset, endian);</span>
<span class="line" id="L1929"> bit_index += <span class="tok-builtin">@bitSizeOf</span>(Limb);</span>
<span class="line" id="L1930"></span>
<span class="line" id="L1931"> <span class="tok-comment">// 2's complement (bitwise not, then add carry bit)</span>
</span>
<span class="line" id="L1932"> <span class="tok-kw">if</span> (!positive) {</span>
<span class="line" id="L1933"> <span class="tok-kw">const</span> ov = <span class="tok-builtin">@addWithOverflow</span>(~limb, carry);</span>
<span class="line" id="L1934"> limb = ov[<span class="tok-number">0</span>];</span>
<span class="line" id="L1935"> carry = ov[<span class="tok-number">1</span>];</span>
<span class="line" id="L1936"> }</span>
<span class="line" id="L1937"> x.limbs[limb_index] = limb;</span>
<span class="line" id="L1938"> }</span>
<span class="line" id="L1939"></span>
<span class="line" id="L1940"> <span class="tok-comment">// Copy the remaining bits</span>
</span>
<span class="line" id="L1941"> <span class="tok-kw">if</span> (bit_count != bit_index) {</span>
<span class="line" id="L1942"> <span class="tok-comment">// Read all remaining bits</span>
</span>
<span class="line" id="L1943"> <span class="tok-kw">var</span> limb = <span class="tok-kw">switch</span> (signedness) {</span>
<span class="line" id="L1944"> .unsigned => mem.readVarPackedInt(Limb, buffer, bit_index + bit_offset, bit_count - bit_index, endian, .unsigned),</span>
<span class="line" id="L1945"> .signed => b: {</span>
<span class="line" id="L1946"> <span class="tok-kw">const</span> SLimb = std.meta.Int(.signed, <span class="tok-builtin">@bitSizeOf</span>(Limb));</span>
<span class="line" id="L1947"> <span class="tok-kw">const</span> limb = mem.readVarPackedInt(SLimb, buffer, bit_index + bit_offset, bit_count - bit_index, endian, .signed);</span>
<span class="line" id="L1948"> <span class="tok-kw">break</span> :b <span class="tok-builtin">@as</span>(Limb, <span class="tok-builtin">@bitCast</span>(limb));</span>
<span class="line" id="L1949"> },</span>
<span class="line" id="L1950"> };</span>
<span class="line" id="L1951"></span>
<span class="line" id="L1952"> <span class="tok-comment">// 2's complement (bitwise not, then add carry bit)</span>
</span>
<span class="line" id="L1953"> <span class="tok-kw">if</span> (!positive) {</span>
<span class="line" id="L1954"> <span class="tok-kw">const</span> ov = <span class="tok-builtin">@addWithOverflow</span>(~limb, carry);</span>
<span class="line" id="L1955"> assert(ov[<span class="tok-number">1</span>] == <span class="tok-number">0</span>);</span>
<span class="line" id="L1956"> limb = ov[<span class="tok-number">0</span>];</span>
<span class="line" id="L1957"> }</span>
<span class="line" id="L1958"> x.limbs[limb_index] = limb;</span>
<span class="line" id="L1959"></span>
<span class="line" id="L1960"> limb_index += <span class="tok-number">1</span>;</span>
<span class="line" id="L1961"> }</span>
<span class="line" id="L1962"></span>
<span class="line" id="L1963"> x.positive = positive;</span>
<span class="line" id="L1964"> x.len = limb_index;</span>
<span class="line" id="L1965"> x.normalize(x.len);</span>
<span class="line" id="L1966"> }</span>
<span class="line" id="L1967"></span>
<span class="line" id="L1968"> <span class="tok-comment">/// Normalize a possible sequence of leading zeros.</span></span>
<span class="line" id="L1969"> <span class="tok-comment">///</span></span>
<span class="line" id="L1970"> <span class="tok-comment">/// [1, 2, 3, 4, 0] -> [1, 2, 3, 4]</span></span>
<span class="line" id="L1971"> <span class="tok-comment">/// [1, 2, 0, 0, 0] -> [1, 2]</span></span>
<span class="line" id="L1972"> <span class="tok-comment">/// [0, 0, 0, 0, 0] -> [0]</span></span>
<span class="line" id="L1973"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">normalize</span>(r: *Mutable, length: <span class="tok-type">usize</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L1974"> r.len = llnormalize(r.limbs[<span class="tok-number">0</span>..length]);</span>
<span class="line" id="L1975"> }</span>
<span class="line" id="L1976">};</span>
<span class="line" id="L1977"></span>
<span class="line" id="L1978"><span class="tok-comment">/// A arbitrary-precision big integer, with a fixed set of immutable limbs.</span></span>
<span class="line" id="L1979"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> Const = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L1980"> <span class="tok-comment">/// Raw digits. These are:</span></span>
<span class="line" id="L1981"> <span class="tok-comment">///</span></span>
<span class="line" id="L1982"> <span class="tok-comment">/// * Little-endian ordered</span></span>
<span class="line" id="L1983"> <span class="tok-comment">/// * limbs.len >= 1</span></span>
<span class="line" id="L1984"> <span class="tok-comment">/// * Zero is represented as limbs.len == 1 with limbs[0] == 0.</span></span>
<span class="line" id="L1985"> <span class="tok-comment">///</span></span>
<span class="line" id="L1986"> <span class="tok-comment">/// Accessing limbs directly should be avoided.</span></span>
<span class="line" id="L1987"> limbs: []<span class="tok-kw">const</span> Limb,</span>
<span class="line" id="L1988"> positive: <span class="tok-type">bool</span>,</span>
<span class="line" id="L1989"></span>
<span class="line" id="L1990"> <span class="tok-comment">/// The result is an independent resource which is managed by the caller.</span></span>
<span class="line" id="L1991"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">toManaged</span>(self: Const, allocator: Allocator) Allocator.Error!Managed {</span>
<span class="line" id="L1992"> <span class="tok-kw">const</span> limbs = <span class="tok-kw">try</span> allocator.alloc(Limb, <span class="tok-builtin">@max</span>(Managed.default_capacity, self.limbs.len));</span>
<span class="line" id="L1993"> <span class="tok-builtin">@memcpy</span>(limbs[<span class="tok-number">0</span>..self.limbs.len], self.limbs);</span>
<span class="line" id="L1994"> <span class="tok-kw">return</span> Managed{</span>
<span class="line" id="L1995"> .allocator = allocator,</span>
<span class="line" id="L1996"> .limbs = limbs,</span>
<span class="line" id="L1997"> .metadata = <span class="tok-kw">if</span> (self.positive)</span>
<span class="line" id="L1998"> self.limbs.len & ~Managed.sign_bit</span>
<span class="line" id="L1999"> <span class="tok-kw">else</span></span>
<span class="line" id="L2000"> self.limbs.len | Managed.sign_bit,</span>
<span class="line" id="L2001"> };</span>
<span class="line" id="L2002"> }</span>
<span class="line" id="L2003"></span>
<span class="line" id="L2004"> <span class="tok-comment">/// Asserts `limbs` is big enough to store the value.</span></span>
<span class="line" id="L2005"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">toMutable</span>(self: Const, limbs: []Limb) Mutable {</span>
<span class="line" id="L2006"> <span class="tok-builtin">@memcpy</span>(limbs[<span class="tok-number">0</span>..self.limbs.len], self.limbs[<span class="tok-number">0</span>..self.limbs.len]);</span>
<span class="line" id="L2007"> <span class="tok-kw">return</span> .{</span>
<span class="line" id="L2008"> .limbs = limbs,</span>
<span class="line" id="L2009"> .positive = self.positive,</span>
<span class="line" id="L2010"> .len = self.limbs.len,</span>
<span class="line" id="L2011"> };</span>
<span class="line" id="L2012"> }</span>
<span class="line" id="L2013"></span>
<span class="line" id="L2014"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">dump</span>(self: Const) <span class="tok-type">void</span> {</span>
<span class="line" id="L2015"> <span class="tok-kw">for</span> (self.limbs[<span class="tok-number">0</span>..self.limbs.len]) |limb| {</span>
<span class="line" id="L2016"> std.debug.print(<span class="tok-str">"{x} "</span>, .{limb});</span>
<span class="line" id="L2017"> }</span>
<span class="line" id="L2018"> std.debug.print(<span class="tok-str">"positive={}\n"</span>, .{self.positive});</span>
<span class="line" id="L2019"> }</span>
<span class="line" id="L2020"></span>
<span class="line" id="L2021"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">abs</span>(self: Const) Const {</span>
<span class="line" id="L2022"> <span class="tok-kw">return</span> .{</span>
<span class="line" id="L2023"> .limbs = self.limbs,</span>
<span class="line" id="L2024"> .positive = <span class="tok-null">true</span>,</span>
<span class="line" id="L2025"> };</span>
<span class="line" id="L2026"> }</span>
<span class="line" id="L2027"></span>
<span class="line" id="L2028"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">negate</span>(self: Const) Const {</span>
<span class="line" id="L2029"> <span class="tok-kw">return</span> .{</span>
<span class="line" id="L2030"> .limbs = self.limbs,</span>
<span class="line" id="L2031"> .positive = !self.positive,</span>
<span class="line" id="L2032"> };</span>
<span class="line" id="L2033"> }</span>
<span class="line" id="L2034"></span>
<span class="line" id="L2035"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">isOdd</span>(self: Const) <span class="tok-type">bool</span> {</span>
<span class="line" id="L2036"> <span class="tok-kw">return</span> self.limbs[<span class="tok-number">0</span>] & <span class="tok-number">1</span> != <span class="tok-number">0</span>;</span>
<span class="line" id="L2037"> }</span>
<span class="line" id="L2038"></span>
<span class="line" id="L2039"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">isEven</span>(self: Const) <span class="tok-type">bool</span> {</span>
<span class="line" id="L2040"> <span class="tok-kw">return</span> !self.isOdd();</span>
<span class="line" id="L2041"> }</span>
<span class="line" id="L2042"></span>
<span class="line" id="L2043"> <span class="tok-comment">/// Returns the number of bits required to represent the absolute value of an integer.</span></span>
<span class="line" id="L2044"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">bitCountAbs</span>(self: Const) <span class="tok-type">usize</span> {</span>
<span class="line" id="L2045"> <span class="tok-kw">return</span> (self.limbs.len - <span class="tok-number">1</span>) * limb_bits + (limb_bits - <span class="tok-builtin">@clz</span>(self.limbs[self.limbs.len - <span class="tok-number">1</span>]));</span>
<span class="line" id="L2046"> }</span>
<span class="line" id="L2047"></span>
<span class="line" id="L2048"> <span class="tok-comment">/// Returns the number of bits required to represent the integer in twos-complement form.</span></span>
<span class="line" id="L2049"> <span class="tok-comment">///</span></span>
<span class="line" id="L2050"> <span class="tok-comment">/// If the integer is negative the value returned is the number of bits needed by a signed</span></span>
<span class="line" id="L2051"> <span class="tok-comment">/// integer to represent the value. If positive the value is the number of bits for an</span></span>
<span class="line" id="L2052"> <span class="tok-comment">/// unsigned integer. Any unsigned integer will fit in the signed integer with bitcount</span></span>
<span class="line" id="L2053"> <span class="tok-comment">/// one greater than the returned value.</span></span>
<span class="line" id="L2054"> <span class="tok-comment">///</span></span>
<span class="line" id="L2055"> <span class="tok-comment">/// e.g. -127 returns 8 as it will fit in an i8. 127 returns 7 since it fits in a u7.</span></span>
<span class="line" id="L2056"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">bitCountTwosComp</span>(self: Const) <span class="tok-type">usize</span> {</span>
<span class="line" id="L2057"> <span class="tok-kw">var</span> bits = self.bitCountAbs();</span>
<span class="line" id="L2058"></span>
<span class="line" id="L2059"> <span class="tok-comment">// If the entire value has only one bit set (e.g. 0b100000000) then the negation in twos</span>
</span>
<span class="line" id="L2060"> <span class="tok-comment">// complement requires one less bit.</span>
</span>
<span class="line" id="L2061"> <span class="tok-kw">if</span> (!self.positive) block: {</span>
<span class="line" id="L2062"> bits += <span class="tok-number">1</span>;</span>
<span class="line" id="L2063"></span>
<span class="line" id="L2064"> <span class="tok-kw">if</span> (<span class="tok-builtin">@popCount</span>(self.limbs[self.limbs.len - <span class="tok-number">1</span>]) == <span class="tok-number">1</span>) {</span>
<span class="line" id="L2065"> <span class="tok-kw">for</span> (self.limbs[<span class="tok-number">0</span> .. self.limbs.len - <span class="tok-number">1</span>]) |limb| {</span>
<span class="line" id="L2066"> <span class="tok-kw">if</span> (<span class="tok-builtin">@popCount</span>(limb) != <span class="tok-number">0</span>) {</span>
<span class="line" id="L2067"> <span class="tok-kw">break</span> :block;</span>
<span class="line" id="L2068"> }</span>
<span class="line" id="L2069"> }</span>
<span class="line" id="L2070"></span>
<span class="line" id="L2071"> bits -= <span class="tok-number">1</span>;</span>
<span class="line" id="L2072"> }</span>
<span class="line" id="L2073"> }</span>
<span class="line" id="L2074"></span>
<span class="line" id="L2075"> <span class="tok-kw">return</span> bits;</span>
<span class="line" id="L2076"> }</span>
<span class="line" id="L2077"></span>
<span class="line" id="L2078"> <span class="tok-comment">/// @popCount with two's complement semantics.</span></span>
<span class="line" id="L2079"> <span class="tok-comment">///</span></span>
<span class="line" id="L2080"> <span class="tok-comment">/// This returns the number of 1 bits set when the value would be represented in</span></span>
<span class="line" id="L2081"> <span class="tok-comment">/// two's complement with the given integer width (bit_count).</span></span>
<span class="line" id="L2082"> <span class="tok-comment">/// This includes the leading sign bit, which will be set for negative values.</span></span>
<span class="line" id="L2083"> <span class="tok-comment">///</span></span>
<span class="line" id="L2084"> <span class="tok-comment">/// Asserts that bit_count is enough to represent value in two's compliment</span></span>
<span class="line" id="L2085"> <span class="tok-comment">/// and that the final result fits in a usize.</span></span>
<span class="line" id="L2086"> <span class="tok-comment">/// Asserts that there are no trailing empty limbs on the most significant end,</span></span>
<span class="line" id="L2087"> <span class="tok-comment">/// i.e. that limb count matches `calcLimbLen()` and zero is not negative.</span></span>
<span class="line" id="L2088"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">popCount</span>(self: Const, bit_count: <span class="tok-type">usize</span>) <span class="tok-type">usize</span> {</span>
<span class="line" id="L2089"> <span class="tok-kw">var</span> sum: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L2090"> <span class="tok-kw">if</span> (self.positive) {</span>
<span class="line" id="L2091"> <span class="tok-kw">for</span> (self.limbs) |limb| {</span>
<span class="line" id="L2092"> sum += <span class="tok-builtin">@popCount</span>(limb);</span>
<span class="line" id="L2093"> }</span>
<span class="line" id="L2094"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L2095"> assert(self.fitsInTwosComp(.signed, bit_count));</span>
<span class="line" id="L2096"> assert(self.limbs[self.limbs.len - <span class="tok-number">1</span>] != <span class="tok-number">0</span>);</span>
<span class="line" id="L2097"></span>
<span class="line" id="L2098"> <span class="tok-kw">var</span> remaining_bits = bit_count;</span>
<span class="line" id="L2099"> <span class="tok-kw">var</span> carry: <span class="tok-type">u1</span> = <span class="tok-number">1</span>;</span>
<span class="line" id="L2100"> <span class="tok-kw">var</span> add_res: Limb = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L2101"></span>
<span class="line" id="L2102"> <span class="tok-comment">// All but the most significant limb.</span>
</span>
<span class="line" id="L2103"> <span class="tok-kw">for</span> (self.limbs[<span class="tok-number">0</span> .. self.limbs.len - <span class="tok-number">1</span>]) |limb| {</span>
<span class="line" id="L2104"> <span class="tok-kw">const</span> ov = <span class="tok-builtin">@addWithOverflow</span>(~limb, carry);</span>
<span class="line" id="L2105"> add_res = ov[<span class="tok-number">0</span>];</span>
<span class="line" id="L2106"> carry = ov[<span class="tok-number">1</span>];</span>
<span class="line" id="L2107"> sum += <span class="tok-builtin">@popCount</span>(add_res);</span>
<span class="line" id="L2108"> remaining_bits -= limb_bits; <span class="tok-comment">// Asserted not to underflow by fitsInTwosComp</span>
</span>
<span class="line" id="L2109"> }</span>
<span class="line" id="L2110"></span>
<span class="line" id="L2111"> <span class="tok-comment">// The most significant limb may have fewer than @bitSizeOf(Limb) meaningful bits,</span>
</span>
<span class="line" id="L2112"> <span class="tok-comment">// which we can detect with @clz().</span>
</span>
<span class="line" id="L2113"> <span class="tok-comment">// There may also be fewer limbs than needed to fill bit_count.</span>
</span>
<span class="line" id="L2114"> <span class="tok-kw">const</span> limb = self.limbs[self.limbs.len - <span class="tok-number">1</span>];</span>
<span class="line" id="L2115"> <span class="tok-kw">const</span> leading_zeroes = <span class="tok-builtin">@clz</span>(limb);</span>
<span class="line" id="L2116"> <span class="tok-comment">// The most significant limb is asserted not to be all 0s (above),</span>
</span>
<span class="line" id="L2117"> <span class="tok-comment">// so ~limb cannot be all 1s, and ~limb + 1 cannot overflow.</span>
</span>
<span class="line" id="L2118"> sum += <span class="tok-builtin">@popCount</span>(~limb + carry);</span>
<span class="line" id="L2119"> sum -= leading_zeroes; <span class="tok-comment">// All leading zeroes were flipped and added to sum, so undo those</span>
</span>
<span class="line" id="L2120"> <span class="tok-kw">const</span> remaining_ones = remaining_bits - (limb_bits - leading_zeroes); <span class="tok-comment">// All bits not covered by limbs</span>
</span>
<span class="line" id="L2121"> sum += remaining_ones;</span>
<span class="line" id="L2122"> }</span>
<span class="line" id="L2123"> <span class="tok-kw">return</span> sum;</span>
<span class="line" id="L2124"> }</span>
<span class="line" id="L2125"></span>
<span class="line" id="L2126"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">fitsInTwosComp</span>(self: Const, signedness: Signedness, bit_count: <span class="tok-type">usize</span>) <span class="tok-type">bool</span> {</span>
<span class="line" id="L2127"> <span class="tok-kw">if</span> (self.eqlZero()) {</span>
<span class="line" id="L2128"> <span class="tok-kw">return</span> <span class="tok-null">true</span>;</span>
<span class="line" id="L2129"> }</span>
<span class="line" id="L2130"> <span class="tok-kw">if</span> (signedness == .unsigned <span class="tok-kw">and</span> !self.positive) {</span>
<span class="line" id="L2131"> <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L2132"> }</span>
<span class="line" id="L2133"></span>
<span class="line" id="L2134"> <span class="tok-kw">const</span> req_bits = self.bitCountTwosComp() + <span class="tok-builtin">@intFromBool</span>(self.positive <span class="tok-kw">and</span> signedness == .signed);</span>
<span class="line" id="L2135"> <span class="tok-kw">return</span> bit_count >= req_bits;</span>
<span class="line" id="L2136"> }</span>
<span class="line" id="L2137"></span>
<span class="line" id="L2138"> <span class="tok-comment">/// Returns whether self can fit into an integer of the requested type.</span></span>
<span class="line" id="L2139"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">fits</span>(self: Const, <span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>) <span class="tok-type">bool</span> {</span>
<span class="line" id="L2140"> <span class="tok-kw">const</span> info = <span class="tok-builtin">@typeInfo</span>(T).Int;</span>
<span class="line" id="L2141"> <span class="tok-kw">return</span> self.fitsInTwosComp(info.signedness, info.bits);</span>
<span class="line" id="L2142"> }</span>
<span class="line" id="L2143"></span>
<span class="line" id="L2144"> <span class="tok-comment">/// Returns the approximate size of the integer in the given base. Negative values accommodate for</span></span>
<span class="line" id="L2145"> <span class="tok-comment">/// the minus sign. This is used for determining the number of characters needed to print the</span></span>
<span class="line" id="L2146"> <span class="tok-comment">/// value. It is inexact and may exceed the given value by ~1-2 bytes.</span></span>
<span class="line" id="L2147"> <span class="tok-comment">/// TODO See if we can make this exact.</span></span>
<span class="line" id="L2148"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">sizeInBaseUpperBound</span>(self: Const, base: <span class="tok-type">usize</span>) <span class="tok-type">usize</span> {</span>
<span class="line" id="L2149"> <span class="tok-kw">const</span> bit_count = <span class="tok-builtin">@as</span>(<span class="tok-type">usize</span>, <span class="tok-builtin">@intFromBool</span>(!self.positive)) + self.bitCountAbs();</span>
<span class="line" id="L2150"> <span class="tok-kw">return</span> (bit_count / math.log2(base)) + <span class="tok-number">2</span>;</span>
<span class="line" id="L2151"> }</span>
<span class="line" id="L2152"></span>
<span class="line" id="L2153"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> ConvertError = <span class="tok-kw">error</span>{</span>
<span class="line" id="L2154"> NegativeIntoUnsigned,</span>
<span class="line" id="L2155"> TargetTooSmall,</span>
<span class="line" id="L2156"> };</span>
<span class="line" id="L2157"></span>
<span class="line" id="L2158"> <span class="tok-comment">/// Convert self to type T.</span></span>
<span class="line" id="L2159"> <span class="tok-comment">///</span></span>
<span class="line" id="L2160"> <span class="tok-comment">/// Returns an error if self cannot be narrowed into the requested type without truncation.</span></span>
<span class="line" id="L2161"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">to</span>(self: Const, <span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>) ConvertError!T {</span>
<span class="line" id="L2162"> <span class="tok-kw">switch</span> (<span class="tok-builtin">@typeInfo</span>(T)) {</span>
<span class="line" id="L2163"> .Int => |info| {</span>
<span class="line" id="L2164"> <span class="tok-comment">// Make sure -0 is handled correctly.</span>
</span>
<span class="line" id="L2165"> <span class="tok-kw">if</span> (self.eqlZero()) <span class="tok-kw">return</span> <span class="tok-number">0</span>;</span>
<span class="line" id="L2166"></span>
<span class="line" id="L2167"> <span class="tok-kw">const</span> UT = std.meta.Int(.unsigned, info.bits);</span>
<span class="line" id="L2168"></span>
<span class="line" id="L2169"> <span class="tok-kw">if</span> (!self.fitsInTwosComp(info.signedness, info.bits)) {</span>
<span class="line" id="L2170"> <span class="tok-kw">return</span> <span class="tok-kw">error</span>.TargetTooSmall;</span>
<span class="line" id="L2171"> }</span>
<span class="line" id="L2172"></span>
<span class="line" id="L2173"> <span class="tok-kw">var</span> r: UT = <span class="tok-number">0</span>;</span>
<span class="line" id="L2174"></span>
<span class="line" id="L2175"> <span class="tok-kw">if</span> (<span class="tok-builtin">@sizeOf</span>(UT) <= <span class="tok-builtin">@sizeOf</span>(Limb)) {</span>
<span class="line" id="L2176"> r = <span class="tok-builtin">@as</span>(UT, <span class="tok-builtin">@intCast</span>(self.limbs[<span class="tok-number">0</span>]));</span>
<span class="line" id="L2177"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L2178"> <span class="tok-kw">for</span> (self.limbs[<span class="tok-number">0</span>..self.limbs.len], <span class="tok-number">0</span>..) |_, ri| {</span>
<span class="line" id="L2179"> <span class="tok-kw">const</span> limb = self.limbs[self.limbs.len - ri - <span class="tok-number">1</span>];</span>
<span class="line" id="L2180"> r <<= limb_bits;</span>
<span class="line" id="L2181"> r |= limb;</span>
<span class="line" id="L2182"> }</span>
<span class="line" id="L2183"> }</span>
<span class="line" id="L2184"></span>
<span class="line" id="L2185"> <span class="tok-kw">if</span> (info.signedness == .unsigned) {</span>
<span class="line" id="L2186"> <span class="tok-kw">return</span> <span class="tok-kw">if</span> (self.positive) <span class="tok-builtin">@as</span>(T, <span class="tok-builtin">@intCast</span>(r)) <span class="tok-kw">else</span> <span class="tok-kw">error</span>.NegativeIntoUnsigned;</span>
<span class="line" id="L2187"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L2188"> <span class="tok-kw">if</span> (self.positive) {</span>
<span class="line" id="L2189"> <span class="tok-kw">return</span> <span class="tok-builtin">@as</span>(T, <span class="tok-builtin">@intCast</span>(r));</span>
<span class="line" id="L2190"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L2191"> <span class="tok-kw">if</span> (math.cast(T, r)) |ok| {</span>
<span class="line" id="L2192"> <span class="tok-kw">return</span> -ok;</span>
<span class="line" id="L2193"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L2194"> <span class="tok-kw">return</span> minInt(T);</span>
<span class="line" id="L2195"> }</span>
<span class="line" id="L2196"> }</span>
<span class="line" id="L2197"> }</span>
<span class="line" id="L2198"> },</span>
<span class="line" id="L2199"> <span class="tok-kw">else</span> => <span class="tok-builtin">@compileError</span>(<span class="tok-str">"cannot convert Const to type "</span> ++ <span class="tok-builtin">@typeName</span>(T)),</span>
<span class="line" id="L2200"> }</span>
<span class="line" id="L2201"> }</span>
<span class="line" id="L2202"></span>
<span class="line" id="L2203"> <span class="tok-comment">/// To allow `std.fmt.format` to work with this type.</span></span>
<span class="line" id="L2204"> <span class="tok-comment">/// If the integer is larger than `pow(2, 64 * @sizeOf(usize) * 8), this function will fail</span></span>
<span class="line" id="L2205"> <span class="tok-comment">/// to print the string, printing "(BigInt)" instead of a number.</span></span>
<span class="line" id="L2206"> <span class="tok-comment">/// This is because the rendering algorithm requires reversing a string, which requires O(N) memory.</span></span>
<span class="line" id="L2207"> <span class="tok-comment">/// See `toString` and `toStringAlloc` for a way to print big integers without failure.</span></span>
<span class="line" id="L2208"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">format</span>(</span>
<span class="line" id="L2209"> self: Const,</span>
<span class="line" id="L2210"> <span class="tok-kw">comptime</span> fmt: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L2211"> options: std.fmt.FormatOptions,</span>
<span class="line" id="L2212"> out_stream: <span class="tok-kw">anytype</span>,</span>
<span class="line" id="L2213"> ) !<span class="tok-type">void</span> {</span>
<span class="line" id="L2214"> _ = options;</span>
<span class="line" id="L2215"> <span class="tok-kw">comptime</span> <span class="tok-kw">var</span> base = <span class="tok-number">10</span>;</span>
<span class="line" id="L2216"> <span class="tok-kw">comptime</span> <span class="tok-kw">var</span> case: std.fmt.Case = .lower;</span>
<span class="line" id="L2217"></span>
<span class="line" id="L2218"> <span class="tok-kw">if</span> (fmt.len == <span class="tok-number">0</span> <span class="tok-kw">or</span> <span class="tok-kw">comptime</span> mem.eql(<span class="tok-type">u8</span>, fmt, <span class="tok-str">"d"</span>)) {</span>
<span class="line" id="L2219"> base = <span class="tok-number">10</span>;</span>
<span class="line" id="L2220"> case = .lower;</span>
<span class="line" id="L2221"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (<span class="tok-kw">comptime</span> mem.eql(<span class="tok-type">u8</span>, fmt, <span class="tok-str">"b"</span>)) {</span>
<span class="line" id="L2222"> base = <span class="tok-number">2</span>;</span>
<span class="line" id="L2223"> case = .lower;</span>
<span class="line" id="L2224"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (<span class="tok-kw">comptime</span> mem.eql(<span class="tok-type">u8</span>, fmt, <span class="tok-str">"x"</span>)) {</span>
<span class="line" id="L2225"> base = <span class="tok-number">16</span>;</span>
<span class="line" id="L2226"> case = .lower;</span>
<span class="line" id="L2227"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (<span class="tok-kw">comptime</span> mem.eql(<span class="tok-type">u8</span>, fmt, <span class="tok-str">"X"</span>)) {</span>
<span class="line" id="L2228"> base = <span class="tok-number">16</span>;</span>
<span class="line" id="L2229"> case = .upper;</span>
<span class="line" id="L2230"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L2231"> std.fmt.invalidFmtError(fmt, self);</span>
<span class="line" id="L2232"> }</span>
<span class="line" id="L2233"></span>
<span class="line" id="L2234"> <span class="tok-kw">var</span> limbs: [<span class="tok-number">128</span>]Limb = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L2235"> <span class="tok-kw">const</span> needed_limbs = calcDivLimbsBufferLen(self.limbs.len, <span class="tok-number">1</span>);</span>
<span class="line" id="L2236"> <span class="tok-kw">if</span> (needed_limbs > limbs.len)</span>
<span class="line" id="L2237"> <span class="tok-kw">return</span> out_stream.writeAll(<span class="tok-str">"(BigInt)"</span>);</span>
<span class="line" id="L2238"></span>
<span class="line" id="L2239"> <span class="tok-comment">// This is the inverse of calcDivLimbsBufferLen</span>
</span>
<span class="line" id="L2240"> <span class="tok-kw">const</span> available_len = (limbs.len / <span class="tok-number">3</span>) - <span class="tok-number">2</span>;</span>
<span class="line" id="L2241"></span>
<span class="line" id="L2242"> <span class="tok-kw">const</span> biggest: Const = .{</span>
<span class="line" id="L2243"> .limbs = &([<span class="tok-number">1</span>]Limb{<span class="tok-kw">comptime</span> math.maxInt(Limb)} ** available_len),</span>
<span class="line" id="L2244"> .positive = <span class="tok-null">false</span>,</span>
<span class="line" id="L2245"> };</span>
<span class="line" id="L2246"> <span class="tok-kw">var</span> buf: [biggest.sizeInBaseUpperBound(base)]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L2247"> <span class="tok-kw">const</span> len = self.toString(&buf, base, case, &limbs);</span>
<span class="line" id="L2248"> <span class="tok-kw">return</span> out_stream.writeAll(buf[<span class="tok-number">0</span>..len]);</span>
<span class="line" id="L2249"> }</span>
<span class="line" id="L2250"></span>
<span class="line" id="L2251"> <span class="tok-comment">/// Converts self to a string in the requested base.</span></span>
<span class="line" id="L2252"> <span class="tok-comment">/// Caller owns returned memory.</span></span>
<span class="line" id="L2253"> <span class="tok-comment">/// Asserts that `base` is in the range [2, 16].</span></span>
<span class="line" id="L2254"> <span class="tok-comment">/// See also `toString`, a lower level function than this.</span></span>
<span class="line" id="L2255"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">toStringAlloc</span>(self: Const, allocator: Allocator, base: <span class="tok-type">u8</span>, case: std.fmt.Case) Allocator.Error![]<span class="tok-type">u8</span> {</span>
<span class="line" id="L2256"> assert(base >= <span class="tok-number">2</span>);</span>
<span class="line" id="L2257"> assert(base <= <span class="tok-number">16</span>);</span>
<span class="line" id="L2258"></span>
<span class="line" id="L2259"> <span class="tok-kw">if</span> (self.eqlZero()) {</span>
<span class="line" id="L2260"> <span class="tok-kw">return</span> allocator.dupe(<span class="tok-type">u8</span>, <span class="tok-str">"0"</span>);</span>
<span class="line" id="L2261"> }</span>
<span class="line" id="L2262"> <span class="tok-kw">const</span> string = <span class="tok-kw">try</span> allocator.alloc(<span class="tok-type">u8</span>, self.sizeInBaseUpperBound(base));</span>
<span class="line" id="L2263"> <span class="tok-kw">errdefer</span> allocator.free(string);</span>
<span class="line" id="L2264"></span>
<span class="line" id="L2265"> <span class="tok-kw">const</span> limbs = <span class="tok-kw">try</span> allocator.alloc(Limb, calcToStringLimbsBufferLen(self.limbs.len, base));</span>
<span class="line" id="L2266"> <span class="tok-kw">defer</span> allocator.free(limbs);</span>
<span class="line" id="L2267"></span>
<span class="line" id="L2268"> <span class="tok-kw">return</span> allocator.realloc(string, self.toString(string, base, case, limbs));</span>
<span class="line" id="L2269"> }</span>
<span class="line" id="L2270"></span>
<span class="line" id="L2271"> <span class="tok-comment">/// Converts self to a string in the requested base.</span></span>
<span class="line" id="L2272"> <span class="tok-comment">/// Asserts that `base` is in the range [2, 16].</span></span>
<span class="line" id="L2273"> <span class="tok-comment">/// `string` is a caller-provided slice of at least `sizeInBaseUpperBound` bytes,</span></span>
<span class="line" id="L2274"> <span class="tok-comment">/// where the result is written to.</span></span>
<span class="line" id="L2275"> <span class="tok-comment">/// Returns the length of the string.</span></span>
<span class="line" id="L2276"> <span class="tok-comment">/// `limbs_buffer` is caller-provided memory for `toString` to use as a working area. It must have</span></span>
<span class="line" id="L2277"> <span class="tok-comment">/// length of at least `calcToStringLimbsBufferLen`.</span></span>
<span class="line" id="L2278"> <span class="tok-comment">/// In the case of power-of-two base, `limbs_buffer` is ignored.</span></span>
<span class="line" id="L2279"> <span class="tok-comment">/// See also `toStringAlloc`, a higher level function than this.</span></span>
<span class="line" id="L2280"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">toString</span>(self: Const, string: []<span class="tok-type">u8</span>, base: <span class="tok-type">u8</span>, case: std.fmt.Case, limbs_buffer: []Limb) <span class="tok-type">usize</span> {</span>
<span class="line" id="L2281"> assert(base >= <span class="tok-number">2</span>);</span>
<span class="line" id="L2282"> assert(base <= <span class="tok-number">16</span>);</span>
<span class="line" id="L2283"></span>
<span class="line" id="L2284"> <span class="tok-kw">if</span> (self.eqlZero()) {</span>
<span class="line" id="L2285"> string[<span class="tok-number">0</span>] = <span class="tok-str">'0'</span>;</span>
<span class="line" id="L2286"> <span class="tok-kw">return</span> <span class="tok-number">1</span>;</span>
<span class="line" id="L2287"> }</span>
<span class="line" id="L2288"></span>
<span class="line" id="L2289"> <span class="tok-kw">var</span> digits_len: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L2290"></span>
<span class="line" id="L2291"> <span class="tok-comment">// Power of two: can do a single pass and use masks to extract digits.</span>
</span>
<span class="line" id="L2292"> <span class="tok-kw">if</span> (math.isPowerOfTwo(base)) {</span>
<span class="line" id="L2293"> <span class="tok-kw">const</span> base_shift = math.log2_int(Limb, base);</span>
<span class="line" id="L2294"></span>
<span class="line" id="L2295"> outer: <span class="tok-kw">for</span> (self.limbs[<span class="tok-number">0</span>..self.limbs.len]) |limb| {</span>
<span class="line" id="L2296"> <span class="tok-kw">var</span> shift: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L2297"> <span class="tok-kw">while</span> (shift < limb_bits) : (shift += base_shift) {</span>
<span class="line" id="L2298"> <span class="tok-kw">const</span> r = <span class="tok-builtin">@as</span>(<span class="tok-type">u8</span>, <span class="tok-builtin">@intCast</span>((limb >> <span class="tok-builtin">@as</span>(Log2Limb, <span class="tok-builtin">@intCast</span>(shift))) & <span class="tok-builtin">@as</span>(Limb, base - <span class="tok-number">1</span>)));</span>
<span class="line" id="L2299"> <span class="tok-kw">const</span> ch = std.fmt.digitToChar(r, case);</span>
<span class="line" id="L2300"> string[digits_len] = ch;</span>
<span class="line" id="L2301"> digits_len += <span class="tok-number">1</span>;</span>
<span class="line" id="L2302"> <span class="tok-comment">// If we hit the end, it must be all zeroes from here.</span>
</span>
<span class="line" id="L2303"> <span class="tok-kw">if</span> (digits_len == string.len) <span class="tok-kw">break</span> :outer;</span>
<span class="line" id="L2304"> }</span>
<span class="line" id="L2305"> }</span>
<span class="line" id="L2306"></span>
<span class="line" id="L2307"> <span class="tok-comment">// Always will have a non-zero digit somewhere.</span>
</span>
<span class="line" id="L2308"> <span class="tok-kw">while</span> (string[digits_len - <span class="tok-number">1</span>] == <span class="tok-str">'0'</span>) {</span>
<span class="line" id="L2309"> digits_len -= <span class="tok-number">1</span>;</span>
<span class="line" id="L2310"> }</span>
<span class="line" id="L2311"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L2312"> <span class="tok-comment">// Non power-of-two: batch divisions per word size.</span>
</span>
<span class="line" id="L2313"> <span class="tok-comment">// We use a HalfLimb here so the division uses the faster lldiv0p5 over lldiv1 codepath.</span>
</span>
<span class="line" id="L2314"> <span class="tok-kw">const</span> digits_per_limb = math.log(HalfLimb, base, maxInt(HalfLimb));</span>
<span class="line" id="L2315"> <span class="tok-kw">var</span> limb_base: Limb = <span class="tok-number">1</span>;</span>
<span class="line" id="L2316"> <span class="tok-kw">var</span> j: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L2317"> <span class="tok-kw">while</span> (j < digits_per_limb) : (j += <span class="tok-number">1</span>) {</span>
<span class="line" id="L2318"> limb_base *= base;</span>
<span class="line" id="L2319"> }</span>
<span class="line" id="L2320"> <span class="tok-kw">const</span> b: Const = .{ .limbs = &[_]Limb{limb_base}, .positive = <span class="tok-null">true</span> };</span>
<span class="line" id="L2321"></span>
<span class="line" id="L2322"> <span class="tok-kw">var</span> q: Mutable = .{</span>
<span class="line" id="L2323"> .limbs = limbs_buffer[<span class="tok-number">0</span> .. self.limbs.len + <span class="tok-number">2</span>],</span>
<span class="line" id="L2324"> .positive = <span class="tok-null">true</span>, <span class="tok-comment">// Make absolute by ignoring self.positive.</span>
</span>
<span class="line" id="L2325"> .len = self.limbs.len,</span>
<span class="line" id="L2326"> };</span>
<span class="line" id="L2327"> <span class="tok-builtin">@memcpy</span>(q.limbs[<span class="tok-number">0</span>..self.limbs.len], self.limbs);</span>
<span class="line" id="L2328"></span>
<span class="line" id="L2329"> <span class="tok-kw">var</span> r: Mutable = .{</span>
<span class="line" id="L2330"> .limbs = limbs_buffer[q.limbs.len..][<span class="tok-number">0</span>..self.limbs.len],</span>
<span class="line" id="L2331"> .positive = <span class="tok-null">true</span>,</span>
<span class="line" id="L2332"> .len = <span class="tok-number">1</span>,</span>
<span class="line" id="L2333"> };</span>
<span class="line" id="L2334"> r.limbs[<span class="tok-number">0</span>] = <span class="tok-number">0</span>;</span>
<span class="line" id="L2335"></span>
<span class="line" id="L2336"> <span class="tok-kw">const</span> rest_of_the_limbs_buf = limbs_buffer[q.limbs.len + r.limbs.len ..];</span>
<span class="line" id="L2337"></span>
<span class="line" id="L2338"> <span class="tok-kw">while</span> (q.len >= <span class="tok-number">2</span>) {</span>
<span class="line" id="L2339"> <span class="tok-comment">// Passing an allocator here would not be helpful since this division is destroying</span>
</span>
<span class="line" id="L2340"> <span class="tok-comment">// information, not creating it. [TODO citation needed]</span>
</span>
<span class="line" id="L2341"> q.divTrunc(&r, q.toConst(), b, rest_of_the_limbs_buf);</span>
<span class="line" id="L2342"></span>
<span class="line" id="L2343"> <span class="tok-kw">var</span> r_word = r.limbs[<span class="tok-number">0</span>];</span>
<span class="line" id="L2344"> <span class="tok-kw">var</span> i: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L2345"> <span class="tok-kw">while</span> (i < digits_per_limb) : (i += <span class="tok-number">1</span>) {</span>
<span class="line" id="L2346"> <span class="tok-kw">const</span> ch = std.fmt.digitToChar(<span class="tok-builtin">@as</span>(<span class="tok-type">u8</span>, <span class="tok-builtin">@intCast</span>(r_word % base)), case);</span>
<span class="line" id="L2347"> r_word /= base;</span>
<span class="line" id="L2348"> string[digits_len] = ch;</span>
<span class="line" id="L2349"> digits_len += <span class="tok-number">1</span>;</span>
<span class="line" id="L2350"> }</span>
<span class="line" id="L2351"> }</span>
<span class="line" id="L2352"></span>
<span class="line" id="L2353"> {</span>
<span class="line" id="L2354"> assert(q.len == <span class="tok-number">1</span>);</span>
<span class="line" id="L2355"></span>
<span class="line" id="L2356"> <span class="tok-kw">var</span> r_word = q.limbs[<span class="tok-number">0</span>];</span>
<span class="line" id="L2357"> <span class="tok-kw">while</span> (r_word != <span class="tok-number">0</span>) {</span>
<span class="line" id="L2358"> <span class="tok-kw">const</span> ch = std.fmt.digitToChar(<span class="tok-builtin">@as</span>(<span class="tok-type">u8</span>, <span class="tok-builtin">@intCast</span>(r_word % base)), case);</span>
<span class="line" id="L2359"> r_word /= base;</span>
<span class="line" id="L2360"> string[digits_len] = ch;</span>
<span class="line" id="L2361"> digits_len += <span class="tok-number">1</span>;</span>
<span class="line" id="L2362"> }</span>
<span class="line" id="L2363"> }</span>
<span class="line" id="L2364"> }</span>
<span class="line" id="L2365"></span>
<span class="line" id="L2366"> <span class="tok-kw">if</span> (!self.positive) {</span>
<span class="line" id="L2367"> string[digits_len] = <span class="tok-str">'-'</span>;</span>
<span class="line" id="L2368"> digits_len += <span class="tok-number">1</span>;</span>
<span class="line" id="L2369"> }</span>
<span class="line" id="L2370"></span>
<span class="line" id="L2371"> <span class="tok-kw">const</span> s = string[<span class="tok-number">0</span>..digits_len];</span>
<span class="line" id="L2372"> mem.reverse(<span class="tok-type">u8</span>, s);</span>
<span class="line" id="L2373"> <span class="tok-kw">return</span> s.len;</span>
<span class="line" id="L2374"> }</span>
<span class="line" id="L2375"></span>
<span class="line" id="L2376"> <span class="tok-comment">/// Write the value of `x` into `buffer`</span></span>
<span class="line" id="L2377"> <span class="tok-comment">/// Asserts that `buffer` is large enough to store the value.</span></span>
<span class="line" id="L2378"> <span class="tok-comment">///</span></span>
<span class="line" id="L2379"> <span class="tok-comment">/// `buffer` is filled so that its contents match what would be observed via</span></span>
<span class="line" id="L2380"> <span class="tok-comment">/// @ptrCast(*[buffer.len]const u8, &x). Byte ordering is determined by `endian`,</span></span>
<span class="line" id="L2381"> <span class="tok-comment">/// and any required padding bits are added on the MSB end.</span></span>
<span class="line" id="L2382"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">writeTwosComplement</span>(x: Const, buffer: []<span class="tok-type">u8</span>, endian: Endian) <span class="tok-type">void</span> {</span>
<span class="line" id="L2383"> <span class="tok-kw">return</span> writePackedTwosComplement(x, buffer, <span class="tok-number">0</span>, <span class="tok-number">8</span> * buffer.len, endian);</span>
<span class="line" id="L2384"> }</span>
<span class="line" id="L2385"></span>
<span class="line" id="L2386"> <span class="tok-comment">/// Write the value of `x` to a packed memory `buffer`.</span></span>
<span class="line" id="L2387"> <span class="tok-comment">/// Asserts that `buffer` is large enough to contain a value of bit-size `bit_count`</span></span>
<span class="line" id="L2388"> <span class="tok-comment">/// at offset `bit_offset`.</span></span>
<span class="line" id="L2389"> <span class="tok-comment">///</span></span>
<span class="line" id="L2390"> <span class="tok-comment">/// This is equivalent to storing the value of an integer with `bit_count` bits as</span></span>
<span class="line" id="L2391"> <span class="tok-comment">/// if it were a field in packed memory at the provided bit offset.</span></span>
<span class="line" id="L2392"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">writePackedTwosComplement</span>(x: Const, buffer: []<span class="tok-type">u8</span>, bit_offset: <span class="tok-type">usize</span>, bit_count: <span class="tok-type">usize</span>, endian: Endian) <span class="tok-type">void</span> {</span>
<span class="line" id="L2393"> assert(x.fitsInTwosComp(<span class="tok-kw">if</span> (x.positive) .unsigned <span class="tok-kw">else</span> .signed, bit_count));</span>
<span class="line" id="L2394"></span>
<span class="line" id="L2395"> <span class="tok-comment">// Copy all complete limbs</span>
</span>
<span class="line" id="L2396"> <span class="tok-kw">var</span> carry: <span class="tok-type">u1</span> = <span class="tok-number">1</span>;</span>
<span class="line" id="L2397"> <span class="tok-kw">var</span> limb_index: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L2398"> <span class="tok-kw">var</span> bit_index: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L2399"> <span class="tok-kw">while</span> (limb_index < bit_count / <span class="tok-builtin">@bitSizeOf</span>(Limb)) : (limb_index += <span class="tok-number">1</span>) {</span>
<span class="line" id="L2400"> <span class="tok-kw">var</span> limb: Limb = <span class="tok-kw">if</span> (limb_index < x.limbs.len) x.limbs[limb_index] <span class="tok-kw">else</span> <span class="tok-number">0</span>;</span>
<span class="line" id="L2401"></span>
<span class="line" id="L2402"> <span class="tok-comment">// 2's complement (bitwise not, then add carry bit)</span>
</span>
<span class="line" id="L2403"> <span class="tok-kw">if</span> (!x.positive) {</span>
<span class="line" id="L2404"> <span class="tok-kw">const</span> ov = <span class="tok-builtin">@addWithOverflow</span>(~limb, carry);</span>
<span class="line" id="L2405"> limb = ov[<span class="tok-number">0</span>];</span>
<span class="line" id="L2406"> carry = ov[<span class="tok-number">1</span>];</span>
<span class="line" id="L2407"> }</span>
<span class="line" id="L2408"></span>
<span class="line" id="L2409"> <span class="tok-comment">// Write one Limb of bits</span>
</span>
<span class="line" id="L2410"> mem.writePackedInt(Limb, buffer, bit_index + bit_offset, limb, endian);</span>
<span class="line" id="L2411"> bit_index += <span class="tok-builtin">@bitSizeOf</span>(Limb);</span>
<span class="line" id="L2412"> }</span>
<span class="line" id="L2413"></span>
<span class="line" id="L2414"> <span class="tok-comment">// Copy the remaining bits</span>
</span>
<span class="line" id="L2415"> <span class="tok-kw">if</span> (bit_count != bit_index) {</span>
<span class="line" id="L2416"> <span class="tok-kw">var</span> limb: Limb = <span class="tok-kw">if</span> (limb_index < x.limbs.len) x.limbs[limb_index] <span class="tok-kw">else</span> <span class="tok-number">0</span>;</span>
<span class="line" id="L2417"></span>
<span class="line" id="L2418"> <span class="tok-comment">// 2's complement (bitwise not, then add carry bit)</span>
</span>
<span class="line" id="L2419"> <span class="tok-kw">if</span> (!x.positive) limb = ~limb +% carry;</span>
<span class="line" id="L2420"></span>
<span class="line" id="L2421"> <span class="tok-comment">// Write all remaining bits</span>
</span>
<span class="line" id="L2422"> mem.writeVarPackedInt(buffer, bit_index + bit_offset, bit_count - bit_index, limb, endian);</span>
<span class="line" id="L2423"> }</span>
<span class="line" id="L2424"> }</span>
<span class="line" id="L2425"></span>
<span class="line" id="L2426"> <span class="tok-comment">/// Returns `math.Order.lt`, `math.Order.eq`, `math.Order.gt` if</span></span>
<span class="line" id="L2427"> <span class="tok-comment">/// `|a| < |b|`, `|a| == |b|`, or `|a| > |b|` respectively.</span></span>
<span class="line" id="L2428"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">orderAbs</span>(a: Const, b: Const) math.Order {</span>
<span class="line" id="L2429"> <span class="tok-kw">if</span> (a.limbs.len < b.limbs.len) {</span>
<span class="line" id="L2430"> <span class="tok-kw">return</span> .lt;</span>
<span class="line" id="L2431"> }</span>
<span class="line" id="L2432"> <span class="tok-kw">if</span> (a.limbs.len > b.limbs.len) {</span>
<span class="line" id="L2433"> <span class="tok-kw">return</span> .gt;</span>
<span class="line" id="L2434"> }</span>
<span class="line" id="L2435"></span>
<span class="line" id="L2436"> <span class="tok-kw">var</span> i: <span class="tok-type">usize</span> = a.limbs.len - <span class="tok-number">1</span>;</span>
<span class="line" id="L2437"> <span class="tok-kw">while</span> (i != <span class="tok-number">0</span>) : (i -= <span class="tok-number">1</span>) {</span>
<span class="line" id="L2438"> <span class="tok-kw">if</span> (a.limbs[i] != b.limbs[i]) {</span>
<span class="line" id="L2439"> <span class="tok-kw">break</span>;</span>
<span class="line" id="L2440"> }</span>
<span class="line" id="L2441"> }</span>
<span class="line" id="L2442"></span>
<span class="line" id="L2443"> <span class="tok-kw">if</span> (a.limbs[i] < b.limbs[i]) {</span>
<span class="line" id="L2444"> <span class="tok-kw">return</span> .lt;</span>
<span class="line" id="L2445"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (a.limbs[i] > b.limbs[i]) {</span>
<span class="line" id="L2446"> <span class="tok-kw">return</span> .gt;</span>
<span class="line" id="L2447"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L2448"> <span class="tok-kw">return</span> .eq;</span>
<span class="line" id="L2449"> }</span>
<span class="line" id="L2450"> }</span>
<span class="line" id="L2451"></span>
<span class="line" id="L2452"> <span class="tok-comment">/// Returns `math.Order.lt`, `math.Order.eq`, `math.Order.gt` if `a < b`, `a == b` or `a > b` respectively.</span></span>
<span class="line" id="L2453"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">order</span>(a: Const, b: Const) math.Order {</span>
<span class="line" id="L2454"> <span class="tok-kw">if</span> (a.positive != b.positive) {</span>
<span class="line" id="L2455"> <span class="tok-kw">return</span> <span class="tok-kw">if</span> (a.positive) .gt <span class="tok-kw">else</span> .lt;</span>
<span class="line" id="L2456"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L2457"> <span class="tok-kw">const</span> r = orderAbs(a, b);</span>
<span class="line" id="L2458"> <span class="tok-kw">return</span> <span class="tok-kw">if</span> (a.positive) r <span class="tok-kw">else</span> <span class="tok-kw">switch</span> (r) {</span>
<span class="line" id="L2459"> .lt => math.Order.gt,</span>
<span class="line" id="L2460"> .eq => math.Order.eq,</span>
<span class="line" id="L2461"> .gt => math.Order.lt,</span>
<span class="line" id="L2462"> };</span>
<span class="line" id="L2463"> }</span>
<span class="line" id="L2464"> }</span>
<span class="line" id="L2465"></span>
<span class="line" id="L2466"> <span class="tok-comment">/// Same as `order` but the right-hand operand is a primitive integer.</span></span>
<span class="line" id="L2467"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">orderAgainstScalar</span>(lhs: Const, scalar: <span class="tok-kw">anytype</span>) math.Order {</span>
<span class="line" id="L2468"> <span class="tok-comment">// Normally we could just determine the number of limbs needed with calcLimbLen,</span>
</span>
<span class="line" id="L2469"> <span class="tok-comment">// but that is not comptime-known when scalar is not a comptime_int. Instead, we</span>
</span>
<span class="line" id="L2470"> <span class="tok-comment">// use calcTwosCompLimbCount for a non-comptime_int scalar, which can be pessimistic</span>
</span>
<span class="line" id="L2471"> <span class="tok-comment">// in the case that scalar happens to be small in magnitude within its type, but it</span>
</span>
<span class="line" id="L2472"> <span class="tok-comment">// is well worth being able to use the stack and not needing an allocator passed in.</span>
</span>
<span class="line" id="L2473"> <span class="tok-comment">// Note that Mutable.init still sets len to calcLimbLen(scalar) in any case.</span>
</span>
<span class="line" id="L2474"> <span class="tok-kw">const</span> limb_len = <span class="tok-kw">comptime</span> <span class="tok-kw">switch</span> (<span class="tok-builtin">@typeInfo</span>(<span class="tok-builtin">@TypeOf</span>(scalar))) {</span>
<span class="line" id="L2475"> .ComptimeInt => calcLimbLen(scalar),</span>
<span class="line" id="L2476"> .Int => |info| calcTwosCompLimbCount(info.bits),</span>
<span class="line" id="L2477"> <span class="tok-kw">else</span> => <span class="tok-builtin">@compileError</span>(<span class="tok-str">"expected scalar to be an int"</span>),</span>
<span class="line" id="L2478"> };</span>
<span class="line" id="L2479"> <span class="tok-kw">var</span> limbs: [limb_len]Limb = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L2480"> <span class="tok-kw">const</span> rhs = Mutable.init(&limbs, scalar);</span>
<span class="line" id="L2481"> <span class="tok-kw">return</span> order(lhs, rhs.toConst());</span>
<span class="line" id="L2482"> }</span>
<span class="line" id="L2483"></span>
<span class="line" id="L2484"> <span class="tok-comment">// TODO: remove after release of 0.11</span>
</span>
<span class="line" id="L2485"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> eqZero = <span class="tok-builtin">@compileError</span>(<span class="tok-str">"use eqlZero"</span>);</span>
<span class="line" id="L2486"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> eqAbs = <span class="tok-builtin">@compileError</span>(<span class="tok-str">"use eqlAbs"</span>);</span>
<span class="line" id="L2487"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> eq = <span class="tok-builtin">@compileError</span>(<span class="tok-str">"use eql"</span>);</span>
<span class="line" id="L2488"></span>
<span class="line" id="L2489"> <span class="tok-comment">/// Returns true if `a == 0`.</span></span>
<span class="line" id="L2490"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">eqlZero</span>(a: Const) <span class="tok-type">bool</span> {</span>
<span class="line" id="L2491"> <span class="tok-kw">var</span> d: Limb = <span class="tok-number">0</span>;</span>
<span class="line" id="L2492"> <span class="tok-kw">for</span> (a.limbs) |limb| d |= limb;</span>
<span class="line" id="L2493"> <span class="tok-kw">return</span> d == <span class="tok-number">0</span>;</span>
<span class="line" id="L2494"> }</span>
<span class="line" id="L2495"></span>
<span class="line" id="L2496"> <span class="tok-comment">/// Returns true if `|a| == |b|`.</span></span>
<span class="line" id="L2497"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">eqlAbs</span>(a: Const, b: Const) <span class="tok-type">bool</span> {</span>
<span class="line" id="L2498"> <span class="tok-kw">return</span> orderAbs(a, b) == .eq;</span>
<span class="line" id="L2499"> }</span>
<span class="line" id="L2500"></span>
<span class="line" id="L2501"> <span class="tok-comment">/// Returns true if `a == b`.</span></span>
<span class="line" id="L2502"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">eql</span>(a: Const, b: Const) <span class="tok-type">bool</span> {</span>
<span class="line" id="L2503"> <span class="tok-kw">return</span> order(a, b) == .eq;</span>
<span class="line" id="L2504"> }</span>
<span class="line" id="L2505"></span>
<span class="line" id="L2506"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">clz</span>(a: Const, bits: Limb) Limb {</span>
<span class="line" id="L2507"> <span class="tok-comment">// Limbs are stored in little-endian order but we need</span>
</span>
<span class="line" id="L2508"> <span class="tok-comment">// to iterate big-endian.</span>
</span>
<span class="line" id="L2509"> <span class="tok-kw">var</span> total_limb_lz: Limb = <span class="tok-number">0</span>;</span>
<span class="line" id="L2510"> <span class="tok-kw">var</span> i: <span class="tok-type">usize</span> = a.limbs.len;</span>
<span class="line" id="L2511"> <span class="tok-kw">const</span> bits_per_limb = <span class="tok-builtin">@sizeOf</span>(Limb) * <span class="tok-number">8</span>;</span>
<span class="line" id="L2512"> <span class="tok-kw">while</span> (i != <span class="tok-number">0</span>) {</span>
<span class="line" id="L2513"> i -= <span class="tok-number">1</span>;</span>
<span class="line" id="L2514"> <span class="tok-kw">const</span> limb = a.limbs[i];</span>
<span class="line" id="L2515"> <span class="tok-kw">const</span> this_limb_lz = <span class="tok-builtin">@clz</span>(limb);</span>
<span class="line" id="L2516"> total_limb_lz += this_limb_lz;</span>
<span class="line" id="L2517"> <span class="tok-kw">if</span> (this_limb_lz != bits_per_limb) <span class="tok-kw">break</span>;</span>
<span class="line" id="L2518"> }</span>
<span class="line" id="L2519"> <span class="tok-kw">const</span> total_limb_bits = a.limbs.len * bits_per_limb;</span>
<span class="line" id="L2520"> <span class="tok-kw">return</span> total_limb_lz + bits - total_limb_bits;</span>
<span class="line" id="L2521"> }</span>
<span class="line" id="L2522"></span>
<span class="line" id="L2523"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">ctz</span>(a: Const, bits: Limb) Limb {</span>
<span class="line" id="L2524"> <span class="tok-comment">// Limbs are stored in little-endian order.</span>
</span>
<span class="line" id="L2525"> <span class="tok-kw">var</span> result: Limb = <span class="tok-number">0</span>;</span>
<span class="line" id="L2526"> <span class="tok-kw">for</span> (a.limbs) |limb| {</span>
<span class="line" id="L2527"> <span class="tok-kw">const</span> limb_tz = <span class="tok-builtin">@ctz</span>(limb);</span>
<span class="line" id="L2528"> result += limb_tz;</span>
<span class="line" id="L2529"> <span class="tok-kw">if</span> (limb_tz != <span class="tok-builtin">@sizeOf</span>(Limb) * <span class="tok-number">8</span>) <span class="tok-kw">break</span>;</span>
<span class="line" id="L2530"> }</span>
<span class="line" id="L2531"> <span class="tok-kw">return</span> <span class="tok-builtin">@min</span>(result, bits);</span>
<span class="line" id="L2532"> }</span>
<span class="line" id="L2533">};</span>
<span class="line" id="L2534"></span>
<span class="line" id="L2535"><span class="tok-comment">/// An arbitrary-precision big integer along with an allocator which manages the memory.</span></span>
<span class="line" id="L2536"><span class="tok-comment">///</span></span>
<span class="line" id="L2537"><span class="tok-comment">/// Memory is allocated as needed to ensure operations never overflow. The range</span></span>
<span class="line" id="L2538"><span class="tok-comment">/// is bounded only by available memory.</span></span>
<span class="line" id="L2539"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> Managed = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L2540"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> sign_bit: <span class="tok-type">usize</span> = <span class="tok-number">1</span> << (<span class="tok-builtin">@typeInfo</span>(<span class="tok-type">usize</span>).Int.bits - <span class="tok-number">1</span>);</span>
<span class="line" id="L2541"></span>
<span class="line" id="L2542"> <span class="tok-comment">/// Default number of limbs to allocate on creation of a `Managed`.</span></span>
<span class="line" id="L2543"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> default_capacity = <span class="tok-number">4</span>;</span>
<span class="line" id="L2544"></span>
<span class="line" id="L2545"> <span class="tok-comment">/// Allocator used by the Managed when requesting memory.</span></span>
<span class="line" id="L2546"> allocator: Allocator,</span>
<span class="line" id="L2547"></span>
<span class="line" id="L2548"> <span class="tok-comment">/// Raw digits. These are:</span></span>
<span class="line" id="L2549"> <span class="tok-comment">///</span></span>
<span class="line" id="L2550"> <span class="tok-comment">/// * Little-endian ordered</span></span>
<span class="line" id="L2551"> <span class="tok-comment">/// * limbs.len >= 1</span></span>
<span class="line" id="L2552"> <span class="tok-comment">/// * Zero is represent as Managed.len() == 1 with limbs[0] == 0.</span></span>
<span class="line" id="L2553"> <span class="tok-comment">///</span></span>
<span class="line" id="L2554"> <span class="tok-comment">/// Accessing limbs directly should be avoided.</span></span>
<span class="line" id="L2555"> limbs: []Limb,</span>
<span class="line" id="L2556"></span>
<span class="line" id="L2557"> <span class="tok-comment">/// High bit is the sign bit. If set, Managed is negative, else Managed is positive.</span></span>
<span class="line" id="L2558"> <span class="tok-comment">/// The remaining bits represent the number of limbs used by Managed.</span></span>
<span class="line" id="L2559"> metadata: <span class="tok-type">usize</span>,</span>
<span class="line" id="L2560"></span>
<span class="line" id="L2561"> <span class="tok-comment">/// Creates a new `Managed`. `default_capacity` limbs will be allocated immediately.</span></span>
<span class="line" id="L2562"> <span class="tok-comment">/// The integer value after initializing is `0`.</span></span>
<span class="line" id="L2563"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">init</span>(allocator: Allocator) !Managed {</span>
<span class="line" id="L2564"> <span class="tok-kw">return</span> initCapacity(allocator, default_capacity);</span>
<span class="line" id="L2565"> }</span>
<span class="line" id="L2566"></span>
<span class="line" id="L2567"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">toMutable</span>(self: Managed) Mutable {</span>
<span class="line" id="L2568"> <span class="tok-kw">return</span> .{</span>
<span class="line" id="L2569"> .limbs = self.limbs,</span>
<span class="line" id="L2570"> .positive = self.isPositive(),</span>
<span class="line" id="L2571"> .len = self.len(),</span>
<span class="line" id="L2572"> };</span>
<span class="line" id="L2573"> }</span>
<span class="line" id="L2574"></span>
<span class="line" id="L2575"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">toConst</span>(self: Managed) Const {</span>
<span class="line" id="L2576"> <span class="tok-kw">return</span> .{</span>
<span class="line" id="L2577"> .limbs = self.limbs[<span class="tok-number">0</span>..self.len()],</span>
<span class="line" id="L2578"> .positive = self.isPositive(),</span>
<span class="line" id="L2579"> };</span>
<span class="line" id="L2580"> }</span>
<span class="line" id="L2581"></span>
<span class="line" id="L2582"> <span class="tok-comment">/// Creates a new `Managed` with value `value`.</span></span>
<span class="line" id="L2583"> <span class="tok-comment">///</span></span>
<span class="line" id="L2584"> <span class="tok-comment">/// This is identical to an `init`, followed by a `set`.</span></span>
<span class="line" id="L2585"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">initSet</span>(allocator: Allocator, value: <span class="tok-kw">anytype</span>) !Managed {</span>
<span class="line" id="L2586"> <span class="tok-kw">var</span> s = <span class="tok-kw">try</span> Managed.init(allocator);</span>
<span class="line" id="L2587"> <span class="tok-kw">errdefer</span> s.deinit();</span>
<span class="line" id="L2588"> <span class="tok-kw">try</span> s.set(value);</span>
<span class="line" id="L2589"> <span class="tok-kw">return</span> s;</span>
<span class="line" id="L2590"> }</span>
<span class="line" id="L2591"></span>
<span class="line" id="L2592"> <span class="tok-comment">/// Creates a new Managed with a specific capacity. If capacity < default_capacity then the</span></span>
<span class="line" id="L2593"> <span class="tok-comment">/// default capacity will be used instead.</span></span>
<span class="line" id="L2594"> <span class="tok-comment">/// The integer value after initializing is `0`.</span></span>
<span class="line" id="L2595"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">initCapacity</span>(allocator: Allocator, capacity: <span class="tok-type">usize</span>) !Managed {</span>
<span class="line" id="L2596"> <span class="tok-kw">return</span> Managed{</span>
<span class="line" id="L2597"> .allocator = allocator,</span>
<span class="line" id="L2598"> .metadata = <span class="tok-number">1</span>,</span>
<span class="line" id="L2599"> .limbs = block: {</span>
<span class="line" id="L2600"> <span class="tok-kw">const</span> limbs = <span class="tok-kw">try</span> allocator.alloc(Limb, <span class="tok-builtin">@max</span>(default_capacity, capacity));</span>
<span class="line" id="L2601"> limbs[<span class="tok-number">0</span>] = <span class="tok-number">0</span>;</span>
<span class="line" id="L2602"> <span class="tok-kw">break</span> :block limbs;</span>
<span class="line" id="L2603"> },</span>
<span class="line" id="L2604"> };</span>
<span class="line" id="L2605"> }</span>
<span class="line" id="L2606"></span>
<span class="line" id="L2607"> <span class="tok-comment">/// Returns the number of limbs currently in use.</span></span>
<span class="line" id="L2608"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">len</span>(self: Managed) <span class="tok-type">usize</span> {</span>
<span class="line" id="L2609"> <span class="tok-kw">return</span> self.metadata & ~sign_bit;</span>
<span class="line" id="L2610"> }</span>
<span class="line" id="L2611"></span>
<span class="line" id="L2612"> <span class="tok-comment">/// Returns whether an Managed is positive.</span></span>
<span class="line" id="L2613"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">isPositive</span>(self: Managed) <span class="tok-type">bool</span> {</span>
<span class="line" id="L2614"> <span class="tok-kw">return</span> self.metadata & sign_bit == <span class="tok-number">0</span>;</span>
<span class="line" id="L2615"> }</span>
<span class="line" id="L2616"></span>
<span class="line" id="L2617"> <span class="tok-comment">/// Sets the sign of an Managed.</span></span>
<span class="line" id="L2618"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">setSign</span>(self: *Managed, positive: <span class="tok-type">bool</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L2619"> <span class="tok-kw">if</span> (positive) {</span>
<span class="line" id="L2620"> self.metadata &= ~sign_bit;</span>
<span class="line" id="L2621"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L2622"> self.metadata |= sign_bit;</span>
<span class="line" id="L2623"> }</span>
<span class="line" id="L2624"> }</span>
<span class="line" id="L2625"></span>
<span class="line" id="L2626"> <span class="tok-comment">/// Sets the length of an Managed.</span></span>
<span class="line" id="L2627"> <span class="tok-comment">///</span></span>
<span class="line" id="L2628"> <span class="tok-comment">/// If setLen is used, then the Managed must be normalized to suit.</span></span>
<span class="line" id="L2629"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">setLen</span>(self: *Managed, new_len: <span class="tok-type">usize</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L2630"> self.metadata &= sign_bit;</span>
<span class="line" id="L2631"> self.metadata |= new_len;</span>
<span class="line" id="L2632"> }</span>
<span class="line" id="L2633"></span>
<span class="line" id="L2634"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">setMetadata</span>(self: *Managed, positive: <span class="tok-type">bool</span>, length: <span class="tok-type">usize</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L2635"> self.metadata = <span class="tok-kw">if</span> (positive) length & ~sign_bit <span class="tok-kw">else</span> length | sign_bit;</span>
<span class="line" id="L2636"> }</span>
<span class="line" id="L2637"></span>
<span class="line" id="L2638"> <span class="tok-comment">/// Ensures an Managed has enough space allocated for capacity limbs. If the Managed does not have</span></span>
<span class="line" id="L2639"> <span class="tok-comment">/// sufficient capacity, the exact amount will be allocated. This occurs even if the requested</span></span>
<span class="line" id="L2640"> <span class="tok-comment">/// capacity is only greater than the current capacity by one limb.</span></span>
<span class="line" id="L2641"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">ensureCapacity</span>(self: *Managed, capacity: <span class="tok-type">usize</span>) !<span class="tok-type">void</span> {</span>
<span class="line" id="L2642"> <span class="tok-kw">if</span> (capacity <= self.limbs.len) {</span>
<span class="line" id="L2643"> <span class="tok-kw">return</span>;</span>
<span class="line" id="L2644"> }</span>
<span class="line" id="L2645"> self.limbs = <span class="tok-kw">try</span> self.allocator.realloc(self.limbs, capacity);</span>
<span class="line" id="L2646"> }</span>
<span class="line" id="L2647"></span>
<span class="line" id="L2648"> <span class="tok-comment">/// Frees all associated memory.</span></span>
<span class="line" id="L2649"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">deinit</span>(self: *Managed) <span class="tok-type">void</span> {</span>
<span class="line" id="L2650"> self.allocator.free(self.limbs);</span>
<span class="line" id="L2651"> self.* = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L2652"> }</span>
<span class="line" id="L2653"></span>
<span class="line" id="L2654"> <span class="tok-comment">/// Returns a `Managed` with the same value. The returned `Managed` is a deep copy and</span></span>
<span class="line" id="L2655"> <span class="tok-comment">/// can be modified separately from the original, and its resources are managed</span></span>
<span class="line" id="L2656"> <span class="tok-comment">/// separately from the original.</span></span>
<span class="line" id="L2657"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">clone</span>(other: Managed) !Managed {</span>
<span class="line" id="L2658"> <span class="tok-kw">return</span> other.cloneWithDifferentAllocator(other.allocator);</span>
<span class="line" id="L2659"> }</span>
<span class="line" id="L2660"></span>
<span class="line" id="L2661"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">cloneWithDifferentAllocator</span>(other: Managed, allocator: Allocator) !Managed {</span>
<span class="line" id="L2662"> <span class="tok-kw">return</span> Managed{</span>
<span class="line" id="L2663"> .allocator = allocator,</span>
<span class="line" id="L2664"> .metadata = other.metadata,</span>
<span class="line" id="L2665"> .limbs = block: {</span>
<span class="line" id="L2666"> <span class="tok-kw">const</span> limbs = <span class="tok-kw">try</span> allocator.alloc(Limb, other.len());</span>
<span class="line" id="L2667"> <span class="tok-builtin">@memcpy</span>(limbs, other.limbs[<span class="tok-number">0</span>..other.len()]);</span>
<span class="line" id="L2668"> <span class="tok-kw">break</span> :block limbs;</span>
<span class="line" id="L2669"> },</span>
<span class="line" id="L2670"> };</span>
<span class="line" id="L2671"> }</span>
<span class="line" id="L2672"></span>
<span class="line" id="L2673"> <span class="tok-comment">/// Copies the value of the integer to an existing `Managed` so that they both have the same value.</span></span>
<span class="line" id="L2674"> <span class="tok-comment">/// Extra memory will be allocated if the receiver does not have enough capacity.</span></span>
<span class="line" id="L2675"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">copy</span>(self: *Managed, other: Const) !<span class="tok-type">void</span> {</span>
<span class="line" id="L2676"> <span class="tok-kw">if</span> (self.limbs.ptr == other.limbs.ptr) <span class="tok-kw">return</span>;</span>
<span class="line" id="L2677"></span>
<span class="line" id="L2678"> <span class="tok-kw">try</span> self.ensureCapacity(other.limbs.len);</span>
<span class="line" id="L2679"> <span class="tok-builtin">@memcpy</span>(self.limbs[<span class="tok-number">0</span>..other.limbs.len], other.limbs[<span class="tok-number">0</span>..other.limbs.len]);</span>
<span class="line" id="L2680"> self.setMetadata(other.positive, other.limbs.len);</span>
<span class="line" id="L2681"> }</span>
<span class="line" id="L2682"></span>
<span class="line" id="L2683"> <span class="tok-comment">/// Efficiently swap a `Managed` with another. This swaps the limb pointers and a full copy is not</span></span>
<span class="line" id="L2684"> <span class="tok-comment">/// performed. The address of the limbs field will not be the same after this function.</span></span>
<span class="line" id="L2685"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">swap</span>(self: *Managed, other: *Managed) <span class="tok-type">void</span> {</span>
<span class="line" id="L2686"> mem.swap(Managed, self, other);</span>
<span class="line" id="L2687"> }</span>
<span class="line" id="L2688"></span>
<span class="line" id="L2689"> <span class="tok-comment">/// Debugging tool: prints the state to stderr.</span></span>
<span class="line" id="L2690"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">dump</span>(self: Managed) <span class="tok-type">void</span> {</span>
<span class="line" id="L2691"> <span class="tok-kw">for</span> (self.limbs[<span class="tok-number">0</span>..self.len()]) |limb| {</span>
<span class="line" id="L2692"> std.debug.print(<span class="tok-str">"{x} "</span>, .{limb});</span>
<span class="line" id="L2693"> }</span>
<span class="line" id="L2694"> std.debug.print(<span class="tok-str">"capacity={} positive={}\n"</span>, .{ self.limbs.len, self.isPositive() });</span>
<span class="line" id="L2695"> }</span>
<span class="line" id="L2696"></span>
<span class="line" id="L2697"> <span class="tok-comment">/// Negate the sign.</span></span>
<span class="line" id="L2698"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">negate</span>(self: *Managed) <span class="tok-type">void</span> {</span>
<span class="line" id="L2699"> self.metadata ^= sign_bit;</span>
<span class="line" id="L2700"> }</span>
<span class="line" id="L2701"></span>
<span class="line" id="L2702"> <span class="tok-comment">/// Make positive.</span></span>
<span class="line" id="L2703"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">abs</span>(self: *Managed) <span class="tok-type">void</span> {</span>
<span class="line" id="L2704"> self.metadata &= ~sign_bit;</span>
<span class="line" id="L2705"> }</span>
<span class="line" id="L2706"></span>
<span class="line" id="L2707"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">isOdd</span>(self: Managed) <span class="tok-type">bool</span> {</span>
<span class="line" id="L2708"> <span class="tok-kw">return</span> self.limbs[<span class="tok-number">0</span>] & <span class="tok-number">1</span> != <span class="tok-number">0</span>;</span>
<span class="line" id="L2709"> }</span>
<span class="line" id="L2710"></span>
<span class="line" id="L2711"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">isEven</span>(self: Managed) <span class="tok-type">bool</span> {</span>
<span class="line" id="L2712"> <span class="tok-kw">return</span> !self.isOdd();</span>
<span class="line" id="L2713"> }</span>
<span class="line" id="L2714"></span>
<span class="line" id="L2715"> <span class="tok-comment">/// Returns the number of bits required to represent the absolute value of an integer.</span></span>
<span class="line" id="L2716"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">bitCountAbs</span>(self: Managed) <span class="tok-type">usize</span> {</span>
<span class="line" id="L2717"> <span class="tok-kw">return</span> self.toConst().bitCountAbs();</span>
<span class="line" id="L2718"> }</span>
<span class="line" id="L2719"></span>
<span class="line" id="L2720"> <span class="tok-comment">/// Returns the number of bits required to represent the integer in twos-complement form.</span></span>
<span class="line" id="L2721"> <span class="tok-comment">///</span></span>
<span class="line" id="L2722"> <span class="tok-comment">/// If the integer is negative the value returned is the number of bits needed by a signed</span></span>
<span class="line" id="L2723"> <span class="tok-comment">/// integer to represent the value. If positive the value is the number of bits for an</span></span>
<span class="line" id="L2724"> <span class="tok-comment">/// unsigned integer. Any unsigned integer will fit in the signed integer with bitcount</span></span>
<span class="line" id="L2725"> <span class="tok-comment">/// one greater than the returned value.</span></span>
<span class="line" id="L2726"> <span class="tok-comment">///</span></span>
<span class="line" id="L2727"> <span class="tok-comment">/// e.g. -127 returns 8 as it will fit in an i8. 127 returns 7 since it fits in a u7.</span></span>
<span class="line" id="L2728"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">bitCountTwosComp</span>(self: Managed) <span class="tok-type">usize</span> {</span>
<span class="line" id="L2729"> <span class="tok-kw">return</span> self.toConst().bitCountTwosComp();</span>
<span class="line" id="L2730"> }</span>
<span class="line" id="L2731"></span>
<span class="line" id="L2732"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">fitsInTwosComp</span>(self: Managed, signedness: Signedness, bit_count: <span class="tok-type">usize</span>) <span class="tok-type">bool</span> {</span>
<span class="line" id="L2733"> <span class="tok-kw">return</span> self.toConst().fitsInTwosComp(signedness, bit_count);</span>
<span class="line" id="L2734"> }</span>
<span class="line" id="L2735"></span>
<span class="line" id="L2736"> <span class="tok-comment">/// Returns whether self can fit into an integer of the requested type.</span></span>
<span class="line" id="L2737"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">fits</span>(self: Managed, <span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>) <span class="tok-type">bool</span> {</span>
<span class="line" id="L2738"> <span class="tok-kw">return</span> self.toConst().fits(T);</span>
<span class="line" id="L2739"> }</span>
<span class="line" id="L2740"></span>
<span class="line" id="L2741"> <span class="tok-comment">/// Returns the approximate size of the integer in the given base. Negative values accommodate for</span></span>
<span class="line" id="L2742"> <span class="tok-comment">/// the minus sign. This is used for determining the number of characters needed to print the</span></span>
<span class="line" id="L2743"> <span class="tok-comment">/// value. It is inexact and may exceed the given value by ~1-2 bytes.</span></span>
<span class="line" id="L2744"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">sizeInBaseUpperBound</span>(self: Managed, base: <span class="tok-type">usize</span>) <span class="tok-type">usize</span> {</span>
<span class="line" id="L2745"> <span class="tok-kw">return</span> self.toConst().sizeInBaseUpperBound(base);</span>
<span class="line" id="L2746"> }</span>
<span class="line" id="L2747"></span>
<span class="line" id="L2748"> <span class="tok-comment">/// Sets an Managed to value. Value must be an primitive integer type.</span></span>
<span class="line" id="L2749"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">set</span>(self: *Managed, value: <span class="tok-kw">anytype</span>) Allocator.Error!<span class="tok-type">void</span> {</span>
<span class="line" id="L2750"> <span class="tok-kw">try</span> self.ensureCapacity(calcLimbLen(value));</span>
<span class="line" id="L2751"> <span class="tok-kw">var</span> m = self.toMutable();</span>
<span class="line" id="L2752"> m.set(value);</span>
<span class="line" id="L2753"> self.setMetadata(m.positive, m.len);</span>
<span class="line" id="L2754"> }</span>
<span class="line" id="L2755"></span>
<span class="line" id="L2756"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> ConvertError = Const.ConvertError;</span>
<span class="line" id="L2757"></span>
<span class="line" id="L2758"> <span class="tok-comment">/// Convert self to type T.</span></span>
<span class="line" id="L2759"> <span class="tok-comment">///</span></span>
<span class="line" id="L2760"> <span class="tok-comment">/// Returns an error if self cannot be narrowed into the requested type without truncation.</span></span>
<span class="line" id="L2761"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">to</span>(self: Managed, <span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>) ConvertError!T {</span>
<span class="line" id="L2762"> <span class="tok-kw">return</span> self.toConst().to(T);</span>
<span class="line" id="L2763"> }</span>
<span class="line" id="L2764"></span>
<span class="line" id="L2765"> <span class="tok-comment">/// Set self from the string representation `value`.</span></span>
<span class="line" id="L2766"> <span class="tok-comment">///</span></span>
<span class="line" id="L2767"> <span class="tok-comment">/// `value` must contain only digits <= `base` and is case insensitive. Base prefixes are</span></span>
<span class="line" id="L2768"> <span class="tok-comment">/// not allowed (e.g. 0x43 should simply be 43). Underscores in the input string are</span></span>
<span class="line" id="L2769"> <span class="tok-comment">/// ignored and can be used as digit separators.</span></span>
<span class="line" id="L2770"> <span class="tok-comment">///</span></span>
<span class="line" id="L2771"> <span class="tok-comment">/// Returns an error if memory could not be allocated or `value` has invalid digits for the</span></span>
<span class="line" id="L2772"> <span class="tok-comment">/// requested base.</span></span>
<span class="line" id="L2773"> <span class="tok-comment">///</span></span>
<span class="line" id="L2774"> <span class="tok-comment">/// self's allocator is used for temporary storage to boost multiplication performance.</span></span>
<span class="line" id="L2775"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">setString</span>(self: *Managed, base: <span class="tok-type">u8</span>, value: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) !<span class="tok-type">void</span> {</span>
<span class="line" id="L2776"> <span class="tok-kw">if</span> (base < <span class="tok-number">2</span> <span class="tok-kw">or</span> base > <span class="tok-number">16</span>) <span class="tok-kw">return</span> <span class="tok-kw">error</span>.InvalidBase;</span>
<span class="line" id="L2777"> <span class="tok-kw">try</span> self.ensureCapacity(calcSetStringLimbCount(base, value.len));</span>
<span class="line" id="L2778"> <span class="tok-kw">const</span> limbs_buffer = <span class="tok-kw">try</span> self.allocator.alloc(Limb, calcSetStringLimbsBufferLen(base, value.len));</span>
<span class="line" id="L2779"> <span class="tok-kw">defer</span> self.allocator.free(limbs_buffer);</span>
<span class="line" id="L2780"> <span class="tok-kw">var</span> m = self.toMutable();</span>
<span class="line" id="L2781"> <span class="tok-kw">try</span> m.setString(base, value, limbs_buffer, self.allocator);</span>
<span class="line" id="L2782"> self.setMetadata(m.positive, m.len);</span>
<span class="line" id="L2783"> }</span>
<span class="line" id="L2784"></span>
<span class="line" id="L2785"> <span class="tok-comment">/// Set self to either bound of a 2s-complement integer.</span></span>
<span class="line" id="L2786"> <span class="tok-comment">/// Note: The result is still sign-magnitude, not twos complement! In order to convert the</span></span>
<span class="line" id="L2787"> <span class="tok-comment">/// result to twos complement, it is sufficient to take the absolute value.</span></span>
<span class="line" id="L2788"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">setTwosCompIntLimit</span>(</span>
<span class="line" id="L2789"> r: *Managed,</span>
<span class="line" id="L2790"> limit: TwosCompIntLimit,</span>
<span class="line" id="L2791"> signedness: Signedness,</span>
<span class="line" id="L2792"> bit_count: <span class="tok-type">usize</span>,</span>
<span class="line" id="L2793"> ) !<span class="tok-type">void</span> {</span>
<span class="line" id="L2794"> <span class="tok-kw">try</span> r.ensureCapacity(calcTwosCompLimbCount(bit_count));</span>
<span class="line" id="L2795"> <span class="tok-kw">var</span> m = r.toMutable();</span>
<span class="line" id="L2796"> m.setTwosCompIntLimit(limit, signedness, bit_count);</span>
<span class="line" id="L2797"> r.setMetadata(m.positive, m.len);</span>
<span class="line" id="L2798"> }</span>
<span class="line" id="L2799"></span>
<span class="line" id="L2800"> <span class="tok-comment">/// Converts self to a string in the requested base. Memory is allocated from the provided</span></span>
<span class="line" id="L2801"> <span class="tok-comment">/// allocator and not the one present in self.</span></span>
<span class="line" id="L2802"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">toString</span>(self: Managed, allocator: Allocator, base: <span class="tok-type">u8</span>, case: std.fmt.Case) ![]<span class="tok-type">u8</span> {</span>
<span class="line" id="L2803"> <span class="tok-kw">if</span> (base < <span class="tok-number">2</span> <span class="tok-kw">or</span> base > <span class="tok-number">16</span>) <span class="tok-kw">return</span> <span class="tok-kw">error</span>.InvalidBase;</span>
<span class="line" id="L2804"> <span class="tok-kw">return</span> self.toConst().toStringAlloc(allocator, base, case);</span>
<span class="line" id="L2805"> }</span>
<span class="line" id="L2806"></span>
<span class="line" id="L2807"> <span class="tok-comment">/// To allow `std.fmt.format` to work with `Managed`.</span></span>
<span class="line" id="L2808"> <span class="tok-comment">/// If the integer is larger than `pow(2, 64 * @sizeOf(usize) * 8), this function will fail</span></span>
<span class="line" id="L2809"> <span class="tok-comment">/// to print the string, printing "(BigInt)" instead of a number.</span></span>
<span class="line" id="L2810"> <span class="tok-comment">/// This is because the rendering algorithm requires reversing a string, which requires O(N) memory.</span></span>
<span class="line" id="L2811"> <span class="tok-comment">/// See `toString` and `toStringAlloc` for a way to print big integers without failure.</span></span>
<span class="line" id="L2812"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">format</span>(</span>
<span class="line" id="L2813"> self: Managed,</span>
<span class="line" id="L2814"> <span class="tok-kw">comptime</span> fmt: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L2815"> options: std.fmt.FormatOptions,</span>
<span class="line" id="L2816"> out_stream: <span class="tok-kw">anytype</span>,</span>
<span class="line" id="L2817"> ) !<span class="tok-type">void</span> {</span>
<span class="line" id="L2818"> <span class="tok-kw">return</span> self.toConst().format(fmt, options, out_stream);</span>
<span class="line" id="L2819"> }</span>
<span class="line" id="L2820"></span>
<span class="line" id="L2821"> <span class="tok-comment">/// Returns math.Order.lt, math.Order.eq, math.Order.gt if |a| < |b|, |a| ==</span></span>
<span class="line" id="L2822"> <span class="tok-comment">/// |b| or |a| > |b| respectively.</span></span>
<span class="line" id="L2823"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">orderAbs</span>(a: Managed, b: Managed) math.Order {</span>
<span class="line" id="L2824"> <span class="tok-kw">return</span> a.toConst().orderAbs(b.toConst());</span>
<span class="line" id="L2825"> }</span>
<span class="line" id="L2826"></span>
<span class="line" id="L2827"> <span class="tok-comment">/// Returns math.Order.lt, math.Order.eq, math.Order.gt if a < b, a == b or a</span></span>
<span class="line" id="L2828"> <span class="tok-comment">/// > b respectively.</span></span>
<span class="line" id="L2829"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">order</span>(a: Managed, b: Managed) math.Order {</span>
<span class="line" id="L2830"> <span class="tok-kw">return</span> a.toConst().order(b.toConst());</span>
<span class="line" id="L2831"> }</span>
<span class="line" id="L2832"></span>
<span class="line" id="L2833"> <span class="tok-comment">// TODO: remove after release of 0.11</span>
</span>
<span class="line" id="L2834"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> eqZero = <span class="tok-builtin">@compileError</span>(<span class="tok-str">"use eqlZero"</span>);</span>
<span class="line" id="L2835"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> eqAbs = <span class="tok-builtin">@compileError</span>(<span class="tok-str">"use eqlAbs"</span>);</span>
<span class="line" id="L2836"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> eq = <span class="tok-builtin">@compileError</span>(<span class="tok-str">"use eql"</span>);</span>
<span class="line" id="L2837"></span>
<span class="line" id="L2838"> <span class="tok-comment">/// Returns true if a == 0.</span></span>
<span class="line" id="L2839"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">eqlZero</span>(a: Managed) <span class="tok-type">bool</span> {</span>
<span class="line" id="L2840"> <span class="tok-kw">return</span> a.toConst().eqlZero();</span>
<span class="line" id="L2841"> }</span>
<span class="line" id="L2842"></span>
<span class="line" id="L2843"> <span class="tok-comment">/// Returns true if |a| == |b|.</span></span>
<span class="line" id="L2844"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">eqlAbs</span>(a: Managed, b: Managed) <span class="tok-type">bool</span> {</span>
<span class="line" id="L2845"> <span class="tok-kw">return</span> a.toConst().eqlAbs(b.toConst());</span>
<span class="line" id="L2846"> }</span>
<span class="line" id="L2847"></span>
<span class="line" id="L2848"> <span class="tok-comment">/// Returns true if a == b.</span></span>
<span class="line" id="L2849"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">eql</span>(a: Managed, b: Managed) <span class="tok-type">bool</span> {</span>
<span class="line" id="L2850"> <span class="tok-kw">return</span> a.toConst().eql(b.toConst());</span>
<span class="line" id="L2851"> }</span>
<span class="line" id="L2852"></span>
<span class="line" id="L2853"> <span class="tok-comment">/// Normalize a possible sequence of leading zeros.</span></span>
<span class="line" id="L2854"> <span class="tok-comment">///</span></span>
<span class="line" id="L2855"> <span class="tok-comment">/// [1, 2, 3, 4, 0] -> [1, 2, 3, 4]</span></span>
<span class="line" id="L2856"> <span class="tok-comment">/// [1, 2, 0, 0, 0] -> [1, 2]</span></span>
<span class="line" id="L2857"> <span class="tok-comment">/// [0, 0, 0, 0, 0] -> [0]</span></span>
<span class="line" id="L2858"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">normalize</span>(r: *Managed, length: <span class="tok-type">usize</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L2859"> assert(length > <span class="tok-number">0</span>);</span>
<span class="line" id="L2860"> assert(length <= r.limbs.len);</span>
<span class="line" id="L2861"></span>
<span class="line" id="L2862"> <span class="tok-kw">var</span> j = length;</span>
<span class="line" id="L2863"> <span class="tok-kw">while</span> (j > <span class="tok-number">0</span>) : (j -= <span class="tok-number">1</span>) {</span>
<span class="line" id="L2864"> <span class="tok-kw">if</span> (r.limbs[j - <span class="tok-number">1</span>] != <span class="tok-number">0</span>) {</span>
<span class="line" id="L2865"> <span class="tok-kw">break</span>;</span>
<span class="line" id="L2866"> }</span>
<span class="line" id="L2867"> }</span>
<span class="line" id="L2868"></span>
<span class="line" id="L2869"> <span class="tok-comment">// Handle zero</span>
</span>
<span class="line" id="L2870"> r.setLen(<span class="tok-kw">if</span> (j != <span class="tok-number">0</span>) j <span class="tok-kw">else</span> <span class="tok-number">1</span>);</span>
<span class="line" id="L2871"> }</span>
<span class="line" id="L2872"></span>
<span class="line" id="L2873"> <span class="tok-comment">/// r = a + scalar</span></span>
<span class="line" id="L2874"> <span class="tok-comment">///</span></span>
<span class="line" id="L2875"> <span class="tok-comment">/// r and a may be aliases.</span></span>
<span class="line" id="L2876"> <span class="tok-comment">///</span></span>
<span class="line" id="L2877"> <span class="tok-comment">/// Returns an error if memory could not be allocated.</span></span>
<span class="line" id="L2878"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addScalar</span>(r: *Managed, a: *<span class="tok-kw">const</span> Managed, scalar: <span class="tok-kw">anytype</span>) Allocator.Error!<span class="tok-type">void</span> {</span>
<span class="line" id="L2879"> <span class="tok-kw">try</span> r.ensureAddScalarCapacity(a.toConst(), scalar);</span>
<span class="line" id="L2880"> <span class="tok-kw">var</span> m = r.toMutable();</span>
<span class="line" id="L2881"> m.addScalar(a.toConst(), scalar);</span>
<span class="line" id="L2882"> r.setMetadata(m.positive, m.len);</span>
<span class="line" id="L2883"> }</span>
<span class="line" id="L2884"></span>
<span class="line" id="L2885"> <span class="tok-comment">/// r = a + b</span></span>
<span class="line" id="L2886"> <span class="tok-comment">///</span></span>
<span class="line" id="L2887"> <span class="tok-comment">/// r, a and b may be aliases.</span></span>
<span class="line" id="L2888"> <span class="tok-comment">///</span></span>
<span class="line" id="L2889"> <span class="tok-comment">/// Returns an error if memory could not be allocated.</span></span>
<span class="line" id="L2890"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">add</span>(r: *Managed, a: *<span class="tok-kw">const</span> Managed, b: *<span class="tok-kw">const</span> Managed) Allocator.Error!<span class="tok-type">void</span> {</span>
<span class="line" id="L2891"> <span class="tok-kw">try</span> r.ensureAddCapacity(a.toConst(), b.toConst());</span>
<span class="line" id="L2892"> <span class="tok-kw">var</span> m = r.toMutable();</span>
<span class="line" id="L2893"> m.add(a.toConst(), b.toConst());</span>
<span class="line" id="L2894"> r.setMetadata(m.positive, m.len);</span>
<span class="line" id="L2895"> }</span>
<span class="line" id="L2896"></span>
<span class="line" id="L2897"> <span class="tok-comment">/// r = a + b with 2s-complement wrapping semantics. Returns whether any overflow occurred.</span></span>
<span class="line" id="L2898"> <span class="tok-comment">///</span></span>
<span class="line" id="L2899"> <span class="tok-comment">/// r, a and b may be aliases.</span></span>
<span class="line" id="L2900"> <span class="tok-comment">///</span></span>
<span class="line" id="L2901"> <span class="tok-comment">/// Returns an error if memory could not be allocated.</span></span>
<span class="line" id="L2902"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addWrap</span>(</span>
<span class="line" id="L2903"> r: *Managed,</span>
<span class="line" id="L2904"> a: *<span class="tok-kw">const</span> Managed,</span>
<span class="line" id="L2905"> b: *<span class="tok-kw">const</span> Managed,</span>
<span class="line" id="L2906"> signedness: Signedness,</span>
<span class="line" id="L2907"> bit_count: <span class="tok-type">usize</span>,</span>
<span class="line" id="L2908"> ) Allocator.Error!<span class="tok-type">bool</span> {</span>
<span class="line" id="L2909"> <span class="tok-kw">try</span> r.ensureTwosCompCapacity(bit_count);</span>
<span class="line" id="L2910"> <span class="tok-kw">var</span> m = r.toMutable();</span>
<span class="line" id="L2911"> <span class="tok-kw">const</span> wrapped = m.addWrap(a.toConst(), b.toConst(), signedness, bit_count);</span>
<span class="line" id="L2912"> r.setMetadata(m.positive, m.len);</span>
<span class="line" id="L2913"> <span class="tok-kw">return</span> wrapped;</span>
<span class="line" id="L2914"> }</span>
<span class="line" id="L2915"></span>
<span class="line" id="L2916"> <span class="tok-comment">/// r = a + b with 2s-complement saturating semantics.</span></span>
<span class="line" id="L2917"> <span class="tok-comment">///</span></span>
<span class="line" id="L2918"> <span class="tok-comment">/// r, a and b may be aliases.</span></span>
<span class="line" id="L2919"> <span class="tok-comment">///</span></span>
<span class="line" id="L2920"> <span class="tok-comment">/// Returns an error if memory could not be allocated.</span></span>
<span class="line" id="L2921"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addSat</span>(r: *Managed, a: *<span class="tok-kw">const</span> Managed, b: *<span class="tok-kw">const</span> Managed, signedness: Signedness, bit_count: <span class="tok-type">usize</span>) Allocator.Error!<span class="tok-type">void</span> {</span>
<span class="line" id="L2922"> <span class="tok-kw">try</span> r.ensureTwosCompCapacity(bit_count);</span>
<span class="line" id="L2923"> <span class="tok-kw">var</span> m = r.toMutable();</span>
<span class="line" id="L2924"> m.addSat(a.toConst(), b.toConst(), signedness, bit_count);</span>
<span class="line" id="L2925"> r.setMetadata(m.positive, m.len);</span>
<span class="line" id="L2926"> }</span>
<span class="line" id="L2927"></span>
<span class="line" id="L2928"> <span class="tok-comment">/// r = a - b</span></span>
<span class="line" id="L2929"> <span class="tok-comment">///</span></span>
<span class="line" id="L2930"> <span class="tok-comment">/// r, a and b may be aliases.</span></span>
<span class="line" id="L2931"> <span class="tok-comment">///</span></span>
<span class="line" id="L2932"> <span class="tok-comment">/// Returns an error if memory could not be allocated.</span></span>
<span class="line" id="L2933"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">sub</span>(r: *Managed, a: *<span class="tok-kw">const</span> Managed, b: *<span class="tok-kw">const</span> Managed) !<span class="tok-type">void</span> {</span>
<span class="line" id="L2934"> <span class="tok-kw">try</span> r.ensureCapacity(<span class="tok-builtin">@max</span>(a.len(), b.len()) + <span class="tok-number">1</span>);</span>
<span class="line" id="L2935"> <span class="tok-kw">var</span> m = r.toMutable();</span>
<span class="line" id="L2936"> m.sub(a.toConst(), b.toConst());</span>
<span class="line" id="L2937"> r.setMetadata(m.positive, m.len);</span>
<span class="line" id="L2938"> }</span>
<span class="line" id="L2939"></span>
<span class="line" id="L2940"> <span class="tok-comment">/// r = a - b with 2s-complement wrapping semantics. Returns whether any overflow occurred.</span></span>
<span class="line" id="L2941"> <span class="tok-comment">///</span></span>
<span class="line" id="L2942"> <span class="tok-comment">/// r, a and b may be aliases.</span></span>
<span class="line" id="L2943"> <span class="tok-comment">///</span></span>
<span class="line" id="L2944"> <span class="tok-comment">/// Returns an error if memory could not be allocated.</span></span>
<span class="line" id="L2945"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">subWrap</span>(</span>
<span class="line" id="L2946"> r: *Managed,</span>
<span class="line" id="L2947"> a: *<span class="tok-kw">const</span> Managed,</span>
<span class="line" id="L2948"> b: *<span class="tok-kw">const</span> Managed,</span>
<span class="line" id="L2949"> signedness: Signedness,</span>
<span class="line" id="L2950"> bit_count: <span class="tok-type">usize</span>,</span>
<span class="line" id="L2951"> ) Allocator.Error!<span class="tok-type">bool</span> {</span>
<span class="line" id="L2952"> <span class="tok-kw">try</span> r.ensureTwosCompCapacity(bit_count);</span>
<span class="line" id="L2953"> <span class="tok-kw">var</span> m = r.toMutable();</span>
<span class="line" id="L2954"> <span class="tok-kw">const</span> wrapped = m.subWrap(a.toConst(), b.toConst(), signedness, bit_count);</span>
<span class="line" id="L2955"> r.setMetadata(m.positive, m.len);</span>
<span class="line" id="L2956"> <span class="tok-kw">return</span> wrapped;</span>
<span class="line" id="L2957"> }</span>
<span class="line" id="L2958"></span>
<span class="line" id="L2959"> <span class="tok-comment">/// r = a - b with 2s-complement saturating semantics.</span></span>
<span class="line" id="L2960"> <span class="tok-comment">///</span></span>
<span class="line" id="L2961"> <span class="tok-comment">/// r, a and b may be aliases.</span></span>
<span class="line" id="L2962"> <span class="tok-comment">///</span></span>
<span class="line" id="L2963"> <span class="tok-comment">/// Returns an error if memory could not be allocated.</span></span>
<span class="line" id="L2964"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">subSat</span>(</span>
<span class="line" id="L2965"> r: *Managed,</span>
<span class="line" id="L2966"> a: *<span class="tok-kw">const</span> Managed,</span>
<span class="line" id="L2967"> b: *<span class="tok-kw">const</span> Managed,</span>
<span class="line" id="L2968"> signedness: Signedness,</span>
<span class="line" id="L2969"> bit_count: <span class="tok-type">usize</span>,</span>
<span class="line" id="L2970"> ) Allocator.Error!<span class="tok-type">void</span> {</span>
<span class="line" id="L2971"> <span class="tok-kw">try</span> r.ensureTwosCompCapacity(bit_count);</span>
<span class="line" id="L2972"> <span class="tok-kw">var</span> m = r.toMutable();</span>
<span class="line" id="L2973"> m.subSat(a.toConst(), b.toConst(), signedness, bit_count);</span>
<span class="line" id="L2974"> r.setMetadata(m.positive, m.len);</span>
<span class="line" id="L2975"> }</span>
<span class="line" id="L2976"></span>
<span class="line" id="L2977"> <span class="tok-comment">/// rma = a * b</span></span>
<span class="line" id="L2978"> <span class="tok-comment">///</span></span>
<span class="line" id="L2979"> <span class="tok-comment">/// rma, a and b may be aliases. However, it is more efficient if rma does not alias a or b.</span></span>
<span class="line" id="L2980"> <span class="tok-comment">///</span></span>
<span class="line" id="L2981"> <span class="tok-comment">/// Returns an error if memory could not be allocated.</span></span>
<span class="line" id="L2982"> <span class="tok-comment">///</span></span>
<span class="line" id="L2983"> <span class="tok-comment">/// rma's allocator is used for temporary storage to speed up the multiplication.</span></span>
<span class="line" id="L2984"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">mul</span>(rma: *Managed, a: *<span class="tok-kw">const</span> Managed, b: *<span class="tok-kw">const</span> Managed) !<span class="tok-type">void</span> {</span>
<span class="line" id="L2985"> <span class="tok-kw">var</span> alias_count: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L2986"> <span class="tok-kw">if</span> (rma.limbs.ptr == a.limbs.ptr)</span>
<span class="line" id="L2987"> alias_count += <span class="tok-number">1</span>;</span>
<span class="line" id="L2988"> <span class="tok-kw">if</span> (rma.limbs.ptr == b.limbs.ptr)</span>
<span class="line" id="L2989"> alias_count += <span class="tok-number">1</span>;</span>
<span class="line" id="L2990"> <span class="tok-kw">try</span> rma.ensureMulCapacity(a.toConst(), b.toConst());</span>
<span class="line" id="L2991"> <span class="tok-kw">var</span> m = rma.toMutable();</span>
<span class="line" id="L2992"> <span class="tok-kw">if</span> (alias_count == <span class="tok-number">0</span>) {</span>
<span class="line" id="L2993"> m.mulNoAlias(a.toConst(), b.toConst(), rma.allocator);</span>
<span class="line" id="L2994"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L2995"> <span class="tok-kw">const</span> limb_count = calcMulLimbsBufferLen(a.len(), b.len(), alias_count);</span>
<span class="line" id="L2996"> <span class="tok-kw">const</span> limbs_buffer = <span class="tok-kw">try</span> rma.allocator.alloc(Limb, limb_count);</span>
<span class="line" id="L2997"> <span class="tok-kw">defer</span> rma.allocator.free(limbs_buffer);</span>
<span class="line" id="L2998"> m.mul(a.toConst(), b.toConst(), limbs_buffer, rma.allocator);</span>
<span class="line" id="L2999"> }</span>
<span class="line" id="L3000"> rma.setMetadata(m.positive, m.len);</span>
<span class="line" id="L3001"> }</span>
<span class="line" id="L3002"></span>
<span class="line" id="L3003"> <span class="tok-comment">/// rma = a * b with 2s-complement wrapping semantics.</span></span>
<span class="line" id="L3004"> <span class="tok-comment">///</span></span>
<span class="line" id="L3005"> <span class="tok-comment">/// rma, a and b may be aliases. However, it is more efficient if rma does not alias a or b.</span></span>
<span class="line" id="L3006"> <span class="tok-comment">///</span></span>
<span class="line" id="L3007"> <span class="tok-comment">/// Returns an error if memory could not be allocated.</span></span>
<span class="line" id="L3008"> <span class="tok-comment">///</span></span>
<span class="line" id="L3009"> <span class="tok-comment">/// rma's allocator is used for temporary storage to speed up the multiplication.</span></span>
<span class="line" id="L3010"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">mulWrap</span>(</span>
<span class="line" id="L3011"> rma: *Managed,</span>
<span class="line" id="L3012"> a: *<span class="tok-kw">const</span> Managed,</span>
<span class="line" id="L3013"> b: *<span class="tok-kw">const</span> Managed,</span>
<span class="line" id="L3014"> signedness: Signedness,</span>
<span class="line" id="L3015"> bit_count: <span class="tok-type">usize</span>,</span>
<span class="line" id="L3016"> ) !<span class="tok-type">void</span> {</span>
<span class="line" id="L3017"> <span class="tok-kw">var</span> alias_count: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L3018"> <span class="tok-kw">if</span> (rma.limbs.ptr == a.limbs.ptr)</span>
<span class="line" id="L3019"> alias_count += <span class="tok-number">1</span>;</span>
<span class="line" id="L3020"> <span class="tok-kw">if</span> (rma.limbs.ptr == b.limbs.ptr)</span>
<span class="line" id="L3021"> alias_count += <span class="tok-number">1</span>;</span>
<span class="line" id="L3022"></span>
<span class="line" id="L3023"> <span class="tok-kw">try</span> rma.ensureTwosCompCapacity(bit_count);</span>
<span class="line" id="L3024"> <span class="tok-kw">var</span> m = rma.toMutable();</span>
<span class="line" id="L3025"> <span class="tok-kw">if</span> (alias_count == <span class="tok-number">0</span>) {</span>
<span class="line" id="L3026"> m.mulWrapNoAlias(a.toConst(), b.toConst(), signedness, bit_count, rma.allocator);</span>
<span class="line" id="L3027"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L3028"> <span class="tok-kw">const</span> limb_count = calcMulWrapLimbsBufferLen(bit_count, a.len(), b.len(), alias_count);</span>
<span class="line" id="L3029"> <span class="tok-kw">const</span> limbs_buffer = <span class="tok-kw">try</span> rma.allocator.alloc(Limb, limb_count);</span>
<span class="line" id="L3030"> <span class="tok-kw">defer</span> rma.allocator.free(limbs_buffer);</span>
<span class="line" id="L3031"> m.mulWrap(a.toConst(), b.toConst(), signedness, bit_count, limbs_buffer, rma.allocator);</span>
<span class="line" id="L3032"> }</span>
<span class="line" id="L3033"> rma.setMetadata(m.positive, m.len);</span>
<span class="line" id="L3034"> }</span>
<span class="line" id="L3035"></span>
<span class="line" id="L3036"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">ensureTwosCompCapacity</span>(r: *Managed, bit_count: <span class="tok-type">usize</span>) !<span class="tok-type">void</span> {</span>
<span class="line" id="L3037"> <span class="tok-kw">try</span> r.ensureCapacity(calcTwosCompLimbCount(bit_count));</span>
<span class="line" id="L3038"> }</span>
<span class="line" id="L3039"></span>
<span class="line" id="L3040"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">ensureAddScalarCapacity</span>(r: *Managed, a: Const, scalar: <span class="tok-kw">anytype</span>) !<span class="tok-type">void</span> {</span>
<span class="line" id="L3041"> <span class="tok-kw">try</span> r.ensureCapacity(<span class="tok-builtin">@max</span>(a.limbs.len, calcLimbLen(scalar)) + <span class="tok-number">1</span>);</span>
<span class="line" id="L3042"> }</span>
<span class="line" id="L3043"></span>
<span class="line" id="L3044"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">ensureAddCapacity</span>(r: *Managed, a: Const, b: Const) !<span class="tok-type">void</span> {</span>
<span class="line" id="L3045"> <span class="tok-kw">try</span> r.ensureCapacity(<span class="tok-builtin">@max</span>(a.limbs.len, b.limbs.len) + <span class="tok-number">1</span>);</span>
<span class="line" id="L3046"> }</span>
<span class="line" id="L3047"></span>
<span class="line" id="L3048"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">ensureMulCapacity</span>(rma: *Managed, a: Const, b: Const) !<span class="tok-type">void</span> {</span>
<span class="line" id="L3049"> <span class="tok-kw">try</span> rma.ensureCapacity(a.limbs.len + b.limbs.len + <span class="tok-number">1</span>);</span>
<span class="line" id="L3050"> }</span>
<span class="line" id="L3051"></span>
<span class="line" id="L3052"> <span class="tok-comment">/// q = a / b (rem r)</span></span>
<span class="line" id="L3053"> <span class="tok-comment">///</span></span>
<span class="line" id="L3054"> <span class="tok-comment">/// a / b are floored (rounded towards 0).</span></span>
<span class="line" id="L3055"> <span class="tok-comment">///</span></span>
<span class="line" id="L3056"> <span class="tok-comment">/// Returns an error if memory could not be allocated.</span></span>
<span class="line" id="L3057"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">divFloor</span>(q: *Managed, r: *Managed, a: *<span class="tok-kw">const</span> Managed, b: *<span class="tok-kw">const</span> Managed) !<span class="tok-type">void</span> {</span>
<span class="line" id="L3058"> <span class="tok-kw">try</span> q.ensureCapacity(a.len());</span>
<span class="line" id="L3059"> <span class="tok-kw">try</span> r.ensureCapacity(b.len());</span>
<span class="line" id="L3060"> <span class="tok-kw">var</span> mq = q.toMutable();</span>
<span class="line" id="L3061"> <span class="tok-kw">var</span> mr = r.toMutable();</span>
<span class="line" id="L3062"> <span class="tok-kw">const</span> limbs_buffer = <span class="tok-kw">try</span> q.allocator.alloc(Limb, calcDivLimbsBufferLen(a.len(), b.len()));</span>
<span class="line" id="L3063"> <span class="tok-kw">defer</span> q.allocator.free(limbs_buffer);</span>
<span class="line" id="L3064"> mq.divFloor(&mr, a.toConst(), b.toConst(), limbs_buffer);</span>
<span class="line" id="L3065"> q.setMetadata(mq.positive, mq.len);</span>
<span class="line" id="L3066"> r.setMetadata(mr.positive, mr.len);</span>
<span class="line" id="L3067"> }</span>
<span class="line" id="L3068"></span>
<span class="line" id="L3069"> <span class="tok-comment">/// q = a / b (rem r)</span></span>
<span class="line" id="L3070"> <span class="tok-comment">///</span></span>
<span class="line" id="L3071"> <span class="tok-comment">/// a / b are truncated (rounded towards -inf).</span></span>
<span class="line" id="L3072"> <span class="tok-comment">///</span></span>
<span class="line" id="L3073"> <span class="tok-comment">/// Returns an error if memory could not be allocated.</span></span>
<span class="line" id="L3074"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">divTrunc</span>(q: *Managed, r: *Managed, a: *<span class="tok-kw">const</span> Managed, b: *<span class="tok-kw">const</span> Managed) !<span class="tok-type">void</span> {</span>
<span class="line" id="L3075"> <span class="tok-kw">try</span> q.ensureCapacity(a.len());</span>
<span class="line" id="L3076"> <span class="tok-kw">try</span> r.ensureCapacity(b.len());</span>
<span class="line" id="L3077"> <span class="tok-kw">var</span> mq = q.toMutable();</span>
<span class="line" id="L3078"> <span class="tok-kw">var</span> mr = r.toMutable();</span>
<span class="line" id="L3079"> <span class="tok-kw">const</span> limbs_buffer = <span class="tok-kw">try</span> q.allocator.alloc(Limb, calcDivLimbsBufferLen(a.len(), b.len()));</span>
<span class="line" id="L3080"> <span class="tok-kw">defer</span> q.allocator.free(limbs_buffer);</span>
<span class="line" id="L3081"> mq.divTrunc(&mr, a.toConst(), b.toConst(), limbs_buffer);</span>
<span class="line" id="L3082"> q.setMetadata(mq.positive, mq.len);</span>
<span class="line" id="L3083"> r.setMetadata(mr.positive, mr.len);</span>
<span class="line" id="L3084"> }</span>
<span class="line" id="L3085"></span>
<span class="line" id="L3086"> <span class="tok-comment">/// r = a << shift, in other words, r = a * 2^shift</span></span>
<span class="line" id="L3087"> <span class="tok-comment">/// r and a may alias.</span></span>
<span class="line" id="L3088"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">shiftLeft</span>(r: *Managed, a: *<span class="tok-kw">const</span> Managed, shift: <span class="tok-type">usize</span>) !<span class="tok-type">void</span> {</span>
<span class="line" id="L3089"> <span class="tok-kw">try</span> r.ensureCapacity(a.len() + (shift / limb_bits) + <span class="tok-number">1</span>);</span>
<span class="line" id="L3090"> <span class="tok-kw">var</span> m = r.toMutable();</span>
<span class="line" id="L3091"> m.shiftLeft(a.toConst(), shift);</span>
<span class="line" id="L3092"> r.setMetadata(m.positive, m.len);</span>
<span class="line" id="L3093"> }</span>
<span class="line" id="L3094"></span>
<span class="line" id="L3095"> <span class="tok-comment">/// r = a <<| shift with 2s-complement saturating semantics.</span></span>
<span class="line" id="L3096"> <span class="tok-comment">/// r and a may alias.</span></span>
<span class="line" id="L3097"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">shiftLeftSat</span>(r: *Managed, a: *<span class="tok-kw">const</span> Managed, shift: <span class="tok-type">usize</span>, signedness: Signedness, bit_count: <span class="tok-type">usize</span>) !<span class="tok-type">void</span> {</span>
<span class="line" id="L3098"> <span class="tok-kw">try</span> r.ensureTwosCompCapacity(bit_count);</span>
<span class="line" id="L3099"> <span class="tok-kw">var</span> m = r.toMutable();</span>
<span class="line" id="L3100"> m.shiftLeftSat(a.toConst(), shift, signedness, bit_count);</span>
<span class="line" id="L3101"> r.setMetadata(m.positive, m.len);</span>
<span class="line" id="L3102"> }</span>
<span class="line" id="L3103"></span>
<span class="line" id="L3104"> <span class="tok-comment">/// r = a >> shift</span></span>
<span class="line" id="L3105"> <span class="tok-comment">/// r and a may alias.</span></span>
<span class="line" id="L3106"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">shiftRight</span>(r: *Managed, a: *<span class="tok-kw">const</span> Managed, shift: <span class="tok-type">usize</span>) !<span class="tok-type">void</span> {</span>
<span class="line" id="L3107"> <span class="tok-kw">if</span> (a.len() <= shift / limb_bits) {</span>
<span class="line" id="L3108"> <span class="tok-comment">// Shifting negative numbers converges to -1 instead of 0</span>
</span>
<span class="line" id="L3109"> <span class="tok-kw">if</span> (a.isPositive()) {</span>
<span class="line" id="L3110"> r.metadata = <span class="tok-number">1</span>;</span>
<span class="line" id="L3111"> r.limbs[<span class="tok-number">0</span>] = <span class="tok-number">0</span>;</span>
<span class="line" id="L3112"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L3113"> r.metadata = <span class="tok-number">1</span>;</span>
<span class="line" id="L3114"> r.setSign(<span class="tok-null">false</span>);</span>
<span class="line" id="L3115"> r.limbs[<span class="tok-number">0</span>] = <span class="tok-number">1</span>;</span>
<span class="line" id="L3116"> }</span>
<span class="line" id="L3117"> <span class="tok-kw">return</span>;</span>
<span class="line" id="L3118"> }</span>
<span class="line" id="L3119"></span>
<span class="line" id="L3120"> <span class="tok-kw">try</span> r.ensureCapacity(a.len() - (shift / limb_bits));</span>
<span class="line" id="L3121"> <span class="tok-kw">var</span> m = r.toMutable();</span>
<span class="line" id="L3122"> m.shiftRight(a.toConst(), shift);</span>
<span class="line" id="L3123"> r.setMetadata(m.positive, m.len);</span>
<span class="line" id="L3124"> }</span>
<span class="line" id="L3125"></span>
<span class="line" id="L3126"> <span class="tok-comment">/// r = ~a under 2s-complement wrapping semantics.</span></span>
<span class="line" id="L3127"> <span class="tok-comment">/// r and a may alias.</span></span>
<span class="line" id="L3128"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">bitNotWrap</span>(r: *Managed, a: *<span class="tok-kw">const</span> Managed, signedness: Signedness, bit_count: <span class="tok-type">usize</span>) !<span class="tok-type">void</span> {</span>
<span class="line" id="L3129"> <span class="tok-kw">try</span> r.ensureTwosCompCapacity(bit_count);</span>
<span class="line" id="L3130"> <span class="tok-kw">var</span> m = r.toMutable();</span>
<span class="line" id="L3131"> m.bitNotWrap(a.toConst(), signedness, bit_count);</span>
<span class="line" id="L3132"> r.setMetadata(m.positive, m.len);</span>
<span class="line" id="L3133"> }</span>
<span class="line" id="L3134"></span>
<span class="line" id="L3135"> <span class="tok-comment">/// r = a | b</span></span>
<span class="line" id="L3136"> <span class="tok-comment">///</span></span>
<span class="line" id="L3137"> <span class="tok-comment">/// a and b are zero-extended to the longer of a or b.</span></span>
<span class="line" id="L3138"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">bitOr</span>(r: *Managed, a: *<span class="tok-kw">const</span> Managed, b: *<span class="tok-kw">const</span> Managed) !<span class="tok-type">void</span> {</span>
<span class="line" id="L3139"> <span class="tok-kw">try</span> r.ensureCapacity(<span class="tok-builtin">@max</span>(a.len(), b.len()));</span>
<span class="line" id="L3140"> <span class="tok-kw">var</span> m = r.toMutable();</span>
<span class="line" id="L3141"> m.bitOr(a.toConst(), b.toConst());</span>
<span class="line" id="L3142"> r.setMetadata(m.positive, m.len);</span>
<span class="line" id="L3143"> }</span>
<span class="line" id="L3144"></span>
<span class="line" id="L3145"> <span class="tok-comment">/// r = a & b</span></span>
<span class="line" id="L3146"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">bitAnd</span>(r: *Managed, a: *<span class="tok-kw">const</span> Managed, b: *<span class="tok-kw">const</span> Managed) !<span class="tok-type">void</span> {</span>
<span class="line" id="L3147"> <span class="tok-kw">const</span> cap = <span class="tok-kw">if</span> (a.isPositive() <span class="tok-kw">or</span> b.isPositive())</span>
<span class="line" id="L3148"> <span class="tok-builtin">@min</span>(a.len(), b.len())</span>
<span class="line" id="L3149"> <span class="tok-kw">else</span></span>
<span class="line" id="L3150"> <span class="tok-builtin">@max</span>(a.len(), b.len()) + <span class="tok-number">1</span>;</span>
<span class="line" id="L3151"> <span class="tok-kw">try</span> r.ensureCapacity(cap);</span>
<span class="line" id="L3152"> <span class="tok-kw">var</span> m = r.toMutable();</span>
<span class="line" id="L3153"> m.bitAnd(a.toConst(), b.toConst());</span>
<span class="line" id="L3154"> r.setMetadata(m.positive, m.len);</span>
<span class="line" id="L3155"> }</span>
<span class="line" id="L3156"></span>
<span class="line" id="L3157"> <span class="tok-comment">/// r = a ^ b</span></span>
<span class="line" id="L3158"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">bitXor</span>(r: *Managed, a: *<span class="tok-kw">const</span> Managed, b: *<span class="tok-kw">const</span> Managed) !<span class="tok-type">void</span> {</span>
<span class="line" id="L3159"> <span class="tok-kw">var</span> cap = <span class="tok-builtin">@max</span>(a.len(), b.len()) + <span class="tok-builtin">@intFromBool</span>(a.isPositive() != b.isPositive());</span>
<span class="line" id="L3160"> <span class="tok-kw">try</span> r.ensureCapacity(cap);</span>
<span class="line" id="L3161"></span>
<span class="line" id="L3162"> <span class="tok-kw">var</span> m = r.toMutable();</span>
<span class="line" id="L3163"> m.bitXor(a.toConst(), b.toConst());</span>
<span class="line" id="L3164"> r.setMetadata(m.positive, m.len);</span>
<span class="line" id="L3165"> }</span>
<span class="line" id="L3166"></span>
<span class="line" id="L3167"> <span class="tok-comment">/// rma may alias x or y.</span></span>
<span class="line" id="L3168"> <span class="tok-comment">/// x and y may alias each other.</span></span>
<span class="line" id="L3169"> <span class="tok-comment">///</span></span>
<span class="line" id="L3170"> <span class="tok-comment">/// rma's allocator is used for temporary storage to boost multiplication performance.</span></span>
<span class="line" id="L3171"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">gcd</span>(rma: *Managed, x: *<span class="tok-kw">const</span> Managed, y: *<span class="tok-kw">const</span> Managed) !<span class="tok-type">void</span> {</span>
<span class="line" id="L3172"> <span class="tok-kw">try</span> rma.ensureCapacity(<span class="tok-builtin">@min</span>(x.len(), y.len()));</span>
<span class="line" id="L3173"> <span class="tok-kw">var</span> m = rma.toMutable();</span>
<span class="line" id="L3174"> <span class="tok-kw">var</span> limbs_buffer = std.ArrayList(Limb).init(rma.allocator);</span>
<span class="line" id="L3175"> <span class="tok-kw">defer</span> limbs_buffer.deinit();</span>
<span class="line" id="L3176"> <span class="tok-kw">try</span> m.gcd(x.toConst(), y.toConst(), &limbs_buffer);</span>
<span class="line" id="L3177"> rma.setMetadata(m.positive, m.len);</span>
<span class="line" id="L3178"> }</span>
<span class="line" id="L3179"></span>
<span class="line" id="L3180"> <span class="tok-comment">/// r = a * a</span></span>
<span class="line" id="L3181"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">sqr</span>(rma: *Managed, a: *<span class="tok-kw">const</span> Managed) !<span class="tok-type">void</span> {</span>
<span class="line" id="L3182"> <span class="tok-kw">const</span> needed_limbs = <span class="tok-number">2</span> * a.len() + <span class="tok-number">1</span>;</span>
<span class="line" id="L3183"></span>
<span class="line" id="L3184"> <span class="tok-kw">if</span> (rma.limbs.ptr == a.limbs.ptr) {</span>
<span class="line" id="L3185"> <span class="tok-kw">var</span> m = <span class="tok-kw">try</span> Managed.initCapacity(rma.allocator, needed_limbs);</span>
<span class="line" id="L3186"> <span class="tok-kw">errdefer</span> m.deinit();</span>
<span class="line" id="L3187"> <span class="tok-kw">var</span> m_mut = m.toMutable();</span>
<span class="line" id="L3188"> m_mut.sqrNoAlias(a.toConst(), rma.allocator);</span>
<span class="line" id="L3189"> m.setMetadata(m_mut.positive, m_mut.len);</span>
<span class="line" id="L3190"></span>
<span class="line" id="L3191"> rma.deinit();</span>
<span class="line" id="L3192"> rma.swap(&m);</span>
<span class="line" id="L3193"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L3194"> <span class="tok-kw">try</span> rma.ensureCapacity(needed_limbs);</span>
<span class="line" id="L3195"> <span class="tok-kw">var</span> rma_mut = rma.toMutable();</span>
<span class="line" id="L3196"> rma_mut.sqrNoAlias(a.toConst(), rma.allocator);</span>
<span class="line" id="L3197"> rma.setMetadata(rma_mut.positive, rma_mut.len);</span>
<span class="line" id="L3198"> }</span>
<span class="line" id="L3199"> }</span>
<span class="line" id="L3200"></span>
<span class="line" id="L3201"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">pow</span>(rma: *Managed, a: *<span class="tok-kw">const</span> Managed, b: <span class="tok-type">u32</span>) !<span class="tok-type">void</span> {</span>
<span class="line" id="L3202"> <span class="tok-kw">const</span> needed_limbs = calcPowLimbsBufferLen(a.bitCountAbs(), b);</span>
<span class="line" id="L3203"></span>
<span class="line" id="L3204"> <span class="tok-kw">const</span> limbs_buffer = <span class="tok-kw">try</span> rma.allocator.alloc(Limb, needed_limbs);</span>
<span class="line" id="L3205"> <span class="tok-kw">defer</span> rma.allocator.free(limbs_buffer);</span>
<span class="line" id="L3206"></span>
<span class="line" id="L3207"> <span class="tok-kw">if</span> (rma.limbs.ptr == a.limbs.ptr) {</span>
<span class="line" id="L3208"> <span class="tok-kw">var</span> m = <span class="tok-kw">try</span> Managed.initCapacity(rma.allocator, needed_limbs);</span>
<span class="line" id="L3209"> <span class="tok-kw">errdefer</span> m.deinit();</span>
<span class="line" id="L3210"> <span class="tok-kw">var</span> m_mut = m.toMutable();</span>
<span class="line" id="L3211"> <span class="tok-kw">try</span> m_mut.pow(a.toConst(), b, limbs_buffer);</span>
<span class="line" id="L3212"> m.setMetadata(m_mut.positive, m_mut.len);</span>
<span class="line" id="L3213"></span>
<span class="line" id="L3214"> rma.deinit();</span>
<span class="line" id="L3215"> rma.swap(&m);</span>
<span class="line" id="L3216"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L3217"> <span class="tok-kw">try</span> rma.ensureCapacity(needed_limbs);</span>
<span class="line" id="L3218"> <span class="tok-kw">var</span> rma_mut = rma.toMutable();</span>
<span class="line" id="L3219"> <span class="tok-kw">try</span> rma_mut.pow(a.toConst(), b, limbs_buffer);</span>
<span class="line" id="L3220"> rma.setMetadata(rma_mut.positive, rma_mut.len);</span>
<span class="line" id="L3221"> }</span>
<span class="line" id="L3222"> }</span>
<span class="line" id="L3223"></span>
<span class="line" id="L3224"> <span class="tok-comment">/// r = ⌊√a⌋</span></span>
<span class="line" id="L3225"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">sqrt</span>(rma: *Managed, a: *<span class="tok-kw">const</span> Managed) !<span class="tok-type">void</span> {</span>
<span class="line" id="L3226"> <span class="tok-kw">const</span> needed_limbs = calcSqrtLimbsBufferLen(a.bitCountAbs());</span>
<span class="line" id="L3227"></span>
<span class="line" id="L3228"> <span class="tok-kw">const</span> limbs_buffer = <span class="tok-kw">try</span> rma.allocator.alloc(Limb, needed_limbs);</span>
<span class="line" id="L3229"> <span class="tok-kw">defer</span> rma.allocator.free(limbs_buffer);</span>
<span class="line" id="L3230"></span>
<span class="line" id="L3231"> <span class="tok-kw">try</span> rma.ensureCapacity((a.len() - <span class="tok-number">1</span>) / <span class="tok-number">2</span> + <span class="tok-number">1</span>);</span>
<span class="line" id="L3232"> <span class="tok-kw">var</span> m = rma.toMutable();</span>
<span class="line" id="L3233"> m.sqrt(a.toConst(), limbs_buffer);</span>
<span class="line" id="L3234"> rma.setMetadata(m.positive, m.len);</span>
<span class="line" id="L3235"> }</span>
<span class="line" id="L3236"></span>
<span class="line" id="L3237"> <span class="tok-comment">/// r = truncate(Int(signedness, bit_count), a)</span></span>
<span class="line" id="L3238"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">truncate</span>(r: *Managed, a: *<span class="tok-kw">const</span> Managed, signedness: Signedness, bit_count: <span class="tok-type">usize</span>) !<span class="tok-type">void</span> {</span>
<span class="line" id="L3239"> <span class="tok-kw">try</span> r.ensureCapacity(calcTwosCompLimbCount(bit_count));</span>
<span class="line" id="L3240"> <span class="tok-kw">var</span> m = r.toMutable();</span>
<span class="line" id="L3241"> m.truncate(a.toConst(), signedness, bit_count);</span>
<span class="line" id="L3242"> r.setMetadata(m.positive, m.len);</span>
<span class="line" id="L3243"> }</span>
<span class="line" id="L3244"></span>
<span class="line" id="L3245"> <span class="tok-comment">/// r = saturate(Int(signedness, bit_count), a)</span></span>
<span class="line" id="L3246"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">saturate</span>(r: *Managed, a: *<span class="tok-kw">const</span> Managed, signedness: Signedness, bit_count: <span class="tok-type">usize</span>) !<span class="tok-type">void</span> {</span>
<span class="line" id="L3247"> <span class="tok-kw">try</span> r.ensureCapacity(calcTwosCompLimbCount(bit_count));</span>
<span class="line" id="L3248"> <span class="tok-kw">var</span> m = r.toMutable();</span>
<span class="line" id="L3249"> m.saturate(a.toConst(), signedness, bit_count);</span>
<span class="line" id="L3250"> r.setMetadata(m.positive, m.len);</span>
<span class="line" id="L3251"> }</span>
<span class="line" id="L3252"></span>
<span class="line" id="L3253"> <span class="tok-comment">/// r = @popCount(a) with 2s-complement semantics.</span></span>
<span class="line" id="L3254"> <span class="tok-comment">/// r and a may be aliases.</span></span>
<span class="line" id="L3255"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">popCount</span>(r: *Managed, a: *<span class="tok-kw">const</span> Managed, bit_count: <span class="tok-type">usize</span>) !<span class="tok-type">void</span> {</span>
<span class="line" id="L3256"> <span class="tok-kw">try</span> r.ensureCapacity(calcTwosCompLimbCount(bit_count));</span>
<span class="line" id="L3257"> <span class="tok-kw">var</span> m = r.toMutable();</span>
<span class="line" id="L3258"> m.popCount(a.toConst(), bit_count);</span>
<span class="line" id="L3259"> r.setMetadata(m.positive, m.len);</span>
<span class="line" id="L3260"> }</span>
<span class="line" id="L3261">};</span>
<span class="line" id="L3262"></span>
<span class="line" id="L3263"><span class="tok-comment">/// Different operators which can be used in accumulation style functions</span></span>
<span class="line" id="L3264"><span class="tok-comment">/// (llmulacc, llmulaccKaratsuba, llmulaccLong, llmulLimb). In all these functions,</span></span>
<span class="line" id="L3265"><span class="tok-comment">/// a computed value is accumulated with an existing result.</span></span>
<span class="line" id="L3266"><span class="tok-kw">const</span> AccOp = <span class="tok-kw">enum</span> {</span>
<span class="line" id="L3267"> <span class="tok-comment">/// The computed value is added to the result.</span></span>
<span class="line" id="L3268"> add,</span>
<span class="line" id="L3269"></span>
<span class="line" id="L3270"> <span class="tok-comment">/// The computed value is subtracted from the result.</span></span>
<span class="line" id="L3271"> sub,</span>
<span class="line" id="L3272">};</span>
<span class="line" id="L3273"></span>
<span class="line" id="L3274"><span class="tok-comment">/// Knuth 4.3.1, Algorithm M.</span></span>
<span class="line" id="L3275"><span class="tok-comment">///</span></span>
<span class="line" id="L3276"><span class="tok-comment">/// r = r (op) a * b</span></span>
<span class="line" id="L3277"><span class="tok-comment">/// r MUST NOT alias any of a or b.</span></span>
<span class="line" id="L3278"><span class="tok-comment">///</span></span>
<span class="line" id="L3279"><span class="tok-comment">/// The result is computed modulo `r.len`. When `r.len >= a.len + b.len`, no overflow occurs.</span></span>
<span class="line" id="L3280"><span class="tok-kw">fn</span> <span class="tok-fn">llmulacc</span>(<span class="tok-kw">comptime</span> op: AccOp, opt_allocator: ?Allocator, r: []Limb, a: []<span class="tok-kw">const</span> Limb, b: []<span class="tok-kw">const</span> Limb) <span class="tok-type">void</span> {</span>
<span class="line" id="L3281"> <span class="tok-builtin">@setRuntimeSafety</span>(debug_safety);</span>
<span class="line" id="L3282"> assert(r.len >= a.len);</span>
<span class="line" id="L3283"> assert(r.len >= b.len);</span>
<span class="line" id="L3284"></span>
<span class="line" id="L3285"> <span class="tok-comment">// Order greatest first.</span>
</span>
<span class="line" id="L3286"> <span class="tok-kw">var</span> x = a;</span>
<span class="line" id="L3287"> <span class="tok-kw">var</span> y = b;</span>
<span class="line" id="L3288"> <span class="tok-kw">if</span> (a.len < b.len) {</span>
<span class="line" id="L3289"> x = b;</span>
<span class="line" id="L3290"> y = a;</span>
<span class="line" id="L3291"> }</span>
<span class="line" id="L3292"></span>
<span class="line" id="L3293"> k_mul: {</span>
<span class="line" id="L3294"> <span class="tok-kw">if</span> (y.len > <span class="tok-number">48</span>) {</span>
<span class="line" id="L3295"> <span class="tok-kw">if</span> (opt_allocator) |allocator| {</span>
<span class="line" id="L3296"> llmulaccKaratsuba(op, allocator, r, x, y) <span class="tok-kw">catch</span> |err| <span class="tok-kw">switch</span> (err) {</span>
<span class="line" id="L3297"> <span class="tok-kw">error</span>.OutOfMemory => <span class="tok-kw">break</span> :k_mul, <span class="tok-comment">// handled below</span>
</span>
<span class="line" id="L3298"> };</span>
<span class="line" id="L3299"> <span class="tok-kw">return</span>;</span>
<span class="line" id="L3300"> }</span>
<span class="line" id="L3301"> }</span>
<span class="line" id="L3302"> }</span>
<span class="line" id="L3303"></span>
<span class="line" id="L3304"> llmulaccLong(op, r, x, y);</span>
<span class="line" id="L3305">}</span>
<span class="line" id="L3306"></span>
<span class="line" id="L3307"><span class="tok-comment">/// Knuth 4.3.1, Algorithm M.</span></span>
<span class="line" id="L3308"><span class="tok-comment">///</span></span>
<span class="line" id="L3309"><span class="tok-comment">/// r = r (op) a * b</span></span>
<span class="line" id="L3310"><span class="tok-comment">/// r MUST NOT alias any of a or b.</span></span>
<span class="line" id="L3311"><span class="tok-comment">///</span></span>
<span class="line" id="L3312"><span class="tok-comment">/// The result is computed modulo `r.len`. When `r.len >= a.len + b.len`, no overflow occurs.</span></span>
<span class="line" id="L3313"><span class="tok-kw">fn</span> <span class="tok-fn">llmulaccKaratsuba</span>(</span>
<span class="line" id="L3314"> <span class="tok-kw">comptime</span> op: AccOp,</span>
<span class="line" id="L3315"> allocator: Allocator,</span>
<span class="line" id="L3316"> r: []Limb,</span>
<span class="line" id="L3317"> a: []<span class="tok-kw">const</span> Limb,</span>
<span class="line" id="L3318"> b: []<span class="tok-kw">const</span> Limb,</span>
<span class="line" id="L3319">) <span class="tok-kw">error</span>{OutOfMemory}!<span class="tok-type">void</span> {</span>
<span class="line" id="L3320"> <span class="tok-builtin">@setRuntimeSafety</span>(debug_safety);</span>
<span class="line" id="L3321"> assert(r.len >= a.len);</span>
<span class="line" id="L3322"> assert(a.len >= b.len);</span>
<span class="line" id="L3323"></span>
<span class="line" id="L3324"> <span class="tok-comment">// Classical karatsuba algorithm:</span>
</span>
<span class="line" id="L3325"> <span class="tok-comment">// a = a1 * B + a0</span>
</span>
<span class="line" id="L3326"> <span class="tok-comment">// b = b1 * B + b0</span>
</span>
<span class="line" id="L3327"> <span class="tok-comment">// Where a0, b0 < B</span>
</span>
<span class="line" id="L3328"> <span class="tok-comment">//</span>
</span>
<span class="line" id="L3329"> <span class="tok-comment">// We then have:</span>
</span>
<span class="line" id="L3330"> <span class="tok-comment">// ab = a * b</span>
</span>
<span class="line" id="L3331"> <span class="tok-comment">// = (a1 * B + a0) * (b1 * B + b0)</span>
</span>
<span class="line" id="L3332"> <span class="tok-comment">// = a1 * b1 * B * B + a1 * B * b0 + a0 * b1 * B + a0 * b0</span>
</span>
<span class="line" id="L3333"> <span class="tok-comment">// = a1 * b1 * B * B + (a1 * b0 + a0 * b1) * B + a0 * b0</span>
</span>
<span class="line" id="L3334"> <span class="tok-comment">//</span>
</span>
<span class="line" id="L3335"> <span class="tok-comment">// Note that:</span>
</span>
<span class="line" id="L3336"> <span class="tok-comment">// a1 * b0 + a0 * b1</span>
</span>
<span class="line" id="L3337"> <span class="tok-comment">// = (a1 + a0)(b1 + b0) - a1 * b1 - a0 * b0</span>
</span>
<span class="line" id="L3338"> <span class="tok-comment">// = (a0 - a1)(b1 - b0) + a1 * b1 + a0 * b0</span>
</span>
<span class="line" id="L3339"> <span class="tok-comment">//</span>
</span>
<span class="line" id="L3340"> <span class="tok-comment">// This yields:</span>
</span>
<span class="line" id="L3341"> <span class="tok-comment">// ab = p2 * B^2 + (p0 + p1 + p2) * B + p0</span>
</span>
<span class="line" id="L3342"> <span class="tok-comment">//</span>
</span>
<span class="line" id="L3343"> <span class="tok-comment">// Where:</span>
</span>
<span class="line" id="L3344"> <span class="tok-comment">// p0 = a0 * b0</span>
</span>
<span class="line" id="L3345"> <span class="tok-comment">// p1 = (a0 - a1)(b1 - b0)</span>
</span>
<span class="line" id="L3346"> <span class="tok-comment">// p2 = a1 * b1</span>
</span>
<span class="line" id="L3347"> <span class="tok-comment">//</span>
</span>
<span class="line" id="L3348"> <span class="tok-comment">// Note, (a0 - a1) and (b1 - b0) produce values -B < x < B, and so we need to mind the sign here.</span>
</span>
<span class="line" id="L3349"> <span class="tok-comment">// We also have:</span>
</span>
<span class="line" id="L3350"> <span class="tok-comment">// 0 <= p0 <= 2B</span>
</span>
<span class="line" id="L3351"> <span class="tok-comment">// -2B <= p1 <= 2B</span>
</span>
<span class="line" id="L3352"> <span class="tok-comment">//</span>
</span>
<span class="line" id="L3353"> <span class="tok-comment">// Note, when B is a multiple of the limb size, multiplies by B amount to shifts or</span>
</span>
<span class="line" id="L3354"> <span class="tok-comment">// slices of a limbs array.</span>
</span>
<span class="line" id="L3355"> <span class="tok-comment">//</span>
</span>
<span class="line" id="L3356"> <span class="tok-comment">// This function computes the result of the multiplication modulo r.len. This means:</span>
</span>
<span class="line" id="L3357"> <span class="tok-comment">// - p2 and p1 only need to be computed modulo r.len - B.</span>
</span>
<span class="line" id="L3358"> <span class="tok-comment">// - In the case of p2, p2 * B^2 needs to be added modulo r.len - 2 * B.</span>
</span>
<span class="line" id="L3359"></span>
<span class="line" id="L3360"> <span class="tok-kw">const</span> split = b.len / <span class="tok-number">2</span>; <span class="tok-comment">// B</span>
</span>
<span class="line" id="L3361"></span>
<span class="line" id="L3362"> <span class="tok-kw">const</span> limbs_after_split = r.len - split; <span class="tok-comment">// Limbs to compute for p1 and p2.</span>
</span>
<span class="line" id="L3363"> <span class="tok-kw">const</span> limbs_after_split2 = r.len - split * <span class="tok-number">2</span>; <span class="tok-comment">// Limbs to add for p2 * B^2.</span>
</span>
<span class="line" id="L3364"></span>
<span class="line" id="L3365"> <span class="tok-comment">// For a0 and b0 we need the full range.</span>
</span>
<span class="line" id="L3366"> <span class="tok-kw">const</span> a0 = a[<span class="tok-number">0</span>..llnormalize(a[<span class="tok-number">0</span>..split])];</span>
<span class="line" id="L3367"> <span class="tok-kw">const</span> b0 = b[<span class="tok-number">0</span>..llnormalize(b[<span class="tok-number">0</span>..split])];</span>
<span class="line" id="L3368"></span>
<span class="line" id="L3369"> <span class="tok-comment">// For a1 and b1 we only need `limbs_after_split` limbs.</span>
</span>
<span class="line" id="L3370"> <span class="tok-kw">const</span> a1 = blk: {</span>
<span class="line" id="L3371"> <span class="tok-kw">var</span> a1 = a[split..];</span>
<span class="line" id="L3372"> a1.len = <span class="tok-builtin">@min</span>(llnormalize(a1), limbs_after_split);</span>
<span class="line" id="L3373"> <span class="tok-kw">break</span> :blk a1;</span>
<span class="line" id="L3374"> };</span>
<span class="line" id="L3375"></span>
<span class="line" id="L3376"> <span class="tok-kw">const</span> b1 = blk: {</span>
<span class="line" id="L3377"> <span class="tok-kw">var</span> b1 = b[split..];</span>
<span class="line" id="L3378"> b1.len = <span class="tok-builtin">@min</span>(llnormalize(b1), limbs_after_split);</span>
<span class="line" id="L3379"> <span class="tok-kw">break</span> :blk b1;</span>
<span class="line" id="L3380"> };</span>
<span class="line" id="L3381"></span>
<span class="line" id="L3382"> <span class="tok-comment">// Note that the above slices relative to `split` work because we have a.len > b.len.</span>
</span>
<span class="line" id="L3383"></span>
<span class="line" id="L3384"> <span class="tok-comment">// We need some temporary memory to store intermediate results.</span>
</span>
<span class="line" id="L3385"> <span class="tok-comment">// Note, we can reduce the amount of temporaries we need by reordering the computation here:</span>
</span>
<span class="line" id="L3386"> <span class="tok-comment">// ab = p2 * B^2 + (p0 + p1 + p2) * B + p0</span>
</span>
<span class="line" id="L3387"> <span class="tok-comment">// = p2 * B^2 + (p0 * B + p1 * B + p2 * B) + p0</span>
</span>
<span class="line" id="L3388"> <span class="tok-comment">// = (p2 * B^2 + p2 * B) + (p0 * B + p0) + p1 * B</span>
</span>
<span class="line" id="L3389"></span>
<span class="line" id="L3390"> <span class="tok-comment">// Allocate at least enough memory to be able to multiply the upper two segments of a and b, assuming</span>
</span>
<span class="line" id="L3391"> <span class="tok-comment">// no overflow.</span>
</span>
<span class="line" id="L3392"> <span class="tok-kw">const</span> tmp = <span class="tok-kw">try</span> allocator.alloc(Limb, a.len - split + b.len - split);</span>
<span class="line" id="L3393"> <span class="tok-kw">defer</span> allocator.free(tmp);</span>
<span class="line" id="L3394"></span>
<span class="line" id="L3395"> <span class="tok-comment">// Compute p2.</span>
</span>
<span class="line" id="L3396"> <span class="tok-comment">// Note, we don't need to compute all of p2, just enough limbs to satisfy r.</span>
</span>
<span class="line" id="L3397"> <span class="tok-kw">const</span> p2_limbs = <span class="tok-builtin">@min</span>(limbs_after_split, a1.len + b1.len);</span>
<span class="line" id="L3398"></span>
<span class="line" id="L3399"> <span class="tok-builtin">@memset</span>(tmp[<span class="tok-number">0</span>..p2_limbs], <span class="tok-number">0</span>);</span>
<span class="line" id="L3400"> llmulacc(.add, allocator, tmp[<span class="tok-number">0</span>..p2_limbs], a1[<span class="tok-number">0</span>..<span class="tok-builtin">@min</span>(a1.len, p2_limbs)], b1[<span class="tok-number">0</span>..<span class="tok-builtin">@min</span>(b1.len, p2_limbs)]);</span>
<span class="line" id="L3401"> <span class="tok-kw">const</span> p2 = tmp[<span class="tok-number">0</span>..llnormalize(tmp[<span class="tok-number">0</span>..p2_limbs])];</span>
<span class="line" id="L3402"></span>
<span class="line" id="L3403"> <span class="tok-comment">// Add p2 * B to the result.</span>
</span>
<span class="line" id="L3404"> llaccum(op, r[split..], p2);</span>
<span class="line" id="L3405"></span>
<span class="line" id="L3406"> <span class="tok-comment">// Add p2 * B^2 to the result if required.</span>
</span>
<span class="line" id="L3407"> <span class="tok-kw">if</span> (limbs_after_split2 > <span class="tok-number">0</span>) {</span>
<span class="line" id="L3408"> llaccum(op, r[split * <span class="tok-number">2</span> ..], p2[<span class="tok-number">0</span>..<span class="tok-builtin">@min</span>(p2.len, limbs_after_split2)]);</span>
<span class="line" id="L3409"> }</span>
<span class="line" id="L3410"></span>
<span class="line" id="L3411"> <span class="tok-comment">// Compute p0.</span>
</span>
<span class="line" id="L3412"> <span class="tok-comment">// Since a0.len, b0.len <= split and r.len >= split * 2, the full width of p0 needs to be computed.</span>
</span>
<span class="line" id="L3413"> <span class="tok-kw">const</span> p0_limbs = a0.len + b0.len;</span>
<span class="line" id="L3414"> <span class="tok-builtin">@memset</span>(tmp[<span class="tok-number">0</span>..p0_limbs], <span class="tok-number">0</span>);</span>
<span class="line" id="L3415"> llmulacc(.add, allocator, tmp[<span class="tok-number">0</span>..p0_limbs], a0, b0);</span>
<span class="line" id="L3416"> <span class="tok-kw">const</span> p0 = tmp[<span class="tok-number">0</span>..llnormalize(tmp[<span class="tok-number">0</span>..p0_limbs])];</span>
<span class="line" id="L3417"></span>
<span class="line" id="L3418"> <span class="tok-comment">// Add p0 to the result.</span>
</span>
<span class="line" id="L3419"> llaccum(op, r, p0);</span>
<span class="line" id="L3420"></span>
<span class="line" id="L3421"> <span class="tok-comment">// Add p0 * B to the result. In this case, we may not need all of it.</span>
</span>
<span class="line" id="L3422"> llaccum(op, r[split..], p0[<span class="tok-number">0</span>..<span class="tok-builtin">@min</span>(limbs_after_split, p0.len)]);</span>
<span class="line" id="L3423"></span>
<span class="line" id="L3424"> <span class="tok-comment">// Finally, compute and add p1.</span>
</span>
<span class="line" id="L3425"> <span class="tok-comment">// From now on we only need `limbs_after_split` limbs for a0 and b0, since the result of the</span>
</span>
<span class="line" id="L3426"> <span class="tok-comment">// following computation will be added * B.</span>
</span>
<span class="line" id="L3427"> <span class="tok-kw">const</span> a0x = a0[<span class="tok-number">0</span>..<span class="tok-builtin">@min</span>(a0.len, limbs_after_split)];</span>
<span class="line" id="L3428"> <span class="tok-kw">const</span> b0x = b0[<span class="tok-number">0</span>..<span class="tok-builtin">@min</span>(b0.len, limbs_after_split)];</span>
<span class="line" id="L3429"></span>
<span class="line" id="L3430"> <span class="tok-kw">const</span> j0_sign = llcmp(a0x, a1);</span>
<span class="line" id="L3431"> <span class="tok-kw">const</span> j1_sign = llcmp(b1, b0x);</span>
<span class="line" id="L3432"></span>
<span class="line" id="L3433"> <span class="tok-kw">if</span> (j0_sign * j1_sign == <span class="tok-number">0</span>) {</span>
<span class="line" id="L3434"> <span class="tok-comment">// p1 is zero, we don't need to do any computation at all.</span>
</span>
<span class="line" id="L3435"> <span class="tok-kw">return</span>;</span>
<span class="line" id="L3436"> }</span>
<span class="line" id="L3437"></span>
<span class="line" id="L3438"> <span class="tok-builtin">@memset</span>(tmp, <span class="tok-number">0</span>);</span>
<span class="line" id="L3439"></span>
<span class="line" id="L3440"> <span class="tok-comment">// p1 is nonzero, so compute the intermediary terms j0 = a0 - a1 and j1 = b1 - b0.</span>
</span>
<span class="line" id="L3441"> <span class="tok-comment">// Note that in this case, we again need some storage for intermediary results</span>
</span>
<span class="line" id="L3442"> <span class="tok-comment">// j0 and j1. Since we have tmp.len >= 2B, we can store both</span>
</span>
<span class="line" id="L3443"> <span class="tok-comment">// intermediaries in the already allocated array.</span>
</span>
<span class="line" id="L3444"> <span class="tok-kw">const</span> j0 = tmp[<span class="tok-number">0</span> .. a.len - split];</span>
<span class="line" id="L3445"> <span class="tok-kw">const</span> j1 = tmp[a.len - split ..];</span>
<span class="line" id="L3446"></span>
<span class="line" id="L3447"> <span class="tok-comment">// Ensure that no subtraction overflows.</span>
</span>
<span class="line" id="L3448"> <span class="tok-kw">if</span> (j0_sign == <span class="tok-number">1</span>) {</span>
<span class="line" id="L3449"> <span class="tok-comment">// a0 > a1.</span>
</span>
<span class="line" id="L3450"> _ = llsubcarry(j0, a0x, a1);</span>
<span class="line" id="L3451"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L3452"> <span class="tok-comment">// a0 < a1.</span>
</span>
<span class="line" id="L3453"> _ = llsubcarry(j0, a1, a0x);</span>
<span class="line" id="L3454"> }</span>
<span class="line" id="L3455"></span>
<span class="line" id="L3456"> <span class="tok-kw">if</span> (j1_sign == <span class="tok-number">1</span>) {</span>
<span class="line" id="L3457"> <span class="tok-comment">// b1 > b0.</span>
</span>
<span class="line" id="L3458"> _ = llsubcarry(j1, b1, b0x);</span>
<span class="line" id="L3459"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L3460"> <span class="tok-comment">// b1 > b0.</span>
</span>
<span class="line" id="L3461"> _ = llsubcarry(j1, b0x, b1);</span>
<span class="line" id="L3462"> }</span>
<span class="line" id="L3463"></span>
<span class="line" id="L3464"> <span class="tok-kw">if</span> (j0_sign * j1_sign == <span class="tok-number">1</span>) {</span>
<span class="line" id="L3465"> <span class="tok-comment">// If j0 and j1 are both positive, we now have:</span>
</span>
<span class="line" id="L3466"> <span class="tok-comment">// p1 = j0 * j1</span>
</span>
<span class="line" id="L3467"> <span class="tok-comment">// If j0 and j1 are both negative, we now have:</span>
</span>
<span class="line" id="L3468"> <span class="tok-comment">// p1 = -j0 * -j1 = j0 * j1</span>
</span>
<span class="line" id="L3469"> <span class="tok-comment">// In this case we can add p1 to the result using llmulacc.</span>
</span>
<span class="line" id="L3470"> llmulacc(op, allocator, r[split..], j0[<span class="tok-number">0</span>..llnormalize(j0)], j1[<span class="tok-number">0</span>..llnormalize(j1)]);</span>
<span class="line" id="L3471"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L3472"> <span class="tok-comment">// In this case either j0 or j1 is negative, an we have:</span>
</span>
<span class="line" id="L3473"> <span class="tok-comment">// p1 = -(j0 * j1)</span>
</span>
<span class="line" id="L3474"> <span class="tok-comment">// Now we need to subtract instead of accumulate.</span>
</span>
<span class="line" id="L3475"> <span class="tok-kw">const</span> inverted_op = <span class="tok-kw">if</span> (op == .add) .sub <span class="tok-kw">else</span> .add;</span>
<span class="line" id="L3476"> llmulacc(inverted_op, allocator, r[split..], j0[<span class="tok-number">0</span>..llnormalize(j0)], j1[<span class="tok-number">0</span>..llnormalize(j1)]);</span>
<span class="line" id="L3477"> }</span>
<span class="line" id="L3478">}</span>
<span class="line" id="L3479"></span>
<span class="line" id="L3480"><span class="tok-comment">/// r = r (op) a.</span></span>
<span class="line" id="L3481"><span class="tok-comment">/// The result is computed modulo `r.len`.</span></span>
<span class="line" id="L3482"><span class="tok-kw">fn</span> <span class="tok-fn">llaccum</span>(<span class="tok-kw">comptime</span> op: AccOp, r: []Limb, a: []<span class="tok-kw">const</span> Limb) <span class="tok-type">void</span> {</span>
<span class="line" id="L3483"> <span class="tok-builtin">@setRuntimeSafety</span>(debug_safety);</span>
<span class="line" id="L3484"> <span class="tok-kw">if</span> (op == .sub) {</span>
<span class="line" id="L3485"> _ = llsubcarry(r, r, a);</span>
<span class="line" id="L3486"> <span class="tok-kw">return</span>;</span>
<span class="line" id="L3487"> }</span>
<span class="line" id="L3488"></span>
<span class="line" id="L3489"> assert(r.len != <span class="tok-number">0</span> <span class="tok-kw">and</span> a.len != <span class="tok-number">0</span>);</span>
<span class="line" id="L3490"> assert(r.len >= a.len);</span>
<span class="line" id="L3491"></span>
<span class="line" id="L3492"> <span class="tok-kw">var</span> i: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L3493"> <span class="tok-kw">var</span> carry: Limb = <span class="tok-number">0</span>;</span>
<span class="line" id="L3494"></span>
<span class="line" id="L3495"> <span class="tok-kw">while</span> (i < a.len) : (i += <span class="tok-number">1</span>) {</span>
<span class="line" id="L3496"> <span class="tok-kw">const</span> ov1 = <span class="tok-builtin">@addWithOverflow</span>(r[i], a[i]);</span>
<span class="line" id="L3497"> r[i] = ov1[<span class="tok-number">0</span>];</span>
<span class="line" id="L3498"> <span class="tok-kw">const</span> ov2 = <span class="tok-builtin">@addWithOverflow</span>(r[i], carry);</span>
<span class="line" id="L3499"> r[i] = ov2[<span class="tok-number">0</span>];</span>
<span class="line" id="L3500"> carry = <span class="tok-builtin">@as</span>(Limb, ov1[<span class="tok-number">1</span>]) + ov2[<span class="tok-number">1</span>];</span>
<span class="line" id="L3501"> }</span>
<span class="line" id="L3502"></span>
<span class="line" id="L3503"> <span class="tok-kw">while</span> ((carry != <span class="tok-number">0</span>) <span class="tok-kw">and</span> i < r.len) : (i += <span class="tok-number">1</span>) {</span>
<span class="line" id="L3504"> <span class="tok-kw">const</span> ov = <span class="tok-builtin">@addWithOverflow</span>(r[i], carry);</span>
<span class="line" id="L3505"> r[i] = ov[<span class="tok-number">0</span>];</span>
<span class="line" id="L3506"> carry = ov[<span class="tok-number">1</span>];</span>
<span class="line" id="L3507"> }</span>
<span class="line" id="L3508">}</span>
<span class="line" id="L3509"></span>
<span class="line" id="L3510"><span class="tok-comment">/// Returns -1, 0, 1 if |a| < |b|, |a| == |b| or |a| > |b| respectively for limbs.</span></span>
<span class="line" id="L3511"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">llcmp</span>(a: []<span class="tok-kw">const</span> Limb, b: []<span class="tok-kw">const</span> Limb) <span class="tok-type">i8</span> {</span>
<span class="line" id="L3512"> <span class="tok-builtin">@setRuntimeSafety</span>(debug_safety);</span>
<span class="line" id="L3513"> <span class="tok-kw">const</span> a_len = llnormalize(a);</span>
<span class="line" id="L3514"> <span class="tok-kw">const</span> b_len = llnormalize(b);</span>
<span class="line" id="L3515"> <span class="tok-kw">if</span> (a_len < b_len) {</span>
<span class="line" id="L3516"> <span class="tok-kw">return</span> -<span class="tok-number">1</span>;</span>
<span class="line" id="L3517"> }</span>
<span class="line" id="L3518"> <span class="tok-kw">if</span> (a_len > b_len) {</span>
<span class="line" id="L3519"> <span class="tok-kw">return</span> <span class="tok-number">1</span>;</span>
<span class="line" id="L3520"> }</span>
<span class="line" id="L3521"></span>
<span class="line" id="L3522"> <span class="tok-kw">var</span> i: <span class="tok-type">usize</span> = a_len - <span class="tok-number">1</span>;</span>
<span class="line" id="L3523"> <span class="tok-kw">while</span> (i != <span class="tok-number">0</span>) : (i -= <span class="tok-number">1</span>) {</span>
<span class="line" id="L3524"> <span class="tok-kw">if</span> (a[i] != b[i]) {</span>
<span class="line" id="L3525"> <span class="tok-kw">break</span>;</span>
<span class="line" id="L3526"> }</span>
<span class="line" id="L3527"> }</span>
<span class="line" id="L3528"></span>
<span class="line" id="L3529"> <span class="tok-kw">if</span> (a[i] < b[i]) {</span>
<span class="line" id="L3530"> <span class="tok-kw">return</span> -<span class="tok-number">1</span>;</span>
<span class="line" id="L3531"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (a[i] > b[i]) {</span>
<span class="line" id="L3532"> <span class="tok-kw">return</span> <span class="tok-number">1</span>;</span>
<span class="line" id="L3533"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L3534"> <span class="tok-kw">return</span> <span class="tok-number">0</span>;</span>
<span class="line" id="L3535"> }</span>
<span class="line" id="L3536">}</span>
<span class="line" id="L3537"></span>
<span class="line" id="L3538"><span class="tok-comment">/// r = r (op) y * xi</span></span>
<span class="line" id="L3539"><span class="tok-comment">/// The result is computed modulo `r.len`. When `r.len >= a.len + b.len`, no overflow occurs.</span></span>
<span class="line" id="L3540"><span class="tok-kw">fn</span> <span class="tok-fn">llmulaccLong</span>(<span class="tok-kw">comptime</span> op: AccOp, r: []Limb, a: []<span class="tok-kw">const</span> Limb, b: []<span class="tok-kw">const</span> Limb) <span class="tok-type">void</span> {</span>
<span class="line" id="L3541"> <span class="tok-builtin">@setRuntimeSafety</span>(debug_safety);</span>
<span class="line" id="L3542"> assert(r.len >= a.len);</span>
<span class="line" id="L3543"> assert(a.len >= b.len);</span>
<span class="line" id="L3544"></span>
<span class="line" id="L3545"> <span class="tok-kw">var</span> i: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L3546"> <span class="tok-kw">while</span> (i < b.len) : (i += <span class="tok-number">1</span>) {</span>
<span class="line" id="L3547"> _ = llmulLimb(op, r[i..], a, b[i]);</span>
<span class="line" id="L3548"> }</span>
<span class="line" id="L3549">}</span>
<span class="line" id="L3550"></span>
<span class="line" id="L3551"><span class="tok-comment">/// r = r (op) y * xi</span></span>
<span class="line" id="L3552"><span class="tok-comment">/// The result is computed modulo `r.len`.</span></span>
<span class="line" id="L3553"><span class="tok-comment">/// Returns whether the operation overflowed.</span></span>
<span class="line" id="L3554"><span class="tok-kw">fn</span> <span class="tok-fn">llmulLimb</span>(<span class="tok-kw">comptime</span> op: AccOp, acc: []Limb, y: []<span class="tok-kw">const</span> Limb, xi: Limb) <span class="tok-type">bool</span> {</span>
<span class="line" id="L3555"> <span class="tok-builtin">@setRuntimeSafety</span>(debug_safety);</span>
<span class="line" id="L3556"> <span class="tok-kw">if</span> (xi == <span class="tok-number">0</span>) {</span>
<span class="line" id="L3557"> <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L3558"> }</span>
<span class="line" id="L3559"></span>
<span class="line" id="L3560"> <span class="tok-kw">const</span> split = <span class="tok-builtin">@min</span>(y.len, acc.len);</span>
<span class="line" id="L3561"> <span class="tok-kw">var</span> a_lo = acc[<span class="tok-number">0</span>..split];</span>
<span class="line" id="L3562"> <span class="tok-kw">var</span> a_hi = acc[split..];</span>
<span class="line" id="L3563"></span>
<span class="line" id="L3564"> <span class="tok-kw">switch</span> (op) {</span>
<span class="line" id="L3565"> .add => {</span>
<span class="line" id="L3566"> <span class="tok-kw">var</span> carry: Limb = <span class="tok-number">0</span>;</span>
<span class="line" id="L3567"> <span class="tok-kw">var</span> j: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L3568"> <span class="tok-kw">while</span> (j < a_lo.len) : (j += <span class="tok-number">1</span>) {</span>
<span class="line" id="L3569"> a_lo[j] = addMulLimbWithCarry(a_lo[j], y[j], xi, &carry);</span>
<span class="line" id="L3570"> }</span>
<span class="line" id="L3571"></span>
<span class="line" id="L3572"> j = <span class="tok-number">0</span>;</span>
<span class="line" id="L3573"> <span class="tok-kw">while</span> ((carry != <span class="tok-number">0</span>) <span class="tok-kw">and</span> (j < a_hi.len)) : (j += <span class="tok-number">1</span>) {</span>
<span class="line" id="L3574"> <span class="tok-kw">const</span> ov = <span class="tok-builtin">@addWithOverflow</span>(a_hi[j], carry);</span>
<span class="line" id="L3575"> a_hi[j] = ov[<span class="tok-number">0</span>];</span>
<span class="line" id="L3576"> carry = ov[<span class="tok-number">1</span>];</span>
<span class="line" id="L3577"> }</span>
<span class="line" id="L3578"></span>
<span class="line" id="L3579"> <span class="tok-kw">return</span> carry != <span class="tok-number">0</span>;</span>
<span class="line" id="L3580"> },</span>
<span class="line" id="L3581"> .sub => {</span>
<span class="line" id="L3582"> <span class="tok-kw">var</span> borrow: Limb = <span class="tok-number">0</span>;</span>
<span class="line" id="L3583"> <span class="tok-kw">var</span> j: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L3584"> <span class="tok-kw">while</span> (j < a_lo.len) : (j += <span class="tok-number">1</span>) {</span>
<span class="line" id="L3585"> a_lo[j] = subMulLimbWithBorrow(a_lo[j], y[j], xi, &borrow);</span>
<span class="line" id="L3586"> }</span>
<span class="line" id="L3587"></span>
<span class="line" id="L3588"> j = <span class="tok-number">0</span>;</span>
<span class="line" id="L3589"> <span class="tok-kw">while</span> ((borrow != <span class="tok-number">0</span>) <span class="tok-kw">and</span> (j < a_hi.len)) : (j += <span class="tok-number">1</span>) {</span>
<span class="line" id="L3590"> <span class="tok-kw">const</span> ov = <span class="tok-builtin">@subWithOverflow</span>(a_hi[j], borrow);</span>
<span class="line" id="L3591"> a_hi[j] = ov[<span class="tok-number">0</span>];</span>
<span class="line" id="L3592"> borrow = ov[<span class="tok-number">1</span>];</span>
<span class="line" id="L3593"> }</span>
<span class="line" id="L3594"></span>
<span class="line" id="L3595"> <span class="tok-kw">return</span> borrow != <span class="tok-number">0</span>;</span>
<span class="line" id="L3596"> },</span>
<span class="line" id="L3597"> }</span>
<span class="line" id="L3598">}</span>
<span class="line" id="L3599"></span>
<span class="line" id="L3600"><span class="tok-comment">/// returns the min length the limb could be.</span></span>
<span class="line" id="L3601"><span class="tok-kw">fn</span> <span class="tok-fn">llnormalize</span>(a: []<span class="tok-kw">const</span> Limb) <span class="tok-type">usize</span> {</span>
<span class="line" id="L3602"> <span class="tok-builtin">@setRuntimeSafety</span>(debug_safety);</span>
<span class="line" id="L3603"> <span class="tok-kw">var</span> j = a.len;</span>
<span class="line" id="L3604"> <span class="tok-kw">while</span> (j > <span class="tok-number">0</span>) : (j -= <span class="tok-number">1</span>) {</span>
<span class="line" id="L3605"> <span class="tok-kw">if</span> (a[j - <span class="tok-number">1</span>] != <span class="tok-number">0</span>) {</span>
<span class="line" id="L3606"> <span class="tok-kw">break</span>;</span>
<span class="line" id="L3607"> }</span>
<span class="line" id="L3608"> }</span>
<span class="line" id="L3609"></span>
<span class="line" id="L3610"> <span class="tok-comment">// Handle zero</span>
</span>
<span class="line" id="L3611"> <span class="tok-kw">return</span> <span class="tok-kw">if</span> (j != <span class="tok-number">0</span>) j <span class="tok-kw">else</span> <span class="tok-number">1</span>;</span>
<span class="line" id="L3612">}</span>
<span class="line" id="L3613"></span>
<span class="line" id="L3614"><span class="tok-comment">/// Knuth 4.3.1, Algorithm S.</span></span>
<span class="line" id="L3615"><span class="tok-kw">fn</span> <span class="tok-fn">llsubcarry</span>(r: []Limb, a: []<span class="tok-kw">const</span> Limb, b: []<span class="tok-kw">const</span> Limb) Limb {</span>
<span class="line" id="L3616"> <span class="tok-builtin">@setRuntimeSafety</span>(debug_safety);</span>
<span class="line" id="L3617"> assert(a.len != <span class="tok-number">0</span> <span class="tok-kw">and</span> b.len != <span class="tok-number">0</span>);</span>
<span class="line" id="L3618"> assert(a.len >= b.len);</span>
<span class="line" id="L3619"> assert(r.len >= a.len);</span>
<span class="line" id="L3620"></span>
<span class="line" id="L3621"> <span class="tok-kw">var</span> i: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L3622"> <span class="tok-kw">var</span> borrow: Limb = <span class="tok-number">0</span>;</span>
<span class="line" id="L3623"></span>
<span class="line" id="L3624"> <span class="tok-kw">while</span> (i < b.len) : (i += <span class="tok-number">1</span>) {</span>
<span class="line" id="L3625"> <span class="tok-kw">const</span> ov1 = <span class="tok-builtin">@subWithOverflow</span>(a[i], b[i]);</span>
<span class="line" id="L3626"> r[i] = ov1[<span class="tok-number">0</span>];</span>
<span class="line" id="L3627"> <span class="tok-kw">const</span> ov2 = <span class="tok-builtin">@subWithOverflow</span>(r[i], borrow);</span>
<span class="line" id="L3628"> r[i] = ov2[<span class="tok-number">0</span>];</span>
<span class="line" id="L3629"> borrow = <span class="tok-builtin">@as</span>(Limb, ov1[<span class="tok-number">1</span>]) + ov2[<span class="tok-number">1</span>];</span>
<span class="line" id="L3630"> }</span>
<span class="line" id="L3631"></span>
<span class="line" id="L3632"> <span class="tok-kw">while</span> (i < a.len) : (i += <span class="tok-number">1</span>) {</span>
<span class="line" id="L3633"> <span class="tok-kw">const</span> ov = <span class="tok-builtin">@subWithOverflow</span>(a[i], borrow);</span>
<span class="line" id="L3634"> r[i] = ov[<span class="tok-number">0</span>];</span>
<span class="line" id="L3635"> borrow = ov[<span class="tok-number">1</span>];</span>
<span class="line" id="L3636"> }</span>
<span class="line" id="L3637"></span>
<span class="line" id="L3638"> <span class="tok-kw">return</span> borrow;</span>
<span class="line" id="L3639">}</span>
<span class="line" id="L3640"></span>
<span class="line" id="L3641"><span class="tok-kw">fn</span> <span class="tok-fn">llsub</span>(r: []Limb, a: []<span class="tok-kw">const</span> Limb, b: []<span class="tok-kw">const</span> Limb) <span class="tok-type">void</span> {</span>
<span class="line" id="L3642"> <span class="tok-builtin">@setRuntimeSafety</span>(debug_safety);</span>
<span class="line" id="L3643"> assert(a.len > b.len <span class="tok-kw">or</span> (a.len == b.len <span class="tok-kw">and</span> a[a.len - <span class="tok-number">1</span>] >= b[b.len - <span class="tok-number">1</span>]));</span>
<span class="line" id="L3644"> assert(llsubcarry(r, a, b) == <span class="tok-number">0</span>);</span>
<span class="line" id="L3645">}</span>
<span class="line" id="L3646"></span>
<span class="line" id="L3647"><span class="tok-comment">/// Knuth 4.3.1, Algorithm A.</span></span>
<span class="line" id="L3648"><span class="tok-kw">fn</span> <span class="tok-fn">lladdcarry</span>(r: []Limb, a: []<span class="tok-kw">const</span> Limb, b: []<span class="tok-kw">const</span> Limb) Limb {</span>
<span class="line" id="L3649"> <span class="tok-builtin">@setRuntimeSafety</span>(debug_safety);</span>
<span class="line" id="L3650"> assert(a.len != <span class="tok-number">0</span> <span class="tok-kw">and</span> b.len != <span class="tok-number">0</span>);</span>
<span class="line" id="L3651"> assert(a.len >= b.len);</span>
<span class="line" id="L3652"> assert(r.len >= a.len);</span>
<span class="line" id="L3653"></span>
<span class="line" id="L3654"> <span class="tok-kw">var</span> i: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L3655"> <span class="tok-kw">var</span> carry: Limb = <span class="tok-number">0</span>;</span>
<span class="line" id="L3656"></span>
<span class="line" id="L3657"> <span class="tok-kw">while</span> (i < b.len) : (i += <span class="tok-number">1</span>) {</span>
<span class="line" id="L3658"> <span class="tok-kw">const</span> ov1 = <span class="tok-builtin">@addWithOverflow</span>(a[i], b[i]);</span>
<span class="line" id="L3659"> r[i] = ov1[<span class="tok-number">0</span>];</span>
<span class="line" id="L3660"> <span class="tok-kw">const</span> ov2 = <span class="tok-builtin">@addWithOverflow</span>(r[i], carry);</span>
<span class="line" id="L3661"> r[i] = ov2[<span class="tok-number">0</span>];</span>
<span class="line" id="L3662"> carry = <span class="tok-builtin">@as</span>(Limb, ov1[<span class="tok-number">1</span>]) + ov2[<span class="tok-number">1</span>];</span>
<span class="line" id="L3663"> }</span>
<span class="line" id="L3664"></span>
<span class="line" id="L3665"> <span class="tok-kw">while</span> (i < a.len) : (i += <span class="tok-number">1</span>) {</span>
<span class="line" id="L3666"> <span class="tok-kw">const</span> ov = <span class="tok-builtin">@addWithOverflow</span>(a[i], carry);</span>
<span class="line" id="L3667"> r[i] = ov[<span class="tok-number">0</span>];</span>
<span class="line" id="L3668"> carry = ov[<span class="tok-number">1</span>];</span>
<span class="line" id="L3669"> }</span>
<span class="line" id="L3670"></span>
<span class="line" id="L3671"> <span class="tok-kw">return</span> carry;</span>
<span class="line" id="L3672">}</span>
<span class="line" id="L3673"></span>
<span class="line" id="L3674"><span class="tok-kw">fn</span> <span class="tok-fn">lladd</span>(r: []Limb, a: []<span class="tok-kw">const</span> Limb, b: []<span class="tok-kw">const</span> Limb) <span class="tok-type">void</span> {</span>
<span class="line" id="L3675"> <span class="tok-builtin">@setRuntimeSafety</span>(debug_safety);</span>
<span class="line" id="L3676"> assert(r.len >= a.len + <span class="tok-number">1</span>);</span>
<span class="line" id="L3677"> r[a.len] = lladdcarry(r, a, b);</span>
<span class="line" id="L3678">}</span>
<span class="line" id="L3679"></span>
<span class="line" id="L3680"><span class="tok-comment">/// Knuth 4.3.1, Exercise 16.</span></span>
<span class="line" id="L3681"><span class="tok-kw">fn</span> <span class="tok-fn">lldiv1</span>(quo: []Limb, rem: *Limb, a: []<span class="tok-kw">const</span> Limb, b: Limb) <span class="tok-type">void</span> {</span>
<span class="line" id="L3682"> <span class="tok-builtin">@setRuntimeSafety</span>(debug_safety);</span>
<span class="line" id="L3683"> assert(a.len > <span class="tok-number">1</span> <span class="tok-kw">or</span> a[<span class="tok-number">0</span>] >= b);</span>
<span class="line" id="L3684"> assert(quo.len >= a.len);</span>
<span class="line" id="L3685"></span>
<span class="line" id="L3686"> rem.* = <span class="tok-number">0</span>;</span>
<span class="line" id="L3687"> <span class="tok-kw">for</span> (a, <span class="tok-number">0</span>..) |_, ri| {</span>
<span class="line" id="L3688"> <span class="tok-kw">const</span> i = a.len - ri - <span class="tok-number">1</span>;</span>
<span class="line" id="L3689"> <span class="tok-kw">const</span> pdiv = ((<span class="tok-builtin">@as</span>(DoubleLimb, rem.*) << limb_bits) | a[i]);</span>
<span class="line" id="L3690"></span>
<span class="line" id="L3691"> <span class="tok-kw">if</span> (pdiv == <span class="tok-number">0</span>) {</span>
<span class="line" id="L3692"> quo[i] = <span class="tok-number">0</span>;</span>
<span class="line" id="L3693"> rem.* = <span class="tok-number">0</span>;</span>
<span class="line" id="L3694"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (pdiv < b) {</span>
<span class="line" id="L3695"> quo[i] = <span class="tok-number">0</span>;</span>
<span class="line" id="L3696"> rem.* = <span class="tok-builtin">@as</span>(Limb, <span class="tok-builtin">@truncate</span>(pdiv));</span>
<span class="line" id="L3697"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (pdiv == b) {</span>
<span class="line" id="L3698"> quo[i] = <span class="tok-number">1</span>;</span>
<span class="line" id="L3699"> rem.* = <span class="tok-number">0</span>;</span>
<span class="line" id="L3700"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L3701"> quo[i] = <span class="tok-builtin">@as</span>(Limb, <span class="tok-builtin">@truncate</span>(<span class="tok-builtin">@divTrunc</span>(pdiv, b)));</span>
<span class="line" id="L3702"> rem.* = <span class="tok-builtin">@as</span>(Limb, <span class="tok-builtin">@truncate</span>(pdiv - (quo[i] *% b)));</span>
<span class="line" id="L3703"> }</span>
<span class="line" id="L3704"> }</span>
<span class="line" id="L3705">}</span>
<span class="line" id="L3706"></span>
<span class="line" id="L3707"><span class="tok-kw">fn</span> <span class="tok-fn">lldiv0p5</span>(quo: []Limb, rem: *Limb, a: []<span class="tok-kw">const</span> Limb, b: HalfLimb) <span class="tok-type">void</span> {</span>
<span class="line" id="L3708"> <span class="tok-builtin">@setRuntimeSafety</span>(debug_safety);</span>
<span class="line" id="L3709"> assert(a.len > <span class="tok-number">1</span> <span class="tok-kw">or</span> a[<span class="tok-number">0</span>] >= b);</span>
<span class="line" id="L3710"> assert(quo.len >= a.len);</span>
<span class="line" id="L3711"></span>
<span class="line" id="L3712"> rem.* = <span class="tok-number">0</span>;</span>
<span class="line" id="L3713"> <span class="tok-kw">for</span> (a, <span class="tok-number">0</span>..) |_, ri| {</span>
<span class="line" id="L3714"> <span class="tok-kw">const</span> i = a.len - ri - <span class="tok-number">1</span>;</span>
<span class="line" id="L3715"> <span class="tok-kw">const</span> ai_high = a[i] >> half_limb_bits;</span>
<span class="line" id="L3716"> <span class="tok-kw">const</span> ai_low = a[i] & ((<span class="tok-number">1</span> << half_limb_bits) - <span class="tok-number">1</span>);</span>
<span class="line" id="L3717"></span>
<span class="line" id="L3718"> <span class="tok-comment">// Split the division into two divisions acting on half a limb each. Carry remainder.</span>
</span>
<span class="line" id="L3719"> <span class="tok-kw">const</span> ai_high_with_carry = (rem.* << half_limb_bits) | ai_high;</span>
<span class="line" id="L3720"> <span class="tok-kw">const</span> ai_high_quo = ai_high_with_carry / b;</span>
<span class="line" id="L3721"> rem.* = ai_high_with_carry % b;</span>
<span class="line" id="L3722"></span>
<span class="line" id="L3723"> <span class="tok-kw">const</span> ai_low_with_carry = (rem.* << half_limb_bits) | ai_low;</span>
<span class="line" id="L3724"> <span class="tok-kw">const</span> ai_low_quo = ai_low_with_carry / b;</span>
<span class="line" id="L3725"> rem.* = ai_low_with_carry % b;</span>
<span class="line" id="L3726"></span>
<span class="line" id="L3727"> quo[i] = (ai_high_quo << half_limb_bits) | ai_low_quo;</span>
<span class="line" id="L3728"> }</span>
<span class="line" id="L3729">}</span>
<span class="line" id="L3730"></span>
<span class="line" id="L3731"><span class="tok-kw">fn</span> <span class="tok-fn">llshl</span>(r: []Limb, a: []<span class="tok-kw">const</span> Limb, shift: <span class="tok-type">usize</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L3732"> <span class="tok-builtin">@setRuntimeSafety</span>(debug_safety);</span>
<span class="line" id="L3733"> assert(a.len >= <span class="tok-number">1</span>);</span>
<span class="line" id="L3734"></span>
<span class="line" id="L3735"> <span class="tok-kw">const</span> interior_limb_shift = <span class="tok-builtin">@as</span>(Log2Limb, <span class="tok-builtin">@truncate</span>(shift));</span>
<span class="line" id="L3736"></span>
<span class="line" id="L3737"> <span class="tok-comment">// We only need the extra limb if the shift of the last element overflows.</span>
</span>
<span class="line" id="L3738"> <span class="tok-comment">// This is useful for the implementation of `shiftLeftSat`.</span>
</span>
<span class="line" id="L3739"> <span class="tok-kw">if</span> (a[a.len - <span class="tok-number">1</span>] << interior_limb_shift >> interior_limb_shift != a[a.len - <span class="tok-number">1</span>]) {</span>
<span class="line" id="L3740"> assert(r.len >= a.len + (shift / limb_bits) + <span class="tok-number">1</span>);</span>
<span class="line" id="L3741"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L3742"> assert(r.len >= a.len + (shift / limb_bits));</span>
<span class="line" id="L3743"> }</span>
<span class="line" id="L3744"></span>
<span class="line" id="L3745"> <span class="tok-kw">const</span> limb_shift = shift / limb_bits + <span class="tok-number">1</span>;</span>
<span class="line" id="L3746"></span>
<span class="line" id="L3747"> <span class="tok-kw">var</span> carry: Limb = <span class="tok-number">0</span>;</span>
<span class="line" id="L3748"> <span class="tok-kw">var</span> i: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L3749"> <span class="tok-kw">while</span> (i < a.len) : (i += <span class="tok-number">1</span>) {</span>
<span class="line" id="L3750"> <span class="tok-kw">const</span> src_i = a.len - i - <span class="tok-number">1</span>;</span>
<span class="line" id="L3751"> <span class="tok-kw">const</span> dst_i = src_i + limb_shift;</span>
<span class="line" id="L3752"></span>
<span class="line" id="L3753"> <span class="tok-kw">const</span> src_digit = a[src_i];</span>
<span class="line" id="L3754"> r[dst_i] = carry | <span class="tok-builtin">@call</span>(.always_inline, math.shr, .{</span>
<span class="line" id="L3755"> Limb,</span>
<span class="line" id="L3756"> src_digit,</span>
<span class="line" id="L3757"> limb_bits - <span class="tok-builtin">@as</span>(Limb, <span class="tok-builtin">@intCast</span>(interior_limb_shift)),</span>
<span class="line" id="L3758"> });</span>
<span class="line" id="L3759"> carry = (src_digit << interior_limb_shift);</span>
<span class="line" id="L3760"> }</span>
<span class="line" id="L3761"></span>
<span class="line" id="L3762"> r[limb_shift - <span class="tok-number">1</span>] = carry;</span>
<span class="line" id="L3763"> <span class="tok-builtin">@memset</span>(r[<span class="tok-number">0</span> .. limb_shift - <span class="tok-number">1</span>], <span class="tok-number">0</span>);</span>
<span class="line" id="L3764">}</span>
<span class="line" id="L3765"></span>
<span class="line" id="L3766"><span class="tok-kw">fn</span> <span class="tok-fn">llshr</span>(r: []Limb, a: []<span class="tok-kw">const</span> Limb, shift: <span class="tok-type">usize</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L3767"> <span class="tok-builtin">@setRuntimeSafety</span>(debug_safety);</span>
<span class="line" id="L3768"> assert(a.len >= <span class="tok-number">1</span>);</span>
<span class="line" id="L3769"> assert(r.len >= a.len - (shift / limb_bits));</span>
<span class="line" id="L3770"></span>
<span class="line" id="L3771"> <span class="tok-kw">const</span> limb_shift = shift / limb_bits;</span>
<span class="line" id="L3772"> <span class="tok-kw">const</span> interior_limb_shift = <span class="tok-builtin">@as</span>(Log2Limb, <span class="tok-builtin">@truncate</span>(shift));</span>
<span class="line" id="L3773"></span>
<span class="line" id="L3774"> <span class="tok-kw">var</span> carry: Limb = <span class="tok-number">0</span>;</span>
<span class="line" id="L3775"> <span class="tok-kw">var</span> i: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L3776"> <span class="tok-kw">while</span> (i < a.len - limb_shift) : (i += <span class="tok-number">1</span>) {</span>
<span class="line" id="L3777"> <span class="tok-kw">const</span> src_i = a.len - i - <span class="tok-number">1</span>;</span>
<span class="line" id="L3778"> <span class="tok-kw">const</span> dst_i = src_i - limb_shift;</span>
<span class="line" id="L3779"></span>
<span class="line" id="L3780"> <span class="tok-kw">const</span> src_digit = a[src_i];</span>
<span class="line" id="L3781"> r[dst_i] = carry | (src_digit >> interior_limb_shift);</span>
<span class="line" id="L3782"> carry = <span class="tok-builtin">@call</span>(.always_inline, math.shl, .{</span>
<span class="line" id="L3783"> Limb,</span>
<span class="line" id="L3784"> src_digit,</span>
<span class="line" id="L3785"> limb_bits - <span class="tok-builtin">@as</span>(Limb, <span class="tok-builtin">@intCast</span>(interior_limb_shift)),</span>
<span class="line" id="L3786"> });</span>
<span class="line" id="L3787"> }</span>
<span class="line" id="L3788">}</span>
<span class="line" id="L3789"></span>
<span class="line" id="L3790"><span class="tok-comment">// r = ~r</span>
</span>
<span class="line" id="L3791"><span class="tok-kw">fn</span> <span class="tok-fn">llnot</span>(r: []Limb) <span class="tok-type">void</span> {</span>
<span class="line" id="L3792"> <span class="tok-builtin">@setRuntimeSafety</span>(debug_safety);</span>
<span class="line" id="L3793"></span>
<span class="line" id="L3794"> <span class="tok-kw">for</span> (r) |*elem| {</span>
<span class="line" id="L3795"> elem.* = ~elem.*;</span>
<span class="line" id="L3796"> }</span>
<span class="line" id="L3797">}</span>
<span class="line" id="L3798"></span>
<span class="line" id="L3799"><span class="tok-comment">// r = a | b with 2s complement semantics.</span>
</span>
<span class="line" id="L3800"><span class="tok-comment">// r may alias.</span>
</span>
<span class="line" id="L3801"><span class="tok-comment">// a and b must not be 0.</span>
</span>
<span class="line" id="L3802"><span class="tok-comment">// Returns `true` when the result is positive.</span>
</span>
<span class="line" id="L3803"><span class="tok-comment">// When b is positive, r requires at least `a.len` limbs of storage.</span>
</span>
<span class="line" id="L3804"><span class="tok-comment">// When b is negative, r requires at least `b.len` limbs of storage.</span>
</span>
<span class="line" id="L3805"><span class="tok-kw">fn</span> <span class="tok-fn">llsignedor</span>(r: []Limb, a: []<span class="tok-kw">const</span> Limb, a_positive: <span class="tok-type">bool</span>, b: []<span class="tok-kw">const</span> Limb, b_positive: <span class="tok-type">bool</span>) <span class="tok-type">bool</span> {</span>
<span class="line" id="L3806"> <span class="tok-builtin">@setRuntimeSafety</span>(debug_safety);</span>
<span class="line" id="L3807"> assert(r.len >= a.len);</span>
<span class="line" id="L3808"> assert(a.len >= b.len);</span>
<span class="line" id="L3809"></span>
<span class="line" id="L3810"> <span class="tok-kw">if</span> (a_positive <span class="tok-kw">and</span> b_positive) {</span>
<span class="line" id="L3811"> <span class="tok-comment">// Trivial case, result is positive.</span>
</span>
<span class="line" id="L3812"> <span class="tok-kw">var</span> i: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L3813"> <span class="tok-kw">while</span> (i < b.len) : (i += <span class="tok-number">1</span>) {</span>
<span class="line" id="L3814"> r[i] = a[i] | b[i];</span>
<span class="line" id="L3815"> }</span>
<span class="line" id="L3816"> <span class="tok-kw">while</span> (i < a.len) : (i += <span class="tok-number">1</span>) {</span>
<span class="line" id="L3817"> r[i] = a[i];</span>
<span class="line" id="L3818"> }</span>
<span class="line" id="L3819"></span>
<span class="line" id="L3820"> <span class="tok-kw">return</span> <span class="tok-null">true</span>;</span>
<span class="line" id="L3821"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (!a_positive <span class="tok-kw">and</span> b_positive) {</span>
<span class="line" id="L3822"> <span class="tok-comment">// Result is negative.</span>
</span>
<span class="line" id="L3823"> <span class="tok-comment">// r = (--a) | b</span>
</span>
<span class="line" id="L3824"> <span class="tok-comment">// = ~(-a - 1) | b</span>
</span>
<span class="line" id="L3825"> <span class="tok-comment">// = ~(-a - 1) | ~~b</span>
</span>
<span class="line" id="L3826"> <span class="tok-comment">// = ~((-a - 1) & ~b)</span>
</span>
<span class="line" id="L3827"> <span class="tok-comment">// = -(((-a - 1) & ~b) + 1)</span>
</span>
<span class="line" id="L3828"></span>
<span class="line" id="L3829"> <span class="tok-kw">var</span> i: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L3830"> <span class="tok-kw">var</span> a_borrow: <span class="tok-type">u1</span> = <span class="tok-number">1</span>;</span>
<span class="line" id="L3831"> <span class="tok-kw">var</span> r_carry: <span class="tok-type">u1</span> = <span class="tok-number">1</span>;</span>
<span class="line" id="L3832"></span>
<span class="line" id="L3833"> <span class="tok-kw">while</span> (i < b.len) : (i += <span class="tok-number">1</span>) {</span>
<span class="line" id="L3834"> <span class="tok-kw">const</span> ov1 = <span class="tok-builtin">@subWithOverflow</span>(a[i], a_borrow);</span>
<span class="line" id="L3835"> a_borrow = ov1[<span class="tok-number">1</span>];</span>
<span class="line" id="L3836"> <span class="tok-kw">const</span> ov2 = <span class="tok-builtin">@addWithOverflow</span>(ov1[<span class="tok-number">0</span>] & ~b[i], r_carry);</span>
<span class="line" id="L3837"> r[i] = ov2[<span class="tok-number">0</span>];</span>
<span class="line" id="L3838"> r_carry = ov2[<span class="tok-number">1</span>];</span>
<span class="line" id="L3839"> }</span>
<span class="line" id="L3840"></span>
<span class="line" id="L3841"> <span class="tok-comment">// In order for r_carry to be nonzero at this point, ~b[i] would need to be</span>
</span>
<span class="line" id="L3842"> <span class="tok-comment">// all ones, which would require b[i] to be zero. This cannot be when</span>
</span>
<span class="line" id="L3843"> <span class="tok-comment">// b is normalized, so there cannot be a carry here.</span>
</span>
<span class="line" id="L3844"> <span class="tok-comment">// Also, x & ~b can only clear bits, so (x & ~b) <= x, meaning (-a - 1) + 1 never overflows.</span>
</span>
<span class="line" id="L3845"> assert(r_carry == <span class="tok-number">0</span>);</span>
<span class="line" id="L3846"></span>
<span class="line" id="L3847"> <span class="tok-comment">// With b = 0, we get (-a - 1) & ~0 = -a - 1.</span>
</span>
<span class="line" id="L3848"> <span class="tok-comment">// Note, if a_borrow is zero we do not need to compute anything for</span>
</span>
<span class="line" id="L3849"> <span class="tok-comment">// the higher limbs so we can early return here.</span>
</span>
<span class="line" id="L3850"> <span class="tok-kw">while</span> (i < a.len <span class="tok-kw">and</span> a_borrow == <span class="tok-number">1</span>) : (i += <span class="tok-number">1</span>) {</span>
<span class="line" id="L3851"> <span class="tok-kw">const</span> ov = <span class="tok-builtin">@subWithOverflow</span>(a[i], a_borrow);</span>
<span class="line" id="L3852"> r[i] = ov[<span class="tok-number">0</span>];</span>
<span class="line" id="L3853"> a_borrow = ov[<span class="tok-number">1</span>];</span>
<span class="line" id="L3854"> }</span>
<span class="line" id="L3855"></span>
<span class="line" id="L3856"> assert(a_borrow == <span class="tok-number">0</span>); <span class="tok-comment">// a was 0.</span>
</span>
<span class="line" id="L3857"></span>
<span class="line" id="L3858"> <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L3859"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (a_positive <span class="tok-kw">and</span> !b_positive) {</span>
<span class="line" id="L3860"> <span class="tok-comment">// Result is negative.</span>
</span>
<span class="line" id="L3861"> <span class="tok-comment">// r = a | (--b)</span>
</span>
<span class="line" id="L3862"> <span class="tok-comment">// = a | ~(-b - 1)</span>
</span>
<span class="line" id="L3863"> <span class="tok-comment">// = ~~a | ~(-b - 1)</span>
</span>
<span class="line" id="L3864"> <span class="tok-comment">// = ~(~a & (-b - 1))</span>
</span>
<span class="line" id="L3865"> <span class="tok-comment">// = -((~a & (-b - 1)) + 1)</span>
</span>
<span class="line" id="L3866"></span>
<span class="line" id="L3867"> <span class="tok-kw">var</span> i: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L3868"> <span class="tok-kw">var</span> b_borrow: <span class="tok-type">u1</span> = <span class="tok-number">1</span>;</span>
<span class="line" id="L3869"> <span class="tok-kw">var</span> r_carry: <span class="tok-type">u1</span> = <span class="tok-number">1</span>;</span>
<span class="line" id="L3870"></span>
<span class="line" id="L3871"> <span class="tok-kw">while</span> (i < b.len) : (i += <span class="tok-number">1</span>) {</span>
<span class="line" id="L3872"> <span class="tok-kw">const</span> ov1 = <span class="tok-builtin">@subWithOverflow</span>(b[i], b_borrow);</span>
<span class="line" id="L3873"> b_borrow = ov1[<span class="tok-number">1</span>];</span>
<span class="line" id="L3874"> <span class="tok-kw">const</span> ov2 = <span class="tok-builtin">@addWithOverflow</span>(~a[i] & ov1[<span class="tok-number">0</span>], r_carry);</span>
<span class="line" id="L3875"> r[i] = ov2[<span class="tok-number">0</span>];</span>
<span class="line" id="L3876"> r_carry = ov2[<span class="tok-number">1</span>];</span>
<span class="line" id="L3877"> }</span>
<span class="line" id="L3878"></span>
<span class="line" id="L3879"> <span class="tok-comment">// b is at least 1, so this should never underflow.</span>
</span>
<span class="line" id="L3880"> assert(b_borrow == <span class="tok-number">0</span>); <span class="tok-comment">// b was 0</span>
</span>
<span class="line" id="L3881"></span>
<span class="line" id="L3882"> <span class="tok-comment">// x & ~a can only clear bits, so (x & ~a) <= x, meaning (-b - 1) + 1 never overflows.</span>
</span>
<span class="line" id="L3883"> assert(r_carry == <span class="tok-number">0</span>);</span>
<span class="line" id="L3884"></span>
<span class="line" id="L3885"> <span class="tok-comment">// With b = 0 and b_borrow = 0, we get ~a & (-0 - 0) = ~a & 0 = 0.</span>
</span>
<span class="line" id="L3886"> <span class="tok-comment">// Omit setting the upper bytes, just deal with those when calling llsignedor.</span>
</span>
<span class="line" id="L3887"></span>
<span class="line" id="L3888"> <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L3889"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L3890"> <span class="tok-comment">// Result is negative.</span>
</span>
<span class="line" id="L3891"> <span class="tok-comment">// r = (--a) | (--b)</span>
</span>
<span class="line" id="L3892"> <span class="tok-comment">// = ~(-a - 1) | ~(-b - 1)</span>
</span>
<span class="line" id="L3893"> <span class="tok-comment">// = ~((-a - 1) & (-b - 1))</span>
</span>
<span class="line" id="L3894"> <span class="tok-comment">// = -(~(~((-a - 1) & (-b - 1))) + 1)</span>
</span>
<span class="line" id="L3895"> <span class="tok-comment">// = -((-a - 1) & (-b - 1) + 1)</span>
</span>
<span class="line" id="L3896"></span>
<span class="line" id="L3897"> <span class="tok-kw">var</span> i: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L3898"> <span class="tok-kw">var</span> a_borrow: <span class="tok-type">u1</span> = <span class="tok-number">1</span>;</span>
<span class="line" id="L3899"> <span class="tok-kw">var</span> b_borrow: <span class="tok-type">u1</span> = <span class="tok-number">1</span>;</span>
<span class="line" id="L3900"> <span class="tok-kw">var</span> r_carry: <span class="tok-type">u1</span> = <span class="tok-number">1</span>;</span>
<span class="line" id="L3901"></span>
<span class="line" id="L3902"> <span class="tok-kw">while</span> (i < b.len) : (i += <span class="tok-number">1</span>) {</span>
<span class="line" id="L3903"> <span class="tok-kw">const</span> ov1 = <span class="tok-builtin">@subWithOverflow</span>(a[i], a_borrow);</span>
<span class="line" id="L3904"> a_borrow = ov1[<span class="tok-number">1</span>];</span>
<span class="line" id="L3905"> <span class="tok-kw">const</span> ov2 = <span class="tok-builtin">@subWithOverflow</span>(b[i], b_borrow);</span>
<span class="line" id="L3906"> b_borrow = ov2[<span class="tok-number">1</span>];</span>
<span class="line" id="L3907"> <span class="tok-kw">const</span> ov3 = <span class="tok-builtin">@addWithOverflow</span>(ov1[<span class="tok-number">0</span>] & ov2[<span class="tok-number">0</span>], r_carry);</span>
<span class="line" id="L3908"> r[i] = ov3[<span class="tok-number">0</span>];</span>
<span class="line" id="L3909"> r_carry = ov3[<span class="tok-number">1</span>];</span>
<span class="line" id="L3910"> }</span>
<span class="line" id="L3911"></span>
<span class="line" id="L3912"> <span class="tok-comment">// b is at least 1, so this should never underflow.</span>
</span>
<span class="line" id="L3913"> assert(b_borrow == <span class="tok-number">0</span>); <span class="tok-comment">// b was 0</span>
</span>
<span class="line" id="L3914"></span>
<span class="line" id="L3915"> <span class="tok-comment">// Can never overflow because in order for b_limb to be maxInt(Limb),</span>
</span>
<span class="line" id="L3916"> <span class="tok-comment">// b_borrow would need to equal 1.</span>
</span>
<span class="line" id="L3917"></span>
<span class="line" id="L3918"> <span class="tok-comment">// x & y can only clear bits, meaning x & y <= x and x & y <= y. This implies that</span>
</span>
<span class="line" id="L3919"> <span class="tok-comment">// for x = a - 1 and y = b - 1, the +1 term would never cause an overflow.</span>
</span>
<span class="line" id="L3920"> assert(r_carry == <span class="tok-number">0</span>);</span>
<span class="line" id="L3921"></span>
<span class="line" id="L3922"> <span class="tok-comment">// With b = 0 and b_borrow = 0 we get (-a - 1) & (-0 - 0) = (-a - 1) & 0 = 0.</span>
</span>
<span class="line" id="L3923"> <span class="tok-comment">// Omit setting the upper bytes, just deal with those when calling llsignedor.</span>
</span>
<span class="line" id="L3924"> <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L3925"> }</span>
<span class="line" id="L3926">}</span>
<span class="line" id="L3927"></span>
<span class="line" id="L3928"><span class="tok-comment">// r = a & b with 2s complement semantics.</span>
</span>
<span class="line" id="L3929"><span class="tok-comment">// r may alias.</span>
</span>
<span class="line" id="L3930"><span class="tok-comment">// a and b must not be 0.</span>
</span>
<span class="line" id="L3931"><span class="tok-comment">// Returns `true` when the result is positive.</span>
</span>
<span class="line" id="L3932"><span class="tok-comment">// When either or both of a and b are positive, r requires at least `b.len` limbs of storage.</span>
</span>
<span class="line" id="L3933"><span class="tok-comment">// When both a and b are negative, r requires at least `a.limbs.len + 1` limbs of storage.</span>
</span>
<span class="line" id="L3934"><span class="tok-kw">fn</span> <span class="tok-fn">llsignedand</span>(r: []Limb, a: []<span class="tok-kw">const</span> Limb, a_positive: <span class="tok-type">bool</span>, b: []<span class="tok-kw">const</span> Limb, b_positive: <span class="tok-type">bool</span>) <span class="tok-type">bool</span> {</span>
<span class="line" id="L3935"> <span class="tok-builtin">@setRuntimeSafety</span>(debug_safety);</span>
<span class="line" id="L3936"> assert(a.len != <span class="tok-number">0</span> <span class="tok-kw">and</span> b.len != <span class="tok-number">0</span>);</span>
<span class="line" id="L3937"> assert(a.len >= b.len);</span>
<span class="line" id="L3938"> assert(r.len >= <span class="tok-kw">if</span> (!a_positive <span class="tok-kw">and</span> !b_positive) a.len + <span class="tok-number">1</span> <span class="tok-kw">else</span> b.len);</span>
<span class="line" id="L3939"></span>
<span class="line" id="L3940"> <span class="tok-kw">if</span> (a_positive <span class="tok-kw">and</span> b_positive) {</span>
<span class="line" id="L3941"> <span class="tok-comment">// Trivial case, result is positive.</span>
</span>
<span class="line" id="L3942"> <span class="tok-kw">var</span> i: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L3943"> <span class="tok-kw">while</span> (i < b.len) : (i += <span class="tok-number">1</span>) {</span>
<span class="line" id="L3944"> r[i] = a[i] & b[i];</span>
<span class="line" id="L3945"> }</span>
<span class="line" id="L3946"></span>
<span class="line" id="L3947"> <span class="tok-comment">// With b = 0 we have a & 0 = 0, so the upper bytes are zero.</span>
</span>
<span class="line" id="L3948"> <span class="tok-comment">// Omit setting them here and simply discard them whenever</span>
</span>
<span class="line" id="L3949"> <span class="tok-comment">// llsignedand is called.</span>
</span>
<span class="line" id="L3950"></span>
<span class="line" id="L3951"> <span class="tok-kw">return</span> <span class="tok-null">true</span>;</span>
<span class="line" id="L3952"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (!a_positive <span class="tok-kw">and</span> b_positive) {</span>
<span class="line" id="L3953"> <span class="tok-comment">// Result is positive.</span>
</span>
<span class="line" id="L3954"> <span class="tok-comment">// r = (--a) & b</span>
</span>
<span class="line" id="L3955"> <span class="tok-comment">// = ~(-a - 1) & b</span>
</span>
<span class="line" id="L3956"></span>
<span class="line" id="L3957"> <span class="tok-kw">var</span> i: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L3958"> <span class="tok-kw">var</span> a_borrow: <span class="tok-type">u1</span> = <span class="tok-number">1</span>;</span>
<span class="line" id="L3959"></span>
<span class="line" id="L3960"> <span class="tok-kw">while</span> (i < b.len) : (i += <span class="tok-number">1</span>) {</span>
<span class="line" id="L3961"> <span class="tok-kw">const</span> ov = <span class="tok-builtin">@subWithOverflow</span>(a[i], a_borrow);</span>
<span class="line" id="L3962"> a_borrow = ov[<span class="tok-number">1</span>];</span>
<span class="line" id="L3963"> r[i] = ~ov[<span class="tok-number">0</span>] & b[i];</span>
<span class="line" id="L3964"> }</span>
<span class="line" id="L3965"></span>
<span class="line" id="L3966"> <span class="tok-comment">// With b = 0 we have ~(a - 1) & 0 = 0, so the upper bytes are zero.</span>
</span>
<span class="line" id="L3967"> <span class="tok-comment">// Omit setting them here and simply discard them whenever</span>
</span>
<span class="line" id="L3968"> <span class="tok-comment">// llsignedand is called.</span>
</span>
<span class="line" id="L3969"></span>
<span class="line" id="L3970"> <span class="tok-kw">return</span> <span class="tok-null">true</span>;</span>
<span class="line" id="L3971"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (a_positive <span class="tok-kw">and</span> !b_positive) {</span>
<span class="line" id="L3972"> <span class="tok-comment">// Result is positive.</span>
</span>
<span class="line" id="L3973"> <span class="tok-comment">// r = a & (--b)</span>
</span>
<span class="line" id="L3974"> <span class="tok-comment">// = a & ~(-b - 1)</span>
</span>
<span class="line" id="L3975"></span>
<span class="line" id="L3976"> <span class="tok-kw">var</span> i: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L3977"> <span class="tok-kw">var</span> b_borrow: <span class="tok-type">u1</span> = <span class="tok-number">1</span>;</span>
<span class="line" id="L3978"></span>
<span class="line" id="L3979"> <span class="tok-kw">while</span> (i < b.len) : (i += <span class="tok-number">1</span>) {</span>
<span class="line" id="L3980"> <span class="tok-kw">const</span> ov = <span class="tok-builtin">@subWithOverflow</span>(b[i], b_borrow);</span>
<span class="line" id="L3981"> b_borrow = ov[<span class="tok-number">1</span>];</span>
<span class="line" id="L3982"> r[i] = a[i] & ~ov[<span class="tok-number">0</span>];</span>
<span class="line" id="L3983"> }</span>
<span class="line" id="L3984"></span>
<span class="line" id="L3985"> assert(b_borrow == <span class="tok-number">0</span>); <span class="tok-comment">// b was 0</span>
</span>
<span class="line" id="L3986"></span>
<span class="line" id="L3987"> <span class="tok-comment">// With b = 0 and b_borrow = 0 we have a & ~(-0 - 0) = a & 0 = 0, so</span>
</span>
<span class="line" id="L3988"> <span class="tok-comment">// the upper bytes are zero. Omit setting them here and simply discard</span>
</span>
<span class="line" id="L3989"> <span class="tok-comment">// them whenever llsignedand is called.</span>
</span>
<span class="line" id="L3990"></span>
<span class="line" id="L3991"> <span class="tok-kw">return</span> <span class="tok-null">true</span>;</span>
<span class="line" id="L3992"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L3993"> <span class="tok-comment">// Result is negative.</span>
</span>
<span class="line" id="L3994"> <span class="tok-comment">// r = (--a) & (--b)</span>
</span>
<span class="line" id="L3995"> <span class="tok-comment">// = ~(-a - 1) & ~(-b - 1)</span>
</span>
<span class="line" id="L3996"> <span class="tok-comment">// = ~((-a - 1) | (-b - 1))</span>
</span>
<span class="line" id="L3997"> <span class="tok-comment">// = -(((-a - 1) | (-b - 1)) + 1)</span>
</span>
<span class="line" id="L3998"></span>
<span class="line" id="L3999"> <span class="tok-kw">var</span> i: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L4000"> <span class="tok-kw">var</span> a_borrow: <span class="tok-type">u1</span> = <span class="tok-number">1</span>;</span>
<span class="line" id="L4001"> <span class="tok-kw">var</span> b_borrow: <span class="tok-type">u1</span> = <span class="tok-number">1</span>;</span>
<span class="line" id="L4002"> <span class="tok-kw">var</span> r_carry: <span class="tok-type">u1</span> = <span class="tok-number">1</span>;</span>
<span class="line" id="L4003"></span>
<span class="line" id="L4004"> <span class="tok-kw">while</span> (i < b.len) : (i += <span class="tok-number">1</span>) {</span>
<span class="line" id="L4005"> <span class="tok-kw">const</span> ov1 = <span class="tok-builtin">@subWithOverflow</span>(a[i], a_borrow);</span>
<span class="line" id="L4006"> a_borrow = ov1[<span class="tok-number">1</span>];</span>
<span class="line" id="L4007"> <span class="tok-kw">const</span> ov2 = <span class="tok-builtin">@subWithOverflow</span>(b[i], b_borrow);</span>
<span class="line" id="L4008"> b_borrow = ov2[<span class="tok-number">1</span>];</span>
<span class="line" id="L4009"> <span class="tok-kw">const</span> ov3 = <span class="tok-builtin">@addWithOverflow</span>(ov1[<span class="tok-number">0</span>] | ov2[<span class="tok-number">0</span>], r_carry);</span>
<span class="line" id="L4010"> r[i] = ov3[<span class="tok-number">0</span>];</span>
<span class="line" id="L4011"> r_carry = ov3[<span class="tok-number">1</span>];</span>
<span class="line" id="L4012"> }</span>
<span class="line" id="L4013"></span>
<span class="line" id="L4014"> <span class="tok-comment">// b is at least 1, so this should never underflow.</span>
</span>
<span class="line" id="L4015"> assert(b_borrow == <span class="tok-number">0</span>); <span class="tok-comment">// b was 0</span>
</span>
<span class="line" id="L4016"></span>
<span class="line" id="L4017"> <span class="tok-comment">// With b = 0 and b_borrow = 0 we get (-a - 1) | (-0 - 0) = (-a - 1) | 0 = -a - 1.</span>
</span>
<span class="line" id="L4018"> <span class="tok-kw">while</span> (i < a.len) : (i += <span class="tok-number">1</span>) {</span>
<span class="line" id="L4019"> <span class="tok-kw">const</span> ov1 = <span class="tok-builtin">@subWithOverflow</span>(a[i], a_borrow);</span>
<span class="line" id="L4020"> a_borrow = ov1[<span class="tok-number">1</span>];</span>
<span class="line" id="L4021"> <span class="tok-kw">const</span> ov2 = <span class="tok-builtin">@addWithOverflow</span>(ov1[<span class="tok-number">0</span>], r_carry);</span>
<span class="line" id="L4022"> r[i] = ov2[<span class="tok-number">0</span>];</span>
<span class="line" id="L4023"> r_carry = ov2[<span class="tok-number">1</span>];</span>
<span class="line" id="L4024"> }</span>
<span class="line" id="L4025"></span>
<span class="line" id="L4026"> assert(a_borrow == <span class="tok-number">0</span>); <span class="tok-comment">// a was 0.</span>
</span>
<span class="line" id="L4027"></span>
<span class="line" id="L4028"> <span class="tok-comment">// The final addition can overflow here, so we need to keep that in mind.</span>
</span>
<span class="line" id="L4029"> r[i] = r_carry;</span>
<span class="line" id="L4030"></span>
<span class="line" id="L4031"> <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L4032"> }</span>
<span class="line" id="L4033">}</span>
<span class="line" id="L4034"></span>
<span class="line" id="L4035"><span class="tok-comment">// r = a ^ b with 2s complement semantics.</span>
</span>
<span class="line" id="L4036"><span class="tok-comment">// r may alias.</span>
</span>
<span class="line" id="L4037"><span class="tok-comment">// a and b must not be -0.</span>
</span>
<span class="line" id="L4038"><span class="tok-comment">// Returns `true` when the result is positive.</span>
</span>
<span class="line" id="L4039"><span class="tok-comment">// If the sign of a and b is equal, then r requires at least `@max(a.len, b.len)` limbs are required.</span>
</span>
<span class="line" id="L4040"><span class="tok-comment">// Otherwise, r requires at least `@max(a.len, b.len) + 1` limbs.</span>
</span>
<span class="line" id="L4041"><span class="tok-kw">fn</span> <span class="tok-fn">llsignedxor</span>(r: []Limb, a: []<span class="tok-kw">const</span> Limb, a_positive: <span class="tok-type">bool</span>, b: []<span class="tok-kw">const</span> Limb, b_positive: <span class="tok-type">bool</span>) <span class="tok-type">bool</span> {</span>
<span class="line" id="L4042"> <span class="tok-builtin">@setRuntimeSafety</span>(debug_safety);</span>
<span class="line" id="L4043"> assert(a.len != <span class="tok-number">0</span> <span class="tok-kw">and</span> b.len != <span class="tok-number">0</span>);</span>
<span class="line" id="L4044"> assert(r.len >= a.len);</span>
<span class="line" id="L4045"> assert(a.len >= b.len);</span>
<span class="line" id="L4046"></span>
<span class="line" id="L4047"> <span class="tok-comment">// If a and b are positive, the result is positive and r = a ^ b.</span>
</span>
<span class="line" id="L4048"> <span class="tok-comment">// If a negative, b positive, result is negative and we have</span>
</span>
<span class="line" id="L4049"> <span class="tok-comment">// r = --(--a ^ b)</span>
</span>
<span class="line" id="L4050"> <span class="tok-comment">// = --(~(-a - 1) ^ b)</span>
</span>
<span class="line" id="L4051"> <span class="tok-comment">// = -(~(~(-a - 1) ^ b) + 1)</span>
</span>
<span class="line" id="L4052"> <span class="tok-comment">// = -(((-a - 1) ^ b) + 1)</span>
</span>
<span class="line" id="L4053"> <span class="tok-comment">// Same if a is positive and b is negative, sides switched.</span>
</span>
<span class="line" id="L4054"> <span class="tok-comment">// If both a and b are negative, the result is positive and we have</span>
</span>
<span class="line" id="L4055"> <span class="tok-comment">// r = (--a) ^ (--b)</span>
</span>
<span class="line" id="L4056"> <span class="tok-comment">// = ~(-a - 1) ^ ~(-b - 1)</span>
</span>
<span class="line" id="L4057"> <span class="tok-comment">// = (-a - 1) ^ (-b - 1)</span>
</span>
<span class="line" id="L4058"> <span class="tok-comment">// These operations can be made more generic as follows:</span>
</span>
<span class="line" id="L4059"> <span class="tok-comment">// - If a is negative, subtract 1 from |a| before the xor.</span>
</span>
<span class="line" id="L4060"> <span class="tok-comment">// - If b is negative, subtract 1 from |b| before the xor.</span>
</span>
<span class="line" id="L4061"> <span class="tok-comment">// - if the result is supposed to be negative, add 1.</span>
</span>
<span class="line" id="L4062"></span>
<span class="line" id="L4063"> <span class="tok-kw">var</span> i: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L4064"> <span class="tok-kw">var</span> a_borrow = <span class="tok-builtin">@intFromBool</span>(!a_positive);</span>
<span class="line" id="L4065"> <span class="tok-kw">var</span> b_borrow = <span class="tok-builtin">@intFromBool</span>(!b_positive);</span>
<span class="line" id="L4066"> <span class="tok-kw">var</span> r_carry = <span class="tok-builtin">@intFromBool</span>(a_positive != b_positive);</span>
<span class="line" id="L4067"></span>
<span class="line" id="L4068"> <span class="tok-kw">while</span> (i < b.len) : (i += <span class="tok-number">1</span>) {</span>
<span class="line" id="L4069"> <span class="tok-kw">const</span> ov1 = <span class="tok-builtin">@subWithOverflow</span>(a[i], a_borrow);</span>
<span class="line" id="L4070"> a_borrow = ov1[<span class="tok-number">1</span>];</span>
<span class="line" id="L4071"> <span class="tok-kw">const</span> ov2 = <span class="tok-builtin">@subWithOverflow</span>(b[i], b_borrow);</span>
<span class="line" id="L4072"> b_borrow = ov2[<span class="tok-number">1</span>];</span>
<span class="line" id="L4073"> <span class="tok-kw">const</span> ov3 = <span class="tok-builtin">@addWithOverflow</span>(ov1[<span class="tok-number">0</span>] ^ ov2[<span class="tok-number">0</span>], r_carry);</span>
<span class="line" id="L4074"> r[i] = ov3[<span class="tok-number">0</span>];</span>
<span class="line" id="L4075"> r_carry = ov3[<span class="tok-number">1</span>];</span>
<span class="line" id="L4076"> }</span>
<span class="line" id="L4077"></span>
<span class="line" id="L4078"> <span class="tok-kw">while</span> (i < a.len) : (i += <span class="tok-number">1</span>) {</span>
<span class="line" id="L4079"> <span class="tok-kw">const</span> ov1 = <span class="tok-builtin">@subWithOverflow</span>(a[i], a_borrow);</span>
<span class="line" id="L4080"> a_borrow = ov1[<span class="tok-number">1</span>];</span>
<span class="line" id="L4081"> <span class="tok-kw">const</span> ov2 = <span class="tok-builtin">@addWithOverflow</span>(ov1[<span class="tok-number">0</span>], r_carry);</span>
<span class="line" id="L4082"> r[i] = ov2[<span class="tok-number">0</span>];</span>
<span class="line" id="L4083"> r_carry = ov2[<span class="tok-number">1</span>];</span>
<span class="line" id="L4084"> }</span>
<span class="line" id="L4085"></span>
<span class="line" id="L4086"> <span class="tok-comment">// If both inputs don't share the same sign, an extra limb is required.</span>
</span>
<span class="line" id="L4087"> <span class="tok-kw">if</span> (a_positive != b_positive) {</span>
<span class="line" id="L4088"> r[i] = r_carry;</span>
<span class="line" id="L4089"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L4090"> assert(r_carry == <span class="tok-number">0</span>);</span>
<span class="line" id="L4091"> }</span>
<span class="line" id="L4092"></span>
<span class="line" id="L4093"> assert(a_borrow == <span class="tok-number">0</span>);</span>
<span class="line" id="L4094"> assert(b_borrow == <span class="tok-number">0</span>);</span>
<span class="line" id="L4095"></span>
<span class="line" id="L4096"> <span class="tok-kw">return</span> a_positive == b_positive;</span>
<span class="line" id="L4097">}</span>
<span class="line" id="L4098"></span>
<span class="line" id="L4099"><span class="tok-comment">/// r MUST NOT alias x.</span></span>
<span class="line" id="L4100"><span class="tok-kw">fn</span> <span class="tok-fn">llsquareBasecase</span>(r: []Limb, x: []<span class="tok-kw">const</span> Limb) <span class="tok-type">void</span> {</span>
<span class="line" id="L4101"> <span class="tok-builtin">@setRuntimeSafety</span>(debug_safety);</span>
<span class="line" id="L4102"></span>
<span class="line" id="L4103"> <span class="tok-kw">const</span> x_norm = x;</span>
<span class="line" id="L4104"> assert(r.len >= <span class="tok-number">2</span> * x_norm.len + <span class="tok-number">1</span>);</span>
<span class="line" id="L4105"></span>
<span class="line" id="L4106"> <span class="tok-comment">// Compute the square of a N-limb bigint with only (N^2 + N)/2</span>
</span>
<span class="line" id="L4107"> <span class="tok-comment">// multiplications by exploiting the symmetry of the coefficients around the</span>
</span>
<span class="line" id="L4108"> <span class="tok-comment">// diagonal:</span>
</span>
<span class="line" id="L4109"> <span class="tok-comment">//</span>
</span>
<span class="line" id="L4110"> <span class="tok-comment">// a b c *</span>
</span>
<span class="line" id="L4111"> <span class="tok-comment">// a b c =</span>
</span>
<span class="line" id="L4112"> <span class="tok-comment">// -------------------</span>
</span>
<span class="line" id="L4113"> <span class="tok-comment">// ca cb cc +</span>
</span>
<span class="line" id="L4114"> <span class="tok-comment">// ba bb bc +</span>
</span>
<span class="line" id="L4115"> <span class="tok-comment">// aa ab ac</span>
</span>
<span class="line" id="L4116"> <span class="tok-comment">//</span>
</span>
<span class="line" id="L4117"> <span class="tok-comment">// Note that:</span>
</span>
<span class="line" id="L4118"> <span class="tok-comment">// - Each mixed-product term appears twice for each column,</span>
</span>
<span class="line" id="L4119"> <span class="tok-comment">// - Squares are always in the 2k (0 <= k < N) column</span>
</span>
<span class="line" id="L4120"></span>
<span class="line" id="L4121"> <span class="tok-kw">for</span> (x_norm, <span class="tok-number">0</span>..) |v, i| {</span>
<span class="line" id="L4122"> <span class="tok-comment">// Accumulate all the x[i]*x[j] (with x!=j) products</span>
</span>
<span class="line" id="L4123"> <span class="tok-kw">const</span> overflow = llmulLimb(.add, r[<span class="tok-number">2</span> * i + <span class="tok-number">1</span> ..], x_norm[i + <span class="tok-number">1</span> ..], v);</span>
<span class="line" id="L4124"> assert(!overflow);</span>
<span class="line" id="L4125"> }</span>
<span class="line" id="L4126"></span>
<span class="line" id="L4127"> <span class="tok-comment">// Each product appears twice, multiply by 2</span>
</span>
<span class="line" id="L4128"> llshl(r, r[<span class="tok-number">0</span> .. <span class="tok-number">2</span> * x_norm.len], <span class="tok-number">1</span>);</span>
<span class="line" id="L4129"></span>
<span class="line" id="L4130"> <span class="tok-kw">for</span> (x_norm, <span class="tok-number">0</span>..) |v, i| {</span>
<span class="line" id="L4131"> <span class="tok-comment">// Compute and add the squares</span>
</span>
<span class="line" id="L4132"> <span class="tok-kw">const</span> overflow = llmulLimb(.add, r[<span class="tok-number">2</span> * i ..], x[i..][<span class="tok-number">0</span>..<span class="tok-number">1</span>], v);</span>
<span class="line" id="L4133"> assert(!overflow);</span>
<span class="line" id="L4134"> }</span>
<span class="line" id="L4135">}</span>
<span class="line" id="L4136"></span>
<span class="line" id="L4137"><span class="tok-comment">/// Knuth 4.6.3</span></span>
<span class="line" id="L4138"><span class="tok-kw">fn</span> <span class="tok-fn">llpow</span>(r: []Limb, a: []<span class="tok-kw">const</span> Limb, b: <span class="tok-type">u32</span>, tmp_limbs: []Limb) <span class="tok-type">void</span> {</span>
<span class="line" id="L4139"> <span class="tok-kw">var</span> tmp1: []Limb = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L4140"> <span class="tok-kw">var</span> tmp2: []Limb = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L4141"></span>
<span class="line" id="L4142"> <span class="tok-comment">// Multiplication requires no aliasing between the operand and the result</span>
</span>
<span class="line" id="L4143"> <span class="tok-comment">// variable, use the output limbs and another temporary set to overcome this</span>
</span>
<span class="line" id="L4144"> <span class="tok-comment">// limitation.</span>
</span>
<span class="line" id="L4145"> <span class="tok-comment">// The initial assignment makes the result end in `r` so an extra memory</span>
</span>
<span class="line" id="L4146"> <span class="tok-comment">// copy is saved, each 1 flips the index twice so it's only the zeros that</span>
</span>
<span class="line" id="L4147"> <span class="tok-comment">// matter.</span>
</span>
<span class="line" id="L4148"> <span class="tok-kw">const</span> b_leading_zeros = <span class="tok-builtin">@clz</span>(b);</span>
<span class="line" id="L4149"> <span class="tok-kw">const</span> exp_zeros = <span class="tok-builtin">@popCount</span>(~b) - b_leading_zeros;</span>
<span class="line" id="L4150"> <span class="tok-kw">if</span> (exp_zeros & <span class="tok-number">1</span> != <span class="tok-number">0</span>) {</span>
<span class="line" id="L4151"> tmp1 = tmp_limbs;</span>
<span class="line" id="L4152"> tmp2 = r;</span>
<span class="line" id="L4153"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L4154"> tmp1 = r;</span>
<span class="line" id="L4155"> tmp2 = tmp_limbs;</span>
<span class="line" id="L4156"> }</span>
<span class="line" id="L4157"></span>
<span class="line" id="L4158"> <span class="tok-builtin">@memcpy</span>(tmp1[<span class="tok-number">0</span>..a.len], a);</span>
<span class="line" id="L4159"> <span class="tok-builtin">@memset</span>(tmp1[a.len..], <span class="tok-number">0</span>);</span>
<span class="line" id="L4160"></span>
<span class="line" id="L4161"> <span class="tok-comment">// Scan the exponent as a binary number, from left to right, dropping the</span>
</span>
<span class="line" id="L4162"> <span class="tok-comment">// most significant bit set.</span>
</span>
<span class="line" id="L4163"> <span class="tok-comment">// Square the result if the current bit is zero, square and multiply by a if</span>
</span>
<span class="line" id="L4164"> <span class="tok-comment">// it is one.</span>
</span>
<span class="line" id="L4165"> <span class="tok-kw">var</span> exp_bits = <span class="tok-number">32</span> - <span class="tok-number">1</span> - b_leading_zeros;</span>
<span class="line" id="L4166"> <span class="tok-kw">var</span> exp = b << <span class="tok-builtin">@as</span>(<span class="tok-type">u5</span>, <span class="tok-builtin">@intCast</span>(<span class="tok-number">1</span> + b_leading_zeros));</span>
<span class="line" id="L4167"></span>
<span class="line" id="L4168"> <span class="tok-kw">var</span> i: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L4169"> <span class="tok-kw">while</span> (i < exp_bits) : (i += <span class="tok-number">1</span>) {</span>
<span class="line" id="L4170"> <span class="tok-comment">// Square</span>
</span>
<span class="line" id="L4171"> <span class="tok-builtin">@memset</span>(tmp2, <span class="tok-number">0</span>);</span>
<span class="line" id="L4172"> llsquareBasecase(tmp2, tmp1[<span class="tok-number">0</span>..llnormalize(tmp1)]);</span>
<span class="line" id="L4173"> mem.swap([]Limb, &tmp1, &tmp2);</span>
<span class="line" id="L4174"> <span class="tok-comment">// Multiply by a</span>
</span>
<span class="line" id="L4175"> <span class="tok-kw">const</span> ov = <span class="tok-builtin">@shlWithOverflow</span>(exp, <span class="tok-number">1</span>);</span>
<span class="line" id="L4176"> exp = ov[<span class="tok-number">0</span>];</span>
<span class="line" id="L4177"> <span class="tok-kw">if</span> (ov[<span class="tok-number">1</span>] != <span class="tok-number">0</span>) {</span>
<span class="line" id="L4178"> <span class="tok-builtin">@memset</span>(tmp2, <span class="tok-number">0</span>);</span>
<span class="line" id="L4179"> llmulacc(.add, <span class="tok-null">null</span>, tmp2, tmp1[<span class="tok-number">0</span>..llnormalize(tmp1)], a);</span>
<span class="line" id="L4180"> mem.swap([]Limb, &tmp1, &tmp2);</span>
<span class="line" id="L4181"> }</span>
<span class="line" id="L4182"> }</span>
<span class="line" id="L4183">}</span>
<span class="line" id="L4184"></span>
<span class="line" id="L4185"><span class="tok-comment">// Storage must live for the lifetime of the returned value</span>
</span>
<span class="line" id="L4186"><span class="tok-kw">fn</span> <span class="tok-fn">fixedIntFromSignedDoubleLimb</span>(A: SignedDoubleLimb, storage: []Limb) Mutable {</span>
<span class="line" id="L4187"> assert(storage.len >= <span class="tok-number">2</span>);</span>
<span class="line" id="L4188"></span>
<span class="line" id="L4189"> <span class="tok-kw">const</span> A_is_positive = A >= <span class="tok-number">0</span>;</span>
<span class="line" id="L4190"> <span class="tok-kw">const</span> Au = <span class="tok-builtin">@as</span>(DoubleLimb, <span class="tok-builtin">@intCast</span>(<span class="tok-kw">if</span> (A < <span class="tok-number">0</span>) -A <span class="tok-kw">else</span> A));</span>
<span class="line" id="L4191"> storage[<span class="tok-number">0</span>] = <span class="tok-builtin">@as</span>(Limb, <span class="tok-builtin">@truncate</span>(Au));</span>
<span class="line" id="L4192"> storage[<span class="tok-number">1</span>] = <span class="tok-builtin">@as</span>(Limb, <span class="tok-builtin">@truncate</span>(Au >> limb_bits));</span>
<span class="line" id="L4193"> <span class="tok-kw">return</span> .{</span>
<span class="line" id="L4194"> .limbs = storage[<span class="tok-number">0</span>..<span class="tok-number">2</span>],</span>
<span class="line" id="L4195"> .positive = A_is_positive,</span>
<span class="line" id="L4196"> .len = <span class="tok-number">2</span>,</span>
<span class="line" id="L4197"> };</span>
<span class="line" id="L4198">}</span>
<span class="line" id="L4199"></span>
<span class="line" id="L4200"><span class="tok-kw">test</span> {</span>
<span class="line" id="L4201"> _ = <span class="tok-builtin">@import</span>(<span class="tok-str">"int_test.zig"</span>);</span>
<span class="line" id="L4202">}</span>
<span class="line" id="L4203"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/Build/Cache.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>Build/Cache.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-comment">//! Manages `zig-cache` directories.</span></span>
<span class="line" id="L2"><span class="tok-comment">//! This is not a general-purpose cache. It is designed to be fast and simple,</span></span>
<span class="line" id="L3"><span class="tok-comment">//! not to withstand attacks using specially-crafted input.</span></span>
<span class="line" id="L4"></span>
<span class="line" id="L5"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> Directory = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L6"> <span class="tok-comment">/// This field is redundant for operations that can act on the open directory handle</span></span>
<span class="line" id="L7"> <span class="tok-comment">/// directly, but it is needed when passing the directory to a child process.</span></span>
<span class="line" id="L8"> <span class="tok-comment">/// `null` means cwd.</span></span>
<span class="line" id="L9"> path: ?[]<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L10"> handle: fs.Dir,</span>
<span class="line" id="L11"></span>
<span class="line" id="L12"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">join</span>(self: Directory, allocator: Allocator, paths: []<span class="tok-kw">const</span> []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) ![]<span class="tok-type">u8</span> {</span>
<span class="line" id="L13"> <span class="tok-kw">if</span> (self.path) |p| {</span>
<span class="line" id="L14"> <span class="tok-comment">// TODO clean way to do this with only 1 allocation</span>
</span>
<span class="line" id="L15"> <span class="tok-kw">const</span> part2 = <span class="tok-kw">try</span> fs.path.join(allocator, paths);</span>
<span class="line" id="L16"> <span class="tok-kw">defer</span> allocator.free(part2);</span>
<span class="line" id="L17"> <span class="tok-kw">return</span> fs.path.join(allocator, &[_][]<span class="tok-kw">const</span> <span class="tok-type">u8</span>{ p, part2 });</span>
<span class="line" id="L18"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L19"> <span class="tok-kw">return</span> fs.path.join(allocator, paths);</span>
<span class="line" id="L20"> }</span>
<span class="line" id="L21"> }</span>
<span class="line" id="L22"></span>
<span class="line" id="L23"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">joinZ</span>(self: Directory, allocator: Allocator, paths: []<span class="tok-kw">const</span> []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) ![:<span class="tok-number">0</span>]<span class="tok-type">u8</span> {</span>
<span class="line" id="L24"> <span class="tok-kw">if</span> (self.path) |p| {</span>
<span class="line" id="L25"> <span class="tok-comment">// TODO clean way to do this with only 1 allocation</span>
</span>
<span class="line" id="L26"> <span class="tok-kw">const</span> part2 = <span class="tok-kw">try</span> fs.path.join(allocator, paths);</span>
<span class="line" id="L27"> <span class="tok-kw">defer</span> allocator.free(part2);</span>
<span class="line" id="L28"> <span class="tok-kw">return</span> fs.path.joinZ(allocator, &[_][]<span class="tok-kw">const</span> <span class="tok-type">u8</span>{ p, part2 });</span>
<span class="line" id="L29"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L30"> <span class="tok-kw">return</span> fs.path.joinZ(allocator, paths);</span>
<span class="line" id="L31"> }</span>
<span class="line" id="L32"> }</span>
<span class="line" id="L33"></span>
<span class="line" id="L34"> <span class="tok-comment">/// Whether or not the handle should be closed, or the path should be freed</span></span>
<span class="line" id="L35"> <span class="tok-comment">/// is determined by usage, however this function is provided for convenience</span></span>
<span class="line" id="L36"> <span class="tok-comment">/// if it happens to be what the caller needs.</span></span>
<span class="line" id="L37"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">closeAndFree</span>(self: *Directory, gpa: Allocator) <span class="tok-type">void</span> {</span>
<span class="line" id="L38"> self.handle.close();</span>
<span class="line" id="L39"> <span class="tok-kw">if</span> (self.path) |p| gpa.free(p);</span>
<span class="line" id="L40"> self.* = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L41"> }</span>
<span class="line" id="L42"></span>
<span class="line" id="L43"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">format</span>(</span>
<span class="line" id="L44"> self: Directory,</span>
<span class="line" id="L45"> <span class="tok-kw">comptime</span> fmt_string: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L46"> options: fmt.FormatOptions,</span>
<span class="line" id="L47"> writer: <span class="tok-kw">anytype</span>,</span>
<span class="line" id="L48"> ) !<span class="tok-type">void</span> {</span>
<span class="line" id="L49"> _ = options;</span>
<span class="line" id="L50"> <span class="tok-kw">if</span> (fmt_string.len != <span class="tok-number">0</span>) fmt.invalidFmtError(fmt, self);</span>
<span class="line" id="L51"> <span class="tok-kw">if</span> (self.path) |p| {</span>
<span class="line" id="L52"> <span class="tok-kw">try</span> writer.writeAll(p);</span>
<span class="line" id="L53"> <span class="tok-kw">try</span> writer.writeAll(fs.path.sep_str);</span>
<span class="line" id="L54"> }</span>
<span class="line" id="L55"> }</span>
<span class="line" id="L56">};</span>
<span class="line" id="L57"></span>
<span class="line" id="L58">gpa: Allocator,</span>
<span class="line" id="L59">manifest_dir: fs.Dir,</span>
<span class="line" id="L60">hash: HashHelper = .{},</span>
<span class="line" id="L61"><span class="tok-comment">/// This value is accessed from multiple threads, protected by mutex.</span></span>
<span class="line" id="L62">recent_problematic_timestamp: <span class="tok-type">i128</span> = <span class="tok-number">0</span>,</span>
<span class="line" id="L63">mutex: std.Thread.Mutex = .{},</span>
<span class="line" id="L64"></span>
<span class="line" id="L65"><span class="tok-comment">/// A set of strings such as the zig library directory or project source root, which</span></span>
<span class="line" id="L66"><span class="tok-comment">/// are stripped from the file paths before putting into the cache. They</span></span>
<span class="line" id="L67"><span class="tok-comment">/// are replaced with single-character indicators. This is not to save</span></span>
<span class="line" id="L68"><span class="tok-comment">/// space but to eliminate absolute file paths. This improves portability</span></span>
<span class="line" id="L69"><span class="tok-comment">/// and usefulness of the cache for advanced use cases.</span></span>
<span class="line" id="L70">prefixes_buffer: [<span class="tok-number">4</span>]Directory = <span class="tok-null">undefined</span>,</span>
<span class="line" id="L71">prefixes_len: <span class="tok-type">usize</span> = <span class="tok-number">0</span>,</span>
<span class="line" id="L72"></span>
<span class="line" id="L73"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> DepTokenizer = <span class="tok-builtin">@import</span>(<span class="tok-str">"Cache/DepTokenizer.zig"</span>);</span>
<span class="line" id="L74"></span>
<span class="line" id="L75"><span class="tok-kw">const</span> Cache = <span class="tok-builtin">@This</span>();</span>
<span class="line" id="L76"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"std"</span>);</span>
<span class="line" id="L77"><span class="tok-kw">const</span> builtin = <span class="tok-builtin">@import</span>(<span class="tok-str">"builtin"</span>);</span>
<span class="line" id="L78"><span class="tok-kw">const</span> crypto = std.crypto;</span>
<span class="line" id="L79"><span class="tok-kw">const</span> fs = std.fs;</span>
<span class="line" id="L80"><span class="tok-kw">const</span> assert = std.debug.assert;</span>
<span class="line" id="L81"><span class="tok-kw">const</span> testing = std.testing;</span>
<span class="line" id="L82"><span class="tok-kw">const</span> mem = std.mem;</span>
<span class="line" id="L83"><span class="tok-kw">const</span> fmt = std.fmt;</span>
<span class="line" id="L84"><span class="tok-kw">const</span> Allocator = std.mem.Allocator;</span>
<span class="line" id="L85"><span class="tok-kw">const</span> log = std.log.scoped(.cache);</span>
<span class="line" id="L86"></span>
<span class="line" id="L87"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addPrefix</span>(cache: *Cache, directory: Directory) <span class="tok-type">void</span> {</span>
<span class="line" id="L88"> cache.prefixes_buffer[cache.prefixes_len] = directory;</span>
<span class="line" id="L89"> cache.prefixes_len += <span class="tok-number">1</span>;</span>
<span class="line" id="L90">}</span>
<span class="line" id="L91"></span>
<span class="line" id="L92"><span class="tok-comment">/// Be sure to call `Manifest.deinit` after successful initialization.</span></span>
<span class="line" id="L93"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">obtain</span>(cache: *Cache) Manifest {</span>
<span class="line" id="L94"> <span class="tok-kw">return</span> Manifest{</span>
<span class="line" id="L95"> .cache = cache,</span>
<span class="line" id="L96"> .hash = cache.hash,</span>
<span class="line" id="L97"> .manifest_file = <span class="tok-null">null</span>,</span>
<span class="line" id="L98"> .manifest_dirty = <span class="tok-null">false</span>,</span>
<span class="line" id="L99"> .hex_digest = <span class="tok-null">undefined</span>,</span>
<span class="line" id="L100"> };</span>
<span class="line" id="L101">}</span>
<span class="line" id="L102"></span>
<span class="line" id="L103"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">prefixes</span>(cache: *<span class="tok-kw">const</span> Cache) []<span class="tok-kw">const</span> Directory {</span>
<span class="line" id="L104"> <span class="tok-kw">return</span> cache.prefixes_buffer[<span class="tok-number">0</span>..cache.prefixes_len];</span>
<span class="line" id="L105">}</span>
<span class="line" id="L106"></span>
<span class="line" id="L107"><span class="tok-kw">const</span> PrefixedPath = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L108"> prefix: <span class="tok-type">u8</span>,</span>
<span class="line" id="L109"> sub_path: []<span class="tok-type">u8</span>,</span>
<span class="line" id="L110">};</span>
<span class="line" id="L111"></span>
<span class="line" id="L112"><span class="tok-kw">fn</span> <span class="tok-fn">findPrefix</span>(cache: *<span class="tok-kw">const</span> Cache, file_path: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) !PrefixedPath {</span>
<span class="line" id="L113"> <span class="tok-kw">const</span> gpa = cache.gpa;</span>
<span class="line" id="L114"> <span class="tok-kw">const</span> resolved_path = <span class="tok-kw">try</span> fs.path.resolve(gpa, &[_][]<span class="tok-kw">const</span> <span class="tok-type">u8</span>{file_path});</span>
<span class="line" id="L115"> <span class="tok-kw">errdefer</span> gpa.free(resolved_path);</span>
<span class="line" id="L116"> <span class="tok-kw">return</span> findPrefixResolved(cache, resolved_path);</span>
<span class="line" id="L117">}</span>
<span class="line" id="L118"></span>
<span class="line" id="L119"><span class="tok-comment">/// Takes ownership of `resolved_path` on success.</span></span>
<span class="line" id="L120"><span class="tok-kw">fn</span> <span class="tok-fn">findPrefixResolved</span>(cache: *<span class="tok-kw">const</span> Cache, resolved_path: []<span class="tok-type">u8</span>) !PrefixedPath {</span>
<span class="line" id="L121"> <span class="tok-kw">const</span> gpa = cache.gpa;</span>
<span class="line" id="L122"> <span class="tok-kw">const</span> prefixes_slice = cache.prefixes();</span>
<span class="line" id="L123"> <span class="tok-kw">var</span> i: <span class="tok-type">u8</span> = <span class="tok-number">1</span>; <span class="tok-comment">// Start at 1 to skip over checking the null prefix.</span>
</span>
<span class="line" id="L124"> <span class="tok-kw">while</span> (i < prefixes_slice.len) : (i += <span class="tok-number">1</span>) {</span>
<span class="line" id="L125"> <span class="tok-kw">const</span> p = prefixes_slice[i].path.?;</span>
<span class="line" id="L126"> <span class="tok-kw">if</span> (p.len > <span class="tok-number">0</span> <span class="tok-kw">and</span> mem.startsWith(<span class="tok-type">u8</span>, resolved_path, p)) {</span>
<span class="line" id="L127"> <span class="tok-comment">// +1 to skip over the path separator here</span>
</span>
<span class="line" id="L128"> <span class="tok-kw">const</span> sub_path = <span class="tok-kw">try</span> gpa.dupe(<span class="tok-type">u8</span>, resolved_path[p.len + <span class="tok-number">1</span> ..]);</span>
<span class="line" id="L129"> gpa.free(resolved_path);</span>
<span class="line" id="L130"> <span class="tok-kw">return</span> PrefixedPath{</span>
<span class="line" id="L131"> .prefix = <span class="tok-builtin">@as</span>(<span class="tok-type">u8</span>, <span class="tok-builtin">@intCast</span>(i)),</span>
<span class="line" id="L132"> .sub_path = sub_path,</span>
<span class="line" id="L133"> };</span>
<span class="line" id="L134"> }</span>
<span class="line" id="L135"> }</span>
<span class="line" id="L136"></span>
<span class="line" id="L137"> <span class="tok-kw">return</span> PrefixedPath{</span>
<span class="line" id="L138"> .prefix = <span class="tok-number">0</span>,</span>
<span class="line" id="L139"> .sub_path = resolved_path,</span>
<span class="line" id="L140"> };</span>
<span class="line" id="L141">}</span>
<span class="line" id="L142"></span>
<span class="line" id="L143"><span class="tok-comment">/// This is 128 bits - Even with 2^54 cache entries, the probably of a collision would be under 10^-6</span></span>
<span class="line" id="L144"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> bin_digest_len = <span class="tok-number">16</span>;</span>
<span class="line" id="L145"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> hex_digest_len = bin_digest_len * <span class="tok-number">2</span>;</span>
<span class="line" id="L146"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> BinDigest = [bin_digest_len]<span class="tok-type">u8</span>;</span>
<span class="line" id="L147"></span>
<span class="line" id="L148"><span class="tok-comment">/// This is currently just an arbitrary non-empty string that can't match another manifest line.</span></span>
<span class="line" id="L149"><span class="tok-kw">const</span> manifest_header = <span class="tok-str">"0"</span>;</span>
<span class="line" id="L150"><span class="tok-kw">const</span> manifest_file_size_max = <span class="tok-number">50</span> * <span class="tok-number">1024</span> * <span class="tok-number">1024</span>;</span>
<span class="line" id="L151"></span>
<span class="line" id="L152"><span class="tok-comment">/// The type used for hashing file contents. Currently, this is SipHash128(1, 3), because it</span></span>
<span class="line" id="L153"><span class="tok-comment">/// provides enough collision resistance for the Manifest use cases, while being one of our</span></span>
<span class="line" id="L154"><span class="tok-comment">/// fastest options right now.</span></span>
<span class="line" id="L155"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> Hasher = crypto.auth.siphash.SipHash128(<span class="tok-number">1</span>, <span class="tok-number">3</span>);</span>
<span class="line" id="L156"></span>
<span class="line" id="L157"><span class="tok-comment">/// Initial state with random bytes, that can be copied.</span></span>
<span class="line" id="L158"><span class="tok-comment">/// Refresh this with new random bytes when the manifest</span></span>
<span class="line" id="L159"><span class="tok-comment">/// format is modified in a non-backwards-compatible way.</span></span>
<span class="line" id="L160"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> hasher_init: Hasher = Hasher.init(&[_]<span class="tok-type">u8</span>{</span>
<span class="line" id="L161"> <span class="tok-number">0x33</span>, <span class="tok-number">0x52</span>, <span class="tok-number">0xa2</span>, <span class="tok-number">0x84</span>,</span>
<span class="line" id="L162"> <span class="tok-number">0xcf</span>, <span class="tok-number">0x17</span>, <span class="tok-number">0x56</span>, <span class="tok-number">0x57</span>,</span>
<span class="line" id="L163"> <span class="tok-number">0x01</span>, <span class="tok-number">0xbb</span>, <span class="tok-number">0xcd</span>, <span class="tok-number">0xe4</span>,</span>
<span class="line" id="L164"> <span class="tok-number">0x77</span>, <span class="tok-number">0xd6</span>, <span class="tok-number">0xf0</span>, <span class="tok-number">0x60</span>,</span>
<span class="line" id="L165">});</span>
<span class="line" id="L166"></span>
<span class="line" id="L167"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> File = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L168"> prefixed_path: ?PrefixedPath,</span>
<span class="line" id="L169"> max_file_size: ?<span class="tok-type">usize</span>,</span>
<span class="line" id="L170"> stat: Stat,</span>
<span class="line" id="L171"> bin_digest: BinDigest,</span>
<span class="line" id="L172"> contents: ?[]<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L173"></span>
<span class="line" id="L174"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> Stat = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L175"> inode: fs.File.INode,</span>
<span class="line" id="L176"> size: <span class="tok-type">u64</span>,</span>
<span class="line" id="L177"> mtime: <span class="tok-type">i128</span>,</span>
<span class="line" id="L178"> };</span>
<span class="line" id="L179"></span>
<span class="line" id="L180"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">deinit</span>(self: *File, gpa: Allocator) <span class="tok-type">void</span> {</span>
<span class="line" id="L181"> <span class="tok-kw">if</span> (self.prefixed_path) |pp| {</span>
<span class="line" id="L182"> gpa.free(pp.sub_path);</span>
<span class="line" id="L183"> self.prefixed_path = <span class="tok-null">null</span>;</span>
<span class="line" id="L184"> }</span>
<span class="line" id="L185"> <span class="tok-kw">if</span> (self.contents) |contents| {</span>
<span class="line" id="L186"> gpa.free(contents);</span>
<span class="line" id="L187"> self.contents = <span class="tok-null">null</span>;</span>
<span class="line" id="L188"> }</span>
<span class="line" id="L189"> self.* = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L190"> }</span>
<span class="line" id="L191">};</span>
<span class="line" id="L192"></span>
<span class="line" id="L193"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> HashHelper = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L194"> hasher: Hasher = hasher_init,</span>
<span class="line" id="L195"></span>
<span class="line" id="L196"> <span class="tok-comment">/// Record a slice of bytes as a dependency of the process being cached.</span></span>
<span class="line" id="L197"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addBytes</span>(hh: *HashHelper, bytes: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L198"> hh.hasher.update(mem.asBytes(&bytes.len));</span>
<span class="line" id="L199"> hh.hasher.update(bytes);</span>
<span class="line" id="L200"> }</span>
<span class="line" id="L201"></span>
<span class="line" id="L202"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addOptionalBytes</span>(hh: *HashHelper, optional_bytes: ?[]<span class="tok-kw">const</span> <span class="tok-type">u8</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L203"> hh.add(optional_bytes != <span class="tok-null">null</span>);</span>
<span class="line" id="L204"> hh.addBytes(optional_bytes <span class="tok-kw">orelse</span> <span class="tok-kw">return</span>);</span>
<span class="line" id="L205"> }</span>
<span class="line" id="L206"></span>
<span class="line" id="L207"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addListOfBytes</span>(hh: *HashHelper, list_of_bytes: []<span class="tok-kw">const</span> []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L208"> hh.add(list_of_bytes.len);</span>
<span class="line" id="L209"> <span class="tok-kw">for</span> (list_of_bytes) |bytes| hh.addBytes(bytes);</span>
<span class="line" id="L210"> }</span>
<span class="line" id="L211"></span>
<span class="line" id="L212"> <span class="tok-comment">/// Convert the input value into bytes and record it as a dependency of the process being cached.</span></span>
<span class="line" id="L213"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">add</span>(hh: *HashHelper, x: <span class="tok-kw">anytype</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L214"> <span class="tok-kw">switch</span> (<span class="tok-builtin">@TypeOf</span>(x)) {</span>
<span class="line" id="L215"> std.SemanticVersion => {</span>
<span class="line" id="L216"> hh.add(x.major);</span>
<span class="line" id="L217"> hh.add(x.minor);</span>
<span class="line" id="L218"> hh.add(x.patch);</span>
<span class="line" id="L219"> },</span>
<span class="line" id="L220"> std.Target.Os.TaggedVersionRange => {</span>
<span class="line" id="L221"> <span class="tok-kw">switch</span> (x) {</span>
<span class="line" id="L222"> .linux => |linux| {</span>
<span class="line" id="L223"> hh.add(linux.range.min);</span>
<span class="line" id="L224"> hh.add(linux.range.max);</span>
<span class="line" id="L225"> hh.add(linux.glibc);</span>
<span class="line" id="L226"> },</span>
<span class="line" id="L227"> .windows => |windows| {</span>
<span class="line" id="L228"> hh.add(windows.min);</span>
<span class="line" id="L229"> hh.add(windows.max);</span>
<span class="line" id="L230"> },</span>
<span class="line" id="L231"> .semver => |semver| {</span>
<span class="line" id="L232"> hh.add(semver.min);</span>
<span class="line" id="L233"> hh.add(semver.max);</span>
<span class="line" id="L234"> },</span>
<span class="line" id="L235"> .none => {},</span>
<span class="line" id="L236"> }</span>
<span class="line" id="L237"> },</span>
<span class="line" id="L238"> std.Build.Step.Compile.BuildId => <span class="tok-kw">switch</span> (x) {</span>
<span class="line" id="L239"> .none, .fast, .uuid, .sha1, .md5 => hh.add(std.meta.activeTag(x)),</span>
<span class="line" id="L240"> .hexstring => |hex_string| hh.addBytes(hex_string.toSlice()),</span>
<span class="line" id="L241"> },</span>
<span class="line" id="L242"> <span class="tok-kw">else</span> => <span class="tok-kw">switch</span> (<span class="tok-builtin">@typeInfo</span>(<span class="tok-builtin">@TypeOf</span>(x))) {</span>
<span class="line" id="L243"> .Bool, .Int, .Enum, .Array => hh.addBytes(mem.asBytes(&x)),</span>
<span class="line" id="L244"> <span class="tok-kw">else</span> => <span class="tok-builtin">@compileError</span>(<span class="tok-str">"unable to hash type "</span> ++ <span class="tok-builtin">@typeName</span>(<span class="tok-builtin">@TypeOf</span>(x))),</span>
<span class="line" id="L245"> },</span>
<span class="line" id="L246"> }</span>
<span class="line" id="L247"> }</span>
<span class="line" id="L248"></span>
<span class="line" id="L249"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addOptional</span>(hh: *HashHelper, optional: <span class="tok-kw">anytype</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L250"> hh.add(optional != <span class="tok-null">null</span>);</span>
<span class="line" id="L251"> hh.add(optional <span class="tok-kw">orelse</span> <span class="tok-kw">return</span>);</span>
<span class="line" id="L252"> }</span>
<span class="line" id="L253"></span>
<span class="line" id="L254"> <span class="tok-comment">/// Returns a hex encoded hash of the inputs, without modifying state.</span></span>
<span class="line" id="L255"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">peek</span>(hh: HashHelper) [hex_digest_len]<span class="tok-type">u8</span> {</span>
<span class="line" id="L256"> <span class="tok-kw">var</span> copy = hh;</span>
<span class="line" id="L257"> <span class="tok-kw">return</span> copy.final();</span>
<span class="line" id="L258"> }</span>
<span class="line" id="L259"></span>
<span class="line" id="L260"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">peekBin</span>(hh: HashHelper) BinDigest {</span>
<span class="line" id="L261"> <span class="tok-kw">var</span> copy = hh;</span>
<span class="line" id="L262"> <span class="tok-kw">var</span> bin_digest: BinDigest = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L263"> copy.hasher.final(&bin_digest);</span>
<span class="line" id="L264"> <span class="tok-kw">return</span> bin_digest;</span>
<span class="line" id="L265"> }</span>
<span class="line" id="L266"></span>
<span class="line" id="L267"> <span class="tok-comment">/// Returns a hex encoded hash of the inputs, mutating the state of the hasher.</span></span>
<span class="line" id="L268"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">final</span>(hh: *HashHelper) [hex_digest_len]<span class="tok-type">u8</span> {</span>
<span class="line" id="L269"> <span class="tok-kw">var</span> bin_digest: BinDigest = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L270"> hh.hasher.final(&bin_digest);</span>
<span class="line" id="L271"></span>
<span class="line" id="L272"> <span class="tok-kw">var</span> out_digest: [hex_digest_len]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L273"> _ = fmt.bufPrint(</span>
<span class="line" id="L274"> &out_digest,</span>
<span class="line" id="L275"> <span class="tok-str">"{s}"</span>,</span>
<span class="line" id="L276"> .{fmt.fmtSliceHexLower(&bin_digest)},</span>
<span class="line" id="L277"> ) <span class="tok-kw">catch</span> <span class="tok-kw">unreachable</span>;</span>
<span class="line" id="L278"> <span class="tok-kw">return</span> out_digest;</span>
<span class="line" id="L279"> }</span>
<span class="line" id="L280">};</span>
<span class="line" id="L281"></span>
<span class="line" id="L282"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> Lock = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L283"> manifest_file: fs.File,</span>
<span class="line" id="L284"></span>
<span class="line" id="L285"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">release</span>(lock: *Lock) <span class="tok-type">void</span> {</span>
<span class="line" id="L286"> <span class="tok-kw">if</span> (builtin.os.tag == .windows) {</span>
<span class="line" id="L287"> <span class="tok-comment">// Windows does not guarantee that locks are immediately unlocked when</span>
</span>
<span class="line" id="L288"> <span class="tok-comment">// the file handle is closed. See LockFileEx documentation.</span>
</span>
<span class="line" id="L289"> lock.manifest_file.unlock();</span>
<span class="line" id="L290"> }</span>
<span class="line" id="L291"></span>
<span class="line" id="L292"> lock.manifest_file.close();</span>
<span class="line" id="L293"> lock.* = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L294"> }</span>
<span class="line" id="L295">};</span>
<span class="line" id="L296"></span>
<span class="line" id="L297"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> Manifest = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L298"> cache: *Cache,</span>
<span class="line" id="L299"> <span class="tok-comment">/// Current state for incremental hashing.</span></span>
<span class="line" id="L300"> hash: HashHelper,</span>
<span class="line" id="L301"> manifest_file: ?fs.File,</span>
<span class="line" id="L302"> manifest_dirty: <span class="tok-type">bool</span>,</span>
<span class="line" id="L303"> <span class="tok-comment">/// Set this flag to true before calling hit() in order to indicate that</span></span>
<span class="line" id="L304"> <span class="tok-comment">/// upon a cache hit, the code using the cache will not modify the files</span></span>
<span class="line" id="L305"> <span class="tok-comment">/// within the cache directory. This allows multiple processes to utilize</span></span>
<span class="line" id="L306"> <span class="tok-comment">/// the same cache directory at the same time.</span></span>
<span class="line" id="L307"> want_shared_lock: <span class="tok-type">bool</span> = <span class="tok-null">true</span>,</span>
<span class="line" id="L308"> have_exclusive_lock: <span class="tok-type">bool</span> = <span class="tok-null">false</span>,</span>
<span class="line" id="L309"> <span class="tok-comment">// Indicate that we want isProblematicTimestamp to perform a filesystem write in</span>
</span>
<span class="line" id="L310"> <span class="tok-comment">// order to obtain a problematic timestamp for the next call. Calls after that</span>
</span>
<span class="line" id="L311"> <span class="tok-comment">// will then use the same timestamp, to avoid unnecessary filesystem writes.</span>
</span>
<span class="line" id="L312"> want_refresh_timestamp: <span class="tok-type">bool</span> = <span class="tok-null">true</span>,</span>
<span class="line" id="L313"> files: std.ArrayListUnmanaged(File) = .{},</span>
<span class="line" id="L314"> hex_digest: [hex_digest_len]<span class="tok-type">u8</span>,</span>
<span class="line" id="L315"> <span class="tok-comment">/// Populated when hit() returns an error because of one</span></span>
<span class="line" id="L316"> <span class="tok-comment">/// of the files listed in the manifest.</span></span>
<span class="line" id="L317"> failed_file_index: ?<span class="tok-type">usize</span> = <span class="tok-null">null</span>,</span>
<span class="line" id="L318"> <span class="tok-comment">/// Keeps track of the last time we performed a file system write to observe</span></span>
<span class="line" id="L319"> <span class="tok-comment">/// what time the file system thinks it is, according to its own granularity.</span></span>
<span class="line" id="L320"> recent_problematic_timestamp: <span class="tok-type">i128</span> = <span class="tok-number">0</span>,</span>
<span class="line" id="L321"></span>
<span class="line" id="L322"> <span class="tok-comment">/// Add a file as a dependency of process being cached. When `hit` is</span></span>
<span class="line" id="L323"> <span class="tok-comment">/// called, the file's contents will be checked to ensure that it matches</span></span>
<span class="line" id="L324"> <span class="tok-comment">/// the contents from previous times.</span></span>
<span class="line" id="L325"> <span class="tok-comment">///</span></span>
<span class="line" id="L326"> <span class="tok-comment">/// Max file size will be used to determine the amount of space the file contents</span></span>
<span class="line" id="L327"> <span class="tok-comment">/// are allowed to take up in memory. If max_file_size is null, then the contents</span></span>
<span class="line" id="L328"> <span class="tok-comment">/// will not be loaded into memory.</span></span>
<span class="line" id="L329"> <span class="tok-comment">///</span></span>
<span class="line" id="L330"> <span class="tok-comment">/// Returns the index of the entry in the `files` array list. You can use it</span></span>
<span class="line" id="L331"> <span class="tok-comment">/// to access the contents of the file after calling `hit()` like so:</span></span>
<span class="line" id="L332"> <span class="tok-comment">///</span></span>
<span class="line" id="L333"> <span class="tok-comment">/// ```</span></span>
<span class="line" id="L334"> <span class="tok-comment">/// var file_contents = cache_hash.files.items[file_index].contents.?;</span></span>
<span class="line" id="L335"> <span class="tok-comment">/// ```</span></span>
<span class="line" id="L336"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addFile</span>(self: *Manifest, file_path: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>, max_file_size: ?<span class="tok-type">usize</span>) !<span class="tok-type">usize</span> {</span>
<span class="line" id="L337"> assert(self.manifest_file == <span class="tok-null">null</span>);</span>
<span class="line" id="L338"></span>
<span class="line" id="L339"> <span class="tok-kw">const</span> gpa = self.cache.gpa;</span>
<span class="line" id="L340"> <span class="tok-kw">try</span> self.files.ensureUnusedCapacity(gpa, <span class="tok-number">1</span>);</span>
<span class="line" id="L341"> <span class="tok-kw">const</span> prefixed_path = <span class="tok-kw">try</span> self.cache.findPrefix(file_path);</span>
<span class="line" id="L342"> <span class="tok-kw">errdefer</span> gpa.free(prefixed_path.sub_path);</span>
<span class="line" id="L343"></span>
<span class="line" id="L344"> self.files.addOneAssumeCapacity().* = .{</span>
<span class="line" id="L345"> .prefixed_path = prefixed_path,</span>
<span class="line" id="L346"> .contents = <span class="tok-null">null</span>,</span>
<span class="line" id="L347"> .max_file_size = max_file_size,</span>
<span class="line" id="L348"> .stat = <span class="tok-null">undefined</span>,</span>
<span class="line" id="L349"> .bin_digest = <span class="tok-null">undefined</span>,</span>
<span class="line" id="L350"> };</span>
<span class="line" id="L351"></span>
<span class="line" id="L352"> self.hash.add(prefixed_path.prefix);</span>
<span class="line" id="L353"> self.hash.addBytes(prefixed_path.sub_path);</span>
<span class="line" id="L354"></span>
<span class="line" id="L355"> <span class="tok-kw">return</span> self.files.items.len - <span class="tok-number">1</span>;</span>
<span class="line" id="L356"> }</span>
<span class="line" id="L357"></span>
<span class="line" id="L358"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addOptionalFile</span>(self: *Manifest, optional_file_path: ?[]<span class="tok-kw">const</span> <span class="tok-type">u8</span>) !<span class="tok-type">void</span> {</span>
<span class="line" id="L359"> self.hash.add(optional_file_path != <span class="tok-null">null</span>);</span>
<span class="line" id="L360"> <span class="tok-kw">const</span> file_path = optional_file_path <span class="tok-kw">orelse</span> <span class="tok-kw">return</span>;</span>
<span class="line" id="L361"> _ = <span class="tok-kw">try</span> self.addFile(file_path, <span class="tok-null">null</span>);</span>
<span class="line" id="L362"> }</span>
<span class="line" id="L363"></span>
<span class="line" id="L364"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addListOfFiles</span>(self: *Manifest, list_of_files: []<span class="tok-kw">const</span> []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) !<span class="tok-type">void</span> {</span>
<span class="line" id="L365"> self.hash.add(list_of_files.len);</span>
<span class="line" id="L366"> <span class="tok-kw">for</span> (list_of_files) |file_path| {</span>
<span class="line" id="L367"> _ = <span class="tok-kw">try</span> self.addFile(file_path, <span class="tok-null">null</span>);</span>
<span class="line" id="L368"> }</span>
<span class="line" id="L369"> }</span>
<span class="line" id="L370"></span>
<span class="line" id="L371"> <span class="tok-comment">/// Check the cache to see if the input exists in it. If it exists, returns `true`.</span></span>
<span class="line" id="L372"> <span class="tok-comment">/// A hex encoding of its hash is available by calling `final`.</span></span>
<span class="line" id="L373"> <span class="tok-comment">///</span></span>
<span class="line" id="L374"> <span class="tok-comment">/// This function will also acquire an exclusive lock to the manifest file. This means</span></span>
<span class="line" id="L375"> <span class="tok-comment">/// that a process holding a Manifest will block any other process attempting to</span></span>
<span class="line" id="L376"> <span class="tok-comment">/// acquire the lock. If `want_shared_lock` is `true`, a cache hit guarantees the</span></span>
<span class="line" id="L377"> <span class="tok-comment">/// manifest file to be locked in shared mode, and a cache miss guarantees the manifest</span></span>
<span class="line" id="L378"> <span class="tok-comment">/// file to be locked in exclusive mode.</span></span>
<span class="line" id="L379"> <span class="tok-comment">///</span></span>
<span class="line" id="L380"> <span class="tok-comment">/// The lock on the manifest file is released when `deinit` is called. As another</span></span>
<span class="line" id="L381"> <span class="tok-comment">/// option, one may call `toOwnedLock` to obtain a smaller object which can represent</span></span>
<span class="line" id="L382"> <span class="tok-comment">/// the lock. `deinit` is safe to call whether or not `toOwnedLock` has been called.</span></span>
<span class="line" id="L383"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">hit</span>(self: *Manifest) !<span class="tok-type">bool</span> {</span>
<span class="line" id="L384"> <span class="tok-kw">const</span> gpa = self.cache.gpa;</span>
<span class="line" id="L385"> assert(self.manifest_file == <span class="tok-null">null</span>);</span>
<span class="line" id="L386"></span>
<span class="line" id="L387"> self.failed_file_index = <span class="tok-null">null</span>;</span>
<span class="line" id="L388"></span>
<span class="line" id="L389"> <span class="tok-kw">const</span> ext = <span class="tok-str">".txt"</span>;</span>
<span class="line" id="L390"> <span class="tok-kw">var</span> manifest_file_path: [hex_digest_len + ext.len]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L391"></span>
<span class="line" id="L392"> <span class="tok-kw">var</span> bin_digest: BinDigest = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L393"> self.hash.hasher.final(&bin_digest);</span>
<span class="line" id="L394"></span>
<span class="line" id="L395"> _ = fmt.bufPrint(</span>
<span class="line" id="L396"> &self.hex_digest,</span>
<span class="line" id="L397"> <span class="tok-str">"{s}"</span>,</span>
<span class="line" id="L398"> .{fmt.fmtSliceHexLower(&bin_digest)},</span>
<span class="line" id="L399"> ) <span class="tok-kw">catch</span> <span class="tok-kw">unreachable</span>;</span>
<span class="line" id="L400"></span>
<span class="line" id="L401"> self.hash.hasher = hasher_init;</span>
<span class="line" id="L402"> self.hash.hasher.update(&bin_digest);</span>
<span class="line" id="L403"></span>
<span class="line" id="L404"> <span class="tok-builtin">@memcpy</span>(manifest_file_path[<span class="tok-number">0</span>..self.hex_digest.len], &self.hex_digest);</span>
<span class="line" id="L405"> manifest_file_path[hex_digest_len..][<span class="tok-number">0</span>..ext.len].* = ext.*;</span>
<span class="line" id="L406"></span>
<span class="line" id="L407"> <span class="tok-kw">while</span> (<span class="tok-null">true</span>) {</span>
<span class="line" id="L408"> <span class="tok-kw">if</span> (self.cache.manifest_dir.createFile(&manifest_file_path, .{</span>
<span class="line" id="L409"> .read = <span class="tok-null">true</span>,</span>
<span class="line" id="L410"> .truncate = <span class="tok-null">false</span>,</span>
<span class="line" id="L411"> .lock = .exclusive,</span>
<span class="line" id="L412"> .lock_nonblocking = self.want_shared_lock,</span>
<span class="line" id="L413"> })) |manifest_file| {</span>
<span class="line" id="L414"> self.manifest_file = manifest_file;</span>
<span class="line" id="L415"> self.have_exclusive_lock = <span class="tok-null">true</span>;</span>
<span class="line" id="L416"> <span class="tok-kw">break</span>;</span>
<span class="line" id="L417"> } <span class="tok-kw">else</span> |err| <span class="tok-kw">switch</span> (err) {</span>
<span class="line" id="L418"> <span class="tok-kw">error</span>.WouldBlock => {</span>
<span class="line" id="L419"> self.manifest_file = <span class="tok-kw">try</span> self.cache.manifest_dir.openFile(&manifest_file_path, .{</span>
<span class="line" id="L420"> .mode = .read_write,</span>
<span class="line" id="L421"> .lock = .shared,</span>
<span class="line" id="L422"> });</span>
<span class="line" id="L423"> <span class="tok-kw">break</span>;</span>
<span class="line" id="L424"> },</span>
<span class="line" id="L425"> <span class="tok-comment">// There are no dir components, so you would think that this was</span>
</span>
<span class="line" id="L426"> <span class="tok-comment">// unreachable, however we have observed on macOS two processes racing</span>
</span>
<span class="line" id="L427"> <span class="tok-comment">// to do openat() with O_CREAT manifest in ENOENT.</span>
</span>
<span class="line" id="L428"> <span class="tok-kw">error</span>.FileNotFound => <span class="tok-kw">continue</span>,</span>
<span class="line" id="L429"> <span class="tok-kw">else</span> => |e| <span class="tok-kw">return</span> e,</span>
<span class="line" id="L430"> }</span>
<span class="line" id="L431"> }</span>
<span class="line" id="L432"></span>
<span class="line" id="L433"> self.want_refresh_timestamp = <span class="tok-null">true</span>;</span>
<span class="line" id="L434"></span>
<span class="line" id="L435"> <span class="tok-kw">while</span> (<span class="tok-null">true</span>) {</span>
<span class="line" id="L436"> <span class="tok-kw">const</span> file_contents = <span class="tok-kw">try</span> self.manifest_file.?.reader().readAllAlloc(gpa, manifest_file_size_max);</span>
<span class="line" id="L437"> <span class="tok-kw">defer</span> gpa.free(file_contents);</span>
<span class="line" id="L438"></span>
<span class="line" id="L439"> <span class="tok-kw">const</span> input_file_count = self.files.items.len;</span>
<span class="line" id="L440"> <span class="tok-kw">var</span> any_file_changed = <span class="tok-null">false</span>;</span>
<span class="line" id="L441"> <span class="tok-kw">var</span> line_iter = mem.tokenizeScalar(<span class="tok-type">u8</span>, file_contents, <span class="tok-str">'\n'</span>);</span>
<span class="line" id="L442"> <span class="tok-kw">var</span> idx: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L443"> <span class="tok-kw">if</span> (<span class="tok-kw">if</span> (line_iter.next()) |line| !std.mem.eql(<span class="tok-type">u8</span>, line, manifest_header) <span class="tok-kw">else</span> <span class="tok-null">true</span>) {</span>
<span class="line" id="L444"> <span class="tok-kw">if</span> (<span class="tok-kw">try</span> self.upgradeToExclusiveLock()) <span class="tok-kw">continue</span>;</span>
<span class="line" id="L445"> self.manifest_dirty = <span class="tok-null">true</span>;</span>
<span class="line" id="L446"> <span class="tok-kw">while</span> (idx < input_file_count) : (idx += <span class="tok-number">1</span>) {</span>
<span class="line" id="L447"> <span class="tok-kw">const</span> ch_file = &self.files.items[idx];</span>
<span class="line" id="L448"> self.populateFileHash(ch_file) <span class="tok-kw">catch</span> |err| {</span>
<span class="line" id="L449"> self.failed_file_index = idx;</span>
<span class="line" id="L450"> <span class="tok-kw">return</span> err;</span>
<span class="line" id="L451"> };</span>
<span class="line" id="L452"> }</span>
<span class="line" id="L453"> <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L454"> }</span>
<span class="line" id="L455"> <span class="tok-kw">while</span> (line_iter.next()) |line| {</span>
<span class="line" id="L456"> <span class="tok-kw">defer</span> idx += <span class="tok-number">1</span>;</span>
<span class="line" id="L457"></span>
<span class="line" id="L458"> <span class="tok-kw">const</span> cache_hash_file = <span class="tok-kw">if</span> (idx < input_file_count) &self.files.items[idx] <span class="tok-kw">else</span> blk: {</span>
<span class="line" id="L459"> <span class="tok-kw">const</span> new = <span class="tok-kw">try</span> self.files.addOne(gpa);</span>
<span class="line" id="L460"> new.* = .{</span>
<span class="line" id="L461"> .prefixed_path = <span class="tok-null">null</span>,</span>
<span class="line" id="L462"> .contents = <span class="tok-null">null</span>,</span>
<span class="line" id="L463"> .max_file_size = <span class="tok-null">null</span>,</span>
<span class="line" id="L464"> .stat = <span class="tok-null">undefined</span>,</span>
<span class="line" id="L465"> .bin_digest = <span class="tok-null">undefined</span>,</span>
<span class="line" id="L466"> };</span>
<span class="line" id="L467"> <span class="tok-kw">break</span> :blk new;</span>
<span class="line" id="L468"> };</span>
<span class="line" id="L469"></span>
<span class="line" id="L470"> <span class="tok-kw">var</span> iter = mem.tokenizeScalar(<span class="tok-type">u8</span>, line, <span class="tok-str">' '</span>);</span>
<span class="line" id="L471"> <span class="tok-kw">const</span> size = iter.next() <span class="tok-kw">orelse</span> <span class="tok-kw">return</span> <span class="tok-kw">error</span>.InvalidFormat;</span>
<span class="line" id="L472"> <span class="tok-kw">const</span> inode = iter.next() <span class="tok-kw">orelse</span> <span class="tok-kw">return</span> <span class="tok-kw">error</span>.InvalidFormat;</span>
<span class="line" id="L473"> <span class="tok-kw">const</span> mtime_nsec_str = iter.next() <span class="tok-kw">orelse</span> <span class="tok-kw">return</span> <span class="tok-kw">error</span>.InvalidFormat;</span>
<span class="line" id="L474"> <span class="tok-kw">const</span> digest_str = iter.next() <span class="tok-kw">orelse</span> <span class="tok-kw">return</span> <span class="tok-kw">error</span>.InvalidFormat;</span>
<span class="line" id="L475"> <span class="tok-kw">const</span> prefix_str = iter.next() <span class="tok-kw">orelse</span> <span class="tok-kw">return</span> <span class="tok-kw">error</span>.InvalidFormat;</span>
<span class="line" id="L476"> <span class="tok-kw">const</span> file_path = iter.rest();</span>
<span class="line" id="L477"></span>
<span class="line" id="L478"> cache_hash_file.stat.size = fmt.parseInt(<span class="tok-type">u64</span>, size, <span class="tok-number">10</span>) <span class="tok-kw">catch</span> <span class="tok-kw">return</span> <span class="tok-kw">error</span>.InvalidFormat;</span>
<span class="line" id="L479"> cache_hash_file.stat.inode = fmt.parseInt(fs.File.INode, inode, <span class="tok-number">10</span>) <span class="tok-kw">catch</span> <span class="tok-kw">return</span> <span class="tok-kw">error</span>.InvalidFormat;</span>
<span class="line" id="L480"> cache_hash_file.stat.mtime = fmt.parseInt(<span class="tok-type">i64</span>, mtime_nsec_str, <span class="tok-number">10</span>) <span class="tok-kw">catch</span> <span class="tok-kw">return</span> <span class="tok-kw">error</span>.InvalidFormat;</span>
<span class="line" id="L481"> _ = fmt.hexToBytes(&cache_hash_file.bin_digest, digest_str) <span class="tok-kw">catch</span> <span class="tok-kw">return</span> <span class="tok-kw">error</span>.InvalidFormat;</span>
<span class="line" id="L482"> <span class="tok-kw">const</span> prefix = fmt.parseInt(<span class="tok-type">u8</span>, prefix_str, <span class="tok-number">10</span>) <span class="tok-kw">catch</span> <span class="tok-kw">return</span> <span class="tok-kw">error</span>.InvalidFormat;</span>
<span class="line" id="L483"> <span class="tok-kw">if</span> (prefix >= self.cache.prefixes_len) <span class="tok-kw">return</span> <span class="tok-kw">error</span>.InvalidFormat;</span>
<span class="line" id="L484"></span>
<span class="line" id="L485"> <span class="tok-kw">if</span> (file_path.len == <span class="tok-number">0</span>) {</span>
<span class="line" id="L486"> <span class="tok-kw">return</span> <span class="tok-kw">error</span>.InvalidFormat;</span>
<span class="line" id="L487"> }</span>
<span class="line" id="L488"> <span class="tok-kw">if</span> (cache_hash_file.prefixed_path) |pp| {</span>
<span class="line" id="L489"> <span class="tok-kw">if</span> (pp.prefix != prefix <span class="tok-kw">or</span> !mem.eql(<span class="tok-type">u8</span>, file_path, pp.sub_path)) {</span>
<span class="line" id="L490"> <span class="tok-kw">return</span> <span class="tok-kw">error</span>.InvalidFormat;</span>
<span class="line" id="L491"> }</span>
<span class="line" id="L492"> }</span>
<span class="line" id="L493"></span>
<span class="line" id="L494"> <span class="tok-kw">if</span> (cache_hash_file.prefixed_path == <span class="tok-null">null</span>) {</span>
<span class="line" id="L495"> cache_hash_file.prefixed_path = .{</span>
<span class="line" id="L496"> .prefix = prefix,</span>
<span class="line" id="L497"> .sub_path = <span class="tok-kw">try</span> gpa.dupe(<span class="tok-type">u8</span>, file_path),</span>
<span class="line" id="L498"> };</span>
<span class="line" id="L499"> }</span>
<span class="line" id="L500"></span>
<span class="line" id="L501"> <span class="tok-kw">const</span> pp = cache_hash_file.prefixed_path.?;</span>
<span class="line" id="L502"> <span class="tok-kw">const</span> dir = self.cache.prefixes()[pp.prefix].handle;</span>
<span class="line" id="L503"> <span class="tok-kw">const</span> this_file = dir.openFile(pp.sub_path, .{ .mode = .read_only }) <span class="tok-kw">catch</span> |err| <span class="tok-kw">switch</span> (err) {</span>
<span class="line" id="L504"> <span class="tok-kw">error</span>.FileNotFound => {</span>
<span class="line" id="L505"> <span class="tok-kw">if</span> (<span class="tok-kw">try</span> self.upgradeToExclusiveLock()) <span class="tok-kw">continue</span>;</span>
<span class="line" id="L506"> <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L507"> },</span>
<span class="line" id="L508"> <span class="tok-kw">else</span> => <span class="tok-kw">return</span> <span class="tok-kw">error</span>.CacheUnavailable,</span>
<span class="line" id="L509"> };</span>
<span class="line" id="L510"> <span class="tok-kw">defer</span> this_file.close();</span>
<span class="line" id="L511"></span>
<span class="line" id="L512"> <span class="tok-kw">const</span> actual_stat = this_file.stat() <span class="tok-kw">catch</span> |err| {</span>
<span class="line" id="L513"> self.failed_file_index = idx;</span>
<span class="line" id="L514"> <span class="tok-kw">return</span> err;</span>
<span class="line" id="L515"> };</span>
<span class="line" id="L516"> <span class="tok-kw">const</span> size_match = actual_stat.size == cache_hash_file.stat.size;</span>
<span class="line" id="L517"> <span class="tok-kw">const</span> mtime_match = actual_stat.mtime == cache_hash_file.stat.mtime;</span>
<span class="line" id="L518"> <span class="tok-kw">const</span> inode_match = actual_stat.inode == cache_hash_file.stat.inode;</span>
<span class="line" id="L519"></span>
<span class="line" id="L520"> <span class="tok-kw">if</span> (!size_match <span class="tok-kw">or</span> !mtime_match <span class="tok-kw">or</span> !inode_match) {</span>
<span class="line" id="L521"> self.manifest_dirty = <span class="tok-null">true</span>;</span>
<span class="line" id="L522"></span>
<span class="line" id="L523"> cache_hash_file.stat = .{</span>
<span class="line" id="L524"> .size = actual_stat.size,</span>
<span class="line" id="L525"> .mtime = actual_stat.mtime,</span>
<span class="line" id="L526"> .inode = actual_stat.inode,</span>
<span class="line" id="L527"> };</span>
<span class="line" id="L528"></span>
<span class="line" id="L529"> <span class="tok-kw">if</span> (self.isProblematicTimestamp(cache_hash_file.stat.mtime)) {</span>
<span class="line" id="L530"> <span class="tok-comment">// The actual file has an unreliable timestamp, force it to be hashed</span>
</span>
<span class="line" id="L531"> cache_hash_file.stat.mtime = <span class="tok-number">0</span>;</span>
<span class="line" id="L532"> cache_hash_file.stat.inode = <span class="tok-number">0</span>;</span>
<span class="line" id="L533"> }</span>
<span class="line" id="L534"></span>
<span class="line" id="L535"> <span class="tok-kw">var</span> actual_digest: BinDigest = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L536"> hashFile(this_file, &actual_digest) <span class="tok-kw">catch</span> |err| {</span>
<span class="line" id="L537"> self.failed_file_index = idx;</span>
<span class="line" id="L538"> <span class="tok-kw">return</span> err;</span>
<span class="line" id="L539"> };</span>
<span class="line" id="L540"></span>
<span class="line" id="L541"> <span class="tok-kw">if</span> (!mem.eql(<span class="tok-type">u8</span>, &cache_hash_file.bin_digest, &actual_digest)) {</span>
<span class="line" id="L542"> cache_hash_file.bin_digest = actual_digest;</span>
<span class="line" id="L543"> <span class="tok-comment">// keep going until we have the input file digests</span>
</span>
<span class="line" id="L544"> any_file_changed = <span class="tok-null">true</span>;</span>
<span class="line" id="L545"> }</span>
<span class="line" id="L546"> }</span>
<span class="line" id="L547"></span>
<span class="line" id="L548"> <span class="tok-kw">if</span> (!any_file_changed) {</span>
<span class="line" id="L549"> self.hash.hasher.update(&cache_hash_file.bin_digest);</span>
<span class="line" id="L550"> }</span>
<span class="line" id="L551"> }</span>
<span class="line" id="L552"></span>
<span class="line" id="L553"> <span class="tok-kw">if</span> (any_file_changed) {</span>
<span class="line" id="L554"> <span class="tok-kw">if</span> (<span class="tok-kw">try</span> self.upgradeToExclusiveLock()) <span class="tok-kw">continue</span>;</span>
<span class="line" id="L555"> <span class="tok-comment">// cache miss</span>
</span>
<span class="line" id="L556"> <span class="tok-comment">// keep the manifest file open</span>
</span>
<span class="line" id="L557"> self.unhit(bin_digest, input_file_count);</span>
<span class="line" id="L558"> <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L559"> }</span>
<span class="line" id="L560"></span>
<span class="line" id="L561"> <span class="tok-kw">if</span> (idx < input_file_count) {</span>
<span class="line" id="L562"> <span class="tok-kw">if</span> (<span class="tok-kw">try</span> self.upgradeToExclusiveLock()) <span class="tok-kw">continue</span>;</span>
<span class="line" id="L563"> self.manifest_dirty = <span class="tok-null">true</span>;</span>
<span class="line" id="L564"> <span class="tok-kw">while</span> (idx < input_file_count) : (idx += <span class="tok-number">1</span>) {</span>
<span class="line" id="L565"> <span class="tok-kw">const</span> ch_file = &self.files.items[idx];</span>
<span class="line" id="L566"> self.populateFileHash(ch_file) <span class="tok-kw">catch</span> |err| {</span>
<span class="line" id="L567"> self.failed_file_index = idx;</span>
<span class="line" id="L568"> <span class="tok-kw">return</span> err;</span>
<span class="line" id="L569"> };</span>
<span class="line" id="L570"> }</span>
<span class="line" id="L571"> <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L572"> }</span>
<span class="line" id="L573"></span>
<span class="line" id="L574"> <span class="tok-kw">if</span> (self.want_shared_lock) {</span>
<span class="line" id="L575"> <span class="tok-kw">try</span> self.downgradeToSharedLock();</span>
<span class="line" id="L576"> }</span>
<span class="line" id="L577"></span>
<span class="line" id="L578"> <span class="tok-kw">return</span> <span class="tok-null">true</span>;</span>
<span class="line" id="L579"> }</span>
<span class="line" id="L580"> }</span>
<span class="line" id="L581"></span>
<span class="line" id="L582"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">unhit</span>(self: *Manifest, bin_digest: BinDigest, input_file_count: <span class="tok-type">usize</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L583"> <span class="tok-comment">// Reset the hash.</span>
</span>
<span class="line" id="L584"> self.hash.hasher = hasher_init;</span>
<span class="line" id="L585"> self.hash.hasher.update(&bin_digest);</span>
<span class="line" id="L586"></span>
<span class="line" id="L587"> <span class="tok-comment">// Remove files not in the initial hash.</span>
</span>
<span class="line" id="L588"> <span class="tok-kw">for</span> (self.files.items[input_file_count..]) |*file| {</span>
<span class="line" id="L589"> file.deinit(self.cache.gpa);</span>
<span class="line" id="L590"> }</span>
<span class="line" id="L591"> self.files.shrinkRetainingCapacity(input_file_count);</span>
<span class="line" id="L592"></span>
<span class="line" id="L593"> <span class="tok-kw">for</span> (self.files.items) |file| {</span>
<span class="line" id="L594"> self.hash.hasher.update(&file.bin_digest);</span>
<span class="line" id="L595"> }</span>
<span class="line" id="L596"> }</span>
<span class="line" id="L597"></span>
<span class="line" id="L598"> <span class="tok-kw">fn</span> <span class="tok-fn">isProblematicTimestamp</span>(man: *Manifest, file_time: <span class="tok-type">i128</span>) <span class="tok-type">bool</span> {</span>
<span class="line" id="L599"> <span class="tok-comment">// If the file_time is prior to the most recent problematic timestamp</span>
</span>
<span class="line" id="L600"> <span class="tok-comment">// then we don't need to access the filesystem.</span>
</span>
<span class="line" id="L601"> <span class="tok-kw">if</span> (file_time < man.recent_problematic_timestamp)</span>
<span class="line" id="L602"> <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L603"></span>
<span class="line" id="L604"> <span class="tok-comment">// Next we will check the globally shared Cache timestamp, which is accessed</span>
</span>
<span class="line" id="L605"> <span class="tok-comment">// from multiple threads.</span>
</span>
<span class="line" id="L606"> man.cache.mutex.lock();</span>
<span class="line" id="L607"> <span class="tok-kw">defer</span> man.cache.mutex.unlock();</span>
<span class="line" id="L608"></span>
<span class="line" id="L609"> <span class="tok-comment">// Save the global one to our local one to avoid locking next time.</span>
</span>
<span class="line" id="L610"> man.recent_problematic_timestamp = man.cache.recent_problematic_timestamp;</span>
<span class="line" id="L611"> <span class="tok-kw">if</span> (file_time < man.recent_problematic_timestamp)</span>
<span class="line" id="L612"> <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L613"></span>
<span class="line" id="L614"> <span class="tok-comment">// This flag prevents multiple filesystem writes for the same hit() call.</span>
</span>
<span class="line" id="L615"> <span class="tok-kw">if</span> (man.want_refresh_timestamp) {</span>
<span class="line" id="L616"> man.want_refresh_timestamp = <span class="tok-null">false</span>;</span>
<span class="line" id="L617"></span>
<span class="line" id="L618"> <span class="tok-kw">var</span> file = man.cache.manifest_dir.createFile(<span class="tok-str">"timestamp"</span>, .{</span>
<span class="line" id="L619"> .read = <span class="tok-null">true</span>,</span>
<span class="line" id="L620"> .truncate = <span class="tok-null">true</span>,</span>
<span class="line" id="L621"> }) <span class="tok-kw">catch</span> <span class="tok-kw">return</span> <span class="tok-null">true</span>;</span>
<span class="line" id="L622"> <span class="tok-kw">defer</span> file.close();</span>
<span class="line" id="L623"></span>
<span class="line" id="L624"> <span class="tok-comment">// Save locally and also save globally (we still hold the global lock).</span>
</span>
<span class="line" id="L625"> man.recent_problematic_timestamp = (file.stat() <span class="tok-kw">catch</span> <span class="tok-kw">return</span> <span class="tok-null">true</span>).mtime;</span>
<span class="line" id="L626"> man.cache.recent_problematic_timestamp = man.recent_problematic_timestamp;</span>
<span class="line" id="L627"> }</span>
<span class="line" id="L628"></span>
<span class="line" id="L629"> <span class="tok-kw">return</span> file_time >= man.recent_problematic_timestamp;</span>
<span class="line" id="L630"> }</span>
<span class="line" id="L631"></span>
<span class="line" id="L632"> <span class="tok-kw">fn</span> <span class="tok-fn">populateFileHash</span>(self: *Manifest, ch_file: *File) !<span class="tok-type">void</span> {</span>
<span class="line" id="L633"> <span class="tok-kw">const</span> pp = ch_file.prefixed_path.?;</span>
<span class="line" id="L634"> <span class="tok-kw">const</span> dir = self.cache.prefixes()[pp.prefix].handle;</span>
<span class="line" id="L635"> <span class="tok-kw">const</span> file = <span class="tok-kw">try</span> dir.openFile(pp.sub_path, .{});</span>
<span class="line" id="L636"> <span class="tok-kw">defer</span> file.close();</span>
<span class="line" id="L637"></span>
<span class="line" id="L638"> <span class="tok-kw">const</span> actual_stat = <span class="tok-kw">try</span> file.stat();</span>
<span class="line" id="L639"> ch_file.stat = .{</span>
<span class="line" id="L640"> .size = actual_stat.size,</span>
<span class="line" id="L641"> .mtime = actual_stat.mtime,</span>
<span class="line" id="L642"> .inode = actual_stat.inode,</span>
<span class="line" id="L643"> };</span>
<span class="line" id="L644"></span>
<span class="line" id="L645"> <span class="tok-kw">if</span> (self.isProblematicTimestamp(ch_file.stat.mtime)) {</span>
<span class="line" id="L646"> <span class="tok-comment">// The actual file has an unreliable timestamp, force it to be hashed</span>
</span>
<span class="line" id="L647"> ch_file.stat.mtime = <span class="tok-number">0</span>;</span>
<span class="line" id="L648"> ch_file.stat.inode = <span class="tok-number">0</span>;</span>
<span class="line" id="L649"> }</span>
<span class="line" id="L650"></span>
<span class="line" id="L651"> <span class="tok-kw">if</span> (ch_file.max_file_size) |max_file_size| {</span>
<span class="line" id="L652"> <span class="tok-kw">if</span> (ch_file.stat.size > max_file_size) {</span>
<span class="line" id="L653"> <span class="tok-kw">return</span> <span class="tok-kw">error</span>.FileTooBig;</span>
<span class="line" id="L654"> }</span>
<span class="line" id="L655"></span>
<span class="line" id="L656"> <span class="tok-kw">const</span> contents = <span class="tok-kw">try</span> self.cache.gpa.alloc(<span class="tok-type">u8</span>, <span class="tok-builtin">@as</span>(<span class="tok-type">usize</span>, <span class="tok-builtin">@intCast</span>(ch_file.stat.size)));</span>
<span class="line" id="L657"> <span class="tok-kw">errdefer</span> self.cache.gpa.free(contents);</span>
<span class="line" id="L658"></span>
<span class="line" id="L659"> <span class="tok-comment">// Hash while reading from disk, to keep the contents in the cpu cache while</span>
</span>
<span class="line" id="L660"> <span class="tok-comment">// doing hashing.</span>
</span>
<span class="line" id="L661"> <span class="tok-kw">var</span> hasher = hasher_init;</span>
<span class="line" id="L662"> <span class="tok-kw">var</span> off: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L663"> <span class="tok-kw">while</span> (<span class="tok-null">true</span>) {</span>
<span class="line" id="L664"> <span class="tok-comment">// give me everything you've got, captain</span>
</span>
<span class="line" id="L665"> <span class="tok-kw">const</span> bytes_read = <span class="tok-kw">try</span> file.read(contents[off..]);</span>
<span class="line" id="L666"> <span class="tok-kw">if</span> (bytes_read == <span class="tok-number">0</span>) <span class="tok-kw">break</span>;</span>
<span class="line" id="L667"> hasher.update(contents[off..][<span class="tok-number">0</span>..bytes_read]);</span>
<span class="line" id="L668"> off += bytes_read;</span>
<span class="line" id="L669"> }</span>
<span class="line" id="L670"> hasher.final(&ch_file.bin_digest);</span>
<span class="line" id="L671"></span>
<span class="line" id="L672"> ch_file.contents = contents;</span>
<span class="line" id="L673"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L674"> <span class="tok-kw">try</span> hashFile(file, &ch_file.bin_digest);</span>
<span class="line" id="L675"> }</span>
<span class="line" id="L676"></span>
<span class="line" id="L677"> self.hash.hasher.update(&ch_file.bin_digest);</span>
<span class="line" id="L678"> }</span>
<span class="line" id="L679"></span>
<span class="line" id="L680"> <span class="tok-comment">/// Add a file as a dependency of process being cached, after the initial hash has been</span></span>
<span class="line" id="L681"> <span class="tok-comment">/// calculated. This is useful for processes that don't know all the files that</span></span>
<span class="line" id="L682"> <span class="tok-comment">/// are depended on ahead of time. For example, a source file that can import other files</span></span>
<span class="line" id="L683"> <span class="tok-comment">/// will need to be recompiled if the imported file is changed.</span></span>
<span class="line" id="L684"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addFilePostFetch</span>(self: *Manifest, file_path: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>, max_file_size: <span class="tok-type">usize</span>) ![]<span class="tok-kw">const</span> <span class="tok-type">u8</span> {</span>
<span class="line" id="L685"> assert(self.manifest_file != <span class="tok-null">null</span>);</span>
<span class="line" id="L686"></span>
<span class="line" id="L687"> <span class="tok-kw">const</span> gpa = self.cache.gpa;</span>
<span class="line" id="L688"> <span class="tok-kw">const</span> prefixed_path = <span class="tok-kw">try</span> self.cache.findPrefix(file_path);</span>
<span class="line" id="L689"> <span class="tok-kw">errdefer</span> gpa.free(prefixed_path.sub_path);</span>
<span class="line" id="L690"></span>
<span class="line" id="L691"> <span class="tok-kw">const</span> new_ch_file = <span class="tok-kw">try</span> self.files.addOne(gpa);</span>
<span class="line" id="L692"> new_ch_file.* = .{</span>
<span class="line" id="L693"> .prefixed_path = prefixed_path,</span>
<span class="line" id="L694"> .max_file_size = max_file_size,</span>
<span class="line" id="L695"> .stat = <span class="tok-null">undefined</span>,</span>
<span class="line" id="L696"> .bin_digest = <span class="tok-null">undefined</span>,</span>
<span class="line" id="L697"> .contents = <span class="tok-null">null</span>,</span>
<span class="line" id="L698"> };</span>
<span class="line" id="L699"> <span class="tok-kw">errdefer</span> self.files.shrinkRetainingCapacity(self.files.items.len - <span class="tok-number">1</span>);</span>
<span class="line" id="L700"></span>
<span class="line" id="L701"> <span class="tok-kw">try</span> self.populateFileHash(new_ch_file);</span>
<span class="line" id="L702"></span>
<span class="line" id="L703"> <span class="tok-kw">return</span> new_ch_file.contents.?;</span>
<span class="line" id="L704"> }</span>
<span class="line" id="L705"></span>
<span class="line" id="L706"> <span class="tok-comment">/// Add a file as a dependency of process being cached, after the initial hash has been</span></span>
<span class="line" id="L707"> <span class="tok-comment">/// calculated. This is useful for processes that don't know the all the files that</span></span>
<span class="line" id="L708"> <span class="tok-comment">/// are depended on ahead of time. For example, a source file that can import other files</span></span>
<span class="line" id="L709"> <span class="tok-comment">/// will need to be recompiled if the imported file is changed.</span></span>
<span class="line" id="L710"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addFilePost</span>(self: *Manifest, file_path: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) !<span class="tok-type">void</span> {</span>
<span class="line" id="L711"> assert(self.manifest_file != <span class="tok-null">null</span>);</span>
<span class="line" id="L712"></span>
<span class="line" id="L713"> <span class="tok-kw">const</span> gpa = self.cache.gpa;</span>
<span class="line" id="L714"> <span class="tok-kw">const</span> prefixed_path = <span class="tok-kw">try</span> self.cache.findPrefix(file_path);</span>
<span class="line" id="L715"> <span class="tok-kw">errdefer</span> gpa.free(prefixed_path.sub_path);</span>
<span class="line" id="L716"></span>
<span class="line" id="L717"> <span class="tok-kw">const</span> new_ch_file = <span class="tok-kw">try</span> self.files.addOne(gpa);</span>
<span class="line" id="L718"> new_ch_file.* = .{</span>
<span class="line" id="L719"> .prefixed_path = prefixed_path,</span>
<span class="line" id="L720"> .max_file_size = <span class="tok-null">null</span>,</span>
<span class="line" id="L721"> .stat = <span class="tok-null">undefined</span>,</span>
<span class="line" id="L722"> .bin_digest = <span class="tok-null">undefined</span>,</span>
<span class="line" id="L723"> .contents = <span class="tok-null">null</span>,</span>
<span class="line" id="L724"> };</span>
<span class="line" id="L725"> <span class="tok-kw">errdefer</span> self.files.shrinkRetainingCapacity(self.files.items.len - <span class="tok-number">1</span>);</span>
<span class="line" id="L726"></span>
<span class="line" id="L727"> <span class="tok-kw">try</span> self.populateFileHash(new_ch_file);</span>
<span class="line" id="L728"> }</span>
<span class="line" id="L729"></span>
<span class="line" id="L730"> <span class="tok-comment">/// Like `addFilePost` but when the file contents have already been loaded from disk.</span></span>
<span class="line" id="L731"> <span class="tok-comment">/// On success, cache takes ownership of `resolved_path`.</span></span>
<span class="line" id="L732"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addFilePostContents</span>(</span>
<span class="line" id="L733"> self: *Manifest,</span>
<span class="line" id="L734"> resolved_path: []<span class="tok-type">u8</span>,</span>
<span class="line" id="L735"> bytes: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L736"> stat: File.Stat,</span>
<span class="line" id="L737"> ) <span class="tok-kw">error</span>{OutOfMemory}!<span class="tok-type">void</span> {</span>
<span class="line" id="L738"> assert(self.manifest_file != <span class="tok-null">null</span>);</span>
<span class="line" id="L739"> <span class="tok-kw">const</span> gpa = self.cache.gpa;</span>
<span class="line" id="L740"></span>
<span class="line" id="L741"> <span class="tok-kw">const</span> ch_file = <span class="tok-kw">try</span> self.files.addOne(gpa);</span>
<span class="line" id="L742"> <span class="tok-kw">errdefer</span> self.files.shrinkRetainingCapacity(self.files.items.len - <span class="tok-number">1</span>);</span>
<span class="line" id="L743"></span>
<span class="line" id="L744"> <span class="tok-kw">const</span> prefixed_path = <span class="tok-kw">try</span> self.cache.findPrefixResolved(resolved_path);</span>
<span class="line" id="L745"> <span class="tok-kw">errdefer</span> gpa.free(prefixed_path.sub_path);</span>
<span class="line" id="L746"></span>
<span class="line" id="L747"> ch_file.* = .{</span>
<span class="line" id="L748"> .prefixed_path = prefixed_path,</span>
<span class="line" id="L749"> .max_file_size = <span class="tok-null">null</span>,</span>
<span class="line" id="L750"> .stat = stat,</span>
<span class="line" id="L751"> .bin_digest = <span class="tok-null">undefined</span>,</span>
<span class="line" id="L752"> .contents = <span class="tok-null">null</span>,</span>
<span class="line" id="L753"> };</span>
<span class="line" id="L754"></span>
<span class="line" id="L755"> <span class="tok-kw">if</span> (self.isProblematicTimestamp(ch_file.stat.mtime)) {</span>
<span class="line" id="L756"> <span class="tok-comment">// The actual file has an unreliable timestamp, force it to be hashed</span>
</span>
<span class="line" id="L757"> ch_file.stat.mtime = <span class="tok-number">0</span>;</span>
<span class="line" id="L758"> ch_file.stat.inode = <span class="tok-number">0</span>;</span>
<span class="line" id="L759"> }</span>
<span class="line" id="L760"></span>
<span class="line" id="L761"> {</span>
<span class="line" id="L762"> <span class="tok-kw">var</span> hasher = hasher_init;</span>
<span class="line" id="L763"> hasher.update(bytes);</span>
<span class="line" id="L764"> hasher.final(&ch_file.bin_digest);</span>
<span class="line" id="L765"> }</span>
<span class="line" id="L766"></span>
<span class="line" id="L767"> self.hash.hasher.update(&ch_file.bin_digest);</span>
<span class="line" id="L768"> }</span>
<span class="line" id="L769"></span>
<span class="line" id="L770"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addDepFilePost</span>(self: *Manifest, dir: fs.Dir, dep_file_basename: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) !<span class="tok-type">void</span> {</span>
<span class="line" id="L771"> assert(self.manifest_file != <span class="tok-null">null</span>);</span>
<span class="line" id="L772"></span>
<span class="line" id="L773"> <span class="tok-kw">const</span> dep_file_contents = <span class="tok-kw">try</span> dir.readFileAlloc(self.cache.gpa, dep_file_basename, manifest_file_size_max);</span>
<span class="line" id="L774"> <span class="tok-kw">defer</span> self.cache.gpa.free(dep_file_contents);</span>
<span class="line" id="L775"></span>
<span class="line" id="L776"> <span class="tok-kw">var</span> error_buf = std.ArrayList(<span class="tok-type">u8</span>).init(self.cache.gpa);</span>
<span class="line" id="L777"> <span class="tok-kw">defer</span> error_buf.deinit();</span>
<span class="line" id="L778"></span>
<span class="line" id="L779"> <span class="tok-kw">var</span> it: DepTokenizer = .{ .bytes = dep_file_contents };</span>
<span class="line" id="L780"></span>
<span class="line" id="L781"> <span class="tok-comment">// Skip first token: target.</span>
</span>
<span class="line" id="L782"> <span class="tok-kw">switch</span> (it.next() <span class="tok-kw">orelse</span> <span class="tok-kw">return</span>) { <span class="tok-comment">// Empty dep file OK.</span>
</span>
<span class="line" id="L783"> .target, .target_must_resolve, .prereq => {},</span>
<span class="line" id="L784"> <span class="tok-kw">else</span> => |err| {</span>
<span class="line" id="L785"> <span class="tok-kw">try</span> err.printError(error_buf.writer());</span>
<span class="line" id="L786"> log.err(<span class="tok-str">"failed parsing {s}: {s}"</span>, .{ dep_file_basename, error_buf.items });</span>
<span class="line" id="L787"> <span class="tok-kw">return</span> <span class="tok-kw">error</span>.InvalidDepFile;</span>
<span class="line" id="L788"> },</span>
<span class="line" id="L789"> }</span>
<span class="line" id="L790"> <span class="tok-comment">// Process 0+ preqreqs.</span>
</span>
<span class="line" id="L791"> <span class="tok-comment">// Clang is invoked in single-source mode so we never get more targets.</span>
</span>
<span class="line" id="L792"> <span class="tok-kw">while</span> (<span class="tok-null">true</span>) {</span>
<span class="line" id="L793"> <span class="tok-kw">switch</span> (it.next() <span class="tok-kw">orelse</span> <span class="tok-kw">return</span>) {</span>
<span class="line" id="L794"> .target, .target_must_resolve => <span class="tok-kw">return</span>,</span>
<span class="line" id="L795"> .prereq => |file_path| <span class="tok-kw">try</span> self.addFilePost(file_path),</span>
<span class="line" id="L796"> <span class="tok-kw">else</span> => |err| {</span>
<span class="line" id="L797"> <span class="tok-kw">try</span> err.printError(error_buf.writer());</span>
<span class="line" id="L798"> log.err(<span class="tok-str">"failed parsing {s}: {s}"</span>, .{ dep_file_basename, error_buf.items });</span>
<span class="line" id="L799"> <span class="tok-kw">return</span> <span class="tok-kw">error</span>.InvalidDepFile;</span>
<span class="line" id="L800"> },</span>
<span class="line" id="L801"> }</span>
<span class="line" id="L802"> }</span>
<span class="line" id="L803"> }</span>
<span class="line" id="L804"></span>
<span class="line" id="L805"> <span class="tok-comment">/// Returns a hex encoded hash of the inputs.</span></span>
<span class="line" id="L806"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">final</span>(self: *Manifest) [hex_digest_len]<span class="tok-type">u8</span> {</span>
<span class="line" id="L807"> assert(self.manifest_file != <span class="tok-null">null</span>);</span>
<span class="line" id="L808"></span>
<span class="line" id="L809"> <span class="tok-comment">// We don't close the manifest file yet, because we want to</span>
</span>
<span class="line" id="L810"> <span class="tok-comment">// keep it locked until the API user is done using it.</span>
</span>
<span class="line" id="L811"> <span class="tok-comment">// We also don't write out the manifest yet, because until</span>
</span>
<span class="line" id="L812"> <span class="tok-comment">// cache_release is called we still might be working on creating</span>
</span>
<span class="line" id="L813"> <span class="tok-comment">// the artifacts to cache.</span>
</span>
<span class="line" id="L814"></span>
<span class="line" id="L815"> <span class="tok-kw">var</span> bin_digest: BinDigest = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L816"> self.hash.hasher.final(&bin_digest);</span>
<span class="line" id="L817"></span>
<span class="line" id="L818"> <span class="tok-kw">var</span> out_digest: [hex_digest_len]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L819"> _ = fmt.bufPrint(</span>
<span class="line" id="L820"> &out_digest,</span>
<span class="line" id="L821"> <span class="tok-str">"{s}"</span>,</span>
<span class="line" id="L822"> .{fmt.fmtSliceHexLower(&bin_digest)},</span>
<span class="line" id="L823"> ) <span class="tok-kw">catch</span> <span class="tok-kw">unreachable</span>;</span>
<span class="line" id="L824"></span>
<span class="line" id="L825"> <span class="tok-kw">return</span> out_digest;</span>
<span class="line" id="L826"> }</span>
<span class="line" id="L827"></span>
<span class="line" id="L828"> <span class="tok-comment">/// If `want_shared_lock` is true, this function automatically downgrades the</span></span>
<span class="line" id="L829"> <span class="tok-comment">/// lock from exclusive to shared.</span></span>
<span class="line" id="L830"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">writeManifest</span>(self: *Manifest) !<span class="tok-type">void</span> {</span>
<span class="line" id="L831"> assert(self.have_exclusive_lock);</span>
<span class="line" id="L832"></span>
<span class="line" id="L833"> <span class="tok-kw">const</span> manifest_file = self.manifest_file.?;</span>
<span class="line" id="L834"> <span class="tok-kw">if</span> (self.manifest_dirty) {</span>
<span class="line" id="L835"> self.manifest_dirty = <span class="tok-null">false</span>;</span>
<span class="line" id="L836"></span>
<span class="line" id="L837"> <span class="tok-kw">var</span> contents = std.ArrayList(<span class="tok-type">u8</span>).init(self.cache.gpa);</span>
<span class="line" id="L838"> <span class="tok-kw">defer</span> contents.deinit();</span>
<span class="line" id="L839"></span>
<span class="line" id="L840"> <span class="tok-kw">const</span> writer = contents.writer();</span>
<span class="line" id="L841"> <span class="tok-kw">try</span> writer.writeAll(manifest_header ++ <span class="tok-str">"\n"</span>);</span>
<span class="line" id="L842"> <span class="tok-kw">for</span> (self.files.items) |file| {</span>
<span class="line" id="L843"> <span class="tok-kw">try</span> writer.print(<span class="tok-str">"{d} {d} {d} {} {d} {s}\n"</span>, .{</span>
<span class="line" id="L844"> file.stat.size,</span>
<span class="line" id="L845"> file.stat.inode,</span>
<span class="line" id="L846"> file.stat.mtime,</span>
<span class="line" id="L847"> fmt.fmtSliceHexLower(&file.bin_digest),</span>
<span class="line" id="L848"> file.prefixed_path.?.prefix,</span>
<span class="line" id="L849"> file.prefixed_path.?.sub_path,</span>
<span class="line" id="L850"> });</span>
<span class="line" id="L851"> }</span>
<span class="line" id="L852"></span>
<span class="line" id="L853"> <span class="tok-kw">try</span> manifest_file.setEndPos(contents.items.len);</span>
<span class="line" id="L854"> <span class="tok-kw">try</span> manifest_file.pwriteAll(contents.items, <span class="tok-number">0</span>);</span>
<span class="line" id="L855"> }</span>
<span class="line" id="L856"></span>
<span class="line" id="L857"> <span class="tok-kw">if</span> (self.want_shared_lock) {</span>
<span class="line" id="L858"> <span class="tok-kw">try</span> self.downgradeToSharedLock();</span>
<span class="line" id="L859"> }</span>
<span class="line" id="L860"> }</span>
<span class="line" id="L861"></span>
<span class="line" id="L862"> <span class="tok-kw">fn</span> <span class="tok-fn">downgradeToSharedLock</span>(self: *Manifest) !<span class="tok-type">void</span> {</span>
<span class="line" id="L863"> <span class="tok-kw">if</span> (!self.have_exclusive_lock) <span class="tok-kw">return</span>;</span>
<span class="line" id="L864"></span>
<span class="line" id="L865"> <span class="tok-comment">// WASI does not currently support flock, so we bypass it here.</span>
</span>
<span class="line" id="L866"> <span class="tok-comment">// TODO: If/when flock is supported on WASI, this check should be removed.</span>
</span>
<span class="line" id="L867"> <span class="tok-comment">// See https://github.com/WebAssembly/wasi-filesystem/issues/2</span>
</span>
<span class="line" id="L868"> <span class="tok-kw">if</span> (builtin.os.tag != .wasi <span class="tok-kw">or</span> std.process.can_spawn <span class="tok-kw">or</span> !builtin.single_threaded) {</span>
<span class="line" id="L869"> <span class="tok-kw">const</span> manifest_file = self.manifest_file.?;</span>
<span class="line" id="L870"> <span class="tok-kw">try</span> manifest_file.downgradeLock();</span>
<span class="line" id="L871"> }</span>
<span class="line" id="L872"></span>
<span class="line" id="L873"> self.have_exclusive_lock = <span class="tok-null">false</span>;</span>
<span class="line" id="L874"> }</span>
<span class="line" id="L875"></span>
<span class="line" id="L876"> <span class="tok-kw">fn</span> <span class="tok-fn">upgradeToExclusiveLock</span>(self: *Manifest) !<span class="tok-type">bool</span> {</span>
<span class="line" id="L877"> <span class="tok-kw">if</span> (self.have_exclusive_lock) <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L878"> assert(self.manifest_file != <span class="tok-null">null</span>);</span>
<span class="line" id="L879"></span>
<span class="line" id="L880"> <span class="tok-comment">// WASI does not currently support flock, so we bypass it here.</span>
</span>
<span class="line" id="L881"> <span class="tok-comment">// TODO: If/when flock is supported on WASI, this check should be removed.</span>
</span>
<span class="line" id="L882"> <span class="tok-comment">// See https://github.com/WebAssembly/wasi-filesystem/issues/2</span>
</span>
<span class="line" id="L883"> <span class="tok-kw">if</span> (builtin.os.tag != .wasi <span class="tok-kw">or</span> std.process.can_spawn <span class="tok-kw">or</span> !builtin.single_threaded) {</span>
<span class="line" id="L884"> <span class="tok-kw">const</span> manifest_file = self.manifest_file.?;</span>
<span class="line" id="L885"> <span class="tok-comment">// Here we intentionally have a period where the lock is released, in case there are</span>
</span>
<span class="line" id="L886"> <span class="tok-comment">// other processes holding a shared lock.</span>
</span>
<span class="line" id="L887"> manifest_file.unlock();</span>
<span class="line" id="L888"> <span class="tok-kw">try</span> manifest_file.lock(.exclusive);</span>
<span class="line" id="L889"> }</span>
<span class="line" id="L890"> self.have_exclusive_lock = <span class="tok-null">true</span>;</span>
<span class="line" id="L891"> <span class="tok-kw">return</span> <span class="tok-null">true</span>;</span>
<span class="line" id="L892"> }</span>
<span class="line" id="L893"></span>
<span class="line" id="L894"> <span class="tok-comment">/// Obtain only the data needed to maintain a lock on the manifest file.</span></span>
<span class="line" id="L895"> <span class="tok-comment">/// The `Manifest` remains safe to deinit.</span></span>
<span class="line" id="L896"> <span class="tok-comment">/// Don't forget to call `writeManifest` before this!</span></span>
<span class="line" id="L897"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">toOwnedLock</span>(self: *Manifest) Lock {</span>
<span class="line" id="L898"> <span class="tok-kw">const</span> lock: Lock = .{</span>
<span class="line" id="L899"> .manifest_file = self.manifest_file.?,</span>
<span class="line" id="L900"> };</span>
<span class="line" id="L901"></span>
<span class="line" id="L902"> self.manifest_file = <span class="tok-null">null</span>;</span>
<span class="line" id="L903"> <span class="tok-kw">return</span> lock;</span>
<span class="line" id="L904"> }</span>
<span class="line" id="L905"></span>
<span class="line" id="L906"> <span class="tok-comment">/// Releases the manifest file and frees any memory the Manifest was using.</span></span>
<span class="line" id="L907"> <span class="tok-comment">/// `Manifest.hit` must be called first.</span></span>
<span class="line" id="L908"> <span class="tok-comment">/// Don't forget to call `writeManifest` before this!</span></span>
<span class="line" id="L909"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">deinit</span>(self: *Manifest) <span class="tok-type">void</span> {</span>
<span class="line" id="L910"> <span class="tok-kw">if</span> (self.manifest_file) |file| {</span>
<span class="line" id="L911"> <span class="tok-kw">if</span> (builtin.os.tag == .windows) {</span>
<span class="line" id="L912"> <span class="tok-comment">// See Lock.release for why this is required on Windows</span>
</span>
<span class="line" id="L913"> file.unlock();</span>
<span class="line" id="L914"> }</span>
<span class="line" id="L915"></span>
<span class="line" id="L916"> file.close();</span>
<span class="line" id="L917"> }</span>
<span class="line" id="L918"> <span class="tok-kw">for</span> (self.files.items) |*file| {</span>
<span class="line" id="L919"> file.deinit(self.cache.gpa);</span>
<span class="line" id="L920"> }</span>
<span class="line" id="L921"> self.files.deinit(self.cache.gpa);</span>
<span class="line" id="L922"> }</span>
<span class="line" id="L923">};</span>
<span class="line" id="L924"></span>
<span class="line" id="L925"><span class="tok-comment">/// On operating systems that support symlinks, does a readlink. On other operating systems,</span></span>
<span class="line" id="L926"><span class="tok-comment">/// uses the file contents. Windows supports symlinks but only with elevated privileges, so</span></span>
<span class="line" id="L927"><span class="tok-comment">/// it is treated as not supporting symlinks.</span></span>
<span class="line" id="L928"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">readSmallFile</span>(dir: fs.Dir, sub_path: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>, buffer: []<span class="tok-type">u8</span>) ![]<span class="tok-type">u8</span> {</span>
<span class="line" id="L929"> <span class="tok-kw">if</span> (builtin.os.tag == .windows) {</span>
<span class="line" id="L930"> <span class="tok-kw">return</span> dir.readFile(sub_path, buffer);</span>
<span class="line" id="L931"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L932"> <span class="tok-kw">return</span> dir.readLink(sub_path, buffer);</span>
<span class="line" id="L933"> }</span>
<span class="line" id="L934">}</span>
<span class="line" id="L935"></span>
<span class="line" id="L936"><span class="tok-comment">/// On operating systems that support symlinks, does a symlink. On other operating systems,</span></span>
<span class="line" id="L937"><span class="tok-comment">/// uses the file contents. Windows supports symlinks but only with elevated privileges, so</span></span>
<span class="line" id="L938"><span class="tok-comment">/// it is treated as not supporting symlinks.</span></span>
<span class="line" id="L939"><span class="tok-comment">/// `data` must be a valid UTF-8 encoded file path and 255 bytes or fewer.</span></span>
<span class="line" id="L940"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">writeSmallFile</span>(dir: fs.Dir, sub_path: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>, data: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) !<span class="tok-type">void</span> {</span>
<span class="line" id="L941"> assert(data.len <= <span class="tok-number">255</span>);</span>
<span class="line" id="L942"> <span class="tok-kw">if</span> (builtin.os.tag == .windows) {</span>
<span class="line" id="L943"> <span class="tok-kw">return</span> dir.writeFile(sub_path, data);</span>
<span class="line" id="L944"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L945"> <span class="tok-kw">return</span> dir.symLink(data, sub_path, .{});</span>
<span class="line" id="L946"> }</span>
<span class="line" id="L947">}</span>
<span class="line" id="L948"></span>
<span class="line" id="L949"><span class="tok-kw">fn</span> <span class="tok-fn">hashFile</span>(file: fs.File, bin_digest: *[Hasher.mac_length]<span class="tok-type">u8</span>) !<span class="tok-type">void</span> {</span>
<span class="line" id="L950"> <span class="tok-kw">var</span> buf: [<span class="tok-number">1024</span>]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L951"></span>
<span class="line" id="L952"> <span class="tok-kw">var</span> hasher = hasher_init;</span>
<span class="line" id="L953"> <span class="tok-kw">while</span> (<span class="tok-null">true</span>) {</span>
<span class="line" id="L954"> <span class="tok-kw">const</span> bytes_read = <span class="tok-kw">try</span> file.read(&buf);</span>
<span class="line" id="L955"> <span class="tok-kw">if</span> (bytes_read == <span class="tok-number">0</span>) <span class="tok-kw">break</span>;</span>
<span class="line" id="L956"> hasher.update(buf[<span class="tok-number">0</span>..bytes_read]);</span>
<span class="line" id="L957"> }</span>
<span class="line" id="L958"></span>
<span class="line" id="L959"> hasher.final(bin_digest);</span>
<span class="line" id="L960">}</span>
<span class="line" id="L961"></span>
<span class="line" id="L962"><span class="tok-comment">// Create/Write a file, close it, then grab its stat.mtime timestamp.</span>
</span>
<span class="line" id="L963"><span class="tok-kw">fn</span> <span class="tok-fn">testGetCurrentFileTimestamp</span>(dir: fs.Dir) !<span class="tok-type">i128</span> {</span>
<span class="line" id="L964"> <span class="tok-kw">const</span> test_out_file = <span class="tok-str">"test-filetimestamp.tmp"</span>;</span>
<span class="line" id="L965"></span>
<span class="line" id="L966"> <span class="tok-kw">var</span> file = <span class="tok-kw">try</span> dir.createFile(test_out_file, .{</span>
<span class="line" id="L967"> .read = <span class="tok-null">true</span>,</span>
<span class="line" id="L968"> .truncate = <span class="tok-null">true</span>,</span>
<span class="line" id="L969"> });</span>
<span class="line" id="L970"> <span class="tok-kw">defer</span> {</span>
<span class="line" id="L971"> file.close();</span>
<span class="line" id="L972"> dir.deleteFile(test_out_file) <span class="tok-kw">catch</span> {};</span>
<span class="line" id="L973"> }</span>
<span class="line" id="L974"></span>
<span class="line" id="L975"> <span class="tok-kw">return</span> (<span class="tok-kw">try</span> file.stat()).mtime;</span>
<span class="line" id="L976">}</span>
<span class="line" id="L977"></span>
<span class="line" id="L978"><span class="tok-kw">test</span> <span class="tok-str">"cache file and then recall it"</span> {</span>
<span class="line" id="L979"> <span class="tok-kw">if</span> (builtin.os.tag == .wasi) {</span>
<span class="line" id="L980"> <span class="tok-comment">// https://github.com/ziglang/zig/issues/5437</span>
</span>
<span class="line" id="L981"> <span class="tok-kw">return</span> <span class="tok-kw">error</span>.SkipZigTest;</span>
<span class="line" id="L982"> }</span>
<span class="line" id="L983"></span>
<span class="line" id="L984"> <span class="tok-kw">var</span> tmp = testing.tmpDir(.{});</span>
<span class="line" id="L985"> <span class="tok-kw">defer</span> tmp.cleanup();</span>
<span class="line" id="L986"></span>
<span class="line" id="L987"> <span class="tok-kw">const</span> temp_file = <span class="tok-str">"test.txt"</span>;</span>
<span class="line" id="L988"> <span class="tok-kw">const</span> temp_manifest_dir = <span class="tok-str">"temp_manifest_dir"</span>;</span>
<span class="line" id="L989"></span>
<span class="line" id="L990"> <span class="tok-kw">try</span> tmp.dir.writeFile(temp_file, <span class="tok-str">"Hello, world!\n"</span>);</span>
<span class="line" id="L991"></span>
<span class="line" id="L992"> <span class="tok-comment">// Wait for file timestamps to tick</span>
</span>
<span class="line" id="L993"> <span class="tok-kw">const</span> initial_time = <span class="tok-kw">try</span> testGetCurrentFileTimestamp(tmp.dir);</span>
<span class="line" id="L994"> <span class="tok-kw">while</span> ((<span class="tok-kw">try</span> testGetCurrentFileTimestamp(tmp.dir)) == initial_time) {</span>
<span class="line" id="L995"> std.time.sleep(<span class="tok-number">1</span>);</span>
<span class="line" id="L996"> }</span>
<span class="line" id="L997"></span>
<span class="line" id="L998"> <span class="tok-kw">var</span> digest1: [hex_digest_len]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L999"> <span class="tok-kw">var</span> digest2: [hex_digest_len]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L1000"></span>
<span class="line" id="L1001"> {</span>
<span class="line" id="L1002"> <span class="tok-kw">var</span> cache = Cache{</span>
<span class="line" id="L1003"> .gpa = testing.allocator,</span>
<span class="line" id="L1004"> .manifest_dir = <span class="tok-kw">try</span> tmp.dir.makeOpenPath(temp_manifest_dir, .{}),</span>
<span class="line" id="L1005"> };</span>
<span class="line" id="L1006"> cache.addPrefix(.{ .path = <span class="tok-null">null</span>, .handle = tmp.dir });</span>
<span class="line" id="L1007"> <span class="tok-kw">defer</span> cache.manifest_dir.close();</span>
<span class="line" id="L1008"></span>
<span class="line" id="L1009"> {</span>
<span class="line" id="L1010"> <span class="tok-kw">var</span> ch = cache.obtain();</span>
<span class="line" id="L1011"> <span class="tok-kw">defer</span> ch.deinit();</span>
<span class="line" id="L1012"></span>
<span class="line" id="L1013"> ch.hash.add(<span class="tok-null">true</span>);</span>
<span class="line" id="L1014"> ch.hash.add(<span class="tok-builtin">@as</span>(<span class="tok-type">u16</span>, <span class="tok-number">1234</span>));</span>
<span class="line" id="L1015"> ch.hash.addBytes(<span class="tok-str">"1234"</span>);</span>
<span class="line" id="L1016"> _ = <span class="tok-kw">try</span> ch.addFile(temp_file, <span class="tok-null">null</span>);</span>
<span class="line" id="L1017"></span>
<span class="line" id="L1018"> <span class="tok-comment">// There should be nothing in the cache</span>
</span>
<span class="line" id="L1019"> <span class="tok-kw">try</span> testing.expectEqual(<span class="tok-null">false</span>, <span class="tok-kw">try</span> ch.hit());</span>
<span class="line" id="L1020"></span>
<span class="line" id="L1021"> digest1 = ch.final();</span>
<span class="line" id="L1022"> <span class="tok-kw">try</span> ch.writeManifest();</span>
<span class="line" id="L1023"> }</span>
<span class="line" id="L1024"> {</span>
<span class="line" id="L1025"> <span class="tok-kw">var</span> ch = cache.obtain();</span>
<span class="line" id="L1026"> <span class="tok-kw">defer</span> ch.deinit();</span>
<span class="line" id="L1027"></span>
<span class="line" id="L1028"> ch.hash.add(<span class="tok-null">true</span>);</span>
<span class="line" id="L1029"> ch.hash.add(<span class="tok-builtin">@as</span>(<span class="tok-type">u16</span>, <span class="tok-number">1234</span>));</span>
<span class="line" id="L1030"> ch.hash.addBytes(<span class="tok-str">"1234"</span>);</span>
<span class="line" id="L1031"> _ = <span class="tok-kw">try</span> ch.addFile(temp_file, <span class="tok-null">null</span>);</span>
<span class="line" id="L1032"></span>
<span class="line" id="L1033"> <span class="tok-comment">// Cache hit! We just "built" the same file</span>
</span>
<span class="line" id="L1034"> <span class="tok-kw">try</span> testing.expect(<span class="tok-kw">try</span> ch.hit());</span>
<span class="line" id="L1035"> digest2 = ch.final();</span>
<span class="line" id="L1036"></span>
<span class="line" id="L1037"> <span class="tok-kw">try</span> testing.expectEqual(<span class="tok-null">false</span>, ch.have_exclusive_lock);</span>
<span class="line" id="L1038"> }</span>
<span class="line" id="L1039"></span>
<span class="line" id="L1040"> <span class="tok-kw">try</span> testing.expectEqual(digest1, digest2);</span>
<span class="line" id="L1041"> }</span>
<span class="line" id="L1042">}</span>
<span class="line" id="L1043"></span>
<span class="line" id="L1044"><span class="tok-kw">test</span> <span class="tok-str">"check that changing a file makes cache fail"</span> {</span>
<span class="line" id="L1045"> <span class="tok-kw">if</span> (builtin.os.tag == .wasi) {</span>
<span class="line" id="L1046"> <span class="tok-comment">// https://github.com/ziglang/zig/issues/5437</span>
</span>
<span class="line" id="L1047"> <span class="tok-kw">return</span> <span class="tok-kw">error</span>.SkipZigTest;</span>
<span class="line" id="L1048"> }</span>
<span class="line" id="L1049"> <span class="tok-kw">var</span> tmp = testing.tmpDir(.{});</span>
<span class="line" id="L1050"> <span class="tok-kw">defer</span> tmp.cleanup();</span>
<span class="line" id="L1051"></span>
<span class="line" id="L1052"> <span class="tok-kw">const</span> temp_file = <span class="tok-str">"cache_hash_change_file_test.txt"</span>;</span>
<span class="line" id="L1053"> <span class="tok-kw">const</span> temp_manifest_dir = <span class="tok-str">"cache_hash_change_file_manifest_dir"</span>;</span>
<span class="line" id="L1054"> <span class="tok-kw">const</span> original_temp_file_contents = <span class="tok-str">"Hello, world!\n"</span>;</span>
<span class="line" id="L1055"> <span class="tok-kw">const</span> updated_temp_file_contents = <span class="tok-str">"Hello, world; but updated!\n"</span>;</span>
<span class="line" id="L1056"></span>
<span class="line" id="L1057"> <span class="tok-kw">try</span> tmp.dir.writeFile(temp_file, original_temp_file_contents);</span>
<span class="line" id="L1058"></span>
<span class="line" id="L1059"> <span class="tok-comment">// Wait for file timestamps to tick</span>
</span>
<span class="line" id="L1060"> <span class="tok-kw">const</span> initial_time = <span class="tok-kw">try</span> testGetCurrentFileTimestamp(tmp.dir);</span>
<span class="line" id="L1061"> <span class="tok-kw">while</span> ((<span class="tok-kw">try</span> testGetCurrentFileTimestamp(tmp.dir)) == initial_time) {</span>
<span class="line" id="L1062"> std.time.sleep(<span class="tok-number">1</span>);</span>
<span class="line" id="L1063"> }</span>
<span class="line" id="L1064"></span>
<span class="line" id="L1065"> <span class="tok-kw">var</span> digest1: [hex_digest_len]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L1066"> <span class="tok-kw">var</span> digest2: [hex_digest_len]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L1067"></span>
<span class="line" id="L1068"> {</span>
<span class="line" id="L1069"> <span class="tok-kw">var</span> cache = Cache{</span>
<span class="line" id="L1070"> .gpa = testing.allocator,</span>
<span class="line" id="L1071"> .manifest_dir = <span class="tok-kw">try</span> tmp.dir.makeOpenPath(temp_manifest_dir, .{}),</span>
<span class="line" id="L1072"> };</span>
<span class="line" id="L1073"> cache.addPrefix(.{ .path = <span class="tok-null">null</span>, .handle = tmp.dir });</span>
<span class="line" id="L1074"> <span class="tok-kw">defer</span> cache.manifest_dir.close();</span>
<span class="line" id="L1075"></span>
<span class="line" id="L1076"> {</span>
<span class="line" id="L1077"> <span class="tok-kw">var</span> ch = cache.obtain();</span>
<span class="line" id="L1078"> <span class="tok-kw">defer</span> ch.deinit();</span>
<span class="line" id="L1079"></span>
<span class="line" id="L1080"> ch.hash.addBytes(<span class="tok-str">"1234"</span>);</span>
<span class="line" id="L1081"> <span class="tok-kw">const</span> temp_file_idx = <span class="tok-kw">try</span> ch.addFile(temp_file, <span class="tok-number">100</span>);</span>
<span class="line" id="L1082"></span>
<span class="line" id="L1083"> <span class="tok-comment">// There should be nothing in the cache</span>
</span>
<span class="line" id="L1084"> <span class="tok-kw">try</span> testing.expectEqual(<span class="tok-null">false</span>, <span class="tok-kw">try</span> ch.hit());</span>
<span class="line" id="L1085"></span>
<span class="line" id="L1086"> <span class="tok-kw">try</span> testing.expect(mem.eql(<span class="tok-type">u8</span>, original_temp_file_contents, ch.files.items[temp_file_idx].contents.?));</span>
<span class="line" id="L1087"></span>
<span class="line" id="L1088"> digest1 = ch.final();</span>
<span class="line" id="L1089"></span>
<span class="line" id="L1090"> <span class="tok-kw">try</span> ch.writeManifest();</span>
<span class="line" id="L1091"> }</span>
<span class="line" id="L1092"></span>
<span class="line" id="L1093"> <span class="tok-kw">try</span> tmp.dir.writeFile(temp_file, updated_temp_file_contents);</span>
<span class="line" id="L1094"></span>
<span class="line" id="L1095"> {</span>
<span class="line" id="L1096"> <span class="tok-kw">var</span> ch = cache.obtain();</span>
<span class="line" id="L1097"> <span class="tok-kw">defer</span> ch.deinit();</span>
<span class="line" id="L1098"></span>
<span class="line" id="L1099"> ch.hash.addBytes(<span class="tok-str">"1234"</span>);</span>
<span class="line" id="L1100"> <span class="tok-kw">const</span> temp_file_idx = <span class="tok-kw">try</span> ch.addFile(temp_file, <span class="tok-number">100</span>);</span>
<span class="line" id="L1101"></span>
<span class="line" id="L1102"> <span class="tok-comment">// A file that we depend on has been updated, so the cache should not contain an entry for it</span>
</span>
<span class="line" id="L1103"> <span class="tok-kw">try</span> testing.expectEqual(<span class="tok-null">false</span>, <span class="tok-kw">try</span> ch.hit());</span>
<span class="line" id="L1104"></span>
<span class="line" id="L1105"> <span class="tok-comment">// The cache system does not keep the contents of re-hashed input files.</span>
</span>
<span class="line" id="L1106"> <span class="tok-kw">try</span> testing.expect(ch.files.items[temp_file_idx].contents == <span class="tok-null">null</span>);</span>
<span class="line" id="L1107"></span>
<span class="line" id="L1108"> digest2 = ch.final();</span>
<span class="line" id="L1109"></span>
<span class="line" id="L1110"> <span class="tok-kw">try</span> ch.writeManifest();</span>
<span class="line" id="L1111"> }</span>
<span class="line" id="L1112"></span>
<span class="line" id="L1113"> <span class="tok-kw">try</span> testing.expect(!mem.eql(<span class="tok-type">u8</span>, digest1[<span class="tok-number">0</span>..], digest2[<span class="tok-number">0</span>..]));</span>
<span class="line" id="L1114"> }</span>
<span class="line" id="L1115">}</span>
<span class="line" id="L1116"></span>
<span class="line" id="L1117"><span class="tok-kw">test</span> <span class="tok-str">"no file inputs"</span> {</span>
<span class="line" id="L1118"> <span class="tok-kw">if</span> (builtin.os.tag == .wasi) {</span>
<span class="line" id="L1119"> <span class="tok-comment">// https://github.com/ziglang/zig/issues/5437</span>
</span>
<span class="line" id="L1120"> <span class="tok-kw">return</span> <span class="tok-kw">error</span>.SkipZigTest;</span>
<span class="line" id="L1121"> }</span>
<span class="line" id="L1122"></span>
<span class="line" id="L1123"> <span class="tok-kw">var</span> tmp = testing.tmpDir(.{});</span>
<span class="line" id="L1124"> <span class="tok-kw">defer</span> tmp.cleanup();</span>
<span class="line" id="L1125"></span>
<span class="line" id="L1126"> <span class="tok-kw">const</span> temp_manifest_dir = <span class="tok-str">"no_file_inputs_manifest_dir"</span>;</span>
<span class="line" id="L1127"></span>
<span class="line" id="L1128"> <span class="tok-kw">var</span> digest1: [hex_digest_len]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L1129"> <span class="tok-kw">var</span> digest2: [hex_digest_len]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L1130"></span>
<span class="line" id="L1131"> <span class="tok-kw">var</span> cache = Cache{</span>
<span class="line" id="L1132"> .gpa = testing.allocator,</span>
<span class="line" id="L1133"> .manifest_dir = <span class="tok-kw">try</span> tmp.dir.makeOpenPath(temp_manifest_dir, .{}),</span>
<span class="line" id="L1134"> };</span>
<span class="line" id="L1135"> cache.addPrefix(.{ .path = <span class="tok-null">null</span>, .handle = tmp.dir });</span>
<span class="line" id="L1136"> <span class="tok-kw">defer</span> cache.manifest_dir.close();</span>
<span class="line" id="L1137"></span>
<span class="line" id="L1138"> {</span>
<span class="line" id="L1139"> <span class="tok-kw">var</span> man = cache.obtain();</span>
<span class="line" id="L1140"> <span class="tok-kw">defer</span> man.deinit();</span>
<span class="line" id="L1141"></span>
<span class="line" id="L1142"> man.hash.addBytes(<span class="tok-str">"1234"</span>);</span>
<span class="line" id="L1143"></span>
<span class="line" id="L1144"> <span class="tok-comment">// There should be nothing in the cache</span>
</span>
<span class="line" id="L1145"> <span class="tok-kw">try</span> testing.expectEqual(<span class="tok-null">false</span>, <span class="tok-kw">try</span> man.hit());</span>
<span class="line" id="L1146"></span>
<span class="line" id="L1147"> digest1 = man.final();</span>
<span class="line" id="L1148"></span>
<span class="line" id="L1149"> <span class="tok-kw">try</span> man.writeManifest();</span>
<span class="line" id="L1150"> }</span>
<span class="line" id="L1151"> {</span>
<span class="line" id="L1152"> <span class="tok-kw">var</span> man = cache.obtain();</span>
<span class="line" id="L1153"> <span class="tok-kw">defer</span> man.deinit();</span>
<span class="line" id="L1154"></span>
<span class="line" id="L1155"> man.hash.addBytes(<span class="tok-str">"1234"</span>);</span>
<span class="line" id="L1156"></span>
<span class="line" id="L1157"> <span class="tok-kw">try</span> testing.expect(<span class="tok-kw">try</span> man.hit());</span>
<span class="line" id="L1158"> digest2 = man.final();</span>
<span class="line" id="L1159"> <span class="tok-kw">try</span> testing.expectEqual(<span class="tok-null">false</span>, man.have_exclusive_lock);</span>
<span class="line" id="L1160"> }</span>
<span class="line" id="L1161"></span>
<span class="line" id="L1162"> <span class="tok-kw">try</span> testing.expectEqual(digest1, digest2);</span>
<span class="line" id="L1163">}</span>
<span class="line" id="L1164"></span>
<span class="line" id="L1165"><span class="tok-kw">test</span> <span class="tok-str">"Manifest with files added after initial hash work"</span> {</span>
<span class="line" id="L1166"> <span class="tok-kw">if</span> (builtin.os.tag == .wasi) {</span>
<span class="line" id="L1167"> <span class="tok-comment">// https://github.com/ziglang/zig/issues/5437</span>
</span>
<span class="line" id="L1168"> <span class="tok-kw">return</span> <span class="tok-kw">error</span>.SkipZigTest;</span>
<span class="line" id="L1169"> }</span>
<span class="line" id="L1170"> <span class="tok-kw">var</span> tmp = testing.tmpDir(.{});</span>
<span class="line" id="L1171"> <span class="tok-kw">defer</span> tmp.cleanup();</span>
<span class="line" id="L1172"></span>
<span class="line" id="L1173"> <span class="tok-kw">const</span> temp_file1 = <span class="tok-str">"cache_hash_post_file_test1.txt"</span>;</span>
<span class="line" id="L1174"> <span class="tok-kw">const</span> temp_file2 = <span class="tok-str">"cache_hash_post_file_test2.txt"</span>;</span>
<span class="line" id="L1175"> <span class="tok-kw">const</span> temp_manifest_dir = <span class="tok-str">"cache_hash_post_file_manifest_dir"</span>;</span>
<span class="line" id="L1176"></span>
<span class="line" id="L1177"> <span class="tok-kw">try</span> tmp.dir.writeFile(temp_file1, <span class="tok-str">"Hello, world!\n"</span>);</span>
<span class="line" id="L1178"> <span class="tok-kw">try</span> tmp.dir.writeFile(temp_file2, <span class="tok-str">"Hello world the second!\n"</span>);</span>
<span class="line" id="L1179"></span>
<span class="line" id="L1180"> <span class="tok-comment">// Wait for file timestamps to tick</span>
</span>
<span class="line" id="L1181"> <span class="tok-kw">const</span> initial_time = <span class="tok-kw">try</span> testGetCurrentFileTimestamp(tmp.dir);</span>
<span class="line" id="L1182"> <span class="tok-kw">while</span> ((<span class="tok-kw">try</span> testGetCurrentFileTimestamp(tmp.dir)) == initial_time) {</span>
<span class="line" id="L1183"> std.time.sleep(<span class="tok-number">1</span>);</span>
<span class="line" id="L1184"> }</span>
<span class="line" id="L1185"></span>
<span class="line" id="L1186"> <span class="tok-kw">var</span> digest1: [hex_digest_len]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L1187"> <span class="tok-kw">var</span> digest2: [hex_digest_len]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L1188"> <span class="tok-kw">var</span> digest3: [hex_digest_len]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L1189"></span>
<span class="line" id="L1190"> {</span>
<span class="line" id="L1191"> <span class="tok-kw">var</span> cache = Cache{</span>
<span class="line" id="L1192"> .gpa = testing.allocator,</span>
<span class="line" id="L1193"> .manifest_dir = <span class="tok-kw">try</span> tmp.dir.makeOpenPath(temp_manifest_dir, .{}),</span>
<span class="line" id="L1194"> };</span>
<span class="line" id="L1195"> cache.addPrefix(.{ .path = <span class="tok-null">null</span>, .handle = tmp.dir });</span>
<span class="line" id="L1196"> <span class="tok-kw">defer</span> cache.manifest_dir.close();</span>
<span class="line" id="L1197"></span>
<span class="line" id="L1198"> {</span>
<span class="line" id="L1199"> <span class="tok-kw">var</span> ch = cache.obtain();</span>
<span class="line" id="L1200"> <span class="tok-kw">defer</span> ch.deinit();</span>
<span class="line" id="L1201"></span>
<span class="line" id="L1202"> ch.hash.addBytes(<span class="tok-str">"1234"</span>);</span>
<span class="line" id="L1203"> _ = <span class="tok-kw">try</span> ch.addFile(temp_file1, <span class="tok-null">null</span>);</span>
<span class="line" id="L1204"></span>
<span class="line" id="L1205"> <span class="tok-comment">// There should be nothing in the cache</span>
</span>
<span class="line" id="L1206"> <span class="tok-kw">try</span> testing.expectEqual(<span class="tok-null">false</span>, <span class="tok-kw">try</span> ch.hit());</span>
<span class="line" id="L1207"></span>
<span class="line" id="L1208"> _ = <span class="tok-kw">try</span> ch.addFilePost(temp_file2);</span>
<span class="line" id="L1209"></span>
<span class="line" id="L1210"> digest1 = ch.final();</span>
<span class="line" id="L1211"> <span class="tok-kw">try</span> ch.writeManifest();</span>
<span class="line" id="L1212"> }</span>
<span class="line" id="L1213"> {</span>
<span class="line" id="L1214"> <span class="tok-kw">var</span> ch = cache.obtain();</span>
<span class="line" id="L1215"> <span class="tok-kw">defer</span> ch.deinit();</span>
<span class="line" id="L1216"></span>
<span class="line" id="L1217"> ch.hash.addBytes(<span class="tok-str">"1234"</span>);</span>
<span class="line" id="L1218"> _ = <span class="tok-kw">try</span> ch.addFile(temp_file1, <span class="tok-null">null</span>);</span>
<span class="line" id="L1219"></span>
<span class="line" id="L1220"> <span class="tok-kw">try</span> testing.expect(<span class="tok-kw">try</span> ch.hit());</span>
<span class="line" id="L1221"> digest2 = ch.final();</span>
<span class="line" id="L1222"></span>
<span class="line" id="L1223"> <span class="tok-kw">try</span> testing.expectEqual(<span class="tok-null">false</span>, ch.have_exclusive_lock);</span>
<span class="line" id="L1224"> }</span>
<span class="line" id="L1225"> <span class="tok-kw">try</span> testing.expect(mem.eql(<span class="tok-type">u8</span>, &digest1, &digest2));</span>
<span class="line" id="L1226"></span>
<span class="line" id="L1227"> <span class="tok-comment">// Modify the file added after initial hash</span>
</span>
<span class="line" id="L1228"> <span class="tok-kw">try</span> tmp.dir.writeFile(temp_file2, <span class="tok-str">"Hello world the second, updated\n"</span>);</span>
<span class="line" id="L1229"></span>
<span class="line" id="L1230"> <span class="tok-comment">// Wait for file timestamps to tick</span>
</span>
<span class="line" id="L1231"> <span class="tok-kw">const</span> initial_time2 = <span class="tok-kw">try</span> testGetCurrentFileTimestamp(tmp.dir);</span>
<span class="line" id="L1232"> <span class="tok-kw">while</span> ((<span class="tok-kw">try</span> testGetCurrentFileTimestamp(tmp.dir)) == initial_time2) {</span>
<span class="line" id="L1233"> std.time.sleep(<span class="tok-number">1</span>);</span>
<span class="line" id="L1234"> }</span>
<span class="line" id="L1235"></span>
<span class="line" id="L1236"> {</span>
<span class="line" id="L1237"> <span class="tok-kw">var</span> ch = cache.obtain();</span>
<span class="line" id="L1238"> <span class="tok-kw">defer</span> ch.deinit();</span>
<span class="line" id="L1239"></span>
<span class="line" id="L1240"> ch.hash.addBytes(<span class="tok-str">"1234"</span>);</span>
<span class="line" id="L1241"> _ = <span class="tok-kw">try</span> ch.addFile(temp_file1, <span class="tok-null">null</span>);</span>
<span class="line" id="L1242"></span>
<span class="line" id="L1243"> <span class="tok-comment">// A file that we depend on has been updated, so the cache should not contain an entry for it</span>
</span>
<span class="line" id="L1244"> <span class="tok-kw">try</span> testing.expectEqual(<span class="tok-null">false</span>, <span class="tok-kw">try</span> ch.hit());</span>
<span class="line" id="L1245"></span>
<span class="line" id="L1246"> _ = <span class="tok-kw">try</span> ch.addFilePost(temp_file2);</span>
<span class="line" id="L1247"></span>
<span class="line" id="L1248"> digest3 = ch.final();</span>
<span class="line" id="L1249"></span>
<span class="line" id="L1250"> <span class="tok-kw">try</span> ch.writeManifest();</span>
<span class="line" id="L1251"> }</span>
<span class="line" id="L1252"></span>
<span class="line" id="L1253"> <span class="tok-kw">try</span> testing.expect(!mem.eql(<span class="tok-type">u8</span>, &digest1, &digest3));</span>
<span class="line" id="L1254"> }</span>
<span class="line" id="L1255">}</span>
<span class="line" id="L1256"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/Build/Step.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>Build/Step.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1">id: Id,</span>
<span class="line" id="L2">name: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L3">owner: *Build,</span>
<span class="line" id="L4">makeFn: MakeFn,</span>
<span class="line" id="L5"></span>
<span class="line" id="L6">dependencies: std.ArrayList(*Step),</span>
<span class="line" id="L7"><span class="tok-comment">/// This field is empty during execution of the user's build script, and</span></span>
<span class="line" id="L8"><span class="tok-comment">/// then populated during dependency loop checking in the build runner.</span></span>
<span class="line" id="L9">dependants: std.ArrayListUnmanaged(*Step),</span>
<span class="line" id="L10">state: State,</span>
<span class="line" id="L11"><span class="tok-comment">/// Set this field to declare an upper bound on the amount of bytes of memory it will</span></span>
<span class="line" id="L12"><span class="tok-comment">/// take to run the step. Zero means no limit.</span></span>
<span class="line" id="L13"><span class="tok-comment">///</span></span>
<span class="line" id="L14"><span class="tok-comment">/// The idea to annotate steps that might use a high amount of RAM with an</span></span>
<span class="line" id="L15"><span class="tok-comment">/// upper bound. For example, perhaps a particular set of unit tests require 4</span></span>
<span class="line" id="L16"><span class="tok-comment">/// GiB of RAM, and those tests will be run under 4 different build</span></span>
<span class="line" id="L17"><span class="tok-comment">/// configurations at once. This would potentially require 16 GiB of memory on</span></span>
<span class="line" id="L18"><span class="tok-comment">/// the system if all 4 steps executed simultaneously, which could easily be</span></span>
<span class="line" id="L19"><span class="tok-comment">/// greater than what is actually available, potentially causing the system to</span></span>
<span class="line" id="L20"><span class="tok-comment">/// crash when using `zig build` at the default concurrency level.</span></span>
<span class="line" id="L21"><span class="tok-comment">///</span></span>
<span class="line" id="L22"><span class="tok-comment">/// This field causes the build runner to do two things:</span></span>
<span class="line" id="L23"><span class="tok-comment">/// 1. ulimit child processes, so that they will fail if it would exceed this</span></span>
<span class="line" id="L24"><span class="tok-comment">/// memory limit. This serves to enforce that this upper bound value is</span></span>
<span class="line" id="L25"><span class="tok-comment">/// correct.</span></span>
<span class="line" id="L26"><span class="tok-comment">/// 2. Ensure that the set of concurrent steps at any given time have a total</span></span>
<span class="line" id="L27"><span class="tok-comment">/// max_rss value that does not exceed the `max_total_rss` value of the build</span></span>
<span class="line" id="L28"><span class="tok-comment">/// runner. This value is configurable on the command line, and defaults to the</span></span>
<span class="line" id="L29"><span class="tok-comment">/// total system memory available.</span></span>
<span class="line" id="L30">max_rss: <span class="tok-type">usize</span>,</span>
<span class="line" id="L31"></span>
<span class="line" id="L32">result_error_msgs: std.ArrayListUnmanaged([]<span class="tok-kw">const</span> <span class="tok-type">u8</span>),</span>
<span class="line" id="L33">result_error_bundle: std.zig.ErrorBundle,</span>
<span class="line" id="L34">result_cached: <span class="tok-type">bool</span>,</span>
<span class="line" id="L35">result_duration_ns: ?<span class="tok-type">u64</span>,</span>
<span class="line" id="L36"><span class="tok-comment">/// 0 means unavailable or not reported.</span></span>
<span class="line" id="L37">result_peak_rss: <span class="tok-type">usize</span>,</span>
<span class="line" id="L38">test_results: TestResults,</span>
<span class="line" id="L39"></span>
<span class="line" id="L40"><span class="tok-comment">/// The return address associated with creation of this step that can be useful</span></span>
<span class="line" id="L41"><span class="tok-comment">/// to print along with debugging messages.</span></span>
<span class="line" id="L42">debug_stack_trace: [n_debug_stack_frames]<span class="tok-type">usize</span>,</span>
<span class="line" id="L43"></span>
<span class="line" id="L44"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> TestResults = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L45"> fail_count: <span class="tok-type">u32</span> = <span class="tok-number">0</span>,</span>
<span class="line" id="L46"> skip_count: <span class="tok-type">u32</span> = <span class="tok-number">0</span>,</span>
<span class="line" id="L47"> leak_count: <span class="tok-type">u32</span> = <span class="tok-number">0</span>,</span>
<span class="line" id="L48"> test_count: <span class="tok-type">u32</span> = <span class="tok-number">0</span>,</span>
<span class="line" id="L49"></span>
<span class="line" id="L50"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">isSuccess</span>(tr: TestResults) <span class="tok-type">bool</span> {</span>
<span class="line" id="L51"> <span class="tok-kw">return</span> tr.fail_count == <span class="tok-number">0</span> <span class="tok-kw">and</span> tr.leak_count == <span class="tok-number">0</span>;</span>
<span class="line" id="L52"> }</span>
<span class="line" id="L53"></span>
<span class="line" id="L54"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">passCount</span>(tr: TestResults) <span class="tok-type">u32</span> {</span>
<span class="line" id="L55"> <span class="tok-kw">return</span> tr.test_count - tr.fail_count - tr.skip_count;</span>
<span class="line" id="L56"> }</span>
<span class="line" id="L57">};</span>
<span class="line" id="L58"></span>
<span class="line" id="L59"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> MakeFn = *<span class="tok-kw">const</span> <span class="tok-kw">fn</span> (self: *Step, prog_node: *std.Progress.Node) <span class="tok-type">anyerror</span>!<span class="tok-type">void</span>;</span>
<span class="line" id="L60"></span>
<span class="line" id="L61"><span class="tok-kw">const</span> n_debug_stack_frames = <span class="tok-number">4</span>;</span>
<span class="line" id="L62"></span>
<span class="line" id="L63"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> State = <span class="tok-kw">enum</span> {</span>
<span class="line" id="L64"> precheck_unstarted,</span>
<span class="line" id="L65"> precheck_started,</span>
<span class="line" id="L66"> precheck_done,</span>
<span class="line" id="L67"> running,</span>
<span class="line" id="L68"> dependency_failure,</span>
<span class="line" id="L69"> success,</span>
<span class="line" id="L70"> failure,</span>
<span class="line" id="L71"> <span class="tok-comment">/// This state indicates that the step did not complete, however, it also did not fail,</span></span>
<span class="line" id="L72"> <span class="tok-comment">/// and it is safe to continue executing its dependencies.</span></span>
<span class="line" id="L73"> skipped,</span>
<span class="line" id="L74">};</span>
<span class="line" id="L75"></span>
<span class="line" id="L76"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> Id = <span class="tok-kw">enum</span> {</span>
<span class="line" id="L77"> top_level,</span>
<span class="line" id="L78"> compile,</span>
<span class="line" id="L79"> install_artifact,</span>
<span class="line" id="L80"> install_file,</span>
<span class="line" id="L81"> install_dir,</span>
<span class="line" id="L82"> remove_dir,</span>
<span class="line" id="L83"> fmt,</span>
<span class="line" id="L84"> translate_c,</span>
<span class="line" id="L85"> write_file,</span>
<span class="line" id="L86"> run,</span>
<span class="line" id="L87"> check_file,</span>
<span class="line" id="L88"> check_object,</span>
<span class="line" id="L89"> config_header,</span>
<span class="line" id="L90"> objcopy,</span>
<span class="line" id="L91"> options,</span>
<span class="line" id="L92"> custom,</span>
<span class="line" id="L93"></span>
<span class="line" id="L94"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">Type</span>(<span class="tok-kw">comptime</span> id: Id) <span class="tok-type">type</span> {</span>
<span class="line" id="L95"> <span class="tok-kw">return</span> <span class="tok-kw">switch</span> (id) {</span>
<span class="line" id="L96"> .top_level => Build.TopLevelStep,</span>
<span class="line" id="L97"> .compile => Compile,</span>
<span class="line" id="L98"> .install_artifact => InstallArtifact,</span>
<span class="line" id="L99"> .install_file => InstallFile,</span>
<span class="line" id="L100"> .install_dir => InstallDir,</span>
<span class="line" id="L101"> .remove_dir => RemoveDir,</span>
<span class="line" id="L102"> .fmt => Fmt,</span>
<span class="line" id="L103"> .translate_c => TranslateC,</span>
<span class="line" id="L104"> .write_file => WriteFile,</span>
<span class="line" id="L105"> .run => Run,</span>
<span class="line" id="L106"> .check_file => CheckFile,</span>
<span class="line" id="L107"> .check_object => CheckObject,</span>
<span class="line" id="L108"> .config_header => ConfigHeader,</span>
<span class="line" id="L109"> .objcopy => ObjCopy,</span>
<span class="line" id="L110"> .options => Options,</span>
<span class="line" id="L111"> .custom => <span class="tok-builtin">@compileError</span>(<span class="tok-str">"no type available for custom step"</span>),</span>
<span class="line" id="L112"> };</span>
<span class="line" id="L113"> }</span>
<span class="line" id="L114">};</span>
<span class="line" id="L115"></span>
<span class="line" id="L116"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> CheckFile = <span class="tok-builtin">@import</span>(<span class="tok-str">"Step/CheckFile.zig"</span>);</span>
<span class="line" id="L117"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> CheckObject = <span class="tok-builtin">@import</span>(<span class="tok-str">"Step/CheckObject.zig"</span>);</span>
<span class="line" id="L118"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> ConfigHeader = <span class="tok-builtin">@import</span>(<span class="tok-str">"Step/ConfigHeader.zig"</span>);</span>
<span class="line" id="L119"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> Fmt = <span class="tok-builtin">@import</span>(<span class="tok-str">"Step/Fmt.zig"</span>);</span>
<span class="line" id="L120"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> InstallArtifact = <span class="tok-builtin">@import</span>(<span class="tok-str">"Step/InstallArtifact.zig"</span>);</span>
<span class="line" id="L121"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> InstallDir = <span class="tok-builtin">@import</span>(<span class="tok-str">"Step/InstallDir.zig"</span>);</span>
<span class="line" id="L122"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> InstallFile = <span class="tok-builtin">@import</span>(<span class="tok-str">"Step/InstallFile.zig"</span>);</span>
<span class="line" id="L123"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> ObjCopy = <span class="tok-builtin">@import</span>(<span class="tok-str">"Step/ObjCopy.zig"</span>);</span>
<span class="line" id="L124"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> Compile = <span class="tok-builtin">@import</span>(<span class="tok-str">"Step/Compile.zig"</span>);</span>
<span class="line" id="L125"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> Options = <span class="tok-builtin">@import</span>(<span class="tok-str">"Step/Options.zig"</span>);</span>
<span class="line" id="L126"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> RemoveDir = <span class="tok-builtin">@import</span>(<span class="tok-str">"Step/RemoveDir.zig"</span>);</span>
<span class="line" id="L127"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> Run = <span class="tok-builtin">@import</span>(<span class="tok-str">"Step/Run.zig"</span>);</span>
<span class="line" id="L128"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> TranslateC = <span class="tok-builtin">@import</span>(<span class="tok-str">"Step/TranslateC.zig"</span>);</span>
<span class="line" id="L129"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> WriteFile = <span class="tok-builtin">@import</span>(<span class="tok-str">"Step/WriteFile.zig"</span>);</span>
<span class="line" id="L130"></span>
<span class="line" id="L131"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> StepOptions = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L132"> id: Id,</span>
<span class="line" id="L133"> name: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L134"> owner: *Build,</span>
<span class="line" id="L135"> makeFn: MakeFn = makeNoOp,</span>
<span class="line" id="L136"> first_ret_addr: ?<span class="tok-type">usize</span> = <span class="tok-null">null</span>,</span>
<span class="line" id="L137"> max_rss: <span class="tok-type">usize</span> = <span class="tok-number">0</span>,</span>
<span class="line" id="L138">};</span>
<span class="line" id="L139"></span>
<span class="line" id="L140"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">init</span>(options: StepOptions) Step {</span>
<span class="line" id="L141"> <span class="tok-kw">const</span> arena = options.owner.allocator;</span>
<span class="line" id="L142"></span>
<span class="line" id="L143"> <span class="tok-kw">var</span> addresses = [<span class="tok-number">1</span>]<span class="tok-type">usize</span>{<span class="tok-number">0</span>} ** n_debug_stack_frames;</span>
<span class="line" id="L144"> <span class="tok-kw">const</span> first_ret_addr = options.first_ret_addr <span class="tok-kw">orelse</span> <span class="tok-builtin">@returnAddress</span>();</span>
<span class="line" id="L145"> <span class="tok-kw">var</span> stack_trace = std.builtin.StackTrace{</span>
<span class="line" id="L146"> .instruction_addresses = &addresses,</span>
<span class="line" id="L147"> .index = <span class="tok-number">0</span>,</span>
<span class="line" id="L148"> };</span>
<span class="line" id="L149"> std.debug.captureStackTrace(first_ret_addr, &stack_trace);</span>
<span class="line" id="L150"></span>
<span class="line" id="L151"> <span class="tok-kw">return</span> .{</span>
<span class="line" id="L152"> .id = options.id,</span>
<span class="line" id="L153"> .name = arena.dupe(<span class="tok-type">u8</span>, options.name) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>),</span>
<span class="line" id="L154"> .owner = options.owner,</span>
<span class="line" id="L155"> .makeFn = options.makeFn,</span>
<span class="line" id="L156"> .dependencies = std.ArrayList(*Step).init(arena),</span>
<span class="line" id="L157"> .dependants = .{},</span>
<span class="line" id="L158"> .state = .precheck_unstarted,</span>
<span class="line" id="L159"> .max_rss = options.max_rss,</span>
<span class="line" id="L160"> .debug_stack_trace = addresses,</span>
<span class="line" id="L161"> .result_error_msgs = .{},</span>
<span class="line" id="L162"> .result_error_bundle = std.zig.ErrorBundle.empty,</span>
<span class="line" id="L163"> .result_cached = <span class="tok-null">false</span>,</span>
<span class="line" id="L164"> .result_duration_ns = <span class="tok-null">null</span>,</span>
<span class="line" id="L165"> .result_peak_rss = <span class="tok-number">0</span>,</span>
<span class="line" id="L166"> .test_results = .{},</span>
<span class="line" id="L167"> };</span>
<span class="line" id="L168">}</span>
<span class="line" id="L169"></span>
<span class="line" id="L170"><span class="tok-comment">/// If the Step's `make` function reports `error.MakeFailed`, it indicates they</span></span>
<span class="line" id="L171"><span class="tok-comment">/// have already reported the error. Otherwise, we add a simple error report</span></span>
<span class="line" id="L172"><span class="tok-comment">/// here.</span></span>
<span class="line" id="L173"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">make</span>(s: *Step, prog_node: *std.Progress.Node) <span class="tok-kw">error</span>{ MakeFailed, MakeSkipped }!<span class="tok-type">void</span> {</span>
<span class="line" id="L174"> <span class="tok-kw">const</span> arena = s.owner.allocator;</span>
<span class="line" id="L175"></span>
<span class="line" id="L176"> s.makeFn(s, prog_node) <span class="tok-kw">catch</span> |err| <span class="tok-kw">switch</span> (err) {</span>
<span class="line" id="L177"> <span class="tok-kw">error</span>.MakeFailed => <span class="tok-kw">return</span> <span class="tok-kw">error</span>.MakeFailed,</span>
<span class="line" id="L178"> <span class="tok-kw">error</span>.MakeSkipped => <span class="tok-kw">return</span> <span class="tok-kw">error</span>.MakeSkipped,</span>
<span class="line" id="L179"> <span class="tok-kw">else</span> => {</span>
<span class="line" id="L180"> s.result_error_msgs.append(arena, <span class="tok-builtin">@errorName</span>(err)) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L181"> <span class="tok-kw">return</span> <span class="tok-kw">error</span>.MakeFailed;</span>
<span class="line" id="L182"> },</span>
<span class="line" id="L183"> };</span>
<span class="line" id="L184"></span>
<span class="line" id="L185"> <span class="tok-kw">if</span> (!s.test_results.isSuccess()) {</span>
<span class="line" id="L186"> <span class="tok-kw">return</span> <span class="tok-kw">error</span>.MakeFailed;</span>
<span class="line" id="L187"> }</span>
<span class="line" id="L188"></span>
<span class="line" id="L189"> <span class="tok-kw">if</span> (s.max_rss != <span class="tok-number">0</span> <span class="tok-kw">and</span> s.result_peak_rss > s.max_rss) {</span>
<span class="line" id="L190"> <span class="tok-kw">const</span> msg = std.fmt.allocPrint(arena, <span class="tok-str">"memory usage peaked at {d} bytes, exceeding the declared upper bound of {d}"</span>, .{</span>
<span class="line" id="L191"> s.result_peak_rss, s.max_rss,</span>
<span class="line" id="L192"> }) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L193"> s.result_error_msgs.append(arena, msg) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L194"> <span class="tok-kw">return</span> <span class="tok-kw">error</span>.MakeFailed;</span>
<span class="line" id="L195"> }</span>
<span class="line" id="L196">}</span>
<span class="line" id="L197"></span>
<span class="line" id="L198"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">dependOn</span>(self: *Step, other: *Step) <span class="tok-type">void</span> {</span>
<span class="line" id="L199"> self.dependencies.append(other) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L200">}</span>
<span class="line" id="L201"></span>
<span class="line" id="L202"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">getStackTrace</span>(s: *Step) std.builtin.StackTrace {</span>
<span class="line" id="L203"> <span class="tok-kw">const</span> stack_addresses = &s.debug_stack_trace;</span>
<span class="line" id="L204"> <span class="tok-kw">var</span> len: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L205"> <span class="tok-kw">while</span> (len < n_debug_stack_frames <span class="tok-kw">and</span> stack_addresses[len] != <span class="tok-number">0</span>) {</span>
<span class="line" id="L206"> len += <span class="tok-number">1</span>;</span>
<span class="line" id="L207"> }</span>
<span class="line" id="L208"> <span class="tok-kw">return</span> .{</span>
<span class="line" id="L209"> .instruction_addresses = stack_addresses,</span>
<span class="line" id="L210"> .index = len,</span>
<span class="line" id="L211"> };</span>
<span class="line" id="L212">}</span>
<span class="line" id="L213"></span>
<span class="line" id="L214"><span class="tok-kw">fn</span> <span class="tok-fn">makeNoOp</span>(step: *Step, prog_node: *std.Progress.Node) <span class="tok-type">anyerror</span>!<span class="tok-type">void</span> {</span>
<span class="line" id="L215"> _ = prog_node;</span>
<span class="line" id="L216"></span>
<span class="line" id="L217"> <span class="tok-kw">var</span> all_cached = <span class="tok-null">true</span>;</span>
<span class="line" id="L218"></span>
<span class="line" id="L219"> <span class="tok-kw">for</span> (step.dependencies.items) |dep| {</span>
<span class="line" id="L220"> all_cached = all_cached <span class="tok-kw">and</span> dep.result_cached;</span>
<span class="line" id="L221"> }</span>
<span class="line" id="L222"></span>
<span class="line" id="L223"> step.result_cached = all_cached;</span>
<span class="line" id="L224">}</span>
<span class="line" id="L225"></span>
<span class="line" id="L226"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">cast</span>(step: *Step, <span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>) ?*T {</span>
<span class="line" id="L227"> <span class="tok-kw">if</span> (step.id == T.base_id) {</span>
<span class="line" id="L228"> <span class="tok-kw">return</span> <span class="tok-builtin">@fieldParentPtr</span>(T, <span class="tok-str">"step"</span>, step);</span>
<span class="line" id="L229"> }</span>
<span class="line" id="L230"> <span class="tok-kw">return</span> <span class="tok-null">null</span>;</span>
<span class="line" id="L231">}</span>
<span class="line" id="L232"></span>
<span class="line" id="L233"><span class="tok-comment">/// For debugging purposes, prints identifying information about this Step.</span></span>
<span class="line" id="L234"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">dump</span>(step: *Step) <span class="tok-type">void</span> {</span>
<span class="line" id="L235"> std.debug.getStderrMutex().lock();</span>
<span class="line" id="L236"> <span class="tok-kw">defer</span> std.debug.getStderrMutex().unlock();</span>
<span class="line" id="L237"></span>
<span class="line" id="L238"> <span class="tok-kw">const</span> stderr = std.io.getStdErr();</span>
<span class="line" id="L239"> <span class="tok-kw">const</span> w = stderr.writer();</span>
<span class="line" id="L240"> <span class="tok-kw">const</span> tty_config = std.io.tty.detectConfig(stderr);</span>
<span class="line" id="L241"> <span class="tok-kw">const</span> debug_info = std.debug.getSelfDebugInfo() <span class="tok-kw">catch</span> |err| {</span>
<span class="line" id="L242"> w.print(<span class="tok-str">"Unable to dump stack trace: Unable to open debug info: {s}\n"</span>, .{</span>
<span class="line" id="L243"> <span class="tok-builtin">@errorName</span>(err),</span>
<span class="line" id="L244"> }) <span class="tok-kw">catch</span> {};</span>
<span class="line" id="L245"> <span class="tok-kw">return</span>;</span>
<span class="line" id="L246"> };</span>
<span class="line" id="L247"> <span class="tok-kw">const</span> ally = debug_info.allocator;</span>
<span class="line" id="L248"> w.print(<span class="tok-str">"name: '{s}'. creation stack trace:\n"</span>, .{step.name}) <span class="tok-kw">catch</span> {};</span>
<span class="line" id="L249"> std.debug.writeStackTrace(step.getStackTrace(), w, ally, debug_info, tty_config) <span class="tok-kw">catch</span> |err| {</span>
<span class="line" id="L250"> stderr.writer().print(<span class="tok-str">"Unable to dump stack trace: {s}\n"</span>, .{<span class="tok-builtin">@errorName</span>(err)}) <span class="tok-kw">catch</span> {};</span>
<span class="line" id="L251"> <span class="tok-kw">return</span>;</span>
<span class="line" id="L252"> };</span>
<span class="line" id="L253">}</span>
<span class="line" id="L254"></span>
<span class="line" id="L255"><span class="tok-kw">const</span> Step = <span class="tok-builtin">@This</span>();</span>
<span class="line" id="L256"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../std.zig"</span>);</span>
<span class="line" id="L257"><span class="tok-kw">const</span> Build = std.Build;</span>
<span class="line" id="L258"><span class="tok-kw">const</span> Allocator = std.mem.Allocator;</span>
<span class="line" id="L259"><span class="tok-kw">const</span> assert = std.debug.assert;</span>
<span class="line" id="L260"><span class="tok-kw">const</span> builtin = <span class="tok-builtin">@import</span>(<span class="tok-str">"builtin"</span>);</span>
<span class="line" id="L261"></span>
<span class="line" id="L262"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">evalChildProcess</span>(s: *Step, argv: []<span class="tok-kw">const</span> []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) !<span class="tok-type">void</span> {</span>
<span class="line" id="L263"> <span class="tok-kw">const</span> arena = s.owner.allocator;</span>
<span class="line" id="L264"></span>
<span class="line" id="L265"> <span class="tok-kw">try</span> handleChildProcUnsupported(s, <span class="tok-null">null</span>, argv);</span>
<span class="line" id="L266"> <span class="tok-kw">try</span> handleVerbose(s.owner, <span class="tok-null">null</span>, argv);</span>
<span class="line" id="L267"></span>
<span class="line" id="L268"> <span class="tok-kw">const</span> result = std.ChildProcess.exec(.{</span>
<span class="line" id="L269"> .allocator = arena,</span>
<span class="line" id="L270"> .argv = argv,</span>
<span class="line" id="L271"> }) <span class="tok-kw">catch</span> |err| <span class="tok-kw">return</span> s.fail(<span class="tok-str">"unable to spawn {s}: {s}"</span>, .{ argv[<span class="tok-number">0</span>], <span class="tok-builtin">@errorName</span>(err) });</span>
<span class="line" id="L272"></span>
<span class="line" id="L273"> <span class="tok-kw">if</span> (result.stderr.len > <span class="tok-number">0</span>) {</span>
<span class="line" id="L274"> <span class="tok-kw">try</span> s.result_error_msgs.append(arena, result.stderr);</span>
<span class="line" id="L275"> }</span>
<span class="line" id="L276"></span>
<span class="line" id="L277"> <span class="tok-kw">try</span> handleChildProcessTerm(s, result.term, <span class="tok-null">null</span>, argv);</span>
<span class="line" id="L278">}</span>
<span class="line" id="L279"></span>
<span class="line" id="L280"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">fail</span>(step: *Step, <span class="tok-kw">comptime</span> fmt: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>, args: <span class="tok-kw">anytype</span>) <span class="tok-kw">error</span>{ OutOfMemory, MakeFailed } {</span>
<span class="line" id="L281"> <span class="tok-kw">try</span> step.addError(fmt, args);</span>
<span class="line" id="L282"> <span class="tok-kw">return</span> <span class="tok-kw">error</span>.MakeFailed;</span>
<span class="line" id="L283">}</span>
<span class="line" id="L284"></span>
<span class="line" id="L285"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addError</span>(step: *Step, <span class="tok-kw">comptime</span> fmt: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>, args: <span class="tok-kw">anytype</span>) <span class="tok-kw">error</span>{OutOfMemory}!<span class="tok-type">void</span> {</span>
<span class="line" id="L286"> <span class="tok-kw">const</span> arena = step.owner.allocator;</span>
<span class="line" id="L287"> <span class="tok-kw">const</span> msg = <span class="tok-kw">try</span> std.fmt.allocPrint(arena, fmt, args);</span>
<span class="line" id="L288"> <span class="tok-kw">try</span> step.result_error_msgs.append(arena, msg);</span>
<span class="line" id="L289">}</span>
<span class="line" id="L290"></span>
<span class="line" id="L291"><span class="tok-comment">/// Assumes that argv contains `--listen=-` and that the process being spawned</span></span>
<span class="line" id="L292"><span class="tok-comment">/// is the zig compiler - the same version that compiled the build runner.</span></span>
<span class="line" id="L293"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">evalZigProcess</span>(</span>
<span class="line" id="L294"> s: *Step,</span>
<span class="line" id="L295"> argv: []<span class="tok-kw">const</span> []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L296"> prog_node: *std.Progress.Node,</span>
<span class="line" id="L297">) ![]<span class="tok-kw">const</span> <span class="tok-type">u8</span> {</span>
<span class="line" id="L298"> assert(argv.len != <span class="tok-number">0</span>);</span>
<span class="line" id="L299"> <span class="tok-kw">const</span> b = s.owner;</span>
<span class="line" id="L300"> <span class="tok-kw">const</span> arena = b.allocator;</span>
<span class="line" id="L301"> <span class="tok-kw">const</span> gpa = arena;</span>
<span class="line" id="L302"></span>
<span class="line" id="L303"> <span class="tok-kw">try</span> handleChildProcUnsupported(s, <span class="tok-null">null</span>, argv);</span>
<span class="line" id="L304"> <span class="tok-kw">try</span> handleVerbose(s.owner, <span class="tok-null">null</span>, argv);</span>
<span class="line" id="L305"></span>
<span class="line" id="L306"> <span class="tok-kw">var</span> child = std.ChildProcess.init(argv, arena);</span>
<span class="line" id="L307"> child.env_map = b.env_map;</span>
<span class="line" id="L308"> child.stdin_behavior = .Pipe;</span>
<span class="line" id="L309"> child.stdout_behavior = .Pipe;</span>
<span class="line" id="L310"> child.stderr_behavior = .Pipe;</span>
<span class="line" id="L311"> child.request_resource_usage_statistics = <span class="tok-null">true</span>;</span>
<span class="line" id="L312"></span>
<span class="line" id="L313"> child.spawn() <span class="tok-kw">catch</span> |err| <span class="tok-kw">return</span> s.fail(<span class="tok-str">"unable to spawn {s}: {s}"</span>, .{</span>
<span class="line" id="L314"> argv[<span class="tok-number">0</span>], <span class="tok-builtin">@errorName</span>(err),</span>
<span class="line" id="L315"> });</span>
<span class="line" id="L316"> <span class="tok-kw">var</span> timer = <span class="tok-kw">try</span> std.time.Timer.start();</span>
<span class="line" id="L317"></span>
<span class="line" id="L318"> <span class="tok-kw">var</span> poller = std.io.poll(gpa, <span class="tok-kw">enum</span> { stdout, stderr }, .{</span>
<span class="line" id="L319"> .stdout = child.stdout.?,</span>
<span class="line" id="L320"> .stderr = child.stderr.?,</span>
<span class="line" id="L321"> });</span>
<span class="line" id="L322"> <span class="tok-kw">defer</span> poller.deinit();</span>
<span class="line" id="L323"></span>
<span class="line" id="L324"> <span class="tok-kw">try</span> sendMessage(child.stdin.?, .update);</span>
<span class="line" id="L325"> <span class="tok-kw">try</span> sendMessage(child.stdin.?, .exit);</span>
<span class="line" id="L326"></span>
<span class="line" id="L327"> <span class="tok-kw">const</span> Header = std.zig.Server.Message.Header;</span>
<span class="line" id="L328"> <span class="tok-kw">var</span> result: ?[]<span class="tok-kw">const</span> <span class="tok-type">u8</span> = <span class="tok-null">null</span>;</span>
<span class="line" id="L329"></span>
<span class="line" id="L330"> <span class="tok-kw">var</span> node_name: std.ArrayListUnmanaged(<span class="tok-type">u8</span>) = .{};</span>
<span class="line" id="L331"> <span class="tok-kw">defer</span> node_name.deinit(gpa);</span>
<span class="line" id="L332"> <span class="tok-kw">var</span> sub_prog_node = prog_node.start(<span class="tok-str">""</span>, <span class="tok-number">0</span>);</span>
<span class="line" id="L333"> <span class="tok-kw">defer</span> sub_prog_node.end();</span>
<span class="line" id="L334"></span>
<span class="line" id="L335"> <span class="tok-kw">const</span> stdout = poller.fifo(.stdout);</span>
<span class="line" id="L336"></span>
<span class="line" id="L337"> poll: <span class="tok-kw">while</span> (<span class="tok-null">true</span>) {</span>
<span class="line" id="L338"> <span class="tok-kw">while</span> (stdout.readableLength() < <span class="tok-builtin">@sizeOf</span>(Header)) {</span>
<span class="line" id="L339"> <span class="tok-kw">if</span> (!(<span class="tok-kw">try</span> poller.poll())) <span class="tok-kw">break</span> :poll;</span>
<span class="line" id="L340"> }</span>
<span class="line" id="L341"> <span class="tok-kw">const</span> header = stdout.reader().readStruct(Header) <span class="tok-kw">catch</span> <span class="tok-kw">unreachable</span>;</span>
<span class="line" id="L342"> <span class="tok-kw">while</span> (stdout.readableLength() < header.bytes_len) {</span>
<span class="line" id="L343"> <span class="tok-kw">if</span> (!(<span class="tok-kw">try</span> poller.poll())) <span class="tok-kw">break</span> :poll;</span>
<span class="line" id="L344"> }</span>
<span class="line" id="L345"> <span class="tok-kw">const</span> body = stdout.readableSliceOfLen(header.bytes_len);</span>
<span class="line" id="L346"></span>
<span class="line" id="L347"> <span class="tok-kw">switch</span> (header.tag) {</span>
<span class="line" id="L348"> .zig_version => {</span>
<span class="line" id="L349"> <span class="tok-kw">if</span> (!std.mem.eql(<span class="tok-type">u8</span>, builtin.zig_version_string, body)) {</span>
<span class="line" id="L350"> <span class="tok-kw">return</span> s.fail(</span>
<span class="line" id="L351"> <span class="tok-str">"zig version mismatch build runner vs compiler: '{s}' vs '{s}'"</span>,</span>
<span class="line" id="L352"> .{ builtin.zig_version_string, body },</span>
<span class="line" id="L353"> );</span>
<span class="line" id="L354"> }</span>
<span class="line" id="L355"> },</span>
<span class="line" id="L356"> .error_bundle => {</span>
<span class="line" id="L357"> <span class="tok-kw">const</span> EbHdr = std.zig.Server.Message.ErrorBundle;</span>
<span class="line" id="L358"> <span class="tok-kw">const</span> eb_hdr = <span class="tok-builtin">@as</span>(*<span class="tok-kw">align</span>(<span class="tok-number">1</span>) <span class="tok-kw">const</span> EbHdr, <span class="tok-builtin">@ptrCast</span>(body));</span>
<span class="line" id="L359"> <span class="tok-kw">const</span> extra_bytes =</span>
<span class="line" id="L360"> body[<span class="tok-builtin">@sizeOf</span>(EbHdr)..][<span class="tok-number">0</span> .. <span class="tok-builtin">@sizeOf</span>(<span class="tok-type">u32</span>) * eb_hdr.extra_len];</span>
<span class="line" id="L361"> <span class="tok-kw">const</span> string_bytes =</span>
<span class="line" id="L362"> body[<span class="tok-builtin">@sizeOf</span>(EbHdr) + extra_bytes.len ..][<span class="tok-number">0</span>..eb_hdr.string_bytes_len];</span>
<span class="line" id="L363"> <span class="tok-comment">// TODO: use @ptrCast when the compiler supports it</span>
</span>
<span class="line" id="L364"> <span class="tok-kw">const</span> unaligned_extra = std.mem.bytesAsSlice(<span class="tok-type">u32</span>, extra_bytes);</span>
<span class="line" id="L365"> <span class="tok-kw">const</span> extra_array = <span class="tok-kw">try</span> arena.alloc(<span class="tok-type">u32</span>, unaligned_extra.len);</span>
<span class="line" id="L366"> <span class="tok-comment">// TODO: use @memcpy when it supports slices</span>
</span>
<span class="line" id="L367"> <span class="tok-kw">for</span> (extra_array, unaligned_extra) |*dst, src| dst.* = src;</span>
<span class="line" id="L368"> s.result_error_bundle = .{</span>
<span class="line" id="L369"> .string_bytes = <span class="tok-kw">try</span> arena.dupe(<span class="tok-type">u8</span>, string_bytes),</span>
<span class="line" id="L370"> .extra = extra_array,</span>
<span class="line" id="L371"> };</span>
<span class="line" id="L372"> },</span>
<span class="line" id="L373"> .progress => {</span>
<span class="line" id="L374"> node_name.clearRetainingCapacity();</span>
<span class="line" id="L375"> <span class="tok-kw">try</span> node_name.appendSlice(gpa, body);</span>
<span class="line" id="L376"> sub_prog_node.setName(node_name.items);</span>
<span class="line" id="L377"> },</span>
<span class="line" id="L378"> .emit_bin_path => {</span>
<span class="line" id="L379"> <span class="tok-kw">const</span> EbpHdr = std.zig.Server.Message.EmitBinPath;</span>
<span class="line" id="L380"> <span class="tok-kw">const</span> ebp_hdr = <span class="tok-builtin">@as</span>(*<span class="tok-kw">align</span>(<span class="tok-number">1</span>) <span class="tok-kw">const</span> EbpHdr, <span class="tok-builtin">@ptrCast</span>(body));</span>
<span class="line" id="L381"> s.result_cached = ebp_hdr.flags.cache_hit;</span>
<span class="line" id="L382"> result = <span class="tok-kw">try</span> arena.dupe(<span class="tok-type">u8</span>, body[<span class="tok-builtin">@sizeOf</span>(EbpHdr)..]);</span>
<span class="line" id="L383"> },</span>
<span class="line" id="L384"> <span class="tok-kw">else</span> => {}, <span class="tok-comment">// ignore other messages</span>
</span>
<span class="line" id="L385"> }</span>
<span class="line" id="L386"></span>
<span class="line" id="L387"> stdout.discard(body.len);</span>
<span class="line" id="L388"> }</span>
<span class="line" id="L389"></span>
<span class="line" id="L390"> <span class="tok-kw">const</span> stderr = poller.fifo(.stderr);</span>
<span class="line" id="L391"> <span class="tok-kw">if</span> (stderr.readableLength() > <span class="tok-number">0</span>) {</span>
<span class="line" id="L392"> <span class="tok-kw">try</span> s.result_error_msgs.append(arena, <span class="tok-kw">try</span> stderr.toOwnedSlice());</span>
<span class="line" id="L393"> }</span>
<span class="line" id="L394"></span>
<span class="line" id="L395"> <span class="tok-comment">// Send EOF to stdin.</span>
</span>
<span class="line" id="L396"> child.stdin.?.close();</span>
<span class="line" id="L397"> child.stdin = <span class="tok-null">null</span>;</span>
<span class="line" id="L398"></span>
<span class="line" id="L399"> <span class="tok-kw">const</span> term = child.wait() <span class="tok-kw">catch</span> |err| {</span>
<span class="line" id="L400"> <span class="tok-kw">return</span> s.fail(<span class="tok-str">"unable to wait for {s}: {s}"</span>, .{ argv[<span class="tok-number">0</span>], <span class="tok-builtin">@errorName</span>(err) });</span>
<span class="line" id="L401"> };</span>
<span class="line" id="L402"> s.result_duration_ns = timer.read();</span>
<span class="line" id="L403"> s.result_peak_rss = child.resource_usage_statistics.getMaxRss() <span class="tok-kw">orelse</span> <span class="tok-number">0</span>;</span>
<span class="line" id="L404"></span>
<span class="line" id="L405"> <span class="tok-comment">// Special handling for Compile step that is expecting compile errors.</span>
</span>
<span class="line" id="L406"> <span class="tok-kw">if</span> (s.cast(Compile)) |compile| <span class="tok-kw">switch</span> (term) {</span>
<span class="line" id="L407"> .Exited => {</span>
<span class="line" id="L408"> <span class="tok-comment">// Note that the exit code may be 0 in this case due to the</span>
</span>
<span class="line" id="L409"> <span class="tok-comment">// compiler server protocol.</span>
</span>
<span class="line" id="L410"> <span class="tok-kw">if</span> (compile.expect_errors.len != <span class="tok-number">0</span> <span class="tok-kw">and</span> s.result_error_bundle.errorMessageCount() > <span class="tok-number">0</span>) {</span>
<span class="line" id="L411"> <span class="tok-kw">return</span> <span class="tok-kw">error</span>.NeedCompileErrorCheck;</span>
<span class="line" id="L412"> }</span>
<span class="line" id="L413"> },</span>
<span class="line" id="L414"> <span class="tok-kw">else</span> => {},</span>
<span class="line" id="L415"> };</span>
<span class="line" id="L416"></span>
<span class="line" id="L417"> <span class="tok-kw">try</span> handleChildProcessTerm(s, term, <span class="tok-null">null</span>, argv);</span>
<span class="line" id="L418"></span>
<span class="line" id="L419"> <span class="tok-kw">if</span> (s.result_error_bundle.errorMessageCount() > <span class="tok-number">0</span>) {</span>
<span class="line" id="L420"> <span class="tok-kw">return</span> s.fail(<span class="tok-str">"the following command failed with {d} compilation errors:\n{s}"</span>, .{</span>
<span class="line" id="L421"> s.result_error_bundle.errorMessageCount(),</span>
<span class="line" id="L422"> <span class="tok-kw">try</span> allocPrintCmd(arena, <span class="tok-null">null</span>, argv),</span>
<span class="line" id="L423"> });</span>
<span class="line" id="L424"> }</span>
<span class="line" id="L425"></span>
<span class="line" id="L426"> <span class="tok-kw">return</span> result <span class="tok-kw">orelse</span> <span class="tok-kw">return</span> s.fail(</span>
<span class="line" id="L427"> <span class="tok-str">"the following command failed to communicate the compilation result:\n{s}"</span>,</span>
<span class="line" id="L428"> .{<span class="tok-kw">try</span> allocPrintCmd(arena, <span class="tok-null">null</span>, argv)},</span>
<span class="line" id="L429"> );</span>
<span class="line" id="L430">}</span>
<span class="line" id="L431"></span>
<span class="line" id="L432"><span class="tok-kw">fn</span> <span class="tok-fn">sendMessage</span>(file: std.fs.File, tag: std.zig.Client.Message.Tag) !<span class="tok-type">void</span> {</span>
<span class="line" id="L433"> <span class="tok-kw">const</span> header: std.zig.Client.Message.Header = .{</span>
<span class="line" id="L434"> .tag = tag,</span>
<span class="line" id="L435"> .bytes_len = <span class="tok-number">0</span>,</span>
<span class="line" id="L436"> };</span>
<span class="line" id="L437"> <span class="tok-kw">try</span> file.writeAll(std.mem.asBytes(&header));</span>
<span class="line" id="L438">}</span>
<span class="line" id="L439"></span>
<span class="line" id="L440"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">handleVerbose</span>(</span>
<span class="line" id="L441"> b: *Build,</span>
<span class="line" id="L442"> opt_cwd: ?[]<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L443"> argv: []<span class="tok-kw">const</span> []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L444">) <span class="tok-kw">error</span>{OutOfMemory}!<span class="tok-type">void</span> {</span>
<span class="line" id="L445"> <span class="tok-kw">return</span> handleVerbose2(b, opt_cwd, <span class="tok-null">null</span>, argv);</span>
<span class="line" id="L446">}</span>
<span class="line" id="L447"></span>
<span class="line" id="L448"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">handleVerbose2</span>(</span>
<span class="line" id="L449"> b: *Build,</span>
<span class="line" id="L450"> opt_cwd: ?[]<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L451"> opt_env: ?*<span class="tok-kw">const</span> std.process.EnvMap,</span>
<span class="line" id="L452"> argv: []<span class="tok-kw">const</span> []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L453">) <span class="tok-kw">error</span>{OutOfMemory}!<span class="tok-type">void</span> {</span>
<span class="line" id="L454"> <span class="tok-kw">if</span> (b.verbose) {</span>
<span class="line" id="L455"> <span class="tok-comment">// Intention of verbose is to print all sub-process command lines to</span>
</span>
<span class="line" id="L456"> <span class="tok-comment">// stderr before spawning them.</span>
</span>
<span class="line" id="L457"> <span class="tok-kw">const</span> text = <span class="tok-kw">try</span> allocPrintCmd2(b.allocator, opt_cwd, opt_env, argv);</span>
<span class="line" id="L458"> std.debug.print(<span class="tok-str">"{s}\n"</span>, .{text});</span>
<span class="line" id="L459"> }</span>
<span class="line" id="L460">}</span>
<span class="line" id="L461"></span>
<span class="line" id="L462"><span class="tok-kw">pub</span> <span class="tok-kw">inline</span> <span class="tok-kw">fn</span> <span class="tok-fn">handleChildProcUnsupported</span>(</span>
<span class="line" id="L463"> s: *Step,</span>
<span class="line" id="L464"> opt_cwd: ?[]<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L465"> argv: []<span class="tok-kw">const</span> []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L466">) <span class="tok-kw">error</span>{ OutOfMemory, MakeFailed }!<span class="tok-type">void</span> {</span>
<span class="line" id="L467"> <span class="tok-kw">if</span> (!std.process.can_spawn) {</span>
<span class="line" id="L468"> <span class="tok-kw">return</span> s.fail(</span>
<span class="line" id="L469"> <span class="tok-str">"unable to execute the following command: host cannot spawn child processes\n{s}"</span>,</span>
<span class="line" id="L470"> .{<span class="tok-kw">try</span> allocPrintCmd(s.owner.allocator, opt_cwd, argv)},</span>
<span class="line" id="L471"> );</span>
<span class="line" id="L472"> }</span>
<span class="line" id="L473">}</span>
<span class="line" id="L474"></span>
<span class="line" id="L475"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">handleChildProcessTerm</span>(</span>
<span class="line" id="L476"> s: *Step,</span>
<span class="line" id="L477"> term: std.ChildProcess.Term,</span>
<span class="line" id="L478"> opt_cwd: ?[]<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L479"> argv: []<span class="tok-kw">const</span> []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L480">) <span class="tok-kw">error</span>{ MakeFailed, OutOfMemory }!<span class="tok-type">void</span> {</span>
<span class="line" id="L481"> <span class="tok-kw">const</span> arena = s.owner.allocator;</span>
<span class="line" id="L482"> <span class="tok-kw">switch</span> (term) {</span>
<span class="line" id="L483"> .Exited => |code| {</span>
<span class="line" id="L484"> <span class="tok-kw">if</span> (code != <span class="tok-number">0</span>) {</span>
<span class="line" id="L485"> <span class="tok-kw">return</span> s.fail(</span>
<span class="line" id="L486"> <span class="tok-str">"the following command exited with error code {d}:\n{s}"</span>,</span>
<span class="line" id="L487"> .{ code, <span class="tok-kw">try</span> allocPrintCmd(arena, opt_cwd, argv) },</span>
<span class="line" id="L488"> );</span>
<span class="line" id="L489"> }</span>
<span class="line" id="L490"> },</span>
<span class="line" id="L491"> .Signal, .Stopped, .Unknown => {</span>
<span class="line" id="L492"> <span class="tok-kw">return</span> s.fail(</span>
<span class="line" id="L493"> <span class="tok-str">"the following command terminated unexpectedly:\n{s}"</span>,</span>
<span class="line" id="L494"> .{<span class="tok-kw">try</span> allocPrintCmd(arena, opt_cwd, argv)},</span>
<span class="line" id="L495"> );</span>
<span class="line" id="L496"> },</span>
<span class="line" id="L497"> }</span>
<span class="line" id="L498">}</span>
<span class="line" id="L499"></span>
<span class="line" id="L500"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">allocPrintCmd</span>(</span>
<span class="line" id="L501"> arena: Allocator,</span>
<span class="line" id="L502"> opt_cwd: ?[]<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L503"> argv: []<span class="tok-kw">const</span> []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L504">) Allocator.Error![]<span class="tok-type">u8</span> {</span>
<span class="line" id="L505"> <span class="tok-kw">return</span> allocPrintCmd2(arena, opt_cwd, <span class="tok-null">null</span>, argv);</span>
<span class="line" id="L506">}</span>
<span class="line" id="L507"></span>
<span class="line" id="L508"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">allocPrintCmd2</span>(</span>
<span class="line" id="L509"> arena: Allocator,</span>
<span class="line" id="L510"> opt_cwd: ?[]<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L511"> opt_env: ?*<span class="tok-kw">const</span> std.process.EnvMap,</span>
<span class="line" id="L512"> argv: []<span class="tok-kw">const</span> []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L513">) Allocator.Error![]<span class="tok-type">u8</span> {</span>
<span class="line" id="L514"> <span class="tok-kw">var</span> buf: std.ArrayListUnmanaged(<span class="tok-type">u8</span>) = .{};</span>
<span class="line" id="L515"> <span class="tok-kw">if</span> (opt_cwd) |cwd| <span class="tok-kw">try</span> buf.writer(arena).print(<span class="tok-str">"cd {s} && "</span>, .{cwd});</span>
<span class="line" id="L516"> <span class="tok-kw">if</span> (opt_env) |env| {</span>
<span class="line" id="L517"> <span class="tok-kw">const</span> process_env_map = std.process.getEnvMap(arena) <span class="tok-kw">catch</span> std.process.EnvMap.init(arena);</span>
<span class="line" id="L518"> <span class="tok-kw">var</span> it = env.iterator();</span>
<span class="line" id="L519"> <span class="tok-kw">while</span> (it.next()) |entry| {</span>
<span class="line" id="L520"> <span class="tok-kw">const</span> key = entry.key_ptr.*;</span>
<span class="line" id="L521"> <span class="tok-kw">const</span> value = entry.value_ptr.*;</span>
<span class="line" id="L522"> <span class="tok-kw">if</span> (process_env_map.get(key)) |process_value| {</span>
<span class="line" id="L523"> <span class="tok-kw">if</span> (std.mem.eql(<span class="tok-type">u8</span>, value, process_value)) <span class="tok-kw">continue</span>;</span>
<span class="line" id="L524"> }</span>
<span class="line" id="L525"> <span class="tok-kw">try</span> buf.writer(arena).print(<span class="tok-str">"{s}={s} "</span>, .{ key, value });</span>
<span class="line" id="L526"> }</span>
<span class="line" id="L527"> }</span>
<span class="line" id="L528"> <span class="tok-kw">for</span> (argv) |arg| {</span>
<span class="line" id="L529"> <span class="tok-kw">try</span> buf.writer(arena).print(<span class="tok-str">"{s} "</span>, .{arg});</span>
<span class="line" id="L530"> }</span>
<span class="line" id="L531"> <span class="tok-kw">return</span> buf.toOwnedSlice(arena);</span>
<span class="line" id="L532">}</span>
<span class="line" id="L533"></span>
<span class="line" id="L534"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">cacheHit</span>(s: *Step, man: *std.Build.Cache.Manifest) !<span class="tok-type">bool</span> {</span>
<span class="line" id="L535"> s.result_cached = man.hit() <span class="tok-kw">catch</span> |err| <span class="tok-kw">return</span> failWithCacheError(s, man, err);</span>
<span class="line" id="L536"> <span class="tok-kw">return</span> s.result_cached;</span>
<span class="line" id="L537">}</span>
<span class="line" id="L538"></span>
<span class="line" id="L539"><span class="tok-kw">fn</span> <span class="tok-fn">failWithCacheError</span>(s: *Step, man: *<span class="tok-kw">const</span> std.Build.Cache.Manifest, err: <span class="tok-type">anyerror</span>) <span class="tok-type">anyerror</span> {</span>
<span class="line" id="L540"> <span class="tok-kw">const</span> i = man.failed_file_index <span class="tok-kw">orelse</span> <span class="tok-kw">return</span> err;</span>
<span class="line" id="L541"> <span class="tok-kw">const</span> pp = man.files.items[i].prefixed_path <span class="tok-kw">orelse</span> <span class="tok-kw">return</span> err;</span>
<span class="line" id="L542"> <span class="tok-kw">const</span> prefix = man.cache.prefixes()[pp.prefix].path <span class="tok-kw">orelse</span> <span class="tok-str">""</span>;</span>
<span class="line" id="L543"> <span class="tok-kw">return</span> s.fail(<span class="tok-str">"{s}: {s}/{s}"</span>, .{ <span class="tok-builtin">@errorName</span>(err), prefix, pp.sub_path });</span>
<span class="line" id="L544">}</span>
<span class="line" id="L545"></span>
<span class="line" id="L546"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">writeManifest</span>(s: *Step, man: *std.Build.Cache.Manifest) !<span class="tok-type">void</span> {</span>
<span class="line" id="L547"> <span class="tok-kw">if</span> (s.test_results.isSuccess()) {</span>
<span class="line" id="L548"> man.writeManifest() <span class="tok-kw">catch</span> |err| {</span>
<span class="line" id="L549"> <span class="tok-kw">try</span> s.addError(<span class="tok-str">"unable to write cache manifest: {s}"</span>, .{<span class="tok-builtin">@errorName</span>(err)});</span>
<span class="line" id="L550"> };</span>
<span class="line" id="L551"> }</span>
<span class="line" id="L552">}</span>
<span class="line" id="L553"></span>
<span class="line" id="L554"><span class="tok-kw">test</span> {</span>
<span class="line" id="L555"> _ = CheckFile;</span>
<span class="line" id="L556"> _ = CheckObject;</span>
<span class="line" id="L557"> _ = Fmt;</span>
<span class="line" id="L558"> _ = InstallArtifact;</span>
<span class="line" id="L559"> _ = InstallDir;</span>
<span class="line" id="L560"> _ = InstallFile;</span>
<span class="line" id="L561"> _ = ObjCopy;</span>
<span class="line" id="L562"> _ = Compile;</span>
<span class="line" id="L563"> _ = Options;</span>
<span class="line" id="L564"> _ = RemoveDir;</span>
<span class="line" id="L565"> _ = Run;</span>
<span class="line" id="L566"> _ = TranslateC;</span>
<span class="line" id="L567"> _ = WriteFile;</span>
<span class="line" id="L568">}</span>
<span class="line" id="L569"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std/Build | repos/yazap/docs/src/std/Build/Step/ObjCopy.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>Build/Step/ObjCopy.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"std"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> ObjCopy = <span class="tok-builtin">@This</span>();</span>
<span class="line" id="L3"></span>
<span class="line" id="L4"><span class="tok-kw">const</span> Allocator = std.mem.Allocator;</span>
<span class="line" id="L5"><span class="tok-kw">const</span> ArenaAllocator = std.heap.ArenaAllocator;</span>
<span class="line" id="L6"><span class="tok-kw">const</span> ArrayListUnmanaged = std.ArrayListUnmanaged;</span>
<span class="line" id="L7"><span class="tok-kw">const</span> File = std.fs.File;</span>
<span class="line" id="L8"><span class="tok-kw">const</span> InstallDir = std.Build.InstallDir;</span>
<span class="line" id="L9"><span class="tok-kw">const</span> Step = std.Build.Step;</span>
<span class="line" id="L10"><span class="tok-kw">const</span> elf = std.elf;</span>
<span class="line" id="L11"><span class="tok-kw">const</span> fs = std.fs;</span>
<span class="line" id="L12"><span class="tok-kw">const</span> io = std.io;</span>
<span class="line" id="L13"><span class="tok-kw">const</span> sort = std.sort;</span>
<span class="line" id="L14"></span>
<span class="line" id="L15"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> base_id: Step.Id = .objcopy;</span>
<span class="line" id="L16"></span>
<span class="line" id="L17"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> RawFormat = <span class="tok-kw">enum</span> {</span>
<span class="line" id="L18"> bin,</span>
<span class="line" id="L19"> hex,</span>
<span class="line" id="L20">};</span>
<span class="line" id="L21"></span>
<span class="line" id="L22">step: Step,</span>
<span class="line" id="L23">file_source: std.Build.FileSource,</span>
<span class="line" id="L24">basename: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L25">output_file: std.Build.GeneratedFile,</span>
<span class="line" id="L26"></span>
<span class="line" id="L27">format: ?RawFormat,</span>
<span class="line" id="L28">only_section: ?[]<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L29">pad_to: ?<span class="tok-type">u64</span>,</span>
<span class="line" id="L30"></span>
<span class="line" id="L31"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> Options = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L32"> basename: ?[]<span class="tok-kw">const</span> <span class="tok-type">u8</span> = <span class="tok-null">null</span>,</span>
<span class="line" id="L33"> format: ?RawFormat = <span class="tok-null">null</span>,</span>
<span class="line" id="L34"> only_section: ?[]<span class="tok-kw">const</span> <span class="tok-type">u8</span> = <span class="tok-null">null</span>,</span>
<span class="line" id="L35"> pad_to: ?<span class="tok-type">u64</span> = <span class="tok-null">null</span>,</span>
<span class="line" id="L36">};</span>
<span class="line" id="L37"></span>
<span class="line" id="L38"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">create</span>(</span>
<span class="line" id="L39"> owner: *std.Build,</span>
<span class="line" id="L40"> file_source: std.Build.FileSource,</span>
<span class="line" id="L41"> options: Options,</span>
<span class="line" id="L42">) *ObjCopy {</span>
<span class="line" id="L43"> <span class="tok-kw">const</span> self = owner.allocator.create(ObjCopy) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L44"> self.* = ObjCopy{</span>
<span class="line" id="L45"> .step = Step.init(.{</span>
<span class="line" id="L46"> .id = base_id,</span>
<span class="line" id="L47"> .name = owner.fmt(<span class="tok-str">"objcopy {s}"</span>, .{file_source.getDisplayName()}),</span>
<span class="line" id="L48"> .owner = owner,</span>
<span class="line" id="L49"> .makeFn = make,</span>
<span class="line" id="L50"> }),</span>
<span class="line" id="L51"> .file_source = file_source,</span>
<span class="line" id="L52"> .basename = options.basename <span class="tok-kw">orelse</span> file_source.getDisplayName(),</span>
<span class="line" id="L53"> .output_file = std.Build.GeneratedFile{ .step = &self.step },</span>
<span class="line" id="L54"></span>
<span class="line" id="L55"> .format = options.format,</span>
<span class="line" id="L56"> .only_section = options.only_section,</span>
<span class="line" id="L57"> .pad_to = options.pad_to,</span>
<span class="line" id="L58"> };</span>
<span class="line" id="L59"> file_source.addStepDependencies(&self.step);</span>
<span class="line" id="L60"> <span class="tok-kw">return</span> self;</span>
<span class="line" id="L61">}</span>
<span class="line" id="L62"></span>
<span class="line" id="L63"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">getOutputSource</span>(self: *<span class="tok-kw">const</span> ObjCopy) std.Build.FileSource {</span>
<span class="line" id="L64"> <span class="tok-kw">return</span> .{ .generated = &self.output_file };</span>
<span class="line" id="L65">}</span>
<span class="line" id="L66"></span>
<span class="line" id="L67"><span class="tok-kw">fn</span> <span class="tok-fn">make</span>(step: *Step, prog_node: *std.Progress.Node) !<span class="tok-type">void</span> {</span>
<span class="line" id="L68"> <span class="tok-kw">const</span> b = step.owner;</span>
<span class="line" id="L69"> <span class="tok-kw">const</span> self = <span class="tok-builtin">@fieldParentPtr</span>(ObjCopy, <span class="tok-str">"step"</span>, step);</span>
<span class="line" id="L70"></span>
<span class="line" id="L71"> <span class="tok-kw">var</span> man = b.cache.obtain();</span>
<span class="line" id="L72"> <span class="tok-kw">defer</span> man.deinit();</span>
<span class="line" id="L73"></span>
<span class="line" id="L74"> <span class="tok-comment">// Random bytes to make ObjCopy unique. Refresh this with new random</span>
</span>
<span class="line" id="L75"> <span class="tok-comment">// bytes when ObjCopy implementation is modified incompatibly.</span>
</span>
<span class="line" id="L76"> man.hash.add(<span class="tok-builtin">@as</span>(<span class="tok-type">u32</span>, <span class="tok-number">0xe18b7baf</span>));</span>
<span class="line" id="L77"></span>
<span class="line" id="L78"> <span class="tok-kw">const</span> full_src_path = self.file_source.getPath(b);</span>
<span class="line" id="L79"> _ = <span class="tok-kw">try</span> man.addFile(full_src_path, <span class="tok-null">null</span>);</span>
<span class="line" id="L80"> man.hash.addOptionalBytes(self.only_section);</span>
<span class="line" id="L81"> man.hash.addOptional(self.pad_to);</span>
<span class="line" id="L82"> man.hash.addOptional(self.format);</span>
<span class="line" id="L83"></span>
<span class="line" id="L84"> <span class="tok-kw">if</span> (<span class="tok-kw">try</span> step.cacheHit(&man)) {</span>
<span class="line" id="L85"> <span class="tok-comment">// Cache hit, skip subprocess execution.</span>
</span>
<span class="line" id="L86"> <span class="tok-kw">const</span> digest = man.final();</span>
<span class="line" id="L87"> self.output_file.path = <span class="tok-kw">try</span> b.cache_root.join(b.allocator, &.{</span>
<span class="line" id="L88"> <span class="tok-str">"o"</span>, &digest, self.basename,</span>
<span class="line" id="L89"> });</span>
<span class="line" id="L90"> <span class="tok-kw">return</span>;</span>
<span class="line" id="L91"> }</span>
<span class="line" id="L92"></span>
<span class="line" id="L93"> <span class="tok-kw">const</span> digest = man.final();</span>
<span class="line" id="L94"> <span class="tok-kw">const</span> full_dest_path = <span class="tok-kw">try</span> b.cache_root.join(b.allocator, &.{ <span class="tok-str">"o"</span>, &digest, self.basename });</span>
<span class="line" id="L95"> <span class="tok-kw">const</span> cache_path = <span class="tok-str">"o"</span> ++ fs.path.sep_str ++ digest;</span>
<span class="line" id="L96"> b.cache_root.handle.makePath(cache_path) <span class="tok-kw">catch</span> |err| {</span>
<span class="line" id="L97"> <span class="tok-kw">return</span> step.fail(<span class="tok-str">"unable to make path {s}: {s}"</span>, .{ cache_path, <span class="tok-builtin">@errorName</span>(err) });</span>
<span class="line" id="L98"> };</span>
<span class="line" id="L99"></span>
<span class="line" id="L100"> <span class="tok-kw">var</span> argv = std.ArrayList([]<span class="tok-kw">const</span> <span class="tok-type">u8</span>).init(b.allocator);</span>
<span class="line" id="L101"> <span class="tok-kw">try</span> argv.appendSlice(&.{ b.zig_exe, <span class="tok-str">"objcopy"</span> });</span>
<span class="line" id="L102"></span>
<span class="line" id="L103"> <span class="tok-kw">if</span> (self.only_section) |only_section| {</span>
<span class="line" id="L104"> <span class="tok-kw">try</span> argv.appendSlice(&.{ <span class="tok-str">"-j"</span>, only_section });</span>
<span class="line" id="L105"> }</span>
<span class="line" id="L106"> <span class="tok-kw">if</span> (self.pad_to) |pad_to| {</span>
<span class="line" id="L107"> <span class="tok-kw">try</span> argv.appendSlice(&.{ <span class="tok-str">"--pad-to"</span>, b.fmt(<span class="tok-str">"{d}"</span>, .{pad_to}) });</span>
<span class="line" id="L108"> }</span>
<span class="line" id="L109"> <span class="tok-kw">if</span> (self.format) |format| <span class="tok-kw">switch</span> (format) {</span>
<span class="line" id="L110"> .bin => <span class="tok-kw">try</span> argv.appendSlice(&.{ <span class="tok-str">"-O"</span>, <span class="tok-str">"binary"</span> }),</span>
<span class="line" id="L111"> .hex => <span class="tok-kw">try</span> argv.appendSlice(&.{ <span class="tok-str">"-O"</span>, <span class="tok-str">"hex"</span> }),</span>
<span class="line" id="L112"> };</span>
<span class="line" id="L113"></span>
<span class="line" id="L114"> <span class="tok-kw">try</span> argv.appendSlice(&.{ full_src_path, full_dest_path });</span>
<span class="line" id="L115"></span>
<span class="line" id="L116"> <span class="tok-kw">try</span> argv.append(<span class="tok-str">"--listen=-"</span>);</span>
<span class="line" id="L117"> _ = <span class="tok-kw">try</span> step.evalZigProcess(argv.items, prog_node);</span>
<span class="line" id="L118"></span>
<span class="line" id="L119"> self.output_file.path = full_dest_path;</span>
<span class="line" id="L120"> <span class="tok-kw">try</span> man.writeManifest();</span>
<span class="line" id="L121">}</span>
<span class="line" id="L122"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std/Build | repos/yazap/docs/src/std/Build/Step/Options.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>Build/Step/Options.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"std"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> builtin = <span class="tok-builtin">@import</span>(<span class="tok-str">"builtin"</span>);</span>
<span class="line" id="L3"><span class="tok-kw">const</span> fs = std.fs;</span>
<span class="line" id="L4"><span class="tok-kw">const</span> Step = std.Build.Step;</span>
<span class="line" id="L5"><span class="tok-kw">const</span> GeneratedFile = std.Build.GeneratedFile;</span>
<span class="line" id="L6"><span class="tok-kw">const</span> FileSource = std.Build.FileSource;</span>
<span class="line" id="L7"></span>
<span class="line" id="L8"><span class="tok-kw">const</span> Options = <span class="tok-builtin">@This</span>();</span>
<span class="line" id="L9"></span>
<span class="line" id="L10"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> base_id = .options;</span>
<span class="line" id="L11"></span>
<span class="line" id="L12">step: Step,</span>
<span class="line" id="L13">generated_file: GeneratedFile,</span>
<span class="line" id="L14"></span>
<span class="line" id="L15">contents: std.ArrayList(<span class="tok-type">u8</span>),</span>
<span class="line" id="L16">artifact_args: std.ArrayList(OptionArtifactArg),</span>
<span class="line" id="L17">file_source_args: std.ArrayList(OptionFileSourceArg),</span>
<span class="line" id="L18"></span>
<span class="line" id="L19"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">create</span>(owner: *std.Build) *Options {</span>
<span class="line" id="L20"> <span class="tok-kw">const</span> self = owner.allocator.create(Options) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L21"> self.* = .{</span>
<span class="line" id="L22"> .step = Step.init(.{</span>
<span class="line" id="L23"> .id = base_id,</span>
<span class="line" id="L24"> .name = <span class="tok-str">"options"</span>,</span>
<span class="line" id="L25"> .owner = owner,</span>
<span class="line" id="L26"> .makeFn = make,</span>
<span class="line" id="L27"> }),</span>
<span class="line" id="L28"> .generated_file = <span class="tok-null">undefined</span>,</span>
<span class="line" id="L29"> .contents = std.ArrayList(<span class="tok-type">u8</span>).init(owner.allocator),</span>
<span class="line" id="L30"> .artifact_args = std.ArrayList(OptionArtifactArg).init(owner.allocator),</span>
<span class="line" id="L31"> .file_source_args = std.ArrayList(OptionFileSourceArg).init(owner.allocator),</span>
<span class="line" id="L32"> };</span>
<span class="line" id="L33"> self.generated_file = .{ .step = &self.step };</span>
<span class="line" id="L34"></span>
<span class="line" id="L35"> <span class="tok-kw">return</span> self;</span>
<span class="line" id="L36">}</span>
<span class="line" id="L37"></span>
<span class="line" id="L38"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addOption</span>(self: *Options, <span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>, name: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>, value: T) <span class="tok-type">void</span> {</span>
<span class="line" id="L39"> <span class="tok-kw">return</span> addOptionFallible(self, T, name, value) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"unhandled error"</span>);</span>
<span class="line" id="L40">}</span>
<span class="line" id="L41"></span>
<span class="line" id="L42"><span class="tok-kw">fn</span> <span class="tok-fn">addOptionFallible</span>(self: *Options, <span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>, name: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>, value: T) !<span class="tok-type">void</span> {</span>
<span class="line" id="L43"> <span class="tok-kw">const</span> out = self.contents.writer();</span>
<span class="line" id="L44"> <span class="tok-kw">switch</span> (T) {</span>
<span class="line" id="L45"> []<span class="tok-kw">const</span> []<span class="tok-kw">const</span> <span class="tok-type">u8</span> => {</span>
<span class="line" id="L46"> <span class="tok-kw">try</span> out.print(<span class="tok-str">"pub const {}: []const []const u8 = &[_][]const u8{{\n"</span>, .{std.zig.fmtId(name)});</span>
<span class="line" id="L47"> <span class="tok-kw">for</span> (value) |slice| {</span>
<span class="line" id="L48"> <span class="tok-kw">try</span> out.print(<span class="tok-str">" \"{}\",\n"</span>, .{std.zig.fmtEscapes(slice)});</span>
<span class="line" id="L49"> }</span>
<span class="line" id="L50"> <span class="tok-kw">try</span> out.writeAll(<span class="tok-str">"};\n"</span>);</span>
<span class="line" id="L51"> <span class="tok-kw">return</span>;</span>
<span class="line" id="L52"> },</span>
<span class="line" id="L53"> [:<span class="tok-number">0</span>]<span class="tok-kw">const</span> <span class="tok-type">u8</span> => {</span>
<span class="line" id="L54"> <span class="tok-kw">try</span> out.print(<span class="tok-str">"pub const {}: [:0]const u8 = \"{}\";\n"</span>, .{ std.zig.fmtId(name), std.zig.fmtEscapes(value) });</span>
<span class="line" id="L55"> <span class="tok-kw">return</span>;</span>
<span class="line" id="L56"> },</span>
<span class="line" id="L57"> []<span class="tok-kw">const</span> <span class="tok-type">u8</span> => {</span>
<span class="line" id="L58"> <span class="tok-kw">try</span> out.print(<span class="tok-str">"pub const {}: []const u8 = \"{}\";\n"</span>, .{ std.zig.fmtId(name), std.zig.fmtEscapes(value) });</span>
<span class="line" id="L59"> <span class="tok-kw">return</span>;</span>
<span class="line" id="L60"> },</span>
<span class="line" id="L61"> ?[:<span class="tok-number">0</span>]<span class="tok-kw">const</span> <span class="tok-type">u8</span> => {</span>
<span class="line" id="L62"> <span class="tok-kw">try</span> out.print(<span class="tok-str">"pub const {}: ?[:0]const u8 = "</span>, .{std.zig.fmtId(name)});</span>
<span class="line" id="L63"> <span class="tok-kw">if</span> (value) |payload| {</span>
<span class="line" id="L64"> <span class="tok-kw">try</span> out.print(<span class="tok-str">"\"{}\";\n"</span>, .{std.zig.fmtEscapes(payload)});</span>
<span class="line" id="L65"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L66"> <span class="tok-kw">try</span> out.writeAll(<span class="tok-str">"null;\n"</span>);</span>
<span class="line" id="L67"> }</span>
<span class="line" id="L68"> <span class="tok-kw">return</span>;</span>
<span class="line" id="L69"> },</span>
<span class="line" id="L70"> ?[]<span class="tok-kw">const</span> <span class="tok-type">u8</span> => {</span>
<span class="line" id="L71"> <span class="tok-kw">try</span> out.print(<span class="tok-str">"pub const {}: ?[]const u8 = "</span>, .{std.zig.fmtId(name)});</span>
<span class="line" id="L72"> <span class="tok-kw">if</span> (value) |payload| {</span>
<span class="line" id="L73"> <span class="tok-kw">try</span> out.print(<span class="tok-str">"\"{}\";\n"</span>, .{std.zig.fmtEscapes(payload)});</span>
<span class="line" id="L74"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L75"> <span class="tok-kw">try</span> out.writeAll(<span class="tok-str">"null;\n"</span>);</span>
<span class="line" id="L76"> }</span>
<span class="line" id="L77"> <span class="tok-kw">return</span>;</span>
<span class="line" id="L78"> },</span>
<span class="line" id="L79"> std.SemanticVersion => {</span>
<span class="line" id="L80"> <span class="tok-kw">try</span> out.print(</span>
<span class="line" id="L81"> <span class="tok-str">\\pub const {}: @import("std").SemanticVersion = .{{</span></span>
<span class="line" id="L82"> <span class="tok-str">\\ .major = {d},</span></span>
<span class="line" id="L83"> <span class="tok-str">\\ .minor = {d},</span></span>
<span class="line" id="L84"> <span class="tok-str">\\ .patch = {d},</span></span>
<span class="line" id="L85"> <span class="tok-str">\\</span></span>
<span class="line" id="L86"> , .{</span>
<span class="line" id="L87"> std.zig.fmtId(name),</span>
<span class="line" id="L88"></span>
<span class="line" id="L89"> value.major,</span>
<span class="line" id="L90"> value.minor,</span>
<span class="line" id="L91"> value.patch,</span>
<span class="line" id="L92"> });</span>
<span class="line" id="L93"> <span class="tok-kw">if</span> (value.pre) |some| {</span>
<span class="line" id="L94"> <span class="tok-kw">try</span> out.print(<span class="tok-str">" .pre = \"{}\",\n"</span>, .{std.zig.fmtEscapes(some)});</span>
<span class="line" id="L95"> }</span>
<span class="line" id="L96"> <span class="tok-kw">if</span> (value.build) |some| {</span>
<span class="line" id="L97"> <span class="tok-kw">try</span> out.print(<span class="tok-str">" .build = \"{}\",\n"</span>, .{std.zig.fmtEscapes(some)});</span>
<span class="line" id="L98"> }</span>
<span class="line" id="L99"> <span class="tok-kw">try</span> out.writeAll(<span class="tok-str">"};\n"</span>);</span>
<span class="line" id="L100"> <span class="tok-kw">return</span>;</span>
<span class="line" id="L101"> },</span>
<span class="line" id="L102"> <span class="tok-kw">else</span> => {},</span>
<span class="line" id="L103"> }</span>
<span class="line" id="L104"> <span class="tok-kw">switch</span> (<span class="tok-builtin">@typeInfo</span>(T)) {</span>
<span class="line" id="L105"> .Enum => |enum_info| {</span>
<span class="line" id="L106"> <span class="tok-kw">try</span> out.print(<span class="tok-str">"pub const {} = enum {{\n"</span>, .{std.zig.fmtId(<span class="tok-builtin">@typeName</span>(T))});</span>
<span class="line" id="L107"> <span class="tok-kw">inline</span> <span class="tok-kw">for</span> (enum_info.fields) |field| {</span>
<span class="line" id="L108"> <span class="tok-kw">try</span> out.print(<span class="tok-str">" {},\n"</span>, .{std.zig.fmtId(field.name)});</span>
<span class="line" id="L109"> }</span>
<span class="line" id="L110"> <span class="tok-kw">try</span> out.writeAll(<span class="tok-str">"};\n"</span>);</span>
<span class="line" id="L111"> <span class="tok-kw">try</span> out.print(<span class="tok-str">"pub const {}: {s} = {s}.{s};\n"</span>, .{</span>
<span class="line" id="L112"> std.zig.fmtId(name),</span>
<span class="line" id="L113"> std.zig.fmtId(<span class="tok-builtin">@typeName</span>(T)),</span>
<span class="line" id="L114"> std.zig.fmtId(<span class="tok-builtin">@typeName</span>(T)),</span>
<span class="line" id="L115"> std.zig.fmtId(<span class="tok-builtin">@tagName</span>(value)),</span>
<span class="line" id="L116"> });</span>
<span class="line" id="L117"> <span class="tok-kw">return</span>;</span>
<span class="line" id="L118"> },</span>
<span class="line" id="L119"> <span class="tok-kw">else</span> => {},</span>
<span class="line" id="L120"> }</span>
<span class="line" id="L121"> <span class="tok-kw">try</span> out.print(<span class="tok-str">"pub const {}: {s} = "</span>, .{ std.zig.fmtId(name), <span class="tok-builtin">@typeName</span>(T) });</span>
<span class="line" id="L122"> <span class="tok-kw">try</span> printLiteral(out, value, <span class="tok-number">0</span>);</span>
<span class="line" id="L123"> <span class="tok-kw">try</span> out.writeAll(<span class="tok-str">";\n"</span>);</span>
<span class="line" id="L124">}</span>
<span class="line" id="L125"></span>
<span class="line" id="L126"><span class="tok-comment">// TODO: non-recursive?</span>
</span>
<span class="line" id="L127"><span class="tok-kw">fn</span> <span class="tok-fn">printLiteral</span>(out: <span class="tok-kw">anytype</span>, val: <span class="tok-kw">anytype</span>, indent: <span class="tok-type">u8</span>) !<span class="tok-type">void</span> {</span>
<span class="line" id="L128"> <span class="tok-kw">const</span> T = <span class="tok-builtin">@TypeOf</span>(val);</span>
<span class="line" id="L129"> <span class="tok-kw">switch</span> (<span class="tok-builtin">@typeInfo</span>(T)) {</span>
<span class="line" id="L130"> .Array => {</span>
<span class="line" id="L131"> <span class="tok-kw">try</span> out.print(<span class="tok-str">"{s} {{\n"</span>, .{<span class="tok-builtin">@typeName</span>(T)});</span>
<span class="line" id="L132"> <span class="tok-kw">for</span> (val) |item| {</span>
<span class="line" id="L133"> <span class="tok-kw">try</span> out.writeByteNTimes(<span class="tok-str">' '</span>, indent + <span class="tok-number">4</span>);</span>
<span class="line" id="L134"> <span class="tok-kw">try</span> printLiteral(out, item, indent + <span class="tok-number">4</span>);</span>
<span class="line" id="L135"> <span class="tok-kw">try</span> out.writeAll(<span class="tok-str">",\n"</span>);</span>
<span class="line" id="L136"> }</span>
<span class="line" id="L137"> <span class="tok-kw">try</span> out.writeByteNTimes(<span class="tok-str">' '</span>, indent);</span>
<span class="line" id="L138"> <span class="tok-kw">try</span> out.writeAll(<span class="tok-str">"}"</span>);</span>
<span class="line" id="L139"> },</span>
<span class="line" id="L140"> .Pointer => |p| {</span>
<span class="line" id="L141"> <span class="tok-kw">if</span> (p.size != .Slice) {</span>
<span class="line" id="L142"> <span class="tok-builtin">@compileError</span>(<span class="tok-str">"Non-slice pointers are not yet supported in build options"</span>);</span>
<span class="line" id="L143"> }</span>
<span class="line" id="L144"> <span class="tok-kw">try</span> out.print(<span class="tok-str">"&[_]{s} {{\n"</span>, .{<span class="tok-builtin">@typeName</span>(p.child)});</span>
<span class="line" id="L145"> <span class="tok-kw">for</span> (val) |item| {</span>
<span class="line" id="L146"> <span class="tok-kw">try</span> out.writeByteNTimes(<span class="tok-str">' '</span>, indent + <span class="tok-number">4</span>);</span>
<span class="line" id="L147"> <span class="tok-kw">try</span> printLiteral(out, item, indent + <span class="tok-number">4</span>);</span>
<span class="line" id="L148"> <span class="tok-kw">try</span> out.writeAll(<span class="tok-str">",\n"</span>);</span>
<span class="line" id="L149"> }</span>
<span class="line" id="L150"> <span class="tok-kw">try</span> out.writeByteNTimes(<span class="tok-str">' '</span>, indent);</span>
<span class="line" id="L151"> <span class="tok-kw">try</span> out.writeAll(<span class="tok-str">"}"</span>);</span>
<span class="line" id="L152"> },</span>
<span class="line" id="L153"> .Optional => {</span>
<span class="line" id="L154"> <span class="tok-kw">if</span> (val) |inner| {</span>
<span class="line" id="L155"> <span class="tok-kw">return</span> printLiteral(out, inner, indent);</span>
<span class="line" id="L156"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L157"> <span class="tok-kw">return</span> out.writeAll(<span class="tok-str">"null"</span>);</span>
<span class="line" id="L158"> }</span>
<span class="line" id="L159"> },</span>
<span class="line" id="L160"> .Void,</span>
<span class="line" id="L161"> .Bool,</span>
<span class="line" id="L162"> .Int,</span>
<span class="line" id="L163"> .ComptimeInt,</span>
<span class="line" id="L164"> .Float,</span>
<span class="line" id="L165"> .Null,</span>
<span class="line" id="L166"> => <span class="tok-kw">try</span> out.print(<span class="tok-str">"{any}"</span>, .{val}),</span>
<span class="line" id="L167"> <span class="tok-kw">else</span> => <span class="tok-builtin">@compileError</span>(std.fmt.comptimePrint(<span class="tok-str">"`{s}` are not yet supported as build options"</span>, .{<span class="tok-builtin">@tagName</span>(<span class="tok-builtin">@typeInfo</span>(T))})),</span>
<span class="line" id="L168"> }</span>
<span class="line" id="L169">}</span>
<span class="line" id="L170"></span>
<span class="line" id="L171"><span class="tok-comment">/// The value is the path in the cache dir.</span></span>
<span class="line" id="L172"><span class="tok-comment">/// Adds a dependency automatically.</span></span>
<span class="line" id="L173"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addOptionFileSource</span>(</span>
<span class="line" id="L174"> self: *Options,</span>
<span class="line" id="L175"> name: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L176"> source: FileSource,</span>
<span class="line" id="L177">) <span class="tok-type">void</span> {</span>
<span class="line" id="L178"> self.file_source_args.append(.{</span>
<span class="line" id="L179"> .name = name,</span>
<span class="line" id="L180"> .source = source.dupe(self.step.owner),</span>
<span class="line" id="L181"> }) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L182"> source.addStepDependencies(&self.step);</span>
<span class="line" id="L183">}</span>
<span class="line" id="L184"></span>
<span class="line" id="L185"><span class="tok-comment">/// The value is the path in the cache dir.</span></span>
<span class="line" id="L186"><span class="tok-comment">/// Adds a dependency automatically.</span></span>
<span class="line" id="L187"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addOptionArtifact</span>(self: *Options, name: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>, artifact: *Step.Compile) <span class="tok-type">void</span> {</span>
<span class="line" id="L188"> self.artifact_args.append(.{ .name = self.step.owner.dupe(name), .artifact = artifact }) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L189"> self.step.dependOn(&artifact.step);</span>
<span class="line" id="L190">}</span>
<span class="line" id="L191"></span>
<span class="line" id="L192"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">createModule</span>(self: *Options) *std.Build.Module {</span>
<span class="line" id="L193"> <span class="tok-kw">return</span> self.step.owner.createModule(.{</span>
<span class="line" id="L194"> .source_file = self.getSource(),</span>
<span class="line" id="L195"> .dependencies = &.{},</span>
<span class="line" id="L196"> });</span>
<span class="line" id="L197">}</span>
<span class="line" id="L198"></span>
<span class="line" id="L199"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">getSource</span>(self: *Options) FileSource {</span>
<span class="line" id="L200"> <span class="tok-kw">return</span> .{ .generated = &self.generated_file };</span>
<span class="line" id="L201">}</span>
<span class="line" id="L202"></span>
<span class="line" id="L203"><span class="tok-kw">fn</span> <span class="tok-fn">make</span>(step: *Step, prog_node: *std.Progress.Node) !<span class="tok-type">void</span> {</span>
<span class="line" id="L204"> <span class="tok-comment">// This step completes so quickly that no progress is necessary.</span>
</span>
<span class="line" id="L205"> _ = prog_node;</span>
<span class="line" id="L206"></span>
<span class="line" id="L207"> <span class="tok-kw">const</span> b = step.owner;</span>
<span class="line" id="L208"> <span class="tok-kw">const</span> self = <span class="tok-builtin">@fieldParentPtr</span>(Options, <span class="tok-str">"step"</span>, step);</span>
<span class="line" id="L209"></span>
<span class="line" id="L210"> <span class="tok-kw">for</span> (self.artifact_args.items) |item| {</span>
<span class="line" id="L211"> self.addOption(</span>
<span class="line" id="L212"> []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L213"> item.name,</span>
<span class="line" id="L214"> b.pathFromRoot(item.artifact.getOutputSource().getPath(b)),</span>
<span class="line" id="L215"> );</span>
<span class="line" id="L216"> }</span>
<span class="line" id="L217"></span>
<span class="line" id="L218"> <span class="tok-kw">for</span> (self.file_source_args.items) |item| {</span>
<span class="line" id="L219"> self.addOption(</span>
<span class="line" id="L220"> []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L221"> item.name,</span>
<span class="line" id="L222"> item.source.getPath(b),</span>
<span class="line" id="L223"> );</span>
<span class="line" id="L224"> }</span>
<span class="line" id="L225"></span>
<span class="line" id="L226"> <span class="tok-kw">const</span> basename = <span class="tok-str">"options.zig"</span>;</span>
<span class="line" id="L227"></span>
<span class="line" id="L228"> <span class="tok-comment">// Hash contents to file name.</span>
</span>
<span class="line" id="L229"> <span class="tok-kw">var</span> hash = b.cache.hash;</span>
<span class="line" id="L230"> <span class="tok-comment">// Random bytes to make unique. Refresh this with new random bytes when</span>
</span>
<span class="line" id="L231"> <span class="tok-comment">// implementation is modified in a non-backwards-compatible way.</span>
</span>
<span class="line" id="L232"> hash.add(<span class="tok-builtin">@as</span>(<span class="tok-type">u32</span>, <span class="tok-number">0x38845ef8</span>));</span>
<span class="line" id="L233"> hash.addBytes(self.contents.items);</span>
<span class="line" id="L234"> <span class="tok-kw">const</span> sub_path = <span class="tok-str">"c"</span> ++ fs.path.sep_str ++ hash.final() ++ fs.path.sep_str ++ basename;</span>
<span class="line" id="L235"></span>
<span class="line" id="L236"> self.generated_file.path = <span class="tok-kw">try</span> b.cache_root.join(b.allocator, &.{sub_path});</span>
<span class="line" id="L237"></span>
<span class="line" id="L238"> <span class="tok-comment">// Optimize for the hot path. Stat the file, and if it already exists,</span>
</span>
<span class="line" id="L239"> <span class="tok-comment">// cache hit.</span>
</span>
<span class="line" id="L240"> <span class="tok-kw">if</span> (b.cache_root.handle.access(sub_path, .{})) |_| {</span>
<span class="line" id="L241"> <span class="tok-comment">// This is the hot path, success.</span>
</span>
<span class="line" id="L242"> step.result_cached = <span class="tok-null">true</span>;</span>
<span class="line" id="L243"> <span class="tok-kw">return</span>;</span>
<span class="line" id="L244"> } <span class="tok-kw">else</span> |outer_err| <span class="tok-kw">switch</span> (outer_err) {</span>
<span class="line" id="L245"> <span class="tok-kw">error</span>.FileNotFound => {</span>
<span class="line" id="L246"> <span class="tok-kw">const</span> sub_dirname = fs.path.dirname(sub_path).?;</span>
<span class="line" id="L247"> b.cache_root.handle.makePath(sub_dirname) <span class="tok-kw">catch</span> |e| {</span>
<span class="line" id="L248"> <span class="tok-kw">return</span> step.fail(<span class="tok-str">"unable to make path '{}{s}': {s}"</span>, .{</span>
<span class="line" id="L249"> b.cache_root, sub_dirname, <span class="tok-builtin">@errorName</span>(e),</span>
<span class="line" id="L250"> });</span>
<span class="line" id="L251"> };</span>
<span class="line" id="L252"></span>
<span class="line" id="L253"> <span class="tok-kw">const</span> rand_int = std.crypto.random.int(<span class="tok-type">u64</span>);</span>
<span class="line" id="L254"> <span class="tok-kw">const</span> tmp_sub_path = <span class="tok-str">"tmp"</span> ++ fs.path.sep_str ++</span>
<span class="line" id="L255"> std.Build.hex64(rand_int) ++ fs.path.sep_str ++</span>
<span class="line" id="L256"> basename;</span>
<span class="line" id="L257"> <span class="tok-kw">const</span> tmp_sub_path_dirname = fs.path.dirname(tmp_sub_path).?;</span>
<span class="line" id="L258"></span>
<span class="line" id="L259"> b.cache_root.handle.makePath(tmp_sub_path_dirname) <span class="tok-kw">catch</span> |err| {</span>
<span class="line" id="L260"> <span class="tok-kw">return</span> step.fail(<span class="tok-str">"unable to make temporary directory '{}{s}': {s}"</span>, .{</span>
<span class="line" id="L261"> b.cache_root, tmp_sub_path_dirname, <span class="tok-builtin">@errorName</span>(err),</span>
<span class="line" id="L262"> });</span>
<span class="line" id="L263"> };</span>
<span class="line" id="L264"></span>
<span class="line" id="L265"> b.cache_root.handle.writeFile(tmp_sub_path, self.contents.items) <span class="tok-kw">catch</span> |err| {</span>
<span class="line" id="L266"> <span class="tok-kw">return</span> step.fail(<span class="tok-str">"unable to write options to '{}{s}': {s}"</span>, .{</span>
<span class="line" id="L267"> b.cache_root, tmp_sub_path, <span class="tok-builtin">@errorName</span>(err),</span>
<span class="line" id="L268"> });</span>
<span class="line" id="L269"> };</span>
<span class="line" id="L270"></span>
<span class="line" id="L271"> b.cache_root.handle.rename(tmp_sub_path, sub_path) <span class="tok-kw">catch</span> |err| <span class="tok-kw">switch</span> (err) {</span>
<span class="line" id="L272"> <span class="tok-kw">error</span>.PathAlreadyExists => {</span>
<span class="line" id="L273"> <span class="tok-comment">// Other process beat us to it. Clean up the temp file.</span>
</span>
<span class="line" id="L274"> b.cache_root.handle.deleteFile(tmp_sub_path) <span class="tok-kw">catch</span> |e| {</span>
<span class="line" id="L275"> <span class="tok-kw">try</span> step.addError(<span class="tok-str">"warning: unable to delete temp file '{}{s}': {s}"</span>, .{</span>
<span class="line" id="L276"> b.cache_root, tmp_sub_path, <span class="tok-builtin">@errorName</span>(e),</span>
<span class="line" id="L277"> });</span>
<span class="line" id="L278"> };</span>
<span class="line" id="L279"> step.result_cached = <span class="tok-null">true</span>;</span>
<span class="line" id="L280"> <span class="tok-kw">return</span>;</span>
<span class="line" id="L281"> },</span>
<span class="line" id="L282"> <span class="tok-kw">else</span> => {</span>
<span class="line" id="L283"> <span class="tok-kw">return</span> step.fail(<span class="tok-str">"unable to rename options from '{}{s}' to '{}{s}': {s}"</span>, .{</span>
<span class="line" id="L284"> b.cache_root, tmp_sub_path,</span>
<span class="line" id="L285"> b.cache_root, sub_path,</span>
<span class="line" id="L286"> <span class="tok-builtin">@errorName</span>(err),</span>
<span class="line" id="L287"> });</span>
<span class="line" id="L288"> },</span>
<span class="line" id="L289"> };</span>
<span class="line" id="L290"> },</span>
<span class="line" id="L291"> <span class="tok-kw">else</span> => |e| <span class="tok-kw">return</span> step.fail(<span class="tok-str">"unable to access options file '{}{s}': {s}"</span>, .{</span>
<span class="line" id="L292"> b.cache_root, sub_path, <span class="tok-builtin">@errorName</span>(e),</span>
<span class="line" id="L293"> }),</span>
<span class="line" id="L294"> }</span>
<span class="line" id="L295">}</span>
<span class="line" id="L296"></span>
<span class="line" id="L297"><span class="tok-kw">const</span> OptionArtifactArg = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L298"> name: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L299"> artifact: *Step.Compile,</span>
<span class="line" id="L300">};</span>
<span class="line" id="L301"></span>
<span class="line" id="L302"><span class="tok-kw">const</span> OptionFileSourceArg = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L303"> name: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L304"> source: FileSource,</span>
<span class="line" id="L305">};</span>
<span class="line" id="L306"></span>
<span class="line" id="L307"><span class="tok-kw">test</span> Options {</span>
<span class="line" id="L308"> <span class="tok-kw">if</span> (builtin.os.tag == .wasi) <span class="tok-kw">return</span> <span class="tok-kw">error</span>.SkipZigTest;</span>
<span class="line" id="L309"></span>
<span class="line" id="L310"> <span class="tok-kw">var</span> arena = std.heap.ArenaAllocator.init(std.testing.allocator);</span>
<span class="line" id="L311"> <span class="tok-kw">defer</span> arena.deinit();</span>
<span class="line" id="L312"></span>
<span class="line" id="L313"> <span class="tok-kw">const</span> host = <span class="tok-kw">try</span> std.zig.system.NativeTargetInfo.detect(.{});</span>
<span class="line" id="L314"></span>
<span class="line" id="L315"> <span class="tok-kw">var</span> cache: std.Build.Cache = .{</span>
<span class="line" id="L316"> .gpa = arena.allocator(),</span>
<span class="line" id="L317"> .manifest_dir = std.fs.cwd(),</span>
<span class="line" id="L318"> };</span>
<span class="line" id="L319"></span>
<span class="line" id="L320"> <span class="tok-kw">var</span> builder = <span class="tok-kw">try</span> std.Build.create(</span>
<span class="line" id="L321"> arena.allocator(),</span>
<span class="line" id="L322"> <span class="tok-str">"test"</span>,</span>
<span class="line" id="L323"> .{ .path = <span class="tok-str">"test"</span>, .handle = std.fs.cwd() },</span>
<span class="line" id="L324"> .{ .path = <span class="tok-str">"test"</span>, .handle = std.fs.cwd() },</span>
<span class="line" id="L325"> .{ .path = <span class="tok-str">"test"</span>, .handle = std.fs.cwd() },</span>
<span class="line" id="L326"> host,</span>
<span class="line" id="L327"> &cache,</span>
<span class="line" id="L328"> );</span>
<span class="line" id="L329"> <span class="tok-kw">defer</span> builder.destroy();</span>
<span class="line" id="L330"></span>
<span class="line" id="L331"> <span class="tok-kw">const</span> options = builder.addOptions();</span>
<span class="line" id="L332"></span>
<span class="line" id="L333"> <span class="tok-comment">// TODO this regressed at some point</span>
</span>
<span class="line" id="L334"> <span class="tok-comment">//const KeywordEnum = enum {</span>
</span>
<span class="line" id="L335"> <span class="tok-comment">// @"0.8.1",</span>
</span>
<span class="line" id="L336"> <span class="tok-comment">//};</span>
</span>
<span class="line" id="L337"></span>
<span class="line" id="L338"> <span class="tok-kw">const</span> nested_array = [<span class="tok-number">2</span>][<span class="tok-number">2</span>]<span class="tok-type">u16</span>{</span>
<span class="line" id="L339"> [<span class="tok-number">2</span>]<span class="tok-type">u16</span>{ <span class="tok-number">300</span>, <span class="tok-number">200</span> },</span>
<span class="line" id="L340"> [<span class="tok-number">2</span>]<span class="tok-type">u16</span>{ <span class="tok-number">300</span>, <span class="tok-number">200</span> },</span>
<span class="line" id="L341"> };</span>
<span class="line" id="L342"> <span class="tok-kw">const</span> nested_slice: []<span class="tok-kw">const</span> []<span class="tok-kw">const</span> <span class="tok-type">u16</span> = &[_][]<span class="tok-kw">const</span> <span class="tok-type">u16</span>{ &nested_array[<span class="tok-number">0</span>], &nested_array[<span class="tok-number">1</span>] };</span>
<span class="line" id="L343"></span>
<span class="line" id="L344"> options.addOption(<span class="tok-type">usize</span>, <span class="tok-str">"option1"</span>, <span class="tok-number">1</span>);</span>
<span class="line" id="L345"> options.addOption(?<span class="tok-type">usize</span>, <span class="tok-str">"option2"</span>, <span class="tok-null">null</span>);</span>
<span class="line" id="L346"> options.addOption(?<span class="tok-type">usize</span>, <span class="tok-str">"option3"</span>, <span class="tok-number">3</span>);</span>
<span class="line" id="L347"> options.addOption(<span class="tok-type">comptime_int</span>, <span class="tok-str">"option4"</span>, <span class="tok-number">4</span>);</span>
<span class="line" id="L348"> options.addOption([]<span class="tok-kw">const</span> <span class="tok-type">u8</span>, <span class="tok-str">"string"</span>, <span class="tok-str">"zigisthebest"</span>);</span>
<span class="line" id="L349"> options.addOption(?[]<span class="tok-kw">const</span> <span class="tok-type">u8</span>, <span class="tok-str">"optional_string"</span>, <span class="tok-null">null</span>);</span>
<span class="line" id="L350"> options.addOption([<span class="tok-number">2</span>][<span class="tok-number">2</span>]<span class="tok-type">u16</span>, <span class="tok-str">"nested_array"</span>, nested_array);</span>
<span class="line" id="L351"> options.addOption([]<span class="tok-kw">const</span> []<span class="tok-kw">const</span> <span class="tok-type">u16</span>, <span class="tok-str">"nested_slice"</span>, nested_slice);</span>
<span class="line" id="L352"> <span class="tok-comment">//options.addOption(KeywordEnum, "keyword_enum", .@"0.8.1");</span>
</span>
<span class="line" id="L353"> options.addOption(std.SemanticVersion, <span class="tok-str">"semantic_version"</span>, <span class="tok-kw">try</span> std.SemanticVersion.parse(<span class="tok-str">"0.1.2-foo+bar"</span>));</span>
<span class="line" id="L354"></span>
<span class="line" id="L355"> <span class="tok-kw">try</span> std.testing.expectEqualStrings(</span>
<span class="line" id="L356"> <span class="tok-str">\\pub const option1: usize = 1;</span></span>
<span class="line" id="L357"> <span class="tok-str">\\pub const option2: ?usize = null;</span></span>
<span class="line" id="L358"> <span class="tok-str">\\pub const option3: ?usize = 3;</span></span>
<span class="line" id="L359"> <span class="tok-str">\\pub const option4: comptime_int = 4;</span></span>
<span class="line" id="L360"> <span class="tok-str">\\pub const string: []const u8 = "zigisthebest";</span></span>
<span class="line" id="L361"> <span class="tok-str">\\pub const optional_string: ?[]const u8 = null;</span></span>
<span class="line" id="L362"> <span class="tok-str">\\pub const nested_array: [2][2]u16 = [2][2]u16 {</span></span>
<span class="line" id="L363"> <span class="tok-str">\\ [2]u16 {</span></span>
<span class="line" id="L364"> <span class="tok-str">\\ 300,</span></span>
<span class="line" id="L365"> <span class="tok-str">\\ 200,</span></span>
<span class="line" id="L366"> <span class="tok-str">\\ },</span></span>
<span class="line" id="L367"> <span class="tok-str">\\ [2]u16 {</span></span>
<span class="line" id="L368"> <span class="tok-str">\\ 300,</span></span>
<span class="line" id="L369"> <span class="tok-str">\\ 200,</span></span>
<span class="line" id="L370"> <span class="tok-str">\\ },</span></span>
<span class="line" id="L371"> <span class="tok-str">\\};</span></span>
<span class="line" id="L372"> <span class="tok-str">\\pub const nested_slice: []const []const u16 = &[_][]const u16 {</span></span>
<span class="line" id="L373"> <span class="tok-str">\\ &[_]u16 {</span></span>
<span class="line" id="L374"> <span class="tok-str">\\ 300,</span></span>
<span class="line" id="L375"> <span class="tok-str">\\ 200,</span></span>
<span class="line" id="L376"> <span class="tok-str">\\ },</span></span>
<span class="line" id="L377"> <span class="tok-str">\\ &[_]u16 {</span></span>
<span class="line" id="L378"> <span class="tok-str">\\ 300,</span></span>
<span class="line" id="L379"> <span class="tok-str">\\ 200,</span></span>
<span class="line" id="L380"> <span class="tok-str">\\ },</span></span>
<span class="line" id="L381"> <span class="tok-str">\\};</span></span>
<span class="line" id="L382"> <span class="tok-comment">//\\pub const KeywordEnum = enum {</span>
</span>
<span class="line" id="L383"> <span class="tok-comment">//\\ @"0.8.1",</span>
</span>
<span class="line" id="L384"> <span class="tok-comment">//\\};</span>
</span>
<span class="line" id="L385"> <span class="tok-comment">//\\pub const keyword_enum: KeywordEnum = KeywordEnum.@"0.8.1";</span>
</span>
<span class="line" id="L386"> <span class="tok-str">\\pub const semantic_version: @import("std").SemanticVersion = .{</span></span>
<span class="line" id="L387"> <span class="tok-str">\\ .major = 0,</span></span>
<span class="line" id="L388"> <span class="tok-str">\\ .minor = 1,</span></span>
<span class="line" id="L389"> <span class="tok-str">\\ .patch = 2,</span></span>
<span class="line" id="L390"> <span class="tok-str">\\ .pre = "foo",</span></span>
<span class="line" id="L391"> <span class="tok-str">\\ .build = "bar",</span></span>
<span class="line" id="L392"> <span class="tok-str">\\};</span></span>
<span class="line" id="L393"> <span class="tok-str">\\</span></span>
<span class="line" id="L394"> , options.contents.items);</span>
<span class="line" id="L395"></span>
<span class="line" id="L396"> _ = <span class="tok-kw">try</span> std.zig.Ast.parse(arena.allocator(), <span class="tok-kw">try</span> options.contents.toOwnedSliceSentinel(<span class="tok-number">0</span>), .zig);</span>
<span class="line" id="L397">}</span>
<span class="line" id="L398"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std/Build | repos/yazap/docs/src/std/Build/Step/Fmt.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>Build/Step/Fmt.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-comment">//! This step has two modes:</span></span>
<span class="line" id="L2"><span class="tok-comment">//! * Modify mode: directly modify source files, formatting them in place.</span></span>
<span class="line" id="L3"><span class="tok-comment">//! * Check mode: fail the step if a non-conforming file is found.</span></span>
<span class="line" id="L4"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"std"</span>);</span>
<span class="line" id="L5"><span class="tok-kw">const</span> Step = std.Build.Step;</span>
<span class="line" id="L6"><span class="tok-kw">const</span> Fmt = <span class="tok-builtin">@This</span>();</span>
<span class="line" id="L7"></span>
<span class="line" id="L8">step: Step,</span>
<span class="line" id="L9">paths: []<span class="tok-kw">const</span> []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L10">exclude_paths: []<span class="tok-kw">const</span> []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L11">check: <span class="tok-type">bool</span>,</span>
<span class="line" id="L12"></span>
<span class="line" id="L13"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> base_id = .fmt;</span>
<span class="line" id="L14"></span>
<span class="line" id="L15"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> Options = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L16"> paths: []<span class="tok-kw">const</span> []<span class="tok-kw">const</span> <span class="tok-type">u8</span> = &.{},</span>
<span class="line" id="L17"> exclude_paths: []<span class="tok-kw">const</span> []<span class="tok-kw">const</span> <span class="tok-type">u8</span> = &.{},</span>
<span class="line" id="L18"> <span class="tok-comment">/// If true, fails the build step when any non-conforming files are encountered.</span></span>
<span class="line" id="L19"> check: <span class="tok-type">bool</span> = <span class="tok-null">false</span>,</span>
<span class="line" id="L20">};</span>
<span class="line" id="L21"></span>
<span class="line" id="L22"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">create</span>(owner: *std.Build, options: Options) *Fmt {</span>
<span class="line" id="L23"> <span class="tok-kw">const</span> self = owner.allocator.create(Fmt) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L24"> <span class="tok-kw">const</span> name = <span class="tok-kw">if</span> (options.check) <span class="tok-str">"zig fmt --check"</span> <span class="tok-kw">else</span> <span class="tok-str">"zig fmt"</span>;</span>
<span class="line" id="L25"> self.* = .{</span>
<span class="line" id="L26"> .step = Step.init(.{</span>
<span class="line" id="L27"> .id = base_id,</span>
<span class="line" id="L28"> .name = name,</span>
<span class="line" id="L29"> .owner = owner,</span>
<span class="line" id="L30"> .makeFn = make,</span>
<span class="line" id="L31"> }),</span>
<span class="line" id="L32"> .paths = options.paths,</span>
<span class="line" id="L33"> .exclude_paths = options.exclude_paths,</span>
<span class="line" id="L34"> .check = options.check,</span>
<span class="line" id="L35"> };</span>
<span class="line" id="L36"> <span class="tok-kw">return</span> self;</span>
<span class="line" id="L37">}</span>
<span class="line" id="L38"></span>
<span class="line" id="L39"><span class="tok-kw">fn</span> <span class="tok-fn">make</span>(step: *Step, prog_node: *std.Progress.Node) !<span class="tok-type">void</span> {</span>
<span class="line" id="L40"> <span class="tok-comment">// zig fmt is fast enough that no progress is needed.</span>
</span>
<span class="line" id="L41"> _ = prog_node;</span>
<span class="line" id="L42"></span>
<span class="line" id="L43"> <span class="tok-comment">// TODO: if check=false, this means we are modifying source files in place, which</span>
</span>
<span class="line" id="L44"> <span class="tok-comment">// is an operation that could race against other operations also modifying source files</span>
</span>
<span class="line" id="L45"> <span class="tok-comment">// in place. In this case, this step should obtain a write lock while making those</span>
</span>
<span class="line" id="L46"> <span class="tok-comment">// modifications.</span>
</span>
<span class="line" id="L47"></span>
<span class="line" id="L48"> <span class="tok-kw">const</span> b = step.owner;</span>
<span class="line" id="L49"> <span class="tok-kw">const</span> arena = b.allocator;</span>
<span class="line" id="L50"> <span class="tok-kw">const</span> self = <span class="tok-builtin">@fieldParentPtr</span>(Fmt, <span class="tok-str">"step"</span>, step);</span>
<span class="line" id="L51"></span>
<span class="line" id="L52"> <span class="tok-kw">var</span> argv: std.ArrayListUnmanaged([]<span class="tok-kw">const</span> <span class="tok-type">u8</span>) = .{};</span>
<span class="line" id="L53"> <span class="tok-kw">try</span> argv.ensureUnusedCapacity(arena, <span class="tok-number">2</span> + <span class="tok-number">1</span> + self.paths.len + <span class="tok-number">2</span> * self.exclude_paths.len);</span>
<span class="line" id="L54"></span>
<span class="line" id="L55"> argv.appendAssumeCapacity(b.zig_exe);</span>
<span class="line" id="L56"> argv.appendAssumeCapacity(<span class="tok-str">"fmt"</span>);</span>
<span class="line" id="L57"></span>
<span class="line" id="L58"> <span class="tok-kw">if</span> (self.check) {</span>
<span class="line" id="L59"> argv.appendAssumeCapacity(<span class="tok-str">"--check"</span>);</span>
<span class="line" id="L60"> }</span>
<span class="line" id="L61"></span>
<span class="line" id="L62"> <span class="tok-kw">for</span> (self.paths) |p| {</span>
<span class="line" id="L63"> argv.appendAssumeCapacity(b.pathFromRoot(p));</span>
<span class="line" id="L64"> }</span>
<span class="line" id="L65"></span>
<span class="line" id="L66"> <span class="tok-kw">for</span> (self.exclude_paths) |p| {</span>
<span class="line" id="L67"> argv.appendAssumeCapacity(<span class="tok-str">"--exclude"</span>);</span>
<span class="line" id="L68"> argv.appendAssumeCapacity(b.pathFromRoot(p));</span>
<span class="line" id="L69"> }</span>
<span class="line" id="L70"></span>
<span class="line" id="L71"> <span class="tok-kw">return</span> step.evalChildProcess(argv.items);</span>
<span class="line" id="L72">}</span>
<span class="line" id="L73"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std/Build | repos/yazap/docs/src/std/Build/Step/InstallArtifact.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>Build/Step/InstallArtifact.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"std"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> Step = std.Build.Step;</span>
<span class="line" id="L3"><span class="tok-kw">const</span> InstallDir = std.Build.InstallDir;</span>
<span class="line" id="L4"><span class="tok-kw">const</span> InstallArtifact = <span class="tok-builtin">@This</span>();</span>
<span class="line" id="L5"><span class="tok-kw">const</span> fs = std.fs;</span>
<span class="line" id="L6"></span>
<span class="line" id="L7"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> base_id = .install_artifact;</span>
<span class="line" id="L8"></span>
<span class="line" id="L9">step: Step,</span>
<span class="line" id="L10">artifact: *Step.Compile,</span>
<span class="line" id="L11">dest_dir: InstallDir,</span>
<span class="line" id="L12">pdb_dir: ?InstallDir,</span>
<span class="line" id="L13">h_dir: ?InstallDir,</span>
<span class="line" id="L14"><span class="tok-comment">/// If non-null, adds additional path components relative to dest_dir, and</span></span>
<span class="line" id="L15"><span class="tok-comment">/// overrides the basename of the Compile step.</span></span>
<span class="line" id="L16">dest_sub_path: ?[]<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L17"></span>
<span class="line" id="L18"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">create</span>(owner: *std.Build, artifact: *Step.Compile) *InstallArtifact {</span>
<span class="line" id="L19"> <span class="tok-kw">const</span> self = owner.allocator.create(InstallArtifact) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L20"> self.* = InstallArtifact{</span>
<span class="line" id="L21"> .step = Step.init(.{</span>
<span class="line" id="L22"> .id = base_id,</span>
<span class="line" id="L23"> .name = owner.fmt(<span class="tok-str">"install {s}"</span>, .{artifact.name}),</span>
<span class="line" id="L24"> .owner = owner,</span>
<span class="line" id="L25"> .makeFn = make,</span>
<span class="line" id="L26"> }),</span>
<span class="line" id="L27"> .artifact = artifact,</span>
<span class="line" id="L28"> .dest_dir = artifact.override_dest_dir <span class="tok-kw">orelse</span> <span class="tok-kw">switch</span> (artifact.kind) {</span>
<span class="line" id="L29"> .obj => <span class="tok-builtin">@panic</span>(<span class="tok-str">"Cannot install a .obj build artifact."</span>),</span>
<span class="line" id="L30"> .exe, .@"test" => InstallDir{ .bin = {} },</span>
<span class="line" id="L31"> .lib => InstallDir{ .lib = {} },</span>
<span class="line" id="L32"> },</span>
<span class="line" id="L33"> .pdb_dir = <span class="tok-kw">if</span> (artifact.producesPdbFile()) blk: {</span>
<span class="line" id="L34"> <span class="tok-kw">if</span> (artifact.kind == .exe <span class="tok-kw">or</span> artifact.kind == .@"test") {</span>
<span class="line" id="L35"> <span class="tok-kw">break</span> :blk InstallDir{ .bin = {} };</span>
<span class="line" id="L36"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L37"> <span class="tok-kw">break</span> :blk InstallDir{ .lib = {} };</span>
<span class="line" id="L38"> }</span>
<span class="line" id="L39"> } <span class="tok-kw">else</span> <span class="tok-null">null</span>,</span>
<span class="line" id="L40"> .h_dir = <span class="tok-kw">if</span> (artifact.kind == .lib <span class="tok-kw">and</span> artifact.emit_h) .header <span class="tok-kw">else</span> <span class="tok-null">null</span>,</span>
<span class="line" id="L41"> .dest_sub_path = <span class="tok-null">null</span>,</span>
<span class="line" id="L42"> };</span>
<span class="line" id="L43"> self.step.dependOn(&artifact.step);</span>
<span class="line" id="L44"></span>
<span class="line" id="L45"> owner.pushInstalledFile(self.dest_dir, artifact.out_filename);</span>
<span class="line" id="L46"> <span class="tok-kw">if</span> (self.artifact.isDynamicLibrary()) {</span>
<span class="line" id="L47"> <span class="tok-kw">if</span> (artifact.major_only_filename) |name| {</span>
<span class="line" id="L48"> owner.pushInstalledFile(.lib, name);</span>
<span class="line" id="L49"> }</span>
<span class="line" id="L50"> <span class="tok-kw">if</span> (artifact.name_only_filename) |name| {</span>
<span class="line" id="L51"> owner.pushInstalledFile(.lib, name);</span>
<span class="line" id="L52"> }</span>
<span class="line" id="L53"> <span class="tok-kw">if</span> (self.artifact.target.isWindows()) {</span>
<span class="line" id="L54"> owner.pushInstalledFile(.lib, artifact.out_lib_filename);</span>
<span class="line" id="L55"> }</span>
<span class="line" id="L56"> }</span>
<span class="line" id="L57"> <span class="tok-kw">if</span> (self.pdb_dir) |pdb_dir| {</span>
<span class="line" id="L58"> owner.pushInstalledFile(pdb_dir, artifact.out_pdb_filename);</span>
<span class="line" id="L59"> }</span>
<span class="line" id="L60"> <span class="tok-kw">if</span> (self.h_dir) |h_dir| {</span>
<span class="line" id="L61"> owner.pushInstalledFile(h_dir, artifact.out_h_filename);</span>
<span class="line" id="L62"> }</span>
<span class="line" id="L63"> <span class="tok-kw">return</span> self;</span>
<span class="line" id="L64">}</span>
<span class="line" id="L65"></span>
<span class="line" id="L66"><span class="tok-kw">fn</span> <span class="tok-fn">make</span>(step: *Step, prog_node: *std.Progress.Node) !<span class="tok-type">void</span> {</span>
<span class="line" id="L67"> _ = prog_node;</span>
<span class="line" id="L68"> <span class="tok-kw">const</span> self = <span class="tok-builtin">@fieldParentPtr</span>(InstallArtifact, <span class="tok-str">"step"</span>, step);</span>
<span class="line" id="L69"> <span class="tok-kw">const</span> src_builder = self.artifact.step.owner;</span>
<span class="line" id="L70"> <span class="tok-kw">const</span> dest_builder = step.owner;</span>
<span class="line" id="L71"></span>
<span class="line" id="L72"> <span class="tok-kw">const</span> dest_sub_path = <span class="tok-kw">if</span> (self.dest_sub_path) |sub_path| sub_path <span class="tok-kw">else</span> self.artifact.out_filename;</span>
<span class="line" id="L73"> <span class="tok-kw">const</span> full_dest_path = dest_builder.getInstallPath(self.dest_dir, dest_sub_path);</span>
<span class="line" id="L74"> <span class="tok-kw">const</span> cwd = fs.cwd();</span>
<span class="line" id="L75"></span>
<span class="line" id="L76"> <span class="tok-kw">var</span> all_cached = <span class="tok-null">true</span>;</span>
<span class="line" id="L77"></span>
<span class="line" id="L78"> {</span>
<span class="line" id="L79"> <span class="tok-kw">const</span> full_src_path = self.artifact.getOutputSource().getPath(src_builder);</span>
<span class="line" id="L80"> <span class="tok-kw">const</span> p = fs.Dir.updateFile(cwd, full_src_path, cwd, full_dest_path, .{}) <span class="tok-kw">catch</span> |err| {</span>
<span class="line" id="L81"> <span class="tok-kw">return</span> step.fail(<span class="tok-str">"unable to update file from '{s}' to '{s}': {s}"</span>, .{</span>
<span class="line" id="L82"> full_src_path, full_dest_path, <span class="tok-builtin">@errorName</span>(err),</span>
<span class="line" id="L83"> });</span>
<span class="line" id="L84"> };</span>
<span class="line" id="L85"> all_cached = all_cached <span class="tok-kw">and</span> p == .fresh;</span>
<span class="line" id="L86"> }</span>
<span class="line" id="L87"></span>
<span class="line" id="L88"> <span class="tok-kw">if</span> (self.artifact.isDynamicLibrary() <span class="tok-kw">and</span></span>
<span class="line" id="L89"> self.artifact.version != <span class="tok-null">null</span> <span class="tok-kw">and</span></span>
<span class="line" id="L90"> self.artifact.target.wantSharedLibSymLinks())</span>
<span class="line" id="L91"> {</span>
<span class="line" id="L92"> <span class="tok-kw">try</span> Step.Compile.doAtomicSymLinks(step, full_dest_path, self.artifact.major_only_filename.?, self.artifact.name_only_filename.?);</span>
<span class="line" id="L93"> }</span>
<span class="line" id="L94"> <span class="tok-kw">if</span> (self.artifact.isDynamicLibrary() <span class="tok-kw">and</span></span>
<span class="line" id="L95"> self.artifact.target.isWindows() <span class="tok-kw">and</span></span>
<span class="line" id="L96"> self.artifact.emit_implib != .no_emit)</span>
<span class="line" id="L97"> {</span>
<span class="line" id="L98"> <span class="tok-kw">const</span> full_src_path = self.artifact.getOutputLibSource().getPath(src_builder);</span>
<span class="line" id="L99"> <span class="tok-kw">const</span> full_implib_path = dest_builder.getInstallPath(self.dest_dir, self.artifact.out_lib_filename);</span>
<span class="line" id="L100"> <span class="tok-kw">const</span> p = fs.Dir.updateFile(cwd, full_src_path, cwd, full_implib_path, .{}) <span class="tok-kw">catch</span> |err| {</span>
<span class="line" id="L101"> <span class="tok-kw">return</span> step.fail(<span class="tok-str">"unable to update file from '{s}' to '{s}': {s}"</span>, .{</span>
<span class="line" id="L102"> full_src_path, full_implib_path, <span class="tok-builtin">@errorName</span>(err),</span>
<span class="line" id="L103"> });</span>
<span class="line" id="L104"> };</span>
<span class="line" id="L105"> all_cached = all_cached <span class="tok-kw">and</span> p == .fresh;</span>
<span class="line" id="L106"> }</span>
<span class="line" id="L107"> <span class="tok-kw">if</span> (self.pdb_dir) |pdb_dir| {</span>
<span class="line" id="L108"> <span class="tok-kw">const</span> full_src_path = self.artifact.getOutputPdbSource().getPath(src_builder);</span>
<span class="line" id="L109"> <span class="tok-kw">const</span> full_pdb_path = dest_builder.getInstallPath(pdb_dir, self.artifact.out_pdb_filename);</span>
<span class="line" id="L110"> <span class="tok-kw">const</span> p = fs.Dir.updateFile(cwd, full_src_path, cwd, full_pdb_path, .{}) <span class="tok-kw">catch</span> |err| {</span>
<span class="line" id="L111"> <span class="tok-kw">return</span> step.fail(<span class="tok-str">"unable to update file from '{s}' to '{s}': {s}"</span>, .{</span>
<span class="line" id="L112"> full_src_path, full_pdb_path, <span class="tok-builtin">@errorName</span>(err),</span>
<span class="line" id="L113"> });</span>
<span class="line" id="L114"> };</span>
<span class="line" id="L115"> all_cached = all_cached <span class="tok-kw">and</span> p == .fresh;</span>
<span class="line" id="L116"> }</span>
<span class="line" id="L117"> <span class="tok-kw">if</span> (self.h_dir) |h_dir| {</span>
<span class="line" id="L118"> <span class="tok-kw">const</span> full_src_path = self.artifact.getOutputHSource().getPath(src_builder);</span>
<span class="line" id="L119"> <span class="tok-kw">const</span> full_h_path = dest_builder.getInstallPath(h_dir, self.artifact.out_h_filename);</span>
<span class="line" id="L120"> <span class="tok-kw">const</span> p = fs.Dir.updateFile(cwd, full_src_path, cwd, full_h_path, .{}) <span class="tok-kw">catch</span> |err| {</span>
<span class="line" id="L121"> <span class="tok-kw">return</span> step.fail(<span class="tok-str">"unable to update file from '{s}' to '{s}': {s}"</span>, .{</span>
<span class="line" id="L122"> full_src_path, full_h_path, <span class="tok-builtin">@errorName</span>(err),</span>
<span class="line" id="L123"> });</span>
<span class="line" id="L124"> };</span>
<span class="line" id="L125"> all_cached = all_cached <span class="tok-kw">and</span> p == .fresh;</span>
<span class="line" id="L126"> }</span>
<span class="line" id="L127"> self.artifact.installed_path = full_dest_path;</span>
<span class="line" id="L128"> step.result_cached = all_cached;</span>
<span class="line" id="L129">}</span>
<span class="line" id="L130"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std/Build | repos/yazap/docs/src/std/Build/Step/TranslateC.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>Build/Step/TranslateC.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"std"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> Step = std.Build.Step;</span>
<span class="line" id="L3"><span class="tok-kw">const</span> fs = std.fs;</span>
<span class="line" id="L4"><span class="tok-kw">const</span> mem = std.mem;</span>
<span class="line" id="L5"><span class="tok-kw">const</span> CrossTarget = std.zig.CrossTarget;</span>
<span class="line" id="L6"></span>
<span class="line" id="L7"><span class="tok-kw">const</span> TranslateC = <span class="tok-builtin">@This</span>();</span>
<span class="line" id="L8"></span>
<span class="line" id="L9"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> base_id = .translate_c;</span>
<span class="line" id="L10"></span>
<span class="line" id="L11">step: Step,</span>
<span class="line" id="L12">source: std.Build.FileSource,</span>
<span class="line" id="L13">include_dirs: std.ArrayList([]<span class="tok-kw">const</span> <span class="tok-type">u8</span>),</span>
<span class="line" id="L14">c_macros: std.ArrayList([]<span class="tok-kw">const</span> <span class="tok-type">u8</span>),</span>
<span class="line" id="L15">out_basename: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L16">target: CrossTarget,</span>
<span class="line" id="L17">optimize: std.builtin.OptimizeMode,</span>
<span class="line" id="L18">output_file: std.Build.GeneratedFile,</span>
<span class="line" id="L19"></span>
<span class="line" id="L20"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> Options = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L21"> source_file: std.Build.FileSource,</span>
<span class="line" id="L22"> target: CrossTarget,</span>
<span class="line" id="L23"> optimize: std.builtin.OptimizeMode,</span>
<span class="line" id="L24">};</span>
<span class="line" id="L25"></span>
<span class="line" id="L26"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">create</span>(owner: *std.Build, options: Options) *TranslateC {</span>
<span class="line" id="L27"> <span class="tok-kw">const</span> self = owner.allocator.create(TranslateC) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L28"> <span class="tok-kw">const</span> source = options.source_file.dupe(owner);</span>
<span class="line" id="L29"> self.* = TranslateC{</span>
<span class="line" id="L30"> .step = Step.init(.{</span>
<span class="line" id="L31"> .id = .translate_c,</span>
<span class="line" id="L32"> .name = <span class="tok-str">"translate-c"</span>,</span>
<span class="line" id="L33"> .owner = owner,</span>
<span class="line" id="L34"> .makeFn = make,</span>
<span class="line" id="L35"> }),</span>
<span class="line" id="L36"> .source = source,</span>
<span class="line" id="L37"> .include_dirs = std.ArrayList([]<span class="tok-kw">const</span> <span class="tok-type">u8</span>).init(owner.allocator),</span>
<span class="line" id="L38"> .c_macros = std.ArrayList([]<span class="tok-kw">const</span> <span class="tok-type">u8</span>).init(owner.allocator),</span>
<span class="line" id="L39"> .out_basename = <span class="tok-null">undefined</span>,</span>
<span class="line" id="L40"> .target = options.target,</span>
<span class="line" id="L41"> .optimize = options.optimize,</span>
<span class="line" id="L42"> .output_file = std.Build.GeneratedFile{ .step = &self.step },</span>
<span class="line" id="L43"> };</span>
<span class="line" id="L44"> source.addStepDependencies(&self.step);</span>
<span class="line" id="L45"> <span class="tok-kw">return</span> self;</span>
<span class="line" id="L46">}</span>
<span class="line" id="L47"></span>
<span class="line" id="L48"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> AddExecutableOptions = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L49"> name: ?[]<span class="tok-kw">const</span> <span class="tok-type">u8</span> = <span class="tok-null">null</span>,</span>
<span class="line" id="L50"> version: ?std.SemanticVersion = <span class="tok-null">null</span>,</span>
<span class="line" id="L51"> target: ?CrossTarget = <span class="tok-null">null</span>,</span>
<span class="line" id="L52"> optimize: ?std.builtin.Mode = <span class="tok-null">null</span>,</span>
<span class="line" id="L53"> linkage: ?Step.Compile.Linkage = <span class="tok-null">null</span>,</span>
<span class="line" id="L54">};</span>
<span class="line" id="L55"></span>
<span class="line" id="L56"><span class="tok-comment">/// Creates a step to build an executable from the translated source.</span></span>
<span class="line" id="L57"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addExecutable</span>(self: *TranslateC, options: AddExecutableOptions) *Step.Compile {</span>
<span class="line" id="L58"> <span class="tok-kw">return</span> self.step.owner.addExecutable(.{</span>
<span class="line" id="L59"> .root_source_file = .{ .generated = &self.output_file },</span>
<span class="line" id="L60"> .name = options.name <span class="tok-kw">orelse</span> <span class="tok-str">"translated_c"</span>,</span>
<span class="line" id="L61"> .version = options.version,</span>
<span class="line" id="L62"> .target = options.target <span class="tok-kw">orelse</span> self.target,</span>
<span class="line" id="L63"> .optimize = options.optimize <span class="tok-kw">orelse</span> self.optimize,</span>
<span class="line" id="L64"> .linkage = options.linkage,</span>
<span class="line" id="L65"> });</span>
<span class="line" id="L66">}</span>
<span class="line" id="L67"></span>
<span class="line" id="L68"><span class="tok-comment">/// Creates a module from the translated source and adds it to the package's</span></span>
<span class="line" id="L69"><span class="tok-comment">/// module set making it available to other packages which depend on this one.</span></span>
<span class="line" id="L70"><span class="tok-comment">/// `createModule` can be used instead to create a private module.</span></span>
<span class="line" id="L71"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addModule</span>(self: *TranslateC, name: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) *std.Build.Module {</span>
<span class="line" id="L72"> <span class="tok-kw">return</span> self.step.owner.addModule(name, .{</span>
<span class="line" id="L73"> .source_file = .{ .generated = &self.output_file },</span>
<span class="line" id="L74"> });</span>
<span class="line" id="L75">}</span>
<span class="line" id="L76"></span>
<span class="line" id="L77"><span class="tok-comment">/// Creates a private module from the translated source to be used by the</span></span>
<span class="line" id="L78"><span class="tok-comment">/// current package, but not exposed to other packages depending on this one.</span></span>
<span class="line" id="L79"><span class="tok-comment">/// `addModule` can be used instead to create a public module.</span></span>
<span class="line" id="L80"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">createModule</span>(self: *TranslateC) *std.Build.Module {</span>
<span class="line" id="L81"> <span class="tok-kw">const</span> b = self.step.owner;</span>
<span class="line" id="L82"> <span class="tok-kw">const</span> module = b.allocator.create(std.Build.Module) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L83"></span>
<span class="line" id="L84"> module.* = .{</span>
<span class="line" id="L85"> .builder = b,</span>
<span class="line" id="L86"> .source_file = .{ .generated = &self.output_file },</span>
<span class="line" id="L87"> .dependencies = std.StringArrayHashMap(*std.Build.Module).init(b.allocator),</span>
<span class="line" id="L88"> };</span>
<span class="line" id="L89"> <span class="tok-kw">return</span> module;</span>
<span class="line" id="L90">}</span>
<span class="line" id="L91"></span>
<span class="line" id="L92"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addIncludeDir</span>(self: *TranslateC, include_dir: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L93"> self.include_dirs.append(self.step.owner.dupePath(include_dir)) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L94">}</span>
<span class="line" id="L95"></span>
<span class="line" id="L96"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addCheckFile</span>(self: *TranslateC, expected_matches: []<span class="tok-kw">const</span> []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) *Step.CheckFile {</span>
<span class="line" id="L97"> <span class="tok-kw">return</span> Step.CheckFile.create(</span>
<span class="line" id="L98"> self.step.owner,</span>
<span class="line" id="L99"> .{ .generated = &self.output_file },</span>
<span class="line" id="L100"> .{ .expected_matches = expected_matches },</span>
<span class="line" id="L101"> );</span>
<span class="line" id="L102">}</span>
<span class="line" id="L103"></span>
<span class="line" id="L104"><span class="tok-comment">/// If the value is omitted, it is set to 1.</span></span>
<span class="line" id="L105"><span class="tok-comment">/// `name` and `value` need not live longer than the function call.</span></span>
<span class="line" id="L106"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">defineCMacro</span>(self: *TranslateC, name: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>, value: ?[]<span class="tok-kw">const</span> <span class="tok-type">u8</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L107"> <span class="tok-kw">const</span> macro = std.Build.constructCMacro(self.step.owner.allocator, name, value);</span>
<span class="line" id="L108"> self.c_macros.append(macro) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L109">}</span>
<span class="line" id="L110"></span>
<span class="line" id="L111"><span class="tok-comment">/// name_and_value looks like [name]=[value]. If the value is omitted, it is set to 1.</span></span>
<span class="line" id="L112"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">defineCMacroRaw</span>(self: *TranslateC, name_and_value: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L113"> self.c_macros.append(self.step.owner.dupe(name_and_value)) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L114">}</span>
<span class="line" id="L115"></span>
<span class="line" id="L116"><span class="tok-kw">fn</span> <span class="tok-fn">make</span>(step: *Step, prog_node: *std.Progress.Node) !<span class="tok-type">void</span> {</span>
<span class="line" id="L117"> <span class="tok-kw">const</span> b = step.owner;</span>
<span class="line" id="L118"> <span class="tok-kw">const</span> self = <span class="tok-builtin">@fieldParentPtr</span>(TranslateC, <span class="tok-str">"step"</span>, step);</span>
<span class="line" id="L119"></span>
<span class="line" id="L120"> <span class="tok-kw">var</span> argv_list = std.ArrayList([]<span class="tok-kw">const</span> <span class="tok-type">u8</span>).init(b.allocator);</span>
<span class="line" id="L121"> <span class="tok-kw">try</span> argv_list.append(b.zig_exe);</span>
<span class="line" id="L122"> <span class="tok-kw">try</span> argv_list.append(<span class="tok-str">"translate-c"</span>);</span>
<span class="line" id="L123"> <span class="tok-kw">try</span> argv_list.append(<span class="tok-str">"-lc"</span>);</span>
<span class="line" id="L124"></span>
<span class="line" id="L125"> <span class="tok-kw">try</span> argv_list.append(<span class="tok-str">"--listen=-"</span>);</span>
<span class="line" id="L126"></span>
<span class="line" id="L127"> <span class="tok-kw">if</span> (!self.target.isNative()) {</span>
<span class="line" id="L128"> <span class="tok-kw">try</span> argv_list.append(<span class="tok-str">"-target"</span>);</span>
<span class="line" id="L129"> <span class="tok-kw">try</span> argv_list.append(<span class="tok-kw">try</span> self.target.zigTriple(b.allocator));</span>
<span class="line" id="L130"> }</span>
<span class="line" id="L131"></span>
<span class="line" id="L132"> <span class="tok-kw">switch</span> (self.optimize) {</span>
<span class="line" id="L133"> .Debug => {}, <span class="tok-comment">// Skip since it's the default.</span>
</span>
<span class="line" id="L134"> <span class="tok-kw">else</span> => <span class="tok-kw">try</span> argv_list.append(b.fmt(<span class="tok-str">"-O{s}"</span>, .{<span class="tok-builtin">@tagName</span>(self.optimize)})),</span>
<span class="line" id="L135"> }</span>
<span class="line" id="L136"></span>
<span class="line" id="L137"> <span class="tok-kw">for</span> (self.include_dirs.items) |include_dir| {</span>
<span class="line" id="L138"> <span class="tok-kw">try</span> argv_list.append(<span class="tok-str">"-I"</span>);</span>
<span class="line" id="L139"> <span class="tok-kw">try</span> argv_list.append(include_dir);</span>
<span class="line" id="L140"> }</span>
<span class="line" id="L141"></span>
<span class="line" id="L142"> <span class="tok-kw">for</span> (self.c_macros.items) |c_macro| {</span>
<span class="line" id="L143"> <span class="tok-kw">try</span> argv_list.append(<span class="tok-str">"-D"</span>);</span>
<span class="line" id="L144"> <span class="tok-kw">try</span> argv_list.append(c_macro);</span>
<span class="line" id="L145"> }</span>
<span class="line" id="L146"></span>
<span class="line" id="L147"> <span class="tok-kw">try</span> argv_list.append(self.source.getPath(b));</span>
<span class="line" id="L148"></span>
<span class="line" id="L149"> <span class="tok-kw">const</span> output_path = <span class="tok-kw">try</span> step.evalZigProcess(argv_list.items, prog_node);</span>
<span class="line" id="L150"></span>
<span class="line" id="L151"> self.out_basename = fs.path.basename(output_path);</span>
<span class="line" id="L152"> <span class="tok-kw">const</span> output_dir = fs.path.dirname(output_path).?;</span>
<span class="line" id="L153"></span>
<span class="line" id="L154"> self.output_file.path = <span class="tok-kw">try</span> fs.path.join(</span>
<span class="line" id="L155"> b.allocator,</span>
<span class="line" id="L156"> &[_][]<span class="tok-kw">const</span> <span class="tok-type">u8</span>{ output_dir, self.out_basename },</span>
<span class="line" id="L157"> );</span>
<span class="line" id="L158">}</span>
<span class="line" id="L159"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std/Build | repos/yazap/docs/src/std/Build/Step/InstallDir.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>Build/Step/InstallDir.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"std"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> mem = std.mem;</span>
<span class="line" id="L3"><span class="tok-kw">const</span> fs = std.fs;</span>
<span class="line" id="L4"><span class="tok-kw">const</span> Step = std.Build.Step;</span>
<span class="line" id="L5"><span class="tok-kw">const</span> FileSource = std.Build.FileSource;</span>
<span class="line" id="L6"><span class="tok-kw">const</span> InstallDir = std.Build.InstallDir;</span>
<span class="line" id="L7"><span class="tok-kw">const</span> InstallDirStep = <span class="tok-builtin">@This</span>();</span>
<span class="line" id="L8"></span>
<span class="line" id="L9">step: Step,</span>
<span class="line" id="L10">options: Options,</span>
<span class="line" id="L11"><span class="tok-comment">/// This is used by the build system when a file being installed comes from one</span></span>
<span class="line" id="L12"><span class="tok-comment">/// package but is being installed by another.</span></span>
<span class="line" id="L13">dest_builder: *std.Build,</span>
<span class="line" id="L14"></span>
<span class="line" id="L15"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> base_id = .install_dir;</span>
<span class="line" id="L16"></span>
<span class="line" id="L17"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> Options = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L18"> source_dir: FileSource,</span>
<span class="line" id="L19"> install_dir: InstallDir,</span>
<span class="line" id="L20"> install_subdir: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L21"> <span class="tok-comment">/// File paths which end in any of these suffixes will be excluded</span></span>
<span class="line" id="L22"> <span class="tok-comment">/// from being installed.</span></span>
<span class="line" id="L23"> exclude_extensions: []<span class="tok-kw">const</span> []<span class="tok-kw">const</span> <span class="tok-type">u8</span> = &.{},</span>
<span class="line" id="L24"> <span class="tok-comment">/// File paths which end in any of these suffixes will result in</span></span>
<span class="line" id="L25"> <span class="tok-comment">/// empty files being installed. This is mainly intended for large</span></span>
<span class="line" id="L26"> <span class="tok-comment">/// test.zig files in order to prevent needless installation bloat.</span></span>
<span class="line" id="L27"> <span class="tok-comment">/// However if the files were not present at all, then</span></span>
<span class="line" id="L28"> <span class="tok-comment">/// `@import("test.zig")` would be a compile error.</span></span>
<span class="line" id="L29"> blank_extensions: []<span class="tok-kw">const</span> []<span class="tok-kw">const</span> <span class="tok-type">u8</span> = &.{},</span>
<span class="line" id="L30"></span>
<span class="line" id="L31"> <span class="tok-kw">fn</span> <span class="tok-fn">dupe</span>(self: Options, b: *std.Build) Options {</span>
<span class="line" id="L32"> <span class="tok-kw">return</span> .{</span>
<span class="line" id="L33"> .source_dir = self.source_dir.dupe(b),</span>
<span class="line" id="L34"> .install_dir = self.install_dir.dupe(b),</span>
<span class="line" id="L35"> .install_subdir = b.dupe(self.install_subdir),</span>
<span class="line" id="L36"> .exclude_extensions = b.dupeStrings(self.exclude_extensions),</span>
<span class="line" id="L37"> .blank_extensions = b.dupeStrings(self.blank_extensions),</span>
<span class="line" id="L38"> };</span>
<span class="line" id="L39"> }</span>
<span class="line" id="L40">};</span>
<span class="line" id="L41"></span>
<span class="line" id="L42"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">create</span>(owner: *std.Build, options: Options) *InstallDirStep {</span>
<span class="line" id="L43"> owner.pushInstalledFile(options.install_dir, options.install_subdir);</span>
<span class="line" id="L44"> <span class="tok-kw">const</span> self = owner.allocator.create(InstallDirStep) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L45"> self.* = .{</span>
<span class="line" id="L46"> .step = Step.init(.{</span>
<span class="line" id="L47"> .id = .install_dir,</span>
<span class="line" id="L48"> .name = owner.fmt(<span class="tok-str">"install {s}/"</span>, .{options.source_dir.getDisplayName()}),</span>
<span class="line" id="L49"> .owner = owner,</span>
<span class="line" id="L50"> .makeFn = make,</span>
<span class="line" id="L51"> }),</span>
<span class="line" id="L52"> .options = options.dupe(owner),</span>
<span class="line" id="L53"> .dest_builder = owner,</span>
<span class="line" id="L54"> };</span>
<span class="line" id="L55"> options.source_dir.addStepDependencies(&self.step);</span>
<span class="line" id="L56"> <span class="tok-kw">return</span> self;</span>
<span class="line" id="L57">}</span>
<span class="line" id="L58"></span>
<span class="line" id="L59"><span class="tok-kw">fn</span> <span class="tok-fn">make</span>(step: *Step, prog_node: *std.Progress.Node) !<span class="tok-type">void</span> {</span>
<span class="line" id="L60"> _ = prog_node;</span>
<span class="line" id="L61"> <span class="tok-kw">const</span> self = <span class="tok-builtin">@fieldParentPtr</span>(InstallDirStep, <span class="tok-str">"step"</span>, step);</span>
<span class="line" id="L62"> <span class="tok-kw">const</span> dest_builder = self.dest_builder;</span>
<span class="line" id="L63"> <span class="tok-kw">const</span> arena = dest_builder.allocator;</span>
<span class="line" id="L64"> <span class="tok-kw">const</span> dest_prefix = dest_builder.getInstallPath(self.options.install_dir, self.options.install_subdir);</span>
<span class="line" id="L65"> <span class="tok-kw">const</span> src_builder = self.step.owner;</span>
<span class="line" id="L66"> <span class="tok-kw">const</span> src_dir_path = self.options.source_dir.getPath2(src_builder, step);</span>
<span class="line" id="L67"> <span class="tok-kw">var</span> src_dir = src_builder.build_root.handle.openIterableDir(src_dir_path, .{}) <span class="tok-kw">catch</span> |err| {</span>
<span class="line" id="L68"> <span class="tok-kw">return</span> step.fail(<span class="tok-str">"unable to open source directory '{}{s}': {s}"</span>, .{</span>
<span class="line" id="L69"> src_builder.build_root, src_dir_path, <span class="tok-builtin">@errorName</span>(err),</span>
<span class="line" id="L70"> });</span>
<span class="line" id="L71"> };</span>
<span class="line" id="L72"> <span class="tok-kw">defer</span> src_dir.close();</span>
<span class="line" id="L73"> <span class="tok-kw">var</span> it = <span class="tok-kw">try</span> src_dir.walk(arena);</span>
<span class="line" id="L74"> <span class="tok-kw">var</span> all_cached = <span class="tok-null">true</span>;</span>
<span class="line" id="L75"> next_entry: <span class="tok-kw">while</span> (<span class="tok-kw">try</span> it.next()) |entry| {</span>
<span class="line" id="L76"> <span class="tok-kw">for</span> (self.options.exclude_extensions) |ext| {</span>
<span class="line" id="L77"> <span class="tok-kw">if</span> (mem.endsWith(<span class="tok-type">u8</span>, entry.path, ext)) {</span>
<span class="line" id="L78"> <span class="tok-kw">continue</span> :next_entry;</span>
<span class="line" id="L79"> }</span>
<span class="line" id="L80"> }</span>
<span class="line" id="L81"></span>
<span class="line" id="L82"> <span class="tok-comment">// relative to src build root</span>
</span>
<span class="line" id="L83"> <span class="tok-kw">const</span> src_sub_path = <span class="tok-kw">try</span> fs.path.join(arena, &.{ src_dir_path, entry.path });</span>
<span class="line" id="L84"> <span class="tok-kw">const</span> dest_path = <span class="tok-kw">try</span> fs.path.join(arena, &.{ dest_prefix, entry.path });</span>
<span class="line" id="L85"> <span class="tok-kw">const</span> cwd = fs.cwd();</span>
<span class="line" id="L86"></span>
<span class="line" id="L87"> <span class="tok-kw">switch</span> (entry.kind) {</span>
<span class="line" id="L88"> .directory => <span class="tok-kw">try</span> cwd.makePath(dest_path),</span>
<span class="line" id="L89"> .file => {</span>
<span class="line" id="L90"> <span class="tok-kw">for</span> (self.options.blank_extensions) |ext| {</span>
<span class="line" id="L91"> <span class="tok-kw">if</span> (mem.endsWith(<span class="tok-type">u8</span>, entry.path, ext)) {</span>
<span class="line" id="L92"> <span class="tok-kw">try</span> dest_builder.truncateFile(dest_path);</span>
<span class="line" id="L93"> <span class="tok-kw">continue</span> :next_entry;</span>
<span class="line" id="L94"> }</span>
<span class="line" id="L95"> }</span>
<span class="line" id="L96"></span>
<span class="line" id="L97"> <span class="tok-kw">const</span> prev_status = fs.Dir.updateFile(</span>
<span class="line" id="L98"> src_builder.build_root.handle,</span>
<span class="line" id="L99"> src_sub_path,</span>
<span class="line" id="L100"> cwd,</span>
<span class="line" id="L101"> dest_path,</span>
<span class="line" id="L102"> .{},</span>
<span class="line" id="L103"> ) <span class="tok-kw">catch</span> |err| {</span>
<span class="line" id="L104"> <span class="tok-kw">return</span> step.fail(<span class="tok-str">"unable to update file from '{}{s}' to '{s}': {s}"</span>, .{</span>
<span class="line" id="L105"> src_builder.build_root, src_sub_path, dest_path, <span class="tok-builtin">@errorName</span>(err),</span>
<span class="line" id="L106"> });</span>
<span class="line" id="L107"> };</span>
<span class="line" id="L108"> all_cached = all_cached <span class="tok-kw">and</span> prev_status == .fresh;</span>
<span class="line" id="L109"> },</span>
<span class="line" id="L110"> <span class="tok-kw">else</span> => <span class="tok-kw">continue</span>,</span>
<span class="line" id="L111"> }</span>
<span class="line" id="L112"> }</span>
<span class="line" id="L113"></span>
<span class="line" id="L114"> step.result_cached = all_cached;</span>
<span class="line" id="L115">}</span>
<span class="line" id="L116"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std/Build | repos/yazap/docs/src/std/Build/Step/RemoveDir.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>Build/Step/RemoveDir.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"std"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> fs = std.fs;</span>
<span class="line" id="L3"><span class="tok-kw">const</span> Step = std.Build.Step;</span>
<span class="line" id="L4"><span class="tok-kw">const</span> RemoveDir = <span class="tok-builtin">@This</span>();</span>
<span class="line" id="L5"></span>
<span class="line" id="L6"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> base_id = .remove_dir;</span>
<span class="line" id="L7"></span>
<span class="line" id="L8">step: Step,</span>
<span class="line" id="L9">dir_path: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L10"></span>
<span class="line" id="L11"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">init</span>(owner: *std.Build, dir_path: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) RemoveDir {</span>
<span class="line" id="L12"> <span class="tok-kw">return</span> RemoveDir{</span>
<span class="line" id="L13"> .step = Step.init(.{</span>
<span class="line" id="L14"> .id = .remove_dir,</span>
<span class="line" id="L15"> .name = owner.fmt(<span class="tok-str">"RemoveDir {s}"</span>, .{dir_path}),</span>
<span class="line" id="L16"> .owner = owner,</span>
<span class="line" id="L17"> .makeFn = make,</span>
<span class="line" id="L18"> }),</span>
<span class="line" id="L19"> .dir_path = owner.dupePath(dir_path),</span>
<span class="line" id="L20"> };</span>
<span class="line" id="L21">}</span>
<span class="line" id="L22"></span>
<span class="line" id="L23"><span class="tok-kw">fn</span> <span class="tok-fn">make</span>(step: *Step, prog_node: *std.Progress.Node) !<span class="tok-type">void</span> {</span>
<span class="line" id="L24"> <span class="tok-comment">// TODO update progress node while walking file system.</span>
</span>
<span class="line" id="L25"> <span class="tok-comment">// Should the standard library support this use case??</span>
</span>
<span class="line" id="L26"> _ = prog_node;</span>
<span class="line" id="L27"></span>
<span class="line" id="L28"> <span class="tok-kw">const</span> b = step.owner;</span>
<span class="line" id="L29"> <span class="tok-kw">const</span> self = <span class="tok-builtin">@fieldParentPtr</span>(RemoveDir, <span class="tok-str">"step"</span>, step);</span>
<span class="line" id="L30"></span>
<span class="line" id="L31"> b.build_root.handle.deleteTree(self.dir_path) <span class="tok-kw">catch</span> |err| {</span>
<span class="line" id="L32"> <span class="tok-kw">if</span> (b.build_root.path) |base| {</span>
<span class="line" id="L33"> <span class="tok-kw">return</span> step.fail(<span class="tok-str">"unable to recursively delete path '{s}/{s}': {s}"</span>, .{</span>
<span class="line" id="L34"> base, self.dir_path, <span class="tok-builtin">@errorName</span>(err),</span>
<span class="line" id="L35"> });</span>
<span class="line" id="L36"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L37"> <span class="tok-kw">return</span> step.fail(<span class="tok-str">"unable to recursively delete path '{s}': {s}"</span>, .{</span>
<span class="line" id="L38"> self.dir_path, <span class="tok-builtin">@errorName</span>(err),</span>
<span class="line" id="L39"> });</span>
<span class="line" id="L40"> }</span>
<span class="line" id="L41"> };</span>
<span class="line" id="L42">}</span>
<span class="line" id="L43"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std/Build | repos/yazap/docs/src/std/Build/Step/WriteFile.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>Build/Step/WriteFile.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-comment">//! WriteFile is primarily used to create a directory in an appropriate</span></span>
<span class="line" id="L2"><span class="tok-comment">//! location inside the local cache which has a set of files that have either</span></span>
<span class="line" id="L3"><span class="tok-comment">//! been generated during the build, or are copied from the source package.</span></span>
<span class="line" id="L4"><span class="tok-comment">//!</span></span>
<span class="line" id="L5"><span class="tok-comment">//! However, this step has an additional capability of writing data to paths</span></span>
<span class="line" id="L6"><span class="tok-comment">//! relative to the package root, effectively mutating the package's source</span></span>
<span class="line" id="L7"><span class="tok-comment">//! files. Be careful with the latter functionality; it should not be used</span></span>
<span class="line" id="L8"><span class="tok-comment">//! during the normal build process, but as a utility run by a developer with</span></span>
<span class="line" id="L9"><span class="tok-comment">//! intention to update source files, which will then be committed to version</span></span>
<span class="line" id="L10"><span class="tok-comment">//! control.</span></span>
<span class="line" id="L11"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"std"</span>);</span>
<span class="line" id="L12"><span class="tok-kw">const</span> Step = std.Build.Step;</span>
<span class="line" id="L13"><span class="tok-kw">const</span> fs = std.fs;</span>
<span class="line" id="L14"><span class="tok-kw">const</span> ArrayList = std.ArrayList;</span>
<span class="line" id="L15"><span class="tok-kw">const</span> WriteFile = <span class="tok-builtin">@This</span>();</span>
<span class="line" id="L16"></span>
<span class="line" id="L17">step: Step,</span>
<span class="line" id="L18"><span class="tok-comment">/// The elements here are pointers because we need stable pointers for the</span></span>
<span class="line" id="L19"><span class="tok-comment">/// GeneratedFile field.</span></span>
<span class="line" id="L20">files: std.ArrayListUnmanaged(*File),</span>
<span class="line" id="L21">output_source_files: std.ArrayListUnmanaged(OutputSourceFile),</span>
<span class="line" id="L22">generated_directory: std.Build.GeneratedFile,</span>
<span class="line" id="L23"></span>
<span class="line" id="L24"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> base_id = .write_file;</span>
<span class="line" id="L25"></span>
<span class="line" id="L26"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> File = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L27"> generated_file: std.Build.GeneratedFile,</span>
<span class="line" id="L28"> sub_path: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L29"> contents: Contents,</span>
<span class="line" id="L30"></span>
<span class="line" id="L31"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">getFileSource</span>(self: *File) std.Build.FileSource {</span>
<span class="line" id="L32"> <span class="tok-kw">return</span> .{ .generated = &self.generated_file };</span>
<span class="line" id="L33"> }</span>
<span class="line" id="L34">};</span>
<span class="line" id="L35"></span>
<span class="line" id="L36"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> OutputSourceFile = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L37"> contents: Contents,</span>
<span class="line" id="L38"> sub_path: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L39">};</span>
<span class="line" id="L40"></span>
<span class="line" id="L41"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> Contents = <span class="tok-kw">union</span>(<span class="tok-kw">enum</span>) {</span>
<span class="line" id="L42"> bytes: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L43"> copy: std.Build.FileSource,</span>
<span class="line" id="L44">};</span>
<span class="line" id="L45"></span>
<span class="line" id="L46"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">create</span>(owner: *std.Build) *WriteFile {</span>
<span class="line" id="L47"> <span class="tok-kw">const</span> wf = owner.allocator.create(WriteFile) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L48"> wf.* = .{</span>
<span class="line" id="L49"> .step = Step.init(.{</span>
<span class="line" id="L50"> .id = .write_file,</span>
<span class="line" id="L51"> .name = <span class="tok-str">"WriteFile"</span>,</span>
<span class="line" id="L52"> .owner = owner,</span>
<span class="line" id="L53"> .makeFn = make,</span>
<span class="line" id="L54"> }),</span>
<span class="line" id="L55"> .files = .{},</span>
<span class="line" id="L56"> .output_source_files = .{},</span>
<span class="line" id="L57"> .generated_directory = .{ .step = &wf.step },</span>
<span class="line" id="L58"> };</span>
<span class="line" id="L59"> <span class="tok-kw">return</span> wf;</span>
<span class="line" id="L60">}</span>
<span class="line" id="L61"></span>
<span class="line" id="L62"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">add</span>(wf: *WriteFile, sub_path: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>, bytes: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) std.Build.FileSource {</span>
<span class="line" id="L63"> <span class="tok-kw">const</span> b = wf.step.owner;</span>
<span class="line" id="L64"> <span class="tok-kw">const</span> gpa = b.allocator;</span>
<span class="line" id="L65"> <span class="tok-kw">const</span> file = gpa.create(File) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L66"> file.* = .{</span>
<span class="line" id="L67"> .generated_file = .{ .step = &wf.step },</span>
<span class="line" id="L68"> .sub_path = b.dupePath(sub_path),</span>
<span class="line" id="L69"> .contents = .{ .bytes = b.dupe(bytes) },</span>
<span class="line" id="L70"> };</span>
<span class="line" id="L71"> wf.files.append(gpa, file) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L72"> wf.maybeUpdateName();</span>
<span class="line" id="L73"> <span class="tok-kw">return</span> file.getFileSource();</span>
<span class="line" id="L74">}</span>
<span class="line" id="L75"></span>
<span class="line" id="L76"><span class="tok-comment">/// Place the file into the generated directory within the local cache,</span></span>
<span class="line" id="L77"><span class="tok-comment">/// along with all the rest of the files added to this step. The parameter</span></span>
<span class="line" id="L78"><span class="tok-comment">/// here is the destination path relative to the local cache directory</span></span>
<span class="line" id="L79"><span class="tok-comment">/// associated with this WriteFile. It may be a basename, or it may</span></span>
<span class="line" id="L80"><span class="tok-comment">/// include sub-directories, in which case this step will ensure the</span></span>
<span class="line" id="L81"><span class="tok-comment">/// required sub-path exists.</span></span>
<span class="line" id="L82"><span class="tok-comment">/// This is the option expected to be used most commonly with `addCopyFile`.</span></span>
<span class="line" id="L83"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addCopyFile</span>(wf: *WriteFile, source: std.Build.FileSource, sub_path: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) std.Build.FileSource {</span>
<span class="line" id="L84"> <span class="tok-kw">const</span> b = wf.step.owner;</span>
<span class="line" id="L85"> <span class="tok-kw">const</span> gpa = b.allocator;</span>
<span class="line" id="L86"> <span class="tok-kw">const</span> file = gpa.create(File) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L87"> file.* = .{</span>
<span class="line" id="L88"> .generated_file = .{ .step = &wf.step },</span>
<span class="line" id="L89"> .sub_path = b.dupePath(sub_path),</span>
<span class="line" id="L90"> .contents = .{ .copy = source },</span>
<span class="line" id="L91"> };</span>
<span class="line" id="L92"> wf.files.append(gpa, file) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L93"></span>
<span class="line" id="L94"> wf.maybeUpdateName();</span>
<span class="line" id="L95"> source.addStepDependencies(&wf.step);</span>
<span class="line" id="L96"> <span class="tok-kw">return</span> file.getFileSource();</span>
<span class="line" id="L97">}</span>
<span class="line" id="L98"></span>
<span class="line" id="L99"><span class="tok-comment">/// A path relative to the package root.</span></span>
<span class="line" id="L100"><span class="tok-comment">/// Be careful with this because it updates source files. This should not be</span></span>
<span class="line" id="L101"><span class="tok-comment">/// used as part of the normal build process, but as a utility occasionally</span></span>
<span class="line" id="L102"><span class="tok-comment">/// run by a developer with intent to modify source files and then commit</span></span>
<span class="line" id="L103"><span class="tok-comment">/// those changes to version control.</span></span>
<span class="line" id="L104"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addCopyFileToSource</span>(wf: *WriteFile, source: std.Build.FileSource, sub_path: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L105"> <span class="tok-kw">const</span> b = wf.step.owner;</span>
<span class="line" id="L106"> wf.output_source_files.append(b.allocator, .{</span>
<span class="line" id="L107"> .contents = .{ .copy = source },</span>
<span class="line" id="L108"> .sub_path = sub_path,</span>
<span class="line" id="L109"> }) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L110"> source.addStepDependencies(&wf.step);</span>
<span class="line" id="L111">}</span>
<span class="line" id="L112"></span>
<span class="line" id="L113"><span class="tok-comment">/// A path relative to the package root.</span></span>
<span class="line" id="L114"><span class="tok-comment">/// Be careful with this because it updates source files. This should not be</span></span>
<span class="line" id="L115"><span class="tok-comment">/// used as part of the normal build process, but as a utility occasionally</span></span>
<span class="line" id="L116"><span class="tok-comment">/// run by a developer with intent to modify source files and then commit</span></span>
<span class="line" id="L117"><span class="tok-comment">/// those changes to version control.</span></span>
<span class="line" id="L118"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addBytesToSource</span>(wf: *WriteFile, bytes: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>, sub_path: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L119"> <span class="tok-kw">const</span> b = wf.step.owner;</span>
<span class="line" id="L120"> wf.output_source_files.append(b.allocator, .{</span>
<span class="line" id="L121"> .contents = .{ .bytes = bytes },</span>
<span class="line" id="L122"> .sub_path = sub_path,</span>
<span class="line" id="L123"> }) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L124">}</span>
<span class="line" id="L125"></span>
<span class="line" id="L126"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> getFileSource = <span class="tok-builtin">@compileError</span>(<span class="tok-str">"Deprecated; use the return value from add()/addCopyFile(), or use files[i].getFileSource()"</span>);</span>
<span class="line" id="L127"></span>
<span class="line" id="L128"><span class="tok-comment">/// Returns a `FileSource` representing the base directory that contains all the</span></span>
<span class="line" id="L129"><span class="tok-comment">/// files from this `WriteFile`.</span></span>
<span class="line" id="L130"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">getDirectorySource</span>(wf: *WriteFile) std.Build.FileSource {</span>
<span class="line" id="L131"> <span class="tok-kw">return</span> .{ .generated = &wf.generated_directory };</span>
<span class="line" id="L132">}</span>
<span class="line" id="L133"></span>
<span class="line" id="L134"><span class="tok-kw">fn</span> <span class="tok-fn">maybeUpdateName</span>(wf: *WriteFile) <span class="tok-type">void</span> {</span>
<span class="line" id="L135"> <span class="tok-kw">if</span> (wf.files.items.len == <span class="tok-number">1</span>) {</span>
<span class="line" id="L136"> <span class="tok-comment">// First time adding a file; update name.</span>
</span>
<span class="line" id="L137"> <span class="tok-kw">if</span> (std.mem.eql(<span class="tok-type">u8</span>, wf.step.name, <span class="tok-str">"WriteFile"</span>)) {</span>
<span class="line" id="L138"> wf.step.name = wf.step.owner.fmt(<span class="tok-str">"WriteFile {s}"</span>, .{wf.files.items[<span class="tok-number">0</span>].sub_path});</span>
<span class="line" id="L139"> }</span>
<span class="line" id="L140"> }</span>
<span class="line" id="L141">}</span>
<span class="line" id="L142"></span>
<span class="line" id="L143"><span class="tok-kw">fn</span> <span class="tok-fn">make</span>(step: *Step, prog_node: *std.Progress.Node) !<span class="tok-type">void</span> {</span>
<span class="line" id="L144"> _ = prog_node;</span>
<span class="line" id="L145"> <span class="tok-kw">const</span> b = step.owner;</span>
<span class="line" id="L146"> <span class="tok-kw">const</span> wf = <span class="tok-builtin">@fieldParentPtr</span>(WriteFile, <span class="tok-str">"step"</span>, step);</span>
<span class="line" id="L147"></span>
<span class="line" id="L148"> <span class="tok-comment">// Writing to source files is kind of an extra capability of this</span>
</span>
<span class="line" id="L149"> <span class="tok-comment">// WriteFile - arguably it should be a different step. But anyway here</span>
</span>
<span class="line" id="L150"> <span class="tok-comment">// it is, it happens unconditionally and does not interact with the other</span>
</span>
<span class="line" id="L151"> <span class="tok-comment">// files here.</span>
</span>
<span class="line" id="L152"> <span class="tok-kw">var</span> any_miss = <span class="tok-null">false</span>;</span>
<span class="line" id="L153"> <span class="tok-kw">for</span> (wf.output_source_files.items) |output_source_file| {</span>
<span class="line" id="L154"> <span class="tok-kw">if</span> (fs.path.dirname(output_source_file.sub_path)) |dirname| {</span>
<span class="line" id="L155"> b.build_root.handle.makePath(dirname) <span class="tok-kw">catch</span> |err| {</span>
<span class="line" id="L156"> <span class="tok-kw">return</span> step.fail(<span class="tok-str">"unable to make path '{}{s}': {s}"</span>, .{</span>
<span class="line" id="L157"> b.build_root, dirname, <span class="tok-builtin">@errorName</span>(err),</span>
<span class="line" id="L158"> });</span>
<span class="line" id="L159"> };</span>
<span class="line" id="L160"> }</span>
<span class="line" id="L161"> <span class="tok-kw">switch</span> (output_source_file.contents) {</span>
<span class="line" id="L162"> .bytes => |bytes| {</span>
<span class="line" id="L163"> b.build_root.handle.writeFile(output_source_file.sub_path, bytes) <span class="tok-kw">catch</span> |err| {</span>
<span class="line" id="L164"> <span class="tok-kw">return</span> step.fail(<span class="tok-str">"unable to write file '{}{s}': {s}"</span>, .{</span>
<span class="line" id="L165"> b.build_root, output_source_file.sub_path, <span class="tok-builtin">@errorName</span>(err),</span>
<span class="line" id="L166"> });</span>
<span class="line" id="L167"> };</span>
<span class="line" id="L168"> any_miss = <span class="tok-null">true</span>;</span>
<span class="line" id="L169"> },</span>
<span class="line" id="L170"> .copy => |file_source| {</span>
<span class="line" id="L171"> <span class="tok-kw">const</span> source_path = file_source.getPath(b);</span>
<span class="line" id="L172"> <span class="tok-kw">const</span> prev_status = fs.Dir.updateFile(</span>
<span class="line" id="L173"> fs.cwd(),</span>
<span class="line" id="L174"> source_path,</span>
<span class="line" id="L175"> b.build_root.handle,</span>
<span class="line" id="L176"> output_source_file.sub_path,</span>
<span class="line" id="L177"> .{},</span>
<span class="line" id="L178"> ) <span class="tok-kw">catch</span> |err| {</span>
<span class="line" id="L179"> <span class="tok-kw">return</span> step.fail(<span class="tok-str">"unable to update file from '{s}' to '{}{s}': {s}"</span>, .{</span>
<span class="line" id="L180"> source_path, b.build_root, output_source_file.sub_path, <span class="tok-builtin">@errorName</span>(err),</span>
<span class="line" id="L181"> });</span>
<span class="line" id="L182"> };</span>
<span class="line" id="L183"> any_miss = any_miss <span class="tok-kw">or</span> prev_status == .stale;</span>
<span class="line" id="L184"> },</span>
<span class="line" id="L185"> }</span>
<span class="line" id="L186"> }</span>
<span class="line" id="L187"></span>
<span class="line" id="L188"> <span class="tok-comment">// The cache is used here not really as a way to speed things up - because writing</span>
</span>
<span class="line" id="L189"> <span class="tok-comment">// the data to a file would probably be very fast - but as a way to find a canonical</span>
</span>
<span class="line" id="L190"> <span class="tok-comment">// location to put build artifacts.</span>
</span>
<span class="line" id="L191"></span>
<span class="line" id="L192"> <span class="tok-comment">// If, for example, a hard-coded path was used as the location to put WriteFile</span>
</span>
<span class="line" id="L193"> <span class="tok-comment">// files, then two WriteFiles executing in parallel might clobber each other.</span>
</span>
<span class="line" id="L194"></span>
<span class="line" id="L195"> <span class="tok-kw">var</span> man = b.cache.obtain();</span>
<span class="line" id="L196"> <span class="tok-kw">defer</span> man.deinit();</span>
<span class="line" id="L197"></span>
<span class="line" id="L198"> <span class="tok-comment">// Random bytes to make WriteFile unique. Refresh this with</span>
</span>
<span class="line" id="L199"> <span class="tok-comment">// new random bytes when WriteFile implementation is modified</span>
</span>
<span class="line" id="L200"> <span class="tok-comment">// in a non-backwards-compatible way.</span>
</span>
<span class="line" id="L201"> man.hash.add(<span class="tok-builtin">@as</span>(<span class="tok-type">u32</span>, <span class="tok-number">0xd767ee59</span>));</span>
<span class="line" id="L202"></span>
<span class="line" id="L203"> <span class="tok-kw">for</span> (wf.files.items) |file| {</span>
<span class="line" id="L204"> man.hash.addBytes(file.sub_path);</span>
<span class="line" id="L205"> <span class="tok-kw">switch</span> (file.contents) {</span>
<span class="line" id="L206"> .bytes => |bytes| {</span>
<span class="line" id="L207"> man.hash.addBytes(bytes);</span>
<span class="line" id="L208"> },</span>
<span class="line" id="L209"> .copy => |file_source| {</span>
<span class="line" id="L210"> _ = <span class="tok-kw">try</span> man.addFile(file_source.getPath(b), <span class="tok-null">null</span>);</span>
<span class="line" id="L211"> },</span>
<span class="line" id="L212"> }</span>
<span class="line" id="L213"> }</span>
<span class="line" id="L214"></span>
<span class="line" id="L215"> <span class="tok-kw">if</span> (<span class="tok-kw">try</span> step.cacheHit(&man)) {</span>
<span class="line" id="L216"> <span class="tok-kw">const</span> digest = man.final();</span>
<span class="line" id="L217"> <span class="tok-kw">for</span> (wf.files.items) |file| {</span>
<span class="line" id="L218"> file.generated_file.path = <span class="tok-kw">try</span> b.cache_root.join(b.allocator, &.{</span>
<span class="line" id="L219"> <span class="tok-str">"o"</span>, &digest, file.sub_path,</span>
<span class="line" id="L220"> });</span>
<span class="line" id="L221"> }</span>
<span class="line" id="L222"> wf.generated_directory.path = <span class="tok-kw">try</span> b.cache_root.join(b.allocator, &.{ <span class="tok-str">"o"</span>, &digest });</span>
<span class="line" id="L223"> <span class="tok-kw">return</span>;</span>
<span class="line" id="L224"> }</span>
<span class="line" id="L225"></span>
<span class="line" id="L226"> <span class="tok-kw">const</span> digest = man.final();</span>
<span class="line" id="L227"> <span class="tok-kw">const</span> cache_path = <span class="tok-str">"o"</span> ++ fs.path.sep_str ++ digest;</span>
<span class="line" id="L228"></span>
<span class="line" id="L229"> wf.generated_directory.path = <span class="tok-kw">try</span> b.cache_root.join(b.allocator, &.{ <span class="tok-str">"o"</span>, &digest });</span>
<span class="line" id="L230"></span>
<span class="line" id="L231"> <span class="tok-kw">var</span> cache_dir = b.cache_root.handle.makeOpenPath(cache_path, .{}) <span class="tok-kw">catch</span> |err| {</span>
<span class="line" id="L232"> <span class="tok-kw">return</span> step.fail(<span class="tok-str">"unable to make path '{}{s}': {s}"</span>, .{</span>
<span class="line" id="L233"> b.cache_root, cache_path, <span class="tok-builtin">@errorName</span>(err),</span>
<span class="line" id="L234"> });</span>
<span class="line" id="L235"> };</span>
<span class="line" id="L236"> <span class="tok-kw">defer</span> cache_dir.close();</span>
<span class="line" id="L237"></span>
<span class="line" id="L238"> <span class="tok-kw">for</span> (wf.files.items) |file| {</span>
<span class="line" id="L239"> <span class="tok-kw">if</span> (fs.path.dirname(file.sub_path)) |dirname| {</span>
<span class="line" id="L240"> cache_dir.makePath(dirname) <span class="tok-kw">catch</span> |err| {</span>
<span class="line" id="L241"> <span class="tok-kw">return</span> step.fail(<span class="tok-str">"unable to make path '{}{s}{c}{s}': {s}"</span>, .{</span>
<span class="line" id="L242"> b.cache_root, cache_path, fs.path.sep, dirname, <span class="tok-builtin">@errorName</span>(err),</span>
<span class="line" id="L243"> });</span>
<span class="line" id="L244"> };</span>
<span class="line" id="L245"> }</span>
<span class="line" id="L246"> <span class="tok-kw">switch</span> (file.contents) {</span>
<span class="line" id="L247"> .bytes => |bytes| {</span>
<span class="line" id="L248"> cache_dir.writeFile(file.sub_path, bytes) <span class="tok-kw">catch</span> |err| {</span>
<span class="line" id="L249"> <span class="tok-kw">return</span> step.fail(<span class="tok-str">"unable to write file '{}{s}{c}{s}': {s}"</span>, .{</span>
<span class="line" id="L250"> b.cache_root, cache_path, fs.path.sep, file.sub_path, <span class="tok-builtin">@errorName</span>(err),</span>
<span class="line" id="L251"> });</span>
<span class="line" id="L252"> };</span>
<span class="line" id="L253"> },</span>
<span class="line" id="L254"> .copy => |file_source| {</span>
<span class="line" id="L255"> <span class="tok-kw">const</span> source_path = file_source.getPath(b);</span>
<span class="line" id="L256"> <span class="tok-kw">const</span> prev_status = fs.Dir.updateFile(</span>
<span class="line" id="L257"> fs.cwd(),</span>
<span class="line" id="L258"> source_path,</span>
<span class="line" id="L259"> cache_dir,</span>
<span class="line" id="L260"> file.sub_path,</span>
<span class="line" id="L261"> .{},</span>
<span class="line" id="L262"> ) <span class="tok-kw">catch</span> |err| {</span>
<span class="line" id="L263"> <span class="tok-kw">return</span> step.fail(<span class="tok-str">"unable to update file from '{s}' to '{}{s}{c}{s}': {s}"</span>, .{</span>
<span class="line" id="L264"> source_path,</span>
<span class="line" id="L265"> b.cache_root,</span>
<span class="line" id="L266"> cache_path,</span>
<span class="line" id="L267"> fs.path.sep,</span>
<span class="line" id="L268"> file.sub_path,</span>
<span class="line" id="L269"> <span class="tok-builtin">@errorName</span>(err),</span>
<span class="line" id="L270"> });</span>
<span class="line" id="L271"> };</span>
<span class="line" id="L272"> <span class="tok-comment">// At this point we already will mark the step as a cache miss.</span>
</span>
<span class="line" id="L273"> <span class="tok-comment">// But this is kind of a partial cache hit since individual</span>
</span>
<span class="line" id="L274"> <span class="tok-comment">// file copies may be avoided. Oh well, this information is</span>
</span>
<span class="line" id="L275"> <span class="tok-comment">// discarded.</span>
</span>
<span class="line" id="L276"> _ = prev_status;</span>
<span class="line" id="L277"> },</span>
<span class="line" id="L278"> }</span>
<span class="line" id="L279"></span>
<span class="line" id="L280"> file.generated_file.path = <span class="tok-kw">try</span> b.cache_root.join(b.allocator, &.{</span>
<span class="line" id="L281"> cache_path, file.sub_path,</span>
<span class="line" id="L282"> });</span>
<span class="line" id="L283"> }</span>
<span class="line" id="L284"></span>
<span class="line" id="L285"> <span class="tok-kw">try</span> step.writeManifest(&man);</span>
<span class="line" id="L286">}</span>
<span class="line" id="L287"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std/Build | repos/yazap/docs/src/std/Build/Step/CheckObject.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>Build/Step/CheckObject.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"std"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> assert = std.debug.assert;</span>
<span class="line" id="L3"><span class="tok-kw">const</span> elf = std.elf;</span>
<span class="line" id="L4"><span class="tok-kw">const</span> fs = std.fs;</span>
<span class="line" id="L5"><span class="tok-kw">const</span> macho = std.macho;</span>
<span class="line" id="L6"><span class="tok-kw">const</span> math = std.math;</span>
<span class="line" id="L7"><span class="tok-kw">const</span> mem = std.mem;</span>
<span class="line" id="L8"><span class="tok-kw">const</span> testing = std.testing;</span>
<span class="line" id="L9"></span>
<span class="line" id="L10"><span class="tok-kw">const</span> CheckObject = <span class="tok-builtin">@This</span>();</span>
<span class="line" id="L11"></span>
<span class="line" id="L12"><span class="tok-kw">const</span> Allocator = mem.Allocator;</span>
<span class="line" id="L13"><span class="tok-kw">const</span> Step = std.Build.Step;</span>
<span class="line" id="L14"></span>
<span class="line" id="L15"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> base_id = .check_object;</span>
<span class="line" id="L16"></span>
<span class="line" id="L17">step: Step,</span>
<span class="line" id="L18">source: std.Build.FileSource,</span>
<span class="line" id="L19">max_bytes: <span class="tok-type">usize</span> = <span class="tok-number">20</span> * <span class="tok-number">1024</span> * <span class="tok-number">1024</span>,</span>
<span class="line" id="L20">checks: std.ArrayList(Check),</span>
<span class="line" id="L21">obj_format: std.Target.ObjectFormat,</span>
<span class="line" id="L22"></span>
<span class="line" id="L23"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">create</span>(</span>
<span class="line" id="L24"> owner: *std.Build,</span>
<span class="line" id="L25"> source: std.Build.FileSource,</span>
<span class="line" id="L26"> obj_format: std.Target.ObjectFormat,</span>
<span class="line" id="L27">) *CheckObject {</span>
<span class="line" id="L28"> <span class="tok-kw">const</span> gpa = owner.allocator;</span>
<span class="line" id="L29"> <span class="tok-kw">const</span> self = gpa.create(CheckObject) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L30"> self.* = .{</span>
<span class="line" id="L31"> .step = Step.init(.{</span>
<span class="line" id="L32"> .id = .check_file,</span>
<span class="line" id="L33"> .name = <span class="tok-str">"CheckObject"</span>,</span>
<span class="line" id="L34"> .owner = owner,</span>
<span class="line" id="L35"> .makeFn = make,</span>
<span class="line" id="L36"> }),</span>
<span class="line" id="L37"> .source = source.dupe(owner),</span>
<span class="line" id="L38"> .checks = std.ArrayList(Check).init(gpa),</span>
<span class="line" id="L39"> .obj_format = obj_format,</span>
<span class="line" id="L40"> };</span>
<span class="line" id="L41"> self.source.addStepDependencies(&self.step);</span>
<span class="line" id="L42"> <span class="tok-kw">return</span> self;</span>
<span class="line" id="L43">}</span>
<span class="line" id="L44"></span>
<span class="line" id="L45"><span class="tok-kw">const</span> SearchPhrase = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L46"> string: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L47"> file_source: ?std.Build.FileSource = <span class="tok-null">null</span>,</span>
<span class="line" id="L48"></span>
<span class="line" id="L49"> <span class="tok-kw">fn</span> <span class="tok-fn">resolve</span>(phrase: SearchPhrase, b: *std.Build, step: *Step) []<span class="tok-kw">const</span> <span class="tok-type">u8</span> {</span>
<span class="line" id="L50"> <span class="tok-kw">const</span> file_source = phrase.file_source <span class="tok-kw">orelse</span> <span class="tok-kw">return</span> phrase.string;</span>
<span class="line" id="L51"> <span class="tok-kw">return</span> b.fmt(<span class="tok-str">"{s} {s}"</span>, .{ phrase.string, file_source.getPath2(b, step) });</span>
<span class="line" id="L52"> }</span>
<span class="line" id="L53">};</span>
<span class="line" id="L54"></span>
<span class="line" id="L55"><span class="tok-comment">/// There five types of actions currently supported:</span></span>
<span class="line" id="L56"><span class="tok-comment">/// .exact - will do an exact match against the haystack</span></span>
<span class="line" id="L57"><span class="tok-comment">/// .contains - will check for existence within the haystack</span></span>
<span class="line" id="L58"><span class="tok-comment">/// .not_present - will check for non-existence within the haystack</span></span>
<span class="line" id="L59"><span class="tok-comment">/// .extract - will do an exact match and extract into a variable enclosed within `{name}` braces</span></span>
<span class="line" id="L60"><span class="tok-comment">/// .compute_cmp - will perform an operation on the extracted global variables</span></span>
<span class="line" id="L61"><span class="tok-comment">/// using the MatchAction. It currently only supports an addition. The operation is required</span></span>
<span class="line" id="L62"><span class="tok-comment">/// to be specified in Reverse Polish Notation to ease in operator-precedence parsing (well,</span></span>
<span class="line" id="L63"><span class="tok-comment">/// to avoid any parsing really).</span></span>
<span class="line" id="L64"><span class="tok-comment">/// For example, if the two extracted values were saved as `vmaddr` and `entryoff` respectively</span></span>
<span class="line" id="L65"><span class="tok-comment">/// they could then be added with this simple program `vmaddr entryoff +`.</span></span>
<span class="line" id="L66"><span class="tok-kw">const</span> Action = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L67"> tag: <span class="tok-kw">enum</span> { exact, contains, not_present, extract, compute_cmp },</span>
<span class="line" id="L68"> phrase: SearchPhrase,</span>
<span class="line" id="L69"> expected: ?ComputeCompareExpected = <span class="tok-null">null</span>,</span>
<span class="line" id="L70"></span>
<span class="line" id="L71"> <span class="tok-comment">/// Returns true if the `phrase` is an exact match with the haystack and variable was successfully extracted.</span></span>
<span class="line" id="L72"> <span class="tok-kw">fn</span> <span class="tok-fn">extract</span>(</span>
<span class="line" id="L73"> act: Action,</span>
<span class="line" id="L74"> b: *std.Build,</span>
<span class="line" id="L75"> step: *Step,</span>
<span class="line" id="L76"> haystack: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L77"> global_vars: <span class="tok-kw">anytype</span>,</span>
<span class="line" id="L78"> ) !<span class="tok-type">bool</span> {</span>
<span class="line" id="L79"> assert(act.tag == .extract);</span>
<span class="line" id="L80"> <span class="tok-kw">const</span> hay = mem.trim(<span class="tok-type">u8</span>, haystack, <span class="tok-str">" "</span>);</span>
<span class="line" id="L81"> <span class="tok-kw">const</span> phrase = mem.trim(<span class="tok-type">u8</span>, act.phrase.resolve(b, step), <span class="tok-str">" "</span>);</span>
<span class="line" id="L82"></span>
<span class="line" id="L83"> <span class="tok-kw">var</span> candidate_vars = std.ArrayList(<span class="tok-kw">struct</span> { name: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>, value: <span class="tok-type">u64</span> }).init(b.allocator);</span>
<span class="line" id="L84"> <span class="tok-kw">var</span> hay_it = mem.tokenizeScalar(<span class="tok-type">u8</span>, hay, <span class="tok-str">' '</span>);</span>
<span class="line" id="L85"> <span class="tok-kw">var</span> needle_it = mem.tokenizeScalar(<span class="tok-type">u8</span>, phrase, <span class="tok-str">' '</span>);</span>
<span class="line" id="L86"></span>
<span class="line" id="L87"> <span class="tok-kw">while</span> (needle_it.next()) |needle_tok| {</span>
<span class="line" id="L88"> <span class="tok-kw">const</span> hay_tok = hay_it.next() <span class="tok-kw">orelse</span> <span class="tok-kw">break</span>;</span>
<span class="line" id="L89"> <span class="tok-kw">if</span> (mem.startsWith(<span class="tok-type">u8</span>, needle_tok, <span class="tok-str">"{"</span>)) {</span>
<span class="line" id="L90"> <span class="tok-kw">const</span> closing_brace = mem.indexOf(<span class="tok-type">u8</span>, needle_tok, <span class="tok-str">"}"</span>) <span class="tok-kw">orelse</span> <span class="tok-kw">return</span> <span class="tok-kw">error</span>.MissingClosingBrace;</span>
<span class="line" id="L91"> <span class="tok-kw">if</span> (closing_brace != needle_tok.len - <span class="tok-number">1</span>) <span class="tok-kw">return</span> <span class="tok-kw">error</span>.ClosingBraceNotLast;</span>
<span class="line" id="L92"></span>
<span class="line" id="L93"> <span class="tok-kw">const</span> name = needle_tok[<span class="tok-number">1</span>..closing_brace];</span>
<span class="line" id="L94"> <span class="tok-kw">if</span> (name.len == <span class="tok-number">0</span>) <span class="tok-kw">return</span> <span class="tok-kw">error</span>.MissingBraceValue;</span>
<span class="line" id="L95"> <span class="tok-kw">const</span> value = std.fmt.parseInt(<span class="tok-type">u64</span>, hay_tok, <span class="tok-number">16</span>) <span class="tok-kw">catch</span> <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L96"> <span class="tok-kw">try</span> candidate_vars.append(.{</span>
<span class="line" id="L97"> .name = name,</span>
<span class="line" id="L98"> .value = value,</span>
<span class="line" id="L99"> });</span>
<span class="line" id="L100"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L101"> <span class="tok-kw">if</span> (!mem.eql(<span class="tok-type">u8</span>, hay_tok, needle_tok)) <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L102"> }</span>
<span class="line" id="L103"> }</span>
<span class="line" id="L104"></span>
<span class="line" id="L105"> <span class="tok-kw">if</span> (candidate_vars.items.len == <span class="tok-number">0</span>) <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L106"></span>
<span class="line" id="L107"> <span class="tok-kw">for</span> (candidate_vars.items) |cv| <span class="tok-kw">try</span> global_vars.putNoClobber(cv.name, cv.value);</span>
<span class="line" id="L108"></span>
<span class="line" id="L109"> <span class="tok-kw">return</span> <span class="tok-null">true</span>;</span>
<span class="line" id="L110"> }</span>
<span class="line" id="L111"></span>
<span class="line" id="L112"> <span class="tok-comment">/// Returns true if the `phrase` is an exact match with the haystack.</span></span>
<span class="line" id="L113"> <span class="tok-kw">fn</span> <span class="tok-fn">exact</span>(</span>
<span class="line" id="L114"> act: Action,</span>
<span class="line" id="L115"> b: *std.Build,</span>
<span class="line" id="L116"> step: *Step,</span>
<span class="line" id="L117"> haystack: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L118"> ) <span class="tok-type">bool</span> {</span>
<span class="line" id="L119"> assert(act.tag == .exact);</span>
<span class="line" id="L120"> <span class="tok-kw">const</span> hay = mem.trim(<span class="tok-type">u8</span>, haystack, <span class="tok-str">" "</span>);</span>
<span class="line" id="L121"> <span class="tok-kw">const</span> phrase = mem.trim(<span class="tok-type">u8</span>, act.phrase.resolve(b, step), <span class="tok-str">" "</span>);</span>
<span class="line" id="L122"> <span class="tok-kw">return</span> mem.eql(<span class="tok-type">u8</span>, hay, phrase);</span>
<span class="line" id="L123"> }</span>
<span class="line" id="L124"></span>
<span class="line" id="L125"> <span class="tok-comment">/// Returns true if the `phrase` exists within the haystack.</span></span>
<span class="line" id="L126"> <span class="tok-kw">fn</span> <span class="tok-fn">contains</span>(</span>
<span class="line" id="L127"> act: Action,</span>
<span class="line" id="L128"> b: *std.Build,</span>
<span class="line" id="L129"> step: *Step,</span>
<span class="line" id="L130"> haystack: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L131"> ) <span class="tok-type">bool</span> {</span>
<span class="line" id="L132"> assert(act.tag == .contains);</span>
<span class="line" id="L133"> <span class="tok-kw">const</span> hay = mem.trim(<span class="tok-type">u8</span>, haystack, <span class="tok-str">" "</span>);</span>
<span class="line" id="L134"> <span class="tok-kw">const</span> phrase = mem.trim(<span class="tok-type">u8</span>, act.phrase.resolve(b, step), <span class="tok-str">" "</span>);</span>
<span class="line" id="L135"> <span class="tok-kw">return</span> mem.indexOf(<span class="tok-type">u8</span>, hay, phrase) != <span class="tok-null">null</span>;</span>
<span class="line" id="L136"> }</span>
<span class="line" id="L137"></span>
<span class="line" id="L138"> <span class="tok-comment">/// Returns true if the `phrase` does not exist within the haystack.</span></span>
<span class="line" id="L139"> <span class="tok-kw">fn</span> <span class="tok-fn">notPresent</span>(</span>
<span class="line" id="L140"> act: Action,</span>
<span class="line" id="L141"> b: *std.Build,</span>
<span class="line" id="L142"> step: *Step,</span>
<span class="line" id="L143"> haystack: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L144"> ) <span class="tok-type">bool</span> {</span>
<span class="line" id="L145"> assert(act.tag == .not_present);</span>
<span class="line" id="L146"> <span class="tok-kw">return</span> !contains(.{</span>
<span class="line" id="L147"> .tag = .contains,</span>
<span class="line" id="L148"> .phrase = act.phrase,</span>
<span class="line" id="L149"> .expected = act.expected,</span>
<span class="line" id="L150"> }, b, step, haystack);</span>
<span class="line" id="L151"> }</span>
<span class="line" id="L152"></span>
<span class="line" id="L153"> <span class="tok-comment">/// Will return true if the `phrase` is correctly parsed into an RPN program and</span></span>
<span class="line" id="L154"> <span class="tok-comment">/// its reduced, computed value compares using `op` with the expected value, either</span></span>
<span class="line" id="L155"> <span class="tok-comment">/// a literal or another extracted variable.</span></span>
<span class="line" id="L156"> <span class="tok-kw">fn</span> <span class="tok-fn">computeCmp</span>(act: Action, b: *std.Build, step: *Step, global_vars: <span class="tok-kw">anytype</span>) !<span class="tok-type">bool</span> {</span>
<span class="line" id="L157"> <span class="tok-kw">const</span> gpa = step.owner.allocator;</span>
<span class="line" id="L158"> <span class="tok-kw">const</span> phrase = act.phrase.resolve(b, step);</span>
<span class="line" id="L159"> <span class="tok-kw">var</span> op_stack = std.ArrayList(<span class="tok-kw">enum</span> { add, sub, mod, mul }).init(gpa);</span>
<span class="line" id="L160"> <span class="tok-kw">var</span> values = std.ArrayList(<span class="tok-type">u64</span>).init(gpa);</span>
<span class="line" id="L161"></span>
<span class="line" id="L162"> <span class="tok-kw">var</span> it = mem.tokenizeScalar(<span class="tok-type">u8</span>, phrase, <span class="tok-str">' '</span>);</span>
<span class="line" id="L163"> <span class="tok-kw">while</span> (it.next()) |next| {</span>
<span class="line" id="L164"> <span class="tok-kw">if</span> (mem.eql(<span class="tok-type">u8</span>, next, <span class="tok-str">"+"</span>)) {</span>
<span class="line" id="L165"> <span class="tok-kw">try</span> op_stack.append(.add);</span>
<span class="line" id="L166"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (mem.eql(<span class="tok-type">u8</span>, next, <span class="tok-str">"-"</span>)) {</span>
<span class="line" id="L167"> <span class="tok-kw">try</span> op_stack.append(.sub);</span>
<span class="line" id="L168"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (mem.eql(<span class="tok-type">u8</span>, next, <span class="tok-str">"%"</span>)) {</span>
<span class="line" id="L169"> <span class="tok-kw">try</span> op_stack.append(.mod);</span>
<span class="line" id="L170"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (mem.eql(<span class="tok-type">u8</span>, next, <span class="tok-str">"*"</span>)) {</span>
<span class="line" id="L171"> <span class="tok-kw">try</span> op_stack.append(.mul);</span>
<span class="line" id="L172"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L173"> <span class="tok-kw">const</span> val = std.fmt.parseInt(<span class="tok-type">u64</span>, next, <span class="tok-number">0</span>) <span class="tok-kw">catch</span> blk: {</span>
<span class="line" id="L174"> <span class="tok-kw">break</span> :blk global_vars.get(next) <span class="tok-kw">orelse</span> {</span>
<span class="line" id="L175"> <span class="tok-kw">try</span> step.addError(</span>
<span class="line" id="L176"> <span class="tok-str">\\</span></span>
<span class="line" id="L177"> <span class="tok-str">\\========= variable was not extracted: ===========</span></span>
<span class="line" id="L178"> <span class="tok-str">\\{s}</span></span>
<span class="line" id="L179"> <span class="tok-str">\\=================================================</span></span>
<span class="line" id="L180"> , .{next});</span>
<span class="line" id="L181"> <span class="tok-kw">return</span> <span class="tok-kw">error</span>.UnknownVariable;</span>
<span class="line" id="L182"> };</span>
<span class="line" id="L183"> };</span>
<span class="line" id="L184"> <span class="tok-kw">try</span> values.append(val);</span>
<span class="line" id="L185"> }</span>
<span class="line" id="L186"> }</span>
<span class="line" id="L187"></span>
<span class="line" id="L188"> <span class="tok-kw">var</span> op_i: <span class="tok-type">usize</span> = <span class="tok-number">1</span>;</span>
<span class="line" id="L189"> <span class="tok-kw">var</span> reduced: <span class="tok-type">u64</span> = values.items[<span class="tok-number">0</span>];</span>
<span class="line" id="L190"> <span class="tok-kw">for</span> (op_stack.items) |op| {</span>
<span class="line" id="L191"> <span class="tok-kw">const</span> other = values.items[op_i];</span>
<span class="line" id="L192"> <span class="tok-kw">switch</span> (op) {</span>
<span class="line" id="L193"> .add => {</span>
<span class="line" id="L194"> reduced += other;</span>
<span class="line" id="L195"> },</span>
<span class="line" id="L196"> .sub => {</span>
<span class="line" id="L197"> reduced -= other;</span>
<span class="line" id="L198"> },</span>
<span class="line" id="L199"> .mod => {</span>
<span class="line" id="L200"> reduced %= other;</span>
<span class="line" id="L201"> },</span>
<span class="line" id="L202"> .mul => {</span>
<span class="line" id="L203"> reduced *= other;</span>
<span class="line" id="L204"> },</span>
<span class="line" id="L205"> }</span>
<span class="line" id="L206"> op_i += <span class="tok-number">1</span>;</span>
<span class="line" id="L207"> }</span>
<span class="line" id="L208"></span>
<span class="line" id="L209"> <span class="tok-kw">const</span> exp_value = <span class="tok-kw">switch</span> (act.expected.?.value) {</span>
<span class="line" id="L210"> .variable => |name| global_vars.get(name) <span class="tok-kw">orelse</span> {</span>
<span class="line" id="L211"> <span class="tok-kw">try</span> step.addError(</span>
<span class="line" id="L212"> <span class="tok-str">\\</span></span>
<span class="line" id="L213"> <span class="tok-str">\\========= variable was not extracted: ===========</span></span>
<span class="line" id="L214"> <span class="tok-str">\\{s}</span></span>
<span class="line" id="L215"> <span class="tok-str">\\=================================================</span></span>
<span class="line" id="L216"> , .{name});</span>
<span class="line" id="L217"> <span class="tok-kw">return</span> <span class="tok-kw">error</span>.UnknownVariable;</span>
<span class="line" id="L218"> },</span>
<span class="line" id="L219"> .literal => |x| x,</span>
<span class="line" id="L220"> };</span>
<span class="line" id="L221"> <span class="tok-kw">return</span> math.compare(reduced, act.expected.?.op, exp_value);</span>
<span class="line" id="L222"> }</span>
<span class="line" id="L223">};</span>
<span class="line" id="L224"></span>
<span class="line" id="L225"><span class="tok-kw">const</span> ComputeCompareExpected = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L226"> op: math.CompareOperator,</span>
<span class="line" id="L227"> value: <span class="tok-kw">union</span>(<span class="tok-kw">enum</span>) {</span>
<span class="line" id="L228"> variable: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L229"> literal: <span class="tok-type">u64</span>,</span>
<span class="line" id="L230"> },</span>
<span class="line" id="L231"></span>
<span class="line" id="L232"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">format</span>(</span>
<span class="line" id="L233"> value: <span class="tok-builtin">@This</span>(),</span>
<span class="line" id="L234"> <span class="tok-kw">comptime</span> fmt: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L235"> options: std.fmt.FormatOptions,</span>
<span class="line" id="L236"> writer: <span class="tok-kw">anytype</span>,</span>
<span class="line" id="L237"> ) !<span class="tok-type">void</span> {</span>
<span class="line" id="L238"> <span class="tok-kw">if</span> (fmt.len != <span class="tok-number">0</span>) std.fmt.invalidFmtError(fmt, value);</span>
<span class="line" id="L239"> _ = options;</span>
<span class="line" id="L240"> <span class="tok-kw">try</span> writer.print(<span class="tok-str">"{s} "</span>, .{<span class="tok-builtin">@tagName</span>(value.op)});</span>
<span class="line" id="L241"> <span class="tok-kw">switch</span> (value.value) {</span>
<span class="line" id="L242"> .variable => |name| <span class="tok-kw">try</span> writer.writeAll(name),</span>
<span class="line" id="L243"> .literal => |x| <span class="tok-kw">try</span> writer.print(<span class="tok-str">"{x}"</span>, .{x}),</span>
<span class="line" id="L244"> }</span>
<span class="line" id="L245"> }</span>
<span class="line" id="L246">};</span>
<span class="line" id="L247"></span>
<span class="line" id="L248"><span class="tok-kw">const</span> Check = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L249"> actions: std.ArrayList(Action),</span>
<span class="line" id="L250"></span>
<span class="line" id="L251"> <span class="tok-kw">fn</span> <span class="tok-fn">create</span>(allocator: Allocator) Check {</span>
<span class="line" id="L252"> <span class="tok-kw">return</span> .{</span>
<span class="line" id="L253"> .actions = std.ArrayList(Action).init(allocator),</span>
<span class="line" id="L254"> };</span>
<span class="line" id="L255"> }</span>
<span class="line" id="L256"></span>
<span class="line" id="L257"> <span class="tok-kw">fn</span> <span class="tok-fn">extract</span>(self: *Check, phrase: SearchPhrase) <span class="tok-type">void</span> {</span>
<span class="line" id="L258"> self.actions.append(.{</span>
<span class="line" id="L259"> .tag = .extract,</span>
<span class="line" id="L260"> .phrase = phrase,</span>
<span class="line" id="L261"> }) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L262"> }</span>
<span class="line" id="L263"></span>
<span class="line" id="L264"> <span class="tok-kw">fn</span> <span class="tok-fn">exact</span>(self: *Check, phrase: SearchPhrase) <span class="tok-type">void</span> {</span>
<span class="line" id="L265"> self.actions.append(.{</span>
<span class="line" id="L266"> .tag = .exact,</span>
<span class="line" id="L267"> .phrase = phrase,</span>
<span class="line" id="L268"> }) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L269"> }</span>
<span class="line" id="L270"></span>
<span class="line" id="L271"> <span class="tok-kw">fn</span> <span class="tok-fn">contains</span>(self: *Check, phrase: SearchPhrase) <span class="tok-type">void</span> {</span>
<span class="line" id="L272"> self.actions.append(.{</span>
<span class="line" id="L273"> .tag = .contains,</span>
<span class="line" id="L274"> .phrase = phrase,</span>
<span class="line" id="L275"> }) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L276"> }</span>
<span class="line" id="L277"></span>
<span class="line" id="L278"> <span class="tok-kw">fn</span> <span class="tok-fn">notPresent</span>(self: *Check, phrase: SearchPhrase) <span class="tok-type">void</span> {</span>
<span class="line" id="L279"> self.actions.append(.{</span>
<span class="line" id="L280"> .tag = .not_present,</span>
<span class="line" id="L281"> .phrase = phrase,</span>
<span class="line" id="L282"> }) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L283"> }</span>
<span class="line" id="L284"></span>
<span class="line" id="L285"> <span class="tok-kw">fn</span> <span class="tok-fn">computeCmp</span>(self: *Check, phrase: SearchPhrase, expected: ComputeCompareExpected) <span class="tok-type">void</span> {</span>
<span class="line" id="L286"> self.actions.append(.{</span>
<span class="line" id="L287"> .tag = .compute_cmp,</span>
<span class="line" id="L288"> .phrase = phrase,</span>
<span class="line" id="L289"> .expected = expected,</span>
<span class="line" id="L290"> }) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L291"> }</span>
<span class="line" id="L292">};</span>
<span class="line" id="L293"></span>
<span class="line" id="L294"><span class="tok-comment">/// Creates a new empty sequence of actions.</span></span>
<span class="line" id="L295"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">checkStart</span>(self: *CheckObject) <span class="tok-type">void</span> {</span>
<span class="line" id="L296"> <span class="tok-kw">var</span> new_check = Check.create(self.step.owner.allocator);</span>
<span class="line" id="L297"> self.checks.append(new_check) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L298">}</span>
<span class="line" id="L299"></span>
<span class="line" id="L300"><span class="tok-comment">/// Adds an exact match phrase to the latest created Check with `CheckObject.checkStart()`.</span></span>
<span class="line" id="L301"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">checkExact</span>(self: *CheckObject, phrase: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L302"> self.checkExactInner(phrase, <span class="tok-null">null</span>);</span>
<span class="line" id="L303">}</span>
<span class="line" id="L304"></span>
<span class="line" id="L305"><span class="tok-comment">/// Like `checkExact()` but takes an additional argument `FileSource` which will be</span></span>
<span class="line" id="L306"><span class="tok-comment">/// resolved to a full search query in `make()`.</span></span>
<span class="line" id="L307"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">checkExactFileSource</span>(self: *CheckObject, phrase: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>, file_source: std.Build.FileSource) <span class="tok-type">void</span> {</span>
<span class="line" id="L308"> self.checkExactInner(phrase, file_source);</span>
<span class="line" id="L309">}</span>
<span class="line" id="L310"></span>
<span class="line" id="L311"><span class="tok-kw">fn</span> <span class="tok-fn">checkExactInner</span>(self: *CheckObject, phrase: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>, file_source: ?std.Build.FileSource) <span class="tok-type">void</span> {</span>
<span class="line" id="L312"> assert(self.checks.items.len > <span class="tok-number">0</span>);</span>
<span class="line" id="L313"> <span class="tok-kw">const</span> last = &self.checks.items[self.checks.items.len - <span class="tok-number">1</span>];</span>
<span class="line" id="L314"> last.exact(.{ .string = self.step.owner.dupe(phrase), .file_source = file_source });</span>
<span class="line" id="L315">}</span>
<span class="line" id="L316"></span>
<span class="line" id="L317"><span class="tok-comment">/// Adds a fuzzy match phrase to the latest created Check with `CheckObject.checkStart()`.</span></span>
<span class="line" id="L318"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">checkContains</span>(self: *CheckObject, phrase: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L319"> self.checkContainsInner(phrase, <span class="tok-null">null</span>);</span>
<span class="line" id="L320">}</span>
<span class="line" id="L321"></span>
<span class="line" id="L322"><span class="tok-comment">/// Like `checkContains()` but takes an additional argument `FileSource` which will be</span></span>
<span class="line" id="L323"><span class="tok-comment">/// resolved to a full search query in `make()`.</span></span>
<span class="line" id="L324"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">checkContainsFileSource</span>(self: *CheckObject, phrase: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>, file_source: std.Build.FileSource) <span class="tok-type">void</span> {</span>
<span class="line" id="L325"> self.checkContainsInner(phrase, file_source);</span>
<span class="line" id="L326">}</span>
<span class="line" id="L327"></span>
<span class="line" id="L328"><span class="tok-kw">fn</span> <span class="tok-fn">checkContainsInner</span>(self: *CheckObject, phrase: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>, file_source: ?std.Build.FileSource) <span class="tok-type">void</span> {</span>
<span class="line" id="L329"> assert(self.checks.items.len > <span class="tok-number">0</span>);</span>
<span class="line" id="L330"> <span class="tok-kw">const</span> last = &self.checks.items[self.checks.items.len - <span class="tok-number">1</span>];</span>
<span class="line" id="L331"> last.contains(.{ .string = self.step.owner.dupe(phrase), .file_source = file_source });</span>
<span class="line" id="L332">}</span>
<span class="line" id="L333"></span>
<span class="line" id="L334"><span class="tok-comment">/// Adds an exact match phrase with variable extractor to the latest created Check</span></span>
<span class="line" id="L335"><span class="tok-comment">/// with `CheckObject.checkStart()`.</span></span>
<span class="line" id="L336"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">checkExtract</span>(self: *CheckObject, phrase: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L337"> self.checkExtractInner(phrase, <span class="tok-null">null</span>);</span>
<span class="line" id="L338">}</span>
<span class="line" id="L339"></span>
<span class="line" id="L340"><span class="tok-comment">/// Like `checkExtract()` but takes an additional argument `FileSource` which will be</span></span>
<span class="line" id="L341"><span class="tok-comment">/// resolved to a full search query in `make()`.</span></span>
<span class="line" id="L342"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">checkExtractFileSource</span>(self: *CheckObject, phrase: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>, file_source: std.Build.FileSource) <span class="tok-type">void</span> {</span>
<span class="line" id="L343"> self.checkExtractInner(phrase, file_source);</span>
<span class="line" id="L344">}</span>
<span class="line" id="L345"></span>
<span class="line" id="L346"><span class="tok-kw">fn</span> <span class="tok-fn">checkExtractInner</span>(self: *CheckObject, phrase: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>, file_source: ?std.Build.FileSource) <span class="tok-type">void</span> {</span>
<span class="line" id="L347"> assert(self.checks.items.len > <span class="tok-number">0</span>);</span>
<span class="line" id="L348"> <span class="tok-kw">const</span> last = &self.checks.items[self.checks.items.len - <span class="tok-number">1</span>];</span>
<span class="line" id="L349"> last.extract(.{ .string = self.step.owner.dupe(phrase), .file_source = file_source });</span>
<span class="line" id="L350">}</span>
<span class="line" id="L351"></span>
<span class="line" id="L352"><span class="tok-comment">/// Adds another searched phrase to the latest created Check with `CheckObject.checkStart(...)`</span></span>
<span class="line" id="L353"><span class="tok-comment">/// however ensures there is no matching phrase in the output.</span></span>
<span class="line" id="L354"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">checkNotPresent</span>(self: *CheckObject, phrase: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L355"> self.checkNotPresentInner(phrase, <span class="tok-null">null</span>);</span>
<span class="line" id="L356">}</span>
<span class="line" id="L357"></span>
<span class="line" id="L358"><span class="tok-comment">/// Like `checkExtract()` but takes an additional argument `FileSource` which will be</span></span>
<span class="line" id="L359"><span class="tok-comment">/// resolved to a full search query in `make()`.</span></span>
<span class="line" id="L360"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">checkNotPresentFileSource</span>(self: *CheckObject, phrase: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>, file_source: std.Build.FileSource) <span class="tok-type">void</span> {</span>
<span class="line" id="L361"> self.checkNotPresentInner(phrase, file_source);</span>
<span class="line" id="L362">}</span>
<span class="line" id="L363"></span>
<span class="line" id="L364"><span class="tok-kw">fn</span> <span class="tok-fn">checkNotPresentInner</span>(self: *CheckObject, phrase: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>, file_source: ?std.Build.FileSource) <span class="tok-type">void</span> {</span>
<span class="line" id="L365"> assert(self.checks.items.len > <span class="tok-number">0</span>);</span>
<span class="line" id="L366"> <span class="tok-kw">const</span> last = &self.checks.items[self.checks.items.len - <span class="tok-number">1</span>];</span>
<span class="line" id="L367"> last.notPresent(.{ .string = self.step.owner.dupe(phrase), .file_source = file_source });</span>
<span class="line" id="L368">}</span>
<span class="line" id="L369"></span>
<span class="line" id="L370"><span class="tok-comment">/// Creates a new check checking specifically symbol table parsed and dumped from the object</span></span>
<span class="line" id="L371"><span class="tok-comment">/// file.</span></span>
<span class="line" id="L372"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">checkInSymtab</span>(self: *CheckObject) <span class="tok-type">void</span> {</span>
<span class="line" id="L373"> <span class="tok-kw">const</span> label = <span class="tok-kw">switch</span> (self.obj_format) {</span>
<span class="line" id="L374"> .macho => MachODumper.symtab_label,</span>
<span class="line" id="L375"> .elf => ElfDumper.symtab_label,</span>
<span class="line" id="L376"> .wasm => WasmDumper.symtab_label,</span>
<span class="line" id="L377"> .coff => <span class="tok-builtin">@panic</span>(<span class="tok-str">"TODO symtab for coff"</span>),</span>
<span class="line" id="L378"> <span class="tok-kw">else</span> => <span class="tok-builtin">@panic</span>(<span class="tok-str">"TODO other file formats"</span>),</span>
<span class="line" id="L379"> };</span>
<span class="line" id="L380"> self.checkStart();</span>
<span class="line" id="L381"> self.checkExact(label);</span>
<span class="line" id="L382">}</span>
<span class="line" id="L383"></span>
<span class="line" id="L384"><span class="tok-comment">/// Creates a new check checking specifically dynamic symbol table parsed and dumped from the object</span></span>
<span class="line" id="L385"><span class="tok-comment">/// file.</span></span>
<span class="line" id="L386"><span class="tok-comment">/// This check is target-dependent and applicable to ELF only.</span></span>
<span class="line" id="L387"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">checkInDynamicSymtab</span>(self: *CheckObject) <span class="tok-type">void</span> {</span>
<span class="line" id="L388"> <span class="tok-kw">const</span> label = <span class="tok-kw">switch</span> (self.obj_format) {</span>
<span class="line" id="L389"> .elf => ElfDumper.dynamic_symtab_label,</span>
<span class="line" id="L390"> <span class="tok-kw">else</span> => <span class="tok-builtin">@panic</span>(<span class="tok-str">"Unsupported target platform"</span>),</span>
<span class="line" id="L391"> };</span>
<span class="line" id="L392"> self.checkStart();</span>
<span class="line" id="L393"> self.checkExact(label);</span>
<span class="line" id="L394">}</span>
<span class="line" id="L395"></span>
<span class="line" id="L396"><span class="tok-comment">/// Creates a new check checking specifically dynamic section parsed and dumped from the object</span></span>
<span class="line" id="L397"><span class="tok-comment">/// file.</span></span>
<span class="line" id="L398"><span class="tok-comment">/// This check is target-dependent and applicable to ELF only.</span></span>
<span class="line" id="L399"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">checkInDynamicSection</span>(self: *CheckObject) <span class="tok-type">void</span> {</span>
<span class="line" id="L400"> <span class="tok-kw">const</span> label = <span class="tok-kw">switch</span> (self.obj_format) {</span>
<span class="line" id="L401"> .elf => ElfDumper.dynamic_section_label,</span>
<span class="line" id="L402"> <span class="tok-kw">else</span> => <span class="tok-builtin">@panic</span>(<span class="tok-str">"Unsupported target platform"</span>),</span>
<span class="line" id="L403"> };</span>
<span class="line" id="L404"> self.checkStart();</span>
<span class="line" id="L405"> self.checkExact(label);</span>
<span class="line" id="L406">}</span>
<span class="line" id="L407"></span>
<span class="line" id="L408"><span class="tok-comment">/// Creates a new standalone, singular check which allows running simple binary operations</span></span>
<span class="line" id="L409"><span class="tok-comment">/// on the extracted variables. It will then compare the reduced program with the value of</span></span>
<span class="line" id="L410"><span class="tok-comment">/// the expected variable.</span></span>
<span class="line" id="L411"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">checkComputeCompare</span>(</span>
<span class="line" id="L412"> self: *CheckObject,</span>
<span class="line" id="L413"> program: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L414"> expected: ComputeCompareExpected,</span>
<span class="line" id="L415">) <span class="tok-type">void</span> {</span>
<span class="line" id="L416"> <span class="tok-kw">var</span> new_check = Check.create(self.step.owner.allocator);</span>
<span class="line" id="L417"> new_check.computeCmp(.{ .string = self.step.owner.dupe(program) }, expected);</span>
<span class="line" id="L418"> self.checks.append(new_check) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L419">}</span>
<span class="line" id="L420"></span>
<span class="line" id="L421"><span class="tok-kw">fn</span> <span class="tok-fn">make</span>(step: *Step, prog_node: *std.Progress.Node) !<span class="tok-type">void</span> {</span>
<span class="line" id="L422"> _ = prog_node;</span>
<span class="line" id="L423"> <span class="tok-kw">const</span> b = step.owner;</span>
<span class="line" id="L424"> <span class="tok-kw">const</span> gpa = b.allocator;</span>
<span class="line" id="L425"> <span class="tok-kw">const</span> self = <span class="tok-builtin">@fieldParentPtr</span>(CheckObject, <span class="tok-str">"step"</span>, step);</span>
<span class="line" id="L426"></span>
<span class="line" id="L427"> <span class="tok-kw">const</span> src_path = self.source.getPath(b);</span>
<span class="line" id="L428"> <span class="tok-kw">const</span> contents = fs.cwd().readFileAllocOptions(</span>
<span class="line" id="L429"> gpa,</span>
<span class="line" id="L430"> src_path,</span>
<span class="line" id="L431"> self.max_bytes,</span>
<span class="line" id="L432"> <span class="tok-null">null</span>,</span>
<span class="line" id="L433"> <span class="tok-builtin">@alignOf</span>(<span class="tok-type">u64</span>),</span>
<span class="line" id="L434"> <span class="tok-null">null</span>,</span>
<span class="line" id="L435"> ) <span class="tok-kw">catch</span> |err| <span class="tok-kw">return</span> step.fail(<span class="tok-str">"unable to read '{s}': {s}"</span>, .{ src_path, <span class="tok-builtin">@errorName</span>(err) });</span>
<span class="line" id="L436"></span>
<span class="line" id="L437"> <span class="tok-kw">const</span> output = <span class="tok-kw">switch</span> (self.obj_format) {</span>
<span class="line" id="L438"> .macho => <span class="tok-kw">try</span> MachODumper.parseAndDump(step, contents),</span>
<span class="line" id="L439"> .elf => <span class="tok-kw">try</span> ElfDumper.parseAndDump(step, contents),</span>
<span class="line" id="L440"> .coff => <span class="tok-builtin">@panic</span>(<span class="tok-str">"TODO coff parser"</span>),</span>
<span class="line" id="L441"> .wasm => <span class="tok-kw">try</span> WasmDumper.parseAndDump(step, contents),</span>
<span class="line" id="L442"> <span class="tok-kw">else</span> => <span class="tok-kw">unreachable</span>,</span>
<span class="line" id="L443"> };</span>
<span class="line" id="L444"></span>
<span class="line" id="L445"> <span class="tok-kw">var</span> vars = std.StringHashMap(<span class="tok-type">u64</span>).init(gpa);</span>
<span class="line" id="L446"></span>
<span class="line" id="L447"> <span class="tok-kw">for</span> (self.checks.items) |chk| {</span>
<span class="line" id="L448"> <span class="tok-kw">var</span> it = mem.tokenizeAny(<span class="tok-type">u8</span>, output, <span class="tok-str">"\r\n"</span>);</span>
<span class="line" id="L449"> <span class="tok-kw">for</span> (chk.actions.items) |act| {</span>
<span class="line" id="L450"> <span class="tok-kw">switch</span> (act.tag) {</span>
<span class="line" id="L451"> .exact => {</span>
<span class="line" id="L452"> <span class="tok-kw">while</span> (it.next()) |line| {</span>
<span class="line" id="L453"> <span class="tok-kw">if</span> (act.exact(b, step, line)) <span class="tok-kw">break</span>;</span>
<span class="line" id="L454"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L455"> <span class="tok-kw">return</span> step.fail(</span>
<span class="line" id="L456"> <span class="tok-str">\\</span></span>
<span class="line" id="L457"> <span class="tok-str">\\========= expected to find: ==========================</span></span>
<span class="line" id="L458"> <span class="tok-str">\\{s}</span></span>
<span class="line" id="L459"> <span class="tok-str">\\========= but parsed file does not contain it: =======</span></span>
<span class="line" id="L460"> <span class="tok-str">\\{s}</span></span>
<span class="line" id="L461"> <span class="tok-str">\\======================================================</span></span>
<span class="line" id="L462"> , .{ act.phrase.resolve(b, step), output });</span>
<span class="line" id="L463"> }</span>
<span class="line" id="L464"> },</span>
<span class="line" id="L465"> .contains => {</span>
<span class="line" id="L466"> <span class="tok-kw">while</span> (it.next()) |line| {</span>
<span class="line" id="L467"> <span class="tok-kw">if</span> (act.contains(b, step, line)) <span class="tok-kw">break</span>;</span>
<span class="line" id="L468"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L469"> <span class="tok-kw">return</span> step.fail(</span>
<span class="line" id="L470"> <span class="tok-str">\\</span></span>
<span class="line" id="L471"> <span class="tok-str">\\========= expected to find: ==========================</span></span>
<span class="line" id="L472"> <span class="tok-str">\\*{s}*</span></span>
<span class="line" id="L473"> <span class="tok-str">\\========= but parsed file does not contain it: =======</span></span>
<span class="line" id="L474"> <span class="tok-str">\\{s}</span></span>
<span class="line" id="L475"> <span class="tok-str">\\======================================================</span></span>
<span class="line" id="L476"> , .{ act.phrase.resolve(b, step), output });</span>
<span class="line" id="L477"> }</span>
<span class="line" id="L478"> },</span>
<span class="line" id="L479"> .not_present => {</span>
<span class="line" id="L480"> <span class="tok-kw">while</span> (it.next()) |line| {</span>
<span class="line" id="L481"> <span class="tok-kw">if</span> (act.notPresent(b, step, line)) <span class="tok-kw">break</span>;</span>
<span class="line" id="L482"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L483"> <span class="tok-kw">return</span> step.fail(</span>
<span class="line" id="L484"> <span class="tok-str">\\</span></span>
<span class="line" id="L485"> <span class="tok-str">\\========= expected not to find: ===================</span></span>
<span class="line" id="L486"> <span class="tok-str">\\{s}</span></span>
<span class="line" id="L487"> <span class="tok-str">\\========= but parsed file does contain it: ========</span></span>
<span class="line" id="L488"> <span class="tok-str">\\{s}</span></span>
<span class="line" id="L489"> <span class="tok-str">\\===================================================</span></span>
<span class="line" id="L490"> , .{ act.phrase.resolve(b, step), output });</span>
<span class="line" id="L491"> }</span>
<span class="line" id="L492"> },</span>
<span class="line" id="L493"> .extract => {</span>
<span class="line" id="L494"> <span class="tok-kw">while</span> (it.next()) |line| {</span>
<span class="line" id="L495"> <span class="tok-kw">if</span> (<span class="tok-kw">try</span> act.extract(b, step, line, &vars)) <span class="tok-kw">break</span>;</span>
<span class="line" id="L496"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L497"> <span class="tok-kw">return</span> step.fail(</span>
<span class="line" id="L498"> <span class="tok-str">\\</span></span>
<span class="line" id="L499"> <span class="tok-str">\\========= expected to find and extract: ==============</span></span>
<span class="line" id="L500"> <span class="tok-str">\\{s}</span></span>
<span class="line" id="L501"> <span class="tok-str">\\========= but parsed file does not contain it: =======</span></span>
<span class="line" id="L502"> <span class="tok-str">\\{s}</span></span>
<span class="line" id="L503"> <span class="tok-str">\\======================================================</span></span>
<span class="line" id="L504"> , .{ act.phrase.resolve(b, step), output });</span>
<span class="line" id="L505"> }</span>
<span class="line" id="L506"> },</span>
<span class="line" id="L507"> .compute_cmp => {</span>
<span class="line" id="L508"> <span class="tok-kw">const</span> res = act.computeCmp(b, step, vars) <span class="tok-kw">catch</span> |err| <span class="tok-kw">switch</span> (err) {</span>
<span class="line" id="L509"> <span class="tok-kw">error</span>.UnknownVariable => {</span>
<span class="line" id="L510"> <span class="tok-kw">return</span> step.fail(</span>
<span class="line" id="L511"> <span class="tok-str">\\========= from parsed file: =====================</span></span>
<span class="line" id="L512"> <span class="tok-str">\\{s}</span></span>
<span class="line" id="L513"> <span class="tok-str">\\=================================================</span></span>
<span class="line" id="L514"> , .{output});</span>
<span class="line" id="L515"> },</span>
<span class="line" id="L516"> <span class="tok-kw">else</span> => |e| <span class="tok-kw">return</span> e,</span>
<span class="line" id="L517"> };</span>
<span class="line" id="L518"> <span class="tok-kw">if</span> (!res) {</span>
<span class="line" id="L519"> <span class="tok-kw">return</span> step.fail(</span>
<span class="line" id="L520"> <span class="tok-str">\\</span></span>
<span class="line" id="L521"> <span class="tok-str">\\========= comparison failed for action: ===========</span></span>
<span class="line" id="L522"> <span class="tok-str">\\{s} {}</span></span>
<span class="line" id="L523"> <span class="tok-str">\\========= from parsed file: =======================</span></span>
<span class="line" id="L524"> <span class="tok-str">\\{s}</span></span>
<span class="line" id="L525"> <span class="tok-str">\\===================================================</span></span>
<span class="line" id="L526"> , .{ act.phrase.resolve(b, step), act.expected.?, output });</span>
<span class="line" id="L527"> }</span>
<span class="line" id="L528"> },</span>
<span class="line" id="L529"> }</span>
<span class="line" id="L530"> }</span>
<span class="line" id="L531"> }</span>
<span class="line" id="L532">}</span>
<span class="line" id="L533"></span>
<span class="line" id="L534"><span class="tok-kw">const</span> MachODumper = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L535"> <span class="tok-kw">const</span> LoadCommandIterator = macho.LoadCommandIterator;</span>
<span class="line" id="L536"> <span class="tok-kw">const</span> symtab_label = <span class="tok-str">"symbol table"</span>;</span>
<span class="line" id="L537"></span>
<span class="line" id="L538"> <span class="tok-kw">const</span> Symtab = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L539"> symbols: []<span class="tok-kw">align</span>(<span class="tok-number">1</span>) <span class="tok-kw">const</span> macho.nlist_64,</span>
<span class="line" id="L540"> strings: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L541"> };</span>
<span class="line" id="L542"></span>
<span class="line" id="L543"> <span class="tok-kw">fn</span> <span class="tok-fn">parseAndDump</span>(step: *Step, bytes: []<span class="tok-kw">align</span>(<span class="tok-builtin">@alignOf</span>(<span class="tok-type">u64</span>)) <span class="tok-kw">const</span> <span class="tok-type">u8</span>) ![]<span class="tok-kw">const</span> <span class="tok-type">u8</span> {</span>
<span class="line" id="L544"> <span class="tok-kw">const</span> gpa = step.owner.allocator;</span>
<span class="line" id="L545"> <span class="tok-kw">var</span> stream = std.io.fixedBufferStream(bytes);</span>
<span class="line" id="L546"> <span class="tok-kw">const</span> reader = stream.reader();</span>
<span class="line" id="L547"></span>
<span class="line" id="L548"> <span class="tok-kw">const</span> hdr = <span class="tok-kw">try</span> reader.readStruct(macho.mach_header_64);</span>
<span class="line" id="L549"> <span class="tok-kw">if</span> (hdr.magic != macho.MH_MAGIC_64) {</span>
<span class="line" id="L550"> <span class="tok-kw">return</span> <span class="tok-kw">error</span>.InvalidMagicNumber;</span>
<span class="line" id="L551"> }</span>
<span class="line" id="L552"></span>
<span class="line" id="L553"> <span class="tok-kw">var</span> output = std.ArrayList(<span class="tok-type">u8</span>).init(gpa);</span>
<span class="line" id="L554"> <span class="tok-kw">const</span> writer = output.writer();</span>
<span class="line" id="L555"></span>
<span class="line" id="L556"> <span class="tok-kw">var</span> symtab: ?Symtab = <span class="tok-null">null</span>;</span>
<span class="line" id="L557"> <span class="tok-kw">var</span> sections = std.ArrayList(macho.section_64).init(gpa);</span>
<span class="line" id="L558"> <span class="tok-kw">var</span> imports = std.ArrayList([]<span class="tok-kw">const</span> <span class="tok-type">u8</span>).init(gpa);</span>
<span class="line" id="L559"></span>
<span class="line" id="L560"> <span class="tok-kw">var</span> it = LoadCommandIterator{</span>
<span class="line" id="L561"> .ncmds = hdr.ncmds,</span>
<span class="line" id="L562"> .buffer = bytes[<span class="tok-builtin">@sizeOf</span>(macho.mach_header_64)..][<span class="tok-number">0</span>..hdr.sizeofcmds],</span>
<span class="line" id="L563"> };</span>
<span class="line" id="L564"> <span class="tok-kw">var</span> i: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L565"> <span class="tok-kw">while</span> (it.next()) |cmd| {</span>
<span class="line" id="L566"> <span class="tok-kw">switch</span> (cmd.cmd()) {</span>
<span class="line" id="L567"> .SEGMENT_64 => {</span>
<span class="line" id="L568"> <span class="tok-kw">const</span> seg = cmd.cast(macho.segment_command_64).?;</span>
<span class="line" id="L569"> <span class="tok-kw">try</span> sections.ensureUnusedCapacity(seg.nsects);</span>
<span class="line" id="L570"> <span class="tok-kw">for</span> (cmd.getSections()) |sect| {</span>
<span class="line" id="L571"> sections.appendAssumeCapacity(sect);</span>
<span class="line" id="L572"> }</span>
<span class="line" id="L573"> },</span>
<span class="line" id="L574"> .SYMTAB => {</span>
<span class="line" id="L575"> <span class="tok-kw">const</span> lc = cmd.cast(macho.symtab_command).?;</span>
<span class="line" id="L576"> <span class="tok-kw">const</span> symbols = <span class="tok-builtin">@as</span>([*]<span class="tok-kw">align</span>(<span class="tok-number">1</span>) <span class="tok-kw">const</span> macho.nlist_64, <span class="tok-builtin">@ptrCast</span>(bytes.ptr + lc.symoff))[<span class="tok-number">0</span>..lc.nsyms];</span>
<span class="line" id="L577"> <span class="tok-kw">const</span> strings = bytes[lc.stroff..][<span class="tok-number">0</span>..lc.strsize];</span>
<span class="line" id="L578"> symtab = .{ .symbols = symbols, .strings = strings };</span>
<span class="line" id="L579"> },</span>
<span class="line" id="L580"> .LOAD_DYLIB,</span>
<span class="line" id="L581"> .LOAD_WEAK_DYLIB,</span>
<span class="line" id="L582"> .REEXPORT_DYLIB,</span>
<span class="line" id="L583"> => {</span>
<span class="line" id="L584"> <span class="tok-kw">try</span> imports.append(cmd.getDylibPathName());</span>
<span class="line" id="L585"> },</span>
<span class="line" id="L586"> <span class="tok-kw">else</span> => {},</span>
<span class="line" id="L587"> }</span>
<span class="line" id="L588"></span>
<span class="line" id="L589"> <span class="tok-kw">try</span> dumpLoadCommand(cmd, i, writer);</span>
<span class="line" id="L590"> <span class="tok-kw">try</span> writer.writeByte(<span class="tok-str">'\n'</span>);</span>
<span class="line" id="L591"></span>
<span class="line" id="L592"> i += <span class="tok-number">1</span>;</span>
<span class="line" id="L593"> }</span>
<span class="line" id="L594"></span>
<span class="line" id="L595"> <span class="tok-kw">if</span> (symtab) |stab| {</span>
<span class="line" id="L596"> <span class="tok-kw">try</span> dumpSymtab(sections.items, imports.items, stab, writer);</span>
<span class="line" id="L597"> }</span>
<span class="line" id="L598"></span>
<span class="line" id="L599"> <span class="tok-kw">return</span> output.toOwnedSlice();</span>
<span class="line" id="L600"> }</span>
<span class="line" id="L601"></span>
<span class="line" id="L602"> <span class="tok-kw">fn</span> <span class="tok-fn">dumpLoadCommand</span>(lc: macho.LoadCommandIterator.LoadCommand, index: <span class="tok-type">usize</span>, writer: <span class="tok-kw">anytype</span>) !<span class="tok-type">void</span> {</span>
<span class="line" id="L603"> <span class="tok-comment">// print header first</span>
</span>
<span class="line" id="L604"> <span class="tok-kw">try</span> writer.print(</span>
<span class="line" id="L605"> <span class="tok-str">\\LC {d}</span></span>
<span class="line" id="L606"> <span class="tok-str">\\cmd {s}</span></span>
<span class="line" id="L607"> <span class="tok-str">\\cmdsize {d}</span></span>
<span class="line" id="L608"> , .{ index, <span class="tok-builtin">@tagName</span>(lc.cmd()), lc.cmdsize() });</span>
<span class="line" id="L609"></span>
<span class="line" id="L610"> <span class="tok-kw">switch</span> (lc.cmd()) {</span>
<span class="line" id="L611"> .SEGMENT_64 => {</span>
<span class="line" id="L612"> <span class="tok-kw">const</span> seg = lc.cast(macho.segment_command_64).?;</span>
<span class="line" id="L613"> <span class="tok-kw">try</span> writer.writeByte(<span class="tok-str">'\n'</span>);</span>
<span class="line" id="L614"> <span class="tok-kw">try</span> writer.print(</span>
<span class="line" id="L615"> <span class="tok-str">\\segname {s}</span></span>
<span class="line" id="L616"> <span class="tok-str">\\vmaddr {x}</span></span>
<span class="line" id="L617"> <span class="tok-str">\\vmsize {x}</span></span>
<span class="line" id="L618"> <span class="tok-str">\\fileoff {x}</span></span>
<span class="line" id="L619"> <span class="tok-str">\\filesz {x}</span></span>
<span class="line" id="L620"> , .{</span>
<span class="line" id="L621"> seg.segName(),</span>
<span class="line" id="L622"> seg.vmaddr,</span>
<span class="line" id="L623"> seg.vmsize,</span>
<span class="line" id="L624"> seg.fileoff,</span>
<span class="line" id="L625"> seg.filesize,</span>
<span class="line" id="L626"> });</span>
<span class="line" id="L627"></span>
<span class="line" id="L628"> <span class="tok-kw">for</span> (lc.getSections()) |sect| {</span>
<span class="line" id="L629"> <span class="tok-kw">try</span> writer.writeByte(<span class="tok-str">'\n'</span>);</span>
<span class="line" id="L630"> <span class="tok-kw">try</span> writer.print(</span>
<span class="line" id="L631"> <span class="tok-str">\\sectname {s}</span></span>
<span class="line" id="L632"> <span class="tok-str">\\addr {x}</span></span>
<span class="line" id="L633"> <span class="tok-str">\\size {x}</span></span>
<span class="line" id="L634"> <span class="tok-str">\\offset {x}</span></span>
<span class="line" id="L635"> <span class="tok-str">\\align {x}</span></span>
<span class="line" id="L636"> , .{</span>
<span class="line" id="L637"> sect.sectName(),</span>
<span class="line" id="L638"> sect.addr,</span>
<span class="line" id="L639"> sect.size,</span>
<span class="line" id="L640"> sect.offset,</span>
<span class="line" id="L641"> sect.@"align",</span>
<span class="line" id="L642"> });</span>
<span class="line" id="L643"> }</span>
<span class="line" id="L644"> },</span>
<span class="line" id="L645"></span>
<span class="line" id="L646"> .ID_DYLIB,</span>
<span class="line" id="L647"> .LOAD_DYLIB,</span>
<span class="line" id="L648"> .LOAD_WEAK_DYLIB,</span>
<span class="line" id="L649"> .REEXPORT_DYLIB,</span>
<span class="line" id="L650"> => {</span>
<span class="line" id="L651"> <span class="tok-kw">const</span> dylib = lc.cast(macho.dylib_command).?;</span>
<span class="line" id="L652"> <span class="tok-kw">try</span> writer.writeByte(<span class="tok-str">'\n'</span>);</span>
<span class="line" id="L653"> <span class="tok-kw">try</span> writer.print(</span>
<span class="line" id="L654"> <span class="tok-str">\\name {s}</span></span>
<span class="line" id="L655"> <span class="tok-str">\\timestamp {d}</span></span>
<span class="line" id="L656"> <span class="tok-str">\\current version {x}</span></span>
<span class="line" id="L657"> <span class="tok-str">\\compatibility version {x}</span></span>
<span class="line" id="L658"> , .{</span>
<span class="line" id="L659"> lc.getDylibPathName(),</span>
<span class="line" id="L660"> dylib.dylib.timestamp,</span>
<span class="line" id="L661"> dylib.dylib.current_version,</span>
<span class="line" id="L662"> dylib.dylib.compatibility_version,</span>
<span class="line" id="L663"> });</span>
<span class="line" id="L664"> },</span>
<span class="line" id="L665"></span>
<span class="line" id="L666"> .MAIN => {</span>
<span class="line" id="L667"> <span class="tok-kw">const</span> main = lc.cast(macho.entry_point_command).?;</span>
<span class="line" id="L668"> <span class="tok-kw">try</span> writer.writeByte(<span class="tok-str">'\n'</span>);</span>
<span class="line" id="L669"> <span class="tok-kw">try</span> writer.print(</span>
<span class="line" id="L670"> <span class="tok-str">\\entryoff {x}</span></span>
<span class="line" id="L671"> <span class="tok-str">\\stacksize {x}</span></span>
<span class="line" id="L672"> , .{ main.entryoff, main.stacksize });</span>
<span class="line" id="L673"> },</span>
<span class="line" id="L674"></span>
<span class="line" id="L675"> .RPATH => {</span>
<span class="line" id="L676"> <span class="tok-kw">try</span> writer.writeByte(<span class="tok-str">'\n'</span>);</span>
<span class="line" id="L677"> <span class="tok-kw">try</span> writer.print(</span>
<span class="line" id="L678"> <span class="tok-str">\\path {s}</span></span>
<span class="line" id="L679"> , .{</span>
<span class="line" id="L680"> lc.getRpathPathName(),</span>
<span class="line" id="L681"> });</span>
<span class="line" id="L682"> },</span>
<span class="line" id="L683"></span>
<span class="line" id="L684"> .UUID => {</span>
<span class="line" id="L685"> <span class="tok-kw">const</span> uuid = lc.cast(macho.uuid_command).?;</span>
<span class="line" id="L686"> <span class="tok-kw">try</span> writer.writeByte(<span class="tok-str">'\n'</span>);</span>
<span class="line" id="L687"> <span class="tok-kw">try</span> writer.print(<span class="tok-str">"uuid {x}"</span>, .{std.fmt.fmtSliceHexLower(&uuid.uuid)});</span>
<span class="line" id="L688"> },</span>
<span class="line" id="L689"></span>
<span class="line" id="L690"> .DATA_IN_CODE,</span>
<span class="line" id="L691"> .FUNCTION_STARTS,</span>
<span class="line" id="L692"> .CODE_SIGNATURE,</span>
<span class="line" id="L693"> => {</span>
<span class="line" id="L694"> <span class="tok-kw">const</span> llc = lc.cast(macho.linkedit_data_command).?;</span>
<span class="line" id="L695"> <span class="tok-kw">try</span> writer.writeByte(<span class="tok-str">'\n'</span>);</span>
<span class="line" id="L696"> <span class="tok-kw">try</span> writer.print(</span>
<span class="line" id="L697"> <span class="tok-str">\\dataoff {x}</span></span>
<span class="line" id="L698"> <span class="tok-str">\\datasize {x}</span></span>
<span class="line" id="L699"> , .{ llc.dataoff, llc.datasize });</span>
<span class="line" id="L700"> },</span>
<span class="line" id="L701"></span>
<span class="line" id="L702"> .DYLD_INFO_ONLY => {</span>
<span class="line" id="L703"> <span class="tok-kw">const</span> dlc = lc.cast(macho.dyld_info_command).?;</span>
<span class="line" id="L704"> <span class="tok-kw">try</span> writer.writeByte(<span class="tok-str">'\n'</span>);</span>
<span class="line" id="L705"> <span class="tok-kw">try</span> writer.print(</span>
<span class="line" id="L706"> <span class="tok-str">\\rebaseoff {x}</span></span>
<span class="line" id="L707"> <span class="tok-str">\\rebasesize {x}</span></span>
<span class="line" id="L708"> <span class="tok-str">\\bindoff {x}</span></span>
<span class="line" id="L709"> <span class="tok-str">\\bindsize {x}</span></span>
<span class="line" id="L710"> <span class="tok-str">\\weakbindoff {x}</span></span>
<span class="line" id="L711"> <span class="tok-str">\\weakbindsize {x}</span></span>
<span class="line" id="L712"> <span class="tok-str">\\lazybindoff {x}</span></span>
<span class="line" id="L713"> <span class="tok-str">\\lazybindsize {x}</span></span>
<span class="line" id="L714"> <span class="tok-str">\\exportoff {x}</span></span>
<span class="line" id="L715"> <span class="tok-str">\\exportsize {x}</span></span>
<span class="line" id="L716"> , .{</span>
<span class="line" id="L717"> dlc.rebase_off,</span>
<span class="line" id="L718"> dlc.rebase_size,</span>
<span class="line" id="L719"> dlc.bind_off,</span>
<span class="line" id="L720"> dlc.bind_size,</span>
<span class="line" id="L721"> dlc.weak_bind_off,</span>
<span class="line" id="L722"> dlc.weak_bind_size,</span>
<span class="line" id="L723"> dlc.lazy_bind_off,</span>
<span class="line" id="L724"> dlc.lazy_bind_size,</span>
<span class="line" id="L725"> dlc.export_off,</span>
<span class="line" id="L726"> dlc.export_size,</span>
<span class="line" id="L727"> });</span>
<span class="line" id="L728"> },</span>
<span class="line" id="L729"></span>
<span class="line" id="L730"> .SYMTAB => {</span>
<span class="line" id="L731"> <span class="tok-kw">const</span> slc = lc.cast(macho.symtab_command).?;</span>
<span class="line" id="L732"> <span class="tok-kw">try</span> writer.writeByte(<span class="tok-str">'\n'</span>);</span>
<span class="line" id="L733"> <span class="tok-kw">try</span> writer.print(</span>
<span class="line" id="L734"> <span class="tok-str">\\symoff {x}</span></span>
<span class="line" id="L735"> <span class="tok-str">\\nsyms {x}</span></span>
<span class="line" id="L736"> <span class="tok-str">\\stroff {x}</span></span>
<span class="line" id="L737"> <span class="tok-str">\\strsize {x}</span></span>
<span class="line" id="L738"> , .{</span>
<span class="line" id="L739"> slc.symoff,</span>
<span class="line" id="L740"> slc.nsyms,</span>
<span class="line" id="L741"> slc.stroff,</span>
<span class="line" id="L742"> slc.strsize,</span>
<span class="line" id="L743"> });</span>
<span class="line" id="L744"> },</span>
<span class="line" id="L745"></span>
<span class="line" id="L746"> .DYSYMTAB => {</span>
<span class="line" id="L747"> <span class="tok-kw">const</span> dlc = lc.cast(macho.dysymtab_command).?;</span>
<span class="line" id="L748"> <span class="tok-kw">try</span> writer.writeByte(<span class="tok-str">'\n'</span>);</span>
<span class="line" id="L749"> <span class="tok-kw">try</span> writer.print(</span>
<span class="line" id="L750"> <span class="tok-str">\\ilocalsym {x}</span></span>
<span class="line" id="L751"> <span class="tok-str">\\nlocalsym {x}</span></span>
<span class="line" id="L752"> <span class="tok-str">\\iextdefsym {x}</span></span>
<span class="line" id="L753"> <span class="tok-str">\\nextdefsym {x}</span></span>
<span class="line" id="L754"> <span class="tok-str">\\iundefsym {x}</span></span>
<span class="line" id="L755"> <span class="tok-str">\\nundefsym {x}</span></span>
<span class="line" id="L756"> <span class="tok-str">\\indirectsymoff {x}</span></span>
<span class="line" id="L757"> <span class="tok-str">\\nindirectsyms {x}</span></span>
<span class="line" id="L758"> , .{</span>
<span class="line" id="L759"> dlc.ilocalsym,</span>
<span class="line" id="L760"> dlc.nlocalsym,</span>
<span class="line" id="L761"> dlc.iextdefsym,</span>
<span class="line" id="L762"> dlc.nextdefsym,</span>
<span class="line" id="L763"> dlc.iundefsym,</span>
<span class="line" id="L764"> dlc.nundefsym,</span>
<span class="line" id="L765"> dlc.indirectsymoff,</span>
<span class="line" id="L766"> dlc.nindirectsyms,</span>
<span class="line" id="L767"> });</span>
<span class="line" id="L768"> },</span>
<span class="line" id="L769"></span>
<span class="line" id="L770"> <span class="tok-kw">else</span> => {},</span>
<span class="line" id="L771"> }</span>
<span class="line" id="L772"> }</span>
<span class="line" id="L773"></span>
<span class="line" id="L774"> <span class="tok-kw">fn</span> <span class="tok-fn">dumpSymtab</span>(</span>
<span class="line" id="L775"> sections: []<span class="tok-kw">const</span> macho.section_64,</span>
<span class="line" id="L776"> imports: []<span class="tok-kw">const</span> []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L777"> symtab: Symtab,</span>
<span class="line" id="L778"> writer: <span class="tok-kw">anytype</span>,</span>
<span class="line" id="L779"> ) !<span class="tok-type">void</span> {</span>
<span class="line" id="L780"> <span class="tok-kw">try</span> writer.writeAll(symtab_label ++ <span class="tok-str">"\n"</span>);</span>
<span class="line" id="L781"></span>
<span class="line" id="L782"> <span class="tok-kw">for</span> (symtab.symbols) |sym| {</span>
<span class="line" id="L783"> <span class="tok-kw">if</span> (sym.stab()) <span class="tok-kw">continue</span>;</span>
<span class="line" id="L784"> <span class="tok-kw">const</span> sym_name = mem.sliceTo(<span class="tok-builtin">@as</span>([*:<span class="tok-number">0</span>]<span class="tok-kw">const</span> <span class="tok-type">u8</span>, <span class="tok-builtin">@ptrCast</span>(symtab.strings.ptr + sym.n_strx)), <span class="tok-number">0</span>);</span>
<span class="line" id="L785"> <span class="tok-kw">if</span> (sym.sect()) {</span>
<span class="line" id="L786"> <span class="tok-kw">const</span> sect = sections[sym.n_sect - <span class="tok-number">1</span>];</span>
<span class="line" id="L787"> <span class="tok-kw">try</span> writer.print(<span class="tok-str">"{x} ({s},{s})"</span>, .{</span>
<span class="line" id="L788"> sym.n_value,</span>
<span class="line" id="L789"> sect.segName(),</span>
<span class="line" id="L790"> sect.sectName(),</span>
<span class="line" id="L791"> });</span>
<span class="line" id="L792"> <span class="tok-kw">if</span> (sym.ext()) {</span>
<span class="line" id="L793"> <span class="tok-kw">try</span> writer.writeAll(<span class="tok-str">" external"</span>);</span>
<span class="line" id="L794"> }</span>
<span class="line" id="L795"> <span class="tok-kw">try</span> writer.print(<span class="tok-str">" {s}\n"</span>, .{sym_name});</span>
<span class="line" id="L796"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (sym.undf()) {</span>
<span class="line" id="L797"> <span class="tok-kw">const</span> ordinal = <span class="tok-builtin">@divTrunc</span>(<span class="tok-builtin">@as</span>(<span class="tok-type">i16</span>, <span class="tok-builtin">@bitCast</span>(sym.n_desc)), macho.N_SYMBOL_RESOLVER);</span>
<span class="line" id="L798"> <span class="tok-kw">const</span> import_name = blk: {</span>
<span class="line" id="L799"> <span class="tok-kw">if</span> (ordinal <= <span class="tok-number">0</span>) {</span>
<span class="line" id="L800"> <span class="tok-kw">if</span> (ordinal == macho.BIND_SPECIAL_DYLIB_SELF)</span>
<span class="line" id="L801"> <span class="tok-kw">break</span> :blk <span class="tok-str">"self import"</span>;</span>
<span class="line" id="L802"> <span class="tok-kw">if</span> (ordinal == macho.BIND_SPECIAL_DYLIB_MAIN_EXECUTABLE)</span>
<span class="line" id="L803"> <span class="tok-kw">break</span> :blk <span class="tok-str">"main executable"</span>;</span>
<span class="line" id="L804"> <span class="tok-kw">if</span> (ordinal == macho.BIND_SPECIAL_DYLIB_FLAT_LOOKUP)</span>
<span class="line" id="L805"> <span class="tok-kw">break</span> :blk <span class="tok-str">"flat lookup"</span>;</span>
<span class="line" id="L806"> <span class="tok-kw">unreachable</span>;</span>
<span class="line" id="L807"> }</span>
<span class="line" id="L808"> <span class="tok-kw">const</span> full_path = imports[<span class="tok-builtin">@as</span>(<span class="tok-type">u16</span>, <span class="tok-builtin">@bitCast</span>(ordinal)) - <span class="tok-number">1</span>];</span>
<span class="line" id="L809"> <span class="tok-kw">const</span> basename = fs.path.basename(full_path);</span>
<span class="line" id="L810"> assert(basename.len > <span class="tok-number">0</span>);</span>
<span class="line" id="L811"> <span class="tok-kw">const</span> ext = mem.lastIndexOfScalar(<span class="tok-type">u8</span>, basename, <span class="tok-str">'.'</span>) <span class="tok-kw">orelse</span> basename.len;</span>
<span class="line" id="L812"> <span class="tok-kw">break</span> :blk basename[<span class="tok-number">0</span>..ext];</span>
<span class="line" id="L813"> };</span>
<span class="line" id="L814"> <span class="tok-kw">try</span> writer.writeAll(<span class="tok-str">"(undefined)"</span>);</span>
<span class="line" id="L815"> <span class="tok-kw">if</span> (sym.weakRef()) {</span>
<span class="line" id="L816"> <span class="tok-kw">try</span> writer.writeAll(<span class="tok-str">" weak"</span>);</span>
<span class="line" id="L817"> }</span>
<span class="line" id="L818"> <span class="tok-kw">if</span> (sym.ext()) {</span>
<span class="line" id="L819"> <span class="tok-kw">try</span> writer.writeAll(<span class="tok-str">" external"</span>);</span>
<span class="line" id="L820"> }</span>
<span class="line" id="L821"> <span class="tok-kw">try</span> writer.print(<span class="tok-str">" {s} (from {s})\n"</span>, .{</span>
<span class="line" id="L822"> sym_name,</span>
<span class="line" id="L823"> import_name,</span>
<span class="line" id="L824"> });</span>
<span class="line" id="L825"> } <span class="tok-kw">else</span> <span class="tok-kw">unreachable</span>;</span>
<span class="line" id="L826"> }</span>
<span class="line" id="L827"> }</span>
<span class="line" id="L828">};</span>
<span class="line" id="L829"></span>
<span class="line" id="L830"><span class="tok-kw">const</span> ElfDumper = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L831"> <span class="tok-kw">const</span> symtab_label = <span class="tok-str">"symbol table"</span>;</span>
<span class="line" id="L832"> <span class="tok-kw">const</span> dynamic_symtab_label = <span class="tok-str">"dynamic symbol table"</span>;</span>
<span class="line" id="L833"> <span class="tok-kw">const</span> dynamic_section_label = <span class="tok-str">"dynamic section"</span>;</span>
<span class="line" id="L834"></span>
<span class="line" id="L835"> <span class="tok-kw">const</span> Symtab = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L836"> symbols: []<span class="tok-kw">align</span>(<span class="tok-number">1</span>) <span class="tok-kw">const</span> elf.Elf64_Sym,</span>
<span class="line" id="L837"> strings: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L838"></span>
<span class="line" id="L839"> <span class="tok-kw">fn</span> <span class="tok-fn">get</span>(st: Symtab, index: <span class="tok-type">usize</span>) ?elf.Elf64_Sym {</span>
<span class="line" id="L840"> <span class="tok-kw">if</span> (index >= st.symbols.len) <span class="tok-kw">return</span> <span class="tok-null">null</span>;</span>
<span class="line" id="L841"> <span class="tok-kw">return</span> st.symbols[index];</span>
<span class="line" id="L842"> }</span>
<span class="line" id="L843"></span>
<span class="line" id="L844"> <span class="tok-kw">fn</span> <span class="tok-fn">getName</span>(st: Symtab, index: <span class="tok-type">usize</span>) ?[]<span class="tok-kw">const</span> <span class="tok-type">u8</span> {</span>
<span class="line" id="L845"> <span class="tok-kw">const</span> sym = st.get(index) <span class="tok-kw">orelse</span> <span class="tok-kw">return</span> <span class="tok-null">null</span>;</span>
<span class="line" id="L846"> <span class="tok-kw">return</span> getString(st.strings, sym.st_name);</span>
<span class="line" id="L847"> }</span>
<span class="line" id="L848"> };</span>
<span class="line" id="L849"></span>
<span class="line" id="L850"> <span class="tok-kw">const</span> Context = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L851"> gpa: Allocator,</span>
<span class="line" id="L852"> data: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L853"> hdr: elf.Elf64_Ehdr,</span>
<span class="line" id="L854"> shdrs: []<span class="tok-kw">align</span>(<span class="tok-number">1</span>) <span class="tok-kw">const</span> elf.Elf64_Shdr,</span>
<span class="line" id="L855"> phdrs: []<span class="tok-kw">align</span>(<span class="tok-number">1</span>) <span class="tok-kw">const</span> elf.Elf64_Phdr,</span>
<span class="line" id="L856"> shstrtab: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L857"> symtab: ?Symtab = <span class="tok-null">null</span>,</span>
<span class="line" id="L858"> dysymtab: ?Symtab = <span class="tok-null">null</span>,</span>
<span class="line" id="L859"> };</span>
<span class="line" id="L860"></span>
<span class="line" id="L861"> <span class="tok-kw">fn</span> <span class="tok-fn">parseAndDump</span>(step: *Step, bytes: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) ![]<span class="tok-kw">const</span> <span class="tok-type">u8</span> {</span>
<span class="line" id="L862"> <span class="tok-kw">const</span> gpa = step.owner.allocator;</span>
<span class="line" id="L863"> <span class="tok-kw">var</span> stream = std.io.fixedBufferStream(bytes);</span>
<span class="line" id="L864"> <span class="tok-kw">const</span> reader = stream.reader();</span>
<span class="line" id="L865"></span>
<span class="line" id="L866"> <span class="tok-kw">const</span> hdr = <span class="tok-kw">try</span> reader.readStruct(elf.Elf64_Ehdr);</span>
<span class="line" id="L867"> <span class="tok-kw">if</span> (!mem.eql(<span class="tok-type">u8</span>, hdr.e_ident[<span class="tok-number">0</span>..<span class="tok-number">4</span>], <span class="tok-str">"\x7fELF"</span>)) {</span>
<span class="line" id="L868"> <span class="tok-kw">return</span> <span class="tok-kw">error</span>.InvalidMagicNumber;</span>
<span class="line" id="L869"> }</span>
<span class="line" id="L870"></span>
<span class="line" id="L871"> <span class="tok-kw">const</span> shdrs = <span class="tok-builtin">@as</span>([*]<span class="tok-kw">align</span>(<span class="tok-number">1</span>) <span class="tok-kw">const</span> elf.Elf64_Shdr, <span class="tok-builtin">@ptrCast</span>(bytes.ptr + hdr.e_shoff))[<span class="tok-number">0</span>..hdr.e_shnum];</span>
<span class="line" id="L872"> <span class="tok-kw">const</span> phdrs = <span class="tok-builtin">@as</span>([*]<span class="tok-kw">align</span>(<span class="tok-number">1</span>) <span class="tok-kw">const</span> elf.Elf64_Phdr, <span class="tok-builtin">@ptrCast</span>(bytes.ptr + hdr.e_phoff))[<span class="tok-number">0</span>..hdr.e_phnum];</span>
<span class="line" id="L873"></span>
<span class="line" id="L874"> <span class="tok-kw">var</span> ctx = Context{</span>
<span class="line" id="L875"> .gpa = gpa,</span>
<span class="line" id="L876"> .data = bytes,</span>
<span class="line" id="L877"> .hdr = hdr,</span>
<span class="line" id="L878"> .shdrs = shdrs,</span>
<span class="line" id="L879"> .phdrs = phdrs,</span>
<span class="line" id="L880"> .shstrtab = <span class="tok-null">undefined</span>,</span>
<span class="line" id="L881"> };</span>
<span class="line" id="L882"> ctx.shstrtab = getSectionContents(ctx, ctx.hdr.e_shstrndx);</span>
<span class="line" id="L883"></span>
<span class="line" id="L884"> <span class="tok-kw">for</span> (ctx.shdrs, <span class="tok-number">0</span>..) |shdr, i| <span class="tok-kw">switch</span> (shdr.sh_type) {</span>
<span class="line" id="L885"> elf.SHT_SYMTAB, elf.SHT_DYNSYM => {</span>
<span class="line" id="L886"> <span class="tok-kw">const</span> raw = getSectionContents(ctx, i);</span>
<span class="line" id="L887"> <span class="tok-kw">const</span> nsyms = <span class="tok-builtin">@divExact</span>(raw.len, <span class="tok-builtin">@sizeOf</span>(elf.Elf64_Sym));</span>
<span class="line" id="L888"> <span class="tok-kw">const</span> symbols = <span class="tok-builtin">@as</span>([*]<span class="tok-kw">align</span>(<span class="tok-number">1</span>) <span class="tok-kw">const</span> elf.Elf64_Sym, <span class="tok-builtin">@ptrCast</span>(raw.ptr))[<span class="tok-number">0</span>..nsyms];</span>
<span class="line" id="L889"> <span class="tok-kw">const</span> strings = getSectionContents(ctx, shdr.sh_link);</span>
<span class="line" id="L890"></span>
<span class="line" id="L891"> <span class="tok-kw">switch</span> (shdr.sh_type) {</span>
<span class="line" id="L892"> elf.SHT_SYMTAB => {</span>
<span class="line" id="L893"> ctx.symtab = .{</span>
<span class="line" id="L894"> .symbols = symbols,</span>
<span class="line" id="L895"> .strings = strings,</span>
<span class="line" id="L896"> };</span>
<span class="line" id="L897"> },</span>
<span class="line" id="L898"> elf.SHT_DYNSYM => {</span>
<span class="line" id="L899"> ctx.dysymtab = .{</span>
<span class="line" id="L900"> .symbols = symbols,</span>
<span class="line" id="L901"> .strings = strings,</span>
<span class="line" id="L902"> };</span>
<span class="line" id="L903"> },</span>
<span class="line" id="L904"> <span class="tok-kw">else</span> => <span class="tok-kw">unreachable</span>,</span>
<span class="line" id="L905"> }</span>
<span class="line" id="L906"> },</span>
<span class="line" id="L907"></span>
<span class="line" id="L908"> <span class="tok-kw">else</span> => {},</span>
<span class="line" id="L909"> };</span>
<span class="line" id="L910"></span>
<span class="line" id="L911"> <span class="tok-kw">var</span> output = std.ArrayList(<span class="tok-type">u8</span>).init(gpa);</span>
<span class="line" id="L912"> <span class="tok-kw">const</span> writer = output.writer();</span>
<span class="line" id="L913"></span>
<span class="line" id="L914"> <span class="tok-kw">try</span> dumpHeader(ctx, writer);</span>
<span class="line" id="L915"> <span class="tok-kw">try</span> dumpShdrs(ctx, writer);</span>
<span class="line" id="L916"> <span class="tok-kw">try</span> dumpPhdrs(ctx, writer);</span>
<span class="line" id="L917"> <span class="tok-kw">try</span> dumpDynamicSection(ctx, writer);</span>
<span class="line" id="L918"> <span class="tok-kw">try</span> dumpSymtab(ctx, .symtab, writer);</span>
<span class="line" id="L919"> <span class="tok-kw">try</span> dumpSymtab(ctx, .dysymtab, writer);</span>
<span class="line" id="L920"></span>
<span class="line" id="L921"> <span class="tok-kw">return</span> output.toOwnedSlice();</span>
<span class="line" id="L922"> }</span>
<span class="line" id="L923"></span>
<span class="line" id="L924"> <span class="tok-kw">inline</span> <span class="tok-kw">fn</span> <span class="tok-fn">getSectionName</span>(ctx: Context, shndx: <span class="tok-type">usize</span>) []<span class="tok-kw">const</span> <span class="tok-type">u8</span> {</span>
<span class="line" id="L925"> <span class="tok-kw">const</span> shdr = ctx.shdrs[shndx];</span>
<span class="line" id="L926"> <span class="tok-kw">return</span> getString(ctx.shstrtab, shdr.sh_name);</span>
<span class="line" id="L927"> }</span>
<span class="line" id="L928"></span>
<span class="line" id="L929"> <span class="tok-kw">fn</span> <span class="tok-fn">getSectionContents</span>(ctx: Context, shndx: <span class="tok-type">usize</span>) []<span class="tok-kw">const</span> <span class="tok-type">u8</span> {</span>
<span class="line" id="L930"> <span class="tok-kw">const</span> shdr = ctx.shdrs[shndx];</span>
<span class="line" id="L931"> assert(shdr.sh_offset < ctx.data.len);</span>
<span class="line" id="L932"> assert(shdr.sh_offset + shdr.sh_size <= ctx.data.len);</span>
<span class="line" id="L933"> <span class="tok-kw">return</span> ctx.data[shdr.sh_offset..][<span class="tok-number">0</span>..shdr.sh_size];</span>
<span class="line" id="L934"> }</span>
<span class="line" id="L935"></span>
<span class="line" id="L936"> <span class="tok-kw">fn</span> <span class="tok-fn">getSectionByName</span>(ctx: Context, name: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) ?<span class="tok-type">usize</span> {</span>
<span class="line" id="L937"> <span class="tok-kw">for</span> (<span class="tok-number">0</span>..ctx.shdrs.len) |shndx| {</span>
<span class="line" id="L938"> <span class="tok-kw">if</span> (mem.eql(<span class="tok-type">u8</span>, getSectionName(ctx, shndx), name)) <span class="tok-kw">return</span> shndx;</span>
<span class="line" id="L939"> } <span class="tok-kw">else</span> <span class="tok-kw">return</span> <span class="tok-null">null</span>;</span>
<span class="line" id="L940"> }</span>
<span class="line" id="L941"></span>
<span class="line" id="L942"> <span class="tok-kw">fn</span> <span class="tok-fn">getString</span>(strtab: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>, off: <span class="tok-type">u32</span>) []<span class="tok-kw">const</span> <span class="tok-type">u8</span> {</span>
<span class="line" id="L943"> assert(off < strtab.len);</span>
<span class="line" id="L944"> <span class="tok-kw">return</span> mem.sliceTo(<span class="tok-builtin">@as</span>([*:<span class="tok-number">0</span>]<span class="tok-kw">const</span> <span class="tok-type">u8</span>, <span class="tok-builtin">@ptrCast</span>(strtab.ptr + off)), <span class="tok-number">0</span>);</span>
<span class="line" id="L945"> }</span>
<span class="line" id="L946"></span>
<span class="line" id="L947"> <span class="tok-kw">fn</span> <span class="tok-fn">dumpHeader</span>(ctx: Context, writer: <span class="tok-kw">anytype</span>) !<span class="tok-type">void</span> {</span>
<span class="line" id="L948"> <span class="tok-kw">try</span> writer.writeAll(<span class="tok-str">"header\n"</span>);</span>
<span class="line" id="L949"> <span class="tok-kw">try</span> writer.print(<span class="tok-str">"type {s}\n"</span>, .{<span class="tok-builtin">@tagName</span>(ctx.hdr.e_type)});</span>
<span class="line" id="L950"> <span class="tok-kw">try</span> writer.print(<span class="tok-str">"entry {x}\n"</span>, .{ctx.hdr.e_entry});</span>
<span class="line" id="L951"> }</span>
<span class="line" id="L952"></span>
<span class="line" id="L953"> <span class="tok-kw">fn</span> <span class="tok-fn">dumpShdrs</span>(ctx: Context, writer: <span class="tok-kw">anytype</span>) !<span class="tok-type">void</span> {</span>
<span class="line" id="L954"> <span class="tok-kw">if</span> (ctx.shdrs.len == <span class="tok-number">0</span>) <span class="tok-kw">return</span>;</span>
<span class="line" id="L955"></span>
<span class="line" id="L956"> <span class="tok-kw">try</span> writer.writeAll(<span class="tok-str">"section headers\n"</span>);</span>
<span class="line" id="L957"></span>
<span class="line" id="L958"> <span class="tok-kw">for</span> (ctx.shdrs, <span class="tok-number">0</span>..) |shdr, shndx| {</span>
<span class="line" id="L959"> <span class="tok-kw">try</span> writer.print(<span class="tok-str">"shdr {d}\n"</span>, .{shndx});</span>
<span class="line" id="L960"> <span class="tok-kw">try</span> writer.print(<span class="tok-str">"name {s}\n"</span>, .{getSectionName(ctx, shndx)});</span>
<span class="line" id="L961"> <span class="tok-kw">try</span> writer.print(<span class="tok-str">"type {s}\n"</span>, .{fmtShType(shdr.sh_type)});</span>
<span class="line" id="L962"> <span class="tok-kw">try</span> writer.print(<span class="tok-str">"addr {x}\n"</span>, .{shdr.sh_addr});</span>
<span class="line" id="L963"> <span class="tok-kw">try</span> writer.print(<span class="tok-str">"offset {x}\n"</span>, .{shdr.sh_offset});</span>
<span class="line" id="L964"> <span class="tok-kw">try</span> writer.print(<span class="tok-str">"size {x}\n"</span>, .{shdr.sh_size});</span>
<span class="line" id="L965"> <span class="tok-kw">try</span> writer.print(<span class="tok-str">"addralign {x}\n"</span>, .{shdr.sh_addralign});</span>
<span class="line" id="L966"> <span class="tok-comment">// TODO dump formatted sh_flags</span>
</span>
<span class="line" id="L967"> }</span>
<span class="line" id="L968"> }</span>
<span class="line" id="L969"></span>
<span class="line" id="L970"> <span class="tok-kw">fn</span> <span class="tok-fn">dumpDynamicSection</span>(ctx: Context, writer: <span class="tok-kw">anytype</span>) !<span class="tok-type">void</span> {</span>
<span class="line" id="L971"> <span class="tok-kw">const</span> shndx = getSectionByName(ctx, <span class="tok-str">".dynamic"</span>) <span class="tok-kw">orelse</span> <span class="tok-kw">return</span>;</span>
<span class="line" id="L972"> <span class="tok-kw">const</span> shdr = ctx.shdrs[shndx];</span>
<span class="line" id="L973"> <span class="tok-kw">const</span> strtab = getSectionContents(ctx, shdr.sh_link);</span>
<span class="line" id="L974"> <span class="tok-kw">const</span> data = getSectionContents(ctx, shndx);</span>
<span class="line" id="L975"> <span class="tok-kw">const</span> nentries = <span class="tok-builtin">@divExact</span>(data.len, <span class="tok-builtin">@sizeOf</span>(elf.Elf64_Dyn));</span>
<span class="line" id="L976"> <span class="tok-kw">const</span> entries = <span class="tok-builtin">@as</span>([*]<span class="tok-kw">align</span>(<span class="tok-number">1</span>) <span class="tok-kw">const</span> elf.Elf64_Dyn, <span class="tok-builtin">@ptrCast</span>(data.ptr))[<span class="tok-number">0</span>..nentries];</span>
<span class="line" id="L977"></span>
<span class="line" id="L978"> <span class="tok-kw">try</span> writer.writeAll(ElfDumper.dynamic_section_label ++ <span class="tok-str">"\n"</span>);</span>
<span class="line" id="L979"></span>
<span class="line" id="L980"> <span class="tok-kw">for</span> (entries) |entry| {</span>
<span class="line" id="L981"> <span class="tok-kw">const</span> key = <span class="tok-builtin">@as</span>(<span class="tok-type">u64</span>, <span class="tok-builtin">@bitCast</span>(entry.d_tag));</span>
<span class="line" id="L982"> <span class="tok-kw">const</span> value = entry.d_val;</span>
<span class="line" id="L983"></span>
<span class="line" id="L984"> <span class="tok-kw">const</span> key_str = <span class="tok-kw">switch</span> (key) {</span>
<span class="line" id="L985"> elf.DT_NEEDED => <span class="tok-str">"NEEDED"</span>,</span>
<span class="line" id="L986"> elf.DT_SONAME => <span class="tok-str">"SONAME"</span>,</span>
<span class="line" id="L987"> elf.DT_INIT_ARRAY => <span class="tok-str">"INIT_ARRAY"</span>,</span>
<span class="line" id="L988"> elf.DT_INIT_ARRAYSZ => <span class="tok-str">"INIT_ARRAYSZ"</span>,</span>
<span class="line" id="L989"> elf.DT_FINI_ARRAY => <span class="tok-str">"FINI_ARRAY"</span>,</span>
<span class="line" id="L990"> elf.DT_FINI_ARRAYSZ => <span class="tok-str">"FINI_ARRAYSZ"</span>,</span>
<span class="line" id="L991"> elf.DT_HASH => <span class="tok-str">"HASH"</span>,</span>
<span class="line" id="L992"> elf.DT_GNU_HASH => <span class="tok-str">"GNU_HASH"</span>,</span>
<span class="line" id="L993"> elf.DT_STRTAB => <span class="tok-str">"STRTAB"</span>,</span>
<span class="line" id="L994"> elf.DT_SYMTAB => <span class="tok-str">"SYMTAB"</span>,</span>
<span class="line" id="L995"> elf.DT_STRSZ => <span class="tok-str">"STRSZ"</span>,</span>
<span class="line" id="L996"> elf.DT_SYMENT => <span class="tok-str">"SYMENT"</span>,</span>
<span class="line" id="L997"> elf.DT_PLTGOT => <span class="tok-str">"PLTGOT"</span>,</span>
<span class="line" id="L998"> elf.DT_PLTRELSZ => <span class="tok-str">"PLTRELSZ"</span>,</span>
<span class="line" id="L999"> elf.DT_PLTREL => <span class="tok-str">"PLTREL"</span>,</span>
<span class="line" id="L1000"> elf.DT_JMPREL => <span class="tok-str">"JMPREL"</span>,</span>
<span class="line" id="L1001"> elf.DT_RELA => <span class="tok-str">"RELA"</span>,</span>
<span class="line" id="L1002"> elf.DT_RELASZ => <span class="tok-str">"RELASZ"</span>,</span>
<span class="line" id="L1003"> elf.DT_RELAENT => <span class="tok-str">"RELAENT"</span>,</span>
<span class="line" id="L1004"> elf.DT_VERDEF => <span class="tok-str">"VERDEF"</span>,</span>
<span class="line" id="L1005"> elf.DT_VERDEFNUM => <span class="tok-str">"VERDEFNUM"</span>,</span>
<span class="line" id="L1006"> elf.DT_FLAGS => <span class="tok-str">"FLAGS"</span>,</span>
<span class="line" id="L1007"> elf.DT_FLAGS_1 => <span class="tok-str">"FLAGS_1"</span>,</span>
<span class="line" id="L1008"> elf.DT_VERNEED => <span class="tok-str">"VERNEED"</span>,</span>
<span class="line" id="L1009"> elf.DT_VERNEEDNUM => <span class="tok-str">"VERNEEDNUM"</span>,</span>
<span class="line" id="L1010"> elf.DT_VERSYM => <span class="tok-str">"VERSYM"</span>,</span>
<span class="line" id="L1011"> elf.DT_RELACOUNT => <span class="tok-str">"RELACOUNT"</span>,</span>
<span class="line" id="L1012"> elf.DT_RPATH => <span class="tok-str">"RPATH"</span>,</span>
<span class="line" id="L1013"> elf.DT_RUNPATH => <span class="tok-str">"RUNPATH"</span>,</span>
<span class="line" id="L1014"> elf.DT_INIT => <span class="tok-str">"INIT"</span>,</span>
<span class="line" id="L1015"> elf.DT_FINI => <span class="tok-str">"FINI"</span>,</span>
<span class="line" id="L1016"> elf.DT_NULL => <span class="tok-str">"NULL"</span>,</span>
<span class="line" id="L1017"> <span class="tok-kw">else</span> => <span class="tok-str">"UNKNOWN"</span>,</span>
<span class="line" id="L1018"> };</span>
<span class="line" id="L1019"> <span class="tok-kw">try</span> writer.print(<span class="tok-str">"{s}"</span>, .{key_str});</span>
<span class="line" id="L1020"></span>
<span class="line" id="L1021"> <span class="tok-kw">switch</span> (key) {</span>
<span class="line" id="L1022"> elf.DT_NEEDED,</span>
<span class="line" id="L1023"> elf.DT_SONAME,</span>
<span class="line" id="L1024"> elf.DT_RPATH,</span>
<span class="line" id="L1025"> elf.DT_RUNPATH,</span>
<span class="line" id="L1026"> => {</span>
<span class="line" id="L1027"> <span class="tok-kw">const</span> name = getString(strtab, <span class="tok-builtin">@intCast</span>(value));</span>
<span class="line" id="L1028"> <span class="tok-kw">try</span> writer.print(<span class="tok-str">" {s}"</span>, .{name});</span>
<span class="line" id="L1029"> },</span>
<span class="line" id="L1030"></span>
<span class="line" id="L1031"> elf.DT_INIT_ARRAY,</span>
<span class="line" id="L1032"> elf.DT_FINI_ARRAY,</span>
<span class="line" id="L1033"> elf.DT_HASH,</span>
<span class="line" id="L1034"> elf.DT_GNU_HASH,</span>
<span class="line" id="L1035"> elf.DT_STRTAB,</span>
<span class="line" id="L1036"> elf.DT_SYMTAB,</span>
<span class="line" id="L1037"> elf.DT_PLTGOT,</span>
<span class="line" id="L1038"> elf.DT_JMPREL,</span>
<span class="line" id="L1039"> elf.DT_RELA,</span>
<span class="line" id="L1040"> elf.DT_VERDEF,</span>
<span class="line" id="L1041"> elf.DT_VERNEED,</span>
<span class="line" id="L1042"> elf.DT_VERSYM,</span>
<span class="line" id="L1043"> elf.DT_INIT,</span>
<span class="line" id="L1044"> elf.DT_FINI,</span>
<span class="line" id="L1045"> elf.DT_NULL,</span>
<span class="line" id="L1046"> => <span class="tok-kw">try</span> writer.print(<span class="tok-str">" {x}"</span>, .{value}),</span>
<span class="line" id="L1047"></span>
<span class="line" id="L1048"> elf.DT_INIT_ARRAYSZ,</span>
<span class="line" id="L1049"> elf.DT_FINI_ARRAYSZ,</span>
<span class="line" id="L1050"> elf.DT_STRSZ,</span>
<span class="line" id="L1051"> elf.DT_SYMENT,</span>
<span class="line" id="L1052"> elf.DT_PLTRELSZ,</span>
<span class="line" id="L1053"> elf.DT_RELASZ,</span>
<span class="line" id="L1054"> elf.DT_RELAENT,</span>
<span class="line" id="L1055"> elf.DT_RELACOUNT,</span>
<span class="line" id="L1056"> => <span class="tok-kw">try</span> writer.print(<span class="tok-str">" {d}"</span>, .{value}),</span>
<span class="line" id="L1057"></span>
<span class="line" id="L1058"> elf.DT_PLTREL => <span class="tok-kw">try</span> writer.writeAll(<span class="tok-kw">switch</span> (value) {</span>
<span class="line" id="L1059"> elf.DT_REL => <span class="tok-str">" REL"</span>,</span>
<span class="line" id="L1060"> elf.DT_RELA => <span class="tok-str">" RELA"</span>,</span>
<span class="line" id="L1061"> <span class="tok-kw">else</span> => <span class="tok-str">" UNKNOWN"</span>,</span>
<span class="line" id="L1062"> }),</span>
<span class="line" id="L1063"></span>
<span class="line" id="L1064"> elf.DT_FLAGS => <span class="tok-kw">if</span> (value > <span class="tok-number">0</span>) {</span>
<span class="line" id="L1065"> <span class="tok-kw">if</span> (value & elf.DF_ORIGIN != <span class="tok-number">0</span>) <span class="tok-kw">try</span> writer.writeAll(<span class="tok-str">" ORIGIN"</span>);</span>
<span class="line" id="L1066"> <span class="tok-kw">if</span> (value & elf.DF_SYMBOLIC != <span class="tok-number">0</span>) <span class="tok-kw">try</span> writer.writeAll(<span class="tok-str">" SYMBOLIC"</span>);</span>
<span class="line" id="L1067"> <span class="tok-kw">if</span> (value & elf.DF_TEXTREL != <span class="tok-number">0</span>) <span class="tok-kw">try</span> writer.writeAll(<span class="tok-str">" TEXTREL"</span>);</span>
<span class="line" id="L1068"> <span class="tok-kw">if</span> (value & elf.DF_BIND_NOW != <span class="tok-number">0</span>) <span class="tok-kw">try</span> writer.writeAll(<span class="tok-str">" BIND_NOW"</span>);</span>
<span class="line" id="L1069"> <span class="tok-kw">if</span> (value & elf.DF_STATIC_TLS != <span class="tok-number">0</span>) <span class="tok-kw">try</span> writer.writeAll(<span class="tok-str">" STATIC_TLS"</span>);</span>
<span class="line" id="L1070"> },</span>
<span class="line" id="L1071"></span>
<span class="line" id="L1072"> elf.DT_FLAGS_1 => <span class="tok-kw">if</span> (value > <span class="tok-number">0</span>) {</span>
<span class="line" id="L1073"> <span class="tok-kw">if</span> (value & elf.DF_1_NOW != <span class="tok-number">0</span>) <span class="tok-kw">try</span> writer.writeAll(<span class="tok-str">" NOW"</span>);</span>
<span class="line" id="L1074"> <span class="tok-kw">if</span> (value & elf.DF_1_GLOBAL != <span class="tok-number">0</span>) <span class="tok-kw">try</span> writer.writeAll(<span class="tok-str">" GLOBAL"</span>);</span>
<span class="line" id="L1075"> <span class="tok-kw">if</span> (value & elf.DF_1_GROUP != <span class="tok-number">0</span>) <span class="tok-kw">try</span> writer.writeAll(<span class="tok-str">" GROUP"</span>);</span>
<span class="line" id="L1076"> <span class="tok-kw">if</span> (value & elf.DF_1_NODELETE != <span class="tok-number">0</span>) <span class="tok-kw">try</span> writer.writeAll(<span class="tok-str">" NODELETE"</span>);</span>
<span class="line" id="L1077"> <span class="tok-kw">if</span> (value & elf.DF_1_LOADFLTR != <span class="tok-number">0</span>) <span class="tok-kw">try</span> writer.writeAll(<span class="tok-str">" LOADFLTR"</span>);</span>
<span class="line" id="L1078"> <span class="tok-kw">if</span> (value & elf.DF_1_INITFIRST != <span class="tok-number">0</span>) <span class="tok-kw">try</span> writer.writeAll(<span class="tok-str">" INITFIRST"</span>);</span>
<span class="line" id="L1079"> <span class="tok-kw">if</span> (value & elf.DF_1_NOOPEN != <span class="tok-number">0</span>) <span class="tok-kw">try</span> writer.writeAll(<span class="tok-str">" NOOPEN"</span>);</span>
<span class="line" id="L1080"> <span class="tok-kw">if</span> (value & elf.DF_1_ORIGIN != <span class="tok-number">0</span>) <span class="tok-kw">try</span> writer.writeAll(<span class="tok-str">" ORIGIN"</span>);</span>
<span class="line" id="L1081"> <span class="tok-kw">if</span> (value & elf.DF_1_DIRECT != <span class="tok-number">0</span>) <span class="tok-kw">try</span> writer.writeAll(<span class="tok-str">" DIRECT"</span>);</span>
<span class="line" id="L1082"> <span class="tok-kw">if</span> (value & elf.DF_1_TRANS != <span class="tok-number">0</span>) <span class="tok-kw">try</span> writer.writeAll(<span class="tok-str">" TRANS"</span>);</span>
<span class="line" id="L1083"> <span class="tok-kw">if</span> (value & elf.DF_1_INTERPOSE != <span class="tok-number">0</span>) <span class="tok-kw">try</span> writer.writeAll(<span class="tok-str">" INTERPOSE"</span>);</span>
<span class="line" id="L1084"> <span class="tok-kw">if</span> (value & elf.DF_1_NODEFLIB != <span class="tok-number">0</span>) <span class="tok-kw">try</span> writer.writeAll(<span class="tok-str">" NODEFLIB"</span>);</span>
<span class="line" id="L1085"> <span class="tok-kw">if</span> (value & elf.DF_1_NODUMP != <span class="tok-number">0</span>) <span class="tok-kw">try</span> writer.writeAll(<span class="tok-str">" NODUMP"</span>);</span>
<span class="line" id="L1086"> <span class="tok-kw">if</span> (value & elf.DF_1_CONFALT != <span class="tok-number">0</span>) <span class="tok-kw">try</span> writer.writeAll(<span class="tok-str">" CONFALT"</span>);</span>
<span class="line" id="L1087"> <span class="tok-kw">if</span> (value & elf.DF_1_ENDFILTEE != <span class="tok-number">0</span>) <span class="tok-kw">try</span> writer.writeAll(<span class="tok-str">" ENDFILTEE"</span>);</span>
<span class="line" id="L1088"> <span class="tok-kw">if</span> (value & elf.DF_1_DISPRELDNE != <span class="tok-number">0</span>) <span class="tok-kw">try</span> writer.writeAll(<span class="tok-str">" DISPRELDNE"</span>);</span>
<span class="line" id="L1089"> <span class="tok-kw">if</span> (value & elf.DF_1_DISPRELPND != <span class="tok-number">0</span>) <span class="tok-kw">try</span> writer.writeAll(<span class="tok-str">" DISPRELPND"</span>);</span>
<span class="line" id="L1090"> <span class="tok-kw">if</span> (value & elf.DF_1_NODIRECT != <span class="tok-number">0</span>) <span class="tok-kw">try</span> writer.writeAll(<span class="tok-str">" NODIRECT"</span>);</span>
<span class="line" id="L1091"> <span class="tok-kw">if</span> (value & elf.DF_1_IGNMULDEF != <span class="tok-number">0</span>) <span class="tok-kw">try</span> writer.writeAll(<span class="tok-str">" IGNMULDEF"</span>);</span>
<span class="line" id="L1092"> <span class="tok-kw">if</span> (value & elf.DF_1_NOKSYMS != <span class="tok-number">0</span>) <span class="tok-kw">try</span> writer.writeAll(<span class="tok-str">" NOKSYMS"</span>);</span>
<span class="line" id="L1093"> <span class="tok-kw">if</span> (value & elf.DF_1_NOHDR != <span class="tok-number">0</span>) <span class="tok-kw">try</span> writer.writeAll(<span class="tok-str">" NOHDR"</span>);</span>
<span class="line" id="L1094"> <span class="tok-kw">if</span> (value & elf.DF_1_EDITED != <span class="tok-number">0</span>) <span class="tok-kw">try</span> writer.writeAll(<span class="tok-str">" EDITED"</span>);</span>
<span class="line" id="L1095"> <span class="tok-kw">if</span> (value & elf.DF_1_NORELOC != <span class="tok-number">0</span>) <span class="tok-kw">try</span> writer.writeAll(<span class="tok-str">" NORELOC"</span>);</span>
<span class="line" id="L1096"> <span class="tok-kw">if</span> (value & elf.DF_1_SYMINTPOSE != <span class="tok-number">0</span>) <span class="tok-kw">try</span> writer.writeAll(<span class="tok-str">" SYMINTPOSE"</span>);</span>
<span class="line" id="L1097"> <span class="tok-kw">if</span> (value & elf.DF_1_GLOBAUDIT != <span class="tok-number">0</span>) <span class="tok-kw">try</span> writer.writeAll(<span class="tok-str">" GLOBAUDIT"</span>);</span>
<span class="line" id="L1098"> <span class="tok-kw">if</span> (value & elf.DF_1_SINGLETON != <span class="tok-number">0</span>) <span class="tok-kw">try</span> writer.writeAll(<span class="tok-str">" SINGLETON"</span>);</span>
<span class="line" id="L1099"> <span class="tok-kw">if</span> (value & elf.DF_1_STUB != <span class="tok-number">0</span>) <span class="tok-kw">try</span> writer.writeAll(<span class="tok-str">" STUB"</span>);</span>
<span class="line" id="L1100"> <span class="tok-kw">if</span> (value & elf.DF_1_PIE != <span class="tok-number">0</span>) <span class="tok-kw">try</span> writer.writeAll(<span class="tok-str">" PIE"</span>);</span>
<span class="line" id="L1101"> },</span>
<span class="line" id="L1102"></span>
<span class="line" id="L1103"> <span class="tok-kw">else</span> => <span class="tok-kw">try</span> writer.print(<span class="tok-str">" {x}"</span>, .{value}),</span>
<span class="line" id="L1104"> }</span>
<span class="line" id="L1105"> <span class="tok-kw">try</span> writer.writeByte(<span class="tok-str">'\n'</span>);</span>
<span class="line" id="L1106"> }</span>
<span class="line" id="L1107"> }</span>
<span class="line" id="L1108"></span>
<span class="line" id="L1109"> <span class="tok-kw">fn</span> <span class="tok-fn">fmtShType</span>(sh_type: <span class="tok-type">u32</span>) std.fmt.Formatter(formatShType) {</span>
<span class="line" id="L1110"> <span class="tok-kw">return</span> .{ .data = sh_type };</span>
<span class="line" id="L1111"> }</span>
<span class="line" id="L1112"></span>
<span class="line" id="L1113"> <span class="tok-kw">fn</span> <span class="tok-fn">formatShType</span>(</span>
<span class="line" id="L1114"> sh_type: <span class="tok-type">u32</span>,</span>
<span class="line" id="L1115"> <span class="tok-kw">comptime</span> unused_fmt_string: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L1116"> options: std.fmt.FormatOptions,</span>
<span class="line" id="L1117"> writer: <span class="tok-kw">anytype</span>,</span>
<span class="line" id="L1118"> ) !<span class="tok-type">void</span> {</span>
<span class="line" id="L1119"> _ = unused_fmt_string;</span>
<span class="line" id="L1120"> _ = options;</span>
<span class="line" id="L1121"> <span class="tok-kw">const</span> name = <span class="tok-kw">switch</span> (sh_type) {</span>
<span class="line" id="L1122"> elf.SHT_NULL => <span class="tok-str">"NULL"</span>,</span>
<span class="line" id="L1123"> elf.SHT_PROGBITS => <span class="tok-str">"PROGBITS"</span>,</span>
<span class="line" id="L1124"> elf.SHT_SYMTAB => <span class="tok-str">"SYMTAB"</span>,</span>
<span class="line" id="L1125"> elf.SHT_STRTAB => <span class="tok-str">"STRTAB"</span>,</span>
<span class="line" id="L1126"> elf.SHT_RELA => <span class="tok-str">"RELA"</span>,</span>
<span class="line" id="L1127"> elf.SHT_HASH => <span class="tok-str">"HASH"</span>,</span>
<span class="line" id="L1128"> elf.SHT_DYNAMIC => <span class="tok-str">"DYNAMIC"</span>,</span>
<span class="line" id="L1129"> elf.SHT_NOTE => <span class="tok-str">"NOTE"</span>,</span>
<span class="line" id="L1130"> elf.SHT_NOBITS => <span class="tok-str">"NOBITS"</span>,</span>
<span class="line" id="L1131"> elf.SHT_REL => <span class="tok-str">"REL"</span>,</span>
<span class="line" id="L1132"> elf.SHT_SHLIB => <span class="tok-str">"SHLIB"</span>,</span>
<span class="line" id="L1133"> elf.SHT_DYNSYM => <span class="tok-str">"DYNSYM"</span>,</span>
<span class="line" id="L1134"> elf.SHT_INIT_ARRAY => <span class="tok-str">"INIT_ARRAY"</span>,</span>
<span class="line" id="L1135"> elf.SHT_FINI_ARRAY => <span class="tok-str">"FINI_ARRAY"</span>,</span>
<span class="line" id="L1136"> elf.SHT_PREINIT_ARRAY => <span class="tok-str">"PREINIT_ARRAY"</span>,</span>
<span class="line" id="L1137"> elf.SHT_GROUP => <span class="tok-str">"GROUP"</span>,</span>
<span class="line" id="L1138"> elf.SHT_SYMTAB_SHNDX => <span class="tok-str">"SYMTAB_SHNDX"</span>,</span>
<span class="line" id="L1139"> elf.SHT_X86_64_UNWIND => <span class="tok-str">"X86_64_UNWIND"</span>,</span>
<span class="line" id="L1140"> elf.SHT_LLVM_ADDRSIG => <span class="tok-str">"LLVM_ADDRSIG"</span>,</span>
<span class="line" id="L1141"> elf.SHT_GNU_HASH => <span class="tok-str">"GNU_HASH"</span>,</span>
<span class="line" id="L1142"> elf.SHT_GNU_VERDEF => <span class="tok-str">"VERDEF"</span>,</span>
<span class="line" id="L1143"> elf.SHT_GNU_VERNEED => <span class="tok-str">"VERNEED"</span>,</span>
<span class="line" id="L1144"> elf.SHT_GNU_VERSYM => <span class="tok-str">"VERSYM"</span>,</span>
<span class="line" id="L1145"> <span class="tok-kw">else</span> => <span class="tok-kw">if</span> (elf.SHT_LOOS <= sh_type <span class="tok-kw">and</span> sh_type < elf.SHT_HIOS) {</span>
<span class="line" id="L1146"> <span class="tok-kw">return</span> <span class="tok-kw">try</span> writer.print(<span class="tok-str">"LOOS+0x{x}"</span>, .{sh_type - elf.SHT_LOOS});</span>
<span class="line" id="L1147"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (elf.SHT_LOPROC <= sh_type <span class="tok-kw">and</span> sh_type < elf.SHT_HIPROC) {</span>
<span class="line" id="L1148"> <span class="tok-kw">return</span> <span class="tok-kw">try</span> writer.print(<span class="tok-str">"LOPROC+0x{x}"</span>, .{sh_type - elf.SHT_LOPROC});</span>
<span class="line" id="L1149"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (elf.SHT_LOUSER <= sh_type <span class="tok-kw">and</span> sh_type < elf.SHT_HIUSER) {</span>
<span class="line" id="L1150"> <span class="tok-kw">return</span> <span class="tok-kw">try</span> writer.print(<span class="tok-str">"LOUSER+0x{x}"</span>, .{sh_type - elf.SHT_LOUSER});</span>
<span class="line" id="L1151"> } <span class="tok-kw">else</span> <span class="tok-str">"UNKNOWN"</span>,</span>
<span class="line" id="L1152"> };</span>
<span class="line" id="L1153"> <span class="tok-kw">try</span> writer.writeAll(name);</span>
<span class="line" id="L1154"> }</span>
<span class="line" id="L1155"></span>
<span class="line" id="L1156"> <span class="tok-kw">fn</span> <span class="tok-fn">dumpPhdrs</span>(ctx: Context, writer: <span class="tok-kw">anytype</span>) !<span class="tok-type">void</span> {</span>
<span class="line" id="L1157"> <span class="tok-kw">if</span> (ctx.phdrs.len == <span class="tok-number">0</span>) <span class="tok-kw">return</span>;</span>
<span class="line" id="L1158"></span>
<span class="line" id="L1159"> <span class="tok-kw">try</span> writer.writeAll(<span class="tok-str">"program headers\n"</span>);</span>
<span class="line" id="L1160"></span>
<span class="line" id="L1161"> <span class="tok-kw">for</span> (ctx.phdrs, <span class="tok-number">0</span>..) |phdr, phndx| {</span>
<span class="line" id="L1162"> <span class="tok-kw">try</span> writer.print(<span class="tok-str">"phdr {d}\n"</span>, .{phndx});</span>
<span class="line" id="L1163"> <span class="tok-kw">try</span> writer.print(<span class="tok-str">"type {s}\n"</span>, .{fmtPhType(phdr.p_type)});</span>
<span class="line" id="L1164"> <span class="tok-kw">try</span> writer.print(<span class="tok-str">"vaddr {x}\n"</span>, .{phdr.p_vaddr});</span>
<span class="line" id="L1165"> <span class="tok-kw">try</span> writer.print(<span class="tok-str">"paddr {x}\n"</span>, .{phdr.p_paddr});</span>
<span class="line" id="L1166"> <span class="tok-kw">try</span> writer.print(<span class="tok-str">"offset {x}\n"</span>, .{phdr.p_offset});</span>
<span class="line" id="L1167"> <span class="tok-kw">try</span> writer.print(<span class="tok-str">"memsz {x}\n"</span>, .{phdr.p_memsz});</span>
<span class="line" id="L1168"> <span class="tok-kw">try</span> writer.print(<span class="tok-str">"filesz {x}\n"</span>, .{phdr.p_filesz});</span>
<span class="line" id="L1169"> <span class="tok-kw">try</span> writer.print(<span class="tok-str">"align {x}\n"</span>, .{phdr.p_align});</span>
<span class="line" id="L1170"></span>
<span class="line" id="L1171"> {</span>
<span class="line" id="L1172"> <span class="tok-kw">const</span> flags = phdr.p_flags;</span>
<span class="line" id="L1173"> <span class="tok-kw">try</span> writer.writeAll(<span class="tok-str">"flags"</span>);</span>
<span class="line" id="L1174"> <span class="tok-kw">if</span> (flags > <span class="tok-number">0</span>) <span class="tok-kw">try</span> writer.writeByte(<span class="tok-str">' '</span>);</span>
<span class="line" id="L1175"> <span class="tok-kw">if</span> (flags & elf.PF_R != <span class="tok-number">0</span>) {</span>
<span class="line" id="L1176"> <span class="tok-kw">try</span> writer.writeByte(<span class="tok-str">'R'</span>);</span>
<span class="line" id="L1177"> }</span>
<span class="line" id="L1178"> <span class="tok-kw">if</span> (flags & elf.PF_W != <span class="tok-number">0</span>) {</span>
<span class="line" id="L1179"> <span class="tok-kw">try</span> writer.writeByte(<span class="tok-str">'W'</span>);</span>
<span class="line" id="L1180"> }</span>
<span class="line" id="L1181"> <span class="tok-kw">if</span> (flags & elf.PF_X != <span class="tok-number">0</span>) {</span>
<span class="line" id="L1182"> <span class="tok-kw">try</span> writer.writeByte(<span class="tok-str">'E'</span>);</span>
<span class="line" id="L1183"> }</span>
<span class="line" id="L1184"> <span class="tok-kw">if</span> (flags & elf.PF_MASKOS != <span class="tok-number">0</span>) {</span>
<span class="line" id="L1185"> <span class="tok-kw">try</span> writer.writeAll(<span class="tok-str">"OS"</span>);</span>
<span class="line" id="L1186"> }</span>
<span class="line" id="L1187"> <span class="tok-kw">if</span> (flags & elf.PF_MASKPROC != <span class="tok-number">0</span>) {</span>
<span class="line" id="L1188"> <span class="tok-kw">try</span> writer.writeAll(<span class="tok-str">"PROC"</span>);</span>
<span class="line" id="L1189"> }</span>
<span class="line" id="L1190"> <span class="tok-kw">try</span> writer.writeByte(<span class="tok-str">'\n'</span>);</span>
<span class="line" id="L1191"> }</span>
<span class="line" id="L1192"> }</span>
<span class="line" id="L1193"> }</span>
<span class="line" id="L1194"></span>
<span class="line" id="L1195"> <span class="tok-kw">fn</span> <span class="tok-fn">fmtPhType</span>(ph_type: <span class="tok-type">u32</span>) std.fmt.Formatter(formatPhType) {</span>
<span class="line" id="L1196"> <span class="tok-kw">return</span> .{ .data = ph_type };</span>
<span class="line" id="L1197"> }</span>
<span class="line" id="L1198"></span>
<span class="line" id="L1199"> <span class="tok-kw">fn</span> <span class="tok-fn">formatPhType</span>(</span>
<span class="line" id="L1200"> ph_type: <span class="tok-type">u32</span>,</span>
<span class="line" id="L1201"> <span class="tok-kw">comptime</span> unused_fmt_string: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L1202"> options: std.fmt.FormatOptions,</span>
<span class="line" id="L1203"> writer: <span class="tok-kw">anytype</span>,</span>
<span class="line" id="L1204"> ) !<span class="tok-type">void</span> {</span>
<span class="line" id="L1205"> _ = unused_fmt_string;</span>
<span class="line" id="L1206"> _ = options;</span>
<span class="line" id="L1207"> <span class="tok-kw">const</span> p_type = <span class="tok-kw">switch</span> (ph_type) {</span>
<span class="line" id="L1208"> elf.PT_NULL => <span class="tok-str">"NULL"</span>,</span>
<span class="line" id="L1209"> elf.PT_LOAD => <span class="tok-str">"LOAD"</span>,</span>
<span class="line" id="L1210"> elf.PT_DYNAMIC => <span class="tok-str">"DYNAMIC"</span>,</span>
<span class="line" id="L1211"> elf.PT_INTERP => <span class="tok-str">"INTERP"</span>,</span>
<span class="line" id="L1212"> elf.PT_NOTE => <span class="tok-str">"NOTE"</span>,</span>
<span class="line" id="L1213"> elf.PT_SHLIB => <span class="tok-str">"SHLIB"</span>,</span>
<span class="line" id="L1214"> elf.PT_PHDR => <span class="tok-str">"PHDR"</span>,</span>
<span class="line" id="L1215"> elf.PT_TLS => <span class="tok-str">"TLS"</span>,</span>
<span class="line" id="L1216"> elf.PT_NUM => <span class="tok-str">"NUM"</span>,</span>
<span class="line" id="L1217"> elf.PT_GNU_EH_FRAME => <span class="tok-str">"GNU_EH_FRAME"</span>,</span>
<span class="line" id="L1218"> elf.PT_GNU_STACK => <span class="tok-str">"GNU_STACK"</span>,</span>
<span class="line" id="L1219"> elf.PT_GNU_RELRO => <span class="tok-str">"GNU_RELRO"</span>,</span>
<span class="line" id="L1220"> <span class="tok-kw">else</span> => <span class="tok-kw">if</span> (elf.PT_LOOS <= ph_type <span class="tok-kw">and</span> ph_type < elf.PT_HIOS) {</span>
<span class="line" id="L1221"> <span class="tok-kw">return</span> <span class="tok-kw">try</span> writer.print(<span class="tok-str">"LOOS+0x{x}"</span>, .{ph_type - elf.PT_LOOS});</span>
<span class="line" id="L1222"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (elf.PT_LOPROC <= ph_type <span class="tok-kw">and</span> ph_type < elf.PT_HIPROC) {</span>
<span class="line" id="L1223"> <span class="tok-kw">return</span> <span class="tok-kw">try</span> writer.print(<span class="tok-str">"LOPROC+0x{x}"</span>, .{ph_type - elf.PT_LOPROC});</span>
<span class="line" id="L1224"> } <span class="tok-kw">else</span> <span class="tok-str">"UNKNOWN"</span>,</span>
<span class="line" id="L1225"> };</span>
<span class="line" id="L1226"> <span class="tok-kw">try</span> writer.writeAll(p_type);</span>
<span class="line" id="L1227"> }</span>
<span class="line" id="L1228"></span>
<span class="line" id="L1229"> <span class="tok-kw">fn</span> <span class="tok-fn">dumpSymtab</span>(ctx: Context, <span class="tok-kw">comptime</span> @"type": <span class="tok-kw">enum</span> { symtab, dysymtab }, writer: <span class="tok-kw">anytype</span>) !<span class="tok-type">void</span> {</span>
<span class="line" id="L1230"> <span class="tok-kw">const</span> symtab = <span class="tok-kw">switch</span> (@"type") {</span>
<span class="line" id="L1231"> .symtab => ctx.symtab,</span>
<span class="line" id="L1232"> .dysymtab => ctx.dysymtab,</span>
<span class="line" id="L1233"> } <span class="tok-kw">orelse</span> <span class="tok-kw">return</span>;</span>
<span class="line" id="L1234"></span>
<span class="line" id="L1235"> <span class="tok-kw">try</span> writer.writeAll(<span class="tok-kw">switch</span> (@"type") {</span>
<span class="line" id="L1236"> .symtab => symtab_label,</span>
<span class="line" id="L1237"> .dysymtab => dynamic_symtab_label,</span>
<span class="line" id="L1238"> } ++ <span class="tok-str">"\n"</span>);</span>
<span class="line" id="L1239"></span>
<span class="line" id="L1240"> <span class="tok-kw">for</span> (symtab.symbols, <span class="tok-number">0</span>..) |sym, index| {</span>
<span class="line" id="L1241"> <span class="tok-kw">try</span> writer.print(<span class="tok-str">"{x} {x}"</span>, .{ sym.st_value, sym.st_size });</span>
<span class="line" id="L1242"></span>
<span class="line" id="L1243"> {</span>
<span class="line" id="L1244"> <span class="tok-kw">if</span> (elf.SHN_LORESERVE <= sym.st_shndx <span class="tok-kw">and</span> sym.st_shndx < elf.SHN_HIRESERVE) {</span>
<span class="line" id="L1245"> <span class="tok-kw">if</span> (elf.SHN_LOPROC <= sym.st_shndx <span class="tok-kw">and</span> sym.st_shndx < elf.SHN_HIPROC) {</span>
<span class="line" id="L1246"> <span class="tok-kw">try</span> writer.print(<span class="tok-str">" LO+{d}"</span>, .{sym.st_shndx - elf.SHN_LOPROC});</span>
<span class="line" id="L1247"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L1248"> <span class="tok-kw">const</span> sym_ndx = &<span class="tok-kw">switch</span> (sym.st_shndx) {</span>
<span class="line" id="L1249"> elf.SHN_ABS => <span class="tok-str">"ABS"</span>,</span>
<span class="line" id="L1250"> elf.SHN_COMMON => <span class="tok-str">"COM"</span>,</span>
<span class="line" id="L1251"> elf.SHN_LIVEPATCH => <span class="tok-str">"LIV"</span>,</span>
<span class="line" id="L1252"> <span class="tok-kw">else</span> => <span class="tok-str">"UNK"</span>,</span>
<span class="line" id="L1253"> };</span>
<span class="line" id="L1254"> <span class="tok-kw">try</span> writer.print(<span class="tok-str">" {s}"</span>, .{sym_ndx});</span>
<span class="line" id="L1255"> }</span>
<span class="line" id="L1256"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (sym.st_shndx == elf.SHN_UNDEF) {</span>
<span class="line" id="L1257"> <span class="tok-kw">try</span> writer.writeAll(<span class="tok-str">" UND"</span>);</span>
<span class="line" id="L1258"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L1259"> <span class="tok-kw">try</span> writer.print(<span class="tok-str">" {x}"</span>, .{sym.st_shndx});</span>
<span class="line" id="L1260"> }</span>
<span class="line" id="L1261"> }</span>
<span class="line" id="L1262"></span>
<span class="line" id="L1263"> blk: {</span>
<span class="line" id="L1264"> <span class="tok-kw">const</span> tt = sym.st_type();</span>
<span class="line" id="L1265"> <span class="tok-kw">const</span> sym_type = <span class="tok-kw">switch</span> (tt) {</span>
<span class="line" id="L1266"> elf.STT_NOTYPE => <span class="tok-str">"NOTYPE"</span>,</span>
<span class="line" id="L1267"> elf.STT_OBJECT => <span class="tok-str">"OBJECT"</span>,</span>
<span class="line" id="L1268"> elf.STT_FUNC => <span class="tok-str">"FUNC"</span>,</span>
<span class="line" id="L1269"> elf.STT_SECTION => <span class="tok-str">"SECTION"</span>,</span>
<span class="line" id="L1270"> elf.STT_FILE => <span class="tok-str">"FILE"</span>,</span>
<span class="line" id="L1271"> elf.STT_COMMON => <span class="tok-str">"COMMON"</span>,</span>
<span class="line" id="L1272"> elf.STT_TLS => <span class="tok-str">"TLS"</span>,</span>
<span class="line" id="L1273"> elf.STT_NUM => <span class="tok-str">"NUM"</span>,</span>
<span class="line" id="L1274"> elf.STT_GNU_IFUNC => <span class="tok-str">"IFUNC"</span>,</span>
<span class="line" id="L1275"> <span class="tok-kw">else</span> => <span class="tok-kw">if</span> (elf.STT_LOPROC <= tt <span class="tok-kw">and</span> tt < elf.STT_HIPROC) {</span>
<span class="line" id="L1276"> <span class="tok-kw">break</span> :blk <span class="tok-kw">try</span> writer.print(<span class="tok-str">" LOPROC+{d}"</span>, .{tt - elf.STT_LOPROC});</span>
<span class="line" id="L1277"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (elf.STT_LOOS <= tt <span class="tok-kw">and</span> tt < elf.STT_HIOS) {</span>
<span class="line" id="L1278"> <span class="tok-kw">break</span> :blk <span class="tok-kw">try</span> writer.print(<span class="tok-str">" LOOS+{d}"</span>, .{tt - elf.STT_LOOS});</span>
<span class="line" id="L1279"> } <span class="tok-kw">else</span> <span class="tok-str">"UNK"</span>,</span>
<span class="line" id="L1280"> };</span>
<span class="line" id="L1281"> <span class="tok-kw">try</span> writer.print(<span class="tok-str">" {s}"</span>, .{sym_type});</span>
<span class="line" id="L1282"> }</span>
<span class="line" id="L1283"></span>
<span class="line" id="L1284"> blk: {</span>
<span class="line" id="L1285"> <span class="tok-kw">const</span> bind = sym.st_bind();</span>
<span class="line" id="L1286"> <span class="tok-kw">const</span> sym_bind = <span class="tok-kw">switch</span> (bind) {</span>
<span class="line" id="L1287"> elf.STB_LOCAL => <span class="tok-str">"LOCAL"</span>,</span>
<span class="line" id="L1288"> elf.STB_GLOBAL => <span class="tok-str">"GLOBAL"</span>,</span>
<span class="line" id="L1289"> elf.STB_WEAK => <span class="tok-str">"WEAK"</span>,</span>
<span class="line" id="L1290"> elf.STB_NUM => <span class="tok-str">"NUM"</span>,</span>
<span class="line" id="L1291"> <span class="tok-kw">else</span> => <span class="tok-kw">if</span> (elf.STB_LOPROC <= bind <span class="tok-kw">and</span> bind < elf.STB_HIPROC) {</span>
<span class="line" id="L1292"> <span class="tok-kw">break</span> :blk <span class="tok-kw">try</span> writer.print(<span class="tok-str">" LOPROC+{d}"</span>, .{bind - elf.STB_LOPROC});</span>
<span class="line" id="L1293"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (elf.STB_LOOS <= bind <span class="tok-kw">and</span> bind < elf.STB_HIOS) {</span>
<span class="line" id="L1294"> <span class="tok-kw">break</span> :blk <span class="tok-kw">try</span> writer.print(<span class="tok-str">" LOOS+{d}"</span>, .{bind - elf.STB_LOOS});</span>
<span class="line" id="L1295"> } <span class="tok-kw">else</span> <span class="tok-str">"UNKNOWN"</span>,</span>
<span class="line" id="L1296"> };</span>
<span class="line" id="L1297"> <span class="tok-kw">try</span> writer.print(<span class="tok-str">" {s}"</span>, .{sym_bind});</span>
<span class="line" id="L1298"> }</span>
<span class="line" id="L1299"></span>
<span class="line" id="L1300"> <span class="tok-kw">const</span> sym_vis = <span class="tok-builtin">@as</span>(elf.STV, <span class="tok-builtin">@enumFromInt</span>(sym.st_other));</span>
<span class="line" id="L1301"> <span class="tok-kw">try</span> writer.print(<span class="tok-str">" {s}"</span>, .{<span class="tok-builtin">@tagName</span>(sym_vis)});</span>
<span class="line" id="L1302"></span>
<span class="line" id="L1303"> <span class="tok-kw">const</span> sym_name = <span class="tok-kw">switch</span> (sym.st_type()) {</span>
<span class="line" id="L1304"> elf.STT_SECTION => getSectionName(ctx, sym.st_shndx),</span>
<span class="line" id="L1305"> <span class="tok-kw">else</span> => symtab.getName(index).?,</span>
<span class="line" id="L1306"> };</span>
<span class="line" id="L1307"> <span class="tok-kw">try</span> writer.print(<span class="tok-str">" {s}\n"</span>, .{sym_name});</span>
<span class="line" id="L1308"> }</span>
<span class="line" id="L1309"> }</span>
<span class="line" id="L1310">};</span>
<span class="line" id="L1311"></span>
<span class="line" id="L1312"><span class="tok-kw">const</span> WasmDumper = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L1313"> <span class="tok-kw">const</span> symtab_label = <span class="tok-str">"symbols"</span>;</span>
<span class="line" id="L1314"></span>
<span class="line" id="L1315"> <span class="tok-kw">fn</span> <span class="tok-fn">parseAndDump</span>(step: *Step, bytes: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) ![]<span class="tok-kw">const</span> <span class="tok-type">u8</span> {</span>
<span class="line" id="L1316"> <span class="tok-kw">const</span> gpa = step.owner.allocator;</span>
<span class="line" id="L1317"> <span class="tok-kw">var</span> fbs = std.io.fixedBufferStream(bytes);</span>
<span class="line" id="L1318"> <span class="tok-kw">const</span> reader = fbs.reader();</span>
<span class="line" id="L1319"></span>
<span class="line" id="L1320"> <span class="tok-kw">const</span> buf = <span class="tok-kw">try</span> reader.readBytesNoEof(<span class="tok-number">8</span>);</span>
<span class="line" id="L1321"> <span class="tok-kw">if</span> (!mem.eql(<span class="tok-type">u8</span>, buf[<span class="tok-number">0</span>..<span class="tok-number">4</span>], &std.wasm.magic)) {</span>
<span class="line" id="L1322"> <span class="tok-kw">return</span> <span class="tok-kw">error</span>.InvalidMagicByte;</span>
<span class="line" id="L1323"> }</span>
<span class="line" id="L1324"> <span class="tok-kw">if</span> (!mem.eql(<span class="tok-type">u8</span>, buf[<span class="tok-number">4</span>..], &std.wasm.version)) {</span>
<span class="line" id="L1325"> <span class="tok-kw">return</span> <span class="tok-kw">error</span>.UnsupportedWasmVersion;</span>
<span class="line" id="L1326"> }</span>
<span class="line" id="L1327"></span>
<span class="line" id="L1328"> <span class="tok-kw">var</span> output = std.ArrayList(<span class="tok-type">u8</span>).init(gpa);</span>
<span class="line" id="L1329"> <span class="tok-kw">errdefer</span> output.deinit();</span>
<span class="line" id="L1330"> <span class="tok-kw">const</span> writer = output.writer();</span>
<span class="line" id="L1331"></span>
<span class="line" id="L1332"> <span class="tok-kw">while</span> (reader.readByte()) |current_byte| {</span>
<span class="line" id="L1333"> <span class="tok-kw">const</span> section = std.meta.intToEnum(std.wasm.Section, current_byte) <span class="tok-kw">catch</span> {</span>
<span class="line" id="L1334"> <span class="tok-kw">return</span> step.fail(<span class="tok-str">"Found invalid section id '{d}'"</span>, .{current_byte});</span>
<span class="line" id="L1335"> };</span>
<span class="line" id="L1336"></span>
<span class="line" id="L1337"> <span class="tok-kw">const</span> section_length = <span class="tok-kw">try</span> std.leb.readULEB128(<span class="tok-type">u32</span>, reader);</span>
<span class="line" id="L1338"> <span class="tok-kw">try</span> parseAndDumpSection(step, section, bytes[fbs.pos..][<span class="tok-number">0</span>..section_length], writer);</span>
<span class="line" id="L1339"> fbs.pos += section_length;</span>
<span class="line" id="L1340"> } <span class="tok-kw">else</span> |_| {} <span class="tok-comment">// reached end of stream</span>
</span>
<span class="line" id="L1341"></span>
<span class="line" id="L1342"> <span class="tok-kw">return</span> output.toOwnedSlice();</span>
<span class="line" id="L1343"> }</span>
<span class="line" id="L1344"></span>
<span class="line" id="L1345"> <span class="tok-kw">fn</span> <span class="tok-fn">parseAndDumpSection</span>(</span>
<span class="line" id="L1346"> step: *Step,</span>
<span class="line" id="L1347"> section: std.wasm.Section,</span>
<span class="line" id="L1348"> data: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L1349"> writer: <span class="tok-kw">anytype</span>,</span>
<span class="line" id="L1350"> ) !<span class="tok-type">void</span> {</span>
<span class="line" id="L1351"> <span class="tok-kw">var</span> fbs = std.io.fixedBufferStream(data);</span>
<span class="line" id="L1352"> <span class="tok-kw">const</span> reader = fbs.reader();</span>
<span class="line" id="L1353"></span>
<span class="line" id="L1354"> <span class="tok-kw">try</span> writer.print(</span>
<span class="line" id="L1355"> <span class="tok-str">\\Section {s}</span></span>
<span class="line" id="L1356"> <span class="tok-str">\\size {d}</span></span>
<span class="line" id="L1357"> , .{ <span class="tok-builtin">@tagName</span>(section), data.len });</span>
<span class="line" id="L1358"></span>
<span class="line" id="L1359"> <span class="tok-kw">switch</span> (section) {</span>
<span class="line" id="L1360"> .<span class="tok-type">type</span>,</span>
<span class="line" id="L1361"> .import,</span>
<span class="line" id="L1362"> .function,</span>
<span class="line" id="L1363"> .table,</span>
<span class="line" id="L1364"> .memory,</span>
<span class="line" id="L1365"> .global,</span>
<span class="line" id="L1366"> .@"export",</span>
<span class="line" id="L1367"> .element,</span>
<span class="line" id="L1368"> .code,</span>
<span class="line" id="L1369"> .data,</span>
<span class="line" id="L1370"> => {</span>
<span class="line" id="L1371"> <span class="tok-kw">const</span> entries = <span class="tok-kw">try</span> std.leb.readULEB128(<span class="tok-type">u32</span>, reader);</span>
<span class="line" id="L1372"> <span class="tok-kw">try</span> writer.print(<span class="tok-str">"\nentries {d}\n"</span>, .{entries});</span>
<span class="line" id="L1373"> <span class="tok-kw">try</span> dumpSection(step, section, data[fbs.pos..], entries, writer);</span>
<span class="line" id="L1374"> },</span>
<span class="line" id="L1375"> .custom => {</span>
<span class="line" id="L1376"> <span class="tok-kw">const</span> name_length = <span class="tok-kw">try</span> std.leb.readULEB128(<span class="tok-type">u32</span>, reader);</span>
<span class="line" id="L1377"> <span class="tok-kw">const</span> name = data[fbs.pos..][<span class="tok-number">0</span>..name_length];</span>
<span class="line" id="L1378"> fbs.pos += name_length;</span>
<span class="line" id="L1379"> <span class="tok-kw">try</span> writer.print(<span class="tok-str">"\nname {s}\n"</span>, .{name});</span>
<span class="line" id="L1380"></span>
<span class="line" id="L1381"> <span class="tok-kw">if</span> (mem.eql(<span class="tok-type">u8</span>, name, <span class="tok-str">"name"</span>)) {</span>
<span class="line" id="L1382"> <span class="tok-kw">try</span> parseDumpNames(step, reader, writer, data);</span>
<span class="line" id="L1383"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (mem.eql(<span class="tok-type">u8</span>, name, <span class="tok-str">"producers"</span>)) {</span>
<span class="line" id="L1384"> <span class="tok-kw">try</span> parseDumpProducers(reader, writer, data);</span>
<span class="line" id="L1385"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (mem.eql(<span class="tok-type">u8</span>, name, <span class="tok-str">"target_features"</span>)) {</span>
<span class="line" id="L1386"> <span class="tok-kw">try</span> parseDumpFeatures(reader, writer, data);</span>
<span class="line" id="L1387"> }</span>
<span class="line" id="L1388"> <span class="tok-comment">// TODO: Implement parsing and dumping other custom sections (such as relocations)</span>
</span>
<span class="line" id="L1389"> },</span>
<span class="line" id="L1390"> .start => {</span>
<span class="line" id="L1391"> <span class="tok-kw">const</span> start = <span class="tok-kw">try</span> std.leb.readULEB128(<span class="tok-type">u32</span>, reader);</span>
<span class="line" id="L1392"> <span class="tok-kw">try</span> writer.print(<span class="tok-str">"\nstart {d}\n"</span>, .{start});</span>
<span class="line" id="L1393"> },</span>
<span class="line" id="L1394"> .data_count => {</span>
<span class="line" id="L1395"> <span class="tok-kw">const</span> count = <span class="tok-kw">try</span> std.leb.readULEB128(<span class="tok-type">u32</span>, reader);</span>
<span class="line" id="L1396"> <span class="tok-kw">try</span> writer.print(<span class="tok-str">"\ncount {d}\n"</span>, .{count});</span>
<span class="line" id="L1397"> },</span>
<span class="line" id="L1398"> <span class="tok-kw">else</span> => {}, <span class="tok-comment">// skip unknown sections</span>
</span>
<span class="line" id="L1399"> }</span>
<span class="line" id="L1400"> }</span>
<span class="line" id="L1401"></span>
<span class="line" id="L1402"> <span class="tok-kw">fn</span> <span class="tok-fn">dumpSection</span>(step: *Step, section: std.wasm.Section, data: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>, entries: <span class="tok-type">u32</span>, writer: <span class="tok-kw">anytype</span>) !<span class="tok-type">void</span> {</span>
<span class="line" id="L1403"> <span class="tok-kw">var</span> fbs = std.io.fixedBufferStream(data);</span>
<span class="line" id="L1404"> <span class="tok-kw">const</span> reader = fbs.reader();</span>
<span class="line" id="L1405"></span>
<span class="line" id="L1406"> <span class="tok-kw">switch</span> (section) {</span>
<span class="line" id="L1407"> .<span class="tok-type">type</span> => {</span>
<span class="line" id="L1408"> <span class="tok-kw">var</span> i: <span class="tok-type">u32</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L1409"> <span class="tok-kw">while</span> (i < entries) : (i += <span class="tok-number">1</span>) {</span>
<span class="line" id="L1410"> <span class="tok-kw">const</span> func_type = <span class="tok-kw">try</span> reader.readByte();</span>
<span class="line" id="L1411"> <span class="tok-kw">if</span> (func_type != std.wasm.function_type) {</span>
<span class="line" id="L1412"> <span class="tok-kw">return</span> step.fail(<span class="tok-str">"expected function type, found byte '{d}'"</span>, .{func_type});</span>
<span class="line" id="L1413"> }</span>
<span class="line" id="L1414"> <span class="tok-kw">const</span> params = <span class="tok-kw">try</span> std.leb.readULEB128(<span class="tok-type">u32</span>, reader);</span>
<span class="line" id="L1415"> <span class="tok-kw">try</span> writer.print(<span class="tok-str">"params {d}\n"</span>, .{params});</span>
<span class="line" id="L1416"> <span class="tok-kw">var</span> index: <span class="tok-type">u32</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L1417"> <span class="tok-kw">while</span> (index < params) : (index += <span class="tok-number">1</span>) {</span>
<span class="line" id="L1418"> <span class="tok-kw">try</span> parseDumpType(step, std.wasm.Valtype, reader, writer);</span>
<span class="line" id="L1419"> } <span class="tok-kw">else</span> index = <span class="tok-number">0</span>;</span>
<span class="line" id="L1420"> <span class="tok-kw">const</span> returns = <span class="tok-kw">try</span> std.leb.readULEB128(<span class="tok-type">u32</span>, reader);</span>
<span class="line" id="L1421"> <span class="tok-kw">try</span> writer.print(<span class="tok-str">"returns {d}\n"</span>, .{returns});</span>
<span class="line" id="L1422"> <span class="tok-kw">while</span> (index < returns) : (index += <span class="tok-number">1</span>) {</span>
<span class="line" id="L1423"> <span class="tok-kw">try</span> parseDumpType(step, std.wasm.Valtype, reader, writer);</span>
<span class="line" id="L1424"> }</span>
<span class="line" id="L1425"> }</span>
<span class="line" id="L1426"> },</span>
<span class="line" id="L1427"> .import => {</span>
<span class="line" id="L1428"> <span class="tok-kw">var</span> i: <span class="tok-type">u32</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L1429"> <span class="tok-kw">while</span> (i < entries) : (i += <span class="tok-number">1</span>) {</span>
<span class="line" id="L1430"> <span class="tok-kw">const</span> module_name_len = <span class="tok-kw">try</span> std.leb.readULEB128(<span class="tok-type">u32</span>, reader);</span>
<span class="line" id="L1431"> <span class="tok-kw">const</span> module_name = data[fbs.pos..][<span class="tok-number">0</span>..module_name_len];</span>
<span class="line" id="L1432"> fbs.pos += module_name_len;</span>
<span class="line" id="L1433"> <span class="tok-kw">const</span> name_len = <span class="tok-kw">try</span> std.leb.readULEB128(<span class="tok-type">u32</span>, reader);</span>
<span class="line" id="L1434"> <span class="tok-kw">const</span> name = data[fbs.pos..][<span class="tok-number">0</span>..name_len];</span>
<span class="line" id="L1435"> fbs.pos += name_len;</span>
<span class="line" id="L1436"></span>
<span class="line" id="L1437"> <span class="tok-kw">const</span> kind = std.meta.intToEnum(std.wasm.ExternalKind, <span class="tok-kw">try</span> reader.readByte()) <span class="tok-kw">catch</span> {</span>
<span class="line" id="L1438"> <span class="tok-kw">return</span> step.fail(<span class="tok-str">"invalid import kind"</span>, .{});</span>
<span class="line" id="L1439"> };</span>
<span class="line" id="L1440"></span>
<span class="line" id="L1441"> <span class="tok-kw">try</span> writer.print(</span>
<span class="line" id="L1442"> <span class="tok-str">\\module {s}</span></span>
<span class="line" id="L1443"> <span class="tok-str">\\name {s}</span></span>
<span class="line" id="L1444"> <span class="tok-str">\\kind {s}</span></span>
<span class="line" id="L1445"> , .{ module_name, name, <span class="tok-builtin">@tagName</span>(kind) });</span>
<span class="line" id="L1446"> <span class="tok-kw">try</span> writer.writeByte(<span class="tok-str">'\n'</span>);</span>
<span class="line" id="L1447"> <span class="tok-kw">switch</span> (kind) {</span>
<span class="line" id="L1448"> .function => {</span>
<span class="line" id="L1449"> <span class="tok-kw">try</span> writer.print(<span class="tok-str">"index {d}\n"</span>, .{<span class="tok-kw">try</span> std.leb.readULEB128(<span class="tok-type">u32</span>, reader)});</span>
<span class="line" id="L1450"> },</span>
<span class="line" id="L1451"> .memory => {</span>
<span class="line" id="L1452"> <span class="tok-kw">try</span> parseDumpLimits(reader, writer);</span>
<span class="line" id="L1453"> },</span>
<span class="line" id="L1454"> .global => {</span>
<span class="line" id="L1455"> <span class="tok-kw">try</span> parseDumpType(step, std.wasm.Valtype, reader, writer);</span>
<span class="line" id="L1456"> <span class="tok-kw">try</span> writer.print(<span class="tok-str">"mutable {}\n"</span>, .{<span class="tok-number">0x01</span> == <span class="tok-kw">try</span> std.leb.readULEB128(<span class="tok-type">u32</span>, reader)});</span>
<span class="line" id="L1457"> },</span>
<span class="line" id="L1458"> .table => {</span>
<span class="line" id="L1459"> <span class="tok-kw">try</span> parseDumpType(step, std.wasm.RefType, reader, writer);</span>
<span class="line" id="L1460"> <span class="tok-kw">try</span> parseDumpLimits(reader, writer);</span>
<span class="line" id="L1461"> },</span>
<span class="line" id="L1462"> }</span>
<span class="line" id="L1463"> }</span>
<span class="line" id="L1464"> },</span>
<span class="line" id="L1465"> .function => {</span>
<span class="line" id="L1466"> <span class="tok-kw">var</span> i: <span class="tok-type">u32</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L1467"> <span class="tok-kw">while</span> (i < entries) : (i += <span class="tok-number">1</span>) {</span>
<span class="line" id="L1468"> <span class="tok-kw">try</span> writer.print(<span class="tok-str">"index {d}\n"</span>, .{<span class="tok-kw">try</span> std.leb.readULEB128(<span class="tok-type">u32</span>, reader)});</span>
<span class="line" id="L1469"> }</span>
<span class="line" id="L1470"> },</span>
<span class="line" id="L1471"> .table => {</span>
<span class="line" id="L1472"> <span class="tok-kw">var</span> i: <span class="tok-type">u32</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L1473"> <span class="tok-kw">while</span> (i < entries) : (i += <span class="tok-number">1</span>) {</span>
<span class="line" id="L1474"> <span class="tok-kw">try</span> parseDumpType(step, std.wasm.RefType, reader, writer);</span>
<span class="line" id="L1475"> <span class="tok-kw">try</span> parseDumpLimits(reader, writer);</span>
<span class="line" id="L1476"> }</span>
<span class="line" id="L1477"> },</span>
<span class="line" id="L1478"> .memory => {</span>
<span class="line" id="L1479"> <span class="tok-kw">var</span> i: <span class="tok-type">u32</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L1480"> <span class="tok-kw">while</span> (i < entries) : (i += <span class="tok-number">1</span>) {</span>
<span class="line" id="L1481"> <span class="tok-kw">try</span> parseDumpLimits(reader, writer);</span>
<span class="line" id="L1482"> }</span>
<span class="line" id="L1483"> },</span>
<span class="line" id="L1484"> .global => {</span>
<span class="line" id="L1485"> <span class="tok-kw">var</span> i: <span class="tok-type">u32</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L1486"> <span class="tok-kw">while</span> (i < entries) : (i += <span class="tok-number">1</span>) {</span>
<span class="line" id="L1487"> <span class="tok-kw">try</span> parseDumpType(step, std.wasm.Valtype, reader, writer);</span>
<span class="line" id="L1488"> <span class="tok-kw">try</span> writer.print(<span class="tok-str">"mutable {}\n"</span>, .{<span class="tok-number">0x01</span> == <span class="tok-kw">try</span> std.leb.readULEB128(<span class="tok-type">u1</span>, reader)});</span>
<span class="line" id="L1489"> <span class="tok-kw">try</span> parseDumpInit(step, reader, writer);</span>
<span class="line" id="L1490"> }</span>
<span class="line" id="L1491"> },</span>
<span class="line" id="L1492"> .@"export" => {</span>
<span class="line" id="L1493"> <span class="tok-kw">var</span> i: <span class="tok-type">u32</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L1494"> <span class="tok-kw">while</span> (i < entries) : (i += <span class="tok-number">1</span>) {</span>
<span class="line" id="L1495"> <span class="tok-kw">const</span> name_len = <span class="tok-kw">try</span> std.leb.readULEB128(<span class="tok-type">u32</span>, reader);</span>
<span class="line" id="L1496"> <span class="tok-kw">const</span> name = data[fbs.pos..][<span class="tok-number">0</span>..name_len];</span>
<span class="line" id="L1497"> fbs.pos += name_len;</span>
<span class="line" id="L1498"> <span class="tok-kw">const</span> kind_byte = <span class="tok-kw">try</span> std.leb.readULEB128(<span class="tok-type">u8</span>, reader);</span>
<span class="line" id="L1499"> <span class="tok-kw">const</span> kind = std.meta.intToEnum(std.wasm.ExternalKind, kind_byte) <span class="tok-kw">catch</span> {</span>
<span class="line" id="L1500"> <span class="tok-kw">return</span> step.fail(<span class="tok-str">"invalid export kind value '{d}'"</span>, .{kind_byte});</span>
<span class="line" id="L1501"> };</span>
<span class="line" id="L1502"> <span class="tok-kw">const</span> index = <span class="tok-kw">try</span> std.leb.readULEB128(<span class="tok-type">u32</span>, reader);</span>
<span class="line" id="L1503"> <span class="tok-kw">try</span> writer.print(</span>
<span class="line" id="L1504"> <span class="tok-str">\\name {s}</span></span>
<span class="line" id="L1505"> <span class="tok-str">\\kind {s}</span></span>
<span class="line" id="L1506"> <span class="tok-str">\\index {d}</span></span>
<span class="line" id="L1507"> , .{ name, <span class="tok-builtin">@tagName</span>(kind), index });</span>
<span class="line" id="L1508"> <span class="tok-kw">try</span> writer.writeByte(<span class="tok-str">'\n'</span>);</span>
<span class="line" id="L1509"> }</span>
<span class="line" id="L1510"> },</span>
<span class="line" id="L1511"> .element => {</span>
<span class="line" id="L1512"> <span class="tok-kw">var</span> i: <span class="tok-type">u32</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L1513"> <span class="tok-kw">while</span> (i < entries) : (i += <span class="tok-number">1</span>) {</span>
<span class="line" id="L1514"> <span class="tok-kw">try</span> writer.print(<span class="tok-str">"table index {d}\n"</span>, .{<span class="tok-kw">try</span> std.leb.readULEB128(<span class="tok-type">u32</span>, reader)});</span>
<span class="line" id="L1515"> <span class="tok-kw">try</span> parseDumpInit(step, reader, writer);</span>
<span class="line" id="L1516"></span>
<span class="line" id="L1517"> <span class="tok-kw">const</span> function_indexes = <span class="tok-kw">try</span> std.leb.readULEB128(<span class="tok-type">u32</span>, reader);</span>
<span class="line" id="L1518"> <span class="tok-kw">var</span> function_index: <span class="tok-type">u32</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L1519"> <span class="tok-kw">try</span> writer.print(<span class="tok-str">"indexes {d}\n"</span>, .{function_indexes});</span>
<span class="line" id="L1520"> <span class="tok-kw">while</span> (function_index < function_indexes) : (function_index += <span class="tok-number">1</span>) {</span>
<span class="line" id="L1521"> <span class="tok-kw">try</span> writer.print(<span class="tok-str">"index {d}\n"</span>, .{<span class="tok-kw">try</span> std.leb.readULEB128(<span class="tok-type">u32</span>, reader)});</span>
<span class="line" id="L1522"> }</span>
<span class="line" id="L1523"> }</span>
<span class="line" id="L1524"> },</span>
<span class="line" id="L1525"> .code => {}, <span class="tok-comment">// code section is considered opaque to linker</span>
</span>
<span class="line" id="L1526"> .data => {</span>
<span class="line" id="L1527"> <span class="tok-kw">var</span> i: <span class="tok-type">u32</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L1528"> <span class="tok-kw">while</span> (i < entries) : (i += <span class="tok-number">1</span>) {</span>
<span class="line" id="L1529"> <span class="tok-kw">const</span> flags = <span class="tok-kw">try</span> std.leb.readULEB128(<span class="tok-type">u32</span>, reader);</span>
<span class="line" id="L1530"> <span class="tok-kw">const</span> index = <span class="tok-kw">if</span> (flags & <span class="tok-number">0x02</span> != <span class="tok-number">0</span>)</span>
<span class="line" id="L1531"> <span class="tok-kw">try</span> std.leb.readULEB128(<span class="tok-type">u32</span>, reader)</span>
<span class="line" id="L1532"> <span class="tok-kw">else</span></span>
<span class="line" id="L1533"> <span class="tok-number">0</span>;</span>
<span class="line" id="L1534"> <span class="tok-kw">try</span> writer.print(<span class="tok-str">"memory index 0x{x}\n"</span>, .{index});</span>
<span class="line" id="L1535"> <span class="tok-kw">if</span> (flags == <span class="tok-number">0</span>) {</span>
<span class="line" id="L1536"> <span class="tok-kw">try</span> parseDumpInit(step, reader, writer);</span>
<span class="line" id="L1537"> }</span>
<span class="line" id="L1538"></span>
<span class="line" id="L1539"> <span class="tok-kw">const</span> size = <span class="tok-kw">try</span> std.leb.readULEB128(<span class="tok-type">u32</span>, reader);</span>
<span class="line" id="L1540"> <span class="tok-kw">try</span> writer.print(<span class="tok-str">"size {d}\n"</span>, .{size});</span>
<span class="line" id="L1541"> <span class="tok-kw">try</span> reader.skipBytes(size, .{}); <span class="tok-comment">// we do not care about the content of the segments</span>
</span>
<span class="line" id="L1542"> }</span>
<span class="line" id="L1543"> },</span>
<span class="line" id="L1544"> <span class="tok-kw">else</span> => <span class="tok-kw">unreachable</span>,</span>
<span class="line" id="L1545"> }</span>
<span class="line" id="L1546"> }</span>
<span class="line" id="L1547"></span>
<span class="line" id="L1548"> <span class="tok-kw">fn</span> <span class="tok-fn">parseDumpType</span>(step: *Step, <span class="tok-kw">comptime</span> WasmType: <span class="tok-type">type</span>, reader: <span class="tok-kw">anytype</span>, writer: <span class="tok-kw">anytype</span>) !<span class="tok-type">void</span> {</span>
<span class="line" id="L1549"> <span class="tok-kw">const</span> type_byte = <span class="tok-kw">try</span> reader.readByte();</span>
<span class="line" id="L1550"> <span class="tok-kw">const</span> valtype = std.meta.intToEnum(WasmType, type_byte) <span class="tok-kw">catch</span> {</span>
<span class="line" id="L1551"> <span class="tok-kw">return</span> step.fail(<span class="tok-str">"Invalid wasm type value '{d}'"</span>, .{type_byte});</span>
<span class="line" id="L1552"> };</span>
<span class="line" id="L1553"> <span class="tok-kw">try</span> writer.print(<span class="tok-str">"type {s}\n"</span>, .{<span class="tok-builtin">@tagName</span>(valtype)});</span>
<span class="line" id="L1554"> }</span>
<span class="line" id="L1555"></span>
<span class="line" id="L1556"> <span class="tok-kw">fn</span> <span class="tok-fn">parseDumpLimits</span>(reader: <span class="tok-kw">anytype</span>, writer: <span class="tok-kw">anytype</span>) !<span class="tok-type">void</span> {</span>
<span class="line" id="L1557"> <span class="tok-kw">const</span> flags = <span class="tok-kw">try</span> std.leb.readULEB128(<span class="tok-type">u8</span>, reader);</span>
<span class="line" id="L1558"> <span class="tok-kw">const</span> min = <span class="tok-kw">try</span> std.leb.readULEB128(<span class="tok-type">u32</span>, reader);</span>
<span class="line" id="L1559"></span>
<span class="line" id="L1560"> <span class="tok-kw">try</span> writer.print(<span class="tok-str">"min {x}\n"</span>, .{min});</span>
<span class="line" id="L1561"> <span class="tok-kw">if</span> (flags != <span class="tok-number">0</span>) {</span>
<span class="line" id="L1562"> <span class="tok-kw">try</span> writer.print(<span class="tok-str">"max {x}\n"</span>, .{<span class="tok-kw">try</span> std.leb.readULEB128(<span class="tok-type">u32</span>, reader)});</span>
<span class="line" id="L1563"> }</span>
<span class="line" id="L1564"> }</span>
<span class="line" id="L1565"></span>
<span class="line" id="L1566"> <span class="tok-kw">fn</span> <span class="tok-fn">parseDumpInit</span>(step: *Step, reader: <span class="tok-kw">anytype</span>, writer: <span class="tok-kw">anytype</span>) !<span class="tok-type">void</span> {</span>
<span class="line" id="L1567"> <span class="tok-kw">const</span> byte = <span class="tok-kw">try</span> reader.readByte();</span>
<span class="line" id="L1568"> <span class="tok-kw">const</span> opcode = std.meta.intToEnum(std.wasm.Opcode, byte) <span class="tok-kw">catch</span> {</span>
<span class="line" id="L1569"> <span class="tok-kw">return</span> step.fail(<span class="tok-str">"invalid wasm opcode '{d}'"</span>, .{byte});</span>
<span class="line" id="L1570"> };</span>
<span class="line" id="L1571"> <span class="tok-kw">switch</span> (opcode) {</span>
<span class="line" id="L1572"> .i32_const => <span class="tok-kw">try</span> writer.print(<span class="tok-str">"i32.const {x}\n"</span>, .{<span class="tok-kw">try</span> std.leb.readILEB128(<span class="tok-type">i32</span>, reader)}),</span>
<span class="line" id="L1573"> .i64_const => <span class="tok-kw">try</span> writer.print(<span class="tok-str">"i64.const {x}\n"</span>, .{<span class="tok-kw">try</span> std.leb.readILEB128(<span class="tok-type">i64</span>, reader)}),</span>
<span class="line" id="L1574"> .f32_const => <span class="tok-kw">try</span> writer.print(<span class="tok-str">"f32.const {x}\n"</span>, .{<span class="tok-builtin">@as</span>(<span class="tok-type">f32</span>, <span class="tok-builtin">@bitCast</span>(<span class="tok-kw">try</span> reader.readIntLittle(<span class="tok-type">u32</span>)))}),</span>
<span class="line" id="L1575"> .f64_const => <span class="tok-kw">try</span> writer.print(<span class="tok-str">"f64.const {x}\n"</span>, .{<span class="tok-builtin">@as</span>(<span class="tok-type">f64</span>, <span class="tok-builtin">@bitCast</span>(<span class="tok-kw">try</span> reader.readIntLittle(<span class="tok-type">u64</span>)))}),</span>
<span class="line" id="L1576"> .global_get => <span class="tok-kw">try</span> writer.print(<span class="tok-str">"global.get {x}\n"</span>, .{<span class="tok-kw">try</span> std.leb.readULEB128(<span class="tok-type">u32</span>, reader)}),</span>
<span class="line" id="L1577"> <span class="tok-kw">else</span> => <span class="tok-kw">unreachable</span>,</span>
<span class="line" id="L1578"> }</span>
<span class="line" id="L1579"> <span class="tok-kw">const</span> end_opcode = <span class="tok-kw">try</span> std.leb.readULEB128(<span class="tok-type">u8</span>, reader);</span>
<span class="line" id="L1580"> <span class="tok-kw">if</span> (end_opcode != std.wasm.opcode(.end)) {</span>
<span class="line" id="L1581"> <span class="tok-kw">return</span> step.fail(<span class="tok-str">"expected 'end' opcode in init expression"</span>, .{});</span>
<span class="line" id="L1582"> }</span>
<span class="line" id="L1583"> }</span>
<span class="line" id="L1584"></span>
<span class="line" id="L1585"> <span class="tok-kw">fn</span> <span class="tok-fn">parseDumpNames</span>(step: *Step, reader: <span class="tok-kw">anytype</span>, writer: <span class="tok-kw">anytype</span>, data: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) !<span class="tok-type">void</span> {</span>
<span class="line" id="L1586"> <span class="tok-kw">while</span> (reader.context.pos < data.len) {</span>
<span class="line" id="L1587"> <span class="tok-kw">try</span> parseDumpType(step, std.wasm.NameSubsection, reader, writer);</span>
<span class="line" id="L1588"> <span class="tok-kw">const</span> size = <span class="tok-kw">try</span> std.leb.readULEB128(<span class="tok-type">u32</span>, reader);</span>
<span class="line" id="L1589"> <span class="tok-kw">const</span> entries = <span class="tok-kw">try</span> std.leb.readULEB128(<span class="tok-type">u32</span>, reader);</span>
<span class="line" id="L1590"> <span class="tok-kw">try</span> writer.print(</span>
<span class="line" id="L1591"> <span class="tok-str">\\size {d}</span></span>
<span class="line" id="L1592"> <span class="tok-str">\\names {d}</span></span>
<span class="line" id="L1593"> , .{ size, entries });</span>
<span class="line" id="L1594"> <span class="tok-kw">try</span> writer.writeByte(<span class="tok-str">'\n'</span>);</span>
<span class="line" id="L1595"> <span class="tok-kw">var</span> i: <span class="tok-type">u32</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L1596"> <span class="tok-kw">while</span> (i < entries) : (i += <span class="tok-number">1</span>) {</span>
<span class="line" id="L1597"> <span class="tok-kw">const</span> index = <span class="tok-kw">try</span> std.leb.readULEB128(<span class="tok-type">u32</span>, reader);</span>
<span class="line" id="L1598"> <span class="tok-kw">const</span> name_len = <span class="tok-kw">try</span> std.leb.readULEB128(<span class="tok-type">u32</span>, reader);</span>
<span class="line" id="L1599"> <span class="tok-kw">const</span> pos = reader.context.pos;</span>
<span class="line" id="L1600"> <span class="tok-kw">const</span> name = data[pos..][<span class="tok-number">0</span>..name_len];</span>
<span class="line" id="L1601"> reader.context.pos += name_len;</span>
<span class="line" id="L1602"></span>
<span class="line" id="L1603"> <span class="tok-kw">try</span> writer.print(</span>
<span class="line" id="L1604"> <span class="tok-str">\\index {d}</span></span>
<span class="line" id="L1605"> <span class="tok-str">\\name {s}</span></span>
<span class="line" id="L1606"> , .{ index, name });</span>
<span class="line" id="L1607"> <span class="tok-kw">try</span> writer.writeByte(<span class="tok-str">'\n'</span>);</span>
<span class="line" id="L1608"> }</span>
<span class="line" id="L1609"> }</span>
<span class="line" id="L1610"> }</span>
<span class="line" id="L1611"></span>
<span class="line" id="L1612"> <span class="tok-kw">fn</span> <span class="tok-fn">parseDumpProducers</span>(reader: <span class="tok-kw">anytype</span>, writer: <span class="tok-kw">anytype</span>, data: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) !<span class="tok-type">void</span> {</span>
<span class="line" id="L1613"> <span class="tok-kw">const</span> field_count = <span class="tok-kw">try</span> std.leb.readULEB128(<span class="tok-type">u32</span>, reader);</span>
<span class="line" id="L1614"> <span class="tok-kw">try</span> writer.print(<span class="tok-str">"fields {d}\n"</span>, .{field_count});</span>
<span class="line" id="L1615"> <span class="tok-kw">var</span> current_field: <span class="tok-type">u32</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L1616"> <span class="tok-kw">while</span> (current_field < field_count) : (current_field += <span class="tok-number">1</span>) {</span>
<span class="line" id="L1617"> <span class="tok-kw">const</span> field_name_length = <span class="tok-kw">try</span> std.leb.readULEB128(<span class="tok-type">u32</span>, reader);</span>
<span class="line" id="L1618"> <span class="tok-kw">const</span> field_name = data[reader.context.pos..][<span class="tok-number">0</span>..field_name_length];</span>
<span class="line" id="L1619"> reader.context.pos += field_name_length;</span>
<span class="line" id="L1620"></span>
<span class="line" id="L1621"> <span class="tok-kw">const</span> value_count = <span class="tok-kw">try</span> std.leb.readULEB128(<span class="tok-type">u32</span>, reader);</span>
<span class="line" id="L1622"> <span class="tok-kw">try</span> writer.print(</span>
<span class="line" id="L1623"> <span class="tok-str">\\field_name {s}</span></span>
<span class="line" id="L1624"> <span class="tok-str">\\values {d}</span></span>
<span class="line" id="L1625"> , .{ field_name, value_count });</span>
<span class="line" id="L1626"> <span class="tok-kw">try</span> writer.writeByte(<span class="tok-str">'\n'</span>);</span>
<span class="line" id="L1627"> <span class="tok-kw">var</span> current_value: <span class="tok-type">u32</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L1628"> <span class="tok-kw">while</span> (current_value < value_count) : (current_value += <span class="tok-number">1</span>) {</span>
<span class="line" id="L1629"> <span class="tok-kw">const</span> value_length = <span class="tok-kw">try</span> std.leb.readULEB128(<span class="tok-type">u32</span>, reader);</span>
<span class="line" id="L1630"> <span class="tok-kw">const</span> value = data[reader.context.pos..][<span class="tok-number">0</span>..value_length];</span>
<span class="line" id="L1631"> reader.context.pos += value_length;</span>
<span class="line" id="L1632"></span>
<span class="line" id="L1633"> <span class="tok-kw">const</span> version_length = <span class="tok-kw">try</span> std.leb.readULEB128(<span class="tok-type">u32</span>, reader);</span>
<span class="line" id="L1634"> <span class="tok-kw">const</span> version = data[reader.context.pos..][<span class="tok-number">0</span>..version_length];</span>
<span class="line" id="L1635"> reader.context.pos += version_length;</span>
<span class="line" id="L1636"></span>
<span class="line" id="L1637"> <span class="tok-kw">try</span> writer.print(</span>
<span class="line" id="L1638"> <span class="tok-str">\\value_name {s}</span></span>
<span class="line" id="L1639"> <span class="tok-str">\\version {s}</span></span>
<span class="line" id="L1640"> , .{ value, version });</span>
<span class="line" id="L1641"> <span class="tok-kw">try</span> writer.writeByte(<span class="tok-str">'\n'</span>);</span>
<span class="line" id="L1642"> }</span>
<span class="line" id="L1643"> }</span>
<span class="line" id="L1644"> }</span>
<span class="line" id="L1645"></span>
<span class="line" id="L1646"> <span class="tok-kw">fn</span> <span class="tok-fn">parseDumpFeatures</span>(reader: <span class="tok-kw">anytype</span>, writer: <span class="tok-kw">anytype</span>, data: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) !<span class="tok-type">void</span> {</span>
<span class="line" id="L1647"> <span class="tok-kw">const</span> feature_count = <span class="tok-kw">try</span> std.leb.readULEB128(<span class="tok-type">u32</span>, reader);</span>
<span class="line" id="L1648"> <span class="tok-kw">try</span> writer.print(<span class="tok-str">"features {d}\n"</span>, .{feature_count});</span>
<span class="line" id="L1649"></span>
<span class="line" id="L1650"> <span class="tok-kw">var</span> index: <span class="tok-type">u32</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L1651"> <span class="tok-kw">while</span> (index < feature_count) : (index += <span class="tok-number">1</span>) {</span>
<span class="line" id="L1652"> <span class="tok-kw">const</span> prefix_byte = <span class="tok-kw">try</span> std.leb.readULEB128(<span class="tok-type">u8</span>, reader);</span>
<span class="line" id="L1653"> <span class="tok-kw">const</span> name_length = <span class="tok-kw">try</span> std.leb.readULEB128(<span class="tok-type">u32</span>, reader);</span>
<span class="line" id="L1654"> <span class="tok-kw">const</span> feature_name = data[reader.context.pos..][<span class="tok-number">0</span>..name_length];</span>
<span class="line" id="L1655"> reader.context.pos += name_length;</span>
<span class="line" id="L1656"></span>
<span class="line" id="L1657"> <span class="tok-kw">try</span> writer.print(<span class="tok-str">"{c} {s}\n"</span>, .{ prefix_byte, feature_name });</span>
<span class="line" id="L1658"> }</span>
<span class="line" id="L1659"> }</span>
<span class="line" id="L1660">};</span>
<span class="line" id="L1661"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std/Build | repos/yazap/docs/src/std/Build/Step/Compile.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>Build/Step/Compile.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> builtin = <span class="tok-builtin">@import</span>(<span class="tok-str">"builtin"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"std"</span>);</span>
<span class="line" id="L3"><span class="tok-kw">const</span> mem = std.mem;</span>
<span class="line" id="L4"><span class="tok-kw">const</span> fs = std.fs;</span>
<span class="line" id="L5"><span class="tok-kw">const</span> assert = std.debug.assert;</span>
<span class="line" id="L6"><span class="tok-kw">const</span> panic = std.debug.panic;</span>
<span class="line" id="L7"><span class="tok-kw">const</span> ArrayList = std.ArrayList;</span>
<span class="line" id="L8"><span class="tok-kw">const</span> StringHashMap = std.StringHashMap;</span>
<span class="line" id="L9"><span class="tok-kw">const</span> Sha256 = std.crypto.hash.sha2.Sha256;</span>
<span class="line" id="L10"><span class="tok-kw">const</span> Allocator = mem.Allocator;</span>
<span class="line" id="L11"><span class="tok-kw">const</span> Step = std.Build.Step;</span>
<span class="line" id="L12"><span class="tok-kw">const</span> CrossTarget = std.zig.CrossTarget;</span>
<span class="line" id="L13"><span class="tok-kw">const</span> NativeTargetInfo = std.zig.system.NativeTargetInfo;</span>
<span class="line" id="L14"><span class="tok-kw">const</span> FileSource = std.Build.FileSource;</span>
<span class="line" id="L15"><span class="tok-kw">const</span> PkgConfigPkg = std.Build.PkgConfigPkg;</span>
<span class="line" id="L16"><span class="tok-kw">const</span> PkgConfigError = std.Build.PkgConfigError;</span>
<span class="line" id="L17"><span class="tok-kw">const</span> ExecError = std.Build.ExecError;</span>
<span class="line" id="L18"><span class="tok-kw">const</span> Module = std.Build.Module;</span>
<span class="line" id="L19"><span class="tok-kw">const</span> VcpkgRoot = std.Build.VcpkgRoot;</span>
<span class="line" id="L20"><span class="tok-kw">const</span> InstallDir = std.Build.InstallDir;</span>
<span class="line" id="L21"><span class="tok-kw">const</span> GeneratedFile = std.Build.GeneratedFile;</span>
<span class="line" id="L22"><span class="tok-kw">const</span> Compile = <span class="tok-builtin">@This</span>();</span>
<span class="line" id="L23"></span>
<span class="line" id="L24"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> base_id: Step.Id = .compile;</span>
<span class="line" id="L25"></span>
<span class="line" id="L26">step: Step,</span>
<span class="line" id="L27">name: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L28">target: CrossTarget,</span>
<span class="line" id="L29">target_info: NativeTargetInfo,</span>
<span class="line" id="L30">optimize: std.builtin.Mode,</span>
<span class="line" id="L31">linker_script: ?FileSource = <span class="tok-null">null</span>,</span>
<span class="line" id="L32">version_script: ?[]<span class="tok-kw">const</span> <span class="tok-type">u8</span> = <span class="tok-null">null</span>,</span>
<span class="line" id="L33">out_filename: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L34">linkage: ?Linkage = <span class="tok-null">null</span>,</span>
<span class="line" id="L35">version: ?std.SemanticVersion,</span>
<span class="line" id="L36">kind: Kind,</span>
<span class="line" id="L37">major_only_filename: ?[]<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L38">name_only_filename: ?[]<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L39">strip: ?<span class="tok-type">bool</span>,</span>
<span class="line" id="L40">unwind_tables: ?<span class="tok-type">bool</span>,</span>
<span class="line" id="L41"><span class="tok-comment">// keep in sync with src/link.zig:CompressDebugSections</span>
</span>
<span class="line" id="L42">compress_debug_sections: <span class="tok-kw">enum</span> { none, zlib } = .none,</span>
<span class="line" id="L43">lib_paths: ArrayList(FileSource),</span>
<span class="line" id="L44">rpaths: ArrayList(FileSource),</span>
<span class="line" id="L45">framework_dirs: ArrayList(FileSource),</span>
<span class="line" id="L46">frameworks: StringHashMap(FrameworkLinkInfo),</span>
<span class="line" id="L47">verbose_link: <span class="tok-type">bool</span>,</span>
<span class="line" id="L48">verbose_cc: <span class="tok-type">bool</span>,</span>
<span class="line" id="L49">emit_analysis: EmitOption = .default,</span>
<span class="line" id="L50">emit_asm: EmitOption = .default,</span>
<span class="line" id="L51">emit_bin: EmitOption = .default,</span>
<span class="line" id="L52">emit_implib: EmitOption = .default,</span>
<span class="line" id="L53">emit_llvm_bc: EmitOption = .default,</span>
<span class="line" id="L54">emit_llvm_ir: EmitOption = .default,</span>
<span class="line" id="L55"><span class="tok-comment">// Lots of things depend on emit_h having a consistent path,</span>
</span>
<span class="line" id="L56"><span class="tok-comment">// so it is not an EmitOption for now.</span>
</span>
<span class="line" id="L57">emit_h: <span class="tok-type">bool</span> = <span class="tok-null">false</span>,</span>
<span class="line" id="L58">bundle_compiler_rt: ?<span class="tok-type">bool</span> = <span class="tok-null">null</span>,</span>
<span class="line" id="L59">single_threaded: ?<span class="tok-type">bool</span>,</span>
<span class="line" id="L60">stack_protector: ?<span class="tok-type">bool</span> = <span class="tok-null">null</span>,</span>
<span class="line" id="L61">disable_stack_probing: <span class="tok-type">bool</span>,</span>
<span class="line" id="L62">disable_sanitize_c: <span class="tok-type">bool</span>,</span>
<span class="line" id="L63">sanitize_thread: <span class="tok-type">bool</span>,</span>
<span class="line" id="L64">rdynamic: <span class="tok-type">bool</span>,</span>
<span class="line" id="L65">dwarf_format: ?std.dwarf.Format = <span class="tok-null">null</span>,</span>
<span class="line" id="L66">import_memory: <span class="tok-type">bool</span> = <span class="tok-null">false</span>,</span>
<span class="line" id="L67">export_memory: <span class="tok-type">bool</span> = <span class="tok-null">false</span>,</span>
<span class="line" id="L68"><span class="tok-comment">/// For WebAssembly targets, this will allow for undefined symbols to</span></span>
<span class="line" id="L69"><span class="tok-comment">/// be imported from the host environment.</span></span>
<span class="line" id="L70">import_symbols: <span class="tok-type">bool</span> = <span class="tok-null">false</span>,</span>
<span class="line" id="L71">import_table: <span class="tok-type">bool</span> = <span class="tok-null">false</span>,</span>
<span class="line" id="L72">export_table: <span class="tok-type">bool</span> = <span class="tok-null">false</span>,</span>
<span class="line" id="L73">initial_memory: ?<span class="tok-type">u64</span> = <span class="tok-null">null</span>,</span>
<span class="line" id="L74">max_memory: ?<span class="tok-type">u64</span> = <span class="tok-null">null</span>,</span>
<span class="line" id="L75">shared_memory: <span class="tok-type">bool</span> = <span class="tok-null">false</span>,</span>
<span class="line" id="L76">global_base: ?<span class="tok-type">u64</span> = <span class="tok-null">null</span>,</span>
<span class="line" id="L77">c_std: std.Build.CStd,</span>
<span class="line" id="L78">zig_lib_dir: ?[]<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L79">main_pkg_path: ?[]<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L80">exec_cmd_args: ?[]<span class="tok-kw">const</span> ?[]<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L81">filter: ?[]<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L82">test_evented_io: <span class="tok-type">bool</span> = <span class="tok-null">false</span>,</span>
<span class="line" id="L83">test_runner: ?[]<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L84">code_model: std.builtin.CodeModel = .default,</span>
<span class="line" id="L85">wasi_exec_model: ?std.builtin.WasiExecModel = <span class="tok-null">null</span>,</span>
<span class="line" id="L86"><span class="tok-comment">/// Symbols to be exported when compiling to wasm</span></span>
<span class="line" id="L87">export_symbol_names: []<span class="tok-kw">const</span> []<span class="tok-kw">const</span> <span class="tok-type">u8</span> = &.{},</span>
<span class="line" id="L88"></span>
<span class="line" id="L89">root_src: ?FileSource,</span>
<span class="line" id="L90">out_h_filename: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L91">out_lib_filename: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L92">out_pdb_filename: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L93">modules: std.StringArrayHashMap(*Module),</span>
<span class="line" id="L94"></span>
<span class="line" id="L95">link_objects: ArrayList(LinkObject),</span>
<span class="line" id="L96">include_dirs: ArrayList(IncludeDir),</span>
<span class="line" id="L97">c_macros: ArrayList([]<span class="tok-kw">const</span> <span class="tok-type">u8</span>),</span>
<span class="line" id="L98">installed_headers: ArrayList(*Step),</span>
<span class="line" id="L99">is_linking_libc: <span class="tok-type">bool</span>,</span>
<span class="line" id="L100">is_linking_libcpp: <span class="tok-type">bool</span>,</span>
<span class="line" id="L101">vcpkg_bin_path: ?[]<span class="tok-kw">const</span> <span class="tok-type">u8</span> = <span class="tok-null">null</span>,</span>
<span class="line" id="L102"></span>
<span class="line" id="L103"><span class="tok-comment">/// This may be set in order to override the default install directory</span></span>
<span class="line" id="L104">override_dest_dir: ?InstallDir,</span>
<span class="line" id="L105">installed_path: ?[]<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L106"></span>
<span class="line" id="L107"><span class="tok-comment">/// Base address for an executable image.</span></span>
<span class="line" id="L108">image_base: ?<span class="tok-type">u64</span> = <span class="tok-null">null</span>,</span>
<span class="line" id="L109"></span>
<span class="line" id="L110">libc_file: ?FileSource = <span class="tok-null">null</span>,</span>
<span class="line" id="L111"></span>
<span class="line" id="L112">valgrind_support: ?<span class="tok-type">bool</span> = <span class="tok-null">null</span>,</span>
<span class="line" id="L113">each_lib_rpath: ?<span class="tok-type">bool</span> = <span class="tok-null">null</span>,</span>
<span class="line" id="L114"><span class="tok-comment">/// On ELF targets, this will emit a link section called ".note.gnu.build-id"</span></span>
<span class="line" id="L115"><span class="tok-comment">/// which can be used to coordinate a stripped binary with its debug symbols.</span></span>
<span class="line" id="L116"><span class="tok-comment">/// As an example, the bloaty project refuses to work unless its inputs have</span></span>
<span class="line" id="L117"><span class="tok-comment">/// build ids, in order to prevent accidental mismatches.</span></span>
<span class="line" id="L118"><span class="tok-comment">/// The default is to not include this section because it slows down linking.</span></span>
<span class="line" id="L119">build_id: ?BuildId = <span class="tok-null">null</span>,</span>
<span class="line" id="L120"></span>
<span class="line" id="L121"><span class="tok-comment">/// Create a .eh_frame_hdr section and a PT_GNU_EH_FRAME segment in the ELF</span></span>
<span class="line" id="L122"><span class="tok-comment">/// file.</span></span>
<span class="line" id="L123">link_eh_frame_hdr: <span class="tok-type">bool</span> = <span class="tok-null">false</span>,</span>
<span class="line" id="L124">link_emit_relocs: <span class="tok-type">bool</span> = <span class="tok-null">false</span>,</span>
<span class="line" id="L125"></span>
<span class="line" id="L126"><span class="tok-comment">/// Place every function in its own section so that unused ones may be</span></span>
<span class="line" id="L127"><span class="tok-comment">/// safely garbage-collected during the linking phase.</span></span>
<span class="line" id="L128">link_function_sections: <span class="tok-type">bool</span> = <span class="tok-null">false</span>,</span>
<span class="line" id="L129"></span>
<span class="line" id="L130"><span class="tok-comment">/// Remove functions and data that are unreachable by the entry point or</span></span>
<span class="line" id="L131"><span class="tok-comment">/// exported symbols.</span></span>
<span class="line" id="L132">link_gc_sections: ?<span class="tok-type">bool</span> = <span class="tok-null">null</span>,</span>
<span class="line" id="L133"></span>
<span class="line" id="L134"><span class="tok-comment">/// (Windows) Whether or not to enable ASLR. Maps to the /DYNAMICBASE[:NO] linker argument.</span></span>
<span class="line" id="L135">linker_dynamicbase: <span class="tok-type">bool</span> = <span class="tok-null">true</span>,</span>
<span class="line" id="L136"></span>
<span class="line" id="L137">linker_allow_shlib_undefined: ?<span class="tok-type">bool</span> = <span class="tok-null">null</span>,</span>
<span class="line" id="L138"></span>
<span class="line" id="L139"><span class="tok-comment">/// Permit read-only relocations in read-only segments. Disallowed by default.</span></span>
<span class="line" id="L140">link_z_notext: <span class="tok-type">bool</span> = <span class="tok-null">false</span>,</span>
<span class="line" id="L141"></span>
<span class="line" id="L142"><span class="tok-comment">/// Force all relocations to be read-only after processing.</span></span>
<span class="line" id="L143">link_z_relro: <span class="tok-type">bool</span> = <span class="tok-null">true</span>,</span>
<span class="line" id="L144"></span>
<span class="line" id="L145"><span class="tok-comment">/// Allow relocations to be lazily processed after load.</span></span>
<span class="line" id="L146">link_z_lazy: <span class="tok-type">bool</span> = <span class="tok-null">false</span>,</span>
<span class="line" id="L147"></span>
<span class="line" id="L148"><span class="tok-comment">/// Common page size</span></span>
<span class="line" id="L149">link_z_common_page_size: ?<span class="tok-type">u64</span> = <span class="tok-null">null</span>,</span>
<span class="line" id="L150"></span>
<span class="line" id="L151"><span class="tok-comment">/// Maximum page size</span></span>
<span class="line" id="L152">link_z_max_page_size: ?<span class="tok-type">u64</span> = <span class="tok-null">null</span>,</span>
<span class="line" id="L153"></span>
<span class="line" id="L154"><span class="tok-comment">/// (Darwin) Install name for the dylib</span></span>
<span class="line" id="L155">install_name: ?[]<span class="tok-kw">const</span> <span class="tok-type">u8</span> = <span class="tok-null">null</span>,</span>
<span class="line" id="L156"></span>
<span class="line" id="L157"><span class="tok-comment">/// (Darwin) Path to entitlements file</span></span>
<span class="line" id="L158">entitlements: ?[]<span class="tok-kw">const</span> <span class="tok-type">u8</span> = <span class="tok-null">null</span>,</span>
<span class="line" id="L159"></span>
<span class="line" id="L160"><span class="tok-comment">/// (Darwin) Size of the pagezero segment.</span></span>
<span class="line" id="L161">pagezero_size: ?<span class="tok-type">u64</span> = <span class="tok-null">null</span>,</span>
<span class="line" id="L162"></span>
<span class="line" id="L163"><span class="tok-comment">/// (Darwin) Search strategy for searching system libraries. Either `paths_first` or `dylibs_first`.</span></span>
<span class="line" id="L164"><span class="tok-comment">/// The former lowers to `-search_paths_first` linker option, while the latter to `-search_dylibs_first`</span></span>
<span class="line" id="L165"><span class="tok-comment">/// option.</span></span>
<span class="line" id="L166"><span class="tok-comment">/// By default, if no option is specified, the linker assumes `paths_first` as the default</span></span>
<span class="line" id="L167"><span class="tok-comment">/// search strategy.</span></span>
<span class="line" id="L168">search_strategy: ?<span class="tok-kw">enum</span> { paths_first, dylibs_first } = <span class="tok-null">null</span>,</span>
<span class="line" id="L169"></span>
<span class="line" id="L170"><span class="tok-comment">/// (Darwin) Set size of the padding between the end of load commands</span></span>
<span class="line" id="L171"><span class="tok-comment">/// and start of `__TEXT,__text` section.</span></span>
<span class="line" id="L172">headerpad_size: ?<span class="tok-type">u32</span> = <span class="tok-null">null</span>,</span>
<span class="line" id="L173"></span>
<span class="line" id="L174"><span class="tok-comment">/// (Darwin) Automatically Set size of the padding between the end of load commands</span></span>
<span class="line" id="L175"><span class="tok-comment">/// and start of `__TEXT,__text` section to a value fitting all paths expanded to MAXPATHLEN.</span></span>
<span class="line" id="L176">headerpad_max_install_names: <span class="tok-type">bool</span> = <span class="tok-null">false</span>,</span>
<span class="line" id="L177"></span>
<span class="line" id="L178"><span class="tok-comment">/// (Darwin) Remove dylibs that are unreachable by the entry point or exported symbols.</span></span>
<span class="line" id="L179">dead_strip_dylibs: <span class="tok-type">bool</span> = <span class="tok-null">false</span>,</span>
<span class="line" id="L180"></span>
<span class="line" id="L181"><span class="tok-comment">/// Position Independent Code</span></span>
<span class="line" id="L182">force_pic: ?<span class="tok-type">bool</span> = <span class="tok-null">null</span>,</span>
<span class="line" id="L183"></span>
<span class="line" id="L184"><span class="tok-comment">/// Position Independent Executable</span></span>
<span class="line" id="L185">pie: ?<span class="tok-type">bool</span> = <span class="tok-null">null</span>,</span>
<span class="line" id="L186"></span>
<span class="line" id="L187">red_zone: ?<span class="tok-type">bool</span> = <span class="tok-null">null</span>,</span>
<span class="line" id="L188"></span>
<span class="line" id="L189">omit_frame_pointer: ?<span class="tok-type">bool</span> = <span class="tok-null">null</span>,</span>
<span class="line" id="L190">dll_export_fns: ?<span class="tok-type">bool</span> = <span class="tok-null">null</span>,</span>
<span class="line" id="L191"></span>
<span class="line" id="L192">subsystem: ?std.Target.SubSystem = <span class="tok-null">null</span>,</span>
<span class="line" id="L193"></span>
<span class="line" id="L194">entry_symbol_name: ?[]<span class="tok-kw">const</span> <span class="tok-type">u8</span> = <span class="tok-null">null</span>,</span>
<span class="line" id="L195"></span>
<span class="line" id="L196"><span class="tok-comment">/// List of symbols forced as undefined in the symbol table</span></span>
<span class="line" id="L197"><span class="tok-comment">/// thus forcing their resolution by the linker.</span></span>
<span class="line" id="L198"><span class="tok-comment">/// Corresponds to `-u <symbol>` for ELF/MachO and `/include:<symbol>` for COFF/PE.</span></span>
<span class="line" id="L199">force_undefined_symbols: std.StringHashMap(<span class="tok-type">void</span>),</span>
<span class="line" id="L200"></span>
<span class="line" id="L201"><span class="tok-comment">/// Overrides the default stack size</span></span>
<span class="line" id="L202">stack_size: ?<span class="tok-type">u64</span> = <span class="tok-null">null</span>,</span>
<span class="line" id="L203"></span>
<span class="line" id="L204">want_lto: ?<span class="tok-type">bool</span> = <span class="tok-null">null</span>,</span>
<span class="line" id="L205">use_llvm: ?<span class="tok-type">bool</span>,</span>
<span class="line" id="L206">use_lld: ?<span class="tok-type">bool</span>,</span>
<span class="line" id="L207"></span>
<span class="line" id="L208"><span class="tok-comment">/// This is an advanced setting that can change the intent of this Compile step.</span></span>
<span class="line" id="L209"><span class="tok-comment">/// If this slice has nonzero length, it means that this Compile step exists to</span></span>
<span class="line" id="L210"><span class="tok-comment">/// check for compile errors and return *success* if they match, and failure</span></span>
<span class="line" id="L211"><span class="tok-comment">/// otherwise.</span></span>
<span class="line" id="L212">expect_errors: []<span class="tok-kw">const</span> []<span class="tok-kw">const</span> <span class="tok-type">u8</span> = &.{},</span>
<span class="line" id="L213"></span>
<span class="line" id="L214">output_path_source: GeneratedFile,</span>
<span class="line" id="L215">output_lib_path_source: GeneratedFile,</span>
<span class="line" id="L216">output_h_path_source: GeneratedFile,</span>
<span class="line" id="L217">output_pdb_path_source: GeneratedFile,</span>
<span class="line" id="L218">output_dirname_source: GeneratedFile,</span>
<span class="line" id="L219">generated_docs: ?*GeneratedFile,</span>
<span class="line" id="L220"></span>
<span class="line" id="L221"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> CSourceFiles = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L222"> files: []<span class="tok-kw">const</span> []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L223"> flags: []<span class="tok-kw">const</span> []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L224">};</span>
<span class="line" id="L225"></span>
<span class="line" id="L226"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> CSourceFile = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L227"> source: FileSource,</span>
<span class="line" id="L228"> args: []<span class="tok-kw">const</span> []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L229"></span>
<span class="line" id="L230"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">dupe</span>(self: CSourceFile, b: *std.Build) CSourceFile {</span>
<span class="line" id="L231"> <span class="tok-kw">return</span> .{</span>
<span class="line" id="L232"> .source = self.source.dupe(b),</span>
<span class="line" id="L233"> .args = b.dupeStrings(self.args),</span>
<span class="line" id="L234"> };</span>
<span class="line" id="L235"> }</span>
<span class="line" id="L236">};</span>
<span class="line" id="L237"></span>
<span class="line" id="L238"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> LinkObject = <span class="tok-kw">union</span>(<span class="tok-kw">enum</span>) {</span>
<span class="line" id="L239"> static_path: FileSource,</span>
<span class="line" id="L240"> other_step: *Compile,</span>
<span class="line" id="L241"> system_lib: SystemLib,</span>
<span class="line" id="L242"> assembly_file: FileSource,</span>
<span class="line" id="L243"> c_source_file: *CSourceFile,</span>
<span class="line" id="L244"> c_source_files: *CSourceFiles,</span>
<span class="line" id="L245">};</span>
<span class="line" id="L246"></span>
<span class="line" id="L247"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> SystemLib = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L248"> name: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L249"> needed: <span class="tok-type">bool</span>,</span>
<span class="line" id="L250"> weak: <span class="tok-type">bool</span>,</span>
<span class="line" id="L251"> use_pkg_config: <span class="tok-kw">enum</span> {</span>
<span class="line" id="L252"> <span class="tok-comment">/// Don't use pkg-config, just pass -lfoo where foo is name.</span></span>
<span class="line" id="L253"> no,</span>
<span class="line" id="L254"> <span class="tok-comment">/// Try to get information on how to link the library from pkg-config.</span></span>
<span class="line" id="L255"> <span class="tok-comment">/// If that fails, fall back to passing -lfoo where foo is name.</span></span>
<span class="line" id="L256"> yes,</span>
<span class="line" id="L257"> <span class="tok-comment">/// Try to get information on how to link the library from pkg-config.</span></span>
<span class="line" id="L258"> <span class="tok-comment">/// If that fails, error out.</span></span>
<span class="line" id="L259"> force,</span>
<span class="line" id="L260"> },</span>
<span class="line" id="L261">};</span>
<span class="line" id="L262"></span>
<span class="line" id="L263"><span class="tok-kw">const</span> FrameworkLinkInfo = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L264"> needed: <span class="tok-type">bool</span> = <span class="tok-null">false</span>,</span>
<span class="line" id="L265"> weak: <span class="tok-type">bool</span> = <span class="tok-null">false</span>,</span>
<span class="line" id="L266">};</span>
<span class="line" id="L267"></span>
<span class="line" id="L268"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> IncludeDir = <span class="tok-kw">union</span>(<span class="tok-kw">enum</span>) {</span>
<span class="line" id="L269"> raw_path: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L270"> raw_path_system: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L271"> other_step: *Compile,</span>
<span class="line" id="L272"> config_header_step: *Step.ConfigHeader,</span>
<span class="line" id="L273">};</span>
<span class="line" id="L274"></span>
<span class="line" id="L275"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> Options = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L276"> name: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L277"> root_source_file: ?FileSource = <span class="tok-null">null</span>,</span>
<span class="line" id="L278"> target: CrossTarget,</span>
<span class="line" id="L279"> optimize: std.builtin.Mode,</span>
<span class="line" id="L280"> kind: Kind,</span>
<span class="line" id="L281"> linkage: ?Linkage = <span class="tok-null">null</span>,</span>
<span class="line" id="L282"> version: ?std.SemanticVersion = <span class="tok-null">null</span>,</span>
<span class="line" id="L283"> max_rss: <span class="tok-type">usize</span> = <span class="tok-number">0</span>,</span>
<span class="line" id="L284"> filter: ?[]<span class="tok-kw">const</span> <span class="tok-type">u8</span> = <span class="tok-null">null</span>,</span>
<span class="line" id="L285"> test_runner: ?[]<span class="tok-kw">const</span> <span class="tok-type">u8</span> = <span class="tok-null">null</span>,</span>
<span class="line" id="L286"> link_libc: ?<span class="tok-type">bool</span> = <span class="tok-null">null</span>,</span>
<span class="line" id="L287"> single_threaded: ?<span class="tok-type">bool</span> = <span class="tok-null">null</span>,</span>
<span class="line" id="L288"> use_llvm: ?<span class="tok-type">bool</span> = <span class="tok-null">null</span>,</span>
<span class="line" id="L289"> use_lld: ?<span class="tok-type">bool</span> = <span class="tok-null">null</span>,</span>
<span class="line" id="L290">};</span>
<span class="line" id="L291"></span>
<span class="line" id="L292"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> BuildId = <span class="tok-kw">union</span>(<span class="tok-kw">enum</span>) {</span>
<span class="line" id="L293"> none,</span>
<span class="line" id="L294"> fast,</span>
<span class="line" id="L295"> uuid,</span>
<span class="line" id="L296"> sha1,</span>
<span class="line" id="L297"> md5,</span>
<span class="line" id="L298"> hexstring: HexString,</span>
<span class="line" id="L299"></span>
<span class="line" id="L300"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">eql</span>(a: BuildId, b: BuildId) <span class="tok-type">bool</span> {</span>
<span class="line" id="L301"> <span class="tok-kw">const</span> a_tag = std.meta.activeTag(a);</span>
<span class="line" id="L302"> <span class="tok-kw">const</span> b_tag = std.meta.activeTag(b);</span>
<span class="line" id="L303"> <span class="tok-kw">if</span> (a_tag != b_tag) <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L304"> <span class="tok-kw">return</span> <span class="tok-kw">switch</span> (a) {</span>
<span class="line" id="L305"> .none, .fast, .uuid, .sha1, .md5 => <span class="tok-null">true</span>,</span>
<span class="line" id="L306"> .hexstring => |a_hexstring| mem.eql(<span class="tok-type">u8</span>, a_hexstring.toSlice(), b.hexstring.toSlice()),</span>
<span class="line" id="L307"> };</span>
<span class="line" id="L308"> }</span>
<span class="line" id="L309"></span>
<span class="line" id="L310"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> HexString = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L311"> bytes: [<span class="tok-number">32</span>]<span class="tok-type">u8</span>,</span>
<span class="line" id="L312"> len: <span class="tok-type">u8</span>,</span>
<span class="line" id="L313"></span>
<span class="line" id="L314"> <span class="tok-comment">/// Result is byte values, *not* hex-encoded.</span></span>
<span class="line" id="L315"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">toSlice</span>(hs: *<span class="tok-kw">const</span> HexString) []<span class="tok-kw">const</span> <span class="tok-type">u8</span> {</span>
<span class="line" id="L316"> <span class="tok-kw">return</span> hs.bytes[<span class="tok-number">0</span>..hs.len];</span>
<span class="line" id="L317"> }</span>
<span class="line" id="L318"> };</span>
<span class="line" id="L319"></span>
<span class="line" id="L320"> <span class="tok-comment">/// Input is byte values, *not* hex-encoded.</span></span>
<span class="line" id="L321"> <span class="tok-comment">/// Asserts `bytes` fits inside `HexString`</span></span>
<span class="line" id="L322"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">initHexString</span>(bytes: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) BuildId {</span>
<span class="line" id="L323"> <span class="tok-kw">var</span> result: BuildId = .{ .hexstring = .{</span>
<span class="line" id="L324"> .bytes = <span class="tok-null">undefined</span>,</span>
<span class="line" id="L325"> .len = <span class="tok-builtin">@as</span>(<span class="tok-type">u8</span>, <span class="tok-builtin">@intCast</span>(bytes.len)),</span>
<span class="line" id="L326"> } };</span>
<span class="line" id="L327"> <span class="tok-builtin">@memcpy</span>(result.hexstring.bytes[<span class="tok-number">0</span>..bytes.len], bytes);</span>
<span class="line" id="L328"> <span class="tok-kw">return</span> result;</span>
<span class="line" id="L329"> }</span>
<span class="line" id="L330"></span>
<span class="line" id="L331"> <span class="tok-comment">/// Converts UTF-8 text to a `BuildId`.</span></span>
<span class="line" id="L332"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">parse</span>(text: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) !BuildId {</span>
<span class="line" id="L333"> <span class="tok-kw">if</span> (mem.eql(<span class="tok-type">u8</span>, text, <span class="tok-str">"none"</span>)) {</span>
<span class="line" id="L334"> <span class="tok-kw">return</span> .none;</span>
<span class="line" id="L335"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (mem.eql(<span class="tok-type">u8</span>, text, <span class="tok-str">"fast"</span>)) {</span>
<span class="line" id="L336"> <span class="tok-kw">return</span> .fast;</span>
<span class="line" id="L337"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (mem.eql(<span class="tok-type">u8</span>, text, <span class="tok-str">"uuid"</span>)) {</span>
<span class="line" id="L338"> <span class="tok-kw">return</span> .uuid;</span>
<span class="line" id="L339"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (mem.eql(<span class="tok-type">u8</span>, text, <span class="tok-str">"sha1"</span>) <span class="tok-kw">or</span> mem.eql(<span class="tok-type">u8</span>, text, <span class="tok-str">"tree"</span>)) {</span>
<span class="line" id="L340"> <span class="tok-kw">return</span> .sha1;</span>
<span class="line" id="L341"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (mem.eql(<span class="tok-type">u8</span>, text, <span class="tok-str">"md5"</span>)) {</span>
<span class="line" id="L342"> <span class="tok-kw">return</span> .md5;</span>
<span class="line" id="L343"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (mem.startsWith(<span class="tok-type">u8</span>, text, <span class="tok-str">"0x"</span>)) {</span>
<span class="line" id="L344"> <span class="tok-kw">var</span> result: BuildId = .{ .hexstring = <span class="tok-null">undefined</span> };</span>
<span class="line" id="L345"> <span class="tok-kw">const</span> slice = <span class="tok-kw">try</span> std.fmt.hexToBytes(&result.hexstring.bytes, text[<span class="tok-number">2</span>..]);</span>
<span class="line" id="L346"> result.hexstring.len = <span class="tok-builtin">@as</span>(<span class="tok-type">u8</span>, <span class="tok-builtin">@intCast</span>(slice.len));</span>
<span class="line" id="L347"> <span class="tok-kw">return</span> result;</span>
<span class="line" id="L348"> }</span>
<span class="line" id="L349"> <span class="tok-kw">return</span> <span class="tok-kw">error</span>.InvalidBuildIdStyle;</span>
<span class="line" id="L350"> }</span>
<span class="line" id="L351"></span>
<span class="line" id="L352"> <span class="tok-kw">test</span> parse {</span>
<span class="line" id="L353"> <span class="tok-kw">try</span> std.testing.expectEqual(BuildId.md5, <span class="tok-kw">try</span> parse(<span class="tok-str">"md5"</span>));</span>
<span class="line" id="L354"> <span class="tok-kw">try</span> std.testing.expectEqual(BuildId.none, <span class="tok-kw">try</span> parse(<span class="tok-str">"none"</span>));</span>
<span class="line" id="L355"> <span class="tok-kw">try</span> std.testing.expectEqual(BuildId.fast, <span class="tok-kw">try</span> parse(<span class="tok-str">"fast"</span>));</span>
<span class="line" id="L356"> <span class="tok-kw">try</span> std.testing.expectEqual(BuildId.uuid, <span class="tok-kw">try</span> parse(<span class="tok-str">"uuid"</span>));</span>
<span class="line" id="L357"> <span class="tok-kw">try</span> std.testing.expectEqual(BuildId.sha1, <span class="tok-kw">try</span> parse(<span class="tok-str">"sha1"</span>));</span>
<span class="line" id="L358"> <span class="tok-kw">try</span> std.testing.expectEqual(BuildId.sha1, <span class="tok-kw">try</span> parse(<span class="tok-str">"tree"</span>));</span>
<span class="line" id="L359"></span>
<span class="line" id="L360"> <span class="tok-kw">try</span> std.testing.expect(BuildId.initHexString(<span class="tok-str">""</span>).eql(<span class="tok-kw">try</span> parse(<span class="tok-str">"0x"</span>)));</span>
<span class="line" id="L361"> <span class="tok-kw">try</span> std.testing.expect(BuildId.initHexString(<span class="tok-str">"\x12\x34\x56"</span>).eql(<span class="tok-kw">try</span> parse(<span class="tok-str">"0x123456"</span>)));</span>
<span class="line" id="L362"> <span class="tok-kw">try</span> std.testing.expectError(<span class="tok-kw">error</span>.InvalidLength, parse(<span class="tok-str">"0x12-34"</span>));</span>
<span class="line" id="L363"> <span class="tok-kw">try</span> std.testing.expectError(<span class="tok-kw">error</span>.InvalidCharacter, parse(<span class="tok-str">"0xfoobbb"</span>));</span>
<span class="line" id="L364"> <span class="tok-kw">try</span> std.testing.expectError(<span class="tok-kw">error</span>.InvalidBuildIdStyle, parse(<span class="tok-str">"yaddaxxx"</span>));</span>
<span class="line" id="L365"> }</span>
<span class="line" id="L366">};</span>
<span class="line" id="L367"></span>
<span class="line" id="L368"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> Kind = <span class="tok-kw">enum</span> {</span>
<span class="line" id="L369"> exe,</span>
<span class="line" id="L370"> lib,</span>
<span class="line" id="L371"> obj,</span>
<span class="line" id="L372"> @"test",</span>
<span class="line" id="L373">};</span>
<span class="line" id="L374"></span>
<span class="line" id="L375"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> Linkage = <span class="tok-kw">enum</span> { dynamic, static };</span>
<span class="line" id="L376"></span>
<span class="line" id="L377"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> EmitOption = <span class="tok-kw">union</span>(<span class="tok-kw">enum</span>) {</span>
<span class="line" id="L378"> default: <span class="tok-type">void</span>,</span>
<span class="line" id="L379"> no_emit: <span class="tok-type">void</span>,</span>
<span class="line" id="L380"> emit: <span class="tok-type">void</span>,</span>
<span class="line" id="L381"> emit_to: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L382"></span>
<span class="line" id="L383"> <span class="tok-kw">fn</span> <span class="tok-fn">getArg</span>(self: <span class="tok-builtin">@This</span>(), b: *std.Build, arg_name: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) ?[]<span class="tok-kw">const</span> <span class="tok-type">u8</span> {</span>
<span class="line" id="L384"> <span class="tok-kw">return</span> <span class="tok-kw">switch</span> (self) {</span>
<span class="line" id="L385"> .no_emit => b.fmt(<span class="tok-str">"-fno-{s}"</span>, .{arg_name}),</span>
<span class="line" id="L386"> .default => <span class="tok-null">null</span>,</span>
<span class="line" id="L387"> .emit => b.fmt(<span class="tok-str">"-f{s}"</span>, .{arg_name}),</span>
<span class="line" id="L388"> .emit_to => |path| b.fmt(<span class="tok-str">"-f{s}={s}"</span>, .{ arg_name, path }),</span>
<span class="line" id="L389"> };</span>
<span class="line" id="L390"> }</span>
<span class="line" id="L391">};</span>
<span class="line" id="L392"></span>
<span class="line" id="L393"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">create</span>(owner: *std.Build, options: Options) *Compile {</span>
<span class="line" id="L394"> <span class="tok-kw">const</span> name = owner.dupe(options.name);</span>
<span class="line" id="L395"> <span class="tok-kw">const</span> root_src: ?FileSource = <span class="tok-kw">if</span> (options.root_source_file) |rsrc| rsrc.dupe(owner) <span class="tok-kw">else</span> <span class="tok-null">null</span>;</span>
<span class="line" id="L396"> <span class="tok-kw">if</span> (mem.indexOf(<span class="tok-type">u8</span>, name, <span class="tok-str">"/"</span>) != <span class="tok-null">null</span> <span class="tok-kw">or</span> mem.indexOf(<span class="tok-type">u8</span>, name, <span class="tok-str">"\\"</span>) != <span class="tok-null">null</span>) {</span>
<span class="line" id="L397"> panic(<span class="tok-str">"invalid name: '{s}'. It looks like a file path, but it is supposed to be the library or application name."</span>, .{name});</span>
<span class="line" id="L398"> }</span>
<span class="line" id="L399"></span>
<span class="line" id="L400"> <span class="tok-comment">// Avoid the common case of the step name looking like "zig test test".</span>
</span>
<span class="line" id="L401"> <span class="tok-kw">const</span> name_adjusted = <span class="tok-kw">if</span> (options.kind == .@"test" <span class="tok-kw">and</span> mem.eql(<span class="tok-type">u8</span>, name, <span class="tok-str">"test"</span>))</span>
<span class="line" id="L402"> <span class="tok-str">""</span></span>
<span class="line" id="L403"> <span class="tok-kw">else</span></span>
<span class="line" id="L404"> owner.fmt(<span class="tok-str">"{s} "</span>, .{name});</span>
<span class="line" id="L405"></span>
<span class="line" id="L406"> <span class="tok-kw">const</span> step_name = owner.fmt(<span class="tok-str">"{s} {s}{s} {s}"</span>, .{</span>
<span class="line" id="L407"> <span class="tok-kw">switch</span> (options.kind) {</span>
<span class="line" id="L408"> .exe => <span class="tok-str">"zig build-exe"</span>,</span>
<span class="line" id="L409"> .lib => <span class="tok-str">"zig build-lib"</span>,</span>
<span class="line" id="L410"> .obj => <span class="tok-str">"zig build-obj"</span>,</span>
<span class="line" id="L411"> .@"test" => <span class="tok-str">"zig test"</span>,</span>
<span class="line" id="L412"> },</span>
<span class="line" id="L413"> name_adjusted,</span>
<span class="line" id="L414"> <span class="tok-builtin">@tagName</span>(options.optimize),</span>
<span class="line" id="L415"> options.target.zigTriple(owner.allocator) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>),</span>
<span class="line" id="L416"> });</span>
<span class="line" id="L417"></span>
<span class="line" id="L418"> <span class="tok-kw">const</span> target_info = NativeTargetInfo.detect(options.target) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"unhandled error"</span>);</span>
<span class="line" id="L419"></span>
<span class="line" id="L420"> <span class="tok-kw">const</span> out_filename = std.zig.binNameAlloc(owner.allocator, .{</span>
<span class="line" id="L421"> .root_name = name,</span>
<span class="line" id="L422"> .target = target_info.target,</span>
<span class="line" id="L423"> .output_mode = <span class="tok-kw">switch</span> (options.kind) {</span>
<span class="line" id="L424"> .lib => .Lib,</span>
<span class="line" id="L425"> .obj => .Obj,</span>
<span class="line" id="L426"> .exe, .@"test" => .Exe,</span>
<span class="line" id="L427"> },</span>
<span class="line" id="L428"> .link_mode = <span class="tok-kw">if</span> (options.linkage) |some| <span class="tok-builtin">@as</span>(std.builtin.LinkMode, <span class="tok-kw">switch</span> (some) {</span>
<span class="line" id="L429"> .dynamic => .Dynamic,</span>
<span class="line" id="L430"> .static => .Static,</span>
<span class="line" id="L431"> }) <span class="tok-kw">else</span> <span class="tok-null">null</span>,</span>
<span class="line" id="L432"> .version = options.version,</span>
<span class="line" id="L433"> }) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L434"></span>
<span class="line" id="L435"> <span class="tok-kw">const</span> self = owner.allocator.create(Compile) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L436"> self.* = .{</span>
<span class="line" id="L437"> .strip = <span class="tok-null">null</span>,</span>
<span class="line" id="L438"> .unwind_tables = <span class="tok-null">null</span>,</span>
<span class="line" id="L439"> .verbose_link = <span class="tok-null">false</span>,</span>
<span class="line" id="L440"> .verbose_cc = <span class="tok-null">false</span>,</span>
<span class="line" id="L441"> .optimize = options.optimize,</span>
<span class="line" id="L442"> .target = options.target,</span>
<span class="line" id="L443"> .linkage = options.linkage,</span>
<span class="line" id="L444"> .kind = options.kind,</span>
<span class="line" id="L445"> .root_src = root_src,</span>
<span class="line" id="L446"> .name = name,</span>
<span class="line" id="L447"> .frameworks = StringHashMap(FrameworkLinkInfo).init(owner.allocator),</span>
<span class="line" id="L448"> .step = Step.init(.{</span>
<span class="line" id="L449"> .id = base_id,</span>
<span class="line" id="L450"> .name = step_name,</span>
<span class="line" id="L451"> .owner = owner,</span>
<span class="line" id="L452"> .makeFn = make,</span>
<span class="line" id="L453"> .max_rss = options.max_rss,</span>
<span class="line" id="L454"> }),</span>
<span class="line" id="L455"> .version = options.version,</span>
<span class="line" id="L456"> .out_filename = out_filename,</span>
<span class="line" id="L457"> .out_h_filename = owner.fmt(<span class="tok-str">"{s}.h"</span>, .{name}),</span>
<span class="line" id="L458"> .out_lib_filename = <span class="tok-null">undefined</span>,</span>
<span class="line" id="L459"> .out_pdb_filename = owner.fmt(<span class="tok-str">"{s}.pdb"</span>, .{name}),</span>
<span class="line" id="L460"> .major_only_filename = <span class="tok-null">null</span>,</span>
<span class="line" id="L461"> .name_only_filename = <span class="tok-null">null</span>,</span>
<span class="line" id="L462"> .modules = std.StringArrayHashMap(*Module).init(owner.allocator),</span>
<span class="line" id="L463"> .include_dirs = ArrayList(IncludeDir).init(owner.allocator),</span>
<span class="line" id="L464"> .link_objects = ArrayList(LinkObject).init(owner.allocator),</span>
<span class="line" id="L465"> .c_macros = ArrayList([]<span class="tok-kw">const</span> <span class="tok-type">u8</span>).init(owner.allocator),</span>
<span class="line" id="L466"> .lib_paths = ArrayList(FileSource).init(owner.allocator),</span>
<span class="line" id="L467"> .rpaths = ArrayList(FileSource).init(owner.allocator),</span>
<span class="line" id="L468"> .framework_dirs = ArrayList(FileSource).init(owner.allocator),</span>
<span class="line" id="L469"> .installed_headers = ArrayList(*Step).init(owner.allocator),</span>
<span class="line" id="L470"> .c_std = std.Build.CStd.C99,</span>
<span class="line" id="L471"> .zig_lib_dir = <span class="tok-null">null</span>,</span>
<span class="line" id="L472"> .main_pkg_path = <span class="tok-null">null</span>,</span>
<span class="line" id="L473"> .exec_cmd_args = <span class="tok-null">null</span>,</span>
<span class="line" id="L474"> .filter = options.filter,</span>
<span class="line" id="L475"> .test_runner = options.test_runner,</span>
<span class="line" id="L476"> .disable_stack_probing = <span class="tok-null">false</span>,</span>
<span class="line" id="L477"> .disable_sanitize_c = <span class="tok-null">false</span>,</span>
<span class="line" id="L478"> .sanitize_thread = <span class="tok-null">false</span>,</span>
<span class="line" id="L479"> .rdynamic = <span class="tok-null">false</span>,</span>
<span class="line" id="L480"> .override_dest_dir = <span class="tok-null">null</span>,</span>
<span class="line" id="L481"> .installed_path = <span class="tok-null">null</span>,</span>
<span class="line" id="L482"> .force_undefined_symbols = StringHashMap(<span class="tok-type">void</span>).init(owner.allocator),</span>
<span class="line" id="L483"></span>
<span class="line" id="L484"> .output_path_source = GeneratedFile{ .step = &self.step },</span>
<span class="line" id="L485"> .output_lib_path_source = GeneratedFile{ .step = &self.step },</span>
<span class="line" id="L486"> .output_h_path_source = GeneratedFile{ .step = &self.step },</span>
<span class="line" id="L487"> .output_pdb_path_source = GeneratedFile{ .step = &self.step },</span>
<span class="line" id="L488"> .output_dirname_source = GeneratedFile{ .step = &self.step },</span>
<span class="line" id="L489"> .generated_docs = <span class="tok-null">null</span>,</span>
<span class="line" id="L490"></span>
<span class="line" id="L491"> .target_info = target_info,</span>
<span class="line" id="L492"></span>
<span class="line" id="L493"> .is_linking_libc = options.link_libc <span class="tok-kw">orelse</span> <span class="tok-null">false</span>,</span>
<span class="line" id="L494"> .is_linking_libcpp = <span class="tok-null">false</span>,</span>
<span class="line" id="L495"> .single_threaded = options.single_threaded,</span>
<span class="line" id="L496"> .use_llvm = options.use_llvm,</span>
<span class="line" id="L497"> .use_lld = options.use_lld,</span>
<span class="line" id="L498"> };</span>
<span class="line" id="L499"></span>
<span class="line" id="L500"> <span class="tok-kw">if</span> (self.kind == .lib) {</span>
<span class="line" id="L501"> <span class="tok-kw">if</span> (self.linkage != <span class="tok-null">null</span> <span class="tok-kw">and</span> self.linkage.? == .static) {</span>
<span class="line" id="L502"> self.out_lib_filename = self.out_filename;</span>
<span class="line" id="L503"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (self.version) |version| {</span>
<span class="line" id="L504"> <span class="tok-kw">if</span> (target_info.target.isDarwin()) {</span>
<span class="line" id="L505"> self.major_only_filename = owner.fmt(<span class="tok-str">"lib{s}.{d}.dylib"</span>, .{</span>
<span class="line" id="L506"> self.name,</span>
<span class="line" id="L507"> version.major,</span>
<span class="line" id="L508"> });</span>
<span class="line" id="L509"> self.name_only_filename = owner.fmt(<span class="tok-str">"lib{s}.dylib"</span>, .{self.name});</span>
<span class="line" id="L510"> self.out_lib_filename = self.out_filename;</span>
<span class="line" id="L511"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (target_info.target.os.tag == .windows) {</span>
<span class="line" id="L512"> self.out_lib_filename = owner.fmt(<span class="tok-str">"{s}.lib"</span>, .{self.name});</span>
<span class="line" id="L513"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L514"> self.major_only_filename = owner.fmt(<span class="tok-str">"lib{s}.so.{d}"</span>, .{ self.name, version.major });</span>
<span class="line" id="L515"> self.name_only_filename = owner.fmt(<span class="tok-str">"lib{s}.so"</span>, .{self.name});</span>
<span class="line" id="L516"> self.out_lib_filename = self.out_filename;</span>
<span class="line" id="L517"> }</span>
<span class="line" id="L518"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L519"> <span class="tok-kw">if</span> (target_info.target.isDarwin()) {</span>
<span class="line" id="L520"> self.out_lib_filename = self.out_filename;</span>
<span class="line" id="L521"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (target_info.target.os.tag == .windows) {</span>
<span class="line" id="L522"> self.out_lib_filename = owner.fmt(<span class="tok-str">"{s}.lib"</span>, .{self.name});</span>
<span class="line" id="L523"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L524"> self.out_lib_filename = self.out_filename;</span>
<span class="line" id="L525"> }</span>
<span class="line" id="L526"> }</span>
<span class="line" id="L527"> }</span>
<span class="line" id="L528"></span>
<span class="line" id="L529"> <span class="tok-kw">if</span> (root_src) |rs| rs.addStepDependencies(&self.step);</span>
<span class="line" id="L530"></span>
<span class="line" id="L531"> <span class="tok-kw">return</span> self;</span>
<span class="line" id="L532">}</span>
<span class="line" id="L533"></span>
<span class="line" id="L534"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">installHeader</span>(cs: *Compile, src_path: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>, dest_rel_path: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L535"> <span class="tok-kw">const</span> b = cs.step.owner;</span>
<span class="line" id="L536"> <span class="tok-kw">const</span> install_file = b.addInstallHeaderFile(src_path, dest_rel_path);</span>
<span class="line" id="L537"> b.getInstallStep().dependOn(&install_file.step);</span>
<span class="line" id="L538"> cs.installed_headers.append(&install_file.step) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L539">}</span>
<span class="line" id="L540"></span>
<span class="line" id="L541"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> InstallConfigHeaderOptions = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L542"> install_dir: InstallDir = .header,</span>
<span class="line" id="L543"> dest_rel_path: ?[]<span class="tok-kw">const</span> <span class="tok-type">u8</span> = <span class="tok-null">null</span>,</span>
<span class="line" id="L544">};</span>
<span class="line" id="L545"></span>
<span class="line" id="L546"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">installConfigHeader</span>(</span>
<span class="line" id="L547"> cs: *Compile,</span>
<span class="line" id="L548"> config_header: *Step.ConfigHeader,</span>
<span class="line" id="L549"> options: InstallConfigHeaderOptions,</span>
<span class="line" id="L550">) <span class="tok-type">void</span> {</span>
<span class="line" id="L551"> <span class="tok-kw">const</span> dest_rel_path = options.dest_rel_path <span class="tok-kw">orelse</span> config_header.include_path;</span>
<span class="line" id="L552"> <span class="tok-kw">const</span> b = cs.step.owner;</span>
<span class="line" id="L553"> <span class="tok-kw">const</span> install_file = b.addInstallFileWithDir(</span>
<span class="line" id="L554"> .{ .generated = &config_header.output_file },</span>
<span class="line" id="L555"> options.install_dir,</span>
<span class="line" id="L556"> dest_rel_path,</span>
<span class="line" id="L557"> );</span>
<span class="line" id="L558"> install_file.step.dependOn(&config_header.step);</span>
<span class="line" id="L559"> b.getInstallStep().dependOn(&install_file.step);</span>
<span class="line" id="L560"> cs.installed_headers.append(&install_file.step) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L561">}</span>
<span class="line" id="L562"></span>
<span class="line" id="L563"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">installHeadersDirectory</span>(</span>
<span class="line" id="L564"> a: *Compile,</span>
<span class="line" id="L565"> src_dir_path: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L566"> dest_rel_path: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L567">) <span class="tok-type">void</span> {</span>
<span class="line" id="L568"> <span class="tok-kw">return</span> installHeadersDirectoryOptions(a, .{</span>
<span class="line" id="L569"> .source_dir = .{ .path = src_dir_path },</span>
<span class="line" id="L570"> .install_dir = .header,</span>
<span class="line" id="L571"> .install_subdir = dest_rel_path,</span>
<span class="line" id="L572"> });</span>
<span class="line" id="L573">}</span>
<span class="line" id="L574"></span>
<span class="line" id="L575"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">installHeadersDirectoryOptions</span>(</span>
<span class="line" id="L576"> cs: *Compile,</span>
<span class="line" id="L577"> options: std.Build.Step.InstallDir.Options,</span>
<span class="line" id="L578">) <span class="tok-type">void</span> {</span>
<span class="line" id="L579"> <span class="tok-kw">const</span> b = cs.step.owner;</span>
<span class="line" id="L580"> <span class="tok-kw">const</span> install_dir = b.addInstallDirectory(options);</span>
<span class="line" id="L581"> b.getInstallStep().dependOn(&install_dir.step);</span>
<span class="line" id="L582"> cs.installed_headers.append(&install_dir.step) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L583">}</span>
<span class="line" id="L584"></span>
<span class="line" id="L585"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">installLibraryHeaders</span>(cs: *Compile, l: *Compile) <span class="tok-type">void</span> {</span>
<span class="line" id="L586"> assert(l.kind == .lib);</span>
<span class="line" id="L587"> <span class="tok-kw">const</span> b = cs.step.owner;</span>
<span class="line" id="L588"> <span class="tok-kw">const</span> install_step = b.getInstallStep();</span>
<span class="line" id="L589"> <span class="tok-comment">// Copy each element from installed_headers, modifying the builder</span>
</span>
<span class="line" id="L590"> <span class="tok-comment">// to be the new parent's builder.</span>
</span>
<span class="line" id="L591"> <span class="tok-kw">for</span> (l.installed_headers.items) |step| {</span>
<span class="line" id="L592"> <span class="tok-kw">const</span> step_copy = <span class="tok-kw">switch</span> (step.id) {</span>
<span class="line" id="L593"> <span class="tok-kw">inline</span> .install_file, .install_dir => |id| blk: {</span>
<span class="line" id="L594"> <span class="tok-kw">const</span> T = id.Type();</span>
<span class="line" id="L595"> <span class="tok-kw">const</span> ptr = b.allocator.create(T) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L596"> ptr.* = step.cast(T).?.*;</span>
<span class="line" id="L597"> ptr.dest_builder = b;</span>
<span class="line" id="L598"> <span class="tok-kw">break</span> :blk &ptr.step;</span>
<span class="line" id="L599"> },</span>
<span class="line" id="L600"> <span class="tok-kw">else</span> => <span class="tok-kw">unreachable</span>,</span>
<span class="line" id="L601"> };</span>
<span class="line" id="L602"> cs.installed_headers.append(step_copy) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L603"> install_step.dependOn(step_copy);</span>
<span class="line" id="L604"> }</span>
<span class="line" id="L605"> cs.installed_headers.appendSlice(l.installed_headers.items) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L606">}</span>
<span class="line" id="L607"></span>
<span class="line" id="L608"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addObjCopy</span>(cs: *Compile, options: Step.ObjCopy.Options) *Step.ObjCopy {</span>
<span class="line" id="L609"> <span class="tok-kw">const</span> b = cs.step.owner;</span>
<span class="line" id="L610"> <span class="tok-kw">var</span> copy = options;</span>
<span class="line" id="L611"> <span class="tok-kw">if</span> (copy.basename == <span class="tok-null">null</span>) {</span>
<span class="line" id="L612"> <span class="tok-kw">if</span> (options.format) |f| {</span>
<span class="line" id="L613"> copy.basename = b.fmt(<span class="tok-str">"{s}.{s}"</span>, .{ cs.name, <span class="tok-builtin">@tagName</span>(f) });</span>
<span class="line" id="L614"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L615"> copy.basename = cs.name;</span>
<span class="line" id="L616"> }</span>
<span class="line" id="L617"> }</span>
<span class="line" id="L618"> <span class="tok-kw">return</span> b.addObjCopy(cs.getOutputSource(), copy);</span>
<span class="line" id="L619">}</span>
<span class="line" id="L620"></span>
<span class="line" id="L621"><span class="tok-comment">/// This function would run in the context of the package that created the executable,</span></span>
<span class="line" id="L622"><span class="tok-comment">/// which is undesirable when running an executable provided by a dependency package.</span></span>
<span class="line" id="L623"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> run = <span class="tok-builtin">@compileError</span>(<span class="tok-str">"deprecated; use std.Build.addRunArtifact"</span>);</span>
<span class="line" id="L624"></span>
<span class="line" id="L625"><span class="tok-comment">/// This function would install in the context of the package that created the artifact,</span></span>
<span class="line" id="L626"><span class="tok-comment">/// which is undesirable when installing an artifact provided by a dependency package.</span></span>
<span class="line" id="L627"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> install = <span class="tok-builtin">@compileError</span>(<span class="tok-str">"deprecated; use std.Build.installArtifact"</span>);</span>
<span class="line" id="L628"></span>
<span class="line" id="L629"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">checkObject</span>(self: *Compile) *Step.CheckObject {</span>
<span class="line" id="L630"> <span class="tok-kw">return</span> Step.CheckObject.create(self.step.owner, self.getOutputSource(), self.target_info.target.ofmt);</span>
<span class="line" id="L631">}</span>
<span class="line" id="L632"></span>
<span class="line" id="L633"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">setLinkerScriptPath</span>(self: *Compile, source: FileSource) <span class="tok-type">void</span> {</span>
<span class="line" id="L634"> <span class="tok-kw">const</span> b = self.step.owner;</span>
<span class="line" id="L635"> self.linker_script = source.dupe(b);</span>
<span class="line" id="L636"> source.addStepDependencies(&self.step);</span>
<span class="line" id="L637">}</span>
<span class="line" id="L638"></span>
<span class="line" id="L639"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">forceUndefinedSymbol</span>(self: *Compile, symbol_name: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L640"> <span class="tok-kw">const</span> b = self.step.owner;</span>
<span class="line" id="L641"> self.force_undefined_symbols.put(b.dupe(symbol_name), {}) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L642">}</span>
<span class="line" id="L643"></span>
<span class="line" id="L644"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">linkFramework</span>(self: *Compile, framework_name: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L645"> <span class="tok-kw">const</span> b = self.step.owner;</span>
<span class="line" id="L646"> self.frameworks.put(b.dupe(framework_name), .{}) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L647">}</span>
<span class="line" id="L648"></span>
<span class="line" id="L649"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">linkFrameworkNeeded</span>(self: *Compile, framework_name: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L650"> <span class="tok-kw">const</span> b = self.step.owner;</span>
<span class="line" id="L651"> self.frameworks.put(b.dupe(framework_name), .{</span>
<span class="line" id="L652"> .needed = <span class="tok-null">true</span>,</span>
<span class="line" id="L653"> }) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L654">}</span>
<span class="line" id="L655"></span>
<span class="line" id="L656"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">linkFrameworkWeak</span>(self: *Compile, framework_name: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L657"> <span class="tok-kw">const</span> b = self.step.owner;</span>
<span class="line" id="L658"> self.frameworks.put(b.dupe(framework_name), .{</span>
<span class="line" id="L659"> .weak = <span class="tok-null">true</span>,</span>
<span class="line" id="L660"> }) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L661">}</span>
<span class="line" id="L662"></span>
<span class="line" id="L663"><span class="tok-comment">/// Returns whether the library, executable, or object depends on a particular system library.</span></span>
<span class="line" id="L664"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">dependsOnSystemLibrary</span>(self: Compile, name: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) <span class="tok-type">bool</span> {</span>
<span class="line" id="L665"> <span class="tok-kw">if</span> (isLibCLibrary(name)) {</span>
<span class="line" id="L666"> <span class="tok-kw">return</span> self.is_linking_libc;</span>
<span class="line" id="L667"> }</span>
<span class="line" id="L668"> <span class="tok-kw">if</span> (isLibCppLibrary(name)) {</span>
<span class="line" id="L669"> <span class="tok-kw">return</span> self.is_linking_libcpp;</span>
<span class="line" id="L670"> }</span>
<span class="line" id="L671"> <span class="tok-kw">for</span> (self.link_objects.items) |link_object| {</span>
<span class="line" id="L672"> <span class="tok-kw">switch</span> (link_object) {</span>
<span class="line" id="L673"> .system_lib => |lib| <span class="tok-kw">if</span> (mem.eql(<span class="tok-type">u8</span>, lib.name, name)) <span class="tok-kw">return</span> <span class="tok-null">true</span>,</span>
<span class="line" id="L674"> <span class="tok-kw">else</span> => <span class="tok-kw">continue</span>,</span>
<span class="line" id="L675"> }</span>
<span class="line" id="L676"> }</span>
<span class="line" id="L677"> <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L678">}</span>
<span class="line" id="L679"></span>
<span class="line" id="L680"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">linkLibrary</span>(self: *Compile, lib: *Compile) <span class="tok-type">void</span> {</span>
<span class="line" id="L681"> assert(lib.kind == .lib);</span>
<span class="line" id="L682"> self.linkLibraryOrObject(lib);</span>
<span class="line" id="L683">}</span>
<span class="line" id="L684"></span>
<span class="line" id="L685"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">isDynamicLibrary</span>(self: *Compile) <span class="tok-type">bool</span> {</span>
<span class="line" id="L686"> <span class="tok-kw">return</span> self.kind == .lib <span class="tok-kw">and</span> self.linkage == Linkage.dynamic;</span>
<span class="line" id="L687">}</span>
<span class="line" id="L688"></span>
<span class="line" id="L689"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">isStaticLibrary</span>(self: *Compile) <span class="tok-type">bool</span> {</span>
<span class="line" id="L690"> <span class="tok-kw">return</span> self.kind == .lib <span class="tok-kw">and</span> self.linkage != Linkage.dynamic;</span>
<span class="line" id="L691">}</span>
<span class="line" id="L692"></span>
<span class="line" id="L693"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">producesPdbFile</span>(self: *Compile) <span class="tok-type">bool</span> {</span>
<span class="line" id="L694"> <span class="tok-kw">if</span> (!self.target.isWindows() <span class="tok-kw">and</span> !self.target.isUefi()) <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L695"> <span class="tok-kw">if</span> (self.target.getObjectFormat() == .c) <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L696"> <span class="tok-kw">if</span> (self.strip == <span class="tok-null">true</span> <span class="tok-kw">or</span> (self.strip == <span class="tok-null">null</span> <span class="tok-kw">and</span> self.optimize == .ReleaseSmall)) <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L697"> <span class="tok-kw">return</span> self.isDynamicLibrary() <span class="tok-kw">or</span> self.kind == .exe <span class="tok-kw">or</span> self.kind == .@"test";</span>
<span class="line" id="L698">}</span>
<span class="line" id="L699"></span>
<span class="line" id="L700"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">linkLibC</span>(self: *Compile) <span class="tok-type">void</span> {</span>
<span class="line" id="L701"> self.is_linking_libc = <span class="tok-null">true</span>;</span>
<span class="line" id="L702">}</span>
<span class="line" id="L703"></span>
<span class="line" id="L704"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">linkLibCpp</span>(self: *Compile) <span class="tok-type">void</span> {</span>
<span class="line" id="L705"> self.is_linking_libcpp = <span class="tok-null">true</span>;</span>
<span class="line" id="L706">}</span>
<span class="line" id="L707"></span>
<span class="line" id="L708"><span class="tok-comment">/// If the value is omitted, it is set to 1.</span></span>
<span class="line" id="L709"><span class="tok-comment">/// `name` and `value` need not live longer than the function call.</span></span>
<span class="line" id="L710"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">defineCMacro</span>(self: *Compile, name: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>, value: ?[]<span class="tok-kw">const</span> <span class="tok-type">u8</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L711"> <span class="tok-kw">const</span> b = self.step.owner;</span>
<span class="line" id="L712"> <span class="tok-kw">const</span> macro = std.Build.constructCMacro(b.allocator, name, value);</span>
<span class="line" id="L713"> self.c_macros.append(macro) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L714">}</span>
<span class="line" id="L715"></span>
<span class="line" id="L716"><span class="tok-comment">/// name_and_value looks like [name]=[value]. If the value is omitted, it is set to 1.</span></span>
<span class="line" id="L717"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">defineCMacroRaw</span>(self: *Compile, name_and_value: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L718"> <span class="tok-kw">const</span> b = self.step.owner;</span>
<span class="line" id="L719"> self.c_macros.append(b.dupe(name_and_value)) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L720">}</span>
<span class="line" id="L721"></span>
<span class="line" id="L722"><span class="tok-comment">/// This one has no integration with anything, it just puts -lname on the command line.</span></span>
<span class="line" id="L723"><span class="tok-comment">/// Prefer to use `linkSystemLibrary` instead.</span></span>
<span class="line" id="L724"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">linkSystemLibraryName</span>(self: *Compile, name: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L725"> <span class="tok-kw">const</span> b = self.step.owner;</span>
<span class="line" id="L726"> self.link_objects.append(.{</span>
<span class="line" id="L727"> .system_lib = .{</span>
<span class="line" id="L728"> .name = b.dupe(name),</span>
<span class="line" id="L729"> .needed = <span class="tok-null">false</span>,</span>
<span class="line" id="L730"> .weak = <span class="tok-null">false</span>,</span>
<span class="line" id="L731"> .use_pkg_config = .no,</span>
<span class="line" id="L732"> },</span>
<span class="line" id="L733"> }) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L734">}</span>
<span class="line" id="L735"></span>
<span class="line" id="L736"><span class="tok-comment">/// This one has no integration with anything, it just puts -needed-lname on the command line.</span></span>
<span class="line" id="L737"><span class="tok-comment">/// Prefer to use `linkSystemLibraryNeeded` instead.</span></span>
<span class="line" id="L738"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">linkSystemLibraryNeededName</span>(self: *Compile, name: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L739"> <span class="tok-kw">const</span> b = self.step.owner;</span>
<span class="line" id="L740"> self.link_objects.append(.{</span>
<span class="line" id="L741"> .system_lib = .{</span>
<span class="line" id="L742"> .name = b.dupe(name),</span>
<span class="line" id="L743"> .needed = <span class="tok-null">true</span>,</span>
<span class="line" id="L744"> .weak = <span class="tok-null">false</span>,</span>
<span class="line" id="L745"> .use_pkg_config = .no,</span>
<span class="line" id="L746"> },</span>
<span class="line" id="L747"> }) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L748">}</span>
<span class="line" id="L749"></span>
<span class="line" id="L750"><span class="tok-comment">/// Darwin-only. This one has no integration with anything, it just puts -weak-lname on the</span></span>
<span class="line" id="L751"><span class="tok-comment">/// command line. Prefer to use `linkSystemLibraryWeak` instead.</span></span>
<span class="line" id="L752"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">linkSystemLibraryWeakName</span>(self: *Compile, name: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L753"> <span class="tok-kw">const</span> b = self.step.owner;</span>
<span class="line" id="L754"> self.link_objects.append(.{</span>
<span class="line" id="L755"> .system_lib = .{</span>
<span class="line" id="L756"> .name = b.dupe(name),</span>
<span class="line" id="L757"> .needed = <span class="tok-null">false</span>,</span>
<span class="line" id="L758"> .weak = <span class="tok-null">true</span>,</span>
<span class="line" id="L759"> .use_pkg_config = .no,</span>
<span class="line" id="L760"> },</span>
<span class="line" id="L761"> }) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L762">}</span>
<span class="line" id="L763"></span>
<span class="line" id="L764"><span class="tok-comment">/// This links against a system library, exclusively using pkg-config to find the library.</span></span>
<span class="line" id="L765"><span class="tok-comment">/// Prefer to use `linkSystemLibrary` instead.</span></span>
<span class="line" id="L766"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">linkSystemLibraryPkgConfigOnly</span>(self: *Compile, lib_name: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L767"> <span class="tok-kw">const</span> b = self.step.owner;</span>
<span class="line" id="L768"> self.link_objects.append(.{</span>
<span class="line" id="L769"> .system_lib = .{</span>
<span class="line" id="L770"> .name = b.dupe(lib_name),</span>
<span class="line" id="L771"> .needed = <span class="tok-null">false</span>,</span>
<span class="line" id="L772"> .weak = <span class="tok-null">false</span>,</span>
<span class="line" id="L773"> .use_pkg_config = .force,</span>
<span class="line" id="L774"> },</span>
<span class="line" id="L775"> }) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L776">}</span>
<span class="line" id="L777"></span>
<span class="line" id="L778"><span class="tok-comment">/// This links against a system library, exclusively using pkg-config to find the library.</span></span>
<span class="line" id="L779"><span class="tok-comment">/// Prefer to use `linkSystemLibraryNeeded` instead.</span></span>
<span class="line" id="L780"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">linkSystemLibraryNeededPkgConfigOnly</span>(self: *Compile, lib_name: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L781"> <span class="tok-kw">const</span> b = self.step.owner;</span>
<span class="line" id="L782"> self.link_objects.append(.{</span>
<span class="line" id="L783"> .system_lib = .{</span>
<span class="line" id="L784"> .name = b.dupe(lib_name),</span>
<span class="line" id="L785"> .needed = <span class="tok-null">true</span>,</span>
<span class="line" id="L786"> .weak = <span class="tok-null">false</span>,</span>
<span class="line" id="L787"> .use_pkg_config = .force,</span>
<span class="line" id="L788"> },</span>
<span class="line" id="L789"> }) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L790">}</span>
<span class="line" id="L791"></span>
<span class="line" id="L792"><span class="tok-comment">/// Run pkg-config for the given library name and parse the output, returning the arguments</span></span>
<span class="line" id="L793"><span class="tok-comment">/// that should be passed to zig to link the given library.</span></span>
<span class="line" id="L794"><span class="tok-kw">fn</span> <span class="tok-fn">runPkgConfig</span>(self: *Compile, lib_name: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) ![]<span class="tok-kw">const</span> []<span class="tok-kw">const</span> <span class="tok-type">u8</span> {</span>
<span class="line" id="L795"> <span class="tok-kw">const</span> b = self.step.owner;</span>
<span class="line" id="L796"> <span class="tok-kw">const</span> pkg_name = match: {</span>
<span class="line" id="L797"> <span class="tok-comment">// First we have to map the library name to pkg config name. Unfortunately,</span>
</span>
<span class="line" id="L798"> <span class="tok-comment">// there are several examples where this is not straightforward:</span>
</span>
<span class="line" id="L799"> <span class="tok-comment">// -lSDL2 -> pkg-config sdl2</span>
</span>
<span class="line" id="L800"> <span class="tok-comment">// -lgdk-3 -> pkg-config gdk-3.0</span>
</span>
<span class="line" id="L801"> <span class="tok-comment">// -latk-1.0 -> pkg-config atk</span>
</span>
<span class="line" id="L802"> <span class="tok-kw">const</span> pkgs = <span class="tok-kw">try</span> getPkgConfigList(b);</span>
<span class="line" id="L803"></span>
<span class="line" id="L804"> <span class="tok-comment">// Exact match means instant winner.</span>
</span>
<span class="line" id="L805"> <span class="tok-kw">for</span> (pkgs) |pkg| {</span>
<span class="line" id="L806"> <span class="tok-kw">if</span> (mem.eql(<span class="tok-type">u8</span>, pkg.name, lib_name)) {</span>
<span class="line" id="L807"> <span class="tok-kw">break</span> :match pkg.name;</span>
<span class="line" id="L808"> }</span>
<span class="line" id="L809"> }</span>
<span class="line" id="L810"></span>
<span class="line" id="L811"> <span class="tok-comment">// Next we'll try ignoring case.</span>
</span>
<span class="line" id="L812"> <span class="tok-kw">for</span> (pkgs) |pkg| {</span>
<span class="line" id="L813"> <span class="tok-kw">if</span> (std.ascii.eqlIgnoreCase(pkg.name, lib_name)) {</span>
<span class="line" id="L814"> <span class="tok-kw">break</span> :match pkg.name;</span>
<span class="line" id="L815"> }</span>
<span class="line" id="L816"> }</span>
<span class="line" id="L817"></span>
<span class="line" id="L818"> <span class="tok-comment">// Now try appending ".0".</span>
</span>
<span class="line" id="L819"> <span class="tok-kw">for</span> (pkgs) |pkg| {</span>
<span class="line" id="L820"> <span class="tok-kw">if</span> (std.ascii.indexOfIgnoreCase(pkg.name, lib_name)) |pos| {</span>
<span class="line" id="L821"> <span class="tok-kw">if</span> (pos != <span class="tok-number">0</span>) <span class="tok-kw">continue</span>;</span>
<span class="line" id="L822"> <span class="tok-kw">if</span> (mem.eql(<span class="tok-type">u8</span>, pkg.name[lib_name.len..], <span class="tok-str">".0"</span>)) {</span>
<span class="line" id="L823"> <span class="tok-kw">break</span> :match pkg.name;</span>
<span class="line" id="L824"> }</span>
<span class="line" id="L825"> }</span>
<span class="line" id="L826"> }</span>
<span class="line" id="L827"></span>
<span class="line" id="L828"> <span class="tok-comment">// Trimming "-1.0".</span>
</span>
<span class="line" id="L829"> <span class="tok-kw">if</span> (mem.endsWith(<span class="tok-type">u8</span>, lib_name, <span class="tok-str">"-1.0"</span>)) {</span>
<span class="line" id="L830"> <span class="tok-kw">const</span> trimmed_lib_name = lib_name[<span class="tok-number">0</span> .. lib_name.len - <span class="tok-str">"-1.0"</span>.len];</span>
<span class="line" id="L831"> <span class="tok-kw">for</span> (pkgs) |pkg| {</span>
<span class="line" id="L832"> <span class="tok-kw">if</span> (std.ascii.eqlIgnoreCase(pkg.name, trimmed_lib_name)) {</span>
<span class="line" id="L833"> <span class="tok-kw">break</span> :match pkg.name;</span>
<span class="line" id="L834"> }</span>
<span class="line" id="L835"> }</span>
<span class="line" id="L836"> }</span>
<span class="line" id="L837"></span>
<span class="line" id="L838"> <span class="tok-kw">return</span> <span class="tok-kw">error</span>.PackageNotFound;</span>
<span class="line" id="L839"> };</span>
<span class="line" id="L840"></span>
<span class="line" id="L841"> <span class="tok-kw">var</span> code: <span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L842"> <span class="tok-kw">const</span> stdout = <span class="tok-kw">if</span> (b.execAllowFail(&[_][]<span class="tok-kw">const</span> <span class="tok-type">u8</span>{</span>
<span class="line" id="L843"> <span class="tok-str">"pkg-config"</span>,</span>
<span class="line" id="L844"> pkg_name,</span>
<span class="line" id="L845"> <span class="tok-str">"--cflags"</span>,</span>
<span class="line" id="L846"> <span class="tok-str">"--libs"</span>,</span>
<span class="line" id="L847"> }, &code, .Ignore)) |stdout| stdout <span class="tok-kw">else</span> |err| <span class="tok-kw">switch</span> (err) {</span>
<span class="line" id="L848"> <span class="tok-kw">error</span>.ProcessTerminated => <span class="tok-kw">return</span> <span class="tok-kw">error</span>.PkgConfigCrashed,</span>
<span class="line" id="L849"> <span class="tok-kw">error</span>.ExecNotSupported => <span class="tok-kw">return</span> <span class="tok-kw">error</span>.PkgConfigFailed,</span>
<span class="line" id="L850"> <span class="tok-kw">error</span>.ExitCodeFailure => <span class="tok-kw">return</span> <span class="tok-kw">error</span>.PkgConfigFailed,</span>
<span class="line" id="L851"> <span class="tok-kw">error</span>.FileNotFound => <span class="tok-kw">return</span> <span class="tok-kw">error</span>.PkgConfigNotInstalled,</span>
<span class="line" id="L852"> <span class="tok-kw">else</span> => <span class="tok-kw">return</span> err,</span>
<span class="line" id="L853"> };</span>
<span class="line" id="L854"></span>
<span class="line" id="L855"> <span class="tok-kw">var</span> zig_args = ArrayList([]<span class="tok-kw">const</span> <span class="tok-type">u8</span>).init(b.allocator);</span>
<span class="line" id="L856"> <span class="tok-kw">defer</span> zig_args.deinit();</span>
<span class="line" id="L857"></span>
<span class="line" id="L858"> <span class="tok-kw">var</span> it = mem.tokenizeAny(<span class="tok-type">u8</span>, stdout, <span class="tok-str">" \r\n\t"</span>);</span>
<span class="line" id="L859"> <span class="tok-kw">while</span> (it.next()) |tok| {</span>
<span class="line" id="L860"> <span class="tok-kw">if</span> (mem.eql(<span class="tok-type">u8</span>, tok, <span class="tok-str">"-I"</span>)) {</span>
<span class="line" id="L861"> <span class="tok-kw">const</span> dir = it.next() <span class="tok-kw">orelse</span> <span class="tok-kw">return</span> <span class="tok-kw">error</span>.PkgConfigInvalidOutput;</span>
<span class="line" id="L862"> <span class="tok-kw">try</span> zig_args.appendSlice(&[_][]<span class="tok-kw">const</span> <span class="tok-type">u8</span>{ <span class="tok-str">"-I"</span>, dir });</span>
<span class="line" id="L863"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (mem.startsWith(<span class="tok-type">u8</span>, tok, <span class="tok-str">"-I"</span>)) {</span>
<span class="line" id="L864"> <span class="tok-kw">try</span> zig_args.append(tok);</span>
<span class="line" id="L865"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (mem.eql(<span class="tok-type">u8</span>, tok, <span class="tok-str">"-L"</span>)) {</span>
<span class="line" id="L866"> <span class="tok-kw">const</span> dir = it.next() <span class="tok-kw">orelse</span> <span class="tok-kw">return</span> <span class="tok-kw">error</span>.PkgConfigInvalidOutput;</span>
<span class="line" id="L867"> <span class="tok-kw">try</span> zig_args.appendSlice(&[_][]<span class="tok-kw">const</span> <span class="tok-type">u8</span>{ <span class="tok-str">"-L"</span>, dir });</span>
<span class="line" id="L868"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (mem.startsWith(<span class="tok-type">u8</span>, tok, <span class="tok-str">"-L"</span>)) {</span>
<span class="line" id="L869"> <span class="tok-kw">try</span> zig_args.append(tok);</span>
<span class="line" id="L870"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (mem.eql(<span class="tok-type">u8</span>, tok, <span class="tok-str">"-l"</span>)) {</span>
<span class="line" id="L871"> <span class="tok-kw">const</span> lib = it.next() <span class="tok-kw">orelse</span> <span class="tok-kw">return</span> <span class="tok-kw">error</span>.PkgConfigInvalidOutput;</span>
<span class="line" id="L872"> <span class="tok-kw">try</span> zig_args.appendSlice(&[_][]<span class="tok-kw">const</span> <span class="tok-type">u8</span>{ <span class="tok-str">"-l"</span>, lib });</span>
<span class="line" id="L873"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (mem.startsWith(<span class="tok-type">u8</span>, tok, <span class="tok-str">"-l"</span>)) {</span>
<span class="line" id="L874"> <span class="tok-kw">try</span> zig_args.append(tok);</span>
<span class="line" id="L875"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (mem.eql(<span class="tok-type">u8</span>, tok, <span class="tok-str">"-D"</span>)) {</span>
<span class="line" id="L876"> <span class="tok-kw">const</span> macro = it.next() <span class="tok-kw">orelse</span> <span class="tok-kw">return</span> <span class="tok-kw">error</span>.PkgConfigInvalidOutput;</span>
<span class="line" id="L877"> <span class="tok-kw">try</span> zig_args.appendSlice(&[_][]<span class="tok-kw">const</span> <span class="tok-type">u8</span>{ <span class="tok-str">"-D"</span>, macro });</span>
<span class="line" id="L878"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (mem.startsWith(<span class="tok-type">u8</span>, tok, <span class="tok-str">"-D"</span>)) {</span>
<span class="line" id="L879"> <span class="tok-kw">try</span> zig_args.append(tok);</span>
<span class="line" id="L880"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (b.debug_pkg_config) {</span>
<span class="line" id="L881"> <span class="tok-kw">return</span> self.step.fail(<span class="tok-str">"unknown pkg-config flag '{s}'"</span>, .{tok});</span>
<span class="line" id="L882"> }</span>
<span class="line" id="L883"> }</span>
<span class="line" id="L884"></span>
<span class="line" id="L885"> <span class="tok-kw">return</span> zig_args.toOwnedSlice();</span>
<span class="line" id="L886">}</span>
<span class="line" id="L887"></span>
<span class="line" id="L888"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">linkSystemLibrary</span>(self: *Compile, name: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L889"> self.linkSystemLibraryInner(name, .{});</span>
<span class="line" id="L890">}</span>
<span class="line" id="L891"></span>
<span class="line" id="L892"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">linkSystemLibraryNeeded</span>(self: *Compile, name: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L893"> self.linkSystemLibraryInner(name, .{ .needed = <span class="tok-null">true</span> });</span>
<span class="line" id="L894">}</span>
<span class="line" id="L895"></span>
<span class="line" id="L896"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">linkSystemLibraryWeak</span>(self: *Compile, name: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L897"> self.linkSystemLibraryInner(name, .{ .weak = <span class="tok-null">true</span> });</span>
<span class="line" id="L898">}</span>
<span class="line" id="L899"></span>
<span class="line" id="L900"><span class="tok-kw">fn</span> <span class="tok-fn">linkSystemLibraryInner</span>(self: *Compile, name: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>, opts: <span class="tok-kw">struct</span> {</span>
<span class="line" id="L901"> needed: <span class="tok-type">bool</span> = <span class="tok-null">false</span>,</span>
<span class="line" id="L902"> weak: <span class="tok-type">bool</span> = <span class="tok-null">false</span>,</span>
<span class="line" id="L903">}) <span class="tok-type">void</span> {</span>
<span class="line" id="L904"> <span class="tok-kw">const</span> b = self.step.owner;</span>
<span class="line" id="L905"> <span class="tok-kw">if</span> (isLibCLibrary(name)) {</span>
<span class="line" id="L906"> self.linkLibC();</span>
<span class="line" id="L907"> <span class="tok-kw">return</span>;</span>
<span class="line" id="L908"> }</span>
<span class="line" id="L909"> <span class="tok-kw">if</span> (isLibCppLibrary(name)) {</span>
<span class="line" id="L910"> self.linkLibCpp();</span>
<span class="line" id="L911"> <span class="tok-kw">return</span>;</span>
<span class="line" id="L912"> }</span>
<span class="line" id="L913"></span>
<span class="line" id="L914"> self.link_objects.append(.{</span>
<span class="line" id="L915"> .system_lib = .{</span>
<span class="line" id="L916"> .name = b.dupe(name),</span>
<span class="line" id="L917"> .needed = opts.needed,</span>
<span class="line" id="L918"> .weak = opts.weak,</span>
<span class="line" id="L919"> .use_pkg_config = .yes,</span>
<span class="line" id="L920"> },</span>
<span class="line" id="L921"> }) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L922">}</span>
<span class="line" id="L923"></span>
<span class="line" id="L924"><span class="tok-comment">/// Handy when you have many C/C++ source files and want them all to have the same flags.</span></span>
<span class="line" id="L925"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addCSourceFiles</span>(self: *Compile, files: []<span class="tok-kw">const</span> []<span class="tok-kw">const</span> <span class="tok-type">u8</span>, flags: []<span class="tok-kw">const</span> []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L926"> <span class="tok-kw">const</span> b = self.step.owner;</span>
<span class="line" id="L927"> <span class="tok-kw">const</span> c_source_files = b.allocator.create(CSourceFiles) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L928"></span>
<span class="line" id="L929"> <span class="tok-kw">const</span> files_copy = b.dupeStrings(files);</span>
<span class="line" id="L930"> <span class="tok-kw">const</span> flags_copy = b.dupeStrings(flags);</span>
<span class="line" id="L931"></span>
<span class="line" id="L932"> c_source_files.* = .{</span>
<span class="line" id="L933"> .files = files_copy,</span>
<span class="line" id="L934"> .flags = flags_copy,</span>
<span class="line" id="L935"> };</span>
<span class="line" id="L936"> self.link_objects.append(.{ .c_source_files = c_source_files }) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L937">}</span>
<span class="line" id="L938"></span>
<span class="line" id="L939"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addCSourceFile</span>(self: *Compile, file: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>, flags: []<span class="tok-kw">const</span> []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L940"> self.addCSourceFileSource(.{</span>
<span class="line" id="L941"> .args = flags,</span>
<span class="line" id="L942"> .source = .{ .path = file },</span>
<span class="line" id="L943"> });</span>
<span class="line" id="L944">}</span>
<span class="line" id="L945"></span>
<span class="line" id="L946"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addCSourceFileSource</span>(self: *Compile, source: CSourceFile) <span class="tok-type">void</span> {</span>
<span class="line" id="L947"> <span class="tok-kw">const</span> b = self.step.owner;</span>
<span class="line" id="L948"> <span class="tok-kw">const</span> c_source_file = b.allocator.create(CSourceFile) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L949"> c_source_file.* = source.dupe(b);</span>
<span class="line" id="L950"> self.link_objects.append(.{ .c_source_file = c_source_file }) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L951"> source.source.addStepDependencies(&self.step);</span>
<span class="line" id="L952">}</span>
<span class="line" id="L953"></span>
<span class="line" id="L954"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">setVerboseLink</span>(self: *Compile, value: <span class="tok-type">bool</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L955"> self.verbose_link = value;</span>
<span class="line" id="L956">}</span>
<span class="line" id="L957"></span>
<span class="line" id="L958"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">setVerboseCC</span>(self: *Compile, value: <span class="tok-type">bool</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L959"> self.verbose_cc = value;</span>
<span class="line" id="L960">}</span>
<span class="line" id="L961"></span>
<span class="line" id="L962"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">overrideZigLibDir</span>(self: *Compile, dir_path: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L963"> <span class="tok-kw">const</span> b = self.step.owner;</span>
<span class="line" id="L964"> self.zig_lib_dir = b.dupePath(dir_path);</span>
<span class="line" id="L965">}</span>
<span class="line" id="L966"></span>
<span class="line" id="L967"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">setMainPkgPath</span>(self: *Compile, dir_path: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L968"> <span class="tok-kw">const</span> b = self.step.owner;</span>
<span class="line" id="L969"> self.main_pkg_path = b.dupePath(dir_path);</span>
<span class="line" id="L970">}</span>
<span class="line" id="L971"></span>
<span class="line" id="L972"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">setLibCFile</span>(self: *Compile, libc_file: ?FileSource) <span class="tok-type">void</span> {</span>
<span class="line" id="L973"> <span class="tok-kw">const</span> b = self.step.owner;</span>
<span class="line" id="L974"> self.libc_file = <span class="tok-kw">if</span> (libc_file) |f| f.dupe(b) <span class="tok-kw">else</span> <span class="tok-null">null</span>;</span>
<span class="line" id="L975">}</span>
<span class="line" id="L976"></span>
<span class="line" id="L977"><span class="tok-comment">/// Returns the generated executable, library or object file.</span></span>
<span class="line" id="L978"><span class="tok-comment">/// To run an executable built with zig build, use `run`, or create an install step and invoke it.</span></span>
<span class="line" id="L979"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">getOutputSource</span>(self: *Compile) FileSource {</span>
<span class="line" id="L980"> <span class="tok-kw">return</span> .{ .generated = &self.output_path_source };</span>
<span class="line" id="L981">}</span>
<span class="line" id="L982"></span>
<span class="line" id="L983"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">getOutputDirectorySource</span>(self: *Compile) FileSource {</span>
<span class="line" id="L984"> <span class="tok-kw">return</span> .{ .generated = &self.output_dirname_source };</span>
<span class="line" id="L985">}</span>
<span class="line" id="L986"></span>
<span class="line" id="L987"><span class="tok-comment">/// Returns the generated import library. This function can only be called for libraries.</span></span>
<span class="line" id="L988"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">getOutputLibSource</span>(self: *Compile) FileSource {</span>
<span class="line" id="L989"> assert(self.kind == .lib);</span>
<span class="line" id="L990"> <span class="tok-kw">return</span> .{ .generated = &self.output_lib_path_source };</span>
<span class="line" id="L991">}</span>
<span class="line" id="L992"></span>
<span class="line" id="L993"><span class="tok-comment">/// Returns the generated header file.</span></span>
<span class="line" id="L994"><span class="tok-comment">/// This function can only be called for libraries or object files which have `emit_h` set.</span></span>
<span class="line" id="L995"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">getOutputHSource</span>(self: *Compile) FileSource {</span>
<span class="line" id="L996"> assert(self.kind != .exe <span class="tok-kw">and</span> self.kind != .@"test");</span>
<span class="line" id="L997"> assert(self.emit_h);</span>
<span class="line" id="L998"> <span class="tok-kw">return</span> .{ .generated = &self.output_h_path_source };</span>
<span class="line" id="L999">}</span>
<span class="line" id="L1000"></span>
<span class="line" id="L1001"><span class="tok-comment">/// Returns the generated PDB file. This function can only be called for Windows and UEFI.</span></span>
<span class="line" id="L1002"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">getOutputPdbSource</span>(self: *Compile) FileSource {</span>
<span class="line" id="L1003"> <span class="tok-comment">// TODO: Is this right? Isn't PDB for *any* PE/COFF file?</span>
</span>
<span class="line" id="L1004"> assert(self.target.isWindows() <span class="tok-kw">or</span> self.target.isUefi());</span>
<span class="line" id="L1005"> <span class="tok-kw">return</span> .{ .generated = &self.output_pdb_path_source };</span>
<span class="line" id="L1006">}</span>
<span class="line" id="L1007"></span>
<span class="line" id="L1008"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">getOutputDocs</span>(self: *Compile) FileSource {</span>
<span class="line" id="L1009"> assert(self.generated_docs == <span class="tok-null">null</span>); <span class="tok-comment">// This function may only be called once.</span>
</span>
<span class="line" id="L1010"> <span class="tok-kw">const</span> arena = self.step.owner.allocator;</span>
<span class="line" id="L1011"> <span class="tok-kw">const</span> generated_file = arena.create(GeneratedFile) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L1012"> generated_file.* = .{ .step = &self.step };</span>
<span class="line" id="L1013"> self.generated_docs = generated_file;</span>
<span class="line" id="L1014"> <span class="tok-kw">return</span> .{ .generated = generated_file };</span>
<span class="line" id="L1015">}</span>
<span class="line" id="L1016"></span>
<span class="line" id="L1017"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addAssemblyFile</span>(self: *Compile, path: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L1018"> <span class="tok-kw">const</span> b = self.step.owner;</span>
<span class="line" id="L1019"> self.link_objects.append(.{</span>
<span class="line" id="L1020"> .assembly_file = .{ .path = b.dupe(path) },</span>
<span class="line" id="L1021"> }) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L1022">}</span>
<span class="line" id="L1023"></span>
<span class="line" id="L1024"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addAssemblyFileSource</span>(self: *Compile, source: FileSource) <span class="tok-type">void</span> {</span>
<span class="line" id="L1025"> <span class="tok-kw">const</span> b = self.step.owner;</span>
<span class="line" id="L1026"> <span class="tok-kw">const</span> source_duped = source.dupe(b);</span>
<span class="line" id="L1027"> self.link_objects.append(.{ .assembly_file = source_duped }) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L1028"> source_duped.addStepDependencies(&self.step);</span>
<span class="line" id="L1029">}</span>
<span class="line" id="L1030"></span>
<span class="line" id="L1031"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addObjectFile</span>(self: *Compile, source_file: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L1032"> self.addObjectFileSource(.{ .path = source_file });</span>
<span class="line" id="L1033">}</span>
<span class="line" id="L1034"></span>
<span class="line" id="L1035"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addObjectFileSource</span>(self: *Compile, source: FileSource) <span class="tok-type">void</span> {</span>
<span class="line" id="L1036"> <span class="tok-kw">const</span> b = self.step.owner;</span>
<span class="line" id="L1037"> self.link_objects.append(.{ .static_path = source.dupe(b) }) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L1038"> source.addStepDependencies(&self.step);</span>
<span class="line" id="L1039">}</span>
<span class="line" id="L1040"></span>
<span class="line" id="L1041"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addObject</span>(self: *Compile, obj: *Compile) <span class="tok-type">void</span> {</span>
<span class="line" id="L1042"> assert(obj.kind == .obj);</span>
<span class="line" id="L1043"> self.linkLibraryOrObject(obj);</span>
<span class="line" id="L1044">}</span>
<span class="line" id="L1045"></span>
<span class="line" id="L1046"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addSystemIncludePath</span>(self: *Compile, path: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L1047"> <span class="tok-kw">const</span> b = self.step.owner;</span>
<span class="line" id="L1048"> self.include_dirs.append(IncludeDir{ .raw_path_system = b.dupe(path) }) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L1049">}</span>
<span class="line" id="L1050"></span>
<span class="line" id="L1051"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addIncludePath</span>(self: *Compile, path: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L1052"> <span class="tok-kw">const</span> b = self.step.owner;</span>
<span class="line" id="L1053"> self.include_dirs.append(IncludeDir{ .raw_path = b.dupe(path) }) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L1054">}</span>
<span class="line" id="L1055"></span>
<span class="line" id="L1056"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addConfigHeader</span>(self: *Compile, config_header: *Step.ConfigHeader) <span class="tok-type">void</span> {</span>
<span class="line" id="L1057"> self.step.dependOn(&config_header.step);</span>
<span class="line" id="L1058"> self.include_dirs.append(.{ .config_header_step = config_header }) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L1059">}</span>
<span class="line" id="L1060"></span>
<span class="line" id="L1061"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addLibraryPath</span>(self: *Compile, path: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L1062"> <span class="tok-kw">const</span> b = self.step.owner;</span>
<span class="line" id="L1063"> self.lib_paths.append(.{ .path = b.dupe(path) }) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L1064">}</span>
<span class="line" id="L1065"></span>
<span class="line" id="L1066"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addLibraryPathDirectorySource</span>(self: *Compile, directory_source: FileSource) <span class="tok-type">void</span> {</span>
<span class="line" id="L1067"> self.lib_paths.append(directory_source) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L1068"> directory_source.addStepDependencies(&self.step);</span>
<span class="line" id="L1069">}</span>
<span class="line" id="L1070"></span>
<span class="line" id="L1071"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addRPath</span>(self: *Compile, path: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L1072"> <span class="tok-kw">const</span> b = self.step.owner;</span>
<span class="line" id="L1073"> self.rpaths.append(.{ .path = b.dupe(path) }) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L1074">}</span>
<span class="line" id="L1075"></span>
<span class="line" id="L1076"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addRPathDirectorySource</span>(self: *Compile, directory_source: FileSource) <span class="tok-type">void</span> {</span>
<span class="line" id="L1077"> self.rpaths.append(directory_source) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L1078"> directory_source.addStepDependencies(&self.step);</span>
<span class="line" id="L1079">}</span>
<span class="line" id="L1080"></span>
<span class="line" id="L1081"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addFrameworkPath</span>(self: *Compile, dir_path: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L1082"> <span class="tok-kw">const</span> b = self.step.owner;</span>
<span class="line" id="L1083"> self.framework_dirs.append(.{ .path = b.dupe(dir_path) }) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L1084">}</span>
<span class="line" id="L1085"></span>
<span class="line" id="L1086"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addFrameworkPathDirectorySource</span>(self: *Compile, directory_source: FileSource) <span class="tok-type">void</span> {</span>
<span class="line" id="L1087"> self.framework_dirs.append(directory_source) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L1088"> directory_source.addStepDependencies(&self.step);</span>
<span class="line" id="L1089">}</span>
<span class="line" id="L1090"></span>
<span class="line" id="L1091"><span class="tok-comment">/// Adds a module to be used with `@import` and exposing it in the current</span></span>
<span class="line" id="L1092"><span class="tok-comment">/// package's module table using `name`.</span></span>
<span class="line" id="L1093"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addModule</span>(cs: *Compile, name: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>, module: *Module) <span class="tok-type">void</span> {</span>
<span class="line" id="L1094"> <span class="tok-kw">const</span> b = cs.step.owner;</span>
<span class="line" id="L1095"> cs.modules.put(b.dupe(name), module) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L1096"></span>
<span class="line" id="L1097"> <span class="tok-kw">var</span> done = std.AutoHashMap(*Module, <span class="tok-type">void</span>).init(b.allocator);</span>
<span class="line" id="L1098"> <span class="tok-kw">defer</span> done.deinit();</span>
<span class="line" id="L1099"> cs.addRecursiveBuildDeps(module, &done) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L1100">}</span>
<span class="line" id="L1101"></span>
<span class="line" id="L1102"><span class="tok-comment">/// Adds a module to be used with `@import` without exposing it in the current</span></span>
<span class="line" id="L1103"><span class="tok-comment">/// package's module table.</span></span>
<span class="line" id="L1104"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addAnonymousModule</span>(cs: *Compile, name: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>, options: std.Build.CreateModuleOptions) <span class="tok-type">void</span> {</span>
<span class="line" id="L1105"> <span class="tok-kw">const</span> b = cs.step.owner;</span>
<span class="line" id="L1106"> <span class="tok-kw">const</span> module = b.createModule(options);</span>
<span class="line" id="L1107"> <span class="tok-kw">return</span> addModule(cs, name, module);</span>
<span class="line" id="L1108">}</span>
<span class="line" id="L1109"></span>
<span class="line" id="L1110"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addOptions</span>(cs: *Compile, module_name: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>, options: *Step.Options) <span class="tok-type">void</span> {</span>
<span class="line" id="L1111"> addModule(cs, module_name, options.createModule());</span>
<span class="line" id="L1112">}</span>
<span class="line" id="L1113"></span>
<span class="line" id="L1114"><span class="tok-kw">fn</span> <span class="tok-fn">addRecursiveBuildDeps</span>(cs: *Compile, module: *Module, done: *std.AutoHashMap(*Module, <span class="tok-type">void</span>)) !<span class="tok-type">void</span> {</span>
<span class="line" id="L1115"> <span class="tok-kw">if</span> (done.contains(module)) <span class="tok-kw">return</span>;</span>
<span class="line" id="L1116"> <span class="tok-kw">try</span> done.put(module, {});</span>
<span class="line" id="L1117"> module.source_file.addStepDependencies(&cs.step);</span>
<span class="line" id="L1118"> <span class="tok-kw">for</span> (module.dependencies.values()) |dep| {</span>
<span class="line" id="L1119"> <span class="tok-kw">try</span> cs.addRecursiveBuildDeps(dep, done);</span>
<span class="line" id="L1120"> }</span>
<span class="line" id="L1121">}</span>
<span class="line" id="L1122"></span>
<span class="line" id="L1123"><span class="tok-comment">/// If Vcpkg was found on the system, it will be added to include and lib</span></span>
<span class="line" id="L1124"><span class="tok-comment">/// paths for the specified target.</span></span>
<span class="line" id="L1125"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addVcpkgPaths</span>(self: *Compile, linkage: Compile.Linkage) !<span class="tok-type">void</span> {</span>
<span class="line" id="L1126"> <span class="tok-kw">const</span> b = self.step.owner;</span>
<span class="line" id="L1127"> <span class="tok-comment">// Ideally in the Unattempted case we would call the function recursively</span>
</span>
<span class="line" id="L1128"> <span class="tok-comment">// after findVcpkgRoot and have only one switch statement, but the compiler</span>
</span>
<span class="line" id="L1129"> <span class="tok-comment">// cannot resolve the error set.</span>
</span>
<span class="line" id="L1130"> <span class="tok-kw">switch</span> (b.vcpkg_root) {</span>
<span class="line" id="L1131"> .unattempted => {</span>
<span class="line" id="L1132"> b.vcpkg_root = <span class="tok-kw">if</span> (<span class="tok-kw">try</span> findVcpkgRoot(b.allocator)) |root|</span>
<span class="line" id="L1133"> VcpkgRoot{ .found = root }</span>
<span class="line" id="L1134"> <span class="tok-kw">else</span></span>
<span class="line" id="L1135"> .not_found;</span>
<span class="line" id="L1136"> },</span>
<span class="line" id="L1137"> .not_found => <span class="tok-kw">return</span> <span class="tok-kw">error</span>.VcpkgNotFound,</span>
<span class="line" id="L1138"> .found => {},</span>
<span class="line" id="L1139"> }</span>
<span class="line" id="L1140"></span>
<span class="line" id="L1141"> <span class="tok-kw">switch</span> (b.vcpkg_root) {</span>
<span class="line" id="L1142"> .unattempted => <span class="tok-kw">unreachable</span>,</span>
<span class="line" id="L1143"> .not_found => <span class="tok-kw">return</span> <span class="tok-kw">error</span>.VcpkgNotFound,</span>
<span class="line" id="L1144"> .found => |root| {</span>
<span class="line" id="L1145"> <span class="tok-kw">const</span> allocator = b.allocator;</span>
<span class="line" id="L1146"> <span class="tok-kw">const</span> triplet = <span class="tok-kw">try</span> self.target.vcpkgTriplet(allocator, <span class="tok-kw">if</span> (linkage == .static) .Static <span class="tok-kw">else</span> .Dynamic);</span>
<span class="line" id="L1147"> <span class="tok-kw">defer</span> b.allocator.free(triplet);</span>
<span class="line" id="L1148"></span>
<span class="line" id="L1149"> <span class="tok-kw">const</span> include_path = b.pathJoin(&.{ root, <span class="tok-str">"installed"</span>, triplet, <span class="tok-str">"include"</span> });</span>
<span class="line" id="L1150"> <span class="tok-kw">errdefer</span> allocator.free(include_path);</span>
<span class="line" id="L1151"> <span class="tok-kw">try</span> self.include_dirs.append(IncludeDir{ .raw_path = include_path });</span>
<span class="line" id="L1152"></span>
<span class="line" id="L1153"> <span class="tok-kw">const</span> lib_path = b.pathJoin(&.{ root, <span class="tok-str">"installed"</span>, triplet, <span class="tok-str">"lib"</span> });</span>
<span class="line" id="L1154"> <span class="tok-kw">try</span> self.lib_paths.append(.{ .path = lib_path });</span>
<span class="line" id="L1155"></span>
<span class="line" id="L1156"> self.vcpkg_bin_path = b.pathJoin(&.{ root, <span class="tok-str">"installed"</span>, triplet, <span class="tok-str">"bin"</span> });</span>
<span class="line" id="L1157"> },</span>
<span class="line" id="L1158"> }</span>
<span class="line" id="L1159">}</span>
<span class="line" id="L1160"></span>
<span class="line" id="L1161"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">setExecCmd</span>(self: *Compile, args: []<span class="tok-kw">const</span> ?[]<span class="tok-kw">const</span> <span class="tok-type">u8</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L1162"> <span class="tok-kw">const</span> b = self.step.owner;</span>
<span class="line" id="L1163"> assert(self.kind == .@"test");</span>
<span class="line" id="L1164"> <span class="tok-kw">const</span> duped_args = b.allocator.alloc(?[]<span class="tok-type">u8</span>, args.len) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L1165"> <span class="tok-kw">for</span> (args, <span class="tok-number">0</span>..) |arg, i| {</span>
<span class="line" id="L1166"> duped_args[i] = <span class="tok-kw">if</span> (arg) |a| b.dupe(a) <span class="tok-kw">else</span> <span class="tok-null">null</span>;</span>
<span class="line" id="L1167"> }</span>
<span class="line" id="L1168"> self.exec_cmd_args = duped_args;</span>
<span class="line" id="L1169">}</span>
<span class="line" id="L1170"></span>
<span class="line" id="L1171"><span class="tok-kw">fn</span> <span class="tok-fn">linkLibraryOrObject</span>(self: *Compile, other: *Compile) <span class="tok-type">void</span> {</span>
<span class="line" id="L1172"> self.step.dependOn(&other.step);</span>
<span class="line" id="L1173"> self.link_objects.append(.{ .other_step = other }) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L1174"> self.include_dirs.append(.{ .other_step = other }) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L1175"></span>
<span class="line" id="L1176"> <span class="tok-kw">for</span> (other.installed_headers.items) |install_step| {</span>
<span class="line" id="L1177"> self.step.dependOn(install_step);</span>
<span class="line" id="L1178"> }</span>
<span class="line" id="L1179">}</span>
<span class="line" id="L1180"></span>
<span class="line" id="L1181"><span class="tok-kw">fn</span> <span class="tok-fn">appendModuleArgs</span>(</span>
<span class="line" id="L1182"> cs: *Compile,</span>
<span class="line" id="L1183"> zig_args: *ArrayList([]<span class="tok-kw">const</span> <span class="tok-type">u8</span>),</span>
<span class="line" id="L1184">) <span class="tok-kw">error</span>{OutOfMemory}!<span class="tok-type">void</span> {</span>
<span class="line" id="L1185"> <span class="tok-kw">const</span> b = cs.step.owner;</span>
<span class="line" id="L1186"> <span class="tok-comment">// First, traverse the whole dependency graph and give every module a unique name, ideally one</span>
</span>
<span class="line" id="L1187"> <span class="tok-comment">// named after what it's called somewhere in the graph. It will help here to have both a mapping</span>
</span>
<span class="line" id="L1188"> <span class="tok-comment">// from module to name and a set of all the currently-used names.</span>
</span>
<span class="line" id="L1189"> <span class="tok-kw">var</span> mod_names = std.AutoHashMap(*Module, []<span class="tok-kw">const</span> <span class="tok-type">u8</span>).init(b.allocator);</span>
<span class="line" id="L1190"> <span class="tok-kw">var</span> names = std.StringHashMap(<span class="tok-type">void</span>).init(b.allocator);</span>
<span class="line" id="L1191"></span>
<span class="line" id="L1192"> <span class="tok-kw">var</span> to_name = std.ArrayList(<span class="tok-kw">struct</span> {</span>
<span class="line" id="L1193"> name: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L1194"> mod: *Module,</span>
<span class="line" id="L1195"> }).init(b.allocator);</span>
<span class="line" id="L1196"> {</span>
<span class="line" id="L1197"> <span class="tok-kw">var</span> it = cs.modules.iterator();</span>
<span class="line" id="L1198"> <span class="tok-kw">while</span> (it.next()) |kv| {</span>
<span class="line" id="L1199"> <span class="tok-comment">// While we're traversing the root dependencies, let's make sure that no module names</span>
</span>
<span class="line" id="L1200"> <span class="tok-comment">// have colons in them, since the CLI forbids it. We handle this for transitive</span>
</span>
<span class="line" id="L1201"> <span class="tok-comment">// dependencies further down.</span>
</span>
<span class="line" id="L1202"> <span class="tok-kw">if</span> (std.mem.indexOfScalar(<span class="tok-type">u8</span>, kv.key_ptr.*, <span class="tok-str">':'</span>) != <span class="tok-null">null</span>) {</span>
<span class="line" id="L1203"> <span class="tok-builtin">@panic</span>(<span class="tok-str">"Module names cannot contain colons"</span>);</span>
<span class="line" id="L1204"> }</span>
<span class="line" id="L1205"> <span class="tok-kw">try</span> to_name.append(.{</span>
<span class="line" id="L1206"> .name = kv.key_ptr.*,</span>
<span class="line" id="L1207"> .mod = kv.value_ptr.*,</span>
<span class="line" id="L1208"> });</span>
<span class="line" id="L1209"> }</span>
<span class="line" id="L1210"> }</span>
<span class="line" id="L1211"></span>
<span class="line" id="L1212"> <span class="tok-kw">while</span> (to_name.popOrNull()) |dep| {</span>
<span class="line" id="L1213"> <span class="tok-kw">if</span> (mod_names.contains(dep.mod)) <span class="tok-kw">continue</span>;</span>
<span class="line" id="L1214"></span>
<span class="line" id="L1215"> <span class="tok-comment">// We'll use this buffer to store the name we decide on</span>
</span>
<span class="line" id="L1216"> <span class="tok-kw">var</span> buf = <span class="tok-kw">try</span> b.allocator.alloc(<span class="tok-type">u8</span>, dep.name.len + <span class="tok-number">32</span>);</span>
<span class="line" id="L1217"> <span class="tok-comment">// First, try just the exposed dependency name</span>
</span>
<span class="line" id="L1218"> <span class="tok-builtin">@memcpy</span>(buf[<span class="tok-number">0</span>..dep.name.len], dep.name);</span>
<span class="line" id="L1219"> <span class="tok-kw">var</span> name = buf[<span class="tok-number">0</span>..dep.name.len];</span>
<span class="line" id="L1220"> <span class="tok-kw">var</span> n: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L1221"> <span class="tok-kw">while</span> (names.contains(name)) {</span>
<span class="line" id="L1222"> <span class="tok-comment">// If that failed, append an incrementing number to the end</span>
</span>
<span class="line" id="L1223"> name = std.fmt.bufPrint(buf, <span class="tok-str">"{s}{}"</span>, .{ dep.name, n }) <span class="tok-kw">catch</span> <span class="tok-kw">unreachable</span>;</span>
<span class="line" id="L1224"> n += <span class="tok-number">1</span>;</span>
<span class="line" id="L1225"> }</span>
<span class="line" id="L1226"></span>
<span class="line" id="L1227"> <span class="tok-kw">try</span> mod_names.put(dep.mod, name);</span>
<span class="line" id="L1228"> <span class="tok-kw">try</span> names.put(name, {});</span>
<span class="line" id="L1229"></span>
<span class="line" id="L1230"> <span class="tok-kw">var</span> it = dep.mod.dependencies.iterator();</span>
<span class="line" id="L1231"> <span class="tok-kw">while</span> (it.next()) |kv| {</span>
<span class="line" id="L1232"> <span class="tok-comment">// Same colon-in-name check as above, but for transitive dependencies.</span>
</span>
<span class="line" id="L1233"> <span class="tok-kw">if</span> (std.mem.indexOfScalar(<span class="tok-type">u8</span>, kv.key_ptr.*, <span class="tok-str">':'</span>) != <span class="tok-null">null</span>) {</span>
<span class="line" id="L1234"> <span class="tok-builtin">@panic</span>(<span class="tok-str">"Module names cannot contain colons"</span>);</span>
<span class="line" id="L1235"> }</span>
<span class="line" id="L1236"> <span class="tok-kw">try</span> to_name.append(.{</span>
<span class="line" id="L1237"> .name = kv.key_ptr.*,</span>
<span class="line" id="L1238"> .mod = kv.value_ptr.*,</span>
<span class="line" id="L1239"> });</span>
<span class="line" id="L1240"> }</span>
<span class="line" id="L1241"> }</span>
<span class="line" id="L1242"></span>
<span class="line" id="L1243"> <span class="tok-comment">// Since the module names given to the CLI are based off of the exposed names, we already know</span>
</span>
<span class="line" id="L1244"> <span class="tok-comment">// that none of the CLI names have colons in them, so there's no need to check that explicitly.</span>
</span>
<span class="line" id="L1245"></span>
<span class="line" id="L1246"> <span class="tok-comment">// Every module in the graph is now named; output their definitions</span>
</span>
<span class="line" id="L1247"> {</span>
<span class="line" id="L1248"> <span class="tok-kw">var</span> it = mod_names.iterator();</span>
<span class="line" id="L1249"> <span class="tok-kw">while</span> (it.next()) |kv| {</span>
<span class="line" id="L1250"> <span class="tok-kw">const</span> mod = kv.key_ptr.*;</span>
<span class="line" id="L1251"> <span class="tok-kw">const</span> name = kv.value_ptr.*;</span>
<span class="line" id="L1252"></span>
<span class="line" id="L1253"> <span class="tok-kw">const</span> deps_str = <span class="tok-kw">try</span> constructDepString(b.allocator, mod_names, mod.dependencies);</span>
<span class="line" id="L1254"> <span class="tok-kw">const</span> src = mod.builder.pathFromRoot(mod.source_file.getPath(mod.builder));</span>
<span class="line" id="L1255"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"--mod"</span>);</span>
<span class="line" id="L1256"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-kw">try</span> std.fmt.allocPrint(b.allocator, <span class="tok-str">"{s}:{s}:{s}"</span>, .{ name, deps_str, src }));</span>
<span class="line" id="L1257"> }</span>
<span class="line" id="L1258"> }</span>
<span class="line" id="L1259"></span>
<span class="line" id="L1260"> <span class="tok-comment">// Lastly, output the root dependencies</span>
</span>
<span class="line" id="L1261"> <span class="tok-kw">const</span> deps_str = <span class="tok-kw">try</span> constructDepString(b.allocator, mod_names, cs.modules);</span>
<span class="line" id="L1262"> <span class="tok-kw">if</span> (deps_str.len > <span class="tok-number">0</span>) {</span>
<span class="line" id="L1263"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"--deps"</span>);</span>
<span class="line" id="L1264"> <span class="tok-kw">try</span> zig_args.append(deps_str);</span>
<span class="line" id="L1265"> }</span>
<span class="line" id="L1266">}</span>
<span class="line" id="L1267"></span>
<span class="line" id="L1268"><span class="tok-kw">fn</span> <span class="tok-fn">constructDepString</span>(</span>
<span class="line" id="L1269"> allocator: std.mem.Allocator,</span>
<span class="line" id="L1270"> mod_names: std.AutoHashMap(*Module, []<span class="tok-kw">const</span> <span class="tok-type">u8</span>),</span>
<span class="line" id="L1271"> deps: std.StringArrayHashMap(*Module),</span>
<span class="line" id="L1272">) ![]<span class="tok-kw">const</span> <span class="tok-type">u8</span> {</span>
<span class="line" id="L1273"> <span class="tok-kw">var</span> deps_str = std.ArrayList(<span class="tok-type">u8</span>).init(allocator);</span>
<span class="line" id="L1274"> <span class="tok-kw">var</span> it = deps.iterator();</span>
<span class="line" id="L1275"> <span class="tok-kw">while</span> (it.next()) |kv| {</span>
<span class="line" id="L1276"> <span class="tok-kw">const</span> expose = kv.key_ptr.*;</span>
<span class="line" id="L1277"> <span class="tok-kw">const</span> name = mod_names.get(kv.value_ptr.*).?;</span>
<span class="line" id="L1278"> <span class="tok-kw">if</span> (std.mem.eql(<span class="tok-type">u8</span>, expose, name)) {</span>
<span class="line" id="L1279"> <span class="tok-kw">try</span> deps_str.writer().print(<span class="tok-str">"{s},"</span>, .{name});</span>
<span class="line" id="L1280"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L1281"> <span class="tok-kw">try</span> deps_str.writer().print(<span class="tok-str">"{s}={s},"</span>, .{ expose, name });</span>
<span class="line" id="L1282"> }</span>
<span class="line" id="L1283"> }</span>
<span class="line" id="L1284"> <span class="tok-kw">if</span> (deps_str.items.len > <span class="tok-number">0</span>) {</span>
<span class="line" id="L1285"> <span class="tok-kw">return</span> deps_str.items[<span class="tok-number">0</span> .. deps_str.items.len - <span class="tok-number">1</span>]; <span class="tok-comment">// omit trailing comma</span>
</span>
<span class="line" id="L1286"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L1287"> <span class="tok-kw">return</span> <span class="tok-str">""</span>;</span>
<span class="line" id="L1288"> }</span>
<span class="line" id="L1289">}</span>
<span class="line" id="L1290"></span>
<span class="line" id="L1291"><span class="tok-kw">fn</span> <span class="tok-fn">make</span>(step: *Step, prog_node: *std.Progress.Node) !<span class="tok-type">void</span> {</span>
<span class="line" id="L1292"> <span class="tok-kw">const</span> b = step.owner;</span>
<span class="line" id="L1293"> <span class="tok-kw">const</span> self = <span class="tok-builtin">@fieldParentPtr</span>(Compile, <span class="tok-str">"step"</span>, step);</span>
<span class="line" id="L1294"></span>
<span class="line" id="L1295"> <span class="tok-kw">if</span> (self.root_src == <span class="tok-null">null</span> <span class="tok-kw">and</span> self.link_objects.items.len == <span class="tok-number">0</span>) {</span>
<span class="line" id="L1296"> <span class="tok-kw">return</span> step.fail(<span class="tok-str">"the linker needs one or more objects to link"</span>, .{});</span>
<span class="line" id="L1297"> }</span>
<span class="line" id="L1298"></span>
<span class="line" id="L1299"> <span class="tok-kw">var</span> zig_args = ArrayList([]<span class="tok-kw">const</span> <span class="tok-type">u8</span>).init(b.allocator);</span>
<span class="line" id="L1300"> <span class="tok-kw">defer</span> zig_args.deinit();</span>
<span class="line" id="L1301"></span>
<span class="line" id="L1302"> <span class="tok-kw">try</span> zig_args.append(b.zig_exe);</span>
<span class="line" id="L1303"></span>
<span class="line" id="L1304"> <span class="tok-kw">const</span> cmd = <span class="tok-kw">switch</span> (self.kind) {</span>
<span class="line" id="L1305"> .lib => <span class="tok-str">"build-lib"</span>,</span>
<span class="line" id="L1306"> .exe => <span class="tok-str">"build-exe"</span>,</span>
<span class="line" id="L1307"> .obj => <span class="tok-str">"build-obj"</span>,</span>
<span class="line" id="L1308"> .@"test" => <span class="tok-str">"test"</span>,</span>
<span class="line" id="L1309"> };</span>
<span class="line" id="L1310"> <span class="tok-kw">try</span> zig_args.append(cmd);</span>
<span class="line" id="L1311"></span>
<span class="line" id="L1312"> <span class="tok-kw">if</span> (b.reference_trace) |some| {</span>
<span class="line" id="L1313"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-kw">try</span> std.fmt.allocPrint(b.allocator, <span class="tok-str">"-freference-trace={d}"</span>, .{some}));</span>
<span class="line" id="L1314"> }</span>
<span class="line" id="L1315"></span>
<span class="line" id="L1316"> <span class="tok-kw">try</span> addFlag(&zig_args, <span class="tok-str">"LLVM"</span>, self.use_llvm);</span>
<span class="line" id="L1317"> <span class="tok-kw">try</span> addFlag(&zig_args, <span class="tok-str">"LLD"</span>, self.use_lld);</span>
<span class="line" id="L1318"></span>
<span class="line" id="L1319"> <span class="tok-kw">if</span> (self.target.ofmt) |ofmt| {</span>
<span class="line" id="L1320"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-kw">try</span> std.fmt.allocPrint(b.allocator, <span class="tok-str">"-ofmt={s}"</span>, .{<span class="tok-builtin">@tagName</span>(ofmt)}));</span>
<span class="line" id="L1321"> }</span>
<span class="line" id="L1322"></span>
<span class="line" id="L1323"> <span class="tok-kw">if</span> (self.entry_symbol_name) |entry| {</span>
<span class="line" id="L1324"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"--entry"</span>);</span>
<span class="line" id="L1325"> <span class="tok-kw">try</span> zig_args.append(entry);</span>
<span class="line" id="L1326"> }</span>
<span class="line" id="L1327"></span>
<span class="line" id="L1328"> {</span>
<span class="line" id="L1329"> <span class="tok-kw">var</span> it = self.force_undefined_symbols.keyIterator();</span>
<span class="line" id="L1330"> <span class="tok-kw">while</span> (it.next()) |symbol_name| {</span>
<span class="line" id="L1331"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"--force_undefined"</span>);</span>
<span class="line" id="L1332"> <span class="tok-kw">try</span> zig_args.append(symbol_name.*);</span>
<span class="line" id="L1333"> }</span>
<span class="line" id="L1334"> }</span>
<span class="line" id="L1335"></span>
<span class="line" id="L1336"> <span class="tok-kw">if</span> (self.stack_size) |stack_size| {</span>
<span class="line" id="L1337"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"--stack"</span>);</span>
<span class="line" id="L1338"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-kw">try</span> std.fmt.allocPrint(b.allocator, <span class="tok-str">"{}"</span>, .{stack_size}));</span>
<span class="line" id="L1339"> }</span>
<span class="line" id="L1340"></span>
<span class="line" id="L1341"> <span class="tok-kw">if</span> (self.root_src) |root_src| <span class="tok-kw">try</span> zig_args.append(root_src.getPath(b));</span>
<span class="line" id="L1342"></span>
<span class="line" id="L1343"> <span class="tok-comment">// We will add link objects from transitive dependencies, but we want to keep</span>
</span>
<span class="line" id="L1344"> <span class="tok-comment">// all link objects in the same order provided.</span>
</span>
<span class="line" id="L1345"> <span class="tok-comment">// This array is used to keep self.link_objects immutable.</span>
</span>
<span class="line" id="L1346"> <span class="tok-kw">var</span> transitive_deps: TransitiveDeps = .{</span>
<span class="line" id="L1347"> .link_objects = ArrayList(LinkObject).init(b.allocator),</span>
<span class="line" id="L1348"> .seen_system_libs = StringHashMap(<span class="tok-type">void</span>).init(b.allocator),</span>
<span class="line" id="L1349"> .seen_steps = std.AutoHashMap(*<span class="tok-kw">const</span> Step, <span class="tok-type">void</span>).init(b.allocator),</span>
<span class="line" id="L1350"> .is_linking_libcpp = self.is_linking_libcpp,</span>
<span class="line" id="L1351"> .is_linking_libc = self.is_linking_libc,</span>
<span class="line" id="L1352"> .frameworks = &self.frameworks,</span>
<span class="line" id="L1353"> };</span>
<span class="line" id="L1354"></span>
<span class="line" id="L1355"> <span class="tok-kw">try</span> transitive_deps.seen_steps.put(&self.step, {});</span>
<span class="line" id="L1356"> <span class="tok-kw">try</span> transitive_deps.add(self.link_objects.items);</span>
<span class="line" id="L1357"></span>
<span class="line" id="L1358"> <span class="tok-kw">var</span> prev_has_cflags = <span class="tok-null">false</span>;</span>
<span class="line" id="L1359"></span>
<span class="line" id="L1360"> <span class="tok-kw">for</span> (transitive_deps.link_objects.items) |link_object| {</span>
<span class="line" id="L1361"> <span class="tok-kw">switch</span> (link_object) {</span>
<span class="line" id="L1362"> .static_path => |static_path| <span class="tok-kw">try</span> zig_args.append(static_path.getPath(b)),</span>
<span class="line" id="L1363"></span>
<span class="line" id="L1364"> .other_step => |other| <span class="tok-kw">switch</span> (other.kind) {</span>
<span class="line" id="L1365"> .exe => <span class="tok-builtin">@panic</span>(<span class="tok-str">"Cannot link with an executable build artifact"</span>),</span>
<span class="line" id="L1366"> .@"test" => <span class="tok-builtin">@panic</span>(<span class="tok-str">"Cannot link with a test"</span>),</span>
<span class="line" id="L1367"> .obj => {</span>
<span class="line" id="L1368"> <span class="tok-kw">try</span> zig_args.append(other.getOutputSource().getPath(b));</span>
<span class="line" id="L1369"> },</span>
<span class="line" id="L1370"> .lib => l: {</span>
<span class="line" id="L1371"> <span class="tok-kw">if</span> (self.isStaticLibrary() <span class="tok-kw">and</span> other.isStaticLibrary()) {</span>
<span class="line" id="L1372"> <span class="tok-comment">// Avoid putting a static library inside a static library.</span>
</span>
<span class="line" id="L1373"> <span class="tok-kw">break</span> :l;</span>
<span class="line" id="L1374"> }</span>
<span class="line" id="L1375"></span>
<span class="line" id="L1376"> <span class="tok-kw">const</span> full_path_lib = other.getOutputLibSource().getPath(b);</span>
<span class="line" id="L1377"> <span class="tok-kw">try</span> zig_args.append(full_path_lib);</span>
<span class="line" id="L1378"></span>
<span class="line" id="L1379"> <span class="tok-kw">if</span> (other.linkage == Linkage.dynamic <span class="tok-kw">and</span> !self.target.isWindows()) {</span>
<span class="line" id="L1380"> <span class="tok-kw">if</span> (fs.path.dirname(full_path_lib)) |dirname| {</span>
<span class="line" id="L1381"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"-rpath"</span>);</span>
<span class="line" id="L1382"> <span class="tok-kw">try</span> zig_args.append(dirname);</span>
<span class="line" id="L1383"> }</span>
<span class="line" id="L1384"> }</span>
<span class="line" id="L1385"> },</span>
<span class="line" id="L1386"> },</span>
<span class="line" id="L1387"></span>
<span class="line" id="L1388"> .system_lib => |system_lib| {</span>
<span class="line" id="L1389"> <span class="tok-kw">const</span> prefix: []<span class="tok-kw">const</span> <span class="tok-type">u8</span> = prefix: {</span>
<span class="line" id="L1390"> <span class="tok-kw">if</span> (system_lib.needed) <span class="tok-kw">break</span> :prefix <span class="tok-str">"-needed-l"</span>;</span>
<span class="line" id="L1391"> <span class="tok-kw">if</span> (system_lib.weak) <span class="tok-kw">break</span> :prefix <span class="tok-str">"-weak-l"</span>;</span>
<span class="line" id="L1392"> <span class="tok-kw">break</span> :prefix <span class="tok-str">"-l"</span>;</span>
<span class="line" id="L1393"> };</span>
<span class="line" id="L1394"> <span class="tok-kw">switch</span> (system_lib.use_pkg_config) {</span>
<span class="line" id="L1395"> .no => <span class="tok-kw">try</span> zig_args.append(b.fmt(<span class="tok-str">"{s}{s}"</span>, .{ prefix, system_lib.name })),</span>
<span class="line" id="L1396"> .yes, .force => {</span>
<span class="line" id="L1397"> <span class="tok-kw">if</span> (self.runPkgConfig(system_lib.name)) |args| {</span>
<span class="line" id="L1398"> <span class="tok-kw">try</span> zig_args.appendSlice(args);</span>
<span class="line" id="L1399"> } <span class="tok-kw">else</span> |err| <span class="tok-kw">switch</span> (err) {</span>
<span class="line" id="L1400"> <span class="tok-kw">error</span>.PkgConfigInvalidOutput,</span>
<span class="line" id="L1401"> <span class="tok-kw">error</span>.PkgConfigCrashed,</span>
<span class="line" id="L1402"> <span class="tok-kw">error</span>.PkgConfigFailed,</span>
<span class="line" id="L1403"> <span class="tok-kw">error</span>.PkgConfigNotInstalled,</span>
<span class="line" id="L1404"> <span class="tok-kw">error</span>.PackageNotFound,</span>
<span class="line" id="L1405"> => <span class="tok-kw">switch</span> (system_lib.use_pkg_config) {</span>
<span class="line" id="L1406"> .yes => {</span>
<span class="line" id="L1407"> <span class="tok-comment">// pkg-config failed, so fall back to linking the library</span>
</span>
<span class="line" id="L1408"> <span class="tok-comment">// by name directly.</span>
</span>
<span class="line" id="L1409"> <span class="tok-kw">try</span> zig_args.append(b.fmt(<span class="tok-str">"{s}{s}"</span>, .{</span>
<span class="line" id="L1410"> prefix,</span>
<span class="line" id="L1411"> system_lib.name,</span>
<span class="line" id="L1412"> }));</span>
<span class="line" id="L1413"> },</span>
<span class="line" id="L1414"> .force => {</span>
<span class="line" id="L1415"> panic(<span class="tok-str">"pkg-config failed for library {s}"</span>, .{system_lib.name});</span>
<span class="line" id="L1416"> },</span>
<span class="line" id="L1417"> .no => <span class="tok-kw">unreachable</span>,</span>
<span class="line" id="L1418"> },</span>
<span class="line" id="L1419"></span>
<span class="line" id="L1420"> <span class="tok-kw">else</span> => |e| <span class="tok-kw">return</span> e,</span>
<span class="line" id="L1421"> }</span>
<span class="line" id="L1422"> },</span>
<span class="line" id="L1423"> }</span>
<span class="line" id="L1424"> },</span>
<span class="line" id="L1425"></span>
<span class="line" id="L1426"> .assembly_file => |asm_file| {</span>
<span class="line" id="L1427"> <span class="tok-kw">if</span> (prev_has_cflags) {</span>
<span class="line" id="L1428"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"-cflags"</span>);</span>
<span class="line" id="L1429"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"--"</span>);</span>
<span class="line" id="L1430"> prev_has_cflags = <span class="tok-null">false</span>;</span>
<span class="line" id="L1431"> }</span>
<span class="line" id="L1432"> <span class="tok-kw">try</span> zig_args.append(asm_file.getPath(b));</span>
<span class="line" id="L1433"> },</span>
<span class="line" id="L1434"></span>
<span class="line" id="L1435"> .c_source_file => |c_source_file| {</span>
<span class="line" id="L1436"> <span class="tok-kw">if</span> (c_source_file.args.len == <span class="tok-number">0</span>) {</span>
<span class="line" id="L1437"> <span class="tok-kw">if</span> (prev_has_cflags) {</span>
<span class="line" id="L1438"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"-cflags"</span>);</span>
<span class="line" id="L1439"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"--"</span>);</span>
<span class="line" id="L1440"> prev_has_cflags = <span class="tok-null">false</span>;</span>
<span class="line" id="L1441"> }</span>
<span class="line" id="L1442"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L1443"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"-cflags"</span>);</span>
<span class="line" id="L1444"> <span class="tok-kw">for</span> (c_source_file.args) |arg| {</span>
<span class="line" id="L1445"> <span class="tok-kw">try</span> zig_args.append(arg);</span>
<span class="line" id="L1446"> }</span>
<span class="line" id="L1447"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"--"</span>);</span>
<span class="line" id="L1448"> prev_has_cflags = <span class="tok-null">true</span>;</span>
<span class="line" id="L1449"> }</span>
<span class="line" id="L1450"> <span class="tok-kw">try</span> zig_args.append(c_source_file.source.getPath(b));</span>
<span class="line" id="L1451"> },</span>
<span class="line" id="L1452"></span>
<span class="line" id="L1453"> .c_source_files => |c_source_files| {</span>
<span class="line" id="L1454"> <span class="tok-kw">if</span> (c_source_files.flags.len == <span class="tok-number">0</span>) {</span>
<span class="line" id="L1455"> <span class="tok-kw">if</span> (prev_has_cflags) {</span>
<span class="line" id="L1456"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"-cflags"</span>);</span>
<span class="line" id="L1457"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"--"</span>);</span>
<span class="line" id="L1458"> prev_has_cflags = <span class="tok-null">false</span>;</span>
<span class="line" id="L1459"> }</span>
<span class="line" id="L1460"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L1461"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"-cflags"</span>);</span>
<span class="line" id="L1462"> <span class="tok-kw">for</span> (c_source_files.flags) |flag| {</span>
<span class="line" id="L1463"> <span class="tok-kw">try</span> zig_args.append(flag);</span>
<span class="line" id="L1464"> }</span>
<span class="line" id="L1465"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"--"</span>);</span>
<span class="line" id="L1466"> prev_has_cflags = <span class="tok-null">true</span>;</span>
<span class="line" id="L1467"> }</span>
<span class="line" id="L1468"> <span class="tok-kw">for</span> (c_source_files.files) |file| {</span>
<span class="line" id="L1469"> <span class="tok-kw">try</span> zig_args.append(b.pathFromRoot(file));</span>
<span class="line" id="L1470"> }</span>
<span class="line" id="L1471"> },</span>
<span class="line" id="L1472"> }</span>
<span class="line" id="L1473"> }</span>
<span class="line" id="L1474"></span>
<span class="line" id="L1475"> <span class="tok-kw">if</span> (transitive_deps.is_linking_libcpp) {</span>
<span class="line" id="L1476"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"-lc++"</span>);</span>
<span class="line" id="L1477"> }</span>
<span class="line" id="L1478"></span>
<span class="line" id="L1479"> <span class="tok-kw">if</span> (transitive_deps.is_linking_libc) {</span>
<span class="line" id="L1480"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"-lc"</span>);</span>
<span class="line" id="L1481"> }</span>
<span class="line" id="L1482"></span>
<span class="line" id="L1483"> <span class="tok-kw">if</span> (self.image_base) |image_base| {</span>
<span class="line" id="L1484"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"--image-base"</span>);</span>
<span class="line" id="L1485"> <span class="tok-kw">try</span> zig_args.append(b.fmt(<span class="tok-str">"0x{x}"</span>, .{image_base}));</span>
<span class="line" id="L1486"> }</span>
<span class="line" id="L1487"></span>
<span class="line" id="L1488"> <span class="tok-kw">if</span> (self.filter) |filter| {</span>
<span class="line" id="L1489"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"--test-filter"</span>);</span>
<span class="line" id="L1490"> <span class="tok-kw">try</span> zig_args.append(filter);</span>
<span class="line" id="L1491"> }</span>
<span class="line" id="L1492"></span>
<span class="line" id="L1493"> <span class="tok-kw">if</span> (self.test_evented_io) {</span>
<span class="line" id="L1494"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"--test-evented-io"</span>);</span>
<span class="line" id="L1495"> }</span>
<span class="line" id="L1496"></span>
<span class="line" id="L1497"> <span class="tok-kw">if</span> (self.test_runner) |test_runner| {</span>
<span class="line" id="L1498"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"--test-runner"</span>);</span>
<span class="line" id="L1499"> <span class="tok-kw">try</span> zig_args.append(b.pathFromRoot(test_runner));</span>
<span class="line" id="L1500"> }</span>
<span class="line" id="L1501"></span>
<span class="line" id="L1502"> <span class="tok-kw">for</span> (b.debug_log_scopes) |log_scope| {</span>
<span class="line" id="L1503"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"--debug-log"</span>);</span>
<span class="line" id="L1504"> <span class="tok-kw">try</span> zig_args.append(log_scope);</span>
<span class="line" id="L1505"> }</span>
<span class="line" id="L1506"></span>
<span class="line" id="L1507"> <span class="tok-kw">if</span> (b.debug_compile_errors) {</span>
<span class="line" id="L1508"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"--debug-compile-errors"</span>);</span>
<span class="line" id="L1509"> }</span>
<span class="line" id="L1510"></span>
<span class="line" id="L1511"> <span class="tok-kw">if</span> (b.verbose_cimport) <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"--verbose-cimport"</span>);</span>
<span class="line" id="L1512"> <span class="tok-kw">if</span> (b.verbose_air) <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"--verbose-air"</span>);</span>
<span class="line" id="L1513"> <span class="tok-kw">if</span> (b.verbose_llvm_ir) |path| <span class="tok-kw">try</span> zig_args.append(b.fmt(<span class="tok-str">"--verbose-llvm-ir={s}"</span>, .{path}));</span>
<span class="line" id="L1514"> <span class="tok-kw">if</span> (b.verbose_llvm_bc) |path| <span class="tok-kw">try</span> zig_args.append(b.fmt(<span class="tok-str">"--verbose-llvm-bc={s}"</span>, .{path}));</span>
<span class="line" id="L1515"> <span class="tok-kw">if</span> (b.verbose_link <span class="tok-kw">or</span> self.verbose_link) <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"--verbose-link"</span>);</span>
<span class="line" id="L1516"> <span class="tok-kw">if</span> (b.verbose_cc <span class="tok-kw">or</span> self.verbose_cc) <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"--verbose-cc"</span>);</span>
<span class="line" id="L1517"> <span class="tok-kw">if</span> (b.verbose_llvm_cpu_features) <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"--verbose-llvm-cpu-features"</span>);</span>
<span class="line" id="L1518"></span>
<span class="line" id="L1519"> <span class="tok-kw">if</span> (self.emit_analysis.getArg(b, <span class="tok-str">"emit-analysis"</span>)) |arg| <span class="tok-kw">try</span> zig_args.append(arg);</span>
<span class="line" id="L1520"> <span class="tok-kw">if</span> (self.emit_asm.getArg(b, <span class="tok-str">"emit-asm"</span>)) |arg| <span class="tok-kw">try</span> zig_args.append(arg);</span>
<span class="line" id="L1521"> <span class="tok-kw">if</span> (self.emit_bin.getArg(b, <span class="tok-str">"emit-bin"</span>)) |arg| <span class="tok-kw">try</span> zig_args.append(arg);</span>
<span class="line" id="L1522"> <span class="tok-kw">if</span> (self.generated_docs != <span class="tok-null">null</span>) <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"-femit-docs"</span>);</span>
<span class="line" id="L1523"> <span class="tok-kw">if</span> (self.emit_implib.getArg(b, <span class="tok-str">"emit-implib"</span>)) |arg| <span class="tok-kw">try</span> zig_args.append(arg);</span>
<span class="line" id="L1524"> <span class="tok-kw">if</span> (self.emit_llvm_bc.getArg(b, <span class="tok-str">"emit-llvm-bc"</span>)) |arg| <span class="tok-kw">try</span> zig_args.append(arg);</span>
<span class="line" id="L1525"> <span class="tok-kw">if</span> (self.emit_llvm_ir.getArg(b, <span class="tok-str">"emit-llvm-ir"</span>)) |arg| <span class="tok-kw">try</span> zig_args.append(arg);</span>
<span class="line" id="L1526"></span>
<span class="line" id="L1527"> <span class="tok-kw">if</span> (self.emit_h) <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"-femit-h"</span>);</span>
<span class="line" id="L1528"></span>
<span class="line" id="L1529"> <span class="tok-kw">try</span> addFlag(&zig_args, <span class="tok-str">"strip"</span>, self.strip);</span>
<span class="line" id="L1530"> <span class="tok-kw">try</span> addFlag(&zig_args, <span class="tok-str">"unwind-tables"</span>, self.unwind_tables);</span>
<span class="line" id="L1531"></span>
<span class="line" id="L1532"> <span class="tok-kw">if</span> (self.dwarf_format) |dwarf_format| {</span>
<span class="line" id="L1533"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-kw">switch</span> (dwarf_format) {</span>
<span class="line" id="L1534"> .@"32" => <span class="tok-str">"-gdwarf32"</span>,</span>
<span class="line" id="L1535"> .@"64" => <span class="tok-str">"-gdwarf64"</span>,</span>
<span class="line" id="L1536"> });</span>
<span class="line" id="L1537"> }</span>
<span class="line" id="L1538"></span>
<span class="line" id="L1539"> <span class="tok-kw">switch</span> (self.compress_debug_sections) {</span>
<span class="line" id="L1540"> .none => {},</span>
<span class="line" id="L1541"> .zlib => <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"--compress-debug-sections=zlib"</span>),</span>
<span class="line" id="L1542"> }</span>
<span class="line" id="L1543"></span>
<span class="line" id="L1544"> <span class="tok-kw">if</span> (self.link_eh_frame_hdr) {</span>
<span class="line" id="L1545"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"--eh-frame-hdr"</span>);</span>
<span class="line" id="L1546"> }</span>
<span class="line" id="L1547"> <span class="tok-kw">if</span> (self.link_emit_relocs) {</span>
<span class="line" id="L1548"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"--emit-relocs"</span>);</span>
<span class="line" id="L1549"> }</span>
<span class="line" id="L1550"> <span class="tok-kw">if</span> (self.link_function_sections) {</span>
<span class="line" id="L1551"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"-ffunction-sections"</span>);</span>
<span class="line" id="L1552"> }</span>
<span class="line" id="L1553"> <span class="tok-kw">if</span> (self.link_gc_sections) |x| {</span>
<span class="line" id="L1554"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-kw">if</span> (x) <span class="tok-str">"--gc-sections"</span> <span class="tok-kw">else</span> <span class="tok-str">"--no-gc-sections"</span>);</span>
<span class="line" id="L1555"> }</span>
<span class="line" id="L1556"> <span class="tok-kw">if</span> (!self.linker_dynamicbase) {</span>
<span class="line" id="L1557"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"--no-dynamicbase"</span>);</span>
<span class="line" id="L1558"> }</span>
<span class="line" id="L1559"> <span class="tok-kw">if</span> (self.linker_allow_shlib_undefined) |x| {</span>
<span class="line" id="L1560"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-kw">if</span> (x) <span class="tok-str">"-fallow-shlib-undefined"</span> <span class="tok-kw">else</span> <span class="tok-str">"-fno-allow-shlib-undefined"</span>);</span>
<span class="line" id="L1561"> }</span>
<span class="line" id="L1562"> <span class="tok-kw">if</span> (self.link_z_notext) {</span>
<span class="line" id="L1563"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"-z"</span>);</span>
<span class="line" id="L1564"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"notext"</span>);</span>
<span class="line" id="L1565"> }</span>
<span class="line" id="L1566"> <span class="tok-kw">if</span> (!self.link_z_relro) {</span>
<span class="line" id="L1567"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"-z"</span>);</span>
<span class="line" id="L1568"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"norelro"</span>);</span>
<span class="line" id="L1569"> }</span>
<span class="line" id="L1570"> <span class="tok-kw">if</span> (self.link_z_lazy) {</span>
<span class="line" id="L1571"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"-z"</span>);</span>
<span class="line" id="L1572"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"lazy"</span>);</span>
<span class="line" id="L1573"> }</span>
<span class="line" id="L1574"> <span class="tok-kw">if</span> (self.link_z_common_page_size) |size| {</span>
<span class="line" id="L1575"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"-z"</span>);</span>
<span class="line" id="L1576"> <span class="tok-kw">try</span> zig_args.append(b.fmt(<span class="tok-str">"common-page-size={d}"</span>, .{size}));</span>
<span class="line" id="L1577"> }</span>
<span class="line" id="L1578"> <span class="tok-kw">if</span> (self.link_z_max_page_size) |size| {</span>
<span class="line" id="L1579"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"-z"</span>);</span>
<span class="line" id="L1580"> <span class="tok-kw">try</span> zig_args.append(b.fmt(<span class="tok-str">"max-page-size={d}"</span>, .{size}));</span>
<span class="line" id="L1581"> }</span>
<span class="line" id="L1582"></span>
<span class="line" id="L1583"> <span class="tok-kw">if</span> (self.libc_file) |libc_file| {</span>
<span class="line" id="L1584"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"--libc"</span>);</span>
<span class="line" id="L1585"> <span class="tok-kw">try</span> zig_args.append(libc_file.getPath(b));</span>
<span class="line" id="L1586"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (b.libc_file) |libc_file| {</span>
<span class="line" id="L1587"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"--libc"</span>);</span>
<span class="line" id="L1588"> <span class="tok-kw">try</span> zig_args.append(libc_file);</span>
<span class="line" id="L1589"> }</span>
<span class="line" id="L1590"></span>
<span class="line" id="L1591"> <span class="tok-kw">switch</span> (self.optimize) {</span>
<span class="line" id="L1592"> .Debug => {}, <span class="tok-comment">// Skip since it's the default.</span>
</span>
<span class="line" id="L1593"> <span class="tok-kw">else</span> => <span class="tok-kw">try</span> zig_args.append(b.fmt(<span class="tok-str">"-O{s}"</span>, .{<span class="tok-builtin">@tagName</span>(self.optimize)})),</span>
<span class="line" id="L1594"> }</span>
<span class="line" id="L1595"></span>
<span class="line" id="L1596"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"--cache-dir"</span>);</span>
<span class="line" id="L1597"> <span class="tok-kw">try</span> zig_args.append(b.cache_root.path <span class="tok-kw">orelse</span> <span class="tok-str">"."</span>);</span>
<span class="line" id="L1598"></span>
<span class="line" id="L1599"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"--global-cache-dir"</span>);</span>
<span class="line" id="L1600"> <span class="tok-kw">try</span> zig_args.append(b.global_cache_root.path <span class="tok-kw">orelse</span> <span class="tok-str">"."</span>);</span>
<span class="line" id="L1601"></span>
<span class="line" id="L1602"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"--name"</span>);</span>
<span class="line" id="L1603"> <span class="tok-kw">try</span> zig_args.append(self.name);</span>
<span class="line" id="L1604"></span>
<span class="line" id="L1605"> <span class="tok-kw">if</span> (self.linkage) |some| <span class="tok-kw">switch</span> (some) {</span>
<span class="line" id="L1606"> .dynamic => <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"-dynamic"</span>),</span>
<span class="line" id="L1607"> .static => <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"-static"</span>),</span>
<span class="line" id="L1608"> };</span>
<span class="line" id="L1609"> <span class="tok-kw">if</span> (self.kind == .lib <span class="tok-kw">and</span> self.linkage != <span class="tok-null">null</span> <span class="tok-kw">and</span> self.linkage.? == .dynamic) {</span>
<span class="line" id="L1610"> <span class="tok-kw">if</span> (self.version) |version| {</span>
<span class="line" id="L1611"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"--version"</span>);</span>
<span class="line" id="L1612"> <span class="tok-kw">try</span> zig_args.append(b.fmt(<span class="tok-str">"{}"</span>, .{version}));</span>
<span class="line" id="L1613"> }</span>
<span class="line" id="L1614"></span>
<span class="line" id="L1615"> <span class="tok-kw">if</span> (self.target.isDarwin()) {</span>
<span class="line" id="L1616"> <span class="tok-kw">const</span> install_name = self.install_name <span class="tok-kw">orelse</span> b.fmt(<span class="tok-str">"@rpath/{s}{s}{s}"</span>, .{</span>
<span class="line" id="L1617"> self.target.libPrefix(),</span>
<span class="line" id="L1618"> self.name,</span>
<span class="line" id="L1619"> self.target.dynamicLibSuffix(),</span>
<span class="line" id="L1620"> });</span>
<span class="line" id="L1621"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"-install_name"</span>);</span>
<span class="line" id="L1622"> <span class="tok-kw">try</span> zig_args.append(install_name);</span>
<span class="line" id="L1623"> }</span>
<span class="line" id="L1624"> }</span>
<span class="line" id="L1625"></span>
<span class="line" id="L1626"> <span class="tok-kw">if</span> (self.entitlements) |entitlements| {</span>
<span class="line" id="L1627"> <span class="tok-kw">try</span> zig_args.appendSlice(&[_][]<span class="tok-kw">const</span> <span class="tok-type">u8</span>{ <span class="tok-str">"--entitlements"</span>, entitlements });</span>
<span class="line" id="L1628"> }</span>
<span class="line" id="L1629"> <span class="tok-kw">if</span> (self.pagezero_size) |pagezero_size| {</span>
<span class="line" id="L1630"> <span class="tok-kw">const</span> size = <span class="tok-kw">try</span> std.fmt.allocPrint(b.allocator, <span class="tok-str">"{x}"</span>, .{pagezero_size});</span>
<span class="line" id="L1631"> <span class="tok-kw">try</span> zig_args.appendSlice(&[_][]<span class="tok-kw">const</span> <span class="tok-type">u8</span>{ <span class="tok-str">"-pagezero_size"</span>, size });</span>
<span class="line" id="L1632"> }</span>
<span class="line" id="L1633"> <span class="tok-kw">if</span> (self.search_strategy) |strat| <span class="tok-kw">switch</span> (strat) {</span>
<span class="line" id="L1634"> .paths_first => <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"-search_paths_first"</span>),</span>
<span class="line" id="L1635"> .dylibs_first => <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"-search_dylibs_first"</span>),</span>
<span class="line" id="L1636"> };</span>
<span class="line" id="L1637"> <span class="tok-kw">if</span> (self.headerpad_size) |headerpad_size| {</span>
<span class="line" id="L1638"> <span class="tok-kw">const</span> size = <span class="tok-kw">try</span> std.fmt.allocPrint(b.allocator, <span class="tok-str">"{x}"</span>, .{headerpad_size});</span>
<span class="line" id="L1639"> <span class="tok-kw">try</span> zig_args.appendSlice(&[_][]<span class="tok-kw">const</span> <span class="tok-type">u8</span>{ <span class="tok-str">"-headerpad"</span>, size });</span>
<span class="line" id="L1640"> }</span>
<span class="line" id="L1641"> <span class="tok-kw">if</span> (self.headerpad_max_install_names) {</span>
<span class="line" id="L1642"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"-headerpad_max_install_names"</span>);</span>
<span class="line" id="L1643"> }</span>
<span class="line" id="L1644"> <span class="tok-kw">if</span> (self.dead_strip_dylibs) {</span>
<span class="line" id="L1645"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"-dead_strip_dylibs"</span>);</span>
<span class="line" id="L1646"> }</span>
<span class="line" id="L1647"></span>
<span class="line" id="L1648"> <span class="tok-kw">try</span> addFlag(&zig_args, <span class="tok-str">"compiler-rt"</span>, self.bundle_compiler_rt);</span>
<span class="line" id="L1649"> <span class="tok-kw">try</span> addFlag(&zig_args, <span class="tok-str">"single-threaded"</span>, self.single_threaded);</span>
<span class="line" id="L1650"> <span class="tok-kw">if</span> (self.disable_stack_probing) {</span>
<span class="line" id="L1651"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"-fno-stack-check"</span>);</span>
<span class="line" id="L1652"> }</span>
<span class="line" id="L1653"> <span class="tok-kw">try</span> addFlag(&zig_args, <span class="tok-str">"stack-protector"</span>, self.stack_protector);</span>
<span class="line" id="L1654"> <span class="tok-kw">if</span> (self.red_zone) |red_zone| {</span>
<span class="line" id="L1655"> <span class="tok-kw">if</span> (red_zone) {</span>
<span class="line" id="L1656"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"-mred-zone"</span>);</span>
<span class="line" id="L1657"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L1658"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"-mno-red-zone"</span>);</span>
<span class="line" id="L1659"> }</span>
<span class="line" id="L1660"> }</span>
<span class="line" id="L1661"> <span class="tok-kw">try</span> addFlag(&zig_args, <span class="tok-str">"omit-frame-pointer"</span>, self.omit_frame_pointer);</span>
<span class="line" id="L1662"> <span class="tok-kw">try</span> addFlag(&zig_args, <span class="tok-str">"dll-export-fns"</span>, self.dll_export_fns);</span>
<span class="line" id="L1663"></span>
<span class="line" id="L1664"> <span class="tok-kw">if</span> (self.disable_sanitize_c) {</span>
<span class="line" id="L1665"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"-fno-sanitize-c"</span>);</span>
<span class="line" id="L1666"> }</span>
<span class="line" id="L1667"> <span class="tok-kw">if</span> (self.sanitize_thread) {</span>
<span class="line" id="L1668"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"-fsanitize-thread"</span>);</span>
<span class="line" id="L1669"> }</span>
<span class="line" id="L1670"> <span class="tok-kw">if</span> (self.rdynamic) {</span>
<span class="line" id="L1671"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"-rdynamic"</span>);</span>
<span class="line" id="L1672"> }</span>
<span class="line" id="L1673"> <span class="tok-kw">if</span> (self.import_memory) {</span>
<span class="line" id="L1674"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"--import-memory"</span>);</span>
<span class="line" id="L1675"> }</span>
<span class="line" id="L1676"> <span class="tok-kw">if</span> (self.export_memory) {</span>
<span class="line" id="L1677"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"--export-memory"</span>);</span>
<span class="line" id="L1678"> }</span>
<span class="line" id="L1679"> <span class="tok-kw">if</span> (self.import_symbols) {</span>
<span class="line" id="L1680"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"--import-symbols"</span>);</span>
<span class="line" id="L1681"> }</span>
<span class="line" id="L1682"> <span class="tok-kw">if</span> (self.import_table) {</span>
<span class="line" id="L1683"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"--import-table"</span>);</span>
<span class="line" id="L1684"> }</span>
<span class="line" id="L1685"> <span class="tok-kw">if</span> (self.export_table) {</span>
<span class="line" id="L1686"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"--export-table"</span>);</span>
<span class="line" id="L1687"> }</span>
<span class="line" id="L1688"> <span class="tok-kw">if</span> (self.initial_memory) |initial_memory| {</span>
<span class="line" id="L1689"> <span class="tok-kw">try</span> zig_args.append(b.fmt(<span class="tok-str">"--initial-memory={d}"</span>, .{initial_memory}));</span>
<span class="line" id="L1690"> }</span>
<span class="line" id="L1691"> <span class="tok-kw">if</span> (self.max_memory) |max_memory| {</span>
<span class="line" id="L1692"> <span class="tok-kw">try</span> zig_args.append(b.fmt(<span class="tok-str">"--max-memory={d}"</span>, .{max_memory}));</span>
<span class="line" id="L1693"> }</span>
<span class="line" id="L1694"> <span class="tok-kw">if</span> (self.shared_memory) {</span>
<span class="line" id="L1695"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"--shared-memory"</span>);</span>
<span class="line" id="L1696"> }</span>
<span class="line" id="L1697"> <span class="tok-kw">if</span> (self.global_base) |global_base| {</span>
<span class="line" id="L1698"> <span class="tok-kw">try</span> zig_args.append(b.fmt(<span class="tok-str">"--global-base={d}"</span>, .{global_base}));</span>
<span class="line" id="L1699"> }</span>
<span class="line" id="L1700"></span>
<span class="line" id="L1701"> <span class="tok-kw">if</span> (self.code_model != .default) {</span>
<span class="line" id="L1702"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"-mcmodel"</span>);</span>
<span class="line" id="L1703"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-builtin">@tagName</span>(self.code_model));</span>
<span class="line" id="L1704"> }</span>
<span class="line" id="L1705"> <span class="tok-kw">if</span> (self.wasi_exec_model) |model| {</span>
<span class="line" id="L1706"> <span class="tok-kw">try</span> zig_args.append(b.fmt(<span class="tok-str">"-mexec-model={s}"</span>, .{<span class="tok-builtin">@tagName</span>(model)}));</span>
<span class="line" id="L1707"> }</span>
<span class="line" id="L1708"> <span class="tok-kw">for</span> (self.export_symbol_names) |symbol_name| {</span>
<span class="line" id="L1709"> <span class="tok-kw">try</span> zig_args.append(b.fmt(<span class="tok-str">"--export={s}"</span>, .{symbol_name}));</span>
<span class="line" id="L1710"> }</span>
<span class="line" id="L1711"></span>
<span class="line" id="L1712"> <span class="tok-kw">if</span> (!self.target.isNative()) {</span>
<span class="line" id="L1713"> <span class="tok-kw">try</span> zig_args.appendSlice(&.{</span>
<span class="line" id="L1714"> <span class="tok-str">"-target"</span>, <span class="tok-kw">try</span> self.target.zigTriple(b.allocator),</span>
<span class="line" id="L1715"> <span class="tok-str">"-mcpu"</span>, <span class="tok-kw">try</span> std.Build.serializeCpu(b.allocator, self.target.getCpu()),</span>
<span class="line" id="L1716"> });</span>
<span class="line" id="L1717"></span>
<span class="line" id="L1718"> <span class="tok-kw">if</span> (self.target.dynamic_linker.get()) |dynamic_linker| {</span>
<span class="line" id="L1719"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"--dynamic-linker"</span>);</span>
<span class="line" id="L1720"> <span class="tok-kw">try</span> zig_args.append(dynamic_linker);</span>
<span class="line" id="L1721"> }</span>
<span class="line" id="L1722"> }</span>
<span class="line" id="L1723"></span>
<span class="line" id="L1724"> <span class="tok-kw">if</span> (self.linker_script) |linker_script| {</span>
<span class="line" id="L1725"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"--script"</span>);</span>
<span class="line" id="L1726"> <span class="tok-kw">try</span> zig_args.append(linker_script.getPath(b));</span>
<span class="line" id="L1727"> }</span>
<span class="line" id="L1728"></span>
<span class="line" id="L1729"> <span class="tok-kw">if</span> (self.version_script) |version_script| {</span>
<span class="line" id="L1730"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"--version-script"</span>);</span>
<span class="line" id="L1731"> <span class="tok-kw">try</span> zig_args.append(b.pathFromRoot(version_script));</span>
<span class="line" id="L1732"> }</span>
<span class="line" id="L1733"></span>
<span class="line" id="L1734"> <span class="tok-kw">if</span> (self.kind == .@"test") {</span>
<span class="line" id="L1735"> <span class="tok-kw">if</span> (self.exec_cmd_args) |exec_cmd_args| {</span>
<span class="line" id="L1736"> <span class="tok-kw">for</span> (exec_cmd_args) |cmd_arg| {</span>
<span class="line" id="L1737"> <span class="tok-kw">if</span> (cmd_arg) |arg| {</span>
<span class="line" id="L1738"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"--test-cmd"</span>);</span>
<span class="line" id="L1739"> <span class="tok-kw">try</span> zig_args.append(arg);</span>
<span class="line" id="L1740"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L1741"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"--test-cmd-bin"</span>);</span>
<span class="line" id="L1742"> }</span>
<span class="line" id="L1743"> }</span>
<span class="line" id="L1744"> }</span>
<span class="line" id="L1745"> }</span>
<span class="line" id="L1746"></span>
<span class="line" id="L1747"> <span class="tok-kw">try</span> self.appendModuleArgs(&zig_args);</span>
<span class="line" id="L1748"></span>
<span class="line" id="L1749"> <span class="tok-kw">for</span> (self.include_dirs.items) |include_dir| {</span>
<span class="line" id="L1750"> <span class="tok-kw">switch</span> (include_dir) {</span>
<span class="line" id="L1751"> .raw_path => |include_path| {</span>
<span class="line" id="L1752"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"-I"</span>);</span>
<span class="line" id="L1753"> <span class="tok-kw">try</span> zig_args.append(b.pathFromRoot(include_path));</span>
<span class="line" id="L1754"> },</span>
<span class="line" id="L1755"> .raw_path_system => |include_path| {</span>
<span class="line" id="L1756"> <span class="tok-kw">if</span> (b.sysroot != <span class="tok-null">null</span>) {</span>
<span class="line" id="L1757"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"-iwithsysroot"</span>);</span>
<span class="line" id="L1758"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L1759"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"-isystem"</span>);</span>
<span class="line" id="L1760"> }</span>
<span class="line" id="L1761"></span>
<span class="line" id="L1762"> <span class="tok-kw">const</span> resolved_include_path = b.pathFromRoot(include_path);</span>
<span class="line" id="L1763"></span>
<span class="line" id="L1764"> <span class="tok-kw">const</span> common_include_path = <span class="tok-kw">if</span> (builtin.os.tag == .windows <span class="tok-kw">and</span> b.sysroot != <span class="tok-null">null</span> <span class="tok-kw">and</span> fs.path.isAbsolute(resolved_include_path)) blk: {</span>
<span class="line" id="L1765"> <span class="tok-comment">// We need to check for disk designator and strip it out from dir path so</span>
</span>
<span class="line" id="L1766"> <span class="tok-comment">// that zig/clang can concat resolved_include_path with sysroot.</span>
</span>
<span class="line" id="L1767"> <span class="tok-kw">const</span> disk_designator = fs.path.diskDesignatorWindows(resolved_include_path);</span>
<span class="line" id="L1768"></span>
<span class="line" id="L1769"> <span class="tok-kw">if</span> (mem.indexOf(<span class="tok-type">u8</span>, resolved_include_path, disk_designator)) |where| {</span>
<span class="line" id="L1770"> <span class="tok-kw">break</span> :blk resolved_include_path[where + disk_designator.len ..];</span>
<span class="line" id="L1771"> }</span>
<span class="line" id="L1772"></span>
<span class="line" id="L1773"> <span class="tok-kw">break</span> :blk resolved_include_path;</span>
<span class="line" id="L1774"> } <span class="tok-kw">else</span> resolved_include_path;</span>
<span class="line" id="L1775"></span>
<span class="line" id="L1776"> <span class="tok-kw">try</span> zig_args.append(common_include_path);</span>
<span class="line" id="L1777"> },</span>
<span class="line" id="L1778"> .other_step => |other| {</span>
<span class="line" id="L1779"> <span class="tok-kw">if</span> (other.emit_h) {</span>
<span class="line" id="L1780"> <span class="tok-kw">const</span> h_path = other.getOutputHSource().getPath(b);</span>
<span class="line" id="L1781"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"-isystem"</span>);</span>
<span class="line" id="L1782"> <span class="tok-kw">try</span> zig_args.append(fs.path.dirname(h_path).?);</span>
<span class="line" id="L1783"> }</span>
<span class="line" id="L1784"> <span class="tok-kw">if</span> (other.installed_headers.items.len > <span class="tok-number">0</span>) {</span>
<span class="line" id="L1785"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"-I"</span>);</span>
<span class="line" id="L1786"> <span class="tok-kw">try</span> zig_args.append(b.pathJoin(&.{</span>
<span class="line" id="L1787"> other.step.owner.install_prefix, <span class="tok-str">"include"</span>,</span>
<span class="line" id="L1788"> }));</span>
<span class="line" id="L1789"> }</span>
<span class="line" id="L1790"> },</span>
<span class="line" id="L1791"> .config_header_step => |config_header| {</span>
<span class="line" id="L1792"> <span class="tok-kw">const</span> full_file_path = config_header.output_file.path.?;</span>
<span class="line" id="L1793"> <span class="tok-kw">const</span> header_dir_path = full_file_path[<span class="tok-number">0</span> .. full_file_path.len - config_header.include_path.len];</span>
<span class="line" id="L1794"> <span class="tok-kw">try</span> zig_args.appendSlice(&.{ <span class="tok-str">"-I"</span>, header_dir_path });</span>
<span class="line" id="L1795"> },</span>
<span class="line" id="L1796"> }</span>
<span class="line" id="L1797"> }</span>
<span class="line" id="L1798"></span>
<span class="line" id="L1799"> <span class="tok-kw">for</span> (self.c_macros.items) |c_macro| {</span>
<span class="line" id="L1800"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"-D"</span>);</span>
<span class="line" id="L1801"> <span class="tok-kw">try</span> zig_args.append(c_macro);</span>
<span class="line" id="L1802"> }</span>
<span class="line" id="L1803"></span>
<span class="line" id="L1804"> <span class="tok-kw">try</span> zig_args.ensureUnusedCapacity(<span class="tok-number">2</span> * self.lib_paths.items.len);</span>
<span class="line" id="L1805"> <span class="tok-kw">for</span> (self.lib_paths.items) |lib_path| {</span>
<span class="line" id="L1806"> zig_args.appendAssumeCapacity(<span class="tok-str">"-L"</span>);</span>
<span class="line" id="L1807"> zig_args.appendAssumeCapacity(lib_path.getPath2(b, step));</span>
<span class="line" id="L1808"> }</span>
<span class="line" id="L1809"></span>
<span class="line" id="L1810"> <span class="tok-kw">try</span> zig_args.ensureUnusedCapacity(<span class="tok-number">2</span> * self.rpaths.items.len);</span>
<span class="line" id="L1811"> <span class="tok-kw">for</span> (self.rpaths.items) |rpath| {</span>
<span class="line" id="L1812"> zig_args.appendAssumeCapacity(<span class="tok-str">"-rpath"</span>);</span>
<span class="line" id="L1813"></span>
<span class="line" id="L1814"> <span class="tok-kw">if</span> (self.target_info.target.isDarwin()) <span class="tok-kw">switch</span> (rpath) {</span>
<span class="line" id="L1815"> .path => |path| {</span>
<span class="line" id="L1816"> <span class="tok-comment">// On Darwin, we should not try to expand special runtime paths such as</span>
</span>
<span class="line" id="L1817"> <span class="tok-comment">// * @executable_path</span>
</span>
<span class="line" id="L1818"> <span class="tok-comment">// * @loader_path</span>
</span>
<span class="line" id="L1819"> <span class="tok-kw">if</span> (mem.startsWith(<span class="tok-type">u8</span>, path, <span class="tok-str">"@executable_path"</span>) <span class="tok-kw">or</span></span>
<span class="line" id="L1820"> mem.startsWith(<span class="tok-type">u8</span>, path, <span class="tok-str">"@loader_path"</span>))</span>
<span class="line" id="L1821"> {</span>
<span class="line" id="L1822"> zig_args.appendAssumeCapacity(path);</span>
<span class="line" id="L1823"> <span class="tok-kw">continue</span>;</span>
<span class="line" id="L1824"> }</span>
<span class="line" id="L1825"> },</span>
<span class="line" id="L1826"> .generated => {},</span>
<span class="line" id="L1827"> };</span>
<span class="line" id="L1828"></span>
<span class="line" id="L1829"> zig_args.appendAssumeCapacity(rpath.getPath2(b, step));</span>
<span class="line" id="L1830"> }</span>
<span class="line" id="L1831"></span>
<span class="line" id="L1832"> <span class="tok-kw">for</span> (self.framework_dirs.items) |directory_source| {</span>
<span class="line" id="L1833"> <span class="tok-kw">if</span> (b.sysroot != <span class="tok-null">null</span>) {</span>
<span class="line" id="L1834"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"-iframeworkwithsysroot"</span>);</span>
<span class="line" id="L1835"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L1836"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"-iframework"</span>);</span>
<span class="line" id="L1837"> }</span>
<span class="line" id="L1838"> <span class="tok-kw">try</span> zig_args.append(directory_source.getPath2(b, step));</span>
<span class="line" id="L1839"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"-F"</span>);</span>
<span class="line" id="L1840"> <span class="tok-kw">try</span> zig_args.append(directory_source.getPath2(b, step));</span>
<span class="line" id="L1841"> }</span>
<span class="line" id="L1842"></span>
<span class="line" id="L1843"> {</span>
<span class="line" id="L1844"> <span class="tok-kw">var</span> it = self.frameworks.iterator();</span>
<span class="line" id="L1845"> <span class="tok-kw">while</span> (it.next()) |entry| {</span>
<span class="line" id="L1846"> <span class="tok-kw">const</span> name = entry.key_ptr.*;</span>
<span class="line" id="L1847"> <span class="tok-kw">const</span> info = entry.value_ptr.*;</span>
<span class="line" id="L1848"> <span class="tok-kw">if</span> (info.needed) {</span>
<span class="line" id="L1849"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"-needed_framework"</span>);</span>
<span class="line" id="L1850"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (info.weak) {</span>
<span class="line" id="L1851"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"-weak_framework"</span>);</span>
<span class="line" id="L1852"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L1853"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"-framework"</span>);</span>
<span class="line" id="L1854"> }</span>
<span class="line" id="L1855"> <span class="tok-kw">try</span> zig_args.append(name);</span>
<span class="line" id="L1856"> }</span>
<span class="line" id="L1857"> }</span>
<span class="line" id="L1858"></span>
<span class="line" id="L1859"> <span class="tok-kw">if</span> (b.sysroot) |sysroot| {</span>
<span class="line" id="L1860"> <span class="tok-kw">try</span> zig_args.appendSlice(&[_][]<span class="tok-kw">const</span> <span class="tok-type">u8</span>{ <span class="tok-str">"--sysroot"</span>, sysroot });</span>
<span class="line" id="L1861"> }</span>
<span class="line" id="L1862"></span>
<span class="line" id="L1863"> <span class="tok-kw">for</span> (b.search_prefixes.items) |search_prefix| {</span>
<span class="line" id="L1864"> <span class="tok-kw">var</span> prefix_dir = fs.cwd().openDir(search_prefix, .{}) <span class="tok-kw">catch</span> |err| {</span>
<span class="line" id="L1865"> <span class="tok-kw">return</span> step.fail(<span class="tok-str">"unable to open prefix directory '{s}': {s}"</span>, .{</span>
<span class="line" id="L1866"> search_prefix, <span class="tok-builtin">@errorName</span>(err),</span>
<span class="line" id="L1867"> });</span>
<span class="line" id="L1868"> };</span>
<span class="line" id="L1869"> <span class="tok-kw">defer</span> prefix_dir.close();</span>
<span class="line" id="L1870"></span>
<span class="line" id="L1871"> <span class="tok-comment">// Avoid passing -L and -I flags for nonexistent directories.</span>
</span>
<span class="line" id="L1872"> <span class="tok-comment">// This prevents a warning, that should probably be upgraded to an error in Zig's</span>
</span>
<span class="line" id="L1873"> <span class="tok-comment">// CLI parsing code, when the linker sees an -L directory that does not exist.</span>
</span>
<span class="line" id="L1874"></span>
<span class="line" id="L1875"> <span class="tok-kw">if</span> (prefix_dir.accessZ(<span class="tok-str">"lib"</span>, .{})) |_| {</span>
<span class="line" id="L1876"> <span class="tok-kw">try</span> zig_args.appendSlice(&.{</span>
<span class="line" id="L1877"> <span class="tok-str">"-L"</span>, <span class="tok-kw">try</span> fs.path.join(b.allocator, &.{ search_prefix, <span class="tok-str">"lib"</span> }),</span>
<span class="line" id="L1878"> });</span>
<span class="line" id="L1879"> } <span class="tok-kw">else</span> |err| <span class="tok-kw">switch</span> (err) {</span>
<span class="line" id="L1880"> <span class="tok-kw">error</span>.FileNotFound => {},</span>
<span class="line" id="L1881"> <span class="tok-kw">else</span> => |e| <span class="tok-kw">return</span> step.fail(<span class="tok-str">"unable to access '{s}/lib' directory: {s}"</span>, .{</span>
<span class="line" id="L1882"> search_prefix, <span class="tok-builtin">@errorName</span>(e),</span>
<span class="line" id="L1883"> }),</span>
<span class="line" id="L1884"> }</span>
<span class="line" id="L1885"></span>
<span class="line" id="L1886"> <span class="tok-kw">if</span> (prefix_dir.accessZ(<span class="tok-str">"include"</span>, .{})) |_| {</span>
<span class="line" id="L1887"> <span class="tok-kw">try</span> zig_args.appendSlice(&.{</span>
<span class="line" id="L1888"> <span class="tok-str">"-I"</span>, <span class="tok-kw">try</span> fs.path.join(b.allocator, &.{ search_prefix, <span class="tok-str">"include"</span> }),</span>
<span class="line" id="L1889"> });</span>
<span class="line" id="L1890"> } <span class="tok-kw">else</span> |err| <span class="tok-kw">switch</span> (err) {</span>
<span class="line" id="L1891"> <span class="tok-kw">error</span>.FileNotFound => {},</span>
<span class="line" id="L1892"> <span class="tok-kw">else</span> => |e| <span class="tok-kw">return</span> step.fail(<span class="tok-str">"unable to access '{s}/include' directory: {s}"</span>, .{</span>
<span class="line" id="L1893"> search_prefix, <span class="tok-builtin">@errorName</span>(e),</span>
<span class="line" id="L1894"> }),</span>
<span class="line" id="L1895"> }</span>
<span class="line" id="L1896"> }</span>
<span class="line" id="L1897"></span>
<span class="line" id="L1898"> <span class="tok-kw">try</span> addFlag(&zig_args, <span class="tok-str">"valgrind"</span>, self.valgrind_support);</span>
<span class="line" id="L1899"> <span class="tok-kw">try</span> addFlag(&zig_args, <span class="tok-str">"each-lib-rpath"</span>, self.each_lib_rpath);</span>
<span class="line" id="L1900"></span>
<span class="line" id="L1901"> <span class="tok-kw">if</span> (self.build_id) |build_id| {</span>
<span class="line" id="L1902"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-kw">switch</span> (build_id) {</span>
<span class="line" id="L1903"> .hexstring => |hs| b.fmt(<span class="tok-str">"--build-id=0x{s}"</span>, .{</span>
<span class="line" id="L1904"> std.fmt.fmtSliceHexLower(hs.toSlice()),</span>
<span class="line" id="L1905"> }),</span>
<span class="line" id="L1906"> .none, .fast, .uuid, .sha1, .md5 => b.fmt(<span class="tok-str">"--build-id={s}"</span>, .{<span class="tok-builtin">@tagName</span>(build_id)}),</span>
<span class="line" id="L1907"> });</span>
<span class="line" id="L1908"> }</span>
<span class="line" id="L1909"></span>
<span class="line" id="L1910"> <span class="tok-kw">if</span> (self.zig_lib_dir) |dir| {</span>
<span class="line" id="L1911"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"--zig-lib-dir"</span>);</span>
<span class="line" id="L1912"> <span class="tok-kw">try</span> zig_args.append(b.pathFromRoot(dir));</span>
<span class="line" id="L1913"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (b.zig_lib_dir) |dir| {</span>
<span class="line" id="L1914"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"--zig-lib-dir"</span>);</span>
<span class="line" id="L1915"> <span class="tok-kw">try</span> zig_args.append(dir);</span>
<span class="line" id="L1916"> }</span>
<span class="line" id="L1917"></span>
<span class="line" id="L1918"> <span class="tok-kw">if</span> (self.main_pkg_path) |dir| {</span>
<span class="line" id="L1919"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"--main-pkg-path"</span>);</span>
<span class="line" id="L1920"> <span class="tok-kw">try</span> zig_args.append(b.pathFromRoot(dir));</span>
<span class="line" id="L1921"> }</span>
<span class="line" id="L1922"></span>
<span class="line" id="L1923"> <span class="tok-kw">try</span> addFlag(&zig_args, <span class="tok-str">"PIC"</span>, self.force_pic);</span>
<span class="line" id="L1924"> <span class="tok-kw">try</span> addFlag(&zig_args, <span class="tok-str">"PIE"</span>, self.pie);</span>
<span class="line" id="L1925"> <span class="tok-kw">try</span> addFlag(&zig_args, <span class="tok-str">"lto"</span>, self.want_lto);</span>
<span class="line" id="L1926"></span>
<span class="line" id="L1927"> <span class="tok-kw">if</span> (self.subsystem) |subsystem| {</span>
<span class="line" id="L1928"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"--subsystem"</span>);</span>
<span class="line" id="L1929"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-kw">switch</span> (subsystem) {</span>
<span class="line" id="L1930"> .Console => <span class="tok-str">"console"</span>,</span>
<span class="line" id="L1931"> .Windows => <span class="tok-str">"windows"</span>,</span>
<span class="line" id="L1932"> .Posix => <span class="tok-str">"posix"</span>,</span>
<span class="line" id="L1933"> .Native => <span class="tok-str">"native"</span>,</span>
<span class="line" id="L1934"> .EfiApplication => <span class="tok-str">"efi_application"</span>,</span>
<span class="line" id="L1935"> .EfiBootServiceDriver => <span class="tok-str">"efi_boot_service_driver"</span>,</span>
<span class="line" id="L1936"> .EfiRom => <span class="tok-str">"efi_rom"</span>,</span>
<span class="line" id="L1937"> .EfiRuntimeDriver => <span class="tok-str">"efi_runtime_driver"</span>,</span>
<span class="line" id="L1938"> });</span>
<span class="line" id="L1939"> }</span>
<span class="line" id="L1940"></span>
<span class="line" id="L1941"> <span class="tok-kw">try</span> zig_args.append(<span class="tok-str">"--listen=-"</span>);</span>
<span class="line" id="L1942"></span>
<span class="line" id="L1943"> <span class="tok-comment">// Windows has an argument length limit of 32,766 characters, macOS 262,144 and Linux</span>
</span>
<span class="line" id="L1944"> <span class="tok-comment">// 2,097,152. If our args exceed 30 KiB, we instead write them to a "response file" and</span>
</span>
<span class="line" id="L1945"> <span class="tok-comment">// pass that to zig, e.g. via 'zig build-lib @args.rsp'</span>
</span>
<span class="line" id="L1946"> <span class="tok-comment">// See @file syntax here: https://gcc.gnu.org/onlinedocs/gcc/Overall-Options.html</span>
</span>
<span class="line" id="L1947"> <span class="tok-kw">var</span> args_length: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L1948"> <span class="tok-kw">for</span> (zig_args.items) |arg| {</span>
<span class="line" id="L1949"> args_length += arg.len + <span class="tok-number">1</span>; <span class="tok-comment">// +1 to account for null terminator</span>
</span>
<span class="line" id="L1950"> }</span>
<span class="line" id="L1951"> <span class="tok-kw">if</span> (args_length >= <span class="tok-number">30</span> * <span class="tok-number">1024</span>) {</span>
<span class="line" id="L1952"> <span class="tok-kw">try</span> b.cache_root.handle.makePath(<span class="tok-str">"args"</span>);</span>
<span class="line" id="L1953"></span>
<span class="line" id="L1954"> <span class="tok-kw">const</span> args_to_escape = zig_args.items[<span class="tok-number">2</span>..];</span>
<span class="line" id="L1955"> <span class="tok-kw">var</span> escaped_args = <span class="tok-kw">try</span> ArrayList([]<span class="tok-kw">const</span> <span class="tok-type">u8</span>).initCapacity(b.allocator, args_to_escape.len);</span>
<span class="line" id="L1956"> arg_blk: <span class="tok-kw">for</span> (args_to_escape) |arg| {</span>
<span class="line" id="L1957"> <span class="tok-kw">for</span> (arg, <span class="tok-number">0</span>..) |c, arg_idx| {</span>
<span class="line" id="L1958"> <span class="tok-kw">if</span> (c == <span class="tok-str">'\\'</span> <span class="tok-kw">or</span> c == <span class="tok-str">'"'</span>) {</span>
<span class="line" id="L1959"> <span class="tok-comment">// Slow path for arguments that need to be escaped. We'll need to allocate and copy</span>
</span>
<span class="line" id="L1960"> <span class="tok-kw">var</span> escaped = <span class="tok-kw">try</span> ArrayList(<span class="tok-type">u8</span>).initCapacity(b.allocator, arg.len + <span class="tok-number">1</span>);</span>
<span class="line" id="L1961"> <span class="tok-kw">const</span> writer = escaped.writer();</span>
<span class="line" id="L1962"> <span class="tok-kw">try</span> writer.writeAll(arg[<span class="tok-number">0</span>..arg_idx]);</span>
<span class="line" id="L1963"> <span class="tok-kw">for</span> (arg[arg_idx..]) |to_escape| {</span>
<span class="line" id="L1964"> <span class="tok-kw">if</span> (to_escape == <span class="tok-str">'\\'</span> <span class="tok-kw">or</span> to_escape == <span class="tok-str">'"'</span>) <span class="tok-kw">try</span> writer.writeByte(<span class="tok-str">'\\'</span>);</span>
<span class="line" id="L1965"> <span class="tok-kw">try</span> writer.writeByte(to_escape);</span>
<span class="line" id="L1966"> }</span>
<span class="line" id="L1967"> escaped_args.appendAssumeCapacity(escaped.items);</span>
<span class="line" id="L1968"> <span class="tok-kw">continue</span> :arg_blk;</span>
<span class="line" id="L1969"> }</span>
<span class="line" id="L1970"> }</span>
<span class="line" id="L1971"> escaped_args.appendAssumeCapacity(arg); <span class="tok-comment">// no escaping needed so just use original argument</span>
</span>
<span class="line" id="L1972"> }</span>
<span class="line" id="L1973"></span>
<span class="line" id="L1974"> <span class="tok-comment">// Write the args to zig-cache/args/<SHA256 hash of args> to avoid conflicts with</span>
</span>
<span class="line" id="L1975"> <span class="tok-comment">// other zig build commands running in parallel.</span>
</span>
<span class="line" id="L1976"> <span class="tok-kw">const</span> partially_quoted = <span class="tok-kw">try</span> std.mem.join(b.allocator, <span class="tok-str">"\" \""</span>, escaped_args.items);</span>
<span class="line" id="L1977"> <span class="tok-kw">const</span> args = <span class="tok-kw">try</span> std.mem.concat(b.allocator, <span class="tok-type">u8</span>, &[_][]<span class="tok-kw">const</span> <span class="tok-type">u8</span>{ <span class="tok-str">"\""</span>, partially_quoted, <span class="tok-str">"\""</span> });</span>
<span class="line" id="L1978"></span>
<span class="line" id="L1979"> <span class="tok-kw">var</span> args_hash: [Sha256.digest_length]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L1980"> Sha256.hash(args, &args_hash, .{});</span>
<span class="line" id="L1981"> <span class="tok-kw">var</span> args_hex_hash: [Sha256.digest_length * <span class="tok-number">2</span>]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L1982"> _ = <span class="tok-kw">try</span> std.fmt.bufPrint(</span>
<span class="line" id="L1983"> &args_hex_hash,</span>
<span class="line" id="L1984"> <span class="tok-str">"{s}"</span>,</span>
<span class="line" id="L1985"> .{std.fmt.fmtSliceHexLower(&args_hash)},</span>
<span class="line" id="L1986"> );</span>
<span class="line" id="L1987"></span>
<span class="line" id="L1988"> <span class="tok-kw">const</span> args_file = <span class="tok-str">"args"</span> ++ fs.path.sep_str ++ args_hex_hash;</span>
<span class="line" id="L1989"> <span class="tok-kw">try</span> b.cache_root.handle.writeFile(args_file, args);</span>
<span class="line" id="L1990"></span>
<span class="line" id="L1991"> <span class="tok-kw">const</span> resolved_args_file = <span class="tok-kw">try</span> mem.concat(b.allocator, <span class="tok-type">u8</span>, &.{</span>
<span class="line" id="L1992"> <span class="tok-str">"@"</span>,</span>
<span class="line" id="L1993"> <span class="tok-kw">try</span> b.cache_root.join(b.allocator, &.{args_file}),</span>
<span class="line" id="L1994"> });</span>
<span class="line" id="L1995"></span>
<span class="line" id="L1996"> zig_args.shrinkRetainingCapacity(<span class="tok-number">2</span>);</span>
<span class="line" id="L1997"> <span class="tok-kw">try</span> zig_args.append(resolved_args_file);</span>
<span class="line" id="L1998"> }</span>
<span class="line" id="L1999"></span>
<span class="line" id="L2000"> <span class="tok-kw">const</span> output_bin_path = step.evalZigProcess(zig_args.items, prog_node) <span class="tok-kw">catch</span> |err| <span class="tok-kw">switch</span> (err) {</span>
<span class="line" id="L2001"> <span class="tok-kw">error</span>.NeedCompileErrorCheck => {</span>
<span class="line" id="L2002"> assert(self.expect_errors.len != <span class="tok-number">0</span>);</span>
<span class="line" id="L2003"> <span class="tok-kw">try</span> checkCompileErrors(self);</span>
<span class="line" id="L2004"> <span class="tok-kw">return</span>;</span>
<span class="line" id="L2005"> },</span>
<span class="line" id="L2006"> <span class="tok-kw">else</span> => |e| <span class="tok-kw">return</span> e,</span>
<span class="line" id="L2007"> };</span>
<span class="line" id="L2008"> <span class="tok-kw">const</span> output_dir = fs.path.dirname(output_bin_path).?;</span>
<span class="line" id="L2009"></span>
<span class="line" id="L2010"> <span class="tok-comment">// Update generated files</span>
</span>
<span class="line" id="L2011"> {</span>
<span class="line" id="L2012"> self.output_dirname_source.path = output_dir;</span>
<span class="line" id="L2013"></span>
<span class="line" id="L2014"> self.output_path_source.path = b.pathJoin(</span>
<span class="line" id="L2015"> &.{ output_dir, self.out_filename },</span>
<span class="line" id="L2016"> );</span>
<span class="line" id="L2017"></span>
<span class="line" id="L2018"> <span class="tok-kw">if</span> (self.kind == .lib) {</span>
<span class="line" id="L2019"> self.output_lib_path_source.path = b.pathJoin(</span>
<span class="line" id="L2020"> &.{ output_dir, self.out_lib_filename },</span>
<span class="line" id="L2021"> );</span>
<span class="line" id="L2022"> }</span>
<span class="line" id="L2023"></span>
<span class="line" id="L2024"> <span class="tok-kw">if</span> (self.emit_h) {</span>
<span class="line" id="L2025"> self.output_h_path_source.path = b.pathJoin(</span>
<span class="line" id="L2026"> &.{ output_dir, self.out_h_filename },</span>
<span class="line" id="L2027"> );</span>
<span class="line" id="L2028"> }</span>
<span class="line" id="L2029"></span>
<span class="line" id="L2030"> <span class="tok-kw">if</span> (self.target.isWindows() <span class="tok-kw">or</span> self.target.isUefi()) {</span>
<span class="line" id="L2031"> self.output_pdb_path_source.path = b.pathJoin(</span>
<span class="line" id="L2032"> &.{ output_dir, self.out_pdb_filename },</span>
<span class="line" id="L2033"> );</span>
<span class="line" id="L2034"> }</span>
<span class="line" id="L2035"></span>
<span class="line" id="L2036"> <span class="tok-kw">if</span> (self.generated_docs) |generated_docs| {</span>
<span class="line" id="L2037"> generated_docs.path = b.pathJoin(&.{ output_dir, <span class="tok-str">"docs"</span> });</span>
<span class="line" id="L2038"> }</span>
<span class="line" id="L2039"> }</span>
<span class="line" id="L2040"></span>
<span class="line" id="L2041"> <span class="tok-kw">if</span> (self.kind == .lib <span class="tok-kw">and</span> self.linkage != <span class="tok-null">null</span> <span class="tok-kw">and</span> self.linkage.? == .dynamic <span class="tok-kw">and</span></span>
<span class="line" id="L2042"> self.version != <span class="tok-null">null</span> <span class="tok-kw">and</span> self.target.wantSharedLibSymLinks())</span>
<span class="line" id="L2043"> {</span>
<span class="line" id="L2044"> <span class="tok-kw">try</span> doAtomicSymLinks(</span>
<span class="line" id="L2045"> step,</span>
<span class="line" id="L2046"> self.getOutputSource().getPath(b),</span>
<span class="line" id="L2047"> self.major_only_filename.?,</span>
<span class="line" id="L2048"> self.name_only_filename.?,</span>
<span class="line" id="L2049"> );</span>
<span class="line" id="L2050"> }</span>
<span class="line" id="L2051">}</span>
<span class="line" id="L2052"></span>
<span class="line" id="L2053"><span class="tok-kw">fn</span> <span class="tok-fn">isLibCLibrary</span>(name: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) <span class="tok-type">bool</span> {</span>
<span class="line" id="L2054"> <span class="tok-kw">const</span> libc_libraries = [_][]<span class="tok-kw">const</span> <span class="tok-type">u8</span>{ <span class="tok-str">"c"</span>, <span class="tok-str">"m"</span>, <span class="tok-str">"dl"</span>, <span class="tok-str">"rt"</span>, <span class="tok-str">"pthread"</span> };</span>
<span class="line" id="L2055"> <span class="tok-kw">for</span> (libc_libraries) |libc_lib_name| {</span>
<span class="line" id="L2056"> <span class="tok-kw">if</span> (mem.eql(<span class="tok-type">u8</span>, name, libc_lib_name))</span>
<span class="line" id="L2057"> <span class="tok-kw">return</span> <span class="tok-null">true</span>;</span>
<span class="line" id="L2058"> }</span>
<span class="line" id="L2059"> <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L2060">}</span>
<span class="line" id="L2061"></span>
<span class="line" id="L2062"><span class="tok-kw">fn</span> <span class="tok-fn">isLibCppLibrary</span>(name: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) <span class="tok-type">bool</span> {</span>
<span class="line" id="L2063"> <span class="tok-kw">const</span> libcpp_libraries = [_][]<span class="tok-kw">const</span> <span class="tok-type">u8</span>{ <span class="tok-str">"c++"</span>, <span class="tok-str">"stdc++"</span> };</span>
<span class="line" id="L2064"> <span class="tok-kw">for</span> (libcpp_libraries) |libcpp_lib_name| {</span>
<span class="line" id="L2065"> <span class="tok-kw">if</span> (mem.eql(<span class="tok-type">u8</span>, name, libcpp_lib_name))</span>
<span class="line" id="L2066"> <span class="tok-kw">return</span> <span class="tok-null">true</span>;</span>
<span class="line" id="L2067"> }</span>
<span class="line" id="L2068"> <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L2069">}</span>
<span class="line" id="L2070"></span>
<span class="line" id="L2071"><span class="tok-comment">/// Returned slice must be freed by the caller.</span></span>
<span class="line" id="L2072"><span class="tok-kw">fn</span> <span class="tok-fn">findVcpkgRoot</span>(allocator: Allocator) !?[]<span class="tok-kw">const</span> <span class="tok-type">u8</span> {</span>
<span class="line" id="L2073"> <span class="tok-kw">const</span> appdata_path = <span class="tok-kw">try</span> fs.getAppDataDir(allocator, <span class="tok-str">"vcpkg"</span>);</span>
<span class="line" id="L2074"> <span class="tok-kw">defer</span> allocator.free(appdata_path);</span>
<span class="line" id="L2075"></span>
<span class="line" id="L2076"> <span class="tok-kw">const</span> path_file = <span class="tok-kw">try</span> fs.path.join(allocator, &[_][]<span class="tok-kw">const</span> <span class="tok-type">u8</span>{ appdata_path, <span class="tok-str">"vcpkg.path.txt"</span> });</span>
<span class="line" id="L2077"> <span class="tok-kw">defer</span> allocator.free(path_file);</span>
<span class="line" id="L2078"></span>
<span class="line" id="L2079"> <span class="tok-kw">const</span> file = fs.cwd().openFile(path_file, .{}) <span class="tok-kw">catch</span> <span class="tok-kw">return</span> <span class="tok-null">null</span>;</span>
<span class="line" id="L2080"> <span class="tok-kw">defer</span> file.close();</span>
<span class="line" id="L2081"></span>
<span class="line" id="L2082"> <span class="tok-kw">const</span> size = <span class="tok-builtin">@as</span>(<span class="tok-type">usize</span>, <span class="tok-builtin">@intCast</span>(<span class="tok-kw">try</span> file.getEndPos()));</span>
<span class="line" id="L2083"> <span class="tok-kw">const</span> vcpkg_path = <span class="tok-kw">try</span> allocator.alloc(<span class="tok-type">u8</span>, size);</span>
<span class="line" id="L2084"> <span class="tok-kw">const</span> size_read = <span class="tok-kw">try</span> file.read(vcpkg_path);</span>
<span class="line" id="L2085"> std.debug.assert(size == size_read);</span>
<span class="line" id="L2086"></span>
<span class="line" id="L2087"> <span class="tok-kw">return</span> vcpkg_path;</span>
<span class="line" id="L2088">}</span>
<span class="line" id="L2089"></span>
<span class="line" id="L2090"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">doAtomicSymLinks</span>(</span>
<span class="line" id="L2091"> step: *Step,</span>
<span class="line" id="L2092"> output_path: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L2093"> filename_major_only: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L2094"> filename_name_only: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L2095">) !<span class="tok-type">void</span> {</span>
<span class="line" id="L2096"> <span class="tok-kw">const</span> arena = step.owner.allocator;</span>
<span class="line" id="L2097"> <span class="tok-kw">const</span> out_dir = fs.path.dirname(output_path) <span class="tok-kw">orelse</span> <span class="tok-str">"."</span>;</span>
<span class="line" id="L2098"> <span class="tok-kw">const</span> out_basename = fs.path.basename(output_path);</span>
<span class="line" id="L2099"> <span class="tok-comment">// sym link for libfoo.so.1 to libfoo.so.1.2.3</span>
</span>
<span class="line" id="L2100"> <span class="tok-kw">const</span> major_only_path = <span class="tok-kw">try</span> fs.path.join(arena, &.{ out_dir, filename_major_only });</span>
<span class="line" id="L2101"> fs.atomicSymLink(arena, out_basename, major_only_path) <span class="tok-kw">catch</span> |err| {</span>
<span class="line" id="L2102"> <span class="tok-kw">return</span> step.fail(<span class="tok-str">"unable to symlink {s} -> {s}: {s}"</span>, .{</span>
<span class="line" id="L2103"> major_only_path, out_basename, <span class="tok-builtin">@errorName</span>(err),</span>
<span class="line" id="L2104"> });</span>
<span class="line" id="L2105"> };</span>
<span class="line" id="L2106"> <span class="tok-comment">// sym link for libfoo.so to libfoo.so.1</span>
</span>
<span class="line" id="L2107"> <span class="tok-kw">const</span> name_only_path = <span class="tok-kw">try</span> fs.path.join(arena, &.{ out_dir, filename_name_only });</span>
<span class="line" id="L2108"> fs.atomicSymLink(arena, filename_major_only, name_only_path) <span class="tok-kw">catch</span> |err| {</span>
<span class="line" id="L2109"> <span class="tok-kw">return</span> step.fail(<span class="tok-str">"Unable to symlink {s} -> {s}: {s}"</span>, .{</span>
<span class="line" id="L2110"> name_only_path, filename_major_only, <span class="tok-builtin">@errorName</span>(err),</span>
<span class="line" id="L2111"> });</span>
<span class="line" id="L2112"> };</span>
<span class="line" id="L2113">}</span>
<span class="line" id="L2114"></span>
<span class="line" id="L2115"><span class="tok-kw">fn</span> <span class="tok-fn">execPkgConfigList</span>(self: *std.Build, out_code: *<span class="tok-type">u8</span>) (PkgConfigError || ExecError)![]<span class="tok-kw">const</span> PkgConfigPkg {</span>
<span class="line" id="L2116"> <span class="tok-kw">const</span> stdout = <span class="tok-kw">try</span> self.execAllowFail(&[_][]<span class="tok-kw">const</span> <span class="tok-type">u8</span>{ <span class="tok-str">"pkg-config"</span>, <span class="tok-str">"--list-all"</span> }, out_code, .Ignore);</span>
<span class="line" id="L2117"> <span class="tok-kw">var</span> list = ArrayList(PkgConfigPkg).init(self.allocator);</span>
<span class="line" id="L2118"> <span class="tok-kw">errdefer</span> list.deinit();</span>
<span class="line" id="L2119"> <span class="tok-kw">var</span> line_it = mem.tokenizeAny(<span class="tok-type">u8</span>, stdout, <span class="tok-str">"\r\n"</span>);</span>
<span class="line" id="L2120"> <span class="tok-kw">while</span> (line_it.next()) |line| {</span>
<span class="line" id="L2121"> <span class="tok-kw">if</span> (mem.trim(<span class="tok-type">u8</span>, line, <span class="tok-str">" \t"</span>).len == <span class="tok-number">0</span>) <span class="tok-kw">continue</span>;</span>
<span class="line" id="L2122"> <span class="tok-kw">var</span> tok_it = mem.tokenizeAny(<span class="tok-type">u8</span>, line, <span class="tok-str">" \t"</span>);</span>
<span class="line" id="L2123"> <span class="tok-kw">try</span> list.append(PkgConfigPkg{</span>
<span class="line" id="L2124"> .name = tok_it.next() <span class="tok-kw">orelse</span> <span class="tok-kw">return</span> <span class="tok-kw">error</span>.PkgConfigInvalidOutput,</span>
<span class="line" id="L2125"> .desc = tok_it.rest(),</span>
<span class="line" id="L2126"> });</span>
<span class="line" id="L2127"> }</span>
<span class="line" id="L2128"> <span class="tok-kw">return</span> list.toOwnedSlice();</span>
<span class="line" id="L2129">}</span>
<span class="line" id="L2130"></span>
<span class="line" id="L2131"><span class="tok-kw">fn</span> <span class="tok-fn">getPkgConfigList</span>(self: *std.Build) ![]<span class="tok-kw">const</span> PkgConfigPkg {</span>
<span class="line" id="L2132"> <span class="tok-kw">if</span> (self.pkg_config_pkg_list) |res| {</span>
<span class="line" id="L2133"> <span class="tok-kw">return</span> res;</span>
<span class="line" id="L2134"> }</span>
<span class="line" id="L2135"> <span class="tok-kw">var</span> code: <span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L2136"> <span class="tok-kw">if</span> (execPkgConfigList(self, &code)) |list| {</span>
<span class="line" id="L2137"> self.pkg_config_pkg_list = list;</span>
<span class="line" id="L2138"> <span class="tok-kw">return</span> list;</span>
<span class="line" id="L2139"> } <span class="tok-kw">else</span> |err| {</span>
<span class="line" id="L2140"> <span class="tok-kw">const</span> result = <span class="tok-kw">switch</span> (err) {</span>
<span class="line" id="L2141"> <span class="tok-kw">error</span>.ProcessTerminated => <span class="tok-kw">error</span>.PkgConfigCrashed,</span>
<span class="line" id="L2142"> <span class="tok-kw">error</span>.ExecNotSupported => <span class="tok-kw">error</span>.PkgConfigFailed,</span>
<span class="line" id="L2143"> <span class="tok-kw">error</span>.ExitCodeFailure => <span class="tok-kw">error</span>.PkgConfigFailed,</span>
<span class="line" id="L2144"> <span class="tok-kw">error</span>.FileNotFound => <span class="tok-kw">error</span>.PkgConfigNotInstalled,</span>
<span class="line" id="L2145"> <span class="tok-kw">error</span>.InvalidName => <span class="tok-kw">error</span>.PkgConfigNotInstalled,</span>
<span class="line" id="L2146"> <span class="tok-kw">error</span>.PkgConfigInvalidOutput => <span class="tok-kw">error</span>.PkgConfigInvalidOutput,</span>
<span class="line" id="L2147"> <span class="tok-kw">else</span> => <span class="tok-kw">return</span> err,</span>
<span class="line" id="L2148"> };</span>
<span class="line" id="L2149"> self.pkg_config_pkg_list = result;</span>
<span class="line" id="L2150"> <span class="tok-kw">return</span> result;</span>
<span class="line" id="L2151"> }</span>
<span class="line" id="L2152">}</span>
<span class="line" id="L2153"></span>
<span class="line" id="L2154"><span class="tok-kw">fn</span> <span class="tok-fn">addFlag</span>(args: *ArrayList([]<span class="tok-kw">const</span> <span class="tok-type">u8</span>), <span class="tok-kw">comptime</span> name: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>, opt: ?<span class="tok-type">bool</span>) !<span class="tok-type">void</span> {</span>
<span class="line" id="L2155"> <span class="tok-kw">const</span> cond = opt <span class="tok-kw">orelse</span> <span class="tok-kw">return</span>;</span>
<span class="line" id="L2156"> <span class="tok-kw">try</span> args.ensureUnusedCapacity(<span class="tok-number">1</span>);</span>
<span class="line" id="L2157"> <span class="tok-kw">if</span> (cond) {</span>
<span class="line" id="L2158"> args.appendAssumeCapacity(<span class="tok-str">"-f"</span> ++ name);</span>
<span class="line" id="L2159"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L2160"> args.appendAssumeCapacity(<span class="tok-str">"-fno-"</span> ++ name);</span>
<span class="line" id="L2161"> }</span>
<span class="line" id="L2162">}</span>
<span class="line" id="L2163"></span>
<span class="line" id="L2164"><span class="tok-kw">const</span> TransitiveDeps = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L2165"> link_objects: ArrayList(LinkObject),</span>
<span class="line" id="L2166"> seen_system_libs: StringHashMap(<span class="tok-type">void</span>),</span>
<span class="line" id="L2167"> seen_steps: std.AutoHashMap(*<span class="tok-kw">const</span> Step, <span class="tok-type">void</span>),</span>
<span class="line" id="L2168"> is_linking_libcpp: <span class="tok-type">bool</span>,</span>
<span class="line" id="L2169"> is_linking_libc: <span class="tok-type">bool</span>,</span>
<span class="line" id="L2170"> frameworks: *StringHashMap(FrameworkLinkInfo),</span>
<span class="line" id="L2171"></span>
<span class="line" id="L2172"> <span class="tok-kw">fn</span> <span class="tok-fn">add</span>(td: *TransitiveDeps, link_objects: []<span class="tok-kw">const</span> LinkObject) !<span class="tok-type">void</span> {</span>
<span class="line" id="L2173"> <span class="tok-kw">try</span> td.link_objects.ensureUnusedCapacity(link_objects.len);</span>
<span class="line" id="L2174"></span>
<span class="line" id="L2175"> <span class="tok-kw">for</span> (link_objects) |link_object| {</span>
<span class="line" id="L2176"> <span class="tok-kw">try</span> td.link_objects.append(link_object);</span>
<span class="line" id="L2177"> <span class="tok-kw">switch</span> (link_object) {</span>
<span class="line" id="L2178"> .other_step => |other| <span class="tok-kw">try</span> addInner(td, other, other.isDynamicLibrary()),</span>
<span class="line" id="L2179"> <span class="tok-kw">else</span> => {},</span>
<span class="line" id="L2180"> }</span>
<span class="line" id="L2181"> }</span>
<span class="line" id="L2182"> }</span>
<span class="line" id="L2183"></span>
<span class="line" id="L2184"> <span class="tok-kw">fn</span> <span class="tok-fn">addInner</span>(td: *TransitiveDeps, other: *Compile, dyn: <span class="tok-type">bool</span>) !<span class="tok-type">void</span> {</span>
<span class="line" id="L2185"> <span class="tok-comment">// Inherit dependency on libc and libc++</span>
</span>
<span class="line" id="L2186"> td.is_linking_libcpp = td.is_linking_libcpp <span class="tok-kw">or</span> other.is_linking_libcpp;</span>
<span class="line" id="L2187"> td.is_linking_libc = td.is_linking_libc <span class="tok-kw">or</span> other.is_linking_libc;</span>
<span class="line" id="L2188"></span>
<span class="line" id="L2189"> <span class="tok-comment">// Inherit dependencies on darwin frameworks</span>
</span>
<span class="line" id="L2190"> <span class="tok-kw">if</span> (!dyn) {</span>
<span class="line" id="L2191"> <span class="tok-kw">var</span> it = other.frameworks.iterator();</span>
<span class="line" id="L2192"> <span class="tok-kw">while</span> (it.next()) |framework| {</span>
<span class="line" id="L2193"> <span class="tok-kw">try</span> td.frameworks.put(framework.key_ptr.*, framework.value_ptr.*);</span>
<span class="line" id="L2194"> }</span>
<span class="line" id="L2195"> }</span>
<span class="line" id="L2196"></span>
<span class="line" id="L2197"> <span class="tok-comment">// Inherit dependencies on system libraries and static libraries.</span>
</span>
<span class="line" id="L2198"> <span class="tok-kw">for</span> (other.link_objects.items) |other_link_object| {</span>
<span class="line" id="L2199"> <span class="tok-kw">switch</span> (other_link_object) {</span>
<span class="line" id="L2200"> .system_lib => |system_lib| {</span>
<span class="line" id="L2201"> <span class="tok-kw">if</span> ((<span class="tok-kw">try</span> td.seen_system_libs.fetchPut(system_lib.name, {})) != <span class="tok-null">null</span>)</span>
<span class="line" id="L2202"> <span class="tok-kw">continue</span>;</span>
<span class="line" id="L2203"></span>
<span class="line" id="L2204"> <span class="tok-kw">if</span> (dyn)</span>
<span class="line" id="L2205"> <span class="tok-kw">continue</span>;</span>
<span class="line" id="L2206"></span>
<span class="line" id="L2207"> <span class="tok-kw">try</span> td.link_objects.append(other_link_object);</span>
<span class="line" id="L2208"> },</span>
<span class="line" id="L2209"> .other_step => |inner_other| {</span>
<span class="line" id="L2210"> <span class="tok-kw">if</span> ((<span class="tok-kw">try</span> td.seen_steps.fetchPut(&inner_other.step, {})) != <span class="tok-null">null</span>)</span>
<span class="line" id="L2211"> <span class="tok-kw">continue</span>;</span>
<span class="line" id="L2212"></span>
<span class="line" id="L2213"> <span class="tok-kw">const</span> included_in_lib = (other.kind == .lib <span class="tok-kw">and</span> inner_other.kind == .obj);</span>
<span class="line" id="L2214"> <span class="tok-kw">if</span> (!dyn <span class="tok-kw">and</span> !included_in_lib)</span>
<span class="line" id="L2215"> <span class="tok-kw">try</span> td.link_objects.append(other_link_object);</span>
<span class="line" id="L2216"></span>
<span class="line" id="L2217"> <span class="tok-kw">try</span> addInner(td, inner_other, dyn <span class="tok-kw">or</span> inner_other.isDynamicLibrary());</span>
<span class="line" id="L2218"> },</span>
<span class="line" id="L2219"> <span class="tok-kw">else</span> => <span class="tok-kw">continue</span>,</span>
<span class="line" id="L2220"> }</span>
<span class="line" id="L2221"> }</span>
<span class="line" id="L2222"> }</span>
<span class="line" id="L2223">};</span>
<span class="line" id="L2224"></span>
<span class="line" id="L2225"><span class="tok-kw">fn</span> <span class="tok-fn">checkCompileErrors</span>(self: *Compile) !<span class="tok-type">void</span> {</span>
<span class="line" id="L2226"> <span class="tok-comment">// Clear this field so that it does not get printed by the build runner.</span>
</span>
<span class="line" id="L2227"> <span class="tok-kw">const</span> actual_eb = self.step.result_error_bundle;</span>
<span class="line" id="L2228"> self.step.result_error_bundle = std.zig.ErrorBundle.empty;</span>
<span class="line" id="L2229"></span>
<span class="line" id="L2230"> <span class="tok-kw">const</span> arena = self.step.owner.allocator;</span>
<span class="line" id="L2231"></span>
<span class="line" id="L2232"> <span class="tok-kw">var</span> actual_stderr_list = std.ArrayList(<span class="tok-type">u8</span>).init(arena);</span>
<span class="line" id="L2233"> <span class="tok-kw">try</span> actual_eb.renderToWriter(.{</span>
<span class="line" id="L2234"> .ttyconf = .no_color,</span>
<span class="line" id="L2235"> .include_reference_trace = <span class="tok-null">false</span>,</span>
<span class="line" id="L2236"> .include_source_line = <span class="tok-null">false</span>,</span>
<span class="line" id="L2237"> }, actual_stderr_list.writer());</span>
<span class="line" id="L2238"> <span class="tok-kw">const</span> actual_stderr = <span class="tok-kw">try</span> actual_stderr_list.toOwnedSlice();</span>
<span class="line" id="L2239"></span>
<span class="line" id="L2240"> <span class="tok-comment">// Render the expected lines into a string that we can compare verbatim.</span>
</span>
<span class="line" id="L2241"> <span class="tok-kw">var</span> expected_generated = std.ArrayList(<span class="tok-type">u8</span>).init(arena);</span>
<span class="line" id="L2242"></span>
<span class="line" id="L2243"> <span class="tok-kw">var</span> actual_line_it = mem.splitScalar(<span class="tok-type">u8</span>, actual_stderr, <span class="tok-str">'\n'</span>);</span>
<span class="line" id="L2244"> <span class="tok-kw">for</span> (self.expect_errors) |expect_line| {</span>
<span class="line" id="L2245"> <span class="tok-kw">const</span> actual_line = actual_line_it.next() <span class="tok-kw">orelse</span> {</span>
<span class="line" id="L2246"> <span class="tok-kw">try</span> expected_generated.appendSlice(expect_line);</span>
<span class="line" id="L2247"> <span class="tok-kw">try</span> expected_generated.append(<span class="tok-str">'\n'</span>);</span>
<span class="line" id="L2248"> <span class="tok-kw">continue</span>;</span>
<span class="line" id="L2249"> };</span>
<span class="line" id="L2250"> <span class="tok-kw">if</span> (mem.endsWith(<span class="tok-type">u8</span>, actual_line, expect_line)) {</span>
<span class="line" id="L2251"> <span class="tok-kw">try</span> expected_generated.appendSlice(actual_line);</span>
<span class="line" id="L2252"> <span class="tok-kw">try</span> expected_generated.append(<span class="tok-str">'\n'</span>);</span>
<span class="line" id="L2253"> <span class="tok-kw">continue</span>;</span>
<span class="line" id="L2254"> }</span>
<span class="line" id="L2255"> <span class="tok-kw">if</span> (mem.startsWith(<span class="tok-type">u8</span>, expect_line, <span class="tok-str">":?:?: "</span>)) {</span>
<span class="line" id="L2256"> <span class="tok-kw">if</span> (mem.endsWith(<span class="tok-type">u8</span>, actual_line, expect_line[<span class="tok-str">":?:?: "</span>.len..])) {</span>
<span class="line" id="L2257"> <span class="tok-kw">try</span> expected_generated.appendSlice(actual_line);</span>
<span class="line" id="L2258"> <span class="tok-kw">try</span> expected_generated.append(<span class="tok-str">'\n'</span>);</span>
<span class="line" id="L2259"> <span class="tok-kw">continue</span>;</span>
<span class="line" id="L2260"> }</span>
<span class="line" id="L2261"> }</span>
<span class="line" id="L2262"> <span class="tok-kw">try</span> expected_generated.appendSlice(expect_line);</span>
<span class="line" id="L2263"> <span class="tok-kw">try</span> expected_generated.append(<span class="tok-str">'\n'</span>);</span>
<span class="line" id="L2264"> }</span>
<span class="line" id="L2265"></span>
<span class="line" id="L2266"> <span class="tok-kw">if</span> (mem.eql(<span class="tok-type">u8</span>, expected_generated.items, actual_stderr)) <span class="tok-kw">return</span>;</span>
<span class="line" id="L2267"></span>
<span class="line" id="L2268"> <span class="tok-comment">// TODO merge this with the testing.expectEqualStrings logic, and also CheckFile</span>
</span>
<span class="line" id="L2269"> <span class="tok-kw">return</span> self.step.fail(</span>
<span class="line" id="L2270"> <span class="tok-str">\\</span></span>
<span class="line" id="L2271"> <span class="tok-str">\\========= expected: =====================</span></span>
<span class="line" id="L2272"> <span class="tok-str">\\{s}</span></span>
<span class="line" id="L2273"> <span class="tok-str">\\========= but found: ====================</span></span>
<span class="line" id="L2274"> <span class="tok-str">\\{s}</span></span>
<span class="line" id="L2275"> <span class="tok-str">\\=========================================</span></span>
<span class="line" id="L2276"> , .{ expected_generated.items, actual_stderr });</span>
<span class="line" id="L2277">}</span>
<span class="line" id="L2278"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std/Build | repos/yazap/docs/src/std/Build/Step/InstallFile.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>Build/Step/InstallFile.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"std"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> Step = std.Build.Step;</span>
<span class="line" id="L3"><span class="tok-kw">const</span> FileSource = std.Build.FileSource;</span>
<span class="line" id="L4"><span class="tok-kw">const</span> InstallDir = std.Build.InstallDir;</span>
<span class="line" id="L5"><span class="tok-kw">const</span> InstallFile = <span class="tok-builtin">@This</span>();</span>
<span class="line" id="L6"><span class="tok-kw">const</span> assert = std.debug.assert;</span>
<span class="line" id="L7"></span>
<span class="line" id="L8"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> base_id = .install_file;</span>
<span class="line" id="L9"></span>
<span class="line" id="L10">step: Step,</span>
<span class="line" id="L11">source: FileSource,</span>
<span class="line" id="L12">dir: InstallDir,</span>
<span class="line" id="L13">dest_rel_path: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L14"><span class="tok-comment">/// This is used by the build system when a file being installed comes from one</span></span>
<span class="line" id="L15"><span class="tok-comment">/// package but is being installed by another.</span></span>
<span class="line" id="L16">dest_builder: *std.Build,</span>
<span class="line" id="L17"></span>
<span class="line" id="L18"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">create</span>(</span>
<span class="line" id="L19"> owner: *std.Build,</span>
<span class="line" id="L20"> source: FileSource,</span>
<span class="line" id="L21"> dir: InstallDir,</span>
<span class="line" id="L22"> dest_rel_path: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L23">) *InstallFile {</span>
<span class="line" id="L24"> assert(dest_rel_path.len != <span class="tok-number">0</span>);</span>
<span class="line" id="L25"> owner.pushInstalledFile(dir, dest_rel_path);</span>
<span class="line" id="L26"> <span class="tok-kw">const</span> self = owner.allocator.create(InstallFile) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L27"> self.* = .{</span>
<span class="line" id="L28"> .step = Step.init(.{</span>
<span class="line" id="L29"> .id = base_id,</span>
<span class="line" id="L30"> .name = owner.fmt(<span class="tok-str">"install {s} to {s}"</span>, .{ source.getDisplayName(), dest_rel_path }),</span>
<span class="line" id="L31"> .owner = owner,</span>
<span class="line" id="L32"> .makeFn = make,</span>
<span class="line" id="L33"> }),</span>
<span class="line" id="L34"> .source = source.dupe(owner),</span>
<span class="line" id="L35"> .dir = dir.dupe(owner),</span>
<span class="line" id="L36"> .dest_rel_path = owner.dupePath(dest_rel_path),</span>
<span class="line" id="L37"> .dest_builder = owner,</span>
<span class="line" id="L38"> };</span>
<span class="line" id="L39"> source.addStepDependencies(&self.step);</span>
<span class="line" id="L40"> <span class="tok-kw">return</span> self;</span>
<span class="line" id="L41">}</span>
<span class="line" id="L42"></span>
<span class="line" id="L43"><span class="tok-kw">fn</span> <span class="tok-fn">make</span>(step: *Step, prog_node: *std.Progress.Node) !<span class="tok-type">void</span> {</span>
<span class="line" id="L44"> _ = prog_node;</span>
<span class="line" id="L45"> <span class="tok-kw">const</span> src_builder = step.owner;</span>
<span class="line" id="L46"> <span class="tok-kw">const</span> self = <span class="tok-builtin">@fieldParentPtr</span>(InstallFile, <span class="tok-str">"step"</span>, step);</span>
<span class="line" id="L47"> <span class="tok-kw">const</span> dest_builder = self.dest_builder;</span>
<span class="line" id="L48"> <span class="tok-kw">const</span> full_src_path = self.source.getPath2(src_builder, step);</span>
<span class="line" id="L49"> <span class="tok-kw">const</span> full_dest_path = dest_builder.getInstallPath(self.dir, self.dest_rel_path);</span>
<span class="line" id="L50"> <span class="tok-kw">const</span> cwd = std.fs.cwd();</span>
<span class="line" id="L51"> <span class="tok-kw">const</span> prev = std.fs.Dir.updateFile(cwd, full_src_path, cwd, full_dest_path, .{}) <span class="tok-kw">catch</span> |err| {</span>
<span class="line" id="L52"> <span class="tok-kw">return</span> step.fail(<span class="tok-str">"unable to update file from '{s}' to '{s}': {s}"</span>, .{</span>
<span class="line" id="L53"> full_src_path, full_dest_path, <span class="tok-builtin">@errorName</span>(err),</span>
<span class="line" id="L54"> });</span>
<span class="line" id="L55"> };</span>
<span class="line" id="L56"> step.result_cached = prev == .fresh;</span>
<span class="line" id="L57">}</span>
<span class="line" id="L58"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std/Build | repos/yazap/docs/src/std/Build/Step/Run.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>Build/Step/Run.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"std"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> builtin = <span class="tok-builtin">@import</span>(<span class="tok-str">"builtin"</span>);</span>
<span class="line" id="L3"><span class="tok-kw">const</span> Step = std.Build.Step;</span>
<span class="line" id="L4"><span class="tok-kw">const</span> fs = std.fs;</span>
<span class="line" id="L5"><span class="tok-kw">const</span> mem = std.mem;</span>
<span class="line" id="L6"><span class="tok-kw">const</span> process = std.process;</span>
<span class="line" id="L7"><span class="tok-kw">const</span> ArrayList = std.ArrayList;</span>
<span class="line" id="L8"><span class="tok-kw">const</span> EnvMap = process.EnvMap;</span>
<span class="line" id="L9"><span class="tok-kw">const</span> Allocator = mem.Allocator;</span>
<span class="line" id="L10"><span class="tok-kw">const</span> ExecError = std.Build.ExecError;</span>
<span class="line" id="L11"><span class="tok-kw">const</span> assert = std.debug.assert;</span>
<span class="line" id="L12"></span>
<span class="line" id="L13"><span class="tok-kw">const</span> Run = <span class="tok-builtin">@This</span>();</span>
<span class="line" id="L14"></span>
<span class="line" id="L15"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> base_id: Step.Id = .run;</span>
<span class="line" id="L16"></span>
<span class="line" id="L17">step: Step,</span>
<span class="line" id="L18"></span>
<span class="line" id="L19"><span class="tok-comment">/// See also addArg and addArgs to modifying this directly</span></span>
<span class="line" id="L20">argv: ArrayList(Arg),</span>
<span class="line" id="L21"></span>
<span class="line" id="L22"><span class="tok-comment">/// Set this to modify the current working directory</span></span>
<span class="line" id="L23"><span class="tok-comment">/// TODO change this to a Build.Cache.Directory to better integrate with</span></span>
<span class="line" id="L24"><span class="tok-comment">/// future child process cwd API.</span></span>
<span class="line" id="L25">cwd: ?[]<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L26"></span>
<span class="line" id="L27"><span class="tok-comment">/// Override this field to modify the environment, or use setEnvironmentVariable</span></span>
<span class="line" id="L28">env_map: ?*EnvMap,</span>
<span class="line" id="L29"></span>
<span class="line" id="L30"><span class="tok-comment">/// Configures whether the Run step is considered to have side-effects, and also</span></span>
<span class="line" id="L31"><span class="tok-comment">/// whether the Run step will inherit stdio streams, forwarding them to the</span></span>
<span class="line" id="L32"><span class="tok-comment">/// parent process, in which case will require a global lock to prevent other</span></span>
<span class="line" id="L33"><span class="tok-comment">/// steps from interfering with stdio while the subprocess associated with this</span></span>
<span class="line" id="L34"><span class="tok-comment">/// Run step is running.</span></span>
<span class="line" id="L35"><span class="tok-comment">/// If the Run step is determined to not have side-effects, then execution will</span></span>
<span class="line" id="L36"><span class="tok-comment">/// be skipped if all output files are up-to-date and input files are</span></span>
<span class="line" id="L37"><span class="tok-comment">/// unchanged.</span></span>
<span class="line" id="L38">stdio: StdIo = .infer_from_args,</span>
<span class="line" id="L39"></span>
<span class="line" id="L40"><span class="tok-comment">/// This field must be `.none` if stdio is `inherit`.</span></span>
<span class="line" id="L41"><span class="tok-comment">/// It should be only set using `setStdIn`.</span></span>
<span class="line" id="L42">stdin: StdIn = .none,</span>
<span class="line" id="L43"></span>
<span class="line" id="L44"><span class="tok-comment">/// Additional file paths relative to build.zig that, when modified, indicate</span></span>
<span class="line" id="L45"><span class="tok-comment">/// that the Run step should be re-executed.</span></span>
<span class="line" id="L46"><span class="tok-comment">/// If the Run step is determined to have side-effects, this field is ignored</span></span>
<span class="line" id="L47"><span class="tok-comment">/// and the Run step is always executed when it appears in the build graph.</span></span>
<span class="line" id="L48">extra_file_dependencies: []<span class="tok-kw">const</span> []<span class="tok-kw">const</span> <span class="tok-type">u8</span> = &.{},</span>
<span class="line" id="L49"></span>
<span class="line" id="L50"><span class="tok-comment">/// After adding an output argument, this step will by default rename itself</span></span>
<span class="line" id="L51"><span class="tok-comment">/// for a better display name in the build summary.</span></span>
<span class="line" id="L52"><span class="tok-comment">/// This can be disabled by setting this to false.</span></span>
<span class="line" id="L53">rename_step_with_output_arg: <span class="tok-type">bool</span> = <span class="tok-null">true</span>,</span>
<span class="line" id="L54"></span>
<span class="line" id="L55"><span class="tok-comment">/// If this is true, a Run step which is configured to check the output of the</span></span>
<span class="line" id="L56"><span class="tok-comment">/// executed binary will not fail the build if the binary cannot be executed</span></span>
<span class="line" id="L57"><span class="tok-comment">/// due to being for a foreign binary to the host system which is running the</span></span>
<span class="line" id="L58"><span class="tok-comment">/// build graph.</span></span>
<span class="line" id="L59"><span class="tok-comment">/// Command-line arguments such as -fqemu and -fwasmtime may affect whether a</span></span>
<span class="line" id="L60"><span class="tok-comment">/// binary is detected as foreign, as well as system configuration such as</span></span>
<span class="line" id="L61"><span class="tok-comment">/// Rosetta (macOS) and binfmt_misc (Linux).</span></span>
<span class="line" id="L62"><span class="tok-comment">/// If this Run step is considered to have side-effects, then this flag does</span></span>
<span class="line" id="L63"><span class="tok-comment">/// nothing.</span></span>
<span class="line" id="L64">skip_foreign_checks: <span class="tok-type">bool</span> = <span class="tok-null">false</span>,</span>
<span class="line" id="L65"></span>
<span class="line" id="L66"><span class="tok-comment">/// If this is true, failing to execute a foreign binary will be considered an</span></span>
<span class="line" id="L67"><span class="tok-comment">/// error. However if this is false, the step will be skipped on failure instead.</span></span>
<span class="line" id="L68"><span class="tok-comment">///</span></span>
<span class="line" id="L69"><span class="tok-comment">/// This allows for a Run step to attempt to execute a foreign binary using an</span></span>
<span class="line" id="L70"><span class="tok-comment">/// external executor (such as qemu) but not fail if the executor is unavailable.</span></span>
<span class="line" id="L71">failing_to_execute_foreign_is_an_error: <span class="tok-type">bool</span> = <span class="tok-null">true</span>,</span>
<span class="line" id="L72"></span>
<span class="line" id="L73"><span class="tok-comment">/// If stderr or stdout exceeds this amount, the child process is killed and</span></span>
<span class="line" id="L74"><span class="tok-comment">/// the step fails.</span></span>
<span class="line" id="L75">max_stdio_size: <span class="tok-type">usize</span> = <span class="tok-number">10</span> * <span class="tok-number">1024</span> * <span class="tok-number">1024</span>,</span>
<span class="line" id="L76"></span>
<span class="line" id="L77">captured_stdout: ?*Output = <span class="tok-null">null</span>,</span>
<span class="line" id="L78">captured_stderr: ?*Output = <span class="tok-null">null</span>,</span>
<span class="line" id="L79"></span>
<span class="line" id="L80">has_side_effects: <span class="tok-type">bool</span> = <span class="tok-null">false</span>,</span>
<span class="line" id="L81"></span>
<span class="line" id="L82"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> StdIn = <span class="tok-kw">union</span>(<span class="tok-kw">enum</span>) {</span>
<span class="line" id="L83"> none,</span>
<span class="line" id="L84"> bytes: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L85"> file_source: std.Build.FileSource,</span>
<span class="line" id="L86">};</span>
<span class="line" id="L87"></span>
<span class="line" id="L88"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> StdIo = <span class="tok-kw">union</span>(<span class="tok-kw">enum</span>) {</span>
<span class="line" id="L89"> <span class="tok-comment">/// Whether the Run step has side-effects will be determined by whether or not one</span></span>
<span class="line" id="L90"> <span class="tok-comment">/// of the args is an output file (added with `addOutputFileArg`).</span></span>
<span class="line" id="L91"> <span class="tok-comment">/// If the Run step is determined to have side-effects, this is the same as `inherit`.</span></span>
<span class="line" id="L92"> <span class="tok-comment">/// The step will fail if the subprocess crashes or returns a non-zero exit code.</span></span>
<span class="line" id="L93"> infer_from_args,</span>
<span class="line" id="L94"> <span class="tok-comment">/// Causes the Run step to be considered to have side-effects, and therefore</span></span>
<span class="line" id="L95"> <span class="tok-comment">/// always execute when it appears in the build graph.</span></span>
<span class="line" id="L96"> <span class="tok-comment">/// It also means that this step will obtain a global lock to prevent other</span></span>
<span class="line" id="L97"> <span class="tok-comment">/// steps from running in the meantime.</span></span>
<span class="line" id="L98"> <span class="tok-comment">/// The step will fail if the subprocess crashes or returns a non-zero exit code.</span></span>
<span class="line" id="L99"> inherit,</span>
<span class="line" id="L100"> <span class="tok-comment">/// Causes the Run step to be considered to *not* have side-effects. The</span></span>
<span class="line" id="L101"> <span class="tok-comment">/// process will be re-executed if any of the input dependencies are</span></span>
<span class="line" id="L102"> <span class="tok-comment">/// modified. The exit code and standard I/O streams will be checked for</span></span>
<span class="line" id="L103"> <span class="tok-comment">/// certain conditions, and the step will succeed or fail based on these</span></span>
<span class="line" id="L104"> <span class="tok-comment">/// conditions.</span></span>
<span class="line" id="L105"> <span class="tok-comment">/// Note that an explicit check for exit code 0 needs to be added to this</span></span>
<span class="line" id="L106"> <span class="tok-comment">/// list if such a check is desirable.</span></span>
<span class="line" id="L107"> check: std.ArrayList(Check),</span>
<span class="line" id="L108"> <span class="tok-comment">/// This Run step is running a zig unit test binary and will communicate</span></span>
<span class="line" id="L109"> <span class="tok-comment">/// extra metadata over the IPC protocol.</span></span>
<span class="line" id="L110"> zig_test,</span>
<span class="line" id="L111"></span>
<span class="line" id="L112"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> Check = <span class="tok-kw">union</span>(<span class="tok-kw">enum</span>) {</span>
<span class="line" id="L113"> expect_stderr_exact: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L114"> expect_stderr_match: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L115"> expect_stdout_exact: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L116"> expect_stdout_match: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L117"> expect_term: std.process.Child.Term,</span>
<span class="line" id="L118"> };</span>
<span class="line" id="L119">};</span>
<span class="line" id="L120"></span>
<span class="line" id="L121"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> Arg = <span class="tok-kw">union</span>(<span class="tok-kw">enum</span>) {</span>
<span class="line" id="L122"> artifact: *Step.Compile,</span>
<span class="line" id="L123"> file_source: PrefixedFileSource,</span>
<span class="line" id="L124"> directory_source: PrefixedFileSource,</span>
<span class="line" id="L125"> bytes: []<span class="tok-type">u8</span>,</span>
<span class="line" id="L126"> output: *Output,</span>
<span class="line" id="L127">};</span>
<span class="line" id="L128"></span>
<span class="line" id="L129"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> PrefixedFileSource = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L130"> prefix: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L131"> file_source: std.Build.FileSource,</span>
<span class="line" id="L132">};</span>
<span class="line" id="L133"></span>
<span class="line" id="L134"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> Output = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L135"> generated_file: std.Build.GeneratedFile,</span>
<span class="line" id="L136"> prefix: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L137"> basename: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L138">};</span>
<span class="line" id="L139"></span>
<span class="line" id="L140"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">create</span>(owner: *std.Build, name: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) *Run {</span>
<span class="line" id="L141"> <span class="tok-kw">const</span> self = owner.allocator.create(Run) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L142"> self.* = .{</span>
<span class="line" id="L143"> .step = Step.init(.{</span>
<span class="line" id="L144"> .id = base_id,</span>
<span class="line" id="L145"> .name = name,</span>
<span class="line" id="L146"> .owner = owner,</span>
<span class="line" id="L147"> .makeFn = make,</span>
<span class="line" id="L148"> }),</span>
<span class="line" id="L149"> .argv = ArrayList(Arg).init(owner.allocator),</span>
<span class="line" id="L150"> .cwd = <span class="tok-null">null</span>,</span>
<span class="line" id="L151"> .env_map = <span class="tok-null">null</span>,</span>
<span class="line" id="L152"> };</span>
<span class="line" id="L153"> <span class="tok-kw">return</span> self;</span>
<span class="line" id="L154">}</span>
<span class="line" id="L155"></span>
<span class="line" id="L156"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">setName</span>(self: *Run, name: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L157"> self.step.name = name;</span>
<span class="line" id="L158"> self.rename_step_with_output_arg = <span class="tok-null">false</span>;</span>
<span class="line" id="L159">}</span>
<span class="line" id="L160"></span>
<span class="line" id="L161"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">enableTestRunnerMode</span>(self: *Run) <span class="tok-type">void</span> {</span>
<span class="line" id="L162"> self.stdio = .zig_test;</span>
<span class="line" id="L163"> self.addArgs(&.{<span class="tok-str">"--listen=-"</span>});</span>
<span class="line" id="L164">}</span>
<span class="line" id="L165"></span>
<span class="line" id="L166"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addArtifactArg</span>(self: *Run, artifact: *Step.Compile) <span class="tok-type">void</span> {</span>
<span class="line" id="L167"> self.argv.append(Arg{ .artifact = artifact }) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L168"> self.step.dependOn(&artifact.step);</span>
<span class="line" id="L169">}</span>
<span class="line" id="L170"></span>
<span class="line" id="L171"><span class="tok-comment">/// This provides file path as a command line argument to the command being</span></span>
<span class="line" id="L172"><span class="tok-comment">/// run, and returns a FileSource which can be used as inputs to other APIs</span></span>
<span class="line" id="L173"><span class="tok-comment">/// throughout the build system.</span></span>
<span class="line" id="L174"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addOutputFileArg</span>(self: *Run, basename: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) std.Build.FileSource {</span>
<span class="line" id="L175"> <span class="tok-kw">return</span> self.addPrefixedOutputFileArg(<span class="tok-str">""</span>, basename);</span>
<span class="line" id="L176">}</span>
<span class="line" id="L177"></span>
<span class="line" id="L178"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addPrefixedOutputFileArg</span>(</span>
<span class="line" id="L179"> self: *Run,</span>
<span class="line" id="L180"> prefix: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L181"> basename: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L182">) std.Build.FileSource {</span>
<span class="line" id="L183"> <span class="tok-kw">const</span> b = self.step.owner;</span>
<span class="line" id="L184"></span>
<span class="line" id="L185"> <span class="tok-kw">const</span> output = b.allocator.create(Output) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L186"> output.* = .{</span>
<span class="line" id="L187"> .prefix = prefix,</span>
<span class="line" id="L188"> .basename = basename,</span>
<span class="line" id="L189"> .generated_file = .{ .step = &self.step },</span>
<span class="line" id="L190"> };</span>
<span class="line" id="L191"> self.argv.append(.{ .output = output }) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L192"></span>
<span class="line" id="L193"> <span class="tok-kw">if</span> (self.rename_step_with_output_arg) {</span>
<span class="line" id="L194"> self.setName(b.fmt(<span class="tok-str">"{s} ({s})"</span>, .{ self.step.name, basename }));</span>
<span class="line" id="L195"> }</span>
<span class="line" id="L196"></span>
<span class="line" id="L197"> <span class="tok-kw">return</span> .{ .generated = &output.generated_file };</span>
<span class="line" id="L198">}</span>
<span class="line" id="L199"></span>
<span class="line" id="L200"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addFileSourceArg</span>(self: *Run, file_source: std.Build.FileSource) <span class="tok-type">void</span> {</span>
<span class="line" id="L201"> self.addPrefixedFileSourceArg(<span class="tok-str">""</span>, file_source);</span>
<span class="line" id="L202">}</span>
<span class="line" id="L203"></span>
<span class="line" id="L204"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addPrefixedFileSourceArg</span>(self: *Run, prefix: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>, file_source: std.Build.FileSource) <span class="tok-type">void</span> {</span>
<span class="line" id="L205"> <span class="tok-kw">const</span> b = self.step.owner;</span>
<span class="line" id="L206"></span>
<span class="line" id="L207"> <span class="tok-kw">const</span> prefixed_file_source: PrefixedFileSource = .{</span>
<span class="line" id="L208"> .prefix = b.dupe(prefix),</span>
<span class="line" id="L209"> .file_source = file_source.dupe(b),</span>
<span class="line" id="L210"> };</span>
<span class="line" id="L211"> self.argv.append(.{ .file_source = prefixed_file_source }) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L212"> file_source.addStepDependencies(&self.step);</span>
<span class="line" id="L213">}</span>
<span class="line" id="L214"></span>
<span class="line" id="L215"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addDirectorySourceArg</span>(self: *Run, directory_source: std.Build.FileSource) <span class="tok-type">void</span> {</span>
<span class="line" id="L216"> self.addPrefixedDirectorySourceArg(<span class="tok-str">""</span>, directory_source);</span>
<span class="line" id="L217">}</span>
<span class="line" id="L218"></span>
<span class="line" id="L219"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addPrefixedDirectorySourceArg</span>(self: *Run, prefix: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>, directory_source: std.Build.FileSource) <span class="tok-type">void</span> {</span>
<span class="line" id="L220"> <span class="tok-kw">const</span> b = self.step.owner;</span>
<span class="line" id="L221"></span>
<span class="line" id="L222"> <span class="tok-kw">const</span> prefixed_directory_source: PrefixedFileSource = .{</span>
<span class="line" id="L223"> .prefix = b.dupe(prefix),</span>
<span class="line" id="L224"> .file_source = directory_source.dupe(b),</span>
<span class="line" id="L225"> };</span>
<span class="line" id="L226"> self.argv.append(.{ .directory_source = prefixed_directory_source }) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L227"> directory_source.addStepDependencies(&self.step);</span>
<span class="line" id="L228">}</span>
<span class="line" id="L229"></span>
<span class="line" id="L230"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addArg</span>(self: *Run, arg: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L231"> self.argv.append(.{ .bytes = self.step.owner.dupe(arg) }) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L232">}</span>
<span class="line" id="L233"></span>
<span class="line" id="L234"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addArgs</span>(self: *Run, args: []<span class="tok-kw">const</span> []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L235"> <span class="tok-kw">for</span> (args) |arg| {</span>
<span class="line" id="L236"> self.addArg(arg);</span>
<span class="line" id="L237"> }</span>
<span class="line" id="L238">}</span>
<span class="line" id="L239"></span>
<span class="line" id="L240"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">setStdIn</span>(self: *Run, stdin: StdIn) <span class="tok-type">void</span> {</span>
<span class="line" id="L241"> <span class="tok-kw">switch</span> (stdin) {</span>
<span class="line" id="L242"> .file_source => |file_source| file_source.addStepDependencies(&self.step),</span>
<span class="line" id="L243"> .bytes, .none => {},</span>
<span class="line" id="L244"> }</span>
<span class="line" id="L245"> self.stdin = stdin;</span>
<span class="line" id="L246">}</span>
<span class="line" id="L247"></span>
<span class="line" id="L248"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">clearEnvironment</span>(self: *Run) <span class="tok-type">void</span> {</span>
<span class="line" id="L249"> <span class="tok-kw">const</span> b = self.step.owner;</span>
<span class="line" id="L250"> <span class="tok-kw">const</span> new_env_map = b.allocator.create(EnvMap) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L251"> new_env_map.* = EnvMap.init(b.allocator);</span>
<span class="line" id="L252"> self.env_map = new_env_map;</span>
<span class="line" id="L253">}</span>
<span class="line" id="L254"></span>
<span class="line" id="L255"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addPathDir</span>(self: *Run, search_path: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L256"> <span class="tok-kw">const</span> b = self.step.owner;</span>
<span class="line" id="L257"> <span class="tok-kw">const</span> env_map = getEnvMapInternal(self);</span>
<span class="line" id="L258"></span>
<span class="line" id="L259"> <span class="tok-kw">const</span> key = <span class="tok-str">"PATH"</span>;</span>
<span class="line" id="L260"> <span class="tok-kw">var</span> prev_path = env_map.get(key);</span>
<span class="line" id="L261"></span>
<span class="line" id="L262"> <span class="tok-kw">if</span> (prev_path) |pp| {</span>
<span class="line" id="L263"> <span class="tok-kw">const</span> new_path = b.fmt(<span class="tok-str">"{s}"</span> ++ [<span class="tok-number">1</span>]<span class="tok-type">u8</span>{fs.path.delimiter} ++ <span class="tok-str">"{s}"</span>, .{ pp, search_path });</span>
<span class="line" id="L264"> env_map.put(key, new_path) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L265"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L266"> env_map.put(key, b.dupePath(search_path)) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L267"> }</span>
<span class="line" id="L268">}</span>
<span class="line" id="L269"></span>
<span class="line" id="L270"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">getEnvMap</span>(self: *Run) *EnvMap {</span>
<span class="line" id="L271"> <span class="tok-kw">return</span> getEnvMapInternal(self);</span>
<span class="line" id="L272">}</span>
<span class="line" id="L273"></span>
<span class="line" id="L274"><span class="tok-kw">fn</span> <span class="tok-fn">getEnvMapInternal</span>(self: *Run) *EnvMap {</span>
<span class="line" id="L275"> <span class="tok-kw">const</span> arena = self.step.owner.allocator;</span>
<span class="line" id="L276"> <span class="tok-kw">return</span> self.env_map <span class="tok-kw">orelse</span> {</span>
<span class="line" id="L277"> <span class="tok-kw">const</span> env_map = arena.create(EnvMap) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L278"> env_map.* = process.getEnvMap(arena) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"unhandled error"</span>);</span>
<span class="line" id="L279"> self.env_map = env_map;</span>
<span class="line" id="L280"> <span class="tok-kw">return</span> env_map;</span>
<span class="line" id="L281"> };</span>
<span class="line" id="L282">}</span>
<span class="line" id="L283"></span>
<span class="line" id="L284"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">setEnvironmentVariable</span>(self: *Run, key: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>, value: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L285"> <span class="tok-kw">const</span> b = self.step.owner;</span>
<span class="line" id="L286"> <span class="tok-kw">const</span> env_map = self.getEnvMap();</span>
<span class="line" id="L287"> env_map.put(b.dupe(key), b.dupe(value)) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"unhandled error"</span>);</span>
<span class="line" id="L288">}</span>
<span class="line" id="L289"></span>
<span class="line" id="L290"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">removeEnvironmentVariable</span>(self: *Run, key: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L291"> self.getEnvMap().remove(key);</span>
<span class="line" id="L292">}</span>
<span class="line" id="L293"></span>
<span class="line" id="L294"><span class="tok-comment">/// Adds a check for exact stderr match. Does not add any other checks.</span></span>
<span class="line" id="L295"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">expectStdErrEqual</span>(self: *Run, bytes: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L296"> <span class="tok-kw">const</span> new_check: StdIo.Check = .{ .expect_stderr_exact = self.step.owner.dupe(bytes) };</span>
<span class="line" id="L297"> self.addCheck(new_check);</span>
<span class="line" id="L298">}</span>
<span class="line" id="L299"></span>
<span class="line" id="L300"><span class="tok-comment">/// Adds a check for exact stdout match as well as a check for exit code 0, if</span></span>
<span class="line" id="L301"><span class="tok-comment">/// there is not already an expected termination check.</span></span>
<span class="line" id="L302"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">expectStdOutEqual</span>(self: *Run, bytes: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L303"> <span class="tok-kw">const</span> new_check: StdIo.Check = .{ .expect_stdout_exact = self.step.owner.dupe(bytes) };</span>
<span class="line" id="L304"> self.addCheck(new_check);</span>
<span class="line" id="L305"> <span class="tok-kw">if</span> (!self.hasTermCheck()) {</span>
<span class="line" id="L306"> self.expectExitCode(<span class="tok-number">0</span>);</span>
<span class="line" id="L307"> }</span>
<span class="line" id="L308">}</span>
<span class="line" id="L309"></span>
<span class="line" id="L310"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">expectExitCode</span>(self: *Run, code: <span class="tok-type">u8</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L311"> <span class="tok-kw">const</span> new_check: StdIo.Check = .{ .expect_term = .{ .Exited = code } };</span>
<span class="line" id="L312"> self.addCheck(new_check);</span>
<span class="line" id="L313">}</span>
<span class="line" id="L314"></span>
<span class="line" id="L315"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">hasTermCheck</span>(self: Run) <span class="tok-type">bool</span> {</span>
<span class="line" id="L316"> <span class="tok-kw">for</span> (self.stdio.check.items) |check| <span class="tok-kw">switch</span> (check) {</span>
<span class="line" id="L317"> .expect_term => <span class="tok-kw">return</span> <span class="tok-null">true</span>,</span>
<span class="line" id="L318"> <span class="tok-kw">else</span> => <span class="tok-kw">continue</span>,</span>
<span class="line" id="L319"> };</span>
<span class="line" id="L320"> <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L321">}</span>
<span class="line" id="L322"></span>
<span class="line" id="L323"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addCheck</span>(self: *Run, new_check: StdIo.Check) <span class="tok-type">void</span> {</span>
<span class="line" id="L324"> <span class="tok-kw">switch</span> (self.stdio) {</span>
<span class="line" id="L325"> .infer_from_args => {</span>
<span class="line" id="L326"> self.stdio = .{ .check = std.ArrayList(StdIo.Check).init(self.step.owner.allocator) };</span>
<span class="line" id="L327"> self.stdio.check.append(new_check) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L328"> },</span>
<span class="line" id="L329"> .check => |*checks| checks.append(new_check) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>),</span>
<span class="line" id="L330"> <span class="tok-kw">else</span> => <span class="tok-builtin">@panic</span>(<span class="tok-str">"illegal call to addCheck: conflicting helper method calls. Suggest to directly set stdio field of Run instead"</span>),</span>
<span class="line" id="L331"> }</span>
<span class="line" id="L332">}</span>
<span class="line" id="L333"></span>
<span class="line" id="L334"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">captureStdErr</span>(self: *Run) std.Build.FileSource {</span>
<span class="line" id="L335"> assert(self.stdio != .inherit);</span>
<span class="line" id="L336"></span>
<span class="line" id="L337"> <span class="tok-kw">if</span> (self.captured_stderr) |output| <span class="tok-kw">return</span> .{ .generated = &output.generated_file };</span>
<span class="line" id="L338"></span>
<span class="line" id="L339"> <span class="tok-kw">const</span> output = self.step.owner.allocator.create(Output) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L340"> output.* = .{</span>
<span class="line" id="L341"> .prefix = <span class="tok-str">""</span>,</span>
<span class="line" id="L342"> .basename = <span class="tok-str">"stderr"</span>,</span>
<span class="line" id="L343"> .generated_file = .{ .step = &self.step },</span>
<span class="line" id="L344"> };</span>
<span class="line" id="L345"> self.captured_stderr = output;</span>
<span class="line" id="L346"> <span class="tok-kw">return</span> .{ .generated = &output.generated_file };</span>
<span class="line" id="L347">}</span>
<span class="line" id="L348"></span>
<span class="line" id="L349"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">captureStdOut</span>(self: *Run) std.Build.FileSource {</span>
<span class="line" id="L350"> assert(self.stdio != .inherit);</span>
<span class="line" id="L351"></span>
<span class="line" id="L352"> <span class="tok-kw">if</span> (self.captured_stdout) |output| <span class="tok-kw">return</span> .{ .generated = &output.generated_file };</span>
<span class="line" id="L353"></span>
<span class="line" id="L354"> <span class="tok-kw">const</span> output = self.step.owner.allocator.create(Output) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L355"> output.* = .{</span>
<span class="line" id="L356"> .prefix = <span class="tok-str">""</span>,</span>
<span class="line" id="L357"> .basename = <span class="tok-str">"stdout"</span>,</span>
<span class="line" id="L358"> .generated_file = .{ .step = &self.step },</span>
<span class="line" id="L359"> };</span>
<span class="line" id="L360"> self.captured_stdout = output;</span>
<span class="line" id="L361"> <span class="tok-kw">return</span> .{ .generated = &output.generated_file };</span>
<span class="line" id="L362">}</span>
<span class="line" id="L363"></span>
<span class="line" id="L364"><span class="tok-comment">/// Returns whether the Run step has side effects *other than* updating the output arguments.</span></span>
<span class="line" id="L365"><span class="tok-kw">fn</span> <span class="tok-fn">hasSideEffects</span>(self: Run) <span class="tok-type">bool</span> {</span>
<span class="line" id="L366"> <span class="tok-kw">if</span> (self.has_side_effects) <span class="tok-kw">return</span> <span class="tok-null">true</span>;</span>
<span class="line" id="L367"> <span class="tok-kw">return</span> <span class="tok-kw">switch</span> (self.stdio) {</span>
<span class="line" id="L368"> .infer_from_args => !self.hasAnyOutputArgs(),</span>
<span class="line" id="L369"> .inherit => <span class="tok-null">true</span>,</span>
<span class="line" id="L370"> .check => <span class="tok-null">false</span>,</span>
<span class="line" id="L371"> .zig_test => <span class="tok-null">false</span>,</span>
<span class="line" id="L372"> };</span>
<span class="line" id="L373">}</span>
<span class="line" id="L374"></span>
<span class="line" id="L375"><span class="tok-kw">fn</span> <span class="tok-fn">hasAnyOutputArgs</span>(self: Run) <span class="tok-type">bool</span> {</span>
<span class="line" id="L376"> <span class="tok-kw">if</span> (self.captured_stdout != <span class="tok-null">null</span>) <span class="tok-kw">return</span> <span class="tok-null">true</span>;</span>
<span class="line" id="L377"> <span class="tok-kw">if</span> (self.captured_stderr != <span class="tok-null">null</span>) <span class="tok-kw">return</span> <span class="tok-null">true</span>;</span>
<span class="line" id="L378"> <span class="tok-kw">for</span> (self.argv.items) |arg| <span class="tok-kw">switch</span> (arg) {</span>
<span class="line" id="L379"> .output => <span class="tok-kw">return</span> <span class="tok-null">true</span>,</span>
<span class="line" id="L380"> <span class="tok-kw">else</span> => <span class="tok-kw">continue</span>,</span>
<span class="line" id="L381"> };</span>
<span class="line" id="L382"> <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L383">}</span>
<span class="line" id="L384"></span>
<span class="line" id="L385"><span class="tok-kw">fn</span> <span class="tok-fn">checksContainStdout</span>(checks: []<span class="tok-kw">const</span> StdIo.Check) <span class="tok-type">bool</span> {</span>
<span class="line" id="L386"> <span class="tok-kw">for</span> (checks) |check| <span class="tok-kw">switch</span> (check) {</span>
<span class="line" id="L387"> .expect_stderr_exact,</span>
<span class="line" id="L388"> .expect_stderr_match,</span>
<span class="line" id="L389"> .expect_term,</span>
<span class="line" id="L390"> => <span class="tok-kw">continue</span>,</span>
<span class="line" id="L391"></span>
<span class="line" id="L392"> .expect_stdout_exact,</span>
<span class="line" id="L393"> .expect_stdout_match,</span>
<span class="line" id="L394"> => <span class="tok-kw">return</span> <span class="tok-null">true</span>,</span>
<span class="line" id="L395"> };</span>
<span class="line" id="L396"> <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L397">}</span>
<span class="line" id="L398"></span>
<span class="line" id="L399"><span class="tok-kw">fn</span> <span class="tok-fn">checksContainStderr</span>(checks: []<span class="tok-kw">const</span> StdIo.Check) <span class="tok-type">bool</span> {</span>
<span class="line" id="L400"> <span class="tok-kw">for</span> (checks) |check| <span class="tok-kw">switch</span> (check) {</span>
<span class="line" id="L401"> .expect_stdout_exact,</span>
<span class="line" id="L402"> .expect_stdout_match,</span>
<span class="line" id="L403"> .expect_term,</span>
<span class="line" id="L404"> => <span class="tok-kw">continue</span>,</span>
<span class="line" id="L405"></span>
<span class="line" id="L406"> .expect_stderr_exact,</span>
<span class="line" id="L407"> .expect_stderr_match,</span>
<span class="line" id="L408"> => <span class="tok-kw">return</span> <span class="tok-null">true</span>,</span>
<span class="line" id="L409"> };</span>
<span class="line" id="L410"> <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L411">}</span>
<span class="line" id="L412"></span>
<span class="line" id="L413"><span class="tok-kw">fn</span> <span class="tok-fn">make</span>(step: *Step, prog_node: *std.Progress.Node) !<span class="tok-type">void</span> {</span>
<span class="line" id="L414"> <span class="tok-kw">const</span> b = step.owner;</span>
<span class="line" id="L415"> <span class="tok-kw">const</span> arena = b.allocator;</span>
<span class="line" id="L416"> <span class="tok-kw">const</span> self = <span class="tok-builtin">@fieldParentPtr</span>(Run, <span class="tok-str">"step"</span>, step);</span>
<span class="line" id="L417"> <span class="tok-kw">const</span> has_side_effects = self.hasSideEffects();</span>
<span class="line" id="L418"></span>
<span class="line" id="L419"> <span class="tok-kw">var</span> argv_list = ArrayList([]<span class="tok-kw">const</span> <span class="tok-type">u8</span>).init(arena);</span>
<span class="line" id="L420"> <span class="tok-kw">var</span> output_placeholders = ArrayList(<span class="tok-kw">struct</span> {</span>
<span class="line" id="L421"> index: <span class="tok-type">usize</span>,</span>
<span class="line" id="L422"> output: *Output,</span>
<span class="line" id="L423"> }).init(arena);</span>
<span class="line" id="L424"></span>
<span class="line" id="L425"> <span class="tok-kw">var</span> man = b.cache.obtain();</span>
<span class="line" id="L426"> <span class="tok-kw">defer</span> man.deinit();</span>
<span class="line" id="L427"></span>
<span class="line" id="L428"> <span class="tok-kw">for</span> (self.argv.items) |arg| {</span>
<span class="line" id="L429"> <span class="tok-kw">switch</span> (arg) {</span>
<span class="line" id="L430"> .bytes => |bytes| {</span>
<span class="line" id="L431"> <span class="tok-kw">try</span> argv_list.append(bytes);</span>
<span class="line" id="L432"> man.hash.addBytes(bytes);</span>
<span class="line" id="L433"> },</span>
<span class="line" id="L434"> .file_source => |file| {</span>
<span class="line" id="L435"> <span class="tok-kw">const</span> file_path = file.file_source.getPath(b);</span>
<span class="line" id="L436"> <span class="tok-kw">try</span> argv_list.append(b.fmt(<span class="tok-str">"{s}{s}"</span>, .{ file.prefix, file_path }));</span>
<span class="line" id="L437"> man.hash.addBytes(file.prefix);</span>
<span class="line" id="L438"> _ = <span class="tok-kw">try</span> man.addFile(file_path, <span class="tok-null">null</span>);</span>
<span class="line" id="L439"> },</span>
<span class="line" id="L440"> .directory_source => |file| {</span>
<span class="line" id="L441"> <span class="tok-kw">const</span> file_path = file.file_source.getPath(b);</span>
<span class="line" id="L442"> <span class="tok-kw">try</span> argv_list.append(b.fmt(<span class="tok-str">"{s}{s}"</span>, .{ file.prefix, file_path }));</span>
<span class="line" id="L443"> man.hash.addBytes(file.prefix);</span>
<span class="line" id="L444"> man.hash.addBytes(file_path);</span>
<span class="line" id="L445"> },</span>
<span class="line" id="L446"> .artifact => |artifact| {</span>
<span class="line" id="L447"> <span class="tok-kw">if</span> (artifact.target.isWindows()) {</span>
<span class="line" id="L448"> <span class="tok-comment">// On Windows we don't have rpaths so we have to add .dll search paths to PATH</span>
</span>
<span class="line" id="L449"> self.addPathForDynLibs(artifact);</span>
<span class="line" id="L450"> }</span>
<span class="line" id="L451"> <span class="tok-kw">const</span> file_path = artifact.installed_path <span class="tok-kw">orelse</span></span>
<span class="line" id="L452"> artifact.getOutputSource().getPath(b);</span>
<span class="line" id="L453"></span>
<span class="line" id="L454"> <span class="tok-kw">try</span> argv_list.append(file_path);</span>
<span class="line" id="L455"></span>
<span class="line" id="L456"> _ = <span class="tok-kw">try</span> man.addFile(file_path, <span class="tok-null">null</span>);</span>
<span class="line" id="L457"> },</span>
<span class="line" id="L458"> .output => |output| {</span>
<span class="line" id="L459"> man.hash.addBytes(output.prefix);</span>
<span class="line" id="L460"> man.hash.addBytes(output.basename);</span>
<span class="line" id="L461"> <span class="tok-comment">// Add a placeholder into the argument list because we need the</span>
</span>
<span class="line" id="L462"> <span class="tok-comment">// manifest hash to be updated with all arguments before the</span>
</span>
<span class="line" id="L463"> <span class="tok-comment">// object directory is computed.</span>
</span>
<span class="line" id="L464"> <span class="tok-kw">try</span> argv_list.append(<span class="tok-str">""</span>);</span>
<span class="line" id="L465"> <span class="tok-kw">try</span> output_placeholders.append(.{</span>
<span class="line" id="L466"> .index = argv_list.items.len - <span class="tok-number">1</span>,</span>
<span class="line" id="L467"> .output = output,</span>
<span class="line" id="L468"> });</span>
<span class="line" id="L469"> },</span>
<span class="line" id="L470"> }</span>
<span class="line" id="L471"> }</span>
<span class="line" id="L472"></span>
<span class="line" id="L473"> <span class="tok-kw">switch</span> (self.stdin) {</span>
<span class="line" id="L474"> .bytes => |bytes| {</span>
<span class="line" id="L475"> man.hash.addBytes(bytes);</span>
<span class="line" id="L476"> },</span>
<span class="line" id="L477"> .file_source => |file_source| {</span>
<span class="line" id="L478"> <span class="tok-kw">const</span> file_path = file_source.getPath(b);</span>
<span class="line" id="L479"> _ = <span class="tok-kw">try</span> man.addFile(file_path, <span class="tok-null">null</span>);</span>
<span class="line" id="L480"> },</span>
<span class="line" id="L481"> .none => {},</span>
<span class="line" id="L482"> }</span>
<span class="line" id="L483"></span>
<span class="line" id="L484"> <span class="tok-kw">if</span> (self.captured_stdout) |output| {</span>
<span class="line" id="L485"> man.hash.addBytes(output.basename);</span>
<span class="line" id="L486"> }</span>
<span class="line" id="L487"></span>
<span class="line" id="L488"> <span class="tok-kw">if</span> (self.captured_stderr) |output| {</span>
<span class="line" id="L489"> man.hash.addBytes(output.basename);</span>
<span class="line" id="L490"> }</span>
<span class="line" id="L491"></span>
<span class="line" id="L492"> hashStdIo(&man.hash, self.stdio);</span>
<span class="line" id="L493"></span>
<span class="line" id="L494"> <span class="tok-kw">if</span> (has_side_effects) {</span>
<span class="line" id="L495"> <span class="tok-kw">try</span> runCommand(self, argv_list.items, has_side_effects, <span class="tok-null">null</span>, prog_node);</span>
<span class="line" id="L496"> <span class="tok-kw">return</span>;</span>
<span class="line" id="L497"> }</span>
<span class="line" id="L498"></span>
<span class="line" id="L499"> <span class="tok-kw">for</span> (self.extra_file_dependencies) |file_path| {</span>
<span class="line" id="L500"> _ = <span class="tok-kw">try</span> man.addFile(b.pathFromRoot(file_path), <span class="tok-null">null</span>);</span>
<span class="line" id="L501"> }</span>
<span class="line" id="L502"></span>
<span class="line" id="L503"> <span class="tok-kw">if</span> (<span class="tok-kw">try</span> step.cacheHit(&man)) {</span>
<span class="line" id="L504"> <span class="tok-comment">// cache hit, skip running command</span>
</span>
<span class="line" id="L505"> <span class="tok-kw">const</span> digest = man.final();</span>
<span class="line" id="L506"> <span class="tok-kw">for</span> (output_placeholders.items) |placeholder| {</span>
<span class="line" id="L507"> placeholder.output.generated_file.path = <span class="tok-kw">try</span> b.cache_root.join(arena, &.{</span>
<span class="line" id="L508"> <span class="tok-str">"o"</span>, &digest, placeholder.output.basename,</span>
<span class="line" id="L509"> });</span>
<span class="line" id="L510"> }</span>
<span class="line" id="L511"></span>
<span class="line" id="L512"> <span class="tok-kw">if</span> (self.captured_stdout) |output| {</span>
<span class="line" id="L513"> output.generated_file.path = <span class="tok-kw">try</span> b.cache_root.join(arena, &.{</span>
<span class="line" id="L514"> <span class="tok-str">"o"</span>, &digest, output.basename,</span>
<span class="line" id="L515"> });</span>
<span class="line" id="L516"> }</span>
<span class="line" id="L517"></span>
<span class="line" id="L518"> <span class="tok-kw">if</span> (self.captured_stderr) |output| {</span>
<span class="line" id="L519"> output.generated_file.path = <span class="tok-kw">try</span> b.cache_root.join(arena, &.{</span>
<span class="line" id="L520"> <span class="tok-str">"o"</span>, &digest, output.basename,</span>
<span class="line" id="L521"> });</span>
<span class="line" id="L522"> }</span>
<span class="line" id="L523"></span>
<span class="line" id="L524"> step.result_cached = <span class="tok-null">true</span>;</span>
<span class="line" id="L525"> <span class="tok-kw">return</span>;</span>
<span class="line" id="L526"> }</span>
<span class="line" id="L527"></span>
<span class="line" id="L528"> <span class="tok-kw">const</span> digest = man.final();</span>
<span class="line" id="L529"></span>
<span class="line" id="L530"> <span class="tok-kw">for</span> (output_placeholders.items) |placeholder| {</span>
<span class="line" id="L531"> <span class="tok-kw">const</span> output_components = .{ <span class="tok-str">"o"</span>, &digest, placeholder.output.basename };</span>
<span class="line" id="L532"> <span class="tok-kw">const</span> output_sub_path = <span class="tok-kw">try</span> fs.path.join(arena, &output_components);</span>
<span class="line" id="L533"> <span class="tok-kw">const</span> output_sub_dir_path = fs.path.dirname(output_sub_path).?;</span>
<span class="line" id="L534"> b.cache_root.handle.makePath(output_sub_dir_path) <span class="tok-kw">catch</span> |err| {</span>
<span class="line" id="L535"> <span class="tok-kw">return</span> step.fail(<span class="tok-str">"unable to make path '{}{s}': {s}"</span>, .{</span>
<span class="line" id="L536"> b.cache_root, output_sub_dir_path, <span class="tok-builtin">@errorName</span>(err),</span>
<span class="line" id="L537"> });</span>
<span class="line" id="L538"> };</span>
<span class="line" id="L539"> <span class="tok-kw">const</span> output_path = <span class="tok-kw">try</span> b.cache_root.join(arena, &output_components);</span>
<span class="line" id="L540"> placeholder.output.generated_file.path = output_path;</span>
<span class="line" id="L541"> <span class="tok-kw">const</span> cli_arg = <span class="tok-kw">if</span> (placeholder.output.prefix.len == <span class="tok-number">0</span>)</span>
<span class="line" id="L542"> output_path</span>
<span class="line" id="L543"> <span class="tok-kw">else</span></span>
<span class="line" id="L544"> b.fmt(<span class="tok-str">"{s}{s}"</span>, .{ placeholder.output.prefix, output_path });</span>
<span class="line" id="L545"> argv_list.items[placeholder.index] = cli_arg;</span>
<span class="line" id="L546"> }</span>
<span class="line" id="L547"></span>
<span class="line" id="L548"> <span class="tok-kw">try</span> runCommand(self, argv_list.items, has_side_effects, &digest, prog_node);</span>
<span class="line" id="L549"></span>
<span class="line" id="L550"> <span class="tok-kw">try</span> step.writeManifest(&man);</span>
<span class="line" id="L551">}</span>
<span class="line" id="L552"></span>
<span class="line" id="L553"><span class="tok-kw">fn</span> <span class="tok-fn">formatTerm</span>(</span>
<span class="line" id="L554"> term: ?std.process.Child.Term,</span>
<span class="line" id="L555"> <span class="tok-kw">comptime</span> fmt: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L556"> options: std.fmt.FormatOptions,</span>
<span class="line" id="L557"> writer: <span class="tok-kw">anytype</span>,</span>
<span class="line" id="L558">) !<span class="tok-type">void</span> {</span>
<span class="line" id="L559"> _ = fmt;</span>
<span class="line" id="L560"> _ = options;</span>
<span class="line" id="L561"> <span class="tok-kw">if</span> (term) |t| <span class="tok-kw">switch</span> (t) {</span>
<span class="line" id="L562"> .Exited => |code| <span class="tok-kw">try</span> writer.print(<span class="tok-str">"exited with code {}"</span>, .{code}),</span>
<span class="line" id="L563"> .Signal => |sig| <span class="tok-kw">try</span> writer.print(<span class="tok-str">"terminated with signal {}"</span>, .{sig}),</span>
<span class="line" id="L564"> .Stopped => |sig| <span class="tok-kw">try</span> writer.print(<span class="tok-str">"stopped with signal {}"</span>, .{sig}),</span>
<span class="line" id="L565"> .Unknown => |code| <span class="tok-kw">try</span> writer.print(<span class="tok-str">"terminated for unknown reason with code {}"</span>, .{code}),</span>
<span class="line" id="L566"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L567"> <span class="tok-kw">try</span> writer.writeAll(<span class="tok-str">"exited with any code"</span>);</span>
<span class="line" id="L568"> }</span>
<span class="line" id="L569">}</span>
<span class="line" id="L570"><span class="tok-kw">fn</span> <span class="tok-fn">fmtTerm</span>(term: ?std.process.Child.Term) std.fmt.Formatter(formatTerm) {</span>
<span class="line" id="L571"> <span class="tok-kw">return</span> .{ .data = term };</span>
<span class="line" id="L572">}</span>
<span class="line" id="L573"></span>
<span class="line" id="L574"><span class="tok-kw">fn</span> <span class="tok-fn">termMatches</span>(expected: ?std.process.Child.Term, actual: std.process.Child.Term) <span class="tok-type">bool</span> {</span>
<span class="line" id="L575"> <span class="tok-kw">return</span> <span class="tok-kw">if</span> (expected) |e| <span class="tok-kw">switch</span> (e) {</span>
<span class="line" id="L576"> .Exited => |expected_code| <span class="tok-kw">switch</span> (actual) {</span>
<span class="line" id="L577"> .Exited => |actual_code| expected_code == actual_code,</span>
<span class="line" id="L578"> <span class="tok-kw">else</span> => <span class="tok-null">false</span>,</span>
<span class="line" id="L579"> },</span>
<span class="line" id="L580"> .Signal => |expected_sig| <span class="tok-kw">switch</span> (actual) {</span>
<span class="line" id="L581"> .Signal => |actual_sig| expected_sig == actual_sig,</span>
<span class="line" id="L582"> <span class="tok-kw">else</span> => <span class="tok-null">false</span>,</span>
<span class="line" id="L583"> },</span>
<span class="line" id="L584"> .Stopped => |expected_sig| <span class="tok-kw">switch</span> (actual) {</span>
<span class="line" id="L585"> .Stopped => |actual_sig| expected_sig == actual_sig,</span>
<span class="line" id="L586"> <span class="tok-kw">else</span> => <span class="tok-null">false</span>,</span>
<span class="line" id="L587"> },</span>
<span class="line" id="L588"> .Unknown => |expected_code| <span class="tok-kw">switch</span> (actual) {</span>
<span class="line" id="L589"> .Unknown => |actual_code| expected_code == actual_code,</span>
<span class="line" id="L590"> <span class="tok-kw">else</span> => <span class="tok-null">false</span>,</span>
<span class="line" id="L591"> },</span>
<span class="line" id="L592"> } <span class="tok-kw">else</span> <span class="tok-kw">switch</span> (actual) {</span>
<span class="line" id="L593"> .Exited => <span class="tok-null">true</span>,</span>
<span class="line" id="L594"> <span class="tok-kw">else</span> => <span class="tok-null">false</span>,</span>
<span class="line" id="L595"> };</span>
<span class="line" id="L596">}</span>
<span class="line" id="L597"></span>
<span class="line" id="L598"><span class="tok-kw">fn</span> <span class="tok-fn">runCommand</span>(</span>
<span class="line" id="L599"> self: *Run,</span>
<span class="line" id="L600"> argv: []<span class="tok-kw">const</span> []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L601"> has_side_effects: <span class="tok-type">bool</span>,</span>
<span class="line" id="L602"> digest: ?*<span class="tok-kw">const</span> [std.Build.Cache.hex_digest_len]<span class="tok-type">u8</span>,</span>
<span class="line" id="L603"> prog_node: *std.Progress.Node,</span>
<span class="line" id="L604">) !<span class="tok-type">void</span> {</span>
<span class="line" id="L605"> <span class="tok-kw">const</span> step = &self.step;</span>
<span class="line" id="L606"> <span class="tok-kw">const</span> b = step.owner;</span>
<span class="line" id="L607"> <span class="tok-kw">const</span> arena = b.allocator;</span>
<span class="line" id="L608"></span>
<span class="line" id="L609"> <span class="tok-kw">try</span> step.handleChildProcUnsupported(self.cwd, argv);</span>
<span class="line" id="L610"> <span class="tok-kw">try</span> Step.handleVerbose2(step.owner, self.cwd, self.env_map, argv);</span>
<span class="line" id="L611"></span>
<span class="line" id="L612"> <span class="tok-kw">const</span> allow_skip = <span class="tok-kw">switch</span> (self.stdio) {</span>
<span class="line" id="L613"> .check, .zig_test => self.skip_foreign_checks,</span>
<span class="line" id="L614"> <span class="tok-kw">else</span> => <span class="tok-null">false</span>,</span>
<span class="line" id="L615"> };</span>
<span class="line" id="L616"></span>
<span class="line" id="L617"> <span class="tok-kw">var</span> interp_argv = std.ArrayList([]<span class="tok-kw">const</span> <span class="tok-type">u8</span>).init(b.allocator);</span>
<span class="line" id="L618"> <span class="tok-kw">defer</span> interp_argv.deinit();</span>
<span class="line" id="L619"></span>
<span class="line" id="L620"> <span class="tok-kw">const</span> result = spawnChildAndCollect(self, argv, has_side_effects, prog_node) <span class="tok-kw">catch</span> |err| term: {</span>
<span class="line" id="L621"> <span class="tok-comment">// InvalidExe: cpu arch mismatch</span>
</span>
<span class="line" id="L622"> <span class="tok-comment">// FileNotFound: can happen with a wrong dynamic linker path</span>
</span>
<span class="line" id="L623"> <span class="tok-kw">if</span> (err == <span class="tok-kw">error</span>.InvalidExe <span class="tok-kw">or</span> err == <span class="tok-kw">error</span>.FileNotFound) interpret: {</span>
<span class="line" id="L624"> <span class="tok-comment">// TODO: learn the target from the binary directly rather than from</span>
</span>
<span class="line" id="L625"> <span class="tok-comment">// relying on it being a Compile step. This will make this logic</span>
</span>
<span class="line" id="L626"> <span class="tok-comment">// work even for the edge case that the binary was produced by a</span>
</span>
<span class="line" id="L627"> <span class="tok-comment">// third party.</span>
</span>
<span class="line" id="L628"> <span class="tok-kw">const</span> exe = <span class="tok-kw">switch</span> (self.argv.items[<span class="tok-number">0</span>]) {</span>
<span class="line" id="L629"> .artifact => |exe| exe,</span>
<span class="line" id="L630"> <span class="tok-kw">else</span> => <span class="tok-kw">break</span> :interpret,</span>
<span class="line" id="L631"> };</span>
<span class="line" id="L632"> <span class="tok-kw">switch</span> (exe.kind) {</span>
<span class="line" id="L633"> .exe, .@"test" => {},</span>
<span class="line" id="L634"> <span class="tok-kw">else</span> => <span class="tok-kw">break</span> :interpret,</span>
<span class="line" id="L635"> }</span>
<span class="line" id="L636"></span>
<span class="line" id="L637"> <span class="tok-kw">const</span> need_cross_glibc = exe.target.isGnuLibC() <span class="tok-kw">and</span> exe.is_linking_libc;</span>
<span class="line" id="L638"> <span class="tok-kw">switch</span> (b.host.getExternalExecutor(exe.target_info, .{</span>
<span class="line" id="L639"> .qemu_fixes_dl = need_cross_glibc <span class="tok-kw">and</span> b.glibc_runtimes_dir != <span class="tok-null">null</span>,</span>
<span class="line" id="L640"> .link_libc = exe.is_linking_libc,</span>
<span class="line" id="L641"> })) {</span>
<span class="line" id="L642"> .native, .rosetta => {</span>
<span class="line" id="L643"> <span class="tok-kw">if</span> (allow_skip) <span class="tok-kw">return</span> <span class="tok-kw">error</span>.MakeSkipped;</span>
<span class="line" id="L644"> <span class="tok-kw">break</span> :interpret;</span>
<span class="line" id="L645"> },</span>
<span class="line" id="L646"> .wine => |bin_name| {</span>
<span class="line" id="L647"> <span class="tok-kw">if</span> (b.enable_wine) {</span>
<span class="line" id="L648"> <span class="tok-kw">try</span> interp_argv.append(bin_name);</span>
<span class="line" id="L649"> <span class="tok-kw">try</span> interp_argv.appendSlice(argv);</span>
<span class="line" id="L650"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L651"> <span class="tok-kw">return</span> failForeign(self, <span class="tok-str">"-fwine"</span>, argv[<span class="tok-number">0</span>], exe);</span>
<span class="line" id="L652"> }</span>
<span class="line" id="L653"> },</span>
<span class="line" id="L654"> .qemu => |bin_name| {</span>
<span class="line" id="L655"> <span class="tok-kw">if</span> (b.enable_qemu) {</span>
<span class="line" id="L656"> <span class="tok-kw">const</span> glibc_dir_arg = <span class="tok-kw">if</span> (need_cross_glibc)</span>
<span class="line" id="L657"> b.glibc_runtimes_dir <span class="tok-kw">orelse</span></span>
<span class="line" id="L658"> <span class="tok-kw">return</span> failForeign(self, <span class="tok-str">"--glibc-runtimes"</span>, argv[<span class="tok-number">0</span>], exe)</span>
<span class="line" id="L659"> <span class="tok-kw">else</span></span>
<span class="line" id="L660"> <span class="tok-null">null</span>;</span>
<span class="line" id="L661"></span>
<span class="line" id="L662"> <span class="tok-kw">try</span> interp_argv.append(bin_name);</span>
<span class="line" id="L663"></span>
<span class="line" id="L664"> <span class="tok-kw">if</span> (glibc_dir_arg) |dir| {</span>
<span class="line" id="L665"> <span class="tok-comment">// TODO look into making this a call to `linuxTriple`. This</span>
</span>
<span class="line" id="L666"> <span class="tok-comment">// needs the directory to be called "i686" rather than</span>
</span>
<span class="line" id="L667"> <span class="tok-comment">// "x86" which is why we do it manually here.</span>
</span>
<span class="line" id="L668"> <span class="tok-kw">const</span> fmt_str = <span class="tok-str">"{s}"</span> ++ fs.path.sep_str ++ <span class="tok-str">"{s}-{s}-{s}"</span>;</span>
<span class="line" id="L669"> <span class="tok-kw">const</span> cpu_arch = exe.target.getCpuArch();</span>
<span class="line" id="L670"> <span class="tok-kw">const</span> os_tag = exe.target.getOsTag();</span>
<span class="line" id="L671"> <span class="tok-kw">const</span> abi = exe.target.getAbi();</span>
<span class="line" id="L672"> <span class="tok-kw">const</span> cpu_arch_name: []<span class="tok-kw">const</span> <span class="tok-type">u8</span> = <span class="tok-kw">if</span> (cpu_arch == .x86)</span>
<span class="line" id="L673"> <span class="tok-str">"i686"</span></span>
<span class="line" id="L674"> <span class="tok-kw">else</span></span>
<span class="line" id="L675"> <span class="tok-builtin">@tagName</span>(cpu_arch);</span>
<span class="line" id="L676"> <span class="tok-kw">const</span> full_dir = <span class="tok-kw">try</span> std.fmt.allocPrint(b.allocator, fmt_str, .{</span>
<span class="line" id="L677"> dir, cpu_arch_name, <span class="tok-builtin">@tagName</span>(os_tag), <span class="tok-builtin">@tagName</span>(abi),</span>
<span class="line" id="L678"> });</span>
<span class="line" id="L679"></span>
<span class="line" id="L680"> <span class="tok-kw">try</span> interp_argv.append(<span class="tok-str">"-L"</span>);</span>
<span class="line" id="L681"> <span class="tok-kw">try</span> interp_argv.append(full_dir);</span>
<span class="line" id="L682"> }</span>
<span class="line" id="L683"></span>
<span class="line" id="L684"> <span class="tok-kw">try</span> interp_argv.appendSlice(argv);</span>
<span class="line" id="L685"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L686"> <span class="tok-kw">return</span> failForeign(self, <span class="tok-str">"-fqemu"</span>, argv[<span class="tok-number">0</span>], exe);</span>
<span class="line" id="L687"> }</span>
<span class="line" id="L688"> },</span>
<span class="line" id="L689"> .darling => |bin_name| {</span>
<span class="line" id="L690"> <span class="tok-kw">if</span> (b.enable_darling) {</span>
<span class="line" id="L691"> <span class="tok-kw">try</span> interp_argv.append(bin_name);</span>
<span class="line" id="L692"> <span class="tok-kw">try</span> interp_argv.appendSlice(argv);</span>
<span class="line" id="L693"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L694"> <span class="tok-kw">return</span> failForeign(self, <span class="tok-str">"-fdarling"</span>, argv[<span class="tok-number">0</span>], exe);</span>
<span class="line" id="L695"> }</span>
<span class="line" id="L696"> },</span>
<span class="line" id="L697"> .wasmtime => |bin_name| {</span>
<span class="line" id="L698"> <span class="tok-kw">if</span> (b.enable_wasmtime) {</span>
<span class="line" id="L699"> <span class="tok-kw">try</span> interp_argv.append(bin_name);</span>
<span class="line" id="L700"> <span class="tok-kw">try</span> interp_argv.append(<span class="tok-str">"--dir=."</span>);</span>
<span class="line" id="L701"> <span class="tok-kw">try</span> interp_argv.append(argv[<span class="tok-number">0</span>]);</span>
<span class="line" id="L702"> <span class="tok-kw">try</span> interp_argv.append(<span class="tok-str">"--"</span>);</span>
<span class="line" id="L703"> <span class="tok-kw">try</span> interp_argv.appendSlice(argv[<span class="tok-number">1</span>..]);</span>
<span class="line" id="L704"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L705"> <span class="tok-kw">return</span> failForeign(self, <span class="tok-str">"-fwasmtime"</span>, argv[<span class="tok-number">0</span>], exe);</span>
<span class="line" id="L706"> }</span>
<span class="line" id="L707"> },</span>
<span class="line" id="L708"> .bad_dl => |foreign_dl| {</span>
<span class="line" id="L709"> <span class="tok-kw">if</span> (allow_skip) <span class="tok-kw">return</span> <span class="tok-kw">error</span>.MakeSkipped;</span>
<span class="line" id="L710"></span>
<span class="line" id="L711"> <span class="tok-kw">const</span> host_dl = b.host.dynamic_linker.get() <span class="tok-kw">orelse</span> <span class="tok-str">"(none)"</span>;</span>
<span class="line" id="L712"></span>
<span class="line" id="L713"> <span class="tok-kw">return</span> step.fail(</span>
<span class="line" id="L714"> <span class="tok-str">\\the host system is unable to execute binaries from the target</span></span>
<span class="line" id="L715"> <span class="tok-str">\\ because the host dynamic linker is '{s}',</span></span>
<span class="line" id="L716"> <span class="tok-str">\\ while the target dynamic linker is '{s}'.</span></span>
<span class="line" id="L717"> <span class="tok-str">\\ consider setting the dynamic linker or enabling skip_foreign_checks in the Run step</span></span>
<span class="line" id="L718"> , .{ host_dl, foreign_dl });</span>
<span class="line" id="L719"> },</span>
<span class="line" id="L720"> .bad_os_or_cpu => {</span>
<span class="line" id="L721"> <span class="tok-kw">if</span> (allow_skip) <span class="tok-kw">return</span> <span class="tok-kw">error</span>.MakeSkipped;</span>
<span class="line" id="L722"></span>
<span class="line" id="L723"> <span class="tok-kw">const</span> host_name = <span class="tok-kw">try</span> b.host.target.zigTriple(b.allocator);</span>
<span class="line" id="L724"> <span class="tok-kw">const</span> foreign_name = <span class="tok-kw">try</span> exe.target.zigTriple(b.allocator);</span>
<span class="line" id="L725"></span>
<span class="line" id="L726"> <span class="tok-kw">return</span> step.fail(<span class="tok-str">"the host system ({s}) is unable to execute binaries from the target ({s})"</span>, .{</span>
<span class="line" id="L727"> host_name, foreign_name,</span>
<span class="line" id="L728"> });</span>
<span class="line" id="L729"> },</span>
<span class="line" id="L730"> }</span>
<span class="line" id="L731"></span>
<span class="line" id="L732"> <span class="tok-kw">if</span> (exe.target.isWindows()) {</span>
<span class="line" id="L733"> <span class="tok-comment">// On Windows we don't have rpaths so we have to add .dll search paths to PATH</span>
</span>
<span class="line" id="L734"> self.addPathForDynLibs(exe);</span>
<span class="line" id="L735"> }</span>
<span class="line" id="L736"></span>
<span class="line" id="L737"> <span class="tok-kw">try</span> Step.handleVerbose2(step.owner, self.cwd, self.env_map, interp_argv.items);</span>
<span class="line" id="L738"></span>
<span class="line" id="L739"> <span class="tok-kw">break</span> :term spawnChildAndCollect(self, interp_argv.items, has_side_effects, prog_node) <span class="tok-kw">catch</span> |e| {</span>
<span class="line" id="L740"> <span class="tok-kw">if</span> (!self.failing_to_execute_foreign_is_an_error) <span class="tok-kw">return</span> <span class="tok-kw">error</span>.MakeSkipped;</span>
<span class="line" id="L741"></span>
<span class="line" id="L742"> <span class="tok-kw">return</span> step.fail(<span class="tok-str">"unable to spawn interpreter {s}: {s}"</span>, .{</span>
<span class="line" id="L743"> interp_argv.items[<span class="tok-number">0</span>], <span class="tok-builtin">@errorName</span>(e),</span>
<span class="line" id="L744"> });</span>
<span class="line" id="L745"> };</span>
<span class="line" id="L746"> }</span>
<span class="line" id="L747"></span>
<span class="line" id="L748"> <span class="tok-kw">return</span> step.fail(<span class="tok-str">"unable to spawn {s}: {s}"</span>, .{ argv[<span class="tok-number">0</span>], <span class="tok-builtin">@errorName</span>(err) });</span>
<span class="line" id="L749"> };</span>
<span class="line" id="L750"></span>
<span class="line" id="L751"> step.result_duration_ns = result.elapsed_ns;</span>
<span class="line" id="L752"> step.result_peak_rss = result.peak_rss;</span>
<span class="line" id="L753"> step.test_results = result.stdio.test_results;</span>
<span class="line" id="L754"></span>
<span class="line" id="L755"> <span class="tok-comment">// Capture stdout and stderr to GeneratedFile objects.</span>
</span>
<span class="line" id="L756"> <span class="tok-kw">const</span> Stream = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L757"> captured: ?*Output,</span>
<span class="line" id="L758"> is_null: <span class="tok-type">bool</span>,</span>
<span class="line" id="L759"> bytes: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L760"> };</span>
<span class="line" id="L761"> <span class="tok-kw">for</span> ([_]Stream{</span>
<span class="line" id="L762"> .{</span>
<span class="line" id="L763"> .captured = self.captured_stdout,</span>
<span class="line" id="L764"> .is_null = result.stdio.stdout_null,</span>
<span class="line" id="L765"> .bytes = result.stdio.stdout,</span>
<span class="line" id="L766"> },</span>
<span class="line" id="L767"> .{</span>
<span class="line" id="L768"> .captured = self.captured_stderr,</span>
<span class="line" id="L769"> .is_null = result.stdio.stderr_null,</span>
<span class="line" id="L770"> .bytes = result.stdio.stderr,</span>
<span class="line" id="L771"> },</span>
<span class="line" id="L772"> }) |stream| {</span>
<span class="line" id="L773"> <span class="tok-kw">if</span> (stream.captured) |output| {</span>
<span class="line" id="L774"> assert(!stream.is_null);</span>
<span class="line" id="L775"></span>
<span class="line" id="L776"> <span class="tok-kw">const</span> output_components = .{ <span class="tok-str">"o"</span>, digest.?, output.basename };</span>
<span class="line" id="L777"> <span class="tok-kw">const</span> output_path = <span class="tok-kw">try</span> b.cache_root.join(arena, &output_components);</span>
<span class="line" id="L778"> output.generated_file.path = output_path;</span>
<span class="line" id="L779"></span>
<span class="line" id="L780"> <span class="tok-kw">const</span> sub_path = <span class="tok-kw">try</span> fs.path.join(arena, &output_components);</span>
<span class="line" id="L781"> <span class="tok-kw">const</span> sub_path_dirname = fs.path.dirname(sub_path).?;</span>
<span class="line" id="L782"> b.cache_root.handle.makePath(sub_path_dirname) <span class="tok-kw">catch</span> |err| {</span>
<span class="line" id="L783"> <span class="tok-kw">return</span> step.fail(<span class="tok-str">"unable to make path '{}{s}': {s}"</span>, .{</span>
<span class="line" id="L784"> b.cache_root, sub_path_dirname, <span class="tok-builtin">@errorName</span>(err),</span>
<span class="line" id="L785"> });</span>
<span class="line" id="L786"> };</span>
<span class="line" id="L787"> b.cache_root.handle.writeFile(sub_path, stream.bytes) <span class="tok-kw">catch</span> |err| {</span>
<span class="line" id="L788"> <span class="tok-kw">return</span> step.fail(<span class="tok-str">"unable to write file '{}{s}': {s}"</span>, .{</span>
<span class="line" id="L789"> b.cache_root, sub_path, <span class="tok-builtin">@errorName</span>(err),</span>
<span class="line" id="L790"> });</span>
<span class="line" id="L791"> };</span>
<span class="line" id="L792"> }</span>
<span class="line" id="L793"> }</span>
<span class="line" id="L794"></span>
<span class="line" id="L795"> <span class="tok-kw">const</span> final_argv = <span class="tok-kw">if</span> (interp_argv.items.len == <span class="tok-number">0</span>) argv <span class="tok-kw">else</span> interp_argv.items;</span>
<span class="line" id="L796"></span>
<span class="line" id="L797"> <span class="tok-kw">switch</span> (self.stdio) {</span>
<span class="line" id="L798"> .check => |checks| <span class="tok-kw">for</span> (checks.items) |check| <span class="tok-kw">switch</span> (check) {</span>
<span class="line" id="L799"> .expect_stderr_exact => |expected_bytes| {</span>
<span class="line" id="L800"> assert(!result.stdio.stderr_null);</span>
<span class="line" id="L801"> <span class="tok-kw">if</span> (!mem.eql(<span class="tok-type">u8</span>, expected_bytes, result.stdio.stderr)) {</span>
<span class="line" id="L802"> <span class="tok-kw">return</span> step.fail(</span>
<span class="line" id="L803"> <span class="tok-str">\\</span></span>
<span class="line" id="L804"> <span class="tok-str">\\========= expected this stderr: =========</span></span>
<span class="line" id="L805"> <span class="tok-str">\\{s}</span></span>
<span class="line" id="L806"> <span class="tok-str">\\========= but found: ====================</span></span>
<span class="line" id="L807"> <span class="tok-str">\\{s}</span></span>
<span class="line" id="L808"> <span class="tok-str">\\========= from the following command: ===</span></span>
<span class="line" id="L809"> <span class="tok-str">\\{s}</span></span>
<span class="line" id="L810"> , .{</span>
<span class="line" id="L811"> expected_bytes,</span>
<span class="line" id="L812"> result.stdio.stderr,</span>
<span class="line" id="L813"> <span class="tok-kw">try</span> Step.allocPrintCmd(arena, self.cwd, final_argv),</span>
<span class="line" id="L814"> });</span>
<span class="line" id="L815"> }</span>
<span class="line" id="L816"> },</span>
<span class="line" id="L817"> .expect_stderr_match => |match| {</span>
<span class="line" id="L818"> assert(!result.stdio.stderr_null);</span>
<span class="line" id="L819"> <span class="tok-kw">if</span> (mem.indexOf(<span class="tok-type">u8</span>, result.stdio.stderr, match) == <span class="tok-null">null</span>) {</span>
<span class="line" id="L820"> <span class="tok-kw">return</span> step.fail(</span>
<span class="line" id="L821"> <span class="tok-str">\\</span></span>
<span class="line" id="L822"> <span class="tok-str">\\========= expected to find in stderr: =========</span></span>
<span class="line" id="L823"> <span class="tok-str">\\{s}</span></span>
<span class="line" id="L824"> <span class="tok-str">\\========= but stderr does not contain it: =====</span></span>
<span class="line" id="L825"> <span class="tok-str">\\{s}</span></span>
<span class="line" id="L826"> <span class="tok-str">\\========= from the following command: =========</span></span>
<span class="line" id="L827"> <span class="tok-str">\\{s}</span></span>
<span class="line" id="L828"> , .{</span>
<span class="line" id="L829"> match,</span>
<span class="line" id="L830"> result.stdio.stderr,</span>
<span class="line" id="L831"> <span class="tok-kw">try</span> Step.allocPrintCmd(arena, self.cwd, final_argv),</span>
<span class="line" id="L832"> });</span>
<span class="line" id="L833"> }</span>
<span class="line" id="L834"> },</span>
<span class="line" id="L835"> .expect_stdout_exact => |expected_bytes| {</span>
<span class="line" id="L836"> assert(!result.stdio.stdout_null);</span>
<span class="line" id="L837"> <span class="tok-kw">if</span> (!mem.eql(<span class="tok-type">u8</span>, expected_bytes, result.stdio.stdout)) {</span>
<span class="line" id="L838"> <span class="tok-kw">return</span> step.fail(</span>
<span class="line" id="L839"> <span class="tok-str">\\</span></span>
<span class="line" id="L840"> <span class="tok-str">\\========= expected this stdout: =========</span></span>
<span class="line" id="L841"> <span class="tok-str">\\{s}</span></span>
<span class="line" id="L842"> <span class="tok-str">\\========= but found: ====================</span></span>
<span class="line" id="L843"> <span class="tok-str">\\{s}</span></span>
<span class="line" id="L844"> <span class="tok-str">\\========= from the following command: ===</span></span>
<span class="line" id="L845"> <span class="tok-str">\\{s}</span></span>
<span class="line" id="L846"> , .{</span>
<span class="line" id="L847"> expected_bytes,</span>
<span class="line" id="L848"> result.stdio.stdout,</span>
<span class="line" id="L849"> <span class="tok-kw">try</span> Step.allocPrintCmd(arena, self.cwd, final_argv),</span>
<span class="line" id="L850"> });</span>
<span class="line" id="L851"> }</span>
<span class="line" id="L852"> },</span>
<span class="line" id="L853"> .expect_stdout_match => |match| {</span>
<span class="line" id="L854"> assert(!result.stdio.stdout_null);</span>
<span class="line" id="L855"> <span class="tok-kw">if</span> (mem.indexOf(<span class="tok-type">u8</span>, result.stdio.stdout, match) == <span class="tok-null">null</span>) {</span>
<span class="line" id="L856"> <span class="tok-kw">return</span> step.fail(</span>
<span class="line" id="L857"> <span class="tok-str">\\</span></span>
<span class="line" id="L858"> <span class="tok-str">\\========= expected to find in stdout: =========</span></span>
<span class="line" id="L859"> <span class="tok-str">\\{s}</span></span>
<span class="line" id="L860"> <span class="tok-str">\\========= but stdout does not contain it: =====</span></span>
<span class="line" id="L861"> <span class="tok-str">\\{s}</span></span>
<span class="line" id="L862"> <span class="tok-str">\\========= from the following command: =========</span></span>
<span class="line" id="L863"> <span class="tok-str">\\{s}</span></span>
<span class="line" id="L864"> , .{</span>
<span class="line" id="L865"> match,</span>
<span class="line" id="L866"> result.stdio.stdout,</span>
<span class="line" id="L867"> <span class="tok-kw">try</span> Step.allocPrintCmd(arena, self.cwd, final_argv),</span>
<span class="line" id="L868"> });</span>
<span class="line" id="L869"> }</span>
<span class="line" id="L870"> },</span>
<span class="line" id="L871"> .expect_term => |expected_term| {</span>
<span class="line" id="L872"> <span class="tok-kw">if</span> (!termMatches(expected_term, result.term)) {</span>
<span class="line" id="L873"> <span class="tok-kw">return</span> step.fail(<span class="tok-str">"the following command {} (expected {}):\n{s}"</span>, .{</span>
<span class="line" id="L874"> fmtTerm(result.term),</span>
<span class="line" id="L875"> fmtTerm(expected_term),</span>
<span class="line" id="L876"> <span class="tok-kw">try</span> Step.allocPrintCmd(arena, self.cwd, final_argv),</span>
<span class="line" id="L877"> });</span>
<span class="line" id="L878"> }</span>
<span class="line" id="L879"> },</span>
<span class="line" id="L880"> },</span>
<span class="line" id="L881"> .zig_test => {</span>
<span class="line" id="L882"> <span class="tok-kw">const</span> prefix: []<span class="tok-kw">const</span> <span class="tok-type">u8</span> = p: {</span>
<span class="line" id="L883"> <span class="tok-kw">if</span> (result.stdio.test_metadata) |tm| {</span>
<span class="line" id="L884"> <span class="tok-kw">if</span> (tm.next_index > <span class="tok-number">0</span> <span class="tok-kw">and</span> tm.next_index <= tm.names.len) {</span>
<span class="line" id="L885"> <span class="tok-kw">const</span> name = tm.testName(tm.next_index - <span class="tok-number">1</span>);</span>
<span class="line" id="L886"> <span class="tok-kw">break</span> :p b.fmt(<span class="tok-str">"while executing test '{s}', "</span>, .{name});</span>
<span class="line" id="L887"> }</span>
<span class="line" id="L888"> }</span>
<span class="line" id="L889"> <span class="tok-kw">break</span> :p <span class="tok-str">""</span>;</span>
<span class="line" id="L890"> };</span>
<span class="line" id="L891"> <span class="tok-kw">const</span> expected_term: std.process.Child.Term = .{ .Exited = <span class="tok-number">0</span> };</span>
<span class="line" id="L892"> <span class="tok-kw">if</span> (!termMatches(expected_term, result.term)) {</span>
<span class="line" id="L893"> <span class="tok-kw">return</span> step.fail(<span class="tok-str">"{s}the following command {} (expected {}):\n{s}"</span>, .{</span>
<span class="line" id="L894"> prefix,</span>
<span class="line" id="L895"> fmtTerm(result.term),</span>
<span class="line" id="L896"> fmtTerm(expected_term),</span>
<span class="line" id="L897"> <span class="tok-kw">try</span> Step.allocPrintCmd(arena, self.cwd, final_argv),</span>
<span class="line" id="L898"> });</span>
<span class="line" id="L899"> }</span>
<span class="line" id="L900"> <span class="tok-kw">if</span> (!result.stdio.test_results.isSuccess()) {</span>
<span class="line" id="L901"> <span class="tok-kw">return</span> step.fail(</span>
<span class="line" id="L902"> <span class="tok-str">"{s}the following test command failed:\n{s}"</span>,</span>
<span class="line" id="L903"> .{ prefix, <span class="tok-kw">try</span> Step.allocPrintCmd(arena, self.cwd, final_argv) },</span>
<span class="line" id="L904"> );</span>
<span class="line" id="L905"> }</span>
<span class="line" id="L906"> },</span>
<span class="line" id="L907"> <span class="tok-kw">else</span> => {</span>
<span class="line" id="L908"> <span class="tok-kw">try</span> step.handleChildProcessTerm(result.term, self.cwd, final_argv);</span>
<span class="line" id="L909"> },</span>
<span class="line" id="L910"> }</span>
<span class="line" id="L911">}</span>
<span class="line" id="L912"></span>
<span class="line" id="L913"><span class="tok-kw">const</span> ChildProcResult = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L914"> term: std.process.Child.Term,</span>
<span class="line" id="L915"> elapsed_ns: <span class="tok-type">u64</span>,</span>
<span class="line" id="L916"> peak_rss: <span class="tok-type">usize</span>,</span>
<span class="line" id="L917"></span>
<span class="line" id="L918"> stdio: StdIoResult,</span>
<span class="line" id="L919">};</span>
<span class="line" id="L920"></span>
<span class="line" id="L921"><span class="tok-kw">fn</span> <span class="tok-fn">spawnChildAndCollect</span>(</span>
<span class="line" id="L922"> self: *Run,</span>
<span class="line" id="L923"> argv: []<span class="tok-kw">const</span> []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L924"> has_side_effects: <span class="tok-type">bool</span>,</span>
<span class="line" id="L925"> prog_node: *std.Progress.Node,</span>
<span class="line" id="L926">) !ChildProcResult {</span>
<span class="line" id="L927"> <span class="tok-kw">const</span> b = self.step.owner;</span>
<span class="line" id="L928"> <span class="tok-kw">const</span> arena = b.allocator;</span>
<span class="line" id="L929"></span>
<span class="line" id="L930"> <span class="tok-kw">var</span> child = std.process.Child.init(argv, arena);</span>
<span class="line" id="L931"> <span class="tok-kw">if</span> (self.cwd) |cwd| {</span>
<span class="line" id="L932"> child.cwd = b.pathFromRoot(cwd);</span>
<span class="line" id="L933"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L934"> child.cwd = b.build_root.path;</span>
<span class="line" id="L935"> child.cwd_dir = b.build_root.handle;</span>
<span class="line" id="L936"> }</span>
<span class="line" id="L937"> child.env_map = self.env_map <span class="tok-kw">orelse</span> b.env_map;</span>
<span class="line" id="L938"> child.request_resource_usage_statistics = <span class="tok-null">true</span>;</span>
<span class="line" id="L939"></span>
<span class="line" id="L940"> child.stdin_behavior = <span class="tok-kw">switch</span> (self.stdio) {</span>
<span class="line" id="L941"> .infer_from_args => <span class="tok-kw">if</span> (has_side_effects) .Inherit <span class="tok-kw">else</span> .Ignore,</span>
<span class="line" id="L942"> .inherit => .Inherit,</span>
<span class="line" id="L943"> .check => .Ignore,</span>
<span class="line" id="L944"> .zig_test => .Pipe,</span>
<span class="line" id="L945"> };</span>
<span class="line" id="L946"> child.stdout_behavior = <span class="tok-kw">switch</span> (self.stdio) {</span>
<span class="line" id="L947"> .infer_from_args => <span class="tok-kw">if</span> (has_side_effects) .Inherit <span class="tok-kw">else</span> .Ignore,</span>
<span class="line" id="L948"> .inherit => .Inherit,</span>
<span class="line" id="L949"> .check => |checks| <span class="tok-kw">if</span> (checksContainStdout(checks.items)) .Pipe <span class="tok-kw">else</span> .Ignore,</span>
<span class="line" id="L950"> .zig_test => .Pipe,</span>
<span class="line" id="L951"> };</span>
<span class="line" id="L952"> child.stderr_behavior = <span class="tok-kw">switch</span> (self.stdio) {</span>
<span class="line" id="L953"> .infer_from_args => <span class="tok-kw">if</span> (has_side_effects) .Inherit <span class="tok-kw">else</span> .Pipe,</span>
<span class="line" id="L954"> .inherit => .Inherit,</span>
<span class="line" id="L955"> .check => .Pipe,</span>
<span class="line" id="L956"> .zig_test => .Pipe,</span>
<span class="line" id="L957"> };</span>
<span class="line" id="L958"> <span class="tok-kw">if</span> (self.captured_stdout != <span class="tok-null">null</span>) child.stdout_behavior = .Pipe;</span>
<span class="line" id="L959"> <span class="tok-kw">if</span> (self.captured_stderr != <span class="tok-null">null</span>) child.stderr_behavior = .Pipe;</span>
<span class="line" id="L960"> <span class="tok-kw">if</span> (self.stdin != .none) {</span>
<span class="line" id="L961"> assert(child.stdin_behavior != .Inherit);</span>
<span class="line" id="L962"> child.stdin_behavior = .Pipe;</span>
<span class="line" id="L963"> }</span>
<span class="line" id="L964"></span>
<span class="line" id="L965"> <span class="tok-kw">try</span> child.spawn();</span>
<span class="line" id="L966"> <span class="tok-kw">var</span> timer = <span class="tok-kw">try</span> std.time.Timer.start();</span>
<span class="line" id="L967"></span>
<span class="line" id="L968"> <span class="tok-kw">const</span> result = <span class="tok-kw">if</span> (self.stdio == .zig_test)</span>
<span class="line" id="L969"> evalZigTest(self, &child, prog_node)</span>
<span class="line" id="L970"> <span class="tok-kw">else</span></span>
<span class="line" id="L971"> evalGeneric(self, &child);</span>
<span class="line" id="L972"></span>
<span class="line" id="L973"> <span class="tok-kw">const</span> term = <span class="tok-kw">try</span> child.wait();</span>
<span class="line" id="L974"> <span class="tok-kw">const</span> elapsed_ns = timer.read();</span>
<span class="line" id="L975"></span>
<span class="line" id="L976"> <span class="tok-kw">return</span> .{</span>
<span class="line" id="L977"> .stdio = <span class="tok-kw">try</span> result,</span>
<span class="line" id="L978"> .term = term,</span>
<span class="line" id="L979"> .elapsed_ns = elapsed_ns,</span>
<span class="line" id="L980"> .peak_rss = child.resource_usage_statistics.getMaxRss() <span class="tok-kw">orelse</span> <span class="tok-number">0</span>,</span>
<span class="line" id="L981"> };</span>
<span class="line" id="L982">}</span>
<span class="line" id="L983"></span>
<span class="line" id="L984"><span class="tok-kw">const</span> StdIoResult = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L985"> <span class="tok-comment">// These use boolean flags instead of optionals as a workaround for</span>
</span>
<span class="line" id="L986"> <span class="tok-comment">// https://github.com/ziglang/zig/issues/14783</span>
</span>
<span class="line" id="L987"> stdout: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L988"> stderr: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L989"> stdout_null: <span class="tok-type">bool</span>,</span>
<span class="line" id="L990"> stderr_null: <span class="tok-type">bool</span>,</span>
<span class="line" id="L991"> test_results: Step.TestResults,</span>
<span class="line" id="L992"> test_metadata: ?TestMetadata,</span>
<span class="line" id="L993">};</span>
<span class="line" id="L994"></span>
<span class="line" id="L995"><span class="tok-kw">fn</span> <span class="tok-fn">evalZigTest</span>(</span>
<span class="line" id="L996"> self: *Run,</span>
<span class="line" id="L997"> child: *std.process.Child,</span>
<span class="line" id="L998"> prog_node: *std.Progress.Node,</span>
<span class="line" id="L999">) !StdIoResult {</span>
<span class="line" id="L1000"> <span class="tok-kw">const</span> gpa = self.step.owner.allocator;</span>
<span class="line" id="L1001"> <span class="tok-kw">const</span> arena = self.step.owner.allocator;</span>
<span class="line" id="L1002"></span>
<span class="line" id="L1003"> <span class="tok-kw">var</span> poller = std.io.poll(gpa, <span class="tok-kw">enum</span> { stdout, stderr }, .{</span>
<span class="line" id="L1004"> .stdout = child.stdout.?,</span>
<span class="line" id="L1005"> .stderr = child.stderr.?,</span>
<span class="line" id="L1006"> });</span>
<span class="line" id="L1007"> <span class="tok-kw">defer</span> poller.deinit();</span>
<span class="line" id="L1008"></span>
<span class="line" id="L1009"> <span class="tok-kw">try</span> sendMessage(child.stdin.?, .query_test_metadata);</span>
<span class="line" id="L1010"></span>
<span class="line" id="L1011"> <span class="tok-kw">const</span> Header = std.zig.Server.Message.Header;</span>
<span class="line" id="L1012"></span>
<span class="line" id="L1013"> <span class="tok-kw">const</span> stdout = poller.fifo(.stdout);</span>
<span class="line" id="L1014"> <span class="tok-kw">const</span> stderr = poller.fifo(.stderr);</span>
<span class="line" id="L1015"></span>
<span class="line" id="L1016"> <span class="tok-kw">var</span> fail_count: <span class="tok-type">u32</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L1017"> <span class="tok-kw">var</span> skip_count: <span class="tok-type">u32</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L1018"> <span class="tok-kw">var</span> leak_count: <span class="tok-type">u32</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L1019"> <span class="tok-kw">var</span> test_count: <span class="tok-type">u32</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L1020"></span>
<span class="line" id="L1021"> <span class="tok-kw">var</span> metadata: ?TestMetadata = <span class="tok-null">null</span>;</span>
<span class="line" id="L1022"></span>
<span class="line" id="L1023"> <span class="tok-kw">var</span> sub_prog_node: ?std.Progress.Node = <span class="tok-null">null</span>;</span>
<span class="line" id="L1024"> <span class="tok-kw">defer</span> <span class="tok-kw">if</span> (sub_prog_node) |*n| n.end();</span>
<span class="line" id="L1025"></span>
<span class="line" id="L1026"> poll: <span class="tok-kw">while</span> (<span class="tok-null">true</span>) {</span>
<span class="line" id="L1027"> <span class="tok-kw">while</span> (stdout.readableLength() < <span class="tok-builtin">@sizeOf</span>(Header)) {</span>
<span class="line" id="L1028"> <span class="tok-kw">if</span> (!(<span class="tok-kw">try</span> poller.poll())) <span class="tok-kw">break</span> :poll;</span>
<span class="line" id="L1029"> }</span>
<span class="line" id="L1030"> <span class="tok-kw">const</span> header = stdout.reader().readStruct(Header) <span class="tok-kw">catch</span> <span class="tok-kw">unreachable</span>;</span>
<span class="line" id="L1031"> <span class="tok-kw">while</span> (stdout.readableLength() < header.bytes_len) {</span>
<span class="line" id="L1032"> <span class="tok-kw">if</span> (!(<span class="tok-kw">try</span> poller.poll())) <span class="tok-kw">break</span> :poll;</span>
<span class="line" id="L1033"> }</span>
<span class="line" id="L1034"> <span class="tok-kw">const</span> body = stdout.readableSliceOfLen(header.bytes_len);</span>
<span class="line" id="L1035"></span>
<span class="line" id="L1036"> <span class="tok-kw">switch</span> (header.tag) {</span>
<span class="line" id="L1037"> .zig_version => {</span>
<span class="line" id="L1038"> <span class="tok-kw">if</span> (!std.mem.eql(<span class="tok-type">u8</span>, builtin.zig_version_string, body)) {</span>
<span class="line" id="L1039"> <span class="tok-kw">return</span> self.step.fail(</span>
<span class="line" id="L1040"> <span class="tok-str">"zig version mismatch build runner vs compiler: '{s}' vs '{s}'"</span>,</span>
<span class="line" id="L1041"> .{ builtin.zig_version_string, body },</span>
<span class="line" id="L1042"> );</span>
<span class="line" id="L1043"> }</span>
<span class="line" id="L1044"> },</span>
<span class="line" id="L1045"> .test_metadata => {</span>
<span class="line" id="L1046"> <span class="tok-kw">const</span> TmHdr = std.zig.Server.Message.TestMetadata;</span>
<span class="line" id="L1047"> <span class="tok-kw">const</span> tm_hdr = <span class="tok-builtin">@as</span>(*<span class="tok-kw">align</span>(<span class="tok-number">1</span>) <span class="tok-kw">const</span> TmHdr, <span class="tok-builtin">@ptrCast</span>(body));</span>
<span class="line" id="L1048"> test_count = tm_hdr.tests_len;</span>
<span class="line" id="L1049"></span>
<span class="line" id="L1050"> <span class="tok-kw">const</span> names_bytes = body[<span class="tok-builtin">@sizeOf</span>(TmHdr)..][<span class="tok-number">0</span> .. test_count * <span class="tok-builtin">@sizeOf</span>(<span class="tok-type">u32</span>)];</span>
<span class="line" id="L1051"> <span class="tok-kw">const</span> async_frame_lens_bytes = body[<span class="tok-builtin">@sizeOf</span>(TmHdr) + names_bytes.len ..][<span class="tok-number">0</span> .. test_count * <span class="tok-builtin">@sizeOf</span>(<span class="tok-type">u32</span>)];</span>
<span class="line" id="L1052"> <span class="tok-kw">const</span> expected_panic_msgs_bytes = body[<span class="tok-builtin">@sizeOf</span>(TmHdr) + names_bytes.len + async_frame_lens_bytes.len ..][<span class="tok-number">0</span> .. test_count * <span class="tok-builtin">@sizeOf</span>(<span class="tok-type">u32</span>)];</span>
<span class="line" id="L1053"> <span class="tok-kw">const</span> string_bytes = body[<span class="tok-builtin">@sizeOf</span>(TmHdr) + names_bytes.len + async_frame_lens_bytes.len + expected_panic_msgs_bytes.len ..][<span class="tok-number">0</span>..tm_hdr.string_bytes_len];</span>
<span class="line" id="L1054"></span>
<span class="line" id="L1055"> <span class="tok-kw">const</span> names = std.mem.bytesAsSlice(<span class="tok-type">u32</span>, names_bytes);</span>
<span class="line" id="L1056"> <span class="tok-kw">const</span> async_frame_lens = std.mem.bytesAsSlice(<span class="tok-type">u32</span>, async_frame_lens_bytes);</span>
<span class="line" id="L1057"> <span class="tok-kw">const</span> expected_panic_msgs = std.mem.bytesAsSlice(<span class="tok-type">u32</span>, expected_panic_msgs_bytes);</span>
<span class="line" id="L1058"> <span class="tok-kw">const</span> names_aligned = <span class="tok-kw">try</span> arena.alloc(<span class="tok-type">u32</span>, names.len);</span>
<span class="line" id="L1059"> <span class="tok-kw">for</span> (names_aligned, names) |*dest, src| dest.* = src;</span>
<span class="line" id="L1060"></span>
<span class="line" id="L1061"> <span class="tok-kw">const</span> async_frame_lens_aligned = <span class="tok-kw">try</span> arena.alloc(<span class="tok-type">u32</span>, async_frame_lens.len);</span>
<span class="line" id="L1062"> <span class="tok-kw">for</span> (async_frame_lens_aligned, async_frame_lens) |*dest, src| dest.* = src;</span>
<span class="line" id="L1063"></span>
<span class="line" id="L1064"> <span class="tok-kw">const</span> expected_panic_msgs_aligned = <span class="tok-kw">try</span> arena.alloc(<span class="tok-type">u32</span>, expected_panic_msgs.len);</span>
<span class="line" id="L1065"> <span class="tok-kw">for</span> (expected_panic_msgs_aligned, expected_panic_msgs) |*dest, src| dest.* = src;</span>
<span class="line" id="L1066"></span>
<span class="line" id="L1067"> prog_node.setEstimatedTotalItems(names.len);</span>
<span class="line" id="L1068"> metadata = .{</span>
<span class="line" id="L1069"> .string_bytes = <span class="tok-kw">try</span> arena.dupe(<span class="tok-type">u8</span>, string_bytes),</span>
<span class="line" id="L1070"> .names = names_aligned,</span>
<span class="line" id="L1071"> .async_frame_lens = async_frame_lens_aligned,</span>
<span class="line" id="L1072"> .expected_panic_msgs = expected_panic_msgs_aligned,</span>
<span class="line" id="L1073"> .next_index = <span class="tok-number">0</span>,</span>
<span class="line" id="L1074"> .prog_node = prog_node,</span>
<span class="line" id="L1075"> };</span>
<span class="line" id="L1076"></span>
<span class="line" id="L1077"> <span class="tok-kw">try</span> requestNextTest(child.stdin.?, &metadata.?, &sub_prog_node);</span>
<span class="line" id="L1078"> },</span>
<span class="line" id="L1079"> .test_results => {</span>
<span class="line" id="L1080"> <span class="tok-kw">const</span> md = metadata.?;</span>
<span class="line" id="L1081"></span>
<span class="line" id="L1082"> <span class="tok-kw">const</span> TrHdr = std.zig.Server.Message.TestResults;</span>
<span class="line" id="L1083"> <span class="tok-kw">const</span> tr_hdr = <span class="tok-builtin">@as</span>(*<span class="tok-kw">align</span>(<span class="tok-number">1</span>) <span class="tok-kw">const</span> TrHdr, <span class="tok-builtin">@ptrCast</span>(body));</span>
<span class="line" id="L1084"> fail_count += <span class="tok-builtin">@intFromBool</span>(tr_hdr.flags.fail);</span>
<span class="line" id="L1085"> skip_count += <span class="tok-builtin">@intFromBool</span>(tr_hdr.flags.skip);</span>
<span class="line" id="L1086"> leak_count += <span class="tok-builtin">@intFromBool</span>(tr_hdr.flags.leak);</span>
<span class="line" id="L1087"></span>
<span class="line" id="L1088"> <span class="tok-kw">if</span> (tr_hdr.flags.fail <span class="tok-kw">or</span> tr_hdr.flags.leak) {</span>
<span class="line" id="L1089"> <span class="tok-kw">const</span> name = std.mem.sliceTo(md.string_bytes[md.names[tr_hdr.index]..], <span class="tok-number">0</span>);</span>
<span class="line" id="L1090"> <span class="tok-kw">const</span> msg = std.mem.trim(<span class="tok-type">u8</span>, stderr.readableSlice(<span class="tok-number">0</span>), <span class="tok-str">"\n"</span>);</span>
<span class="line" id="L1091"> <span class="tok-kw">const</span> label = <span class="tok-kw">if</span> (tr_hdr.flags.fail) <span class="tok-str">"failed"</span> <span class="tok-kw">else</span> <span class="tok-str">"leaked"</span>;</span>
<span class="line" id="L1092"> <span class="tok-kw">if</span> (msg.len > <span class="tok-number">0</span>) {</span>
<span class="line" id="L1093"> <span class="tok-kw">try</span> self.step.addError(<span class="tok-str">"'{s}' {s}: {s}"</span>, .{ name, label, msg });</span>
<span class="line" id="L1094"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L1095"> <span class="tok-kw">try</span> self.step.addError(<span class="tok-str">"'{s}' {s}"</span>, .{ name, label });</span>
<span class="line" id="L1096"> }</span>
<span class="line" id="L1097"> stderr.discard(msg.len);</span>
<span class="line" id="L1098"> }</span>
<span class="line" id="L1099"></span>
<span class="line" id="L1100"> <span class="tok-kw">try</span> requestNextTest(child.stdin.?, &metadata.?, &sub_prog_node);</span>
<span class="line" id="L1101"> },</span>
<span class="line" id="L1102"> <span class="tok-kw">else</span> => {}, <span class="tok-comment">// ignore other messages</span>
</span>
<span class="line" id="L1103"> }</span>
<span class="line" id="L1104"></span>
<span class="line" id="L1105"> stdout.discard(body.len);</span>
<span class="line" id="L1106"> }</span>
<span class="line" id="L1107"></span>
<span class="line" id="L1108"> <span class="tok-kw">if</span> (stderr.readableLength() > <span class="tok-number">0</span>) {</span>
<span class="line" id="L1109"> <span class="tok-kw">const</span> msg = std.mem.trim(<span class="tok-type">u8</span>, <span class="tok-kw">try</span> stderr.toOwnedSlice(), <span class="tok-str">"\n"</span>);</span>
<span class="line" id="L1110"> <span class="tok-kw">if</span> (msg.len > <span class="tok-number">0</span>) <span class="tok-kw">try</span> self.step.result_error_msgs.append(arena, msg);</span>
<span class="line" id="L1111"> }</span>
<span class="line" id="L1112"></span>
<span class="line" id="L1113"> <span class="tok-comment">// Send EOF to stdin.</span>
</span>
<span class="line" id="L1114"> child.stdin.?.close();</span>
<span class="line" id="L1115"> child.stdin = <span class="tok-null">null</span>;</span>
<span class="line" id="L1116"></span>
<span class="line" id="L1117"> <span class="tok-kw">return</span> .{</span>
<span class="line" id="L1118"> .stdout = &.{},</span>
<span class="line" id="L1119"> .stderr = &.{},</span>
<span class="line" id="L1120"> .stdout_null = <span class="tok-null">true</span>,</span>
<span class="line" id="L1121"> .stderr_null = <span class="tok-null">true</span>,</span>
<span class="line" id="L1122"> .test_results = .{</span>
<span class="line" id="L1123"> .test_count = test_count,</span>
<span class="line" id="L1124"> .fail_count = fail_count,</span>
<span class="line" id="L1125"> .skip_count = skip_count,</span>
<span class="line" id="L1126"> .leak_count = leak_count,</span>
<span class="line" id="L1127"> },</span>
<span class="line" id="L1128"> .test_metadata = metadata,</span>
<span class="line" id="L1129"> };</span>
<span class="line" id="L1130">}</span>
<span class="line" id="L1131"></span>
<span class="line" id="L1132"><span class="tok-kw">const</span> TestMetadata = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L1133"> names: []<span class="tok-kw">const</span> <span class="tok-type">u32</span>,</span>
<span class="line" id="L1134"> async_frame_lens: []<span class="tok-kw">const</span> <span class="tok-type">u32</span>,</span>
<span class="line" id="L1135"> expected_panic_msgs: []<span class="tok-kw">const</span> <span class="tok-type">u32</span>,</span>
<span class="line" id="L1136"> string_bytes: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L1137"> next_index: <span class="tok-type">u32</span>,</span>
<span class="line" id="L1138"> prog_node: *std.Progress.Node,</span>
<span class="line" id="L1139"></span>
<span class="line" id="L1140"> <span class="tok-kw">fn</span> <span class="tok-fn">testName</span>(tm: TestMetadata, index: <span class="tok-type">u32</span>) []<span class="tok-kw">const</span> <span class="tok-type">u8</span> {</span>
<span class="line" id="L1141"> <span class="tok-kw">return</span> std.mem.sliceTo(tm.string_bytes[tm.names[index]..], <span class="tok-number">0</span>);</span>
<span class="line" id="L1142"> }</span>
<span class="line" id="L1143">};</span>
<span class="line" id="L1144"></span>
<span class="line" id="L1145"><span class="tok-kw">fn</span> <span class="tok-fn">requestNextTest</span>(in: fs.File, metadata: *TestMetadata, sub_prog_node: *?std.Progress.Node) !<span class="tok-type">void</span> {</span>
<span class="line" id="L1146"> <span class="tok-kw">while</span> (metadata.next_index < metadata.names.len) {</span>
<span class="line" id="L1147"> <span class="tok-kw">const</span> i = metadata.next_index;</span>
<span class="line" id="L1148"> metadata.next_index += <span class="tok-number">1</span>;</span>
<span class="line" id="L1149"></span>
<span class="line" id="L1150"> <span class="tok-kw">if</span> (metadata.async_frame_lens[i] != <span class="tok-number">0</span>) <span class="tok-kw">continue</span>;</span>
<span class="line" id="L1151"> <span class="tok-kw">if</span> (metadata.expected_panic_msgs[i] != <span class="tok-number">0</span>) <span class="tok-kw">continue</span>;</span>
<span class="line" id="L1152"></span>
<span class="line" id="L1153"> <span class="tok-kw">const</span> name = metadata.testName(i);</span>
<span class="line" id="L1154"> <span class="tok-kw">if</span> (sub_prog_node.*) |*n| n.end();</span>
<span class="line" id="L1155"> sub_prog_node.* = metadata.prog_node.start(name, <span class="tok-number">0</span>);</span>
<span class="line" id="L1156"></span>
<span class="line" id="L1157"> <span class="tok-kw">try</span> sendRunTestMessage(in, i);</span>
<span class="line" id="L1158"> <span class="tok-kw">return</span>;</span>
<span class="line" id="L1159"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L1160"> <span class="tok-kw">try</span> sendMessage(in, .exit);</span>
<span class="line" id="L1161"> }</span>
<span class="line" id="L1162">}</span>
<span class="line" id="L1163"></span>
<span class="line" id="L1164"><span class="tok-kw">fn</span> <span class="tok-fn">sendMessage</span>(file: std.fs.File, tag: std.zig.Client.Message.Tag) !<span class="tok-type">void</span> {</span>
<span class="line" id="L1165"> <span class="tok-kw">const</span> header: std.zig.Client.Message.Header = .{</span>
<span class="line" id="L1166"> .tag = tag,</span>
<span class="line" id="L1167"> .bytes_len = <span class="tok-number">0</span>,</span>
<span class="line" id="L1168"> };</span>
<span class="line" id="L1169"> <span class="tok-kw">try</span> file.writeAll(std.mem.asBytes(&header));</span>
<span class="line" id="L1170">}</span>
<span class="line" id="L1171"></span>
<span class="line" id="L1172"><span class="tok-kw">fn</span> <span class="tok-fn">sendRunTestMessage</span>(file: std.fs.File, index: <span class="tok-type">u32</span>) !<span class="tok-type">void</span> {</span>
<span class="line" id="L1173"> <span class="tok-kw">const</span> header: std.zig.Client.Message.Header = .{</span>
<span class="line" id="L1174"> .tag = .run_test,</span>
<span class="line" id="L1175"> .bytes_len = <span class="tok-number">4</span>,</span>
<span class="line" id="L1176"> };</span>
<span class="line" id="L1177"> <span class="tok-kw">const</span> full_msg = std.mem.asBytes(&header) ++ std.mem.asBytes(&index);</span>
<span class="line" id="L1178"> <span class="tok-kw">try</span> file.writeAll(full_msg);</span>
<span class="line" id="L1179">}</span>
<span class="line" id="L1180"></span>
<span class="line" id="L1181"><span class="tok-kw">fn</span> <span class="tok-fn">evalGeneric</span>(self: *Run, child: *std.process.Child) !StdIoResult {</span>
<span class="line" id="L1182"> <span class="tok-kw">const</span> arena = self.step.owner.allocator;</span>
<span class="line" id="L1183"></span>
<span class="line" id="L1184"> <span class="tok-kw">switch</span> (self.stdin) {</span>
<span class="line" id="L1185"> .bytes => |bytes| {</span>
<span class="line" id="L1186"> child.stdin.?.writeAll(bytes) <span class="tok-kw">catch</span> |err| {</span>
<span class="line" id="L1187"> <span class="tok-kw">return</span> self.step.fail(<span class="tok-str">"unable to write stdin: {s}"</span>, .{<span class="tok-builtin">@errorName</span>(err)});</span>
<span class="line" id="L1188"> };</span>
<span class="line" id="L1189"> child.stdin.?.close();</span>
<span class="line" id="L1190"> child.stdin = <span class="tok-null">null</span>;</span>
<span class="line" id="L1191"> },</span>
<span class="line" id="L1192"> .file_source => |file_source| {</span>
<span class="line" id="L1193"> <span class="tok-kw">const</span> path = file_source.getPath(self.step.owner);</span>
<span class="line" id="L1194"> <span class="tok-kw">const</span> file = self.step.owner.build_root.handle.openFile(path, .{}) <span class="tok-kw">catch</span> |err| {</span>
<span class="line" id="L1195"> <span class="tok-kw">return</span> self.step.fail(<span class="tok-str">"unable to open stdin file: {s}"</span>, .{<span class="tok-builtin">@errorName</span>(err)});</span>
<span class="line" id="L1196"> };</span>
<span class="line" id="L1197"> <span class="tok-kw">defer</span> file.close();</span>
<span class="line" id="L1198"> child.stdin.?.writeFileAll(file, .{}) <span class="tok-kw">catch</span> |err| {</span>
<span class="line" id="L1199"> <span class="tok-kw">return</span> self.step.fail(<span class="tok-str">"unable to write file to stdin: {s}"</span>, .{<span class="tok-builtin">@errorName</span>(err)});</span>
<span class="line" id="L1200"> };</span>
<span class="line" id="L1201"> child.stdin.?.close();</span>
<span class="line" id="L1202"> child.stdin = <span class="tok-null">null</span>;</span>
<span class="line" id="L1203"> },</span>
<span class="line" id="L1204"> .none => {},</span>
<span class="line" id="L1205"> }</span>
<span class="line" id="L1206"></span>
<span class="line" id="L1207"> <span class="tok-comment">// These are not optionals, as a workaround for</span>
</span>
<span class="line" id="L1208"> <span class="tok-comment">// https://github.com/ziglang/zig/issues/14783</span>
</span>
<span class="line" id="L1209"> <span class="tok-kw">var</span> stdout_bytes: []<span class="tok-kw">const</span> <span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L1210"> <span class="tok-kw">var</span> stderr_bytes: []<span class="tok-kw">const</span> <span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L1211"> <span class="tok-kw">var</span> stdout_null = <span class="tok-null">true</span>;</span>
<span class="line" id="L1212"> <span class="tok-kw">var</span> stderr_null = <span class="tok-null">true</span>;</span>
<span class="line" id="L1213"></span>
<span class="line" id="L1214"> <span class="tok-kw">if</span> (child.stdout) |stdout| {</span>
<span class="line" id="L1215"> <span class="tok-kw">if</span> (child.stderr) |stderr| {</span>
<span class="line" id="L1216"> <span class="tok-kw">var</span> poller = std.io.poll(arena, <span class="tok-kw">enum</span> { stdout, stderr }, .{</span>
<span class="line" id="L1217"> .stdout = stdout,</span>
<span class="line" id="L1218"> .stderr = stderr,</span>
<span class="line" id="L1219"> });</span>
<span class="line" id="L1220"> <span class="tok-kw">defer</span> poller.deinit();</span>
<span class="line" id="L1221"></span>
<span class="line" id="L1222"> <span class="tok-kw">while</span> (<span class="tok-kw">try</span> poller.poll()) {</span>
<span class="line" id="L1223"> <span class="tok-kw">if</span> (poller.fifo(.stdout).count > self.max_stdio_size)</span>
<span class="line" id="L1224"> <span class="tok-kw">return</span> <span class="tok-kw">error</span>.StdoutStreamTooLong;</span>
<span class="line" id="L1225"> <span class="tok-kw">if</span> (poller.fifo(.stderr).count > self.max_stdio_size)</span>
<span class="line" id="L1226"> <span class="tok-kw">return</span> <span class="tok-kw">error</span>.StderrStreamTooLong;</span>
<span class="line" id="L1227"> }</span>
<span class="line" id="L1228"></span>
<span class="line" id="L1229"> stdout_bytes = <span class="tok-kw">try</span> poller.fifo(.stdout).toOwnedSlice();</span>
<span class="line" id="L1230"> stderr_bytes = <span class="tok-kw">try</span> poller.fifo(.stderr).toOwnedSlice();</span>
<span class="line" id="L1231"> stdout_null = <span class="tok-null">false</span>;</span>
<span class="line" id="L1232"> stderr_null = <span class="tok-null">false</span>;</span>
<span class="line" id="L1233"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L1234"> stdout_bytes = <span class="tok-kw">try</span> stdout.reader().readAllAlloc(arena, self.max_stdio_size);</span>
<span class="line" id="L1235"> stdout_null = <span class="tok-null">false</span>;</span>
<span class="line" id="L1236"> }</span>
<span class="line" id="L1237"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (child.stderr) |stderr| {</span>
<span class="line" id="L1238"> stderr_bytes = <span class="tok-kw">try</span> stderr.reader().readAllAlloc(arena, self.max_stdio_size);</span>
<span class="line" id="L1239"> stderr_null = <span class="tok-null">false</span>;</span>
<span class="line" id="L1240"> }</span>
<span class="line" id="L1241"></span>
<span class="line" id="L1242"> <span class="tok-kw">if</span> (!stderr_null <span class="tok-kw">and</span> stderr_bytes.len > <span class="tok-number">0</span>) {</span>
<span class="line" id="L1243"> <span class="tok-comment">// Treat stderr as an error message.</span>
</span>
<span class="line" id="L1244"> <span class="tok-kw">const</span> stderr_is_diagnostic = self.captured_stderr == <span class="tok-null">null</span> <span class="tok-kw">and</span> <span class="tok-kw">switch</span> (self.stdio) {</span>
<span class="line" id="L1245"> .check => |checks| !checksContainStderr(checks.items),</span>
<span class="line" id="L1246"> <span class="tok-kw">else</span> => <span class="tok-null">true</span>,</span>
<span class="line" id="L1247"> };</span>
<span class="line" id="L1248"> <span class="tok-kw">if</span> (stderr_is_diagnostic) {</span>
<span class="line" id="L1249"> <span class="tok-kw">try</span> self.step.result_error_msgs.append(arena, stderr_bytes);</span>
<span class="line" id="L1250"> }</span>
<span class="line" id="L1251"> }</span>
<span class="line" id="L1252"></span>
<span class="line" id="L1253"> <span class="tok-kw">return</span> .{</span>
<span class="line" id="L1254"> .stdout = stdout_bytes,</span>
<span class="line" id="L1255"> .stderr = stderr_bytes,</span>
<span class="line" id="L1256"> .stdout_null = stdout_null,</span>
<span class="line" id="L1257"> .stderr_null = stderr_null,</span>
<span class="line" id="L1258"> .test_results = .{},</span>
<span class="line" id="L1259"> .test_metadata = <span class="tok-null">null</span>,</span>
<span class="line" id="L1260"> };</span>
<span class="line" id="L1261">}</span>
<span class="line" id="L1262"></span>
<span class="line" id="L1263"><span class="tok-kw">fn</span> <span class="tok-fn">addPathForDynLibs</span>(self: *Run, artifact: *Step.Compile) <span class="tok-type">void</span> {</span>
<span class="line" id="L1264"> <span class="tok-kw">const</span> b = self.step.owner;</span>
<span class="line" id="L1265"> <span class="tok-kw">for</span> (artifact.link_objects.items) |link_object| {</span>
<span class="line" id="L1266"> <span class="tok-kw">switch</span> (link_object) {</span>
<span class="line" id="L1267"> .other_step => |other| {</span>
<span class="line" id="L1268"> <span class="tok-kw">if</span> (other.target.isWindows() <span class="tok-kw">and</span> other.isDynamicLibrary()) {</span>
<span class="line" id="L1269"> addPathDir(self, fs.path.dirname(other.getOutputSource().getPath(b)).?);</span>
<span class="line" id="L1270"> addPathForDynLibs(self, other);</span>
<span class="line" id="L1271"> }</span>
<span class="line" id="L1272"> },</span>
<span class="line" id="L1273"> <span class="tok-kw">else</span> => {},</span>
<span class="line" id="L1274"> }</span>
<span class="line" id="L1275"> }</span>
<span class="line" id="L1276">}</span>
<span class="line" id="L1277"></span>
<span class="line" id="L1278"><span class="tok-kw">fn</span> <span class="tok-fn">failForeign</span>(</span>
<span class="line" id="L1279"> self: *Run,</span>
<span class="line" id="L1280"> suggested_flag: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L1281"> argv0: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L1282"> exe: *Step.Compile,</span>
<span class="line" id="L1283">) <span class="tok-kw">error</span>{ MakeFailed, MakeSkipped, OutOfMemory } {</span>
<span class="line" id="L1284"> <span class="tok-kw">switch</span> (self.stdio) {</span>
<span class="line" id="L1285"> .check, .zig_test => {</span>
<span class="line" id="L1286"> <span class="tok-kw">if</span> (self.skip_foreign_checks)</span>
<span class="line" id="L1287"> <span class="tok-kw">return</span> <span class="tok-kw">error</span>.MakeSkipped;</span>
<span class="line" id="L1288"></span>
<span class="line" id="L1289"> <span class="tok-kw">const</span> b = self.step.owner;</span>
<span class="line" id="L1290"> <span class="tok-kw">const</span> host_name = <span class="tok-kw">try</span> b.host.target.zigTriple(b.allocator);</span>
<span class="line" id="L1291"> <span class="tok-kw">const</span> foreign_name = <span class="tok-kw">try</span> exe.target.zigTriple(b.allocator);</span>
<span class="line" id="L1292"></span>
<span class="line" id="L1293"> <span class="tok-kw">return</span> self.step.fail(</span>
<span class="line" id="L1294"> <span class="tok-str">\\unable to spawn foreign binary '{s}' ({s}) on host system ({s})</span></span>
<span class="line" id="L1295"> <span class="tok-str">\\ consider using {s} or enabling skip_foreign_checks in the Run step</span></span>
<span class="line" id="L1296"> , .{ argv0, foreign_name, host_name, suggested_flag });</span>
<span class="line" id="L1297"> },</span>
<span class="line" id="L1298"> <span class="tok-kw">else</span> => {</span>
<span class="line" id="L1299"> <span class="tok-kw">return</span> self.step.fail(<span class="tok-str">"unable to spawn foreign binary '{s}'"</span>, .{argv0});</span>
<span class="line" id="L1300"> },</span>
<span class="line" id="L1301"> }</span>
<span class="line" id="L1302">}</span>
<span class="line" id="L1303"></span>
<span class="line" id="L1304"><span class="tok-kw">fn</span> <span class="tok-fn">hashStdIo</span>(hh: *std.Build.Cache.HashHelper, stdio: StdIo) <span class="tok-type">void</span> {</span>
<span class="line" id="L1305"> <span class="tok-kw">switch</span> (stdio) {</span>
<span class="line" id="L1306"> .infer_from_args, .inherit, .zig_test => {},</span>
<span class="line" id="L1307"> .check => |checks| <span class="tok-kw">for</span> (checks.items) |check| {</span>
<span class="line" id="L1308"> hh.add(<span class="tok-builtin">@as</span>(std.meta.Tag(StdIo.Check), check));</span>
<span class="line" id="L1309"> <span class="tok-kw">switch</span> (check) {</span>
<span class="line" id="L1310"> .expect_stderr_exact,</span>
<span class="line" id="L1311"> .expect_stderr_match,</span>
<span class="line" id="L1312"> .expect_stdout_exact,</span>
<span class="line" id="L1313"> .expect_stdout_match,</span>
<span class="line" id="L1314"> => |s| hh.addBytes(s),</span>
<span class="line" id="L1315"></span>
<span class="line" id="L1316"> .expect_term => |term| {</span>
<span class="line" id="L1317"> hh.add(<span class="tok-builtin">@as</span>(std.meta.Tag(std.process.Child.Term), term));</span>
<span class="line" id="L1318"> <span class="tok-kw">switch</span> (term) {</span>
<span class="line" id="L1319"> .Exited => |x| hh.add(x),</span>
<span class="line" id="L1320"> .Signal, .Stopped, .Unknown => |x| hh.add(x),</span>
<span class="line" id="L1321"> }</span>
<span class="line" id="L1322"> },</span>
<span class="line" id="L1323"> }</span>
<span class="line" id="L1324"> },</span>
<span class="line" id="L1325"> }</span>
<span class="line" id="L1326">}</span>
<span class="line" id="L1327"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std/Build | repos/yazap/docs/src/std/Build/Step/ConfigHeader.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>Build/Step/ConfigHeader.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"std"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> ConfigHeader = <span class="tok-builtin">@This</span>();</span>
<span class="line" id="L3"><span class="tok-kw">const</span> Step = std.Build.Step;</span>
<span class="line" id="L4"><span class="tok-kw">const</span> Allocator = std.mem.Allocator;</span>
<span class="line" id="L5"></span>
<span class="line" id="L6"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> Style = <span class="tok-kw">union</span>(<span class="tok-kw">enum</span>) {</span>
<span class="line" id="L7"> <span class="tok-comment">/// The configure format supported by autotools. It uses `#undef foo` to</span></span>
<span class="line" id="L8"> <span class="tok-comment">/// mark lines that can be substituted with different values.</span></span>
<span class="line" id="L9"> autoconf: std.Build.FileSource,</span>
<span class="line" id="L10"> <span class="tok-comment">/// The configure format supported by CMake. It uses `@@FOO@@` and</span></span>
<span class="line" id="L11"> <span class="tok-comment">/// `#cmakedefine` for template substitution.</span></span>
<span class="line" id="L12"> cmake: std.Build.FileSource,</span>
<span class="line" id="L13"> <span class="tok-comment">/// Instead of starting with an input file, start with nothing.</span></span>
<span class="line" id="L14"> blank,</span>
<span class="line" id="L15"> <span class="tok-comment">/// Start with nothing, like blank, and output a nasm .asm file.</span></span>
<span class="line" id="L16"> nasm,</span>
<span class="line" id="L17"></span>
<span class="line" id="L18"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">getFileSource</span>(style: Style) ?std.Build.FileSource {</span>
<span class="line" id="L19"> <span class="tok-kw">switch</span> (style) {</span>
<span class="line" id="L20"> .autoconf, .cmake => |s| <span class="tok-kw">return</span> s,</span>
<span class="line" id="L21"> .blank, .nasm => <span class="tok-kw">return</span> <span class="tok-null">null</span>,</span>
<span class="line" id="L22"> }</span>
<span class="line" id="L23"> }</span>
<span class="line" id="L24">};</span>
<span class="line" id="L25"></span>
<span class="line" id="L26"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> Value = <span class="tok-kw">union</span>(<span class="tok-kw">enum</span>) {</span>
<span class="line" id="L27"> undef,</span>
<span class="line" id="L28"> defined,</span>
<span class="line" id="L29"> boolean: <span class="tok-type">bool</span>,</span>
<span class="line" id="L30"> int: <span class="tok-type">i64</span>,</span>
<span class="line" id="L31"> ident: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L32"> string: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L33">};</span>
<span class="line" id="L34"></span>
<span class="line" id="L35">step: Step,</span>
<span class="line" id="L36">values: std.StringArrayHashMap(Value),</span>
<span class="line" id="L37">output_file: std.Build.GeneratedFile,</span>
<span class="line" id="L38"></span>
<span class="line" id="L39">style: Style,</span>
<span class="line" id="L40">max_bytes: <span class="tok-type">usize</span>,</span>
<span class="line" id="L41">include_path: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L42"></span>
<span class="line" id="L43"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> base_id: Step.Id = .config_header;</span>
<span class="line" id="L44"></span>
<span class="line" id="L45"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> Options = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L46"> style: Style = .blank,</span>
<span class="line" id="L47"> max_bytes: <span class="tok-type">usize</span> = <span class="tok-number">2</span> * <span class="tok-number">1024</span> * <span class="tok-number">1024</span>,</span>
<span class="line" id="L48"> include_path: ?[]<span class="tok-kw">const</span> <span class="tok-type">u8</span> = <span class="tok-null">null</span>,</span>
<span class="line" id="L49"> first_ret_addr: ?<span class="tok-type">usize</span> = <span class="tok-null">null</span>,</span>
<span class="line" id="L50">};</span>
<span class="line" id="L51"></span>
<span class="line" id="L52"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">create</span>(owner: *std.Build, options: Options) *ConfigHeader {</span>
<span class="line" id="L53"> <span class="tok-kw">const</span> self = owner.allocator.create(ConfigHeader) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L54"></span>
<span class="line" id="L55"> <span class="tok-kw">var</span> include_path: []<span class="tok-kw">const</span> <span class="tok-type">u8</span> = <span class="tok-str">"config.h"</span>;</span>
<span class="line" id="L56"></span>
<span class="line" id="L57"> <span class="tok-kw">if</span> (options.style.getFileSource()) |s| <span class="tok-kw">switch</span> (s) {</span>
<span class="line" id="L58"> .path => |p| {</span>
<span class="line" id="L59"> <span class="tok-kw">const</span> basename = std.fs.path.basename(p);</span>
<span class="line" id="L60"> <span class="tok-kw">if</span> (std.mem.endsWith(<span class="tok-type">u8</span>, basename, <span class="tok-str">".h.in"</span>)) {</span>
<span class="line" id="L61"> include_path = basename[<span class="tok-number">0</span> .. basename.len - <span class="tok-number">3</span>];</span>
<span class="line" id="L62"> }</span>
<span class="line" id="L63"> },</span>
<span class="line" id="L64"> <span class="tok-kw">else</span> => {},</span>
<span class="line" id="L65"> };</span>
<span class="line" id="L66"></span>
<span class="line" id="L67"> <span class="tok-kw">if</span> (options.include_path) |p| {</span>
<span class="line" id="L68"> include_path = p;</span>
<span class="line" id="L69"> }</span>
<span class="line" id="L70"></span>
<span class="line" id="L71"> <span class="tok-kw">const</span> name = <span class="tok-kw">if</span> (options.style.getFileSource()) |s|</span>
<span class="line" id="L72"> owner.fmt(<span class="tok-str">"configure {s} header {s} to {s}"</span>, .{</span>
<span class="line" id="L73"> <span class="tok-builtin">@tagName</span>(options.style), s.getDisplayName(), include_path,</span>
<span class="line" id="L74"> })</span>
<span class="line" id="L75"> <span class="tok-kw">else</span></span>
<span class="line" id="L76"> owner.fmt(<span class="tok-str">"configure {s} header to {s}"</span>, .{ <span class="tok-builtin">@tagName</span>(options.style), include_path });</span>
<span class="line" id="L77"></span>
<span class="line" id="L78"> self.* = .{</span>
<span class="line" id="L79"> .step = Step.init(.{</span>
<span class="line" id="L80"> .id = base_id,</span>
<span class="line" id="L81"> .name = name,</span>
<span class="line" id="L82"> .owner = owner,</span>
<span class="line" id="L83"> .makeFn = make,</span>
<span class="line" id="L84"> .first_ret_addr = options.first_ret_addr <span class="tok-kw">orelse</span> <span class="tok-builtin">@returnAddress</span>(),</span>
<span class="line" id="L85"> }),</span>
<span class="line" id="L86"> .style = options.style,</span>
<span class="line" id="L87"> .values = std.StringArrayHashMap(Value).init(owner.allocator),</span>
<span class="line" id="L88"></span>
<span class="line" id="L89"> .max_bytes = options.max_bytes,</span>
<span class="line" id="L90"> .include_path = include_path,</span>
<span class="line" id="L91"> .output_file = .{ .step = &self.step },</span>
<span class="line" id="L92"> };</span>
<span class="line" id="L93"></span>
<span class="line" id="L94"> <span class="tok-kw">return</span> self;</span>
<span class="line" id="L95">}</span>
<span class="line" id="L96"></span>
<span class="line" id="L97"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">addValues</span>(self: *ConfigHeader, values: <span class="tok-kw">anytype</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L98"> <span class="tok-kw">return</span> addValuesInner(self, values) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L99">}</span>
<span class="line" id="L100"></span>
<span class="line" id="L101"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">getFileSource</span>(self: *ConfigHeader) std.Build.FileSource {</span>
<span class="line" id="L102"> <span class="tok-kw">return</span> .{ .generated = &self.output_file };</span>
<span class="line" id="L103">}</span>
<span class="line" id="L104"></span>
<span class="line" id="L105"><span class="tok-kw">fn</span> <span class="tok-fn">addValuesInner</span>(self: *ConfigHeader, values: <span class="tok-kw">anytype</span>) !<span class="tok-type">void</span> {</span>
<span class="line" id="L106"> <span class="tok-kw">inline</span> <span class="tok-kw">for</span> (<span class="tok-builtin">@typeInfo</span>(<span class="tok-builtin">@TypeOf</span>(values)).Struct.fields) |field| {</span>
<span class="line" id="L107"> <span class="tok-kw">try</span> putValue(self, field.name, field.<span class="tok-type">type</span>, <span class="tok-builtin">@field</span>(values, field.name));</span>
<span class="line" id="L108"> }</span>
<span class="line" id="L109">}</span>
<span class="line" id="L110"></span>
<span class="line" id="L111"><span class="tok-kw">fn</span> <span class="tok-fn">putValue</span>(self: *ConfigHeader, field_name: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>, <span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>, v: T) !<span class="tok-type">void</span> {</span>
<span class="line" id="L112"> <span class="tok-kw">switch</span> (<span class="tok-builtin">@typeInfo</span>(T)) {</span>
<span class="line" id="L113"> .Null => {</span>
<span class="line" id="L114"> <span class="tok-kw">try</span> self.values.put(field_name, .undef);</span>
<span class="line" id="L115"> },</span>
<span class="line" id="L116"> .Void => {</span>
<span class="line" id="L117"> <span class="tok-kw">try</span> self.values.put(field_name, .defined);</span>
<span class="line" id="L118"> },</span>
<span class="line" id="L119"> .Bool => {</span>
<span class="line" id="L120"> <span class="tok-kw">try</span> self.values.put(field_name, .{ .boolean = v });</span>
<span class="line" id="L121"> },</span>
<span class="line" id="L122"> .Int => {</span>
<span class="line" id="L123"> <span class="tok-kw">try</span> self.values.put(field_name, .{ .int = v });</span>
<span class="line" id="L124"> },</span>
<span class="line" id="L125"> .ComptimeInt => {</span>
<span class="line" id="L126"> <span class="tok-kw">try</span> self.values.put(field_name, .{ .int = v });</span>
<span class="line" id="L127"> },</span>
<span class="line" id="L128"> .EnumLiteral => {</span>
<span class="line" id="L129"> <span class="tok-kw">try</span> self.values.put(field_name, .{ .ident = <span class="tok-builtin">@tagName</span>(v) });</span>
<span class="line" id="L130"> },</span>
<span class="line" id="L131"> .Optional => {</span>
<span class="line" id="L132"> <span class="tok-kw">if</span> (v) |x| {</span>
<span class="line" id="L133"> <span class="tok-kw">return</span> putValue(self, field_name, <span class="tok-builtin">@TypeOf</span>(x), x);</span>
<span class="line" id="L134"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L135"> <span class="tok-kw">try</span> self.values.put(field_name, .undef);</span>
<span class="line" id="L136"> }</span>
<span class="line" id="L137"> },</span>
<span class="line" id="L138"> .Pointer => |ptr| {</span>
<span class="line" id="L139"> <span class="tok-kw">switch</span> (<span class="tok-builtin">@typeInfo</span>(ptr.child)) {</span>
<span class="line" id="L140"> .Array => |array| {</span>
<span class="line" id="L141"> <span class="tok-kw">if</span> (ptr.size == .One <span class="tok-kw">and</span> array.child == <span class="tok-type">u8</span>) {</span>
<span class="line" id="L142"> <span class="tok-kw">try</span> self.values.put(field_name, .{ .string = v });</span>
<span class="line" id="L143"> <span class="tok-kw">return</span>;</span>
<span class="line" id="L144"> }</span>
<span class="line" id="L145"> },</span>
<span class="line" id="L146"> .Int => {</span>
<span class="line" id="L147"> <span class="tok-kw">if</span> (ptr.size == .Slice <span class="tok-kw">and</span> ptr.child == <span class="tok-type">u8</span>) {</span>
<span class="line" id="L148"> <span class="tok-kw">try</span> self.values.put(field_name, .{ .string = v });</span>
<span class="line" id="L149"> <span class="tok-kw">return</span>;</span>
<span class="line" id="L150"> }</span>
<span class="line" id="L151"> },</span>
<span class="line" id="L152"> <span class="tok-kw">else</span> => {},</span>
<span class="line" id="L153"> }</span>
<span class="line" id="L154"></span>
<span class="line" id="L155"> <span class="tok-builtin">@compileError</span>(<span class="tok-str">"unsupported ConfigHeader value type: "</span> ++ <span class="tok-builtin">@typeName</span>(T));</span>
<span class="line" id="L156"> },</span>
<span class="line" id="L157"> <span class="tok-kw">else</span> => <span class="tok-builtin">@compileError</span>(<span class="tok-str">"unsupported ConfigHeader value type: "</span> ++ <span class="tok-builtin">@typeName</span>(T)),</span>
<span class="line" id="L158"> }</span>
<span class="line" id="L159">}</span>
<span class="line" id="L160"></span>
<span class="line" id="L161"><span class="tok-kw">fn</span> <span class="tok-fn">make</span>(step: *Step, prog_node: *std.Progress.Node) !<span class="tok-type">void</span> {</span>
<span class="line" id="L162"> _ = prog_node;</span>
<span class="line" id="L163"> <span class="tok-kw">const</span> b = step.owner;</span>
<span class="line" id="L164"> <span class="tok-kw">const</span> self = <span class="tok-builtin">@fieldParentPtr</span>(ConfigHeader, <span class="tok-str">"step"</span>, step);</span>
<span class="line" id="L165"> <span class="tok-kw">const</span> gpa = b.allocator;</span>
<span class="line" id="L166"> <span class="tok-kw">const</span> arena = b.allocator;</span>
<span class="line" id="L167"></span>
<span class="line" id="L168"> <span class="tok-kw">var</span> man = b.cache.obtain();</span>
<span class="line" id="L169"> <span class="tok-kw">defer</span> man.deinit();</span>
<span class="line" id="L170"></span>
<span class="line" id="L171"> <span class="tok-comment">// Random bytes to make ConfigHeader unique. Refresh this with new</span>
</span>
<span class="line" id="L172"> <span class="tok-comment">// random bytes when ConfigHeader implementation is modified in a</span>
</span>
<span class="line" id="L173"> <span class="tok-comment">// non-backwards-compatible way.</span>
</span>
<span class="line" id="L174"> man.hash.add(<span class="tok-builtin">@as</span>(<span class="tok-type">u32</span>, <span class="tok-number">0xdef08d23</span>));</span>
<span class="line" id="L175"></span>
<span class="line" id="L176"> <span class="tok-kw">var</span> output = std.ArrayList(<span class="tok-type">u8</span>).init(gpa);</span>
<span class="line" id="L177"> <span class="tok-kw">defer</span> output.deinit();</span>
<span class="line" id="L178"></span>
<span class="line" id="L179"> <span class="tok-kw">const</span> header_text = <span class="tok-str">"This file was generated by ConfigHeader using the Zig Build System."</span>;</span>
<span class="line" id="L180"> <span class="tok-kw">const</span> c_generated_line = <span class="tok-str">"/* "</span> ++ header_text ++ <span class="tok-str">" */\n"</span>;</span>
<span class="line" id="L181"> <span class="tok-kw">const</span> asm_generated_line = <span class="tok-str">"; "</span> ++ header_text ++ <span class="tok-str">"\n"</span>;</span>
<span class="line" id="L182"></span>
<span class="line" id="L183"> <span class="tok-kw">switch</span> (self.style) {</span>
<span class="line" id="L184"> .autoconf => |file_source| {</span>
<span class="line" id="L185"> <span class="tok-kw">try</span> output.appendSlice(c_generated_line);</span>
<span class="line" id="L186"> <span class="tok-kw">const</span> src_path = file_source.getPath(b);</span>
<span class="line" id="L187"> <span class="tok-kw">const</span> contents = <span class="tok-kw">try</span> std.fs.cwd().readFileAlloc(arena, src_path, self.max_bytes);</span>
<span class="line" id="L188"> <span class="tok-kw">try</span> render_autoconf(step, contents, &output, self.values, src_path);</span>
<span class="line" id="L189"> },</span>
<span class="line" id="L190"> .cmake => |file_source| {</span>
<span class="line" id="L191"> <span class="tok-kw">try</span> output.appendSlice(c_generated_line);</span>
<span class="line" id="L192"> <span class="tok-kw">const</span> src_path = file_source.getPath(b);</span>
<span class="line" id="L193"> <span class="tok-kw">const</span> contents = <span class="tok-kw">try</span> std.fs.cwd().readFileAlloc(arena, src_path, self.max_bytes);</span>
<span class="line" id="L194"> <span class="tok-kw">try</span> render_cmake(step, contents, &output, self.values, src_path);</span>
<span class="line" id="L195"> },</span>
<span class="line" id="L196"> .blank => {</span>
<span class="line" id="L197"> <span class="tok-kw">try</span> output.appendSlice(c_generated_line);</span>
<span class="line" id="L198"> <span class="tok-kw">try</span> render_blank(&output, self.values, self.include_path);</span>
<span class="line" id="L199"> },</span>
<span class="line" id="L200"> .nasm => {</span>
<span class="line" id="L201"> <span class="tok-kw">try</span> output.appendSlice(asm_generated_line);</span>
<span class="line" id="L202"> <span class="tok-kw">try</span> render_nasm(&output, self.values);</span>
<span class="line" id="L203"> },</span>
<span class="line" id="L204"> }</span>
<span class="line" id="L205"></span>
<span class="line" id="L206"> man.hash.addBytes(output.items);</span>
<span class="line" id="L207"></span>
<span class="line" id="L208"> <span class="tok-kw">if</span> (<span class="tok-kw">try</span> step.cacheHit(&man)) {</span>
<span class="line" id="L209"> <span class="tok-kw">const</span> digest = man.final();</span>
<span class="line" id="L210"> self.output_file.path = <span class="tok-kw">try</span> b.cache_root.join(arena, &.{</span>
<span class="line" id="L211"> <span class="tok-str">"o"</span>, &digest, self.include_path,</span>
<span class="line" id="L212"> });</span>
<span class="line" id="L213"> <span class="tok-kw">return</span>;</span>
<span class="line" id="L214"> }</span>
<span class="line" id="L215"></span>
<span class="line" id="L216"> <span class="tok-kw">const</span> digest = man.final();</span>
<span class="line" id="L217"></span>
<span class="line" id="L218"> <span class="tok-comment">// If output_path has directory parts, deal with them. Example:</span>
</span>
<span class="line" id="L219"> <span class="tok-comment">// output_dir is zig-cache/o/HASH</span>
</span>
<span class="line" id="L220"> <span class="tok-comment">// output_path is libavutil/avconfig.h</span>
</span>
<span class="line" id="L221"> <span class="tok-comment">// We want to open directory zig-cache/o/HASH/libavutil/</span>
</span>
<span class="line" id="L222"> <span class="tok-comment">// but keep output_dir as zig-cache/o/HASH for -I include</span>
</span>
<span class="line" id="L223"> <span class="tok-kw">const</span> sub_path = <span class="tok-kw">try</span> std.fs.path.join(arena, &.{ <span class="tok-str">"o"</span>, &digest, self.include_path });</span>
<span class="line" id="L224"> <span class="tok-kw">const</span> sub_path_dirname = std.fs.path.dirname(sub_path).?;</span>
<span class="line" id="L225"></span>
<span class="line" id="L226"> b.cache_root.handle.makePath(sub_path_dirname) <span class="tok-kw">catch</span> |err| {</span>
<span class="line" id="L227"> <span class="tok-kw">return</span> step.fail(<span class="tok-str">"unable to make path '{}{s}': {s}"</span>, .{</span>
<span class="line" id="L228"> b.cache_root, sub_path_dirname, <span class="tok-builtin">@errorName</span>(err),</span>
<span class="line" id="L229"> });</span>
<span class="line" id="L230"> };</span>
<span class="line" id="L231"></span>
<span class="line" id="L232"> b.cache_root.handle.writeFile(sub_path, output.items) <span class="tok-kw">catch</span> |err| {</span>
<span class="line" id="L233"> <span class="tok-kw">return</span> step.fail(<span class="tok-str">"unable to write file '{}{s}': {s}"</span>, .{</span>
<span class="line" id="L234"> b.cache_root, sub_path, <span class="tok-builtin">@errorName</span>(err),</span>
<span class="line" id="L235"> });</span>
<span class="line" id="L236"> };</span>
<span class="line" id="L237"></span>
<span class="line" id="L238"> self.output_file.path = <span class="tok-kw">try</span> b.cache_root.join(arena, &.{sub_path});</span>
<span class="line" id="L239"> <span class="tok-kw">try</span> man.writeManifest();</span>
<span class="line" id="L240">}</span>
<span class="line" id="L241"></span>
<span class="line" id="L242"><span class="tok-kw">fn</span> <span class="tok-fn">render_autoconf</span>(</span>
<span class="line" id="L243"> step: *Step,</span>
<span class="line" id="L244"> contents: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L245"> output: *std.ArrayList(<span class="tok-type">u8</span>),</span>
<span class="line" id="L246"> values: std.StringArrayHashMap(Value),</span>
<span class="line" id="L247"> src_path: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L248">) !<span class="tok-type">void</span> {</span>
<span class="line" id="L249"> <span class="tok-kw">var</span> values_copy = <span class="tok-kw">try</span> values.clone();</span>
<span class="line" id="L250"> <span class="tok-kw">defer</span> values_copy.deinit();</span>
<span class="line" id="L251"></span>
<span class="line" id="L252"> <span class="tok-kw">var</span> any_errors = <span class="tok-null">false</span>;</span>
<span class="line" id="L253"> <span class="tok-kw">var</span> line_index: <span class="tok-type">u32</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L254"> <span class="tok-kw">var</span> line_it = std.mem.splitScalar(<span class="tok-type">u8</span>, contents, <span class="tok-str">'\n'</span>);</span>
<span class="line" id="L255"> <span class="tok-kw">while</span> (line_it.next()) |line| : (line_index += <span class="tok-number">1</span>) {</span>
<span class="line" id="L256"> <span class="tok-kw">if</span> (!std.mem.startsWith(<span class="tok-type">u8</span>, line, <span class="tok-str">"#"</span>)) {</span>
<span class="line" id="L257"> <span class="tok-kw">try</span> output.appendSlice(line);</span>
<span class="line" id="L258"> <span class="tok-kw">try</span> output.appendSlice(<span class="tok-str">"\n"</span>);</span>
<span class="line" id="L259"> <span class="tok-kw">continue</span>;</span>
<span class="line" id="L260"> }</span>
<span class="line" id="L261"> <span class="tok-kw">var</span> it = std.mem.tokenizeAny(<span class="tok-type">u8</span>, line[<span class="tok-number">1</span>..], <span class="tok-str">" \t\r"</span>);</span>
<span class="line" id="L262"> <span class="tok-kw">const</span> undef = it.next().?;</span>
<span class="line" id="L263"> <span class="tok-kw">if</span> (!std.mem.eql(<span class="tok-type">u8</span>, undef, <span class="tok-str">"undef"</span>)) {</span>
<span class="line" id="L264"> <span class="tok-kw">try</span> output.appendSlice(line);</span>
<span class="line" id="L265"> <span class="tok-kw">try</span> output.appendSlice(<span class="tok-str">"\n"</span>);</span>
<span class="line" id="L266"> <span class="tok-kw">continue</span>;</span>
<span class="line" id="L267"> }</span>
<span class="line" id="L268"> <span class="tok-kw">const</span> name = it.rest();</span>
<span class="line" id="L269"> <span class="tok-kw">const</span> kv = values_copy.fetchSwapRemove(name) <span class="tok-kw">orelse</span> {</span>
<span class="line" id="L270"> <span class="tok-kw">try</span> step.addError(<span class="tok-str">"{s}:{d}: error: unspecified config header value: '{s}'"</span>, .{</span>
<span class="line" id="L271"> src_path, line_index + <span class="tok-number">1</span>, name,</span>
<span class="line" id="L272"> });</span>
<span class="line" id="L273"> any_errors = <span class="tok-null">true</span>;</span>
<span class="line" id="L274"> <span class="tok-kw">continue</span>;</span>
<span class="line" id="L275"> };</span>
<span class="line" id="L276"> <span class="tok-kw">try</span> renderValueC(output, name, kv.value);</span>
<span class="line" id="L277"> }</span>
<span class="line" id="L278"></span>
<span class="line" id="L279"> <span class="tok-kw">for</span> (values_copy.keys()) |name| {</span>
<span class="line" id="L280"> <span class="tok-kw">try</span> step.addError(<span class="tok-str">"{s}: error: config header value unused: '{s}'"</span>, .{ src_path, name });</span>
<span class="line" id="L281"> any_errors = <span class="tok-null">true</span>;</span>
<span class="line" id="L282"> }</span>
<span class="line" id="L283"></span>
<span class="line" id="L284"> <span class="tok-kw">if</span> (any_errors) {</span>
<span class="line" id="L285"> <span class="tok-kw">return</span> <span class="tok-kw">error</span>.MakeFailed;</span>
<span class="line" id="L286"> }</span>
<span class="line" id="L287">}</span>
<span class="line" id="L288"></span>
<span class="line" id="L289"><span class="tok-kw">fn</span> <span class="tok-fn">render_cmake</span>(</span>
<span class="line" id="L290"> step: *Step,</span>
<span class="line" id="L291"> contents: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L292"> output: *std.ArrayList(<span class="tok-type">u8</span>),</span>
<span class="line" id="L293"> values: std.StringArrayHashMap(Value),</span>
<span class="line" id="L294"> src_path: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L295">) !<span class="tok-type">void</span> {</span>
<span class="line" id="L296"> <span class="tok-kw">var</span> build = step.owner;</span>
<span class="line" id="L297"> <span class="tok-kw">var</span> allocator = build.allocator;</span>
<span class="line" id="L298"></span>
<span class="line" id="L299"> <span class="tok-kw">var</span> values_copy = <span class="tok-kw">try</span> values.clone();</span>
<span class="line" id="L300"> <span class="tok-kw">defer</span> values_copy.deinit();</span>
<span class="line" id="L301"></span>
<span class="line" id="L302"> <span class="tok-kw">var</span> any_errors = <span class="tok-null">false</span>;</span>
<span class="line" id="L303"> <span class="tok-kw">var</span> line_index: <span class="tok-type">u32</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L304"> <span class="tok-kw">var</span> line_it = std.mem.splitScalar(<span class="tok-type">u8</span>, contents, <span class="tok-str">'\n'</span>);</span>
<span class="line" id="L305"> <span class="tok-kw">while</span> (line_it.next()) |raw_line| : (line_index += <span class="tok-number">1</span>) {</span>
<span class="line" id="L306"> <span class="tok-kw">const</span> last_line = line_it.index == line_it.buffer.len;</span>
<span class="line" id="L307"></span>
<span class="line" id="L308"> <span class="tok-kw">const</span> first_pass = replace_variables(allocator, raw_line, values, <span class="tok-str">"@"</span>, <span class="tok-str">"@"</span>) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"Failed to substitute"</span>);</span>
<span class="line" id="L309"> <span class="tok-kw">const</span> line = replace_variables(allocator, first_pass, values, <span class="tok-str">"${"</span>, <span class="tok-str">"}"</span>) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"Failed to substitute"</span>);</span>
<span class="line" id="L310"></span>
<span class="line" id="L311"> allocator.free(first_pass);</span>
<span class="line" id="L312"> <span class="tok-kw">defer</span> allocator.free(line);</span>
<span class="line" id="L313"></span>
<span class="line" id="L314"> <span class="tok-kw">if</span> (!std.mem.startsWith(<span class="tok-type">u8</span>, line, <span class="tok-str">"#"</span>)) {</span>
<span class="line" id="L315"> <span class="tok-kw">try</span> output.appendSlice(line);</span>
<span class="line" id="L316"> <span class="tok-kw">if</span> (!last_line) {</span>
<span class="line" id="L317"> <span class="tok-kw">try</span> output.appendSlice(<span class="tok-str">"\n"</span>);</span>
<span class="line" id="L318"> }</span>
<span class="line" id="L319"> <span class="tok-kw">continue</span>;</span>
<span class="line" id="L320"> }</span>
<span class="line" id="L321"> <span class="tok-kw">var</span> it = std.mem.tokenizeAny(<span class="tok-type">u8</span>, line[<span class="tok-number">1</span>..], <span class="tok-str">" \t\r"</span>);</span>
<span class="line" id="L322"> <span class="tok-kw">const</span> cmakedefine = it.next().?;</span>
<span class="line" id="L323"> <span class="tok-kw">if</span> (!std.mem.eql(<span class="tok-type">u8</span>, cmakedefine, <span class="tok-str">"cmakedefine"</span>) <span class="tok-kw">and</span></span>
<span class="line" id="L324"> !std.mem.eql(<span class="tok-type">u8</span>, cmakedefine, <span class="tok-str">"cmakedefine01"</span>))</span>
<span class="line" id="L325"> {</span>
<span class="line" id="L326"> <span class="tok-kw">try</span> output.appendSlice(line);</span>
<span class="line" id="L327"> <span class="tok-kw">if</span> (!last_line) {</span>
<span class="line" id="L328"> <span class="tok-kw">try</span> output.appendSlice(<span class="tok-str">"\n"</span>);</span>
<span class="line" id="L329"> }</span>
<span class="line" id="L330"> <span class="tok-kw">continue</span>;</span>
<span class="line" id="L331"> }</span>
<span class="line" id="L332"></span>
<span class="line" id="L333"> <span class="tok-kw">const</span> booldefine = std.mem.eql(<span class="tok-type">u8</span>, cmakedefine, <span class="tok-str">"cmakedefine01"</span>);</span>
<span class="line" id="L334"></span>
<span class="line" id="L335"> <span class="tok-kw">const</span> name = it.next() <span class="tok-kw">orelse</span> {</span>
<span class="line" id="L336"> <span class="tok-kw">try</span> step.addError(<span class="tok-str">"{s}:{d}: error: missing define name"</span>, .{</span>
<span class="line" id="L337"> src_path, line_index + <span class="tok-number">1</span>,</span>
<span class="line" id="L338"> });</span>
<span class="line" id="L339"> any_errors = <span class="tok-null">true</span>;</span>
<span class="line" id="L340"> <span class="tok-kw">continue</span>;</span>
<span class="line" id="L341"> };</span>
<span class="line" id="L342"> <span class="tok-kw">var</span> value = values_copy.get(name) <span class="tok-kw">orelse</span> blk: {</span>
<span class="line" id="L343"> <span class="tok-kw">if</span> (booldefine) {</span>
<span class="line" id="L344"> <span class="tok-kw">break</span> :blk Value{ .int = <span class="tok-number">0</span> };</span>
<span class="line" id="L345"> }</span>
<span class="line" id="L346"> <span class="tok-kw">break</span> :blk Value.undef;</span>
<span class="line" id="L347"> };</span>
<span class="line" id="L348"></span>
<span class="line" id="L349"> value = blk: {</span>
<span class="line" id="L350"> <span class="tok-kw">switch</span> (value) {</span>
<span class="line" id="L351"> .boolean => |b| {</span>
<span class="line" id="L352"> <span class="tok-kw">if</span> (!b) {</span>
<span class="line" id="L353"> <span class="tok-kw">break</span> :blk Value.undef;</span>
<span class="line" id="L354"> }</span>
<span class="line" id="L355"> },</span>
<span class="line" id="L356"> .int => |i| {</span>
<span class="line" id="L357"> <span class="tok-kw">if</span> (i == <span class="tok-number">0</span>) {</span>
<span class="line" id="L358"> <span class="tok-kw">break</span> :blk Value.undef;</span>
<span class="line" id="L359"> }</span>
<span class="line" id="L360"> },</span>
<span class="line" id="L361"> .string => |string| {</span>
<span class="line" id="L362"> <span class="tok-kw">if</span> (string.len == <span class="tok-number">0</span>) {</span>
<span class="line" id="L363"> <span class="tok-kw">break</span> :blk Value.undef;</span>
<span class="line" id="L364"> }</span>
<span class="line" id="L365"> },</span>
<span class="line" id="L366"></span>
<span class="line" id="L367"> <span class="tok-kw">else</span> => {</span>
<span class="line" id="L368"> <span class="tok-kw">break</span> :blk value;</span>
<span class="line" id="L369"> },</span>
<span class="line" id="L370"> }</span>
<span class="line" id="L371"> };</span>
<span class="line" id="L372"></span>
<span class="line" id="L373"> <span class="tok-kw">if</span> (booldefine) {</span>
<span class="line" id="L374"> value = blk: {</span>
<span class="line" id="L375"> <span class="tok-kw">switch</span> (value) {</span>
<span class="line" id="L376"> .undef => {</span>
<span class="line" id="L377"> <span class="tok-kw">break</span> :blk Value{ .boolean = <span class="tok-null">false</span> };</span>
<span class="line" id="L378"> },</span>
<span class="line" id="L379"> .defined => {</span>
<span class="line" id="L380"> <span class="tok-kw">break</span> :blk Value{ .boolean = <span class="tok-null">false</span> };</span>
<span class="line" id="L381"> },</span>
<span class="line" id="L382"> .boolean => |b| {</span>
<span class="line" id="L383"> <span class="tok-kw">break</span> :blk Value{ .boolean = b };</span>
<span class="line" id="L384"> },</span>
<span class="line" id="L385"> .int => |i| {</span>
<span class="line" id="L386"> <span class="tok-kw">break</span> :blk Value{ .boolean = i != <span class="tok-number">0</span> };</span>
<span class="line" id="L387"> },</span>
<span class="line" id="L388"> .string => |string| {</span>
<span class="line" id="L389"> <span class="tok-kw">break</span> :blk Value{ .boolean = string.len != <span class="tok-number">0</span> };</span>
<span class="line" id="L390"> },</span>
<span class="line" id="L391"></span>
<span class="line" id="L392"> <span class="tok-kw">else</span> => {</span>
<span class="line" id="L393"> <span class="tok-kw">break</span> :blk Value{ .boolean = <span class="tok-null">false</span> };</span>
<span class="line" id="L394"> },</span>
<span class="line" id="L395"> }</span>
<span class="line" id="L396"> };</span>
<span class="line" id="L397"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (value != Value.undef) {</span>
<span class="line" id="L398"> value = Value{ .ident = it.rest() };</span>
<span class="line" id="L399"> }</span>
<span class="line" id="L400"></span>
<span class="line" id="L401"> <span class="tok-kw">try</span> renderValueC(output, name, value);</span>
<span class="line" id="L402"> }</span>
<span class="line" id="L403"></span>
<span class="line" id="L404"> <span class="tok-kw">if</span> (any_errors) {</span>
<span class="line" id="L405"> <span class="tok-kw">return</span> <span class="tok-kw">error</span>.HeaderConfigFailed;</span>
<span class="line" id="L406"> }</span>
<span class="line" id="L407">}</span>
<span class="line" id="L408"></span>
<span class="line" id="L409"><span class="tok-kw">fn</span> <span class="tok-fn">render_blank</span>(</span>
<span class="line" id="L410"> output: *std.ArrayList(<span class="tok-type">u8</span>),</span>
<span class="line" id="L411"> defines: std.StringArrayHashMap(Value),</span>
<span class="line" id="L412"> include_path: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L413">) !<span class="tok-type">void</span> {</span>
<span class="line" id="L414"> <span class="tok-kw">const</span> include_guard_name = <span class="tok-kw">try</span> output.allocator.dupe(<span class="tok-type">u8</span>, include_path);</span>
<span class="line" id="L415"> <span class="tok-kw">for</span> (include_guard_name) |*byte| {</span>
<span class="line" id="L416"> <span class="tok-kw">switch</span> (byte.*) {</span>
<span class="line" id="L417"> <span class="tok-str">'a'</span>...<span class="tok-str">'z'</span> => byte.* = byte.* - <span class="tok-str">'a'</span> + <span class="tok-str">'A'</span>,</span>
<span class="line" id="L418"> <span class="tok-str">'A'</span>...<span class="tok-str">'Z'</span>, <span class="tok-str">'0'</span>...<span class="tok-str">'9'</span> => <span class="tok-kw">continue</span>,</span>
<span class="line" id="L419"> <span class="tok-kw">else</span> => byte.* = <span class="tok-str">'_'</span>,</span>
<span class="line" id="L420"> }</span>
<span class="line" id="L421"> }</span>
<span class="line" id="L422"></span>
<span class="line" id="L423"> <span class="tok-kw">try</span> output.appendSlice(<span class="tok-str">"#ifndef "</span>);</span>
<span class="line" id="L424"> <span class="tok-kw">try</span> output.appendSlice(include_guard_name);</span>
<span class="line" id="L425"> <span class="tok-kw">try</span> output.appendSlice(<span class="tok-str">"\n#define "</span>);</span>
<span class="line" id="L426"> <span class="tok-kw">try</span> output.appendSlice(include_guard_name);</span>
<span class="line" id="L427"> <span class="tok-kw">try</span> output.appendSlice(<span class="tok-str">"\n"</span>);</span>
<span class="line" id="L428"></span>
<span class="line" id="L429"> <span class="tok-kw">const</span> values = defines.values();</span>
<span class="line" id="L430"> <span class="tok-kw">for</span> (defines.keys(), <span class="tok-number">0</span>..) |name, i| {</span>
<span class="line" id="L431"> <span class="tok-kw">try</span> renderValueC(output, name, values[i]);</span>
<span class="line" id="L432"> }</span>
<span class="line" id="L433"></span>
<span class="line" id="L434"> <span class="tok-kw">try</span> output.appendSlice(<span class="tok-str">"#endif /* "</span>);</span>
<span class="line" id="L435"> <span class="tok-kw">try</span> output.appendSlice(include_guard_name);</span>
<span class="line" id="L436"> <span class="tok-kw">try</span> output.appendSlice(<span class="tok-str">" */\n"</span>);</span>
<span class="line" id="L437">}</span>
<span class="line" id="L438"></span>
<span class="line" id="L439"><span class="tok-kw">fn</span> <span class="tok-fn">render_nasm</span>(output: *std.ArrayList(<span class="tok-type">u8</span>), defines: std.StringArrayHashMap(Value)) !<span class="tok-type">void</span> {</span>
<span class="line" id="L440"> <span class="tok-kw">const</span> values = defines.values();</span>
<span class="line" id="L441"> <span class="tok-kw">for</span> (defines.keys(), <span class="tok-number">0</span>..) |name, i| {</span>
<span class="line" id="L442"> <span class="tok-kw">try</span> renderValueNasm(output, name, values[i]);</span>
<span class="line" id="L443"> }</span>
<span class="line" id="L444">}</span>
<span class="line" id="L445"></span>
<span class="line" id="L446"><span class="tok-kw">fn</span> <span class="tok-fn">renderValueC</span>(output: *std.ArrayList(<span class="tok-type">u8</span>), name: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>, value: Value) !<span class="tok-type">void</span> {</span>
<span class="line" id="L447"> <span class="tok-kw">switch</span> (value) {</span>
<span class="line" id="L448"> .undef => {</span>
<span class="line" id="L449"> <span class="tok-kw">try</span> output.appendSlice(<span class="tok-str">"/* #undef "</span>);</span>
<span class="line" id="L450"> <span class="tok-kw">try</span> output.appendSlice(name);</span>
<span class="line" id="L451"> <span class="tok-kw">try</span> output.appendSlice(<span class="tok-str">" */\n"</span>);</span>
<span class="line" id="L452"> },</span>
<span class="line" id="L453"> .defined => {</span>
<span class="line" id="L454"> <span class="tok-kw">try</span> output.appendSlice(<span class="tok-str">"#define "</span>);</span>
<span class="line" id="L455"> <span class="tok-kw">try</span> output.appendSlice(name);</span>
<span class="line" id="L456"> <span class="tok-kw">try</span> output.appendSlice(<span class="tok-str">"\n"</span>);</span>
<span class="line" id="L457"> },</span>
<span class="line" id="L458"> .boolean => |b| {</span>
<span class="line" id="L459"> <span class="tok-kw">try</span> output.appendSlice(<span class="tok-str">"#define "</span>);</span>
<span class="line" id="L460"> <span class="tok-kw">try</span> output.appendSlice(name);</span>
<span class="line" id="L461"> <span class="tok-kw">try</span> output.appendSlice(<span class="tok-kw">if</span> (b) <span class="tok-str">" 1\n"</span> <span class="tok-kw">else</span> <span class="tok-str">" 0\n"</span>);</span>
<span class="line" id="L462"> },</span>
<span class="line" id="L463"> .int => |i| {</span>
<span class="line" id="L464"> <span class="tok-kw">try</span> output.writer().print(<span class="tok-str">"#define {s} {d}\n"</span>, .{ name, i });</span>
<span class="line" id="L465"> },</span>
<span class="line" id="L466"> .ident => |ident| {</span>
<span class="line" id="L467"> <span class="tok-kw">try</span> output.writer().print(<span class="tok-str">"#define {s} {s}\n"</span>, .{ name, ident });</span>
<span class="line" id="L468"> },</span>
<span class="line" id="L469"> .string => |string| {</span>
<span class="line" id="L470"> <span class="tok-comment">// TODO: use C-specific escaping instead of zig string literals</span>
</span>
<span class="line" id="L471"> <span class="tok-kw">try</span> output.writer().print(<span class="tok-str">"#define {s} \"{}\"\n"</span>, .{ name, std.zig.fmtEscapes(string) });</span>
<span class="line" id="L472"> },</span>
<span class="line" id="L473"> }</span>
<span class="line" id="L474">}</span>
<span class="line" id="L475"></span>
<span class="line" id="L476"><span class="tok-kw">fn</span> <span class="tok-fn">renderValueNasm</span>(output: *std.ArrayList(<span class="tok-type">u8</span>), name: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>, value: Value) !<span class="tok-type">void</span> {</span>
<span class="line" id="L477"> <span class="tok-kw">switch</span> (value) {</span>
<span class="line" id="L478"> .undef => {</span>
<span class="line" id="L479"> <span class="tok-kw">try</span> output.appendSlice(<span class="tok-str">"; %undef "</span>);</span>
<span class="line" id="L480"> <span class="tok-kw">try</span> output.appendSlice(name);</span>
<span class="line" id="L481"> <span class="tok-kw">try</span> output.appendSlice(<span class="tok-str">"\n"</span>);</span>
<span class="line" id="L482"> },</span>
<span class="line" id="L483"> .defined => {</span>
<span class="line" id="L484"> <span class="tok-kw">try</span> output.appendSlice(<span class="tok-str">"%define "</span>);</span>
<span class="line" id="L485"> <span class="tok-kw">try</span> output.appendSlice(name);</span>
<span class="line" id="L486"> <span class="tok-kw">try</span> output.appendSlice(<span class="tok-str">"\n"</span>);</span>
<span class="line" id="L487"> },</span>
<span class="line" id="L488"> .boolean => |b| {</span>
<span class="line" id="L489"> <span class="tok-kw">try</span> output.appendSlice(<span class="tok-str">"%define "</span>);</span>
<span class="line" id="L490"> <span class="tok-kw">try</span> output.appendSlice(name);</span>
<span class="line" id="L491"> <span class="tok-kw">try</span> output.appendSlice(<span class="tok-kw">if</span> (b) <span class="tok-str">" 1\n"</span> <span class="tok-kw">else</span> <span class="tok-str">" 0\n"</span>);</span>
<span class="line" id="L492"> },</span>
<span class="line" id="L493"> .int => |i| {</span>
<span class="line" id="L494"> <span class="tok-kw">try</span> output.writer().print(<span class="tok-str">"%define {s} {d}\n"</span>, .{ name, i });</span>
<span class="line" id="L495"> },</span>
<span class="line" id="L496"> .ident => |ident| {</span>
<span class="line" id="L497"> <span class="tok-kw">try</span> output.writer().print(<span class="tok-str">"%define {s} {s}\n"</span>, .{ name, ident });</span>
<span class="line" id="L498"> },</span>
<span class="line" id="L499"> .string => |string| {</span>
<span class="line" id="L500"> <span class="tok-comment">// TODO: use nasm-specific escaping instead of zig string literals</span>
</span>
<span class="line" id="L501"> <span class="tok-kw">try</span> output.writer().print(<span class="tok-str">"%define {s} \"{}\"\n"</span>, .{ name, std.zig.fmtEscapes(string) });</span>
<span class="line" id="L502"> },</span>
<span class="line" id="L503"> }</span>
<span class="line" id="L504">}</span>
<span class="line" id="L505"></span>
<span class="line" id="L506"><span class="tok-kw">fn</span> <span class="tok-fn">replace_variables</span>(</span>
<span class="line" id="L507"> allocator: Allocator,</span>
<span class="line" id="L508"> contents: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L509"> values: std.StringArrayHashMap(Value),</span>
<span class="line" id="L510"> prefix: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L511"> suffix: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L512">) ![]<span class="tok-kw">const</span> <span class="tok-type">u8</span> {</span>
<span class="line" id="L513"> <span class="tok-kw">var</span> content_buf = allocator.dupe(<span class="tok-type">u8</span>, contents) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L514"></span>
<span class="line" id="L515"> <span class="tok-kw">var</span> last_index: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L516"> <span class="tok-kw">while</span> (std.mem.indexOfPos(<span class="tok-type">u8</span>, content_buf, last_index, prefix)) |prefix_index| {</span>
<span class="line" id="L517"> <span class="tok-kw">const</span> start_index = prefix_index + prefix.len;</span>
<span class="line" id="L518"> <span class="tok-kw">if</span> (std.mem.indexOfPos(<span class="tok-type">u8</span>, content_buf, start_index, suffix)) |suffix_index| {</span>
<span class="line" id="L519"> <span class="tok-kw">const</span> end_index = suffix_index + suffix.len;</span>
<span class="line" id="L520"></span>
<span class="line" id="L521"> <span class="tok-kw">const</span> beginline = content_buf[<span class="tok-number">0</span>..prefix_index];</span>
<span class="line" id="L522"> <span class="tok-kw">const</span> endline = content_buf[end_index..];</span>
<span class="line" id="L523"> <span class="tok-kw">const</span> key = content_buf[start_index..suffix_index];</span>
<span class="line" id="L524"> <span class="tok-kw">const</span> value = values.get(key) <span class="tok-kw">orelse</span> .undef;</span>
<span class="line" id="L525"></span>
<span class="line" id="L526"> <span class="tok-kw">switch</span> (value) {</span>
<span class="line" id="L527"> .boolean => |b| {</span>
<span class="line" id="L528"> <span class="tok-kw">const</span> buf = <span class="tok-kw">try</span> std.fmt.allocPrint(allocator, <span class="tok-str">"{s}{}{s}"</span>, .{ beginline, <span class="tok-builtin">@intFromBool</span>(b), endline });</span>
<span class="line" id="L529"> last_index = start_index + <span class="tok-number">1</span>;</span>
<span class="line" id="L530"></span>
<span class="line" id="L531"> allocator.free(content_buf);</span>
<span class="line" id="L532"> content_buf = buf;</span>
<span class="line" id="L533"> },</span>
<span class="line" id="L534"> .int => |i| {</span>
<span class="line" id="L535"> <span class="tok-kw">const</span> buf = <span class="tok-kw">try</span> std.fmt.allocPrint(allocator, <span class="tok-str">"{s}{}{s}"</span>, .{ beginline, i, endline });</span>
<span class="line" id="L536"> <span class="tok-kw">const</span> isNegative = i < <span class="tok-number">0</span>;</span>
<span class="line" id="L537"> <span class="tok-kw">const</span> digits = (<span class="tok-kw">if</span> (<span class="tok-number">0</span> < i) std.math.log10(std.math.absCast(i)) <span class="tok-kw">else</span> <span class="tok-number">0</span>) + <span class="tok-number">1</span>;</span>
<span class="line" id="L538"> last_index = start_index + <span class="tok-builtin">@intFromBool</span>(isNegative) + digits + <span class="tok-number">1</span>;</span>
<span class="line" id="L539"></span>
<span class="line" id="L540"> allocator.free(content_buf);</span>
<span class="line" id="L541"> content_buf = buf;</span>
<span class="line" id="L542"> },</span>
<span class="line" id="L543"> .string => |string| {</span>
<span class="line" id="L544"> <span class="tok-kw">const</span> buf = <span class="tok-kw">try</span> std.fmt.allocPrint(allocator, <span class="tok-str">"{s}{s}{s}"</span>, .{ beginline, string, endline });</span>
<span class="line" id="L545"> last_index = start_index + string.len + <span class="tok-number">1</span>;</span>
<span class="line" id="L546"></span>
<span class="line" id="L547"> allocator.free(content_buf);</span>
<span class="line" id="L548"> content_buf = buf;</span>
<span class="line" id="L549"> },</span>
<span class="line" id="L550"></span>
<span class="line" id="L551"> <span class="tok-kw">else</span> => {</span>
<span class="line" id="L552"> <span class="tok-kw">const</span> buf = <span class="tok-kw">try</span> std.fmt.allocPrint(allocator, <span class="tok-str">"{s}{s}"</span>, .{ beginline, endline });</span>
<span class="line" id="L553"> last_index = start_index + <span class="tok-number">1</span>;</span>
<span class="line" id="L554"></span>
<span class="line" id="L555"> allocator.free(content_buf);</span>
<span class="line" id="L556"> content_buf = buf;</span>
<span class="line" id="L557"> },</span>
<span class="line" id="L558"> }</span>
<span class="line" id="L559"> <span class="tok-kw">continue</span>;</span>
<span class="line" id="L560"> }</span>
<span class="line" id="L561"></span>
<span class="line" id="L562"> last_index = start_index + <span class="tok-number">1</span>;</span>
<span class="line" id="L563"> }</span>
<span class="line" id="L564"></span>
<span class="line" id="L565"> <span class="tok-kw">return</span> content_buf;</span>
<span class="line" id="L566">}</span>
<span class="line" id="L567"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std/Build | repos/yazap/docs/src/std/Build/Step/CheckFile.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>Build/Step/CheckFile.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-comment">//! Fail the build step if a file does not match certain checks.</span></span>
<span class="line" id="L2"><span class="tok-comment">//! TODO: make this more flexible, supporting more kinds of checks.</span></span>
<span class="line" id="L3"><span class="tok-comment">//! TODO: generalize the code in std.testing.expectEqualStrings and make this</span></span>
<span class="line" id="L4"><span class="tok-comment">//! CheckFile step produce those helpful diagnostics when there is not a match.</span></span>
<span class="line" id="L5"><span class="tok-kw">const</span> CheckFile = <span class="tok-builtin">@This</span>();</span>
<span class="line" id="L6"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"std"</span>);</span>
<span class="line" id="L7"><span class="tok-kw">const</span> Step = std.Build.Step;</span>
<span class="line" id="L8"><span class="tok-kw">const</span> fs = std.fs;</span>
<span class="line" id="L9"><span class="tok-kw">const</span> mem = std.mem;</span>
<span class="line" id="L10"></span>
<span class="line" id="L11">step: Step,</span>
<span class="line" id="L12">expected_matches: []<span class="tok-kw">const</span> []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L13">expected_exact: ?[]<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L14">source: std.Build.FileSource,</span>
<span class="line" id="L15">max_bytes: <span class="tok-type">usize</span> = <span class="tok-number">20</span> * <span class="tok-number">1024</span> * <span class="tok-number">1024</span>,</span>
<span class="line" id="L16"></span>
<span class="line" id="L17"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> base_id = .check_file;</span>
<span class="line" id="L18"></span>
<span class="line" id="L19"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> Options = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L20"> expected_matches: []<span class="tok-kw">const</span> []<span class="tok-kw">const</span> <span class="tok-type">u8</span> = &.{},</span>
<span class="line" id="L21"> expected_exact: ?[]<span class="tok-kw">const</span> <span class="tok-type">u8</span> = <span class="tok-null">null</span>,</span>
<span class="line" id="L22">};</span>
<span class="line" id="L23"></span>
<span class="line" id="L24"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">create</span>(</span>
<span class="line" id="L25"> owner: *std.Build,</span>
<span class="line" id="L26"> source: std.Build.FileSource,</span>
<span class="line" id="L27"> options: Options,</span>
<span class="line" id="L28">) *CheckFile {</span>
<span class="line" id="L29"> <span class="tok-kw">const</span> self = owner.allocator.create(CheckFile) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"OOM"</span>);</span>
<span class="line" id="L30"> self.* = .{</span>
<span class="line" id="L31"> .step = Step.init(.{</span>
<span class="line" id="L32"> .id = .check_file,</span>
<span class="line" id="L33"> .name = <span class="tok-str">"CheckFile"</span>,</span>
<span class="line" id="L34"> .owner = owner,</span>
<span class="line" id="L35"> .makeFn = make,</span>
<span class="line" id="L36"> }),</span>
<span class="line" id="L37"> .source = source.dupe(owner),</span>
<span class="line" id="L38"> .expected_matches = owner.dupeStrings(options.expected_matches),</span>
<span class="line" id="L39"> .expected_exact = options.expected_exact,</span>
<span class="line" id="L40"> };</span>
<span class="line" id="L41"> self.source.addStepDependencies(&self.step);</span>
<span class="line" id="L42"> <span class="tok-kw">return</span> self;</span>
<span class="line" id="L43">}</span>
<span class="line" id="L44"></span>
<span class="line" id="L45"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">setName</span>(self: *CheckFile, name: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L46"> self.step.name = name;</span>
<span class="line" id="L47">}</span>
<span class="line" id="L48"></span>
<span class="line" id="L49"><span class="tok-kw">fn</span> <span class="tok-fn">make</span>(step: *Step, prog_node: *std.Progress.Node) !<span class="tok-type">void</span> {</span>
<span class="line" id="L50"> _ = prog_node;</span>
<span class="line" id="L51"> <span class="tok-kw">const</span> b = step.owner;</span>
<span class="line" id="L52"> <span class="tok-kw">const</span> self = <span class="tok-builtin">@fieldParentPtr</span>(CheckFile, <span class="tok-str">"step"</span>, step);</span>
<span class="line" id="L53"></span>
<span class="line" id="L54"> <span class="tok-kw">const</span> src_path = self.source.getPath(b);</span>
<span class="line" id="L55"> <span class="tok-kw">const</span> contents = fs.cwd().readFileAlloc(b.allocator, src_path, self.max_bytes) <span class="tok-kw">catch</span> |err| {</span>
<span class="line" id="L56"> <span class="tok-kw">return</span> step.fail(<span class="tok-str">"unable to read '{s}': {s}"</span>, .{</span>
<span class="line" id="L57"> src_path, <span class="tok-builtin">@errorName</span>(err),</span>
<span class="line" id="L58"> });</span>
<span class="line" id="L59"> };</span>
<span class="line" id="L60"></span>
<span class="line" id="L61"> <span class="tok-kw">for</span> (self.expected_matches) |expected_match| {</span>
<span class="line" id="L62"> <span class="tok-kw">if</span> (mem.indexOf(<span class="tok-type">u8</span>, contents, expected_match) == <span class="tok-null">null</span>) {</span>
<span class="line" id="L63"> <span class="tok-kw">return</span> step.fail(</span>
<span class="line" id="L64"> <span class="tok-str">\\</span></span>
<span class="line" id="L65"> <span class="tok-str">\\========= expected to find: ===================</span></span>
<span class="line" id="L66"> <span class="tok-str">\\{s}</span></span>
<span class="line" id="L67"> <span class="tok-str">\\========= but file does not contain it: =======</span></span>
<span class="line" id="L68"> <span class="tok-str">\\{s}</span></span>
<span class="line" id="L69"> <span class="tok-str">\\===============================================</span></span>
<span class="line" id="L70"> , .{ expected_match, contents });</span>
<span class="line" id="L71"> }</span>
<span class="line" id="L72"> }</span>
<span class="line" id="L73"></span>
<span class="line" id="L74"> <span class="tok-kw">if</span> (self.expected_exact) |expected_exact| {</span>
<span class="line" id="L75"> <span class="tok-kw">if</span> (!mem.eql(<span class="tok-type">u8</span>, expected_exact, contents)) {</span>
<span class="line" id="L76"> <span class="tok-kw">return</span> step.fail(</span>
<span class="line" id="L77"> <span class="tok-str">\\</span></span>
<span class="line" id="L78"> <span class="tok-str">\\========= expected: =====================</span></span>
<span class="line" id="L79"> <span class="tok-str">\\{s}</span></span>
<span class="line" id="L80"> <span class="tok-str">\\========= but found: ====================</span></span>
<span class="line" id="L81"> <span class="tok-str">\\{s}</span></span>
<span class="line" id="L82"> <span class="tok-str">\\========= from the following file: ======</span></span>
<span class="line" id="L83"> <span class="tok-str">\\{s}</span></span>
<span class="line" id="L84"> , .{ expected_exact, contents, src_path });</span>
<span class="line" id="L85"> }</span>
<span class="line" id="L86"> }</span>
<span class="line" id="L87">}</span>
<span class="line" id="L88"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std/Build | repos/yazap/docs/src/std/Build/Cache/DepTokenizer.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>Build/Cache/DepTokenizer.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> Tokenizer = <span class="tok-builtin">@This</span>();</span>
<span class="line" id="L2"></span>
<span class="line" id="L3">index: <span class="tok-type">usize</span> = <span class="tok-number">0</span>,</span>
<span class="line" id="L4">bytes: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L5">state: State = .lhs,</span>
<span class="line" id="L6"></span>
<span class="line" id="L7"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"std"</span>);</span>
<span class="line" id="L8"><span class="tok-kw">const</span> testing = std.testing;</span>
<span class="line" id="L9"><span class="tok-kw">const</span> assert = std.debug.assert;</span>
<span class="line" id="L10"></span>
<span class="line" id="L11"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">next</span>(self: *Tokenizer) ?Token {</span>
<span class="line" id="L12"> <span class="tok-kw">var</span> start = self.index;</span>
<span class="line" id="L13"> <span class="tok-kw">var</span> must_resolve = <span class="tok-null">false</span>;</span>
<span class="line" id="L14"> <span class="tok-kw">while</span> (self.index < self.bytes.len) {</span>
<span class="line" id="L15"> <span class="tok-kw">const</span> char = self.bytes[self.index];</span>
<span class="line" id="L16"> <span class="tok-kw">switch</span> (self.state) {</span>
<span class="line" id="L17"> .lhs => <span class="tok-kw">switch</span> (char) {</span>
<span class="line" id="L18"> <span class="tok-str">'\t'</span>, <span class="tok-str">'\n'</span>, <span class="tok-str">'\r'</span>, <span class="tok-str">' '</span> => {</span>
<span class="line" id="L19"> <span class="tok-comment">// silently ignore whitespace</span>
</span>
<span class="line" id="L20"> self.index += <span class="tok-number">1</span>;</span>
<span class="line" id="L21"> },</span>
<span class="line" id="L22"> <span class="tok-kw">else</span> => {</span>
<span class="line" id="L23"> start = self.index;</span>
<span class="line" id="L24"> self.state = .target;</span>
<span class="line" id="L25"> },</span>
<span class="line" id="L26"> },</span>
<span class="line" id="L27"> .target => <span class="tok-kw">switch</span> (char) {</span>
<span class="line" id="L28"> <span class="tok-str">'\t'</span>, <span class="tok-str">'\n'</span>, <span class="tok-str">'\r'</span>, <span class="tok-str">' '</span> => {</span>
<span class="line" id="L29"> <span class="tok-kw">return</span> errorIllegalChar(.invalid_target, self.index, char);</span>
<span class="line" id="L30"> },</span>
<span class="line" id="L31"> <span class="tok-str">'$'</span> => {</span>
<span class="line" id="L32"> self.state = .target_dollar_sign;</span>
<span class="line" id="L33"> self.index += <span class="tok-number">1</span>;</span>
<span class="line" id="L34"> },</span>
<span class="line" id="L35"> <span class="tok-str">'\\'</span> => {</span>
<span class="line" id="L36"> self.state = .target_reverse_solidus;</span>
<span class="line" id="L37"> self.index += <span class="tok-number">1</span>;</span>
<span class="line" id="L38"> },</span>
<span class="line" id="L39"> <span class="tok-str">':'</span> => {</span>
<span class="line" id="L40"> self.state = .target_colon;</span>
<span class="line" id="L41"> self.index += <span class="tok-number">1</span>;</span>
<span class="line" id="L42"> },</span>
<span class="line" id="L43"> <span class="tok-kw">else</span> => {</span>
<span class="line" id="L44"> self.index += <span class="tok-number">1</span>;</span>
<span class="line" id="L45"> },</span>
<span class="line" id="L46"> },</span>
<span class="line" id="L47"> .target_reverse_solidus => <span class="tok-kw">switch</span> (char) {</span>
<span class="line" id="L48"> <span class="tok-str">'\t'</span>, <span class="tok-str">'\n'</span>, <span class="tok-str">'\r'</span> => {</span>
<span class="line" id="L49"> <span class="tok-kw">return</span> errorIllegalChar(.bad_target_escape, self.index, char);</span>
<span class="line" id="L50"> },</span>
<span class="line" id="L51"> <span class="tok-str">' '</span>, <span class="tok-str">'#'</span>, <span class="tok-str">'\\'</span> => {</span>
<span class="line" id="L52"> must_resolve = <span class="tok-null">true</span>;</span>
<span class="line" id="L53"> self.state = .target;</span>
<span class="line" id="L54"> self.index += <span class="tok-number">1</span>;</span>
<span class="line" id="L55"> },</span>
<span class="line" id="L56"> <span class="tok-str">'$'</span> => {</span>
<span class="line" id="L57"> self.state = .target_dollar_sign;</span>
<span class="line" id="L58"> self.index += <span class="tok-number">1</span>;</span>
<span class="line" id="L59"> },</span>
<span class="line" id="L60"> <span class="tok-kw">else</span> => {</span>
<span class="line" id="L61"> self.state = .target;</span>
<span class="line" id="L62"> self.index += <span class="tok-number">1</span>;</span>
<span class="line" id="L63"> },</span>
<span class="line" id="L64"> },</span>
<span class="line" id="L65"> .target_dollar_sign => <span class="tok-kw">switch</span> (char) {</span>
<span class="line" id="L66"> <span class="tok-str">'$'</span> => {</span>
<span class="line" id="L67"> must_resolve = <span class="tok-null">true</span>;</span>
<span class="line" id="L68"> self.state = .target;</span>
<span class="line" id="L69"> self.index += <span class="tok-number">1</span>;</span>
<span class="line" id="L70"> },</span>
<span class="line" id="L71"> <span class="tok-kw">else</span> => {</span>
<span class="line" id="L72"> <span class="tok-kw">return</span> errorIllegalChar(.expected_dollar_sign, self.index, char);</span>
<span class="line" id="L73"> },</span>
<span class="line" id="L74"> },</span>
<span class="line" id="L75"> .target_colon => <span class="tok-kw">switch</span> (char) {</span>
<span class="line" id="L76"> <span class="tok-str">'\n'</span>, <span class="tok-str">'\r'</span> => {</span>
<span class="line" id="L77"> <span class="tok-kw">const</span> bytes = self.bytes[start .. self.index - <span class="tok-number">1</span>];</span>
<span class="line" id="L78"> <span class="tok-kw">if</span> (bytes.len != <span class="tok-number">0</span>) {</span>
<span class="line" id="L79"> self.state = .lhs;</span>
<span class="line" id="L80"> <span class="tok-kw">return</span> finishTarget(must_resolve, bytes);</span>
<span class="line" id="L81"> }</span>
<span class="line" id="L82"> <span class="tok-comment">// silently ignore null target</span>
</span>
<span class="line" id="L83"> self.state = .lhs;</span>
<span class="line" id="L84"> },</span>
<span class="line" id="L85"> <span class="tok-str">'/'</span>, <span class="tok-str">'\\'</span> => {</span>
<span class="line" id="L86"> self.state = .target_colon_reverse_solidus;</span>
<span class="line" id="L87"> self.index += <span class="tok-number">1</span>;</span>
<span class="line" id="L88"> },</span>
<span class="line" id="L89"> <span class="tok-kw">else</span> => {</span>
<span class="line" id="L90"> <span class="tok-kw">const</span> bytes = self.bytes[start .. self.index - <span class="tok-number">1</span>];</span>
<span class="line" id="L91"> <span class="tok-kw">if</span> (bytes.len != <span class="tok-number">0</span>) {</span>
<span class="line" id="L92"> self.state = .rhs;</span>
<span class="line" id="L93"> <span class="tok-kw">return</span> finishTarget(must_resolve, bytes);</span>
<span class="line" id="L94"> }</span>
<span class="line" id="L95"> <span class="tok-comment">// silently ignore null target</span>
</span>
<span class="line" id="L96"> self.state = .lhs;</span>
<span class="line" id="L97"> },</span>
<span class="line" id="L98"> },</span>
<span class="line" id="L99"> .target_colon_reverse_solidus => <span class="tok-kw">switch</span> (char) {</span>
<span class="line" id="L100"> <span class="tok-str">'\n'</span>, <span class="tok-str">'\r'</span> => {</span>
<span class="line" id="L101"> <span class="tok-kw">const</span> bytes = self.bytes[start .. self.index - <span class="tok-number">2</span>];</span>
<span class="line" id="L102"> <span class="tok-kw">if</span> (bytes.len != <span class="tok-number">0</span>) {</span>
<span class="line" id="L103"> self.state = .lhs;</span>
<span class="line" id="L104"> <span class="tok-kw">return</span> finishTarget(must_resolve, bytes);</span>
<span class="line" id="L105"> }</span>
<span class="line" id="L106"> <span class="tok-comment">// silently ignore null target</span>
</span>
<span class="line" id="L107"> self.state = .lhs;</span>
<span class="line" id="L108"> },</span>
<span class="line" id="L109"> <span class="tok-kw">else</span> => {</span>
<span class="line" id="L110"> self.state = .target;</span>
<span class="line" id="L111"> },</span>
<span class="line" id="L112"> },</span>
<span class="line" id="L113"> .rhs => <span class="tok-kw">switch</span> (char) {</span>
<span class="line" id="L114"> <span class="tok-str">'\t'</span>, <span class="tok-str">' '</span> => {</span>
<span class="line" id="L115"> <span class="tok-comment">// silently ignore horizontal whitespace</span>
</span>
<span class="line" id="L116"> self.index += <span class="tok-number">1</span>;</span>
<span class="line" id="L117"> },</span>
<span class="line" id="L118"> <span class="tok-str">'\n'</span>, <span class="tok-str">'\r'</span> => {</span>
<span class="line" id="L119"> self.state = .lhs;</span>
<span class="line" id="L120"> },</span>
<span class="line" id="L121"> <span class="tok-str">'\\'</span> => {</span>
<span class="line" id="L122"> self.state = .rhs_continuation;</span>
<span class="line" id="L123"> self.index += <span class="tok-number">1</span>;</span>
<span class="line" id="L124"> },</span>
<span class="line" id="L125"> <span class="tok-str">'"'</span> => {</span>
<span class="line" id="L126"> self.state = .prereq_quote;</span>
<span class="line" id="L127"> self.index += <span class="tok-number">1</span>;</span>
<span class="line" id="L128"> start = self.index;</span>
<span class="line" id="L129"> },</span>
<span class="line" id="L130"> <span class="tok-kw">else</span> => {</span>
<span class="line" id="L131"> start = self.index;</span>
<span class="line" id="L132"> self.state = .prereq;</span>
<span class="line" id="L133"> },</span>
<span class="line" id="L134"> },</span>
<span class="line" id="L135"> .rhs_continuation => <span class="tok-kw">switch</span> (char) {</span>
<span class="line" id="L136"> <span class="tok-str">'\n'</span> => {</span>
<span class="line" id="L137"> self.state = .rhs;</span>
<span class="line" id="L138"> self.index += <span class="tok-number">1</span>;</span>
<span class="line" id="L139"> },</span>
<span class="line" id="L140"> <span class="tok-str">'\r'</span> => {</span>
<span class="line" id="L141"> self.state = .rhs_continuation_linefeed;</span>
<span class="line" id="L142"> self.index += <span class="tok-number">1</span>;</span>
<span class="line" id="L143"> },</span>
<span class="line" id="L144"> <span class="tok-kw">else</span> => {</span>
<span class="line" id="L145"> <span class="tok-kw">return</span> errorIllegalChar(.continuation_eol, self.index, char);</span>
<span class="line" id="L146"> },</span>
<span class="line" id="L147"> },</span>
<span class="line" id="L148"> .rhs_continuation_linefeed => <span class="tok-kw">switch</span> (char) {</span>
<span class="line" id="L149"> <span class="tok-str">'\n'</span> => {</span>
<span class="line" id="L150"> self.state = .rhs;</span>
<span class="line" id="L151"> self.index += <span class="tok-number">1</span>;</span>
<span class="line" id="L152"> },</span>
<span class="line" id="L153"> <span class="tok-kw">else</span> => {</span>
<span class="line" id="L154"> <span class="tok-kw">return</span> errorIllegalChar(.continuation_eol, self.index, char);</span>
<span class="line" id="L155"> },</span>
<span class="line" id="L156"> },</span>
<span class="line" id="L157"> .prereq_quote => <span class="tok-kw">switch</span> (char) {</span>
<span class="line" id="L158"> <span class="tok-str">'"'</span> => {</span>
<span class="line" id="L159"> self.index += <span class="tok-number">1</span>;</span>
<span class="line" id="L160"> self.state = .rhs;</span>
<span class="line" id="L161"> <span class="tok-kw">return</span> Token{ .prereq = self.bytes[start .. self.index - <span class="tok-number">1</span>] };</span>
<span class="line" id="L162"> },</span>
<span class="line" id="L163"> <span class="tok-kw">else</span> => {</span>
<span class="line" id="L164"> self.index += <span class="tok-number">1</span>;</span>
<span class="line" id="L165"> },</span>
<span class="line" id="L166"> },</span>
<span class="line" id="L167"> .prereq => <span class="tok-kw">switch</span> (char) {</span>
<span class="line" id="L168"> <span class="tok-str">'\t'</span>, <span class="tok-str">' '</span> => {</span>
<span class="line" id="L169"> self.state = .rhs;</span>
<span class="line" id="L170"> <span class="tok-kw">return</span> Token{ .prereq = self.bytes[start..self.index] };</span>
<span class="line" id="L171"> },</span>
<span class="line" id="L172"> <span class="tok-str">'\n'</span>, <span class="tok-str">'\r'</span> => {</span>
<span class="line" id="L173"> self.state = .lhs;</span>
<span class="line" id="L174"> <span class="tok-kw">return</span> Token{ .prereq = self.bytes[start..self.index] };</span>
<span class="line" id="L175"> },</span>
<span class="line" id="L176"> <span class="tok-str">'\\'</span> => {</span>
<span class="line" id="L177"> self.state = .prereq_continuation;</span>
<span class="line" id="L178"> self.index += <span class="tok-number">1</span>;</span>
<span class="line" id="L179"> },</span>
<span class="line" id="L180"> <span class="tok-kw">else</span> => {</span>
<span class="line" id="L181"> self.index += <span class="tok-number">1</span>;</span>
<span class="line" id="L182"> },</span>
<span class="line" id="L183"> },</span>
<span class="line" id="L184"> .prereq_continuation => <span class="tok-kw">switch</span> (char) {</span>
<span class="line" id="L185"> <span class="tok-str">'\n'</span> => {</span>
<span class="line" id="L186"> self.index += <span class="tok-number">1</span>;</span>
<span class="line" id="L187"> self.state = .rhs;</span>
<span class="line" id="L188"> <span class="tok-kw">return</span> Token{ .prereq = self.bytes[start .. self.index - <span class="tok-number">2</span>] };</span>
<span class="line" id="L189"> },</span>
<span class="line" id="L190"> <span class="tok-str">'\r'</span> => {</span>
<span class="line" id="L191"> self.state = .prereq_continuation_linefeed;</span>
<span class="line" id="L192"> self.index += <span class="tok-number">1</span>;</span>
<span class="line" id="L193"> },</span>
<span class="line" id="L194"> <span class="tok-kw">else</span> => {</span>
<span class="line" id="L195"> <span class="tok-comment">// not continuation</span>
</span>
<span class="line" id="L196"> self.state = .prereq;</span>
<span class="line" id="L197"> self.index += <span class="tok-number">1</span>;</span>
<span class="line" id="L198"> },</span>
<span class="line" id="L199"> },</span>
<span class="line" id="L200"> .prereq_continuation_linefeed => <span class="tok-kw">switch</span> (char) {</span>
<span class="line" id="L201"> <span class="tok-str">'\n'</span> => {</span>
<span class="line" id="L202"> self.index += <span class="tok-number">1</span>;</span>
<span class="line" id="L203"> self.state = .rhs;</span>
<span class="line" id="L204"> <span class="tok-kw">return</span> Token{ .prereq = self.bytes[start .. self.index - <span class="tok-number">1</span>] };</span>
<span class="line" id="L205"> },</span>
<span class="line" id="L206"> <span class="tok-kw">else</span> => {</span>
<span class="line" id="L207"> <span class="tok-kw">return</span> errorIllegalChar(.continuation_eol, self.index, char);</span>
<span class="line" id="L208"> },</span>
<span class="line" id="L209"> },</span>
<span class="line" id="L210"> }</span>
<span class="line" id="L211"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L212"> <span class="tok-kw">switch</span> (self.state) {</span>
<span class="line" id="L213"> .lhs,</span>
<span class="line" id="L214"> .rhs,</span>
<span class="line" id="L215"> .rhs_continuation,</span>
<span class="line" id="L216"> .rhs_continuation_linefeed,</span>
<span class="line" id="L217"> => <span class="tok-kw">return</span> <span class="tok-null">null</span>,</span>
<span class="line" id="L218"> .target => {</span>
<span class="line" id="L219"> <span class="tok-kw">return</span> errorPosition(.incomplete_target, start, self.bytes[start..]);</span>
<span class="line" id="L220"> },</span>
<span class="line" id="L221"> .target_reverse_solidus,</span>
<span class="line" id="L222"> .target_dollar_sign,</span>
<span class="line" id="L223"> => {</span>
<span class="line" id="L224"> <span class="tok-kw">const</span> idx = self.index - <span class="tok-number">1</span>;</span>
<span class="line" id="L225"> <span class="tok-kw">return</span> errorIllegalChar(.incomplete_escape, idx, self.bytes[idx]);</span>
<span class="line" id="L226"> },</span>
<span class="line" id="L227"> .target_colon => {</span>
<span class="line" id="L228"> <span class="tok-kw">const</span> bytes = self.bytes[start .. self.index - <span class="tok-number">1</span>];</span>
<span class="line" id="L229"> <span class="tok-kw">if</span> (bytes.len != <span class="tok-number">0</span>) {</span>
<span class="line" id="L230"> self.index += <span class="tok-number">1</span>;</span>
<span class="line" id="L231"> self.state = .rhs;</span>
<span class="line" id="L232"> <span class="tok-kw">return</span> finishTarget(must_resolve, bytes);</span>
<span class="line" id="L233"> }</span>
<span class="line" id="L234"> <span class="tok-comment">// silently ignore null target</span>
</span>
<span class="line" id="L235"> self.state = .lhs;</span>
<span class="line" id="L236"> <span class="tok-kw">return</span> <span class="tok-null">null</span>;</span>
<span class="line" id="L237"> },</span>
<span class="line" id="L238"> .target_colon_reverse_solidus => {</span>
<span class="line" id="L239"> <span class="tok-kw">const</span> bytes = self.bytes[start .. self.index - <span class="tok-number">2</span>];</span>
<span class="line" id="L240"> <span class="tok-kw">if</span> (bytes.len != <span class="tok-number">0</span>) {</span>
<span class="line" id="L241"> self.index += <span class="tok-number">1</span>;</span>
<span class="line" id="L242"> self.state = .rhs;</span>
<span class="line" id="L243"> <span class="tok-kw">return</span> finishTarget(must_resolve, bytes);</span>
<span class="line" id="L244"> }</span>
<span class="line" id="L245"> <span class="tok-comment">// silently ignore null target</span>
</span>
<span class="line" id="L246"> self.state = .lhs;</span>
<span class="line" id="L247"> <span class="tok-kw">return</span> <span class="tok-null">null</span>;</span>
<span class="line" id="L248"> },</span>
<span class="line" id="L249"> .prereq_quote => {</span>
<span class="line" id="L250"> <span class="tok-kw">return</span> errorPosition(.incomplete_quoted_prerequisite, start, self.bytes[start..]);</span>
<span class="line" id="L251"> },</span>
<span class="line" id="L252"> .prereq => {</span>
<span class="line" id="L253"> self.state = .lhs;</span>
<span class="line" id="L254"> <span class="tok-kw">return</span> Token{ .prereq = self.bytes[start..] };</span>
<span class="line" id="L255"> },</span>
<span class="line" id="L256"> .prereq_continuation => {</span>
<span class="line" id="L257"> self.state = .lhs;</span>
<span class="line" id="L258"> <span class="tok-kw">return</span> Token{ .prereq = self.bytes[start .. self.index - <span class="tok-number">1</span>] };</span>
<span class="line" id="L259"> },</span>
<span class="line" id="L260"> .prereq_continuation_linefeed => {</span>
<span class="line" id="L261"> self.state = .lhs;</span>
<span class="line" id="L262"> <span class="tok-kw">return</span> Token{ .prereq = self.bytes[start .. self.index - <span class="tok-number">2</span>] };</span>
<span class="line" id="L263"> },</span>
<span class="line" id="L264"> }</span>
<span class="line" id="L265"> }</span>
<span class="line" id="L266"> <span class="tok-kw">unreachable</span>;</span>
<span class="line" id="L267">}</span>
<span class="line" id="L268"></span>
<span class="line" id="L269"><span class="tok-kw">fn</span> <span class="tok-fn">errorPosition</span>(<span class="tok-kw">comptime</span> id: std.meta.Tag(Token), index: <span class="tok-type">usize</span>, bytes: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) Token {</span>
<span class="line" id="L270"> <span class="tok-kw">return</span> <span class="tok-builtin">@unionInit</span>(Token, <span class="tok-builtin">@tagName</span>(id), .{ .index = index, .bytes = bytes });</span>
<span class="line" id="L271">}</span>
<span class="line" id="L272"></span>
<span class="line" id="L273"><span class="tok-kw">fn</span> <span class="tok-fn">errorIllegalChar</span>(<span class="tok-kw">comptime</span> id: std.meta.Tag(Token), index: <span class="tok-type">usize</span>, char: <span class="tok-type">u8</span>) Token {</span>
<span class="line" id="L274"> <span class="tok-kw">return</span> <span class="tok-builtin">@unionInit</span>(Token, <span class="tok-builtin">@tagName</span>(id), .{ .index = index, .char = char });</span>
<span class="line" id="L275">}</span>
<span class="line" id="L276"></span>
<span class="line" id="L277"><span class="tok-kw">fn</span> <span class="tok-fn">finishTarget</span>(must_resolve: <span class="tok-type">bool</span>, bytes: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) Token {</span>
<span class="line" id="L278"> <span class="tok-kw">return</span> <span class="tok-kw">if</span> (must_resolve) .{ .target_must_resolve = bytes } <span class="tok-kw">else</span> .{ .target = bytes };</span>
<span class="line" id="L279">}</span>
<span class="line" id="L280"></span>
<span class="line" id="L281"><span class="tok-kw">const</span> State = <span class="tok-kw">enum</span> {</span>
<span class="line" id="L282"> lhs,</span>
<span class="line" id="L283"> target,</span>
<span class="line" id="L284"> target_reverse_solidus,</span>
<span class="line" id="L285"> target_dollar_sign,</span>
<span class="line" id="L286"> target_colon,</span>
<span class="line" id="L287"> target_colon_reverse_solidus,</span>
<span class="line" id="L288"> rhs,</span>
<span class="line" id="L289"> rhs_continuation,</span>
<span class="line" id="L290"> rhs_continuation_linefeed,</span>
<span class="line" id="L291"> prereq_quote,</span>
<span class="line" id="L292"> prereq,</span>
<span class="line" id="L293"> prereq_continuation,</span>
<span class="line" id="L294"> prereq_continuation_linefeed,</span>
<span class="line" id="L295">};</span>
<span class="line" id="L296"></span>
<span class="line" id="L297"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> Token = <span class="tok-kw">union</span>(<span class="tok-kw">enum</span>) {</span>
<span class="line" id="L298"> target: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L299"> target_must_resolve: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L300"> prereq: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L301"></span>
<span class="line" id="L302"> incomplete_quoted_prerequisite: IndexAndBytes,</span>
<span class="line" id="L303"> incomplete_target: IndexAndBytes,</span>
<span class="line" id="L304"></span>
<span class="line" id="L305"> invalid_target: IndexAndChar,</span>
<span class="line" id="L306"> bad_target_escape: IndexAndChar,</span>
<span class="line" id="L307"> expected_dollar_sign: IndexAndChar,</span>
<span class="line" id="L308"> continuation_eol: IndexAndChar,</span>
<span class="line" id="L309"> incomplete_escape: IndexAndChar,</span>
<span class="line" id="L310"></span>
<span class="line" id="L311"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> IndexAndChar = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L312"> index: <span class="tok-type">usize</span>,</span>
<span class="line" id="L313"> char: <span class="tok-type">u8</span>,</span>
<span class="line" id="L314"> };</span>
<span class="line" id="L315"></span>
<span class="line" id="L316"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> IndexAndBytes = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L317"> index: <span class="tok-type">usize</span>,</span>
<span class="line" id="L318"> bytes: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L319"> };</span>
<span class="line" id="L320"></span>
<span class="line" id="L321"> <span class="tok-comment">/// Resolve escapes in target. Only valid with .target_must_resolve.</span></span>
<span class="line" id="L322"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">resolve</span>(self: Token, writer: <span class="tok-kw">anytype</span>) <span class="tok-builtin">@TypeOf</span>(writer).Error!<span class="tok-type">void</span> {</span>
<span class="line" id="L323"> <span class="tok-kw">const</span> bytes = self.target_must_resolve; <span class="tok-comment">// resolve called on incorrect token</span>
</span>
<span class="line" id="L324"></span>
<span class="line" id="L325"> <span class="tok-kw">var</span> state: <span class="tok-kw">enum</span> { start, escape, dollar } = .start;</span>
<span class="line" id="L326"> <span class="tok-kw">for</span> (bytes) |c| {</span>
<span class="line" id="L327"> <span class="tok-kw">switch</span> (state) {</span>
<span class="line" id="L328"> .start => {</span>
<span class="line" id="L329"> <span class="tok-kw">switch</span> (c) {</span>
<span class="line" id="L330"> <span class="tok-str">'\\'</span> => state = .escape,</span>
<span class="line" id="L331"> <span class="tok-str">'$'</span> => state = .dollar,</span>
<span class="line" id="L332"> <span class="tok-kw">else</span> => <span class="tok-kw">try</span> writer.writeByte(c),</span>
<span class="line" id="L333"> }</span>
<span class="line" id="L334"> },</span>
<span class="line" id="L335"> .escape => {</span>
<span class="line" id="L336"> <span class="tok-kw">switch</span> (c) {</span>
<span class="line" id="L337"> <span class="tok-str">' '</span>, <span class="tok-str">'#'</span>, <span class="tok-str">'\\'</span> => {},</span>
<span class="line" id="L338"> <span class="tok-str">'$'</span> => {</span>
<span class="line" id="L339"> <span class="tok-kw">try</span> writer.writeByte(<span class="tok-str">'\\'</span>);</span>
<span class="line" id="L340"> state = .dollar;</span>
<span class="line" id="L341"> <span class="tok-kw">continue</span>;</span>
<span class="line" id="L342"> },</span>
<span class="line" id="L343"> <span class="tok-kw">else</span> => <span class="tok-kw">try</span> writer.writeByte(<span class="tok-str">'\\'</span>),</span>
<span class="line" id="L344"> }</span>
<span class="line" id="L345"> <span class="tok-kw">try</span> writer.writeByte(c);</span>
<span class="line" id="L346"> state = .start;</span>
<span class="line" id="L347"> },</span>
<span class="line" id="L348"> .dollar => {</span>
<span class="line" id="L349"> <span class="tok-kw">try</span> writer.writeByte(<span class="tok-str">'$'</span>);</span>
<span class="line" id="L350"> <span class="tok-kw">switch</span> (c) {</span>
<span class="line" id="L351"> <span class="tok-str">'$'</span> => {},</span>
<span class="line" id="L352"> <span class="tok-kw">else</span> => <span class="tok-kw">try</span> writer.writeByte(c),</span>
<span class="line" id="L353"> }</span>
<span class="line" id="L354"> state = .start;</span>
<span class="line" id="L355"> },</span>
<span class="line" id="L356"> }</span>
<span class="line" id="L357"> }</span>
<span class="line" id="L358"> }</span>
<span class="line" id="L359"></span>
<span class="line" id="L360"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">printError</span>(self: Token, writer: <span class="tok-kw">anytype</span>) <span class="tok-builtin">@TypeOf</span>(writer).Error!<span class="tok-type">void</span> {</span>
<span class="line" id="L361"> <span class="tok-kw">switch</span> (self) {</span>
<span class="line" id="L362"> .target, .target_must_resolve, .prereq => <span class="tok-kw">unreachable</span>, <span class="tok-comment">// not an error</span>
</span>
<span class="line" id="L363"> .incomplete_quoted_prerequisite,</span>
<span class="line" id="L364"> .incomplete_target,</span>
<span class="line" id="L365"> => |index_and_bytes| {</span>
<span class="line" id="L366"> <span class="tok-kw">try</span> writer.print(<span class="tok-str">"{s} '"</span>, .{self.errStr()});</span>
<span class="line" id="L367"> <span class="tok-kw">if</span> (self == .incomplete_target) {</span>
<span class="line" id="L368"> <span class="tok-kw">const</span> tmp = Token{ .target_must_resolve = index_and_bytes.bytes };</span>
<span class="line" id="L369"> <span class="tok-kw">try</span> tmp.resolve(writer);</span>
<span class="line" id="L370"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L371"> <span class="tok-kw">try</span> printCharValues(writer, index_and_bytes.bytes);</span>
<span class="line" id="L372"> }</span>
<span class="line" id="L373"> <span class="tok-kw">try</span> writer.print(<span class="tok-str">"' at position {d}"</span>, .{index_and_bytes.index});</span>
<span class="line" id="L374"> },</span>
<span class="line" id="L375"> .invalid_target,</span>
<span class="line" id="L376"> .bad_target_escape,</span>
<span class="line" id="L377"> .expected_dollar_sign,</span>
<span class="line" id="L378"> .continuation_eol,</span>
<span class="line" id="L379"> .incomplete_escape,</span>
<span class="line" id="L380"> => |index_and_char| {</span>
<span class="line" id="L381"> <span class="tok-kw">try</span> writer.writeAll(<span class="tok-str">"illegal char "</span>);</span>
<span class="line" id="L382"> <span class="tok-kw">try</span> printUnderstandableChar(writer, index_and_char.char);</span>
<span class="line" id="L383"> <span class="tok-kw">try</span> writer.print(<span class="tok-str">" at position {d}: {s}"</span>, .{ index_and_char.index, self.errStr() });</span>
<span class="line" id="L384"> },</span>
<span class="line" id="L385"> }</span>
<span class="line" id="L386"> }</span>
<span class="line" id="L387"></span>
<span class="line" id="L388"> <span class="tok-kw">fn</span> <span class="tok-fn">errStr</span>(self: Token) []<span class="tok-kw">const</span> <span class="tok-type">u8</span> {</span>
<span class="line" id="L389"> <span class="tok-kw">return</span> <span class="tok-kw">switch</span> (self) {</span>
<span class="line" id="L390"> .target, .target_must_resolve, .prereq => <span class="tok-kw">unreachable</span>, <span class="tok-comment">// not an error</span>
</span>
<span class="line" id="L391"> .incomplete_quoted_prerequisite => <span class="tok-str">"incomplete quoted prerequisite"</span>,</span>
<span class="line" id="L392"> .incomplete_target => <span class="tok-str">"incomplete target"</span>,</span>
<span class="line" id="L393"> .invalid_target => <span class="tok-str">"invalid target"</span>,</span>
<span class="line" id="L394"> .bad_target_escape => <span class="tok-str">"bad target escape"</span>,</span>
<span class="line" id="L395"> .expected_dollar_sign => <span class="tok-str">"expecting '$'"</span>,</span>
<span class="line" id="L396"> .continuation_eol => <span class="tok-str">"continuation expecting end-of-line"</span>,</span>
<span class="line" id="L397"> .incomplete_escape => <span class="tok-str">"incomplete escape"</span>,</span>
<span class="line" id="L398"> };</span>
<span class="line" id="L399"> }</span>
<span class="line" id="L400">};</span>
<span class="line" id="L401"></span>
<span class="line" id="L402"><span class="tok-kw">test</span> <span class="tok-str">"empty file"</span> {</span>
<span class="line" id="L403"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">""</span>, <span class="tok-str">""</span>);</span>
<span class="line" id="L404">}</span>
<span class="line" id="L405"></span>
<span class="line" id="L406"><span class="tok-kw">test</span> <span class="tok-str">"empty whitespace"</span> {</span>
<span class="line" id="L407"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">"\n"</span>, <span class="tok-str">""</span>);</span>
<span class="line" id="L408"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">"\r"</span>, <span class="tok-str">""</span>);</span>
<span class="line" id="L409"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">"\r\n"</span>, <span class="tok-str">""</span>);</span>
<span class="line" id="L410"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">" "</span>, <span class="tok-str">""</span>);</span>
<span class="line" id="L411">}</span>
<span class="line" id="L412"></span>
<span class="line" id="L413"><span class="tok-kw">test</span> <span class="tok-str">"empty colon"</span> {</span>
<span class="line" id="L414"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">":"</span>, <span class="tok-str">""</span>);</span>
<span class="line" id="L415"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">"\n:"</span>, <span class="tok-str">""</span>);</span>
<span class="line" id="L416"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">"\r:"</span>, <span class="tok-str">""</span>);</span>
<span class="line" id="L417"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">"\r\n:"</span>, <span class="tok-str">""</span>);</span>
<span class="line" id="L418"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">" :"</span>, <span class="tok-str">""</span>);</span>
<span class="line" id="L419">}</span>
<span class="line" id="L420"></span>
<span class="line" id="L421"><span class="tok-kw">test</span> <span class="tok-str">"empty target"</span> {</span>
<span class="line" id="L422"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">"foo.o:"</span>, <span class="tok-str">"target = {foo.o}"</span>);</span>
<span class="line" id="L423"> <span class="tok-kw">try</span> depTokenizer(</span>
<span class="line" id="L424"> <span class="tok-str">\\foo.o:</span></span>
<span class="line" id="L425"> <span class="tok-str">\\bar.o:</span></span>
<span class="line" id="L426"> <span class="tok-str">\\abcd.o:</span></span>
<span class="line" id="L427"> ,</span>
<span class="line" id="L428"> <span class="tok-str">\\target = {foo.o}</span></span>
<span class="line" id="L429"> <span class="tok-str">\\target = {bar.o}</span></span>
<span class="line" id="L430"> <span class="tok-str">\\target = {abcd.o}</span></span>
<span class="line" id="L431"> );</span>
<span class="line" id="L432">}</span>
<span class="line" id="L433"></span>
<span class="line" id="L434"><span class="tok-kw">test</span> <span class="tok-str">"whitespace empty target"</span> {</span>
<span class="line" id="L435"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">"\nfoo.o:"</span>, <span class="tok-str">"target = {foo.o}"</span>);</span>
<span class="line" id="L436"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">"\rfoo.o:"</span>, <span class="tok-str">"target = {foo.o}"</span>);</span>
<span class="line" id="L437"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">"\r\nfoo.o:"</span>, <span class="tok-str">"target = {foo.o}"</span>);</span>
<span class="line" id="L438"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">" foo.o:"</span>, <span class="tok-str">"target = {foo.o}"</span>);</span>
<span class="line" id="L439">}</span>
<span class="line" id="L440"></span>
<span class="line" id="L441"><span class="tok-kw">test</span> <span class="tok-str">"escape empty target"</span> {</span>
<span class="line" id="L442"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">"\\ foo.o:"</span>, <span class="tok-str">"target = { foo.o}"</span>);</span>
<span class="line" id="L443"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">"\\#foo.o:"</span>, <span class="tok-str">"target = {#foo.o}"</span>);</span>
<span class="line" id="L444"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">"\\\\foo.o:"</span>, <span class="tok-str">"target = {\\foo.o}"</span>);</span>
<span class="line" id="L445"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">"$$foo.o:"</span>, <span class="tok-str">"target = {$foo.o}"</span>);</span>
<span class="line" id="L446">}</span>
<span class="line" id="L447"></span>
<span class="line" id="L448"><span class="tok-kw">test</span> <span class="tok-str">"empty target linefeeds"</span> {</span>
<span class="line" id="L449"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">"\n"</span>, <span class="tok-str">""</span>);</span>
<span class="line" id="L450"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">"\r\n"</span>, <span class="tok-str">""</span>);</span>
<span class="line" id="L451"></span>
<span class="line" id="L452"> <span class="tok-kw">const</span> expect = <span class="tok-str">"target = {foo.o}"</span>;</span>
<span class="line" id="L453"> <span class="tok-kw">try</span> depTokenizer(</span>
<span class="line" id="L454"> <span class="tok-str">\\foo.o:</span></span>
<span class="line" id="L455"> , expect);</span>
<span class="line" id="L456"> <span class="tok-kw">try</span> depTokenizer(</span>
<span class="line" id="L457"> <span class="tok-str">\\foo.o:</span></span>
<span class="line" id="L458"> <span class="tok-str">\\</span></span>
<span class="line" id="L459"> , expect);</span>
<span class="line" id="L460"> <span class="tok-kw">try</span> depTokenizer(</span>
<span class="line" id="L461"> <span class="tok-str">\\foo.o:</span></span>
<span class="line" id="L462"> , expect);</span>
<span class="line" id="L463"> <span class="tok-kw">try</span> depTokenizer(</span>
<span class="line" id="L464"> <span class="tok-str">\\foo.o:</span></span>
<span class="line" id="L465"> <span class="tok-str">\\</span></span>
<span class="line" id="L466"> , expect);</span>
<span class="line" id="L467">}</span>
<span class="line" id="L468"></span>
<span class="line" id="L469"><span class="tok-kw">test</span> <span class="tok-str">"empty target linefeeds + continuations"</span> {</span>
<span class="line" id="L470"> <span class="tok-kw">const</span> expect = <span class="tok-str">"target = {foo.o}"</span>;</span>
<span class="line" id="L471"> <span class="tok-kw">try</span> depTokenizer(</span>
<span class="line" id="L472"> <span class="tok-str">\\foo.o:\</span></span>
<span class="line" id="L473"> , expect);</span>
<span class="line" id="L474"> <span class="tok-kw">try</span> depTokenizer(</span>
<span class="line" id="L475"> <span class="tok-str">\\foo.o:\</span></span>
<span class="line" id="L476"> <span class="tok-str">\\</span></span>
<span class="line" id="L477"> , expect);</span>
<span class="line" id="L478"> <span class="tok-kw">try</span> depTokenizer(</span>
<span class="line" id="L479"> <span class="tok-str">\\foo.o:\</span></span>
<span class="line" id="L480"> , expect);</span>
<span class="line" id="L481"> <span class="tok-kw">try</span> depTokenizer(</span>
<span class="line" id="L482"> <span class="tok-str">\\foo.o:\</span></span>
<span class="line" id="L483"> <span class="tok-str">\\</span></span>
<span class="line" id="L484"> , expect);</span>
<span class="line" id="L485">}</span>
<span class="line" id="L486"></span>
<span class="line" id="L487"><span class="tok-kw">test</span> <span class="tok-str">"empty target linefeeds + hspace + continuations"</span> {</span>
<span class="line" id="L488"> <span class="tok-kw">const</span> expect = <span class="tok-str">"target = {foo.o}"</span>;</span>
<span class="line" id="L489"> <span class="tok-kw">try</span> depTokenizer(</span>
<span class="line" id="L490"> <span class="tok-str">\\foo.o: \</span></span>
<span class="line" id="L491"> , expect);</span>
<span class="line" id="L492"> <span class="tok-kw">try</span> depTokenizer(</span>
<span class="line" id="L493"> <span class="tok-str">\\foo.o: \</span></span>
<span class="line" id="L494"> <span class="tok-str">\\</span></span>
<span class="line" id="L495"> , expect);</span>
<span class="line" id="L496"> <span class="tok-kw">try</span> depTokenizer(</span>
<span class="line" id="L497"> <span class="tok-str">\\foo.o: \</span></span>
<span class="line" id="L498"> , expect);</span>
<span class="line" id="L499"> <span class="tok-kw">try</span> depTokenizer(</span>
<span class="line" id="L500"> <span class="tok-str">\\foo.o: \</span></span>
<span class="line" id="L501"> <span class="tok-str">\\</span></span>
<span class="line" id="L502"> , expect);</span>
<span class="line" id="L503">}</span>
<span class="line" id="L504"></span>
<span class="line" id="L505"><span class="tok-kw">test</span> <span class="tok-str">"prereq"</span> {</span>
<span class="line" id="L506"> <span class="tok-kw">const</span> expect =</span>
<span class="line" id="L507"> <span class="tok-str">\\target = {foo.o}</span></span>
<span class="line" id="L508"> <span class="tok-str">\\prereq = {foo.c}</span></span>
<span class="line" id="L509"> ;</span>
<span class="line" id="L510"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">"foo.o: foo.c"</span>, expect);</span>
<span class="line" id="L511"> <span class="tok-kw">try</span> depTokenizer(</span>
<span class="line" id="L512"> <span class="tok-str">\\foo.o: \</span></span>
<span class="line" id="L513"> <span class="tok-str">\\foo.c</span></span>
<span class="line" id="L514"> , expect);</span>
<span class="line" id="L515"> <span class="tok-kw">try</span> depTokenizer(</span>
<span class="line" id="L516"> <span class="tok-str">\\foo.o: \</span></span>
<span class="line" id="L517"> <span class="tok-str">\\ foo.c</span></span>
<span class="line" id="L518"> , expect);</span>
<span class="line" id="L519"> <span class="tok-kw">try</span> depTokenizer(</span>
<span class="line" id="L520"> <span class="tok-str">\\foo.o: \</span></span>
<span class="line" id="L521"> <span class="tok-str">\\ foo.c</span></span>
<span class="line" id="L522"> , expect);</span>
<span class="line" id="L523">}</span>
<span class="line" id="L524"></span>
<span class="line" id="L525"><span class="tok-kw">test</span> <span class="tok-str">"prereq continuation"</span> {</span>
<span class="line" id="L526"> <span class="tok-kw">const</span> expect =</span>
<span class="line" id="L527"> <span class="tok-str">\\target = {foo.o}</span></span>
<span class="line" id="L528"> <span class="tok-str">\\prereq = {foo.h}</span></span>
<span class="line" id="L529"> <span class="tok-str">\\prereq = {bar.h}</span></span>
<span class="line" id="L530"> ;</span>
<span class="line" id="L531"> <span class="tok-kw">try</span> depTokenizer(</span>
<span class="line" id="L532"> <span class="tok-str">\\foo.o: foo.h\</span></span>
<span class="line" id="L533"> <span class="tok-str">\\bar.h</span></span>
<span class="line" id="L534"> , expect);</span>
<span class="line" id="L535"> <span class="tok-kw">try</span> depTokenizer(</span>
<span class="line" id="L536"> <span class="tok-str">\\foo.o: foo.h\</span></span>
<span class="line" id="L537"> <span class="tok-str">\\bar.h</span></span>
<span class="line" id="L538"> , expect);</span>
<span class="line" id="L539">}</span>
<span class="line" id="L540"></span>
<span class="line" id="L541"><span class="tok-kw">test</span> <span class="tok-str">"multiple prereqs"</span> {</span>
<span class="line" id="L542"> <span class="tok-kw">const</span> expect =</span>
<span class="line" id="L543"> <span class="tok-str">\\target = {foo.o}</span></span>
<span class="line" id="L544"> <span class="tok-str">\\prereq = {foo.c}</span></span>
<span class="line" id="L545"> <span class="tok-str">\\prereq = {foo.h}</span></span>
<span class="line" id="L546"> <span class="tok-str">\\prereq = {bar.h}</span></span>
<span class="line" id="L547"> ;</span>
<span class="line" id="L548"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">"foo.o: foo.c foo.h bar.h"</span>, expect);</span>
<span class="line" id="L549"> <span class="tok-kw">try</span> depTokenizer(</span>
<span class="line" id="L550"> <span class="tok-str">\\foo.o: \</span></span>
<span class="line" id="L551"> <span class="tok-str">\\foo.c foo.h bar.h</span></span>
<span class="line" id="L552"> , expect);</span>
<span class="line" id="L553"> <span class="tok-kw">try</span> depTokenizer(</span>
<span class="line" id="L554"> <span class="tok-str">\\foo.o: foo.c foo.h bar.h\</span></span>
<span class="line" id="L555"> , expect);</span>
<span class="line" id="L556"> <span class="tok-kw">try</span> depTokenizer(</span>
<span class="line" id="L557"> <span class="tok-str">\\foo.o: foo.c foo.h bar.h\</span></span>
<span class="line" id="L558"> <span class="tok-str">\\</span></span>
<span class="line" id="L559"> , expect);</span>
<span class="line" id="L560"> <span class="tok-kw">try</span> depTokenizer(</span>
<span class="line" id="L561"> <span class="tok-str">\\foo.o: \</span></span>
<span class="line" id="L562"> <span class="tok-str">\\foo.c \</span></span>
<span class="line" id="L563"> <span class="tok-str">\\ foo.h\</span></span>
<span class="line" id="L564"> <span class="tok-str">\\bar.h</span></span>
<span class="line" id="L565"> <span class="tok-str">\\</span></span>
<span class="line" id="L566"> , expect);</span>
<span class="line" id="L567"> <span class="tok-kw">try</span> depTokenizer(</span>
<span class="line" id="L568"> <span class="tok-str">\\foo.o: \</span></span>
<span class="line" id="L569"> <span class="tok-str">\\foo.c \</span></span>
<span class="line" id="L570"> <span class="tok-str">\\ foo.h\</span></span>
<span class="line" id="L571"> <span class="tok-str">\\bar.h\</span></span>
<span class="line" id="L572"> <span class="tok-str">\\</span></span>
<span class="line" id="L573"> , expect);</span>
<span class="line" id="L574"> <span class="tok-kw">try</span> depTokenizer(</span>
<span class="line" id="L575"> <span class="tok-str">\\foo.o: \</span></span>
<span class="line" id="L576"> <span class="tok-str">\\foo.c \</span></span>
<span class="line" id="L577"> <span class="tok-str">\\ foo.h\</span></span>
<span class="line" id="L578"> <span class="tok-str">\\bar.h\</span></span>
<span class="line" id="L579"> , expect);</span>
<span class="line" id="L580">}</span>
<span class="line" id="L581"></span>
<span class="line" id="L582"><span class="tok-kw">test</span> <span class="tok-str">"multiple targets and prereqs"</span> {</span>
<span class="line" id="L583"> <span class="tok-kw">try</span> depTokenizer(</span>
<span class="line" id="L584"> <span class="tok-str">\\foo.o: foo.c</span></span>
<span class="line" id="L585"> <span class="tok-str">\\bar.o: bar.c a.h b.h c.h</span></span>
<span class="line" id="L586"> <span class="tok-str">\\abc.o: abc.c \</span></span>
<span class="line" id="L587"> <span class="tok-str">\\ one.h two.h \</span></span>
<span class="line" id="L588"> <span class="tok-str">\\ three.h four.h</span></span>
<span class="line" id="L589"> ,</span>
<span class="line" id="L590"> <span class="tok-str">\\target = {foo.o}</span></span>
<span class="line" id="L591"> <span class="tok-str">\\prereq = {foo.c}</span></span>
<span class="line" id="L592"> <span class="tok-str">\\target = {bar.o}</span></span>
<span class="line" id="L593"> <span class="tok-str">\\prereq = {bar.c}</span></span>
<span class="line" id="L594"> <span class="tok-str">\\prereq = {a.h}</span></span>
<span class="line" id="L595"> <span class="tok-str">\\prereq = {b.h}</span></span>
<span class="line" id="L596"> <span class="tok-str">\\prereq = {c.h}</span></span>
<span class="line" id="L597"> <span class="tok-str">\\target = {abc.o}</span></span>
<span class="line" id="L598"> <span class="tok-str">\\prereq = {abc.c}</span></span>
<span class="line" id="L599"> <span class="tok-str">\\prereq = {one.h}</span></span>
<span class="line" id="L600"> <span class="tok-str">\\prereq = {two.h}</span></span>
<span class="line" id="L601"> <span class="tok-str">\\prereq = {three.h}</span></span>
<span class="line" id="L602"> <span class="tok-str">\\prereq = {four.h}</span></span>
<span class="line" id="L603"> );</span>
<span class="line" id="L604"> <span class="tok-kw">try</span> depTokenizer(</span>
<span class="line" id="L605"> <span class="tok-str">\\ascii.o: ascii.c</span></span>
<span class="line" id="L606"> <span class="tok-str">\\base64.o: base64.c stdio.h</span></span>
<span class="line" id="L607"> <span class="tok-str">\\elf.o: elf.c a.h b.h c.h</span></span>
<span class="line" id="L608"> <span class="tok-str">\\macho.o: \</span></span>
<span class="line" id="L609"> <span class="tok-str">\\ macho.c\</span></span>
<span class="line" id="L610"> <span class="tok-str">\\ a.h b.h c.h</span></span>
<span class="line" id="L611"> ,</span>
<span class="line" id="L612"> <span class="tok-str">\\target = {ascii.o}</span></span>
<span class="line" id="L613"> <span class="tok-str">\\prereq = {ascii.c}</span></span>
<span class="line" id="L614"> <span class="tok-str">\\target = {base64.o}</span></span>
<span class="line" id="L615"> <span class="tok-str">\\prereq = {base64.c}</span></span>
<span class="line" id="L616"> <span class="tok-str">\\prereq = {stdio.h}</span></span>
<span class="line" id="L617"> <span class="tok-str">\\target = {elf.o}</span></span>
<span class="line" id="L618"> <span class="tok-str">\\prereq = {elf.c}</span></span>
<span class="line" id="L619"> <span class="tok-str">\\prereq = {a.h}</span></span>
<span class="line" id="L620"> <span class="tok-str">\\prereq = {b.h}</span></span>
<span class="line" id="L621"> <span class="tok-str">\\prereq = {c.h}</span></span>
<span class="line" id="L622"> <span class="tok-str">\\target = {macho.o}</span></span>
<span class="line" id="L623"> <span class="tok-str">\\prereq = {macho.c}</span></span>
<span class="line" id="L624"> <span class="tok-str">\\prereq = {a.h}</span></span>
<span class="line" id="L625"> <span class="tok-str">\\prereq = {b.h}</span></span>
<span class="line" id="L626"> <span class="tok-str">\\prereq = {c.h}</span></span>
<span class="line" id="L627"> );</span>
<span class="line" id="L628"> <span class="tok-kw">try</span> depTokenizer(</span>
<span class="line" id="L629"> <span class="tok-str">\\a$$scii.o: ascii.c</span></span>
<span class="line" id="L630"> <span class="tok-str">\\\\base64.o: "\base64.c" "s t#dio.h"</span></span>
<span class="line" id="L631"> <span class="tok-str">\\e\\lf.o: "e\lf.c" "a.h$$" "$$b.h c.h$$"</span></span>
<span class="line" id="L632"> <span class="tok-str">\\macho.o: \</span></span>
<span class="line" id="L633"> <span class="tok-str">\\ "macho!.c" \</span></span>
<span class="line" id="L634"> <span class="tok-str">\\ a.h b.h c.h</span></span>
<span class="line" id="L635"> ,</span>
<span class="line" id="L636"> <span class="tok-str">\\target = {a$scii.o}</span></span>
<span class="line" id="L637"> <span class="tok-str">\\prereq = {ascii.c}</span></span>
<span class="line" id="L638"> <span class="tok-str">\\target = {\base64.o}</span></span>
<span class="line" id="L639"> <span class="tok-str">\\prereq = {\base64.c}</span></span>
<span class="line" id="L640"> <span class="tok-str">\\prereq = {s t#dio.h}</span></span>
<span class="line" id="L641"> <span class="tok-str">\\target = {e\lf.o}</span></span>
<span class="line" id="L642"> <span class="tok-str">\\prereq = {e\lf.c}</span></span>
<span class="line" id="L643"> <span class="tok-str">\\prereq = {a.h$$}</span></span>
<span class="line" id="L644"> <span class="tok-str">\\prereq = {$$b.h c.h$$}</span></span>
<span class="line" id="L645"> <span class="tok-str">\\target = {macho.o}</span></span>
<span class="line" id="L646"> <span class="tok-str">\\prereq = {macho!.c}</span></span>
<span class="line" id="L647"> <span class="tok-str">\\prereq = {a.h}</span></span>
<span class="line" id="L648"> <span class="tok-str">\\prereq = {b.h}</span></span>
<span class="line" id="L649"> <span class="tok-str">\\prereq = {c.h}</span></span>
<span class="line" id="L650"> );</span>
<span class="line" id="L651">}</span>
<span class="line" id="L652"></span>
<span class="line" id="L653"><span class="tok-kw">test</span> <span class="tok-str">"windows quoted prereqs"</span> {</span>
<span class="line" id="L654"> <span class="tok-kw">try</span> depTokenizer(</span>
<span class="line" id="L655"> <span class="tok-str">\\c:\foo.o: "C:\Program Files (x86)\Microsoft Visual Studio\foo.c"</span></span>
<span class="line" id="L656"> <span class="tok-str">\\c:\foo2.o: "C:\Program Files (x86)\Microsoft Visual Studio\foo2.c" \</span></span>
<span class="line" id="L657"> <span class="tok-str">\\ "C:\Program Files (x86)\Microsoft Visual Studio\foo1.h" \</span></span>
<span class="line" id="L658"> <span class="tok-str">\\ "C:\Program Files (x86)\Microsoft Visual Studio\foo2.h"</span></span>
<span class="line" id="L659"> ,</span>
<span class="line" id="L660"> <span class="tok-str">\\target = {c:\foo.o}</span></span>
<span class="line" id="L661"> <span class="tok-str">\\prereq = {C:\Program Files (x86)\Microsoft Visual Studio\foo.c}</span></span>
<span class="line" id="L662"> <span class="tok-str">\\target = {c:\foo2.o}</span></span>
<span class="line" id="L663"> <span class="tok-str">\\prereq = {C:\Program Files (x86)\Microsoft Visual Studio\foo2.c}</span></span>
<span class="line" id="L664"> <span class="tok-str">\\prereq = {C:\Program Files (x86)\Microsoft Visual Studio\foo1.h}</span></span>
<span class="line" id="L665"> <span class="tok-str">\\prereq = {C:\Program Files (x86)\Microsoft Visual Studio\foo2.h}</span></span>
<span class="line" id="L666"> );</span>
<span class="line" id="L667">}</span>
<span class="line" id="L668"></span>
<span class="line" id="L669"><span class="tok-kw">test</span> <span class="tok-str">"windows mixed prereqs"</span> {</span>
<span class="line" id="L670"> <span class="tok-kw">try</span> depTokenizer(</span>
<span class="line" id="L671"> <span class="tok-str">\\cimport.o: \</span></span>
<span class="line" id="L672"> <span class="tok-str">\\ C:\msys64\home\anon\project\zig\master\zig-cache\o\qhvhbUo7GU5iKyQ5mpA8TcQpncCYaQu0wwvr3ybiSTj_Dtqi1Nmcb70kfODJ2Qlg\cimport.h \</span></span>
<span class="line" id="L673"> <span class="tok-str">\\ "C:\Program Files (x86)\Windows Kits\10\\Include\10.0.17763.0\ucrt\stdio.h" \</span></span>
<span class="line" id="L674"> <span class="tok-str">\\ "C:\Program Files (x86)\Windows Kits\10\\Include\10.0.17763.0\ucrt\corecrt.h" \</span></span>
<span class="line" id="L675"> <span class="tok-str">\\ "C:\Program Files (x86)\Microsoft Visual Studio\2019\BuildTools\VC\Tools\MSVC\14.21.27702\lib\x64\\..\..\include\vcruntime.h" \</span></span>
<span class="line" id="L676"> <span class="tok-str">\\ "C:\Program Files (x86)\Microsoft Visual Studio\2019\BuildTools\VC\Tools\MSVC\14.21.27702\lib\x64\\..\..\include\sal.h" \</span></span>
<span class="line" id="L677"> <span class="tok-str">\\ "C:\Program Files (x86)\Microsoft Visual Studio\2019\BuildTools\VC\Tools\MSVC\14.21.27702\lib\x64\\..\..\include\concurrencysal.h" \</span></span>
<span class="line" id="L678"> <span class="tok-str">\\ C:\msys64\opt\zig\lib\zig\include\vadefs.h \</span></span>
<span class="line" id="L679"> <span class="tok-str">\\ "C:\Program Files (x86)\Microsoft Visual Studio\2019\BuildTools\VC\Tools\MSVC\14.21.27702\lib\x64\\..\..\include\vadefs.h" \</span></span>
<span class="line" id="L680"> <span class="tok-str">\\ "C:\Program Files (x86)\Windows Kits\10\\Include\10.0.17763.0\ucrt\corecrt_wstdio.h" \</span></span>
<span class="line" id="L681"> <span class="tok-str">\\ "C:\Program Files (x86)\Windows Kits\10\\Include\10.0.17763.0\ucrt\corecrt_stdio_config.h" \</span></span>
<span class="line" id="L682"> <span class="tok-str">\\ "C:\Program Files (x86)\Windows Kits\10\\Include\10.0.17763.0\ucrt\string.h" \</span></span>
<span class="line" id="L683"> <span class="tok-str">\\ "C:\Program Files (x86)\Windows Kits\10\\Include\10.0.17763.0\ucrt\corecrt_memory.h" \</span></span>
<span class="line" id="L684"> <span class="tok-str">\\ "C:\Program Files (x86)\Windows Kits\10\\Include\10.0.17763.0\ucrt\corecrt_memcpy_s.h" \</span></span>
<span class="line" id="L685"> <span class="tok-str">\\ "C:\Program Files (x86)\Windows Kits\10\\Include\10.0.17763.0\ucrt\errno.h" \</span></span>
<span class="line" id="L686"> <span class="tok-str">\\ "C:\Program Files (x86)\Microsoft Visual Studio\2019\BuildTools\VC\Tools\MSVC\14.21.27702\lib\x64\\..\..\include\vcruntime_string.h" \</span></span>
<span class="line" id="L687"> <span class="tok-str">\\ "C:\Program Files (x86)\Windows Kits\10\\Include\10.0.17763.0\ucrt\corecrt_wstring.h"</span></span>
<span class="line" id="L688"> ,</span>
<span class="line" id="L689"> <span class="tok-str">\\target = {cimport.o}</span></span>
<span class="line" id="L690"> <span class="tok-str">\\prereq = {C:\msys64\home\anon\project\zig\master\zig-cache\o\qhvhbUo7GU5iKyQ5mpA8TcQpncCYaQu0wwvr3ybiSTj_Dtqi1Nmcb70kfODJ2Qlg\cimport.h}</span></span>
<span class="line" id="L691"> <span class="tok-str">\\prereq = {C:\Program Files (x86)\Windows Kits\10\\Include\10.0.17763.0\ucrt\stdio.h}</span></span>
<span class="line" id="L692"> <span class="tok-str">\\prereq = {C:\Program Files (x86)\Windows Kits\10\\Include\10.0.17763.0\ucrt\corecrt.h}</span></span>
<span class="line" id="L693"> <span class="tok-str">\\prereq = {C:\Program Files (x86)\Microsoft Visual Studio\2019\BuildTools\VC\Tools\MSVC\14.21.27702\lib\x64\\..\..\include\vcruntime.h}</span></span>
<span class="line" id="L694"> <span class="tok-str">\\prereq = {C:\Program Files (x86)\Microsoft Visual Studio\2019\BuildTools\VC\Tools\MSVC\14.21.27702\lib\x64\\..\..\include\sal.h}</span></span>
<span class="line" id="L695"> <span class="tok-str">\\prereq = {C:\Program Files (x86)\Microsoft Visual Studio\2019\BuildTools\VC\Tools\MSVC\14.21.27702\lib\x64\\..\..\include\concurrencysal.h}</span></span>
<span class="line" id="L696"> <span class="tok-str">\\prereq = {C:\msys64\opt\zig\lib\zig\include\vadefs.h}</span></span>
<span class="line" id="L697"> <span class="tok-str">\\prereq = {C:\Program Files (x86)\Microsoft Visual Studio\2019\BuildTools\VC\Tools\MSVC\14.21.27702\lib\x64\\..\..\include\vadefs.h}</span></span>
<span class="line" id="L698"> <span class="tok-str">\\prereq = {C:\Program Files (x86)\Windows Kits\10\\Include\10.0.17763.0\ucrt\corecrt_wstdio.h}</span></span>
<span class="line" id="L699"> <span class="tok-str">\\prereq = {C:\Program Files (x86)\Windows Kits\10\\Include\10.0.17763.0\ucrt\corecrt_stdio_config.h}</span></span>
<span class="line" id="L700"> <span class="tok-str">\\prereq = {C:\Program Files (x86)\Windows Kits\10\\Include\10.0.17763.0\ucrt\string.h}</span></span>
<span class="line" id="L701"> <span class="tok-str">\\prereq = {C:\Program Files (x86)\Windows Kits\10\\Include\10.0.17763.0\ucrt\corecrt_memory.h}</span></span>
<span class="line" id="L702"> <span class="tok-str">\\prereq = {C:\Program Files (x86)\Windows Kits\10\\Include\10.0.17763.0\ucrt\corecrt_memcpy_s.h}</span></span>
<span class="line" id="L703"> <span class="tok-str">\\prereq = {C:\Program Files (x86)\Windows Kits\10\\Include\10.0.17763.0\ucrt\errno.h}</span></span>
<span class="line" id="L704"> <span class="tok-str">\\prereq = {C:\Program Files (x86)\Microsoft Visual Studio\2019\BuildTools\VC\Tools\MSVC\14.21.27702\lib\x64\\..\..\include\vcruntime_string.h}</span></span>
<span class="line" id="L705"> <span class="tok-str">\\prereq = {C:\Program Files (x86)\Windows Kits\10\\Include\10.0.17763.0\ucrt\corecrt_wstring.h}</span></span>
<span class="line" id="L706"> );</span>
<span class="line" id="L707">}</span>
<span class="line" id="L708"></span>
<span class="line" id="L709"><span class="tok-kw">test</span> <span class="tok-str">"windows funky targets"</span> {</span>
<span class="line" id="L710"> <span class="tok-kw">try</span> depTokenizer(</span>
<span class="line" id="L711"> <span class="tok-str">\\C:\Users\anon\foo.o:</span></span>
<span class="line" id="L712"> <span class="tok-str">\\C:\Users\anon\foo\ .o:</span></span>
<span class="line" id="L713"> <span class="tok-str">\\C:\Users\anon\foo\#.o:</span></span>
<span class="line" id="L714"> <span class="tok-str">\\C:\Users\anon\foo$$.o:</span></span>
<span class="line" id="L715"> <span class="tok-str">\\C:\Users\anon\\\ foo.o:</span></span>
<span class="line" id="L716"> <span class="tok-str">\\C:\Users\anon\\#foo.o:</span></span>
<span class="line" id="L717"> <span class="tok-str">\\C:\Users\anon\$$foo.o:</span></span>
<span class="line" id="L718"> <span class="tok-str">\\C:\Users\anon\\\ \ \ \ \ foo.o:</span></span>
<span class="line" id="L719"> ,</span>
<span class="line" id="L720"> <span class="tok-str">\\target = {C:\Users\anon\foo.o}</span></span>
<span class="line" id="L721"> <span class="tok-str">\\target = {C:\Users\anon\foo .o}</span></span>
<span class="line" id="L722"> <span class="tok-str">\\target = {C:\Users\anon\foo#.o}</span></span>
<span class="line" id="L723"> <span class="tok-str">\\target = {C:\Users\anon\foo$.o}</span></span>
<span class="line" id="L724"> <span class="tok-str">\\target = {C:\Users\anon\ foo.o}</span></span>
<span class="line" id="L725"> <span class="tok-str">\\target = {C:\Users\anon\#foo.o}</span></span>
<span class="line" id="L726"> <span class="tok-str">\\target = {C:\Users\anon\$foo.o}</span></span>
<span class="line" id="L727"> <span class="tok-str">\\target = {C:\Users\anon\ foo.o}</span></span>
<span class="line" id="L728"> );</span>
<span class="line" id="L729">}</span>
<span class="line" id="L730"></span>
<span class="line" id="L731"><span class="tok-kw">test</span> <span class="tok-str">"windows drive and forward slashes"</span> {</span>
<span class="line" id="L732"> <span class="tok-kw">try</span> depTokenizer(</span>
<span class="line" id="L733"> <span class="tok-str">\\C:/msys64/what/zig-cache\tmp\48ac4d78dd531abd-cxa_thread_atexit.obj: \</span></span>
<span class="line" id="L734"> <span class="tok-str">\\ C:/msys64/opt/zig3/lib/zig/libc/mingw/crt/cxa_thread_atexit.c</span></span>
<span class="line" id="L735"> ,</span>
<span class="line" id="L736"> <span class="tok-str">\\target = {C:/msys64/what/zig-cache\tmp\48ac4d78dd531abd-cxa_thread_atexit.obj}</span></span>
<span class="line" id="L737"> <span class="tok-str">\\prereq = {C:/msys64/opt/zig3/lib/zig/libc/mingw/crt/cxa_thread_atexit.c}</span></span>
<span class="line" id="L738"> );</span>
<span class="line" id="L739">}</span>
<span class="line" id="L740"></span>
<span class="line" id="L741"><span class="tok-kw">test</span> <span class="tok-str">"error incomplete escape - reverse_solidus"</span> {</span>
<span class="line" id="L742"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">"\\"</span>,</span>
<span class="line" id="L743"> <span class="tok-str">\\ERROR: illegal char '\' at position 0: incomplete escape</span></span>
<span class="line" id="L744"> );</span>
<span class="line" id="L745"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">"\t\\"</span>,</span>
<span class="line" id="L746"> <span class="tok-str">\\ERROR: illegal char '\' at position 1: incomplete escape</span></span>
<span class="line" id="L747"> );</span>
<span class="line" id="L748"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">"\n\\"</span>,</span>
<span class="line" id="L749"> <span class="tok-str">\\ERROR: illegal char '\' at position 1: incomplete escape</span></span>
<span class="line" id="L750"> );</span>
<span class="line" id="L751"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">"\r\\"</span>,</span>
<span class="line" id="L752"> <span class="tok-str">\\ERROR: illegal char '\' at position 1: incomplete escape</span></span>
<span class="line" id="L753"> );</span>
<span class="line" id="L754"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">"\r\n\\"</span>,</span>
<span class="line" id="L755"> <span class="tok-str">\\ERROR: illegal char '\' at position 2: incomplete escape</span></span>
<span class="line" id="L756"> );</span>
<span class="line" id="L757"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">" \\"</span>,</span>
<span class="line" id="L758"> <span class="tok-str">\\ERROR: illegal char '\' at position 1: incomplete escape</span></span>
<span class="line" id="L759"> );</span>
<span class="line" id="L760">}</span>
<span class="line" id="L761"></span>
<span class="line" id="L762"><span class="tok-kw">test</span> <span class="tok-str">"error incomplete escape - dollar_sign"</span> {</span>
<span class="line" id="L763"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">"$"</span>,</span>
<span class="line" id="L764"> <span class="tok-str">\\ERROR: illegal char '$' at position 0: incomplete escape</span></span>
<span class="line" id="L765"> );</span>
<span class="line" id="L766"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">"\t$"</span>,</span>
<span class="line" id="L767"> <span class="tok-str">\\ERROR: illegal char '$' at position 1: incomplete escape</span></span>
<span class="line" id="L768"> );</span>
<span class="line" id="L769"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">"\n$"</span>,</span>
<span class="line" id="L770"> <span class="tok-str">\\ERROR: illegal char '$' at position 1: incomplete escape</span></span>
<span class="line" id="L771"> );</span>
<span class="line" id="L772"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">"\r$"</span>,</span>
<span class="line" id="L773"> <span class="tok-str">\\ERROR: illegal char '$' at position 1: incomplete escape</span></span>
<span class="line" id="L774"> );</span>
<span class="line" id="L775"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">"\r\n$"</span>,</span>
<span class="line" id="L776"> <span class="tok-str">\\ERROR: illegal char '$' at position 2: incomplete escape</span></span>
<span class="line" id="L777"> );</span>
<span class="line" id="L778"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">" $"</span>,</span>
<span class="line" id="L779"> <span class="tok-str">\\ERROR: illegal char '$' at position 1: incomplete escape</span></span>
<span class="line" id="L780"> );</span>
<span class="line" id="L781">}</span>
<span class="line" id="L782"></span>
<span class="line" id="L783"><span class="tok-kw">test</span> <span class="tok-str">"error incomplete target"</span> {</span>
<span class="line" id="L784"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">"foo.o"</span>,</span>
<span class="line" id="L785"> <span class="tok-str">\\ERROR: incomplete target 'foo.o' at position 0</span></span>
<span class="line" id="L786"> );</span>
<span class="line" id="L787"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">"\tfoo.o"</span>,</span>
<span class="line" id="L788"> <span class="tok-str">\\ERROR: incomplete target 'foo.o' at position 1</span></span>
<span class="line" id="L789"> );</span>
<span class="line" id="L790"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">"\nfoo.o"</span>,</span>
<span class="line" id="L791"> <span class="tok-str">\\ERROR: incomplete target 'foo.o' at position 1</span></span>
<span class="line" id="L792"> );</span>
<span class="line" id="L793"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">"\rfoo.o"</span>,</span>
<span class="line" id="L794"> <span class="tok-str">\\ERROR: incomplete target 'foo.o' at position 1</span></span>
<span class="line" id="L795"> );</span>
<span class="line" id="L796"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">"\r\nfoo.o"</span>,</span>
<span class="line" id="L797"> <span class="tok-str">\\ERROR: incomplete target 'foo.o' at position 2</span></span>
<span class="line" id="L798"> );</span>
<span class="line" id="L799"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">" foo.o"</span>,</span>
<span class="line" id="L800"> <span class="tok-str">\\ERROR: incomplete target 'foo.o' at position 1</span></span>
<span class="line" id="L801"> );</span>
<span class="line" id="L802"></span>
<span class="line" id="L803"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">"\\ foo.o"</span>,</span>
<span class="line" id="L804"> <span class="tok-str">\\ERROR: incomplete target ' foo.o' at position 0</span></span>
<span class="line" id="L805"> );</span>
<span class="line" id="L806"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">"\\#foo.o"</span>,</span>
<span class="line" id="L807"> <span class="tok-str">\\ERROR: incomplete target '#foo.o' at position 0</span></span>
<span class="line" id="L808"> );</span>
<span class="line" id="L809"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">"\\\\foo.o"</span>,</span>
<span class="line" id="L810"> <span class="tok-str">\\ERROR: incomplete target '\foo.o' at position 0</span></span>
<span class="line" id="L811"> );</span>
<span class="line" id="L812"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">"$$foo.o"</span>,</span>
<span class="line" id="L813"> <span class="tok-str">\\ERROR: incomplete target '$foo.o' at position 0</span></span>
<span class="line" id="L814"> );</span>
<span class="line" id="L815">}</span>
<span class="line" id="L816"></span>
<span class="line" id="L817"><span class="tok-kw">test</span> <span class="tok-str">"error illegal char at position - bad target escape"</span> {</span>
<span class="line" id="L818"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">"\\\t"</span>,</span>
<span class="line" id="L819"> <span class="tok-str">\\ERROR: illegal char \x09 at position 1: bad target escape</span></span>
<span class="line" id="L820"> );</span>
<span class="line" id="L821"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">"\\\n"</span>,</span>
<span class="line" id="L822"> <span class="tok-str">\\ERROR: illegal char \x0A at position 1: bad target escape</span></span>
<span class="line" id="L823"> );</span>
<span class="line" id="L824"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">"\\\r"</span>,</span>
<span class="line" id="L825"> <span class="tok-str">\\ERROR: illegal char \x0D at position 1: bad target escape</span></span>
<span class="line" id="L826"> );</span>
<span class="line" id="L827"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">"\\\r\n"</span>,</span>
<span class="line" id="L828"> <span class="tok-str">\\ERROR: illegal char \x0D at position 1: bad target escape</span></span>
<span class="line" id="L829"> );</span>
<span class="line" id="L830">}</span>
<span class="line" id="L831"></span>
<span class="line" id="L832"><span class="tok-kw">test</span> <span class="tok-str">"error illegal char at position - expecting dollar_sign"</span> {</span>
<span class="line" id="L833"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">"$\t"</span>,</span>
<span class="line" id="L834"> <span class="tok-str">\\ERROR: illegal char \x09 at position 1: expecting '$'</span></span>
<span class="line" id="L835"> );</span>
<span class="line" id="L836"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">"$\n"</span>,</span>
<span class="line" id="L837"> <span class="tok-str">\\ERROR: illegal char \x0A at position 1: expecting '$'</span></span>
<span class="line" id="L838"> );</span>
<span class="line" id="L839"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">"$\r"</span>,</span>
<span class="line" id="L840"> <span class="tok-str">\\ERROR: illegal char \x0D at position 1: expecting '$'</span></span>
<span class="line" id="L841"> );</span>
<span class="line" id="L842"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">"$\r\n"</span>,</span>
<span class="line" id="L843"> <span class="tok-str">\\ERROR: illegal char \x0D at position 1: expecting '$'</span></span>
<span class="line" id="L844"> );</span>
<span class="line" id="L845">}</span>
<span class="line" id="L846"></span>
<span class="line" id="L847"><span class="tok-kw">test</span> <span class="tok-str">"error illegal char at position - invalid target"</span> {</span>
<span class="line" id="L848"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">"foo\t.o"</span>,</span>
<span class="line" id="L849"> <span class="tok-str">\\ERROR: illegal char \x09 at position 3: invalid target</span></span>
<span class="line" id="L850"> );</span>
<span class="line" id="L851"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">"foo\n.o"</span>,</span>
<span class="line" id="L852"> <span class="tok-str">\\ERROR: illegal char \x0A at position 3: invalid target</span></span>
<span class="line" id="L853"> );</span>
<span class="line" id="L854"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">"foo\r.o"</span>,</span>
<span class="line" id="L855"> <span class="tok-str">\\ERROR: illegal char \x0D at position 3: invalid target</span></span>
<span class="line" id="L856"> );</span>
<span class="line" id="L857"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">"foo\r\n.o"</span>,</span>
<span class="line" id="L858"> <span class="tok-str">\\ERROR: illegal char \x0D at position 3: invalid target</span></span>
<span class="line" id="L859"> );</span>
<span class="line" id="L860">}</span>
<span class="line" id="L861"></span>
<span class="line" id="L862"><span class="tok-kw">test</span> <span class="tok-str">"error target - continuation expecting end-of-line"</span> {</span>
<span class="line" id="L863"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">"foo.o: \\\t"</span>,</span>
<span class="line" id="L864"> <span class="tok-str">\\target = {foo.o}</span></span>
<span class="line" id="L865"> <span class="tok-str">\\ERROR: illegal char \x09 at position 8: continuation expecting end-of-line</span></span>
<span class="line" id="L866"> );</span>
<span class="line" id="L867"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">"foo.o: \\ "</span>,</span>
<span class="line" id="L868"> <span class="tok-str">\\target = {foo.o}</span></span>
<span class="line" id="L869"> <span class="tok-str">\\ERROR: illegal char ' ' at position 8: continuation expecting end-of-line</span></span>
<span class="line" id="L870"> );</span>
<span class="line" id="L871"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">"foo.o: \\x"</span>,</span>
<span class="line" id="L872"> <span class="tok-str">\\target = {foo.o}</span></span>
<span class="line" id="L873"> <span class="tok-str">\\ERROR: illegal char 'x' at position 8: continuation expecting end-of-line</span></span>
<span class="line" id="L874"> );</span>
<span class="line" id="L875"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">"foo.o: \\\x0dx"</span>,</span>
<span class="line" id="L876"> <span class="tok-str">\\target = {foo.o}</span></span>
<span class="line" id="L877"> <span class="tok-str">\\ERROR: illegal char 'x' at position 9: continuation expecting end-of-line</span></span>
<span class="line" id="L878"> );</span>
<span class="line" id="L879">}</span>
<span class="line" id="L880"></span>
<span class="line" id="L881"><span class="tok-kw">test</span> <span class="tok-str">"error prereq - continuation expecting end-of-line"</span> {</span>
<span class="line" id="L882"> <span class="tok-kw">try</span> depTokenizer(<span class="tok-str">"foo.o: foo.h\\\x0dx"</span>,</span>
<span class="line" id="L883"> <span class="tok-str">\\target = {foo.o}</span></span>
<span class="line" id="L884"> <span class="tok-str">\\ERROR: illegal char 'x' at position 14: continuation expecting end-of-line</span></span>
<span class="line" id="L885"> );</span>
<span class="line" id="L886">}</span>
<span class="line" id="L887"></span>
<span class="line" id="L888"><span class="tok-comment">// - tokenize input, emit textual representation, and compare to expect</span>
</span>
<span class="line" id="L889"><span class="tok-kw">fn</span> <span class="tok-fn">depTokenizer</span>(input: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>, expect: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) !<span class="tok-type">void</span> {</span>
<span class="line" id="L890"> <span class="tok-kw">var</span> arena_allocator = std.heap.ArenaAllocator.init(std.testing.allocator);</span>
<span class="line" id="L891"> <span class="tok-kw">const</span> arena = arena_allocator.allocator();</span>
<span class="line" id="L892"> <span class="tok-kw">defer</span> arena_allocator.deinit();</span>
<span class="line" id="L893"></span>
<span class="line" id="L894"> <span class="tok-kw">var</span> it: Tokenizer = .{ .bytes = input };</span>
<span class="line" id="L895"> <span class="tok-kw">var</span> buffer = std.ArrayList(<span class="tok-type">u8</span>).init(arena);</span>
<span class="line" id="L896"> <span class="tok-kw">var</span> resolve_buf = std.ArrayList(<span class="tok-type">u8</span>).init(arena);</span>
<span class="line" id="L897"> <span class="tok-kw">var</span> i: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L898"> <span class="tok-kw">while</span> (it.next()) |token| {</span>
<span class="line" id="L899"> <span class="tok-kw">if</span> (i != <span class="tok-number">0</span>) <span class="tok-kw">try</span> buffer.appendSlice(<span class="tok-str">"\n"</span>);</span>
<span class="line" id="L900"> <span class="tok-kw">switch</span> (token) {</span>
<span class="line" id="L901"> .target, .prereq => |bytes| {</span>
<span class="line" id="L902"> <span class="tok-kw">try</span> buffer.appendSlice(<span class="tok-builtin">@tagName</span>(token));</span>
<span class="line" id="L903"> <span class="tok-kw">try</span> buffer.appendSlice(<span class="tok-str">" = {"</span>);</span>
<span class="line" id="L904"> <span class="tok-kw">for</span> (bytes) |b| {</span>
<span class="line" id="L905"> <span class="tok-kw">try</span> buffer.append(printable_char_tab[b]);</span>
<span class="line" id="L906"> }</span>
<span class="line" id="L907"> <span class="tok-kw">try</span> buffer.appendSlice(<span class="tok-str">"}"</span>);</span>
<span class="line" id="L908"> },</span>
<span class="line" id="L909"> .target_must_resolve => {</span>
<span class="line" id="L910"> <span class="tok-kw">try</span> buffer.appendSlice(<span class="tok-str">"target = {"</span>);</span>
<span class="line" id="L911"> <span class="tok-kw">try</span> token.resolve(resolve_buf.writer());</span>
<span class="line" id="L912"> <span class="tok-kw">for</span> (resolve_buf.items) |b| {</span>
<span class="line" id="L913"> <span class="tok-kw">try</span> buffer.append(printable_char_tab[b]);</span>
<span class="line" id="L914"> }</span>
<span class="line" id="L915"> resolve_buf.items.len = <span class="tok-number">0</span>;</span>
<span class="line" id="L916"> <span class="tok-kw">try</span> buffer.appendSlice(<span class="tok-str">"}"</span>);</span>
<span class="line" id="L917"> },</span>
<span class="line" id="L918"> <span class="tok-kw">else</span> => {</span>
<span class="line" id="L919"> <span class="tok-kw">try</span> buffer.appendSlice(<span class="tok-str">"ERROR: "</span>);</span>
<span class="line" id="L920"> <span class="tok-kw">try</span> token.printError(buffer.writer());</span>
<span class="line" id="L921"> <span class="tok-kw">break</span>;</span>
<span class="line" id="L922"> },</span>
<span class="line" id="L923"> }</span>
<span class="line" id="L924"> i += <span class="tok-number">1</span>;</span>
<span class="line" id="L925"> }</span>
<span class="line" id="L926"></span>
<span class="line" id="L927"> <span class="tok-kw">if</span> (std.mem.eql(<span class="tok-type">u8</span>, expect, buffer.items)) {</span>
<span class="line" id="L928"> <span class="tok-kw">try</span> testing.expect(<span class="tok-null">true</span>);</span>
<span class="line" id="L929"> <span class="tok-kw">return</span>;</span>
<span class="line" id="L930"> }</span>
<span class="line" id="L931"></span>
<span class="line" id="L932"> <span class="tok-kw">const</span> out = std.io.getStdErr().writer();</span>
<span class="line" id="L933"></span>
<span class="line" id="L934"> <span class="tok-kw">try</span> out.writeAll(<span class="tok-str">"\n"</span>);</span>
<span class="line" id="L935"> <span class="tok-kw">try</span> printSection(out, <span class="tok-str">"<<<< input"</span>, input);</span>
<span class="line" id="L936"> <span class="tok-kw">try</span> printSection(out, <span class="tok-str">"==== expect"</span>, expect);</span>
<span class="line" id="L937"> <span class="tok-kw">try</span> printSection(out, <span class="tok-str">">>>> got"</span>, buffer.items);</span>
<span class="line" id="L938"> <span class="tok-kw">try</span> printRuler(out);</span>
<span class="line" id="L939"></span>
<span class="line" id="L940"> <span class="tok-kw">try</span> testing.expect(<span class="tok-null">false</span>);</span>
<span class="line" id="L941">}</span>
<span class="line" id="L942"></span>
<span class="line" id="L943"><span class="tok-kw">fn</span> <span class="tok-fn">printSection</span>(out: <span class="tok-kw">anytype</span>, label: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>, bytes: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) !<span class="tok-type">void</span> {</span>
<span class="line" id="L944"> <span class="tok-kw">try</span> printLabel(out, label, bytes);</span>
<span class="line" id="L945"> <span class="tok-kw">try</span> hexDump(out, bytes);</span>
<span class="line" id="L946"> <span class="tok-kw">try</span> printRuler(out);</span>
<span class="line" id="L947"> <span class="tok-kw">try</span> out.writeAll(bytes);</span>
<span class="line" id="L948"> <span class="tok-kw">try</span> out.writeAll(<span class="tok-str">"\n"</span>);</span>
<span class="line" id="L949">}</span>
<span class="line" id="L950"></span>
<span class="line" id="L951"><span class="tok-kw">fn</span> <span class="tok-fn">printLabel</span>(out: <span class="tok-kw">anytype</span>, label: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>, bytes: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) !<span class="tok-type">void</span> {</span>
<span class="line" id="L952"> <span class="tok-kw">var</span> buf: [<span class="tok-number">80</span>]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L953"> <span class="tok-kw">var</span> text = <span class="tok-kw">try</span> std.fmt.bufPrint(buf[<span class="tok-number">0</span>..], <span class="tok-str">"{s} {d} bytes "</span>, .{ label, bytes.len });</span>
<span class="line" id="L954"> <span class="tok-kw">try</span> out.writeAll(text);</span>
<span class="line" id="L955"> <span class="tok-kw">var</span> i: <span class="tok-type">usize</span> = text.len;</span>
<span class="line" id="L956"> <span class="tok-kw">const</span> end = <span class="tok-number">79</span>;</span>
<span class="line" id="L957"> <span class="tok-kw">while</span> (i < end) : (i += <span class="tok-number">1</span>) {</span>
<span class="line" id="L958"> <span class="tok-kw">try</span> out.writeAll(&[_]<span class="tok-type">u8</span>{label[<span class="tok-number">0</span>]});</span>
<span class="line" id="L959"> }</span>
<span class="line" id="L960"> <span class="tok-kw">try</span> out.writeAll(<span class="tok-str">"\n"</span>);</span>
<span class="line" id="L961">}</span>
<span class="line" id="L962"></span>
<span class="line" id="L963"><span class="tok-kw">fn</span> <span class="tok-fn">printRuler</span>(out: <span class="tok-kw">anytype</span>) !<span class="tok-type">void</span> {</span>
<span class="line" id="L964"> <span class="tok-kw">var</span> i: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L965"> <span class="tok-kw">const</span> end = <span class="tok-number">79</span>;</span>
<span class="line" id="L966"> <span class="tok-kw">while</span> (i < end) : (i += <span class="tok-number">1</span>) {</span>
<span class="line" id="L967"> <span class="tok-kw">try</span> out.writeAll(<span class="tok-str">"-"</span>);</span>
<span class="line" id="L968"> }</span>
<span class="line" id="L969"> <span class="tok-kw">try</span> out.writeAll(<span class="tok-str">"\n"</span>);</span>
<span class="line" id="L970">}</span>
<span class="line" id="L971"></span>
<span class="line" id="L972"><span class="tok-kw">fn</span> <span class="tok-fn">hexDump</span>(out: <span class="tok-kw">anytype</span>, bytes: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) !<span class="tok-type">void</span> {</span>
<span class="line" id="L973"> <span class="tok-kw">const</span> n16 = bytes.len >> <span class="tok-number">4</span>;</span>
<span class="line" id="L974"> <span class="tok-kw">var</span> line: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L975"> <span class="tok-kw">var</span> offset: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L976"> <span class="tok-kw">while</span> (line < n16) : (line += <span class="tok-number">1</span>) {</span>
<span class="line" id="L977"> <span class="tok-kw">try</span> hexDump16(out, offset, bytes[offset..][<span class="tok-number">0</span>..<span class="tok-number">16</span>]);</span>
<span class="line" id="L978"> offset += <span class="tok-number">16</span>;</span>
<span class="line" id="L979"> }</span>
<span class="line" id="L980"></span>
<span class="line" id="L981"> <span class="tok-kw">const</span> n = bytes.len & <span class="tok-number">0x0f</span>;</span>
<span class="line" id="L982"> <span class="tok-kw">if</span> (n > <span class="tok-number">0</span>) {</span>
<span class="line" id="L983"> <span class="tok-kw">try</span> printDecValue(out, offset, <span class="tok-number">8</span>);</span>
<span class="line" id="L984"> <span class="tok-kw">try</span> out.writeAll(<span class="tok-str">":"</span>);</span>
<span class="line" id="L985"> <span class="tok-kw">try</span> out.writeAll(<span class="tok-str">" "</span>);</span>
<span class="line" id="L986"> <span class="tok-kw">var</span> end1 = <span class="tok-builtin">@min</span>(offset + n, offset + <span class="tok-number">8</span>);</span>
<span class="line" id="L987"> <span class="tok-kw">for</span> (bytes[offset..end1]) |b| {</span>
<span class="line" id="L988"> <span class="tok-kw">try</span> out.writeAll(<span class="tok-str">" "</span>);</span>
<span class="line" id="L989"> <span class="tok-kw">try</span> printHexValue(out, b, <span class="tok-number">2</span>);</span>
<span class="line" id="L990"> }</span>
<span class="line" id="L991"> <span class="tok-kw">var</span> end2 = offset + n;</span>
<span class="line" id="L992"> <span class="tok-kw">if</span> (end2 > end1) {</span>
<span class="line" id="L993"> <span class="tok-kw">try</span> out.writeAll(<span class="tok-str">" "</span>);</span>
<span class="line" id="L994"> <span class="tok-kw">for</span> (bytes[end1..end2]) |b| {</span>
<span class="line" id="L995"> <span class="tok-kw">try</span> out.writeAll(<span class="tok-str">" "</span>);</span>
<span class="line" id="L996"> <span class="tok-kw">try</span> printHexValue(out, b, <span class="tok-number">2</span>);</span>
<span class="line" id="L997"> }</span>
<span class="line" id="L998"> }</span>
<span class="line" id="L999"> <span class="tok-kw">const</span> short = <span class="tok-number">16</span> - n;</span>
<span class="line" id="L1000"> <span class="tok-kw">var</span> i: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L1001"> <span class="tok-kw">while</span> (i < short) : (i += <span class="tok-number">1</span>) {</span>
<span class="line" id="L1002"> <span class="tok-kw">try</span> out.writeAll(<span class="tok-str">" "</span>);</span>
<span class="line" id="L1003"> }</span>
<span class="line" id="L1004"> <span class="tok-kw">if</span> (end2 > end1) {</span>
<span class="line" id="L1005"> <span class="tok-kw">try</span> out.writeAll(<span class="tok-str">" |"</span>);</span>
<span class="line" id="L1006"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L1007"> <span class="tok-kw">try</span> out.writeAll(<span class="tok-str">" |"</span>);</span>
<span class="line" id="L1008"> }</span>
<span class="line" id="L1009"> <span class="tok-kw">try</span> printCharValues(out, bytes[offset..end2]);</span>
<span class="line" id="L1010"> <span class="tok-kw">try</span> out.writeAll(<span class="tok-str">"|\n"</span>);</span>
<span class="line" id="L1011"> offset += n;</span>
<span class="line" id="L1012"> }</span>
<span class="line" id="L1013"></span>
<span class="line" id="L1014"> <span class="tok-kw">try</span> printDecValue(out, offset, <span class="tok-number">8</span>);</span>
<span class="line" id="L1015"> <span class="tok-kw">try</span> out.writeAll(<span class="tok-str">":"</span>);</span>
<span class="line" id="L1016"> <span class="tok-kw">try</span> out.writeAll(<span class="tok-str">"\n"</span>);</span>
<span class="line" id="L1017">}</span>
<span class="line" id="L1018"></span>
<span class="line" id="L1019"><span class="tok-kw">fn</span> <span class="tok-fn">hexDump16</span>(out: <span class="tok-kw">anytype</span>, offset: <span class="tok-type">usize</span>, bytes: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) !<span class="tok-type">void</span> {</span>
<span class="line" id="L1020"> <span class="tok-kw">try</span> printDecValue(out, offset, <span class="tok-number">8</span>);</span>
<span class="line" id="L1021"> <span class="tok-kw">try</span> out.writeAll(<span class="tok-str">":"</span>);</span>
<span class="line" id="L1022"> <span class="tok-kw">try</span> out.writeAll(<span class="tok-str">" "</span>);</span>
<span class="line" id="L1023"> <span class="tok-kw">for</span> (bytes[<span class="tok-number">0</span>..<span class="tok-number">8</span>]) |b| {</span>
<span class="line" id="L1024"> <span class="tok-kw">try</span> out.writeAll(<span class="tok-str">" "</span>);</span>
<span class="line" id="L1025"> <span class="tok-kw">try</span> printHexValue(out, b, <span class="tok-number">2</span>);</span>
<span class="line" id="L1026"> }</span>
<span class="line" id="L1027"> <span class="tok-kw">try</span> out.writeAll(<span class="tok-str">" "</span>);</span>
<span class="line" id="L1028"> <span class="tok-kw">for</span> (bytes[<span class="tok-number">8</span>..<span class="tok-number">16</span>]) |b| {</span>
<span class="line" id="L1029"> <span class="tok-kw">try</span> out.writeAll(<span class="tok-str">" "</span>);</span>
<span class="line" id="L1030"> <span class="tok-kw">try</span> printHexValue(out, b, <span class="tok-number">2</span>);</span>
<span class="line" id="L1031"> }</span>
<span class="line" id="L1032"> <span class="tok-kw">try</span> out.writeAll(<span class="tok-str">" |"</span>);</span>
<span class="line" id="L1033"> <span class="tok-kw">try</span> printCharValues(out, bytes);</span>
<span class="line" id="L1034"> <span class="tok-kw">try</span> out.writeAll(<span class="tok-str">"|\n"</span>);</span>
<span class="line" id="L1035">}</span>
<span class="line" id="L1036"></span>
<span class="line" id="L1037"><span class="tok-kw">fn</span> <span class="tok-fn">printDecValue</span>(out: <span class="tok-kw">anytype</span>, value: <span class="tok-type">u64</span>, width: <span class="tok-type">u8</span>) !<span class="tok-type">void</span> {</span>
<span class="line" id="L1038"> <span class="tok-kw">var</span> buffer: [<span class="tok-number">20</span>]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L1039"> <span class="tok-kw">const</span> len = std.fmt.formatIntBuf(buffer[<span class="tok-number">0</span>..], value, <span class="tok-number">10</span>, .lower, .{ .width = width, .fill = <span class="tok-str">'0'</span> });</span>
<span class="line" id="L1040"> <span class="tok-kw">try</span> out.writeAll(buffer[<span class="tok-number">0</span>..len]);</span>
<span class="line" id="L1041">}</span>
<span class="line" id="L1042"></span>
<span class="line" id="L1043"><span class="tok-kw">fn</span> <span class="tok-fn">printHexValue</span>(out: <span class="tok-kw">anytype</span>, value: <span class="tok-type">u64</span>, width: <span class="tok-type">u8</span>) !<span class="tok-type">void</span> {</span>
<span class="line" id="L1044"> <span class="tok-kw">var</span> buffer: [<span class="tok-number">16</span>]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L1045"> <span class="tok-kw">const</span> len = std.fmt.formatIntBuf(buffer[<span class="tok-number">0</span>..], value, <span class="tok-number">16</span>, .lower, .{ .width = width, .fill = <span class="tok-str">'0'</span> });</span>
<span class="line" id="L1046"> <span class="tok-kw">try</span> out.writeAll(buffer[<span class="tok-number">0</span>..len]);</span>
<span class="line" id="L1047">}</span>
<span class="line" id="L1048"></span>
<span class="line" id="L1049"><span class="tok-kw">fn</span> <span class="tok-fn">printCharValues</span>(out: <span class="tok-kw">anytype</span>, bytes: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) !<span class="tok-type">void</span> {</span>
<span class="line" id="L1050"> <span class="tok-kw">for</span> (bytes) |b| {</span>
<span class="line" id="L1051"> <span class="tok-kw">try</span> out.writeAll(&[_]<span class="tok-type">u8</span>{printable_char_tab[b]});</span>
<span class="line" id="L1052"> }</span>
<span class="line" id="L1053">}</span>
<span class="line" id="L1054"></span>
<span class="line" id="L1055"><span class="tok-kw">fn</span> <span class="tok-fn">printUnderstandableChar</span>(out: <span class="tok-kw">anytype</span>, char: <span class="tok-type">u8</span>) !<span class="tok-type">void</span> {</span>
<span class="line" id="L1056"> <span class="tok-kw">if</span> (std.ascii.isPrint(char)) {</span>
<span class="line" id="L1057"> <span class="tok-kw">try</span> out.print(<span class="tok-str">"'{c}'"</span>, .{char});</span>
<span class="line" id="L1058"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L1059"> <span class="tok-kw">try</span> out.print(<span class="tok-str">"\\x{X:0>2}"</span>, .{char});</span>
<span class="line" id="L1060"> }</span>
<span class="line" id="L1061">}</span>
<span class="line" id="L1062"></span>
<span class="line" id="L1063"><span class="tok-comment">// zig fmt: off</span>
</span>
<span class="line" id="L1064"><span class="tok-kw">const</span> printable_char_tab: [<span class="tok-number">256</span>]<span class="tok-type">u8</span> = (</span>
<span class="line" id="L1065"> <span class="tok-str">"................................ !\"#$%&'()*+,-./0123456789:;<=>?"</span> ++</span>
<span class="line" id="L1066"> <span class="tok-str">"@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~."</span> ++</span>
<span class="line" id="L1067"> <span class="tok-str">"................................................................"</span> ++</span>
<span class="line" id="L1068"> <span class="tok-str">"................................................................"</span></span>
<span class="line" id="L1069">).*;</span>
<span class="line" id="L1070"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/heap/logging_allocator.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>heap/logging_allocator.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../std.zig"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> Allocator = std.mem.Allocator;</span>
<span class="line" id="L3"></span>
<span class="line" id="L4"><span class="tok-comment">/// This allocator is used in front of another allocator and logs to `std.log`</span></span>
<span class="line" id="L5"><span class="tok-comment">/// on every call to the allocator.</span></span>
<span class="line" id="L6"><span class="tok-comment">/// For logging to a `std.io.Writer` see `std.heap.LogToWriterAllocator`</span></span>
<span class="line" id="L7"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">LoggingAllocator</span>(</span>
<span class="line" id="L8"> <span class="tok-kw">comptime</span> success_log_level: std.log.Level,</span>
<span class="line" id="L9"> <span class="tok-kw">comptime</span> failure_log_level: std.log.Level,</span>
<span class="line" id="L10">) <span class="tok-type">type</span> {</span>
<span class="line" id="L11"> <span class="tok-kw">return</span> ScopedLoggingAllocator(.default, success_log_level, failure_log_level);</span>
<span class="line" id="L12">}</span>
<span class="line" id="L13"></span>
<span class="line" id="L14"><span class="tok-comment">/// This allocator is used in front of another allocator and logs to `std.log`</span></span>
<span class="line" id="L15"><span class="tok-comment">/// with the given scope on every call to the allocator.</span></span>
<span class="line" id="L16"><span class="tok-comment">/// For logging to a `std.io.Writer` see `std.heap.LogToWriterAllocator`</span></span>
<span class="line" id="L17"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">ScopedLoggingAllocator</span>(</span>
<span class="line" id="L18"> <span class="tok-kw">comptime</span> scope: <span class="tok-builtin">@Type</span>(.EnumLiteral),</span>
<span class="line" id="L19"> <span class="tok-kw">comptime</span> success_log_level: std.log.Level,</span>
<span class="line" id="L20"> <span class="tok-kw">comptime</span> failure_log_level: std.log.Level,</span>
<span class="line" id="L21">) <span class="tok-type">type</span> {</span>
<span class="line" id="L22"> <span class="tok-kw">const</span> log = std.log.scoped(scope);</span>
<span class="line" id="L23"></span>
<span class="line" id="L24"> <span class="tok-kw">return</span> <span class="tok-kw">struct</span> {</span>
<span class="line" id="L25"> parent_allocator: Allocator,</span>
<span class="line" id="L26"></span>
<span class="line" id="L27"> <span class="tok-kw">const</span> Self = <span class="tok-builtin">@This</span>();</span>
<span class="line" id="L28"></span>
<span class="line" id="L29"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">init</span>(parent_allocator: Allocator) Self {</span>
<span class="line" id="L30"> <span class="tok-kw">return</span> .{</span>
<span class="line" id="L31"> .parent_allocator = parent_allocator,</span>
<span class="line" id="L32"> };</span>
<span class="line" id="L33"> }</span>
<span class="line" id="L34"></span>
<span class="line" id="L35"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">allocator</span>(self: *Self) Allocator {</span>
<span class="line" id="L36"> <span class="tok-kw">return</span> .{</span>
<span class="line" id="L37"> .ptr = self,</span>
<span class="line" id="L38"> .vtable = &.{</span>
<span class="line" id="L39"> .alloc = alloc,</span>
<span class="line" id="L40"> .resize = resize,</span>
<span class="line" id="L41"> .free = free,</span>
<span class="line" id="L42"> },</span>
<span class="line" id="L43"> };</span>
<span class="line" id="L44"> }</span>
<span class="line" id="L45"></span>
<span class="line" id="L46"> <span class="tok-comment">// This function is required as the `std.log.log` function is not public</span>
</span>
<span class="line" id="L47"> <span class="tok-kw">inline</span> <span class="tok-kw">fn</span> <span class="tok-fn">logHelper</span>(<span class="tok-kw">comptime</span> log_level: std.log.Level, <span class="tok-kw">comptime</span> format: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>, args: <span class="tok-kw">anytype</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L48"> <span class="tok-kw">switch</span> (log_level) {</span>
<span class="line" id="L49"> .err => log.err(format, args),</span>
<span class="line" id="L50"> .warn => log.warn(format, args),</span>
<span class="line" id="L51"> .info => log.info(format, args),</span>
<span class="line" id="L52"> .debug => log.debug(format, args),</span>
<span class="line" id="L53"> }</span>
<span class="line" id="L54"> }</span>
<span class="line" id="L55"></span>
<span class="line" id="L56"> <span class="tok-kw">fn</span> <span class="tok-fn">alloc</span>(</span>
<span class="line" id="L57"> ctx: *<span class="tok-type">anyopaque</span>,</span>
<span class="line" id="L58"> len: <span class="tok-type">usize</span>,</span>
<span class="line" id="L59"> log2_ptr_align: <span class="tok-type">u8</span>,</span>
<span class="line" id="L60"> ra: <span class="tok-type">usize</span>,</span>
<span class="line" id="L61"> ) ?[*]<span class="tok-type">u8</span> {</span>
<span class="line" id="L62"> <span class="tok-kw">const</span> self: *Self = <span class="tok-builtin">@ptrCast</span>(<span class="tok-builtin">@alignCast</span>(ctx));</span>
<span class="line" id="L63"> <span class="tok-kw">const</span> result = self.parent_allocator.rawAlloc(len, log2_ptr_align, ra);</span>
<span class="line" id="L64"> <span class="tok-kw">if</span> (result != <span class="tok-null">null</span>) {</span>
<span class="line" id="L65"> logHelper(</span>
<span class="line" id="L66"> success_log_level,</span>
<span class="line" id="L67"> <span class="tok-str">"alloc - success - len: {}, ptr_align: {}"</span>,</span>
<span class="line" id="L68"> .{ len, log2_ptr_align },</span>
<span class="line" id="L69"> );</span>
<span class="line" id="L70"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L71"> logHelper(</span>
<span class="line" id="L72"> failure_log_level,</span>
<span class="line" id="L73"> <span class="tok-str">"alloc - failure: OutOfMemory - len: {}, ptr_align: {}"</span>,</span>
<span class="line" id="L74"> .{ len, log2_ptr_align },</span>
<span class="line" id="L75"> );</span>
<span class="line" id="L76"> }</span>
<span class="line" id="L77"> <span class="tok-kw">return</span> result;</span>
<span class="line" id="L78"> }</span>
<span class="line" id="L79"></span>
<span class="line" id="L80"> <span class="tok-kw">fn</span> <span class="tok-fn">resize</span>(</span>
<span class="line" id="L81"> ctx: *<span class="tok-type">anyopaque</span>,</span>
<span class="line" id="L82"> buf: []<span class="tok-type">u8</span>,</span>
<span class="line" id="L83"> log2_buf_align: <span class="tok-type">u8</span>,</span>
<span class="line" id="L84"> new_len: <span class="tok-type">usize</span>,</span>
<span class="line" id="L85"> ra: <span class="tok-type">usize</span>,</span>
<span class="line" id="L86"> ) <span class="tok-type">bool</span> {</span>
<span class="line" id="L87"> <span class="tok-kw">const</span> self: *Self = <span class="tok-builtin">@ptrCast</span>(<span class="tok-builtin">@alignCast</span>(ctx));</span>
<span class="line" id="L88"> <span class="tok-kw">if</span> (self.parent_allocator.rawResize(buf, log2_buf_align, new_len, ra)) {</span>
<span class="line" id="L89"> <span class="tok-kw">if</span> (new_len <= buf.len) {</span>
<span class="line" id="L90"> logHelper(</span>
<span class="line" id="L91"> success_log_level,</span>
<span class="line" id="L92"> <span class="tok-str">"shrink - success - {} to {}, buf_align: {}"</span>,</span>
<span class="line" id="L93"> .{ buf.len, new_len, log2_buf_align },</span>
<span class="line" id="L94"> );</span>
<span class="line" id="L95"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L96"> logHelper(</span>
<span class="line" id="L97"> success_log_level,</span>
<span class="line" id="L98"> <span class="tok-str">"expand - success - {} to {}, buf_align: {}"</span>,</span>
<span class="line" id="L99"> .{ buf.len, new_len, log2_buf_align },</span>
<span class="line" id="L100"> );</span>
<span class="line" id="L101"> }</span>
<span class="line" id="L102"></span>
<span class="line" id="L103"> <span class="tok-kw">return</span> <span class="tok-null">true</span>;</span>
<span class="line" id="L104"> }</span>
<span class="line" id="L105"></span>
<span class="line" id="L106"> std.debug.assert(new_len > buf.len);</span>
<span class="line" id="L107"> logHelper(</span>
<span class="line" id="L108"> failure_log_level,</span>
<span class="line" id="L109"> <span class="tok-str">"expand - failure - {} to {}, buf_align: {}"</span>,</span>
<span class="line" id="L110"> .{ buf.len, new_len, log2_buf_align },</span>
<span class="line" id="L111"> );</span>
<span class="line" id="L112"> <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L113"> }</span>
<span class="line" id="L114"></span>
<span class="line" id="L115"> <span class="tok-kw">fn</span> <span class="tok-fn">free</span>(</span>
<span class="line" id="L116"> ctx: *<span class="tok-type">anyopaque</span>,</span>
<span class="line" id="L117"> buf: []<span class="tok-type">u8</span>,</span>
<span class="line" id="L118"> log2_buf_align: <span class="tok-type">u8</span>,</span>
<span class="line" id="L119"> ra: <span class="tok-type">usize</span>,</span>
<span class="line" id="L120"> ) <span class="tok-type">void</span> {</span>
<span class="line" id="L121"> <span class="tok-kw">const</span> self: *Self = <span class="tok-builtin">@ptrCast</span>(<span class="tok-builtin">@alignCast</span>(ctx));</span>
<span class="line" id="L122"> self.parent_allocator.rawFree(buf, log2_buf_align, ra);</span>
<span class="line" id="L123"> logHelper(success_log_level, <span class="tok-str">"free - len: {}"</span>, .{buf.len});</span>
<span class="line" id="L124"> }</span>
<span class="line" id="L125"> };</span>
<span class="line" id="L126">}</span>
<span class="line" id="L127"></span>
<span class="line" id="L128"><span class="tok-comment">/// This allocator is used in front of another allocator and logs to `std.log`</span></span>
<span class="line" id="L129"><span class="tok-comment">/// on every call to the allocator.</span></span>
<span class="line" id="L130"><span class="tok-comment">/// For logging to a `std.io.Writer` see `std.heap.LogToWriterAllocator`</span></span>
<span class="line" id="L131"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">loggingAllocator</span>(parent_allocator: Allocator) LoggingAllocator(.debug, .err) {</span>
<span class="line" id="L132"> <span class="tok-kw">return</span> LoggingAllocator(.debug, .err).init(parent_allocator);</span>
<span class="line" id="L133">}</span>
<span class="line" id="L134"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/heap/log_to_writer_allocator.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>heap/log_to_writer_allocator.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../std.zig"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> Allocator = std.mem.Allocator;</span>
<span class="line" id="L3"></span>
<span class="line" id="L4"><span class="tok-comment">/// This allocator is used in front of another allocator and logs to the provided writer</span></span>
<span class="line" id="L5"><span class="tok-comment">/// on every call to the allocator. Writer errors are ignored.</span></span>
<span class="line" id="L6"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">LogToWriterAllocator</span>(<span class="tok-kw">comptime</span> Writer: <span class="tok-type">type</span>) <span class="tok-type">type</span> {</span>
<span class="line" id="L7"> <span class="tok-kw">return</span> <span class="tok-kw">struct</span> {</span>
<span class="line" id="L8"> parent_allocator: Allocator,</span>
<span class="line" id="L9"> writer: Writer,</span>
<span class="line" id="L10"></span>
<span class="line" id="L11"> <span class="tok-kw">const</span> Self = <span class="tok-builtin">@This</span>();</span>
<span class="line" id="L12"></span>
<span class="line" id="L13"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">init</span>(parent_allocator: Allocator, writer: Writer) Self {</span>
<span class="line" id="L14"> <span class="tok-kw">return</span> Self{</span>
<span class="line" id="L15"> .parent_allocator = parent_allocator,</span>
<span class="line" id="L16"> .writer = writer,</span>
<span class="line" id="L17"> };</span>
<span class="line" id="L18"> }</span>
<span class="line" id="L19"></span>
<span class="line" id="L20"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">allocator</span>(self: *Self) Allocator {</span>
<span class="line" id="L21"> <span class="tok-kw">return</span> .{</span>
<span class="line" id="L22"> .ptr = self,</span>
<span class="line" id="L23"> .vtable = &.{</span>
<span class="line" id="L24"> .alloc = alloc,</span>
<span class="line" id="L25"> .resize = resize,</span>
<span class="line" id="L26"> .free = free,</span>
<span class="line" id="L27"> },</span>
<span class="line" id="L28"> };</span>
<span class="line" id="L29"> }</span>
<span class="line" id="L30"></span>
<span class="line" id="L31"> <span class="tok-kw">fn</span> <span class="tok-fn">alloc</span>(</span>
<span class="line" id="L32"> ctx: *<span class="tok-type">anyopaque</span>,</span>
<span class="line" id="L33"> len: <span class="tok-type">usize</span>,</span>
<span class="line" id="L34"> log2_ptr_align: <span class="tok-type">u8</span>,</span>
<span class="line" id="L35"> ra: <span class="tok-type">usize</span>,</span>
<span class="line" id="L36"> ) ?[*]<span class="tok-type">u8</span> {</span>
<span class="line" id="L37"> <span class="tok-kw">const</span> self: *Self = <span class="tok-builtin">@ptrCast</span>(<span class="tok-builtin">@alignCast</span>(ctx));</span>
<span class="line" id="L38"> self.writer.print(<span class="tok-str">"alloc : {}"</span>, .{len}) <span class="tok-kw">catch</span> {};</span>
<span class="line" id="L39"> <span class="tok-kw">const</span> result = self.parent_allocator.rawAlloc(len, log2_ptr_align, ra);</span>
<span class="line" id="L40"> <span class="tok-kw">if</span> (result != <span class="tok-null">null</span>) {</span>
<span class="line" id="L41"> self.writer.print(<span class="tok-str">" success!\n"</span>, .{}) <span class="tok-kw">catch</span> {};</span>
<span class="line" id="L42"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L43"> self.writer.print(<span class="tok-str">" failure!\n"</span>, .{}) <span class="tok-kw">catch</span> {};</span>
<span class="line" id="L44"> }</span>
<span class="line" id="L45"> <span class="tok-kw">return</span> result;</span>
<span class="line" id="L46"> }</span>
<span class="line" id="L47"></span>
<span class="line" id="L48"> <span class="tok-kw">fn</span> <span class="tok-fn">resize</span>(</span>
<span class="line" id="L49"> ctx: *<span class="tok-type">anyopaque</span>,</span>
<span class="line" id="L50"> buf: []<span class="tok-type">u8</span>,</span>
<span class="line" id="L51"> log2_buf_align: <span class="tok-type">u8</span>,</span>
<span class="line" id="L52"> new_len: <span class="tok-type">usize</span>,</span>
<span class="line" id="L53"> ra: <span class="tok-type">usize</span>,</span>
<span class="line" id="L54"> ) <span class="tok-type">bool</span> {</span>
<span class="line" id="L55"> <span class="tok-kw">const</span> self: *Self = <span class="tok-builtin">@ptrCast</span>(<span class="tok-builtin">@alignCast</span>(ctx));</span>
<span class="line" id="L56"> <span class="tok-kw">if</span> (new_len <= buf.len) {</span>
<span class="line" id="L57"> self.writer.print(<span class="tok-str">"shrink: {} to {}\n"</span>, .{ buf.len, new_len }) <span class="tok-kw">catch</span> {};</span>
<span class="line" id="L58"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L59"> self.writer.print(<span class="tok-str">"expand: {} to {}"</span>, .{ buf.len, new_len }) <span class="tok-kw">catch</span> {};</span>
<span class="line" id="L60"> }</span>
<span class="line" id="L61"></span>
<span class="line" id="L62"> <span class="tok-kw">if</span> (self.parent_allocator.rawResize(buf, log2_buf_align, new_len, ra)) {</span>
<span class="line" id="L63"> <span class="tok-kw">if</span> (new_len > buf.len) {</span>
<span class="line" id="L64"> self.writer.print(<span class="tok-str">" success!\n"</span>, .{}) <span class="tok-kw">catch</span> {};</span>
<span class="line" id="L65"> }</span>
<span class="line" id="L66"> <span class="tok-kw">return</span> <span class="tok-null">true</span>;</span>
<span class="line" id="L67"> }</span>
<span class="line" id="L68"></span>
<span class="line" id="L69"> std.debug.assert(new_len > buf.len);</span>
<span class="line" id="L70"> self.writer.print(<span class="tok-str">" failure!\n"</span>, .{}) <span class="tok-kw">catch</span> {};</span>
<span class="line" id="L71"> <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L72"> }</span>
<span class="line" id="L73"></span>
<span class="line" id="L74"> <span class="tok-kw">fn</span> <span class="tok-fn">free</span>(</span>
<span class="line" id="L75"> ctx: *<span class="tok-type">anyopaque</span>,</span>
<span class="line" id="L76"> buf: []<span class="tok-type">u8</span>,</span>
<span class="line" id="L77"> log2_buf_align: <span class="tok-type">u8</span>,</span>
<span class="line" id="L78"> ra: <span class="tok-type">usize</span>,</span>
<span class="line" id="L79"> ) <span class="tok-type">void</span> {</span>
<span class="line" id="L80"> <span class="tok-kw">const</span> self: *Self = <span class="tok-builtin">@ptrCast</span>(<span class="tok-builtin">@alignCast</span>(ctx));</span>
<span class="line" id="L81"> self.writer.print(<span class="tok-str">"free : {}\n"</span>, .{buf.len}) <span class="tok-kw">catch</span> {};</span>
<span class="line" id="L82"> self.parent_allocator.rawFree(buf, log2_buf_align, ra);</span>
<span class="line" id="L83"> }</span>
<span class="line" id="L84"> };</span>
<span class="line" id="L85">}</span>
<span class="line" id="L86"></span>
<span class="line" id="L87"><span class="tok-comment">/// This allocator is used in front of another allocator and logs to the provided writer</span></span>
<span class="line" id="L88"><span class="tok-comment">/// on every call to the allocator. Writer errors are ignored.</span></span>
<span class="line" id="L89"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">logToWriterAllocator</span>(</span>
<span class="line" id="L90"> parent_allocator: Allocator,</span>
<span class="line" id="L91"> writer: <span class="tok-kw">anytype</span>,</span>
<span class="line" id="L92">) LogToWriterAllocator(<span class="tok-builtin">@TypeOf</span>(writer)) {</span>
<span class="line" id="L93"> <span class="tok-kw">return</span> LogToWriterAllocator(<span class="tok-builtin">@TypeOf</span>(writer)).init(parent_allocator, writer);</span>
<span class="line" id="L94">}</span>
<span class="line" id="L95"></span>
<span class="line" id="L96"><span class="tok-kw">test</span> <span class="tok-str">"LogToWriterAllocator"</span> {</span>
<span class="line" id="L97"> <span class="tok-kw">var</span> log_buf: [<span class="tok-number">255</span>]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L98"> <span class="tok-kw">var</span> fbs = std.io.fixedBufferStream(&log_buf);</span>
<span class="line" id="L99"></span>
<span class="line" id="L100"> <span class="tok-kw">var</span> allocator_buf: [<span class="tok-number">10</span>]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L101"> <span class="tok-kw">var</span> fixedBufferAllocator = std.mem.validationWrap(std.heap.FixedBufferAllocator.init(&allocator_buf));</span>
<span class="line" id="L102"> <span class="tok-kw">var</span> allocator_state = logToWriterAllocator(fixedBufferAllocator.allocator(), fbs.writer());</span>
<span class="line" id="L103"> <span class="tok-kw">const</span> allocator = allocator_state.allocator();</span>
<span class="line" id="L104"></span>
<span class="line" id="L105"> <span class="tok-kw">var</span> a = <span class="tok-kw">try</span> allocator.alloc(<span class="tok-type">u8</span>, <span class="tok-number">10</span>);</span>
<span class="line" id="L106"> <span class="tok-kw">try</span> std.testing.expect(allocator.resize(a, <span class="tok-number">5</span>));</span>
<span class="line" id="L107"> a = a[<span class="tok-number">0</span>..<span class="tok-number">5</span>];</span>
<span class="line" id="L108"> <span class="tok-kw">try</span> std.testing.expect(!allocator.resize(a, <span class="tok-number">20</span>));</span>
<span class="line" id="L109"> allocator.free(a);</span>
<span class="line" id="L110"></span>
<span class="line" id="L111"> <span class="tok-kw">try</span> std.testing.expectEqualSlices(<span class="tok-type">u8</span>,</span>
<span class="line" id="L112"> <span class="tok-str">\\alloc : 10 success!</span></span>
<span class="line" id="L113"> <span class="tok-str">\\shrink: 10 to 5</span></span>
<span class="line" id="L114"> <span class="tok-str">\\expand: 5 to 20 failure!</span></span>
<span class="line" id="L115"> <span class="tok-str">\\free : 5</span></span>
<span class="line" id="L116"> <span class="tok-str">\\</span></span>
<span class="line" id="L117"> , fbs.getWritten());</span>
<span class="line" id="L118">}</span>
<span class="line" id="L119"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/heap/WasmPageAllocator.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>heap/WasmPageAllocator.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> WasmPageAllocator = <span class="tok-builtin">@This</span>();</span>
<span class="line" id="L2"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../std.zig"</span>);</span>
<span class="line" id="L3"><span class="tok-kw">const</span> builtin = <span class="tok-builtin">@import</span>(<span class="tok-str">"builtin"</span>);</span>
<span class="line" id="L4"><span class="tok-kw">const</span> Allocator = std.mem.Allocator;</span>
<span class="line" id="L5"><span class="tok-kw">const</span> mem = std.mem;</span>
<span class="line" id="L6"><span class="tok-kw">const</span> maxInt = std.math.maxInt;</span>
<span class="line" id="L7"><span class="tok-kw">const</span> assert = std.debug.assert;</span>
<span class="line" id="L8"></span>
<span class="line" id="L9"><span class="tok-kw">comptime</span> {</span>
<span class="line" id="L10"> <span class="tok-kw">if</span> (!builtin.target.isWasm()) {</span>
<span class="line" id="L11"> <span class="tok-builtin">@compileError</span>(<span class="tok-str">"WasmPageAllocator is only available for wasm32 arch"</span>);</span>
<span class="line" id="L12"> }</span>
<span class="line" id="L13">}</span>
<span class="line" id="L14"></span>
<span class="line" id="L15"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> vtable = Allocator.VTable{</span>
<span class="line" id="L16"> .alloc = alloc,</span>
<span class="line" id="L17"> .resize = resize,</span>
<span class="line" id="L18"> .free = free,</span>
<span class="line" id="L19">};</span>
<span class="line" id="L20"></span>
<span class="line" id="L21"><span class="tok-kw">const</span> PageStatus = <span class="tok-kw">enum</span>(<span class="tok-type">u1</span>) {</span>
<span class="line" id="L22"> used = <span class="tok-number">0</span>,</span>
<span class="line" id="L23"> free = <span class="tok-number">1</span>,</span>
<span class="line" id="L24"></span>
<span class="line" id="L25"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> none_free: <span class="tok-type">u8</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L26">};</span>
<span class="line" id="L27"></span>
<span class="line" id="L28"><span class="tok-kw">const</span> FreeBlock = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L29"> data: []<span class="tok-type">u128</span>,</span>
<span class="line" id="L30"></span>
<span class="line" id="L31"> <span class="tok-kw">const</span> Io = std.packed_int_array.PackedIntIo(<span class="tok-type">u1</span>, .Little);</span>
<span class="line" id="L32"></span>
<span class="line" id="L33"> <span class="tok-kw">fn</span> <span class="tok-fn">totalPages</span>(self: FreeBlock) <span class="tok-type">usize</span> {</span>
<span class="line" id="L34"> <span class="tok-kw">return</span> self.data.len * <span class="tok-number">128</span>;</span>
<span class="line" id="L35"> }</span>
<span class="line" id="L36"></span>
<span class="line" id="L37"> <span class="tok-kw">fn</span> <span class="tok-fn">isInitialized</span>(self: FreeBlock) <span class="tok-type">bool</span> {</span>
<span class="line" id="L38"> <span class="tok-kw">return</span> self.data.len > <span class="tok-number">0</span>;</span>
<span class="line" id="L39"> }</span>
<span class="line" id="L40"></span>
<span class="line" id="L41"> <span class="tok-kw">fn</span> <span class="tok-fn">getBit</span>(self: FreeBlock, idx: <span class="tok-type">usize</span>) PageStatus {</span>
<span class="line" id="L42"> <span class="tok-kw">const</span> bit_offset = <span class="tok-number">0</span>;</span>
<span class="line" id="L43"> <span class="tok-kw">return</span> <span class="tok-builtin">@as</span>(PageStatus, <span class="tok-builtin">@enumFromInt</span>(Io.get(mem.sliceAsBytes(self.data), idx, bit_offset)));</span>
<span class="line" id="L44"> }</span>
<span class="line" id="L45"></span>
<span class="line" id="L46"> <span class="tok-kw">fn</span> <span class="tok-fn">setBits</span>(self: FreeBlock, start_idx: <span class="tok-type">usize</span>, len: <span class="tok-type">usize</span>, val: PageStatus) <span class="tok-type">void</span> {</span>
<span class="line" id="L47"> <span class="tok-kw">const</span> bit_offset = <span class="tok-number">0</span>;</span>
<span class="line" id="L48"> <span class="tok-kw">var</span> i: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L49"> <span class="tok-kw">while</span> (i < len) : (i += <span class="tok-number">1</span>) {</span>
<span class="line" id="L50"> Io.set(mem.sliceAsBytes(self.data), start_idx + i, bit_offset, <span class="tok-builtin">@intFromEnum</span>(val));</span>
<span class="line" id="L51"> }</span>
<span class="line" id="L52"> }</span>
<span class="line" id="L53"></span>
<span class="line" id="L54"> <span class="tok-comment">// Use '0xFFFFFFFF' as a _missing_ sentinel</span>
</span>
<span class="line" id="L55"> <span class="tok-comment">// This saves ~50 bytes compared to returning a nullable</span>
</span>
<span class="line" id="L56"></span>
<span class="line" id="L57"> <span class="tok-comment">// We can guarantee that conventional memory never gets this big,</span>
</span>
<span class="line" id="L58"> <span class="tok-comment">// and wasm32 would not be able to address this memory (32 GB > usize).</span>
</span>
<span class="line" id="L59"></span>
<span class="line" id="L60"> <span class="tok-comment">// Revisit if this is settled: https://github.com/ziglang/zig/issues/3806</span>
</span>
<span class="line" id="L61"> <span class="tok-kw">const</span> not_found = maxInt(<span class="tok-type">usize</span>);</span>
<span class="line" id="L62"></span>
<span class="line" id="L63"> <span class="tok-kw">fn</span> <span class="tok-fn">useRecycled</span>(self: FreeBlock, num_pages: <span class="tok-type">usize</span>, log2_align: <span class="tok-type">u8</span>) <span class="tok-type">usize</span> {</span>
<span class="line" id="L64"> <span class="tok-builtin">@setCold</span>(<span class="tok-null">true</span>);</span>
<span class="line" id="L65"> <span class="tok-kw">for</span> (self.data, <span class="tok-number">0</span>..) |segment, i| {</span>
<span class="line" id="L66"> <span class="tok-kw">const</span> spills_into_next = <span class="tok-builtin">@as</span>(<span class="tok-type">i128</span>, <span class="tok-builtin">@bitCast</span>(segment)) < <span class="tok-number">0</span>;</span>
<span class="line" id="L67"> <span class="tok-kw">const</span> has_enough_bits = <span class="tok-builtin">@popCount</span>(segment) >= num_pages;</span>
<span class="line" id="L68"></span>
<span class="line" id="L69"> <span class="tok-kw">if</span> (!spills_into_next <span class="tok-kw">and</span> !has_enough_bits) <span class="tok-kw">continue</span>;</span>
<span class="line" id="L70"></span>
<span class="line" id="L71"> <span class="tok-kw">var</span> j: <span class="tok-type">usize</span> = i * <span class="tok-number">128</span>;</span>
<span class="line" id="L72"> <span class="tok-kw">while</span> (j < (i + <span class="tok-number">1</span>) * <span class="tok-number">128</span>) : (j += <span class="tok-number">1</span>) {</span>
<span class="line" id="L73"> <span class="tok-kw">var</span> count: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L74"> <span class="tok-kw">while</span> (j + count < self.totalPages() <span class="tok-kw">and</span> self.getBit(j + count) == .free) {</span>
<span class="line" id="L75"> count += <span class="tok-number">1</span>;</span>
<span class="line" id="L76"> <span class="tok-kw">const</span> addr = j * mem.page_size;</span>
<span class="line" id="L77"> <span class="tok-kw">if</span> (count >= num_pages <span class="tok-kw">and</span> mem.isAlignedLog2(addr, log2_align)) {</span>
<span class="line" id="L78"> self.setBits(j, num_pages, .used);</span>
<span class="line" id="L79"> <span class="tok-kw">return</span> j;</span>
<span class="line" id="L80"> }</span>
<span class="line" id="L81"> }</span>
<span class="line" id="L82"> j += count;</span>
<span class="line" id="L83"> }</span>
<span class="line" id="L84"> }</span>
<span class="line" id="L85"> <span class="tok-kw">return</span> not_found;</span>
<span class="line" id="L86"> }</span>
<span class="line" id="L87"></span>
<span class="line" id="L88"> <span class="tok-kw">fn</span> <span class="tok-fn">recycle</span>(self: FreeBlock, start_idx: <span class="tok-type">usize</span>, len: <span class="tok-type">usize</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L89"> self.setBits(start_idx, len, .free);</span>
<span class="line" id="L90"> }</span>
<span class="line" id="L91">};</span>
<span class="line" id="L92"></span>
<span class="line" id="L93"><span class="tok-kw">var</span> _conventional_data = [_]<span class="tok-type">u128</span>{<span class="tok-number">0</span>} ** <span class="tok-number">16</span>;</span>
<span class="line" id="L94"><span class="tok-comment">// Marking `conventional` as const saves ~40 bytes</span>
</span>
<span class="line" id="L95"><span class="tok-kw">const</span> conventional = FreeBlock{ .data = &_conventional_data };</span>
<span class="line" id="L96"><span class="tok-kw">var</span> extended = FreeBlock{ .data = &[_]<span class="tok-type">u128</span>{} };</span>
<span class="line" id="L97"></span>
<span class="line" id="L98"><span class="tok-kw">fn</span> <span class="tok-fn">extendedOffset</span>() <span class="tok-type">usize</span> {</span>
<span class="line" id="L99"> <span class="tok-kw">return</span> conventional.totalPages();</span>
<span class="line" id="L100">}</span>
<span class="line" id="L101"></span>
<span class="line" id="L102"><span class="tok-kw">fn</span> <span class="tok-fn">nPages</span>(memsize: <span class="tok-type">usize</span>) <span class="tok-type">usize</span> {</span>
<span class="line" id="L103"> <span class="tok-kw">return</span> mem.alignForward(<span class="tok-type">usize</span>, memsize, mem.page_size) / mem.page_size;</span>
<span class="line" id="L104">}</span>
<span class="line" id="L105"></span>
<span class="line" id="L106"><span class="tok-kw">fn</span> <span class="tok-fn">alloc</span>(ctx: *<span class="tok-type">anyopaque</span>, len: <span class="tok-type">usize</span>, log2_align: <span class="tok-type">u8</span>, ra: <span class="tok-type">usize</span>) ?[*]<span class="tok-type">u8</span> {</span>
<span class="line" id="L107"> _ = ctx;</span>
<span class="line" id="L108"> _ = ra;</span>
<span class="line" id="L109"> <span class="tok-kw">if</span> (len > maxInt(<span class="tok-type">usize</span>) - (mem.page_size - <span class="tok-number">1</span>)) <span class="tok-kw">return</span> <span class="tok-null">null</span>;</span>
<span class="line" id="L110"> <span class="tok-kw">const</span> page_count = nPages(len);</span>
<span class="line" id="L111"> <span class="tok-kw">const</span> page_idx = allocPages(page_count, log2_align) <span class="tok-kw">catch</span> <span class="tok-kw">return</span> <span class="tok-null">null</span>;</span>
<span class="line" id="L112"> <span class="tok-kw">return</span> <span class="tok-builtin">@as</span>([*]<span class="tok-type">u8</span>, <span class="tok-builtin">@ptrFromInt</span>(page_idx * mem.page_size));</span>
<span class="line" id="L113">}</span>
<span class="line" id="L114"></span>
<span class="line" id="L115"><span class="tok-kw">fn</span> <span class="tok-fn">allocPages</span>(page_count: <span class="tok-type">usize</span>, log2_align: <span class="tok-type">u8</span>) !<span class="tok-type">usize</span> {</span>
<span class="line" id="L116"> {</span>
<span class="line" id="L117"> <span class="tok-kw">const</span> idx = conventional.useRecycled(page_count, log2_align);</span>
<span class="line" id="L118"> <span class="tok-kw">if</span> (idx != FreeBlock.not_found) {</span>
<span class="line" id="L119"> <span class="tok-kw">return</span> idx;</span>
<span class="line" id="L120"> }</span>
<span class="line" id="L121"> }</span>
<span class="line" id="L122"></span>
<span class="line" id="L123"> <span class="tok-kw">const</span> idx = extended.useRecycled(page_count, log2_align);</span>
<span class="line" id="L124"> <span class="tok-kw">if</span> (idx != FreeBlock.not_found) {</span>
<span class="line" id="L125"> <span class="tok-kw">return</span> idx + extendedOffset();</span>
<span class="line" id="L126"> }</span>
<span class="line" id="L127"></span>
<span class="line" id="L128"> <span class="tok-kw">const</span> next_page_idx = <span class="tok-builtin">@wasmMemorySize</span>(<span class="tok-number">0</span>);</span>
<span class="line" id="L129"> <span class="tok-kw">const</span> next_page_addr = next_page_idx * mem.page_size;</span>
<span class="line" id="L130"> <span class="tok-kw">const</span> aligned_addr = mem.alignForwardLog2(next_page_addr, log2_align);</span>
<span class="line" id="L131"> <span class="tok-kw">const</span> drop_page_count = <span class="tok-builtin">@divExact</span>(aligned_addr - next_page_addr, mem.page_size);</span>
<span class="line" id="L132"> <span class="tok-kw">const</span> result = <span class="tok-builtin">@wasmMemoryGrow</span>(<span class="tok-number">0</span>, <span class="tok-builtin">@as</span>(<span class="tok-type">u32</span>, <span class="tok-builtin">@intCast</span>(drop_page_count + page_count)));</span>
<span class="line" id="L133"> <span class="tok-kw">if</span> (result <= <span class="tok-number">0</span>)</span>
<span class="line" id="L134"> <span class="tok-kw">return</span> <span class="tok-kw">error</span>.OutOfMemory;</span>
<span class="line" id="L135"> assert(result == next_page_idx);</span>
<span class="line" id="L136"> <span class="tok-kw">const</span> aligned_page_idx = next_page_idx + drop_page_count;</span>
<span class="line" id="L137"> <span class="tok-kw">if</span> (drop_page_count > <span class="tok-number">0</span>) {</span>
<span class="line" id="L138"> freePages(next_page_idx, aligned_page_idx);</span>
<span class="line" id="L139"> }</span>
<span class="line" id="L140"> <span class="tok-kw">return</span> <span class="tok-builtin">@as</span>(<span class="tok-type">usize</span>, <span class="tok-builtin">@intCast</span>(aligned_page_idx));</span>
<span class="line" id="L141">}</span>
<span class="line" id="L142"></span>
<span class="line" id="L143"><span class="tok-kw">fn</span> <span class="tok-fn">freePages</span>(start: <span class="tok-type">usize</span>, end: <span class="tok-type">usize</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L144"> <span class="tok-kw">if</span> (start < extendedOffset()) {</span>
<span class="line" id="L145"> conventional.recycle(start, <span class="tok-builtin">@min</span>(extendedOffset(), end) - start);</span>
<span class="line" id="L146"> }</span>
<span class="line" id="L147"> <span class="tok-kw">if</span> (end > extendedOffset()) {</span>
<span class="line" id="L148"> <span class="tok-kw">var</span> new_end = end;</span>
<span class="line" id="L149"> <span class="tok-kw">if</span> (!extended.isInitialized()) {</span>
<span class="line" id="L150"> <span class="tok-comment">// Steal the last page from the memory currently being recycled</span>
</span>
<span class="line" id="L151"> <span class="tok-comment">// TODO: would it be better if we use the first page instead?</span>
</span>
<span class="line" id="L152"> new_end -= <span class="tok-number">1</span>;</span>
<span class="line" id="L153"></span>
<span class="line" id="L154"> extended.data = <span class="tok-builtin">@as</span>([*]<span class="tok-type">u128</span>, <span class="tok-builtin">@ptrFromInt</span>(new_end * mem.page_size))[<span class="tok-number">0</span> .. mem.page_size / <span class="tok-builtin">@sizeOf</span>(<span class="tok-type">u128</span>)];</span>
<span class="line" id="L155"> <span class="tok-comment">// Since this is the first page being freed and we consume it, assume *nothing* is free.</span>
</span>
<span class="line" id="L156"> <span class="tok-builtin">@memset</span>(extended.data, PageStatus.none_free);</span>
<span class="line" id="L157"> }</span>
<span class="line" id="L158"> <span class="tok-kw">const</span> clamped_start = <span class="tok-builtin">@max</span>(extendedOffset(), start);</span>
<span class="line" id="L159"> extended.recycle(clamped_start - extendedOffset(), new_end - clamped_start);</span>
<span class="line" id="L160"> }</span>
<span class="line" id="L161">}</span>
<span class="line" id="L162"></span>
<span class="line" id="L163"><span class="tok-kw">fn</span> <span class="tok-fn">resize</span>(</span>
<span class="line" id="L164"> ctx: *<span class="tok-type">anyopaque</span>,</span>
<span class="line" id="L165"> buf: []<span class="tok-type">u8</span>,</span>
<span class="line" id="L166"> log2_buf_align: <span class="tok-type">u8</span>,</span>
<span class="line" id="L167"> new_len: <span class="tok-type">usize</span>,</span>
<span class="line" id="L168"> return_address: <span class="tok-type">usize</span>,</span>
<span class="line" id="L169">) <span class="tok-type">bool</span> {</span>
<span class="line" id="L170"> _ = ctx;</span>
<span class="line" id="L171"> _ = log2_buf_align;</span>
<span class="line" id="L172"> _ = return_address;</span>
<span class="line" id="L173"> <span class="tok-kw">const</span> aligned_len = mem.alignForward(<span class="tok-type">usize</span>, buf.len, mem.page_size);</span>
<span class="line" id="L174"> <span class="tok-kw">if</span> (new_len > aligned_len) <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L175"> <span class="tok-kw">const</span> current_n = nPages(aligned_len);</span>
<span class="line" id="L176"> <span class="tok-kw">const</span> new_n = nPages(new_len);</span>
<span class="line" id="L177"> <span class="tok-kw">if</span> (new_n != current_n) {</span>
<span class="line" id="L178"> <span class="tok-kw">const</span> base = nPages(<span class="tok-builtin">@intFromPtr</span>(buf.ptr));</span>
<span class="line" id="L179"> freePages(base + new_n, base + current_n);</span>
<span class="line" id="L180"> }</span>
<span class="line" id="L181"> <span class="tok-kw">return</span> <span class="tok-null">true</span>;</span>
<span class="line" id="L182">}</span>
<span class="line" id="L183"></span>
<span class="line" id="L184"><span class="tok-kw">fn</span> <span class="tok-fn">free</span>(</span>
<span class="line" id="L185"> ctx: *<span class="tok-type">anyopaque</span>,</span>
<span class="line" id="L186"> buf: []<span class="tok-type">u8</span>,</span>
<span class="line" id="L187"> log2_buf_align: <span class="tok-type">u8</span>,</span>
<span class="line" id="L188"> return_address: <span class="tok-type">usize</span>,</span>
<span class="line" id="L189">) <span class="tok-type">void</span> {</span>
<span class="line" id="L190"> _ = ctx;</span>
<span class="line" id="L191"> _ = log2_buf_align;</span>
<span class="line" id="L192"> _ = return_address;</span>
<span class="line" id="L193"> <span class="tok-kw">const</span> aligned_len = mem.alignForward(<span class="tok-type">usize</span>, buf.len, mem.page_size);</span>
<span class="line" id="L194"> <span class="tok-kw">const</span> current_n = nPages(aligned_len);</span>
<span class="line" id="L195"> <span class="tok-kw">const</span> base = nPages(<span class="tok-builtin">@intFromPtr</span>(buf.ptr));</span>
<span class="line" id="L196"> freePages(base, base + current_n);</span>
<span class="line" id="L197">}</span>
<span class="line" id="L198"></span>
<span class="line" id="L199"><span class="tok-kw">test</span> <span class="tok-str">"internals"</span> {</span>
<span class="line" id="L200"> <span class="tok-kw">const</span> page_allocator = std.heap.page_allocator;</span>
<span class="line" id="L201"> <span class="tok-kw">const</span> testing = std.testing;</span>
<span class="line" id="L202"></span>
<span class="line" id="L203"> <span class="tok-kw">const</span> conventional_memsize = WasmPageAllocator.conventional.totalPages() * mem.page_size;</span>
<span class="line" id="L204"> <span class="tok-kw">const</span> initial = <span class="tok-kw">try</span> page_allocator.alloc(<span class="tok-type">u8</span>, mem.page_size);</span>
<span class="line" id="L205"> <span class="tok-kw">try</span> testing.expect(<span class="tok-builtin">@intFromPtr</span>(initial.ptr) < conventional_memsize); <span class="tok-comment">// If this isn't conventional, the rest of these tests don't make sense. Also we have a serious memory leak in the test suite.</span>
</span>
<span class="line" id="L206"></span>
<span class="line" id="L207"> <span class="tok-kw">var</span> inplace = <span class="tok-kw">try</span> page_allocator.realloc(initial, <span class="tok-number">1</span>);</span>
<span class="line" id="L208"> <span class="tok-kw">try</span> testing.expectEqual(initial.ptr, inplace.ptr);</span>
<span class="line" id="L209"> inplace = <span class="tok-kw">try</span> page_allocator.realloc(inplace, <span class="tok-number">4</span>);</span>
<span class="line" id="L210"> <span class="tok-kw">try</span> testing.expectEqual(initial.ptr, inplace.ptr);</span>
<span class="line" id="L211"> page_allocator.free(inplace);</span>
<span class="line" id="L212"></span>
<span class="line" id="L213"> <span class="tok-kw">const</span> reuse = <span class="tok-kw">try</span> page_allocator.alloc(<span class="tok-type">u8</span>, <span class="tok-number">1</span>);</span>
<span class="line" id="L214"> <span class="tok-kw">try</span> testing.expectEqual(initial.ptr, reuse.ptr);</span>
<span class="line" id="L215"> page_allocator.free(reuse);</span>
<span class="line" id="L216"></span>
<span class="line" id="L217"> <span class="tok-comment">// This segment may span conventional and extended which has really complex rules so we're just ignoring it for now.</span>
</span>
<span class="line" id="L218"> <span class="tok-kw">const</span> padding = <span class="tok-kw">try</span> page_allocator.alloc(<span class="tok-type">u8</span>, conventional_memsize);</span>
<span class="line" id="L219"> page_allocator.free(padding);</span>
<span class="line" id="L220"></span>
<span class="line" id="L221"> <span class="tok-kw">const</span> ext = <span class="tok-kw">try</span> page_allocator.alloc(<span class="tok-type">u8</span>, conventional_memsize);</span>
<span class="line" id="L222"> <span class="tok-kw">try</span> testing.expect(<span class="tok-builtin">@intFromPtr</span>(ext.ptr) >= conventional_memsize);</span>
<span class="line" id="L223"></span>
<span class="line" id="L224"> <span class="tok-kw">const</span> use_small = <span class="tok-kw">try</span> page_allocator.alloc(<span class="tok-type">u8</span>, <span class="tok-number">1</span>);</span>
<span class="line" id="L225"> <span class="tok-kw">try</span> testing.expectEqual(initial.ptr, use_small.ptr);</span>
<span class="line" id="L226"> page_allocator.free(use_small);</span>
<span class="line" id="L227"></span>
<span class="line" id="L228"> inplace = <span class="tok-kw">try</span> page_allocator.realloc(ext, <span class="tok-number">1</span>);</span>
<span class="line" id="L229"> <span class="tok-kw">try</span> testing.expectEqual(ext.ptr, inplace.ptr);</span>
<span class="line" id="L230"> page_allocator.free(inplace);</span>
<span class="line" id="L231"></span>
<span class="line" id="L232"> <span class="tok-kw">const</span> reuse_extended = <span class="tok-kw">try</span> page_allocator.alloc(<span class="tok-type">u8</span>, conventional_memsize);</span>
<span class="line" id="L233"> <span class="tok-kw">try</span> testing.expectEqual(ext.ptr, reuse_extended.ptr);</span>
<span class="line" id="L234"> page_allocator.free(reuse_extended);</span>
<span class="line" id="L235">}</span>
<span class="line" id="L236"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/heap/memory_pool.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>heap/memory_pool.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../std.zig"</span>);</span>
<span class="line" id="L2"></span>
<span class="line" id="L3"><span class="tok-kw">const</span> debug_mode = <span class="tok-builtin">@import</span>(<span class="tok-str">"builtin"</span>).mode == .Debug;</span>
<span class="line" id="L4"></span>
<span class="line" id="L5"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> MemoryPoolError = <span class="tok-kw">error</span>{OutOfMemory};</span>
<span class="line" id="L6"></span>
<span class="line" id="L7"><span class="tok-comment">/// A memory pool that can allocate objects of a single type very quickly.</span></span>
<span class="line" id="L8"><span class="tok-comment">/// Use this when you need to allocate a lot of objects of the same type,</span></span>
<span class="line" id="L9"><span class="tok-comment">/// because It outperforms general purpose allocators.</span></span>
<span class="line" id="L10"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">MemoryPool</span>(<span class="tok-kw">comptime</span> Item: <span class="tok-type">type</span>) <span class="tok-type">type</span> {</span>
<span class="line" id="L11"> <span class="tok-kw">return</span> MemoryPoolAligned(Item, <span class="tok-builtin">@alignOf</span>(Item));</span>
<span class="line" id="L12">}</span>
<span class="line" id="L13"></span>
<span class="line" id="L14"><span class="tok-comment">/// A memory pool that can allocate objects of a single type very quickly.</span></span>
<span class="line" id="L15"><span class="tok-comment">/// Use this when you need to allocate a lot of objects of the same type,</span></span>
<span class="line" id="L16"><span class="tok-comment">/// because It outperforms general purpose allocators.</span></span>
<span class="line" id="L17"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">MemoryPoolAligned</span>(<span class="tok-kw">comptime</span> Item: <span class="tok-type">type</span>, <span class="tok-kw">comptime</span> alignment: <span class="tok-type">u29</span>) <span class="tok-type">type</span> {</span>
<span class="line" id="L18"> <span class="tok-kw">if</span> (<span class="tok-builtin">@alignOf</span>(Item) == alignment) {</span>
<span class="line" id="L19"> <span class="tok-kw">return</span> MemoryPoolExtra(Item, .{});</span>
<span class="line" id="L20"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L21"> <span class="tok-kw">return</span> MemoryPoolExtra(Item, .{ .alignment = alignment });</span>
<span class="line" id="L22"> }</span>
<span class="line" id="L23">}</span>
<span class="line" id="L24"></span>
<span class="line" id="L25"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> Options = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L26"> <span class="tok-comment">/// The alignment of the memory pool items. Use `null` for natural alignment.</span></span>
<span class="line" id="L27"> alignment: ?<span class="tok-type">u29</span> = <span class="tok-null">null</span>,</span>
<span class="line" id="L28"></span>
<span class="line" id="L29"> <span class="tok-comment">/// If `true`, the memory pool can allocate additional items after a initial setup.</span></span>
<span class="line" id="L30"> <span class="tok-comment">/// If `false`, the memory pool will not allocate further after a call to `initPreheated`.</span></span>
<span class="line" id="L31"> growable: <span class="tok-type">bool</span> = <span class="tok-null">true</span>,</span>
<span class="line" id="L32">};</span>
<span class="line" id="L33"></span>
<span class="line" id="L34"><span class="tok-comment">/// A memory pool that can allocate objects of a single type very quickly.</span></span>
<span class="line" id="L35"><span class="tok-comment">/// Use this when you need to allocate a lot of objects of the same type,</span></span>
<span class="line" id="L36"><span class="tok-comment">/// because It outperforms general purpose allocators.</span></span>
<span class="line" id="L37"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">MemoryPoolExtra</span>(<span class="tok-kw">comptime</span> Item: <span class="tok-type">type</span>, <span class="tok-kw">comptime</span> pool_options: Options) <span class="tok-type">type</span> {</span>
<span class="line" id="L38"> <span class="tok-kw">return</span> <span class="tok-kw">struct</span> {</span>
<span class="line" id="L39"> <span class="tok-kw">const</span> Pool = <span class="tok-builtin">@This</span>();</span>
<span class="line" id="L40"></span>
<span class="line" id="L41"> <span class="tok-comment">/// Size of the memory pool items. This is not necessarily the same</span></span>
<span class="line" id="L42"> <span class="tok-comment">/// as `@sizeOf(Item)` as the pool also uses the items for internal means.</span></span>
<span class="line" id="L43"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> item_size = <span class="tok-builtin">@max</span>(<span class="tok-builtin">@sizeOf</span>(Node), <span class="tok-builtin">@sizeOf</span>(Item));</span>
<span class="line" id="L44"></span>
<span class="line" id="L45"> <span class="tok-comment">/// Alignment of the memory pool items. This is not necessarily the same</span></span>
<span class="line" id="L46"> <span class="tok-comment">/// as `@alignOf(Item)` as the pool also uses the items for internal means.</span></span>
<span class="line" id="L47"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> item_alignment = <span class="tok-builtin">@max</span>(<span class="tok-builtin">@alignOf</span>(Node), pool_options.alignment <span class="tok-kw">orelse</span> <span class="tok-number">0</span>);</span>
<span class="line" id="L48"></span>
<span class="line" id="L49"> <span class="tok-kw">const</span> Node = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L50"> next: ?*<span class="tok-builtin">@This</span>(),</span>
<span class="line" id="L51"> };</span>
<span class="line" id="L52"> <span class="tok-kw">const</span> NodePtr = *<span class="tok-kw">align</span>(item_alignment) Node;</span>
<span class="line" id="L53"> <span class="tok-kw">const</span> ItemPtr = *<span class="tok-kw">align</span>(item_alignment) Item;</span>
<span class="line" id="L54"></span>
<span class="line" id="L55"> arena: std.heap.ArenaAllocator,</span>
<span class="line" id="L56"> free_list: ?NodePtr = <span class="tok-null">null</span>,</span>
<span class="line" id="L57"></span>
<span class="line" id="L58"> <span class="tok-comment">/// Creates a new memory pool.</span></span>
<span class="line" id="L59"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">init</span>(allocator: std.mem.Allocator) Pool {</span>
<span class="line" id="L60"> <span class="tok-kw">return</span> .{ .arena = std.heap.ArenaAllocator.init(allocator) };</span>
<span class="line" id="L61"> }</span>
<span class="line" id="L62"></span>
<span class="line" id="L63"> <span class="tok-comment">/// Creates a new memory pool and pre-allocates `initial_size` items.</span></span>
<span class="line" id="L64"> <span class="tok-comment">/// This allows the up to `initial_size` active allocations before a</span></span>
<span class="line" id="L65"> <span class="tok-comment">/// `OutOfMemory` error happens when calling `create()`.</span></span>
<span class="line" id="L66"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">initPreheated</span>(allocator: std.mem.Allocator, initial_size: <span class="tok-type">usize</span>) MemoryPoolError!Pool {</span>
<span class="line" id="L67"> <span class="tok-kw">var</span> pool = init(allocator);</span>
<span class="line" id="L68"> <span class="tok-kw">errdefer</span> pool.deinit();</span>
<span class="line" id="L69"></span>
<span class="line" id="L70"> <span class="tok-kw">var</span> i: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L71"> <span class="tok-kw">while</span> (i < initial_size) : (i += <span class="tok-number">1</span>) {</span>
<span class="line" id="L72"> <span class="tok-kw">const</span> raw_mem = <span class="tok-kw">try</span> pool.allocNew();</span>
<span class="line" id="L73"> <span class="tok-kw">const</span> free_node = <span class="tok-builtin">@as</span>(NodePtr, <span class="tok-builtin">@ptrCast</span>(raw_mem));</span>
<span class="line" id="L74"> free_node.* = Node{</span>
<span class="line" id="L75"> .next = pool.free_list,</span>
<span class="line" id="L76"> };</span>
<span class="line" id="L77"> pool.free_list = free_node;</span>
<span class="line" id="L78"> }</span>
<span class="line" id="L79"></span>
<span class="line" id="L80"> <span class="tok-kw">return</span> pool;</span>
<span class="line" id="L81"> }</span>
<span class="line" id="L82"></span>
<span class="line" id="L83"> <span class="tok-comment">/// Destroys the memory pool and frees all allocated memory.</span></span>
<span class="line" id="L84"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">deinit</span>(pool: *Pool) <span class="tok-type">void</span> {</span>
<span class="line" id="L85"> pool.arena.deinit();</span>
<span class="line" id="L86"> pool.* = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L87"> }</span>
<span class="line" id="L88"></span>
<span class="line" id="L89"> <span class="tok-comment">/// Resets the memory pool and destroys all allocated items.</span></span>
<span class="line" id="L90"> <span class="tok-comment">/// This can be used to batch-destroy all objects without invalidating the memory pool.</span></span>
<span class="line" id="L91"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">reset</span>(pool: *Pool) <span class="tok-type">void</span> {</span>
<span class="line" id="L92"> <span class="tok-comment">// TODO: Potentially store all allocated objects in a list as well, allowing to</span>
</span>
<span class="line" id="L93"> <span class="tok-comment">// just move them into the free list instead of actually releasing the memory.</span>
</span>
<span class="line" id="L94"> <span class="tok-kw">const</span> allocator = pool.arena.child_allocator;</span>
<span class="line" id="L95"></span>
<span class="line" id="L96"> <span class="tok-comment">// TODO: Replace with "pool.arena.reset()" when implemented.</span>
</span>
<span class="line" id="L97"> pool.arena.deinit();</span>
<span class="line" id="L98"> pool.arena = std.heap.ArenaAllocator.init(allocator);</span>
<span class="line" id="L99"></span>
<span class="line" id="L100"> pool.free_list = <span class="tok-null">null</span>;</span>
<span class="line" id="L101"> }</span>
<span class="line" id="L102"></span>
<span class="line" id="L103"> <span class="tok-comment">/// Creates a new item and adds it to the memory pool.</span></span>
<span class="line" id="L104"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">create</span>(pool: *Pool) !ItemPtr {</span>
<span class="line" id="L105"> <span class="tok-kw">const</span> node = <span class="tok-kw">if</span> (pool.free_list) |item| blk: {</span>
<span class="line" id="L106"> pool.free_list = item.next;</span>
<span class="line" id="L107"> <span class="tok-kw">break</span> :blk item;</span>
<span class="line" id="L108"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (pool_options.growable)</span>
<span class="line" id="L109"> <span class="tok-builtin">@as</span>(NodePtr, <span class="tok-builtin">@ptrCast</span>(<span class="tok-kw">try</span> pool.allocNew()))</span>
<span class="line" id="L110"> <span class="tok-kw">else</span></span>
<span class="line" id="L111"> <span class="tok-kw">return</span> <span class="tok-kw">error</span>.OutOfMemory;</span>
<span class="line" id="L112"></span>
<span class="line" id="L113"> <span class="tok-kw">const</span> ptr = <span class="tok-builtin">@as</span>(ItemPtr, <span class="tok-builtin">@ptrCast</span>(node));</span>
<span class="line" id="L114"> ptr.* = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L115"> <span class="tok-kw">return</span> ptr;</span>
<span class="line" id="L116"> }</span>
<span class="line" id="L117"></span>
<span class="line" id="L118"> <span class="tok-comment">/// Destroys a previously created item.</span></span>
<span class="line" id="L119"> <span class="tok-comment">/// Only pass items to `ptr` that were previously created with `create()` of the same memory pool!</span></span>
<span class="line" id="L120"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">destroy</span>(pool: *Pool, ptr: ItemPtr) <span class="tok-type">void</span> {</span>
<span class="line" id="L121"> ptr.* = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L122"></span>
<span class="line" id="L123"> <span class="tok-kw">const</span> node = <span class="tok-builtin">@as</span>(NodePtr, <span class="tok-builtin">@ptrCast</span>(ptr));</span>
<span class="line" id="L124"> node.* = Node{</span>
<span class="line" id="L125"> .next = pool.free_list,</span>
<span class="line" id="L126"> };</span>
<span class="line" id="L127"> pool.free_list = node;</span>
<span class="line" id="L128"> }</span>
<span class="line" id="L129"></span>
<span class="line" id="L130"> <span class="tok-kw">fn</span> <span class="tok-fn">allocNew</span>(pool: *Pool) MemoryPoolError!*<span class="tok-kw">align</span>(item_alignment) [item_size]<span class="tok-type">u8</span> {</span>
<span class="line" id="L131"> <span class="tok-kw">const</span> mem = <span class="tok-kw">try</span> pool.arena.allocator().alignedAlloc(<span class="tok-type">u8</span>, item_alignment, item_size);</span>
<span class="line" id="L132"> <span class="tok-kw">return</span> mem[<span class="tok-number">0</span>..item_size]; <span class="tok-comment">// coerce slice to array pointer</span>
</span>
<span class="line" id="L133"> }</span>
<span class="line" id="L134"> };</span>
<span class="line" id="L135">}</span>
<span class="line" id="L136"></span>
<span class="line" id="L137"><span class="tok-kw">test</span> <span class="tok-str">"memory pool: basic"</span> {</span>
<span class="line" id="L138"> <span class="tok-kw">var</span> pool = MemoryPool(<span class="tok-type">u32</span>).init(std.testing.allocator);</span>
<span class="line" id="L139"> <span class="tok-kw">defer</span> pool.deinit();</span>
<span class="line" id="L140"></span>
<span class="line" id="L141"> <span class="tok-kw">const</span> p1 = <span class="tok-kw">try</span> pool.create();</span>
<span class="line" id="L142"> <span class="tok-kw">const</span> p2 = <span class="tok-kw">try</span> pool.create();</span>
<span class="line" id="L143"> <span class="tok-kw">const</span> p3 = <span class="tok-kw">try</span> pool.create();</span>
<span class="line" id="L144"></span>
<span class="line" id="L145"> <span class="tok-comment">// Assert uniqueness</span>
</span>
<span class="line" id="L146"> <span class="tok-kw">try</span> std.testing.expect(p1 != p2);</span>
<span class="line" id="L147"> <span class="tok-kw">try</span> std.testing.expect(p1 != p3);</span>
<span class="line" id="L148"> <span class="tok-kw">try</span> std.testing.expect(p2 != p3);</span>
<span class="line" id="L149"></span>
<span class="line" id="L150"> pool.destroy(p2);</span>
<span class="line" id="L151"> <span class="tok-kw">const</span> p4 = <span class="tok-kw">try</span> pool.create();</span>
<span class="line" id="L152"></span>
<span class="line" id="L153"> <span class="tok-comment">// Assert memory reuse</span>
</span>
<span class="line" id="L154"> <span class="tok-kw">try</span> std.testing.expect(p2 == p4);</span>
<span class="line" id="L155">}</span>
<span class="line" id="L156"></span>
<span class="line" id="L157"><span class="tok-kw">test</span> <span class="tok-str">"memory pool: preheating (success)"</span> {</span>
<span class="line" id="L158"> <span class="tok-kw">var</span> pool = <span class="tok-kw">try</span> MemoryPool(<span class="tok-type">u32</span>).initPreheated(std.testing.allocator, <span class="tok-number">4</span>);</span>
<span class="line" id="L159"> <span class="tok-kw">defer</span> pool.deinit();</span>
<span class="line" id="L160"></span>
<span class="line" id="L161"> _ = <span class="tok-kw">try</span> pool.create();</span>
<span class="line" id="L162"> _ = <span class="tok-kw">try</span> pool.create();</span>
<span class="line" id="L163"> _ = <span class="tok-kw">try</span> pool.create();</span>
<span class="line" id="L164">}</span>
<span class="line" id="L165"></span>
<span class="line" id="L166"><span class="tok-kw">test</span> <span class="tok-str">"memory pool: preheating (failure)"</span> {</span>
<span class="line" id="L167"> <span class="tok-kw">var</span> failer = std.testing.FailingAllocator.init(std.testing.allocator, <span class="tok-number">0</span>);</span>
<span class="line" id="L168"> <span class="tok-kw">try</span> std.testing.expectError(<span class="tok-kw">error</span>.OutOfMemory, MemoryPool(<span class="tok-type">u32</span>).initPreheated(failer.allocator(), <span class="tok-number">5</span>));</span>
<span class="line" id="L169">}</span>
<span class="line" id="L170"></span>
<span class="line" id="L171"><span class="tok-kw">test</span> <span class="tok-str">"memory pool: growable"</span> {</span>
<span class="line" id="L172"> <span class="tok-kw">var</span> pool = <span class="tok-kw">try</span> MemoryPoolExtra(<span class="tok-type">u32</span>, .{ .growable = <span class="tok-null">false</span> }).initPreheated(std.testing.allocator, <span class="tok-number">4</span>);</span>
<span class="line" id="L173"> <span class="tok-kw">defer</span> pool.deinit();</span>
<span class="line" id="L174"></span>
<span class="line" id="L175"> _ = <span class="tok-kw">try</span> pool.create();</span>
<span class="line" id="L176"> _ = <span class="tok-kw">try</span> pool.create();</span>
<span class="line" id="L177"> _ = <span class="tok-kw">try</span> pool.create();</span>
<span class="line" id="L178"> _ = <span class="tok-kw">try</span> pool.create();</span>
<span class="line" id="L179"></span>
<span class="line" id="L180"> <span class="tok-kw">try</span> std.testing.expectError(<span class="tok-kw">error</span>.OutOfMemory, pool.create());</span>
<span class="line" id="L181">}</span>
<span class="line" id="L182"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/heap/ThreadSafeAllocator.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>heap/ThreadSafeAllocator.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-comment">//! Wraps a non-thread-safe allocator and makes it thread-safe.</span></span>
<span class="line" id="L2"></span>
<span class="line" id="L3">child_allocator: Allocator,</span>
<span class="line" id="L4">mutex: std.Thread.Mutex = .{},</span>
<span class="line" id="L5"></span>
<span class="line" id="L6"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">allocator</span>(self: *ThreadSafeAllocator) Allocator {</span>
<span class="line" id="L7"> <span class="tok-kw">return</span> .{</span>
<span class="line" id="L8"> .ptr = self,</span>
<span class="line" id="L9"> .vtable = &.{</span>
<span class="line" id="L10"> .alloc = alloc,</span>
<span class="line" id="L11"> .resize = resize,</span>
<span class="line" id="L12"> .free = free,</span>
<span class="line" id="L13"> },</span>
<span class="line" id="L14"> };</span>
<span class="line" id="L15">}</span>
<span class="line" id="L16"></span>
<span class="line" id="L17"><span class="tok-kw">fn</span> <span class="tok-fn">alloc</span>(ctx: *<span class="tok-type">anyopaque</span>, n: <span class="tok-type">usize</span>, log2_ptr_align: <span class="tok-type">u8</span>, ra: <span class="tok-type">usize</span>) ?[*]<span class="tok-type">u8</span> {</span>
<span class="line" id="L18"> <span class="tok-kw">const</span> self: *ThreadSafeAllocator = <span class="tok-builtin">@ptrCast</span>(<span class="tok-builtin">@alignCast</span>(ctx));</span>
<span class="line" id="L19"> self.mutex.lock();</span>
<span class="line" id="L20"> <span class="tok-kw">defer</span> self.mutex.unlock();</span>
<span class="line" id="L21"></span>
<span class="line" id="L22"> <span class="tok-kw">return</span> self.child_allocator.rawAlloc(n, log2_ptr_align, ra);</span>
<span class="line" id="L23">}</span>
<span class="line" id="L24"></span>
<span class="line" id="L25"><span class="tok-kw">fn</span> <span class="tok-fn">resize</span>(ctx: *<span class="tok-type">anyopaque</span>, buf: []<span class="tok-type">u8</span>, log2_buf_align: <span class="tok-type">u8</span>, new_len: <span class="tok-type">usize</span>, ret_addr: <span class="tok-type">usize</span>) <span class="tok-type">bool</span> {</span>
<span class="line" id="L26"> <span class="tok-kw">const</span> self: *ThreadSafeAllocator = <span class="tok-builtin">@ptrCast</span>(<span class="tok-builtin">@alignCast</span>(ctx));</span>
<span class="line" id="L27"></span>
<span class="line" id="L28"> self.mutex.lock();</span>
<span class="line" id="L29"> <span class="tok-kw">defer</span> self.mutex.unlock();</span>
<span class="line" id="L30"></span>
<span class="line" id="L31"> <span class="tok-kw">return</span> self.child_allocator.rawResize(buf, log2_buf_align, new_len, ret_addr);</span>
<span class="line" id="L32">}</span>
<span class="line" id="L33"></span>
<span class="line" id="L34"><span class="tok-kw">fn</span> <span class="tok-fn">free</span>(ctx: *<span class="tok-type">anyopaque</span>, buf: []<span class="tok-type">u8</span>, log2_buf_align: <span class="tok-type">u8</span>, ret_addr: <span class="tok-type">usize</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L35"> <span class="tok-kw">const</span> self: *ThreadSafeAllocator = <span class="tok-builtin">@ptrCast</span>(<span class="tok-builtin">@alignCast</span>(ctx));</span>
<span class="line" id="L36"></span>
<span class="line" id="L37"> self.mutex.lock();</span>
<span class="line" id="L38"> <span class="tok-kw">defer</span> self.mutex.unlock();</span>
<span class="line" id="L39"></span>
<span class="line" id="L40"> <span class="tok-kw">return</span> self.child_allocator.rawFree(buf, log2_buf_align, ret_addr);</span>
<span class="line" id="L41">}</span>
<span class="line" id="L42"></span>
<span class="line" id="L43"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../std.zig"</span>);</span>
<span class="line" id="L44"><span class="tok-kw">const</span> ThreadSafeAllocator = <span class="tok-builtin">@This</span>();</span>
<span class="line" id="L45"><span class="tok-kw">const</span> Allocator = std.mem.Allocator;</span>
<span class="line" id="L46"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/heap/WasmAllocator.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>heap/WasmAllocator.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-comment">//! This is intended to be merged into GeneralPurposeAllocator at some point.</span></span>
<span class="line" id="L2"></span>
<span class="line" id="L3"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../std.zig"</span>);</span>
<span class="line" id="L4"><span class="tok-kw">const</span> builtin = <span class="tok-builtin">@import</span>(<span class="tok-str">"builtin"</span>);</span>
<span class="line" id="L5"><span class="tok-kw">const</span> Allocator = std.mem.Allocator;</span>
<span class="line" id="L6"><span class="tok-kw">const</span> mem = std.mem;</span>
<span class="line" id="L7"><span class="tok-kw">const</span> assert = std.debug.assert;</span>
<span class="line" id="L8"><span class="tok-kw">const</span> wasm = std.wasm;</span>
<span class="line" id="L9"><span class="tok-kw">const</span> math = std.math;</span>
<span class="line" id="L10"></span>
<span class="line" id="L11"><span class="tok-kw">comptime</span> {</span>
<span class="line" id="L12"> <span class="tok-kw">if</span> (!builtin.target.isWasm()) {</span>
<span class="line" id="L13"> <span class="tok-builtin">@compileError</span>(<span class="tok-str">"WasmPageAllocator is only available for wasm32 arch"</span>);</span>
<span class="line" id="L14"> }</span>
<span class="line" id="L15">}</span>
<span class="line" id="L16"></span>
<span class="line" id="L17"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> vtable = Allocator.VTable{</span>
<span class="line" id="L18"> .alloc = alloc,</span>
<span class="line" id="L19"> .resize = resize,</span>
<span class="line" id="L20"> .free = free,</span>
<span class="line" id="L21">};</span>
<span class="line" id="L22"></span>
<span class="line" id="L23"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> Error = Allocator.Error;</span>
<span class="line" id="L24"></span>
<span class="line" id="L25"><span class="tok-kw">const</span> max_usize = math.maxInt(<span class="tok-type">usize</span>);</span>
<span class="line" id="L26"><span class="tok-kw">const</span> ushift = math.Log2Int(<span class="tok-type">usize</span>);</span>
<span class="line" id="L27"><span class="tok-kw">const</span> bigpage_size = <span class="tok-number">64</span> * <span class="tok-number">1024</span>;</span>
<span class="line" id="L28"><span class="tok-kw">const</span> pages_per_bigpage = bigpage_size / wasm.page_size;</span>
<span class="line" id="L29"><span class="tok-kw">const</span> bigpage_count = max_usize / bigpage_size;</span>
<span class="line" id="L30"></span>
<span class="line" id="L31"><span class="tok-comment">/// Because of storing free list pointers, the minimum size class is 3.</span></span>
<span class="line" id="L32"><span class="tok-kw">const</span> min_class = math.log2(math.ceilPowerOfTwoAssert(<span class="tok-type">usize</span>, <span class="tok-number">1</span> + <span class="tok-builtin">@sizeOf</span>(<span class="tok-type">usize</span>)));</span>
<span class="line" id="L33"><span class="tok-kw">const</span> size_class_count = math.log2(bigpage_size) - min_class;</span>
<span class="line" id="L34"><span class="tok-comment">/// 0 - 1 bigpage</span></span>
<span class="line" id="L35"><span class="tok-comment">/// 1 - 2 bigpages</span></span>
<span class="line" id="L36"><span class="tok-comment">/// 2 - 4 bigpages</span></span>
<span class="line" id="L37"><span class="tok-comment">/// etc.</span></span>
<span class="line" id="L38"><span class="tok-kw">const</span> big_size_class_count = math.log2(bigpage_count);</span>
<span class="line" id="L39"></span>
<span class="line" id="L40"><span class="tok-kw">var</span> next_addrs = [<span class="tok-number">1</span>]<span class="tok-type">usize</span>{<span class="tok-number">0</span>} ** size_class_count;</span>
<span class="line" id="L41"><span class="tok-comment">/// For each size class, points to the freed pointer.</span></span>
<span class="line" id="L42"><span class="tok-kw">var</span> frees = [<span class="tok-number">1</span>]<span class="tok-type">usize</span>{<span class="tok-number">0</span>} ** size_class_count;</span>
<span class="line" id="L43"><span class="tok-comment">/// For each big size class, points to the freed pointer.</span></span>
<span class="line" id="L44"><span class="tok-kw">var</span> big_frees = [<span class="tok-number">1</span>]<span class="tok-type">usize</span>{<span class="tok-number">0</span>} ** big_size_class_count;</span>
<span class="line" id="L45"></span>
<span class="line" id="L46"><span class="tok-kw">fn</span> <span class="tok-fn">alloc</span>(ctx: *<span class="tok-type">anyopaque</span>, len: <span class="tok-type">usize</span>, log2_align: <span class="tok-type">u8</span>, return_address: <span class="tok-type">usize</span>) ?[*]<span class="tok-type">u8</span> {</span>
<span class="line" id="L47"> _ = ctx;</span>
<span class="line" id="L48"> _ = return_address;</span>
<span class="line" id="L49"> <span class="tok-comment">// Make room for the freelist next pointer.</span>
</span>
<span class="line" id="L50"> <span class="tok-kw">const</span> alignment = <span class="tok-builtin">@as</span>(<span class="tok-type">usize</span>, <span class="tok-number">1</span>) << <span class="tok-builtin">@as</span>(Allocator.Log2Align, <span class="tok-builtin">@intCast</span>(log2_align));</span>
<span class="line" id="L51"> <span class="tok-kw">const</span> actual_len = <span class="tok-builtin">@max</span>(len +| <span class="tok-builtin">@sizeOf</span>(<span class="tok-type">usize</span>), alignment);</span>
<span class="line" id="L52"> <span class="tok-kw">const</span> slot_size = math.ceilPowerOfTwo(<span class="tok-type">usize</span>, actual_len) <span class="tok-kw">catch</span> <span class="tok-kw">return</span> <span class="tok-null">null</span>;</span>
<span class="line" id="L53"> <span class="tok-kw">const</span> class = math.log2(slot_size) - min_class;</span>
<span class="line" id="L54"> <span class="tok-kw">if</span> (class < size_class_count) {</span>
<span class="line" id="L55"> <span class="tok-kw">const</span> addr = a: {</span>
<span class="line" id="L56"> <span class="tok-kw">const</span> top_free_ptr = frees[class];</span>
<span class="line" id="L57"> <span class="tok-kw">if</span> (top_free_ptr != <span class="tok-number">0</span>) {</span>
<span class="line" id="L58"> <span class="tok-kw">const</span> node = <span class="tok-builtin">@as</span>(*<span class="tok-type">usize</span>, <span class="tok-builtin">@ptrFromInt</span>(top_free_ptr + (slot_size - <span class="tok-builtin">@sizeOf</span>(<span class="tok-type">usize</span>))));</span>
<span class="line" id="L59"> frees[class] = node.*;</span>
<span class="line" id="L60"> <span class="tok-kw">break</span> :a top_free_ptr;</span>
<span class="line" id="L61"> }</span>
<span class="line" id="L62"></span>
<span class="line" id="L63"> <span class="tok-kw">const</span> next_addr = next_addrs[class];</span>
<span class="line" id="L64"> <span class="tok-kw">if</span> (next_addr % wasm.page_size == <span class="tok-number">0</span>) {</span>
<span class="line" id="L65"> <span class="tok-kw">const</span> addr = allocBigPages(<span class="tok-number">1</span>);</span>
<span class="line" id="L66"> <span class="tok-kw">if</span> (addr == <span class="tok-number">0</span>) <span class="tok-kw">return</span> <span class="tok-null">null</span>;</span>
<span class="line" id="L67"> <span class="tok-comment">//std.debug.print("allocated fresh slot_size={d} class={d} addr=0x{x}\n", .{</span>
</span>
<span class="line" id="L68"> <span class="tok-comment">// slot_size, class, addr,</span>
</span>
<span class="line" id="L69"> <span class="tok-comment">//});</span>
</span>
<span class="line" id="L70"> next_addrs[class] = addr + slot_size;</span>
<span class="line" id="L71"> <span class="tok-kw">break</span> :a addr;</span>
<span class="line" id="L72"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L73"> next_addrs[class] = next_addr + slot_size;</span>
<span class="line" id="L74"> <span class="tok-kw">break</span> :a next_addr;</span>
<span class="line" id="L75"> }</span>
<span class="line" id="L76"> };</span>
<span class="line" id="L77"> <span class="tok-kw">return</span> <span class="tok-builtin">@as</span>([*]<span class="tok-type">u8</span>, <span class="tok-builtin">@ptrFromInt</span>(addr));</span>
<span class="line" id="L78"> }</span>
<span class="line" id="L79"> <span class="tok-kw">const</span> bigpages_needed = bigPagesNeeded(actual_len);</span>
<span class="line" id="L80"> <span class="tok-kw">const</span> addr = allocBigPages(bigpages_needed);</span>
<span class="line" id="L81"> <span class="tok-kw">return</span> <span class="tok-builtin">@as</span>([*]<span class="tok-type">u8</span>, <span class="tok-builtin">@ptrFromInt</span>(addr));</span>
<span class="line" id="L82">}</span>
<span class="line" id="L83"></span>
<span class="line" id="L84"><span class="tok-kw">fn</span> <span class="tok-fn">resize</span>(</span>
<span class="line" id="L85"> ctx: *<span class="tok-type">anyopaque</span>,</span>
<span class="line" id="L86"> buf: []<span class="tok-type">u8</span>,</span>
<span class="line" id="L87"> log2_buf_align: <span class="tok-type">u8</span>,</span>
<span class="line" id="L88"> new_len: <span class="tok-type">usize</span>,</span>
<span class="line" id="L89"> return_address: <span class="tok-type">usize</span>,</span>
<span class="line" id="L90">) <span class="tok-type">bool</span> {</span>
<span class="line" id="L91"> _ = ctx;</span>
<span class="line" id="L92"> _ = return_address;</span>
<span class="line" id="L93"> <span class="tok-comment">// We don't want to move anything from one size class to another, but we</span>
</span>
<span class="line" id="L94"> <span class="tok-comment">// can recover bytes in between powers of two.</span>
</span>
<span class="line" id="L95"> <span class="tok-kw">const</span> buf_align = <span class="tok-builtin">@as</span>(<span class="tok-type">usize</span>, <span class="tok-number">1</span>) << <span class="tok-builtin">@as</span>(Allocator.Log2Align, <span class="tok-builtin">@intCast</span>(log2_buf_align));</span>
<span class="line" id="L96"> <span class="tok-kw">const</span> old_actual_len = <span class="tok-builtin">@max</span>(buf.len + <span class="tok-builtin">@sizeOf</span>(<span class="tok-type">usize</span>), buf_align);</span>
<span class="line" id="L97"> <span class="tok-kw">const</span> new_actual_len = <span class="tok-builtin">@max</span>(new_len +| <span class="tok-builtin">@sizeOf</span>(<span class="tok-type">usize</span>), buf_align);</span>
<span class="line" id="L98"> <span class="tok-kw">const</span> old_small_slot_size = math.ceilPowerOfTwoAssert(<span class="tok-type">usize</span>, old_actual_len);</span>
<span class="line" id="L99"> <span class="tok-kw">const</span> old_small_class = math.log2(old_small_slot_size) - min_class;</span>
<span class="line" id="L100"> <span class="tok-kw">if</span> (old_small_class < size_class_count) {</span>
<span class="line" id="L101"> <span class="tok-kw">const</span> new_small_slot_size = math.ceilPowerOfTwo(<span class="tok-type">usize</span>, new_actual_len) <span class="tok-kw">catch</span> <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L102"> <span class="tok-kw">return</span> old_small_slot_size == new_small_slot_size;</span>
<span class="line" id="L103"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L104"> <span class="tok-kw">const</span> old_bigpages_needed = bigPagesNeeded(old_actual_len);</span>
<span class="line" id="L105"> <span class="tok-kw">const</span> old_big_slot_pages = math.ceilPowerOfTwoAssert(<span class="tok-type">usize</span>, old_bigpages_needed);</span>
<span class="line" id="L106"> <span class="tok-kw">const</span> new_bigpages_needed = bigPagesNeeded(new_actual_len);</span>
<span class="line" id="L107"> <span class="tok-kw">const</span> new_big_slot_pages = math.ceilPowerOfTwo(<span class="tok-type">usize</span>, new_bigpages_needed) <span class="tok-kw">catch</span> <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L108"> <span class="tok-kw">return</span> old_big_slot_pages == new_big_slot_pages;</span>
<span class="line" id="L109"> }</span>
<span class="line" id="L110">}</span>
<span class="line" id="L111"></span>
<span class="line" id="L112"><span class="tok-kw">fn</span> <span class="tok-fn">free</span>(</span>
<span class="line" id="L113"> ctx: *<span class="tok-type">anyopaque</span>,</span>
<span class="line" id="L114"> buf: []<span class="tok-type">u8</span>,</span>
<span class="line" id="L115"> log2_buf_align: <span class="tok-type">u8</span>,</span>
<span class="line" id="L116"> return_address: <span class="tok-type">usize</span>,</span>
<span class="line" id="L117">) <span class="tok-type">void</span> {</span>
<span class="line" id="L118"> _ = ctx;</span>
<span class="line" id="L119"> _ = return_address;</span>
<span class="line" id="L120"> <span class="tok-kw">const</span> buf_align = <span class="tok-builtin">@as</span>(<span class="tok-type">usize</span>, <span class="tok-number">1</span>) << <span class="tok-builtin">@as</span>(Allocator.Log2Align, <span class="tok-builtin">@intCast</span>(log2_buf_align));</span>
<span class="line" id="L121"> <span class="tok-kw">const</span> actual_len = <span class="tok-builtin">@max</span>(buf.len + <span class="tok-builtin">@sizeOf</span>(<span class="tok-type">usize</span>), buf_align);</span>
<span class="line" id="L122"> <span class="tok-kw">const</span> slot_size = math.ceilPowerOfTwoAssert(<span class="tok-type">usize</span>, actual_len);</span>
<span class="line" id="L123"> <span class="tok-kw">const</span> class = math.log2(slot_size) - min_class;</span>
<span class="line" id="L124"> <span class="tok-kw">const</span> addr = <span class="tok-builtin">@intFromPtr</span>(buf.ptr);</span>
<span class="line" id="L125"> <span class="tok-kw">if</span> (class < size_class_count) {</span>
<span class="line" id="L126"> <span class="tok-kw">const</span> node = <span class="tok-builtin">@as</span>(*<span class="tok-type">usize</span>, <span class="tok-builtin">@ptrFromInt</span>(addr + (slot_size - <span class="tok-builtin">@sizeOf</span>(<span class="tok-type">usize</span>))));</span>
<span class="line" id="L127"> node.* = frees[class];</span>
<span class="line" id="L128"> frees[class] = addr;</span>
<span class="line" id="L129"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L130"> <span class="tok-kw">const</span> bigpages_needed = bigPagesNeeded(actual_len);</span>
<span class="line" id="L131"> <span class="tok-kw">const</span> pow2_pages = math.ceilPowerOfTwoAssert(<span class="tok-type">usize</span>, bigpages_needed);</span>
<span class="line" id="L132"> <span class="tok-kw">const</span> big_slot_size_bytes = pow2_pages * bigpage_size;</span>
<span class="line" id="L133"> <span class="tok-kw">const</span> node = <span class="tok-builtin">@as</span>(*<span class="tok-type">usize</span>, <span class="tok-builtin">@ptrFromInt</span>(addr + (big_slot_size_bytes - <span class="tok-builtin">@sizeOf</span>(<span class="tok-type">usize</span>))));</span>
<span class="line" id="L134"> <span class="tok-kw">const</span> big_class = math.log2(pow2_pages);</span>
<span class="line" id="L135"> node.* = big_frees[big_class];</span>
<span class="line" id="L136"> big_frees[big_class] = addr;</span>
<span class="line" id="L137"> }</span>
<span class="line" id="L138">}</span>
<span class="line" id="L139"></span>
<span class="line" id="L140"><span class="tok-kw">inline</span> <span class="tok-kw">fn</span> <span class="tok-fn">bigPagesNeeded</span>(byte_count: <span class="tok-type">usize</span>) <span class="tok-type">usize</span> {</span>
<span class="line" id="L141"> <span class="tok-kw">return</span> (byte_count + (bigpage_size + (<span class="tok-builtin">@sizeOf</span>(<span class="tok-type">usize</span>) - <span class="tok-number">1</span>))) / bigpage_size;</span>
<span class="line" id="L142">}</span>
<span class="line" id="L143"></span>
<span class="line" id="L144"><span class="tok-kw">fn</span> <span class="tok-fn">allocBigPages</span>(n: <span class="tok-type">usize</span>) <span class="tok-type">usize</span> {</span>
<span class="line" id="L145"> <span class="tok-kw">const</span> pow2_pages = math.ceilPowerOfTwoAssert(<span class="tok-type">usize</span>, n);</span>
<span class="line" id="L146"> <span class="tok-kw">const</span> slot_size_bytes = pow2_pages * bigpage_size;</span>
<span class="line" id="L147"> <span class="tok-kw">const</span> class = math.log2(pow2_pages);</span>
<span class="line" id="L148"></span>
<span class="line" id="L149"> <span class="tok-kw">const</span> top_free_ptr = big_frees[class];</span>
<span class="line" id="L150"> <span class="tok-kw">if</span> (top_free_ptr != <span class="tok-number">0</span>) {</span>
<span class="line" id="L151"> <span class="tok-kw">const</span> node = <span class="tok-builtin">@as</span>(*<span class="tok-type">usize</span>, <span class="tok-builtin">@ptrFromInt</span>(top_free_ptr + (slot_size_bytes - <span class="tok-builtin">@sizeOf</span>(<span class="tok-type">usize</span>))));</span>
<span class="line" id="L152"> big_frees[class] = node.*;</span>
<span class="line" id="L153"> <span class="tok-kw">return</span> top_free_ptr;</span>
<span class="line" id="L154"> }</span>
<span class="line" id="L155"></span>
<span class="line" id="L156"> <span class="tok-kw">const</span> page_index = <span class="tok-builtin">@wasmMemoryGrow</span>(<span class="tok-number">0</span>, pow2_pages * pages_per_bigpage);</span>
<span class="line" id="L157"> <span class="tok-kw">if</span> (page_index <= <span class="tok-number">0</span>) <span class="tok-kw">return</span> <span class="tok-number">0</span>;</span>
<span class="line" id="L158"> <span class="tok-kw">const</span> addr = <span class="tok-builtin">@as</span>(<span class="tok-type">u32</span>, <span class="tok-builtin">@intCast</span>(page_index)) * wasm.page_size;</span>
<span class="line" id="L159"> <span class="tok-kw">return</span> addr;</span>
<span class="line" id="L160">}</span>
<span class="line" id="L161"></span>
<span class="line" id="L162"><span class="tok-kw">const</span> test_ally = Allocator{</span>
<span class="line" id="L163"> .ptr = <span class="tok-null">undefined</span>,</span>
<span class="line" id="L164"> .vtable = &vtable,</span>
<span class="line" id="L165">};</span>
<span class="line" id="L166"></span>
<span class="line" id="L167"><span class="tok-kw">test</span> <span class="tok-str">"small allocations - free in same order"</span> {</span>
<span class="line" id="L168"> <span class="tok-kw">var</span> list: [<span class="tok-number">513</span>]*<span class="tok-type">u64</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L169"></span>
<span class="line" id="L170"> <span class="tok-kw">var</span> i: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L171"> <span class="tok-kw">while</span> (i < <span class="tok-number">513</span>) : (i += <span class="tok-number">1</span>) {</span>
<span class="line" id="L172"> <span class="tok-kw">const</span> ptr = <span class="tok-kw">try</span> test_ally.create(<span class="tok-type">u64</span>);</span>
<span class="line" id="L173"> list[i] = ptr;</span>
<span class="line" id="L174"> }</span>
<span class="line" id="L175"></span>
<span class="line" id="L176"> <span class="tok-kw">for</span> (list) |ptr| {</span>
<span class="line" id="L177"> test_ally.destroy(ptr);</span>
<span class="line" id="L178"> }</span>
<span class="line" id="L179">}</span>
<span class="line" id="L180"></span>
<span class="line" id="L181"><span class="tok-kw">test</span> <span class="tok-str">"small allocations - free in reverse order"</span> {</span>
<span class="line" id="L182"> <span class="tok-kw">var</span> list: [<span class="tok-number">513</span>]*<span class="tok-type">u64</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L183"></span>
<span class="line" id="L184"> <span class="tok-kw">var</span> i: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L185"> <span class="tok-kw">while</span> (i < <span class="tok-number">513</span>) : (i += <span class="tok-number">1</span>) {</span>
<span class="line" id="L186"> <span class="tok-kw">const</span> ptr = <span class="tok-kw">try</span> test_ally.create(<span class="tok-type">u64</span>);</span>
<span class="line" id="L187"> list[i] = ptr;</span>
<span class="line" id="L188"> }</span>
<span class="line" id="L189"></span>
<span class="line" id="L190"> i = list.len;</span>
<span class="line" id="L191"> <span class="tok-kw">while</span> (i > <span class="tok-number">0</span>) {</span>
<span class="line" id="L192"> i -= <span class="tok-number">1</span>;</span>
<span class="line" id="L193"> <span class="tok-kw">const</span> ptr = list[i];</span>
<span class="line" id="L194"> test_ally.destroy(ptr);</span>
<span class="line" id="L195"> }</span>
<span class="line" id="L196">}</span>
<span class="line" id="L197"></span>
<span class="line" id="L198"><span class="tok-kw">test</span> <span class="tok-str">"large allocations"</span> {</span>
<span class="line" id="L199"> <span class="tok-kw">const</span> ptr1 = <span class="tok-kw">try</span> test_ally.alloc(<span class="tok-type">u64</span>, <span class="tok-number">42768</span>);</span>
<span class="line" id="L200"> <span class="tok-kw">const</span> ptr2 = <span class="tok-kw">try</span> test_ally.alloc(<span class="tok-type">u64</span>, <span class="tok-number">52768</span>);</span>
<span class="line" id="L201"> test_ally.free(ptr1);</span>
<span class="line" id="L202"> <span class="tok-kw">const</span> ptr3 = <span class="tok-kw">try</span> test_ally.alloc(<span class="tok-type">u64</span>, <span class="tok-number">62768</span>);</span>
<span class="line" id="L203"> test_ally.free(ptr3);</span>
<span class="line" id="L204"> test_ally.free(ptr2);</span>
<span class="line" id="L205">}</span>
<span class="line" id="L206"></span>
<span class="line" id="L207"><span class="tok-kw">test</span> <span class="tok-str">"very large allocation"</span> {</span>
<span class="line" id="L208"> <span class="tok-kw">try</span> std.testing.expectError(<span class="tok-kw">error</span>.OutOfMemory, test_ally.alloc(<span class="tok-type">u8</span>, math.maxInt(<span class="tok-type">usize</span>)));</span>
<span class="line" id="L209">}</span>
<span class="line" id="L210"></span>
<span class="line" id="L211"><span class="tok-kw">test</span> <span class="tok-str">"realloc"</span> {</span>
<span class="line" id="L212"> <span class="tok-kw">var</span> slice = <span class="tok-kw">try</span> test_ally.alignedAlloc(<span class="tok-type">u8</span>, <span class="tok-builtin">@alignOf</span>(<span class="tok-type">u32</span>), <span class="tok-number">1</span>);</span>
<span class="line" id="L213"> <span class="tok-kw">defer</span> test_ally.free(slice);</span>
<span class="line" id="L214"> slice[<span class="tok-number">0</span>] = <span class="tok-number">0x12</span>;</span>
<span class="line" id="L215"></span>
<span class="line" id="L216"> <span class="tok-comment">// This reallocation should keep its pointer address.</span>
</span>
<span class="line" id="L217"> <span class="tok-kw">const</span> old_slice = slice;</span>
<span class="line" id="L218"> slice = <span class="tok-kw">try</span> test_ally.realloc(slice, <span class="tok-number">2</span>);</span>
<span class="line" id="L219"> <span class="tok-kw">try</span> std.testing.expect(old_slice.ptr == slice.ptr);</span>
<span class="line" id="L220"> <span class="tok-kw">try</span> std.testing.expect(slice[<span class="tok-number">0</span>] == <span class="tok-number">0x12</span>);</span>
<span class="line" id="L221"> slice[<span class="tok-number">1</span>] = <span class="tok-number">0x34</span>;</span>
<span class="line" id="L222"></span>
<span class="line" id="L223"> <span class="tok-comment">// This requires upgrading to a larger size class</span>
</span>
<span class="line" id="L224"> slice = <span class="tok-kw">try</span> test_ally.realloc(slice, <span class="tok-number">17</span>);</span>
<span class="line" id="L225"> <span class="tok-kw">try</span> std.testing.expect(slice[<span class="tok-number">0</span>] == <span class="tok-number">0x12</span>);</span>
<span class="line" id="L226"> <span class="tok-kw">try</span> std.testing.expect(slice[<span class="tok-number">1</span>] == <span class="tok-number">0x34</span>);</span>
<span class="line" id="L227">}</span>
<span class="line" id="L228"></span>
<span class="line" id="L229"><span class="tok-kw">test</span> <span class="tok-str">"shrink"</span> {</span>
<span class="line" id="L230"> <span class="tok-kw">var</span> slice = <span class="tok-kw">try</span> test_ally.alloc(<span class="tok-type">u8</span>, <span class="tok-number">20</span>);</span>
<span class="line" id="L231"> <span class="tok-kw">defer</span> test_ally.free(slice);</span>
<span class="line" id="L232"></span>
<span class="line" id="L233"> <span class="tok-builtin">@memset</span>(slice, <span class="tok-number">0x11</span>);</span>
<span class="line" id="L234"></span>
<span class="line" id="L235"> <span class="tok-kw">try</span> std.testing.expect(test_ally.resize(slice, <span class="tok-number">17</span>));</span>
<span class="line" id="L236"> slice = slice[<span class="tok-number">0</span>..<span class="tok-number">17</span>];</span>
<span class="line" id="L237"></span>
<span class="line" id="L238"> <span class="tok-kw">for</span> (slice) |b| {</span>
<span class="line" id="L239"> <span class="tok-kw">try</span> std.testing.expect(b == <span class="tok-number">0x11</span>);</span>
<span class="line" id="L240"> }</span>
<span class="line" id="L241"></span>
<span class="line" id="L242"> <span class="tok-kw">try</span> std.testing.expect(test_ally.resize(slice, <span class="tok-number">16</span>));</span>
<span class="line" id="L243"> slice = slice[<span class="tok-number">0</span>..<span class="tok-number">16</span>];</span>
<span class="line" id="L244"></span>
<span class="line" id="L245"> <span class="tok-kw">for</span> (slice) |b| {</span>
<span class="line" id="L246"> <span class="tok-kw">try</span> std.testing.expect(b == <span class="tok-number">0x11</span>);</span>
<span class="line" id="L247"> }</span>
<span class="line" id="L248">}</span>
<span class="line" id="L249"></span>
<span class="line" id="L250"><span class="tok-kw">test</span> <span class="tok-str">"large object - grow"</span> {</span>
<span class="line" id="L251"> <span class="tok-kw">var</span> slice1 = <span class="tok-kw">try</span> test_ally.alloc(<span class="tok-type">u8</span>, bigpage_size * <span class="tok-number">2</span> - <span class="tok-number">20</span>);</span>
<span class="line" id="L252"> <span class="tok-kw">defer</span> test_ally.free(slice1);</span>
<span class="line" id="L253"></span>
<span class="line" id="L254"> <span class="tok-kw">const</span> old = slice1;</span>
<span class="line" id="L255"> slice1 = <span class="tok-kw">try</span> test_ally.realloc(slice1, bigpage_size * <span class="tok-number">2</span> - <span class="tok-number">10</span>);</span>
<span class="line" id="L256"> <span class="tok-kw">try</span> std.testing.expect(slice1.ptr == old.ptr);</span>
<span class="line" id="L257"></span>
<span class="line" id="L258"> slice1 = <span class="tok-kw">try</span> test_ally.realloc(slice1, bigpage_size * <span class="tok-number">2</span>);</span>
<span class="line" id="L259"> slice1 = <span class="tok-kw">try</span> test_ally.realloc(slice1, bigpage_size * <span class="tok-number">2</span> + <span class="tok-number">1</span>);</span>
<span class="line" id="L260">}</span>
<span class="line" id="L261"></span>
<span class="line" id="L262"><span class="tok-kw">test</span> <span class="tok-str">"realloc small object to large object"</span> {</span>
<span class="line" id="L263"> <span class="tok-kw">var</span> slice = <span class="tok-kw">try</span> test_ally.alloc(<span class="tok-type">u8</span>, <span class="tok-number">70</span>);</span>
<span class="line" id="L264"> <span class="tok-kw">defer</span> test_ally.free(slice);</span>
<span class="line" id="L265"> slice[<span class="tok-number">0</span>] = <span class="tok-number">0x12</span>;</span>
<span class="line" id="L266"> slice[<span class="tok-number">60</span>] = <span class="tok-number">0x34</span>;</span>
<span class="line" id="L267"></span>
<span class="line" id="L268"> <span class="tok-comment">// This requires upgrading to a large object</span>
</span>
<span class="line" id="L269"> <span class="tok-kw">const</span> large_object_size = bigpage_size * <span class="tok-number">2</span> + <span class="tok-number">50</span>;</span>
<span class="line" id="L270"> slice = <span class="tok-kw">try</span> test_ally.realloc(slice, large_object_size);</span>
<span class="line" id="L271"> <span class="tok-kw">try</span> std.testing.expect(slice[<span class="tok-number">0</span>] == <span class="tok-number">0x12</span>);</span>
<span class="line" id="L272"> <span class="tok-kw">try</span> std.testing.expect(slice[<span class="tok-number">60</span>] == <span class="tok-number">0x34</span>);</span>
<span class="line" id="L273">}</span>
<span class="line" id="L274"></span>
<span class="line" id="L275"><span class="tok-kw">test</span> <span class="tok-str">"shrink large object to large object"</span> {</span>
<span class="line" id="L276"> <span class="tok-kw">var</span> slice = <span class="tok-kw">try</span> test_ally.alloc(<span class="tok-type">u8</span>, bigpage_size * <span class="tok-number">2</span> + <span class="tok-number">50</span>);</span>
<span class="line" id="L277"> <span class="tok-kw">defer</span> test_ally.free(slice);</span>
<span class="line" id="L278"> slice[<span class="tok-number">0</span>] = <span class="tok-number">0x12</span>;</span>
<span class="line" id="L279"> slice[<span class="tok-number">60</span>] = <span class="tok-number">0x34</span>;</span>
<span class="line" id="L280"></span>
<span class="line" id="L281"> <span class="tok-kw">try</span> std.testing.expect(test_ally.resize(slice, bigpage_size * <span class="tok-number">2</span> + <span class="tok-number">1</span>));</span>
<span class="line" id="L282"> slice = slice[<span class="tok-number">0</span> .. bigpage_size * <span class="tok-number">2</span> + <span class="tok-number">1</span>];</span>
<span class="line" id="L283"> <span class="tok-kw">try</span> std.testing.expect(slice[<span class="tok-number">0</span>] == <span class="tok-number">0x12</span>);</span>
<span class="line" id="L284"> <span class="tok-kw">try</span> std.testing.expect(slice[<span class="tok-number">60</span>] == <span class="tok-number">0x34</span>);</span>
<span class="line" id="L285"></span>
<span class="line" id="L286"> <span class="tok-kw">try</span> std.testing.expect(test_ally.resize(slice, bigpage_size * <span class="tok-number">2</span> + <span class="tok-number">1</span>));</span>
<span class="line" id="L287"> <span class="tok-kw">try</span> std.testing.expect(slice[<span class="tok-number">0</span>] == <span class="tok-number">0x12</span>);</span>
<span class="line" id="L288"> <span class="tok-kw">try</span> std.testing.expect(slice[<span class="tok-number">60</span>] == <span class="tok-number">0x34</span>);</span>
<span class="line" id="L289"></span>
<span class="line" id="L290"> slice = <span class="tok-kw">try</span> test_ally.realloc(slice, bigpage_size * <span class="tok-number">2</span>);</span>
<span class="line" id="L291"> <span class="tok-kw">try</span> std.testing.expect(slice[<span class="tok-number">0</span>] == <span class="tok-number">0x12</span>);</span>
<span class="line" id="L292"> <span class="tok-kw">try</span> std.testing.expect(slice[<span class="tok-number">60</span>] == <span class="tok-number">0x34</span>);</span>
<span class="line" id="L293">}</span>
<span class="line" id="L294"></span>
<span class="line" id="L295"><span class="tok-kw">test</span> <span class="tok-str">"realloc large object to small object"</span> {</span>
<span class="line" id="L296"> <span class="tok-kw">var</span> slice = <span class="tok-kw">try</span> test_ally.alloc(<span class="tok-type">u8</span>, bigpage_size * <span class="tok-number">2</span> + <span class="tok-number">50</span>);</span>
<span class="line" id="L297"> <span class="tok-kw">defer</span> test_ally.free(slice);</span>
<span class="line" id="L298"> slice[<span class="tok-number">0</span>] = <span class="tok-number">0x12</span>;</span>
<span class="line" id="L299"> slice[<span class="tok-number">16</span>] = <span class="tok-number">0x34</span>;</span>
<span class="line" id="L300"></span>
<span class="line" id="L301"> slice = <span class="tok-kw">try</span> test_ally.realloc(slice, <span class="tok-number">19</span>);</span>
<span class="line" id="L302"> <span class="tok-kw">try</span> std.testing.expect(slice[<span class="tok-number">0</span>] == <span class="tok-number">0x12</span>);</span>
<span class="line" id="L303"> <span class="tok-kw">try</span> std.testing.expect(slice[<span class="tok-number">16</span>] == <span class="tok-number">0x34</span>);</span>
<span class="line" id="L304">}</span>
<span class="line" id="L305"></span>
<span class="line" id="L306"><span class="tok-kw">test</span> <span class="tok-str">"objects of size 1024 and 2048"</span> {</span>
<span class="line" id="L307"> <span class="tok-kw">const</span> slice = <span class="tok-kw">try</span> test_ally.alloc(<span class="tok-type">u8</span>, <span class="tok-number">1025</span>);</span>
<span class="line" id="L308"> <span class="tok-kw">const</span> slice2 = <span class="tok-kw">try</span> test_ally.alloc(<span class="tok-type">u8</span>, <span class="tok-number">3000</span>);</span>
<span class="line" id="L309"></span>
<span class="line" id="L310"> test_ally.free(slice);</span>
<span class="line" id="L311"> test_ally.free(slice2);</span>
<span class="line" id="L312">}</span>
<span class="line" id="L313"></span>
<span class="line" id="L314"><span class="tok-kw">test</span> <span class="tok-str">"standard allocator tests"</span> {</span>
<span class="line" id="L315"> <span class="tok-kw">try</span> std.heap.testAllocator(test_ally);</span>
<span class="line" id="L316"> <span class="tok-kw">try</span> std.heap.testAllocatorAligned(test_ally);</span>
<span class="line" id="L317">}</span>
<span class="line" id="L318"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/heap/general_purpose_allocator.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>heap/general_purpose_allocator.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-comment">//! # General Purpose Allocator</span></span>
<span class="line" id="L2"><span class="tok-comment">//!</span></span>
<span class="line" id="L3"><span class="tok-comment">//! ## Design Priorities</span></span>
<span class="line" id="L4"><span class="tok-comment">//!</span></span>
<span class="line" id="L5"><span class="tok-comment">//! ### `OptimizationMode.debug` and `OptimizationMode.release_safe`:</span></span>
<span class="line" id="L6"><span class="tok-comment">//!</span></span>
<span class="line" id="L7"><span class="tok-comment">//! * Detect double free, and emit stack trace of:</span></span>
<span class="line" id="L8"><span class="tok-comment">//! - Where it was first allocated</span></span>
<span class="line" id="L9"><span class="tok-comment">//! - Where it was freed the first time</span></span>
<span class="line" id="L10"><span class="tok-comment">//! - Where it was freed the second time</span></span>
<span class="line" id="L11"><span class="tok-comment">//!</span></span>
<span class="line" id="L12"><span class="tok-comment">//! * Detect leaks and emit stack trace of:</span></span>
<span class="line" id="L13"><span class="tok-comment">//! - Where it was allocated</span></span>
<span class="line" id="L14"><span class="tok-comment">//!</span></span>
<span class="line" id="L15"><span class="tok-comment">//! * When a page of memory is no longer needed, give it back to resident memory</span></span>
<span class="line" id="L16"><span class="tok-comment">//! as soon as possible, so that it causes page faults when used.</span></span>
<span class="line" id="L17"><span class="tok-comment">//!</span></span>
<span class="line" id="L18"><span class="tok-comment">//! * Do not re-use memory slots, so that memory safety is upheld. For small</span></span>
<span class="line" id="L19"><span class="tok-comment">//! allocations, this is handled here; for larger ones it is handled in the</span></span>
<span class="line" id="L20"><span class="tok-comment">//! backing allocator (by default `std.heap.page_allocator`).</span></span>
<span class="line" id="L21"><span class="tok-comment">//!</span></span>
<span class="line" id="L22"><span class="tok-comment">//! * Make pointer math errors unlikely to harm memory from</span></span>
<span class="line" id="L23"><span class="tok-comment">//! unrelated allocations.</span></span>
<span class="line" id="L24"><span class="tok-comment">//!</span></span>
<span class="line" id="L25"><span class="tok-comment">//! * It's OK for these mechanisms to cost some extra overhead bytes.</span></span>
<span class="line" id="L26"><span class="tok-comment">//!</span></span>
<span class="line" id="L27"><span class="tok-comment">//! * It's OK for performance cost for these mechanisms.</span></span>
<span class="line" id="L28"><span class="tok-comment">//!</span></span>
<span class="line" id="L29"><span class="tok-comment">//! * Rogue memory writes should not harm the allocator's state.</span></span>
<span class="line" id="L30"><span class="tok-comment">//!</span></span>
<span class="line" id="L31"><span class="tok-comment">//! * Cross platform. Operates based on a backing allocator which makes it work</span></span>
<span class="line" id="L32"><span class="tok-comment">//! everywhere, even freestanding.</span></span>
<span class="line" id="L33"><span class="tok-comment">//!</span></span>
<span class="line" id="L34"><span class="tok-comment">//! * Compile-time configuration.</span></span>
<span class="line" id="L35"><span class="tok-comment">//!</span></span>
<span class="line" id="L36"><span class="tok-comment">//! ### `OptimizationMode.release_fast` (note: not much work has gone into this use case yet):</span></span>
<span class="line" id="L37"><span class="tok-comment">//!</span></span>
<span class="line" id="L38"><span class="tok-comment">//! * Low fragmentation is primary concern</span></span>
<span class="line" id="L39"><span class="tok-comment">//! * Performance of worst-case latency is secondary concern</span></span>
<span class="line" id="L40"><span class="tok-comment">//! * Performance of average-case latency is next</span></span>
<span class="line" id="L41"><span class="tok-comment">//! * Finally, having freed memory unmapped, and pointer math errors unlikely to</span></span>
<span class="line" id="L42"><span class="tok-comment">//! harm memory from unrelated allocations are nice-to-haves.</span></span>
<span class="line" id="L43"><span class="tok-comment">//!</span></span>
<span class="line" id="L44"><span class="tok-comment">//! ### `OptimizationMode.release_small` (note: not much work has gone into this use case yet):</span></span>
<span class="line" id="L45"><span class="tok-comment">//!</span></span>
<span class="line" id="L46"><span class="tok-comment">//! * Small binary code size of the executable is the primary concern.</span></span>
<span class="line" id="L47"><span class="tok-comment">//! * Next, defer to the `.release_fast` priority list.</span></span>
<span class="line" id="L48"><span class="tok-comment">//!</span></span>
<span class="line" id="L49"><span class="tok-comment">//! ## Basic Design:</span></span>
<span class="line" id="L50"><span class="tok-comment">//!</span></span>
<span class="line" id="L51"><span class="tok-comment">//! Small allocations are divided into buckets:</span></span>
<span class="line" id="L52"><span class="tok-comment">//!</span></span>
<span class="line" id="L53"><span class="tok-comment">//! ```</span></span>
<span class="line" id="L54"><span class="tok-comment">//! index obj_size</span></span>
<span class="line" id="L55"><span class="tok-comment">//! 0 1</span></span>
<span class="line" id="L56"><span class="tok-comment">//! 1 2</span></span>
<span class="line" id="L57"><span class="tok-comment">//! 2 4</span></span>
<span class="line" id="L58"><span class="tok-comment">//! 3 8</span></span>
<span class="line" id="L59"><span class="tok-comment">//! 4 16</span></span>
<span class="line" id="L60"><span class="tok-comment">//! 5 32</span></span>
<span class="line" id="L61"><span class="tok-comment">//! 6 64</span></span>
<span class="line" id="L62"><span class="tok-comment">//! 7 128</span></span>
<span class="line" id="L63"><span class="tok-comment">//! 8 256</span></span>
<span class="line" id="L64"><span class="tok-comment">//! 9 512</span></span>
<span class="line" id="L65"><span class="tok-comment">//! 10 1024</span></span>
<span class="line" id="L66"><span class="tok-comment">//! 11 2048</span></span>
<span class="line" id="L67"><span class="tok-comment">//! ```</span></span>
<span class="line" id="L68"><span class="tok-comment">//!</span></span>
<span class="line" id="L69"><span class="tok-comment">//! The main allocator state has an array of all the "current" buckets for each</span></span>
<span class="line" id="L70"><span class="tok-comment">//! size class. Each slot in the array can be null, meaning the bucket for that</span></span>
<span class="line" id="L71"><span class="tok-comment">//! size class is not allocated. When the first object is allocated for a given</span></span>
<span class="line" id="L72"><span class="tok-comment">//! size class, it allocates 1 page of memory from the OS. This page is</span></span>
<span class="line" id="L73"><span class="tok-comment">//! divided into "slots" - one per allocated object. Along with the page of memory</span></span>
<span class="line" id="L74"><span class="tok-comment">//! for object slots, as many pages as necessary are allocated to store the</span></span>
<span class="line" id="L75"><span class="tok-comment">//! BucketHeader, followed by "used bits", and two stack traces for each slot</span></span>
<span class="line" id="L76"><span class="tok-comment">//! (allocation trace and free trace).</span></span>
<span class="line" id="L77"><span class="tok-comment">//!</span></span>
<span class="line" id="L78"><span class="tok-comment">//! The "used bits" are 1 bit per slot representing whether the slot is used.</span></span>
<span class="line" id="L79"><span class="tok-comment">//! Allocations use the data to iterate to find a free slot. Frees assert that the</span></span>
<span class="line" id="L80"><span class="tok-comment">//! corresponding bit is 1 and set it to 0.</span></span>
<span class="line" id="L81"><span class="tok-comment">//!</span></span>
<span class="line" id="L82"><span class="tok-comment">//! Buckets have prev and next pointers. When there is only one bucket for a given</span></span>
<span class="line" id="L83"><span class="tok-comment">//! size class, both prev and next point to itself. When all slots of a bucket are</span></span>
<span class="line" id="L84"><span class="tok-comment">//! used, a new bucket is allocated, and enters the doubly linked list. The main</span></span>
<span class="line" id="L85"><span class="tok-comment">//! allocator state tracks the "current" bucket for each size class. Leak detection</span></span>
<span class="line" id="L86"><span class="tok-comment">//! currently only checks the current bucket.</span></span>
<span class="line" id="L87"><span class="tok-comment">//!</span></span>
<span class="line" id="L88"><span class="tok-comment">//! Resizing detects if the size class is unchanged or smaller, in which case the same</span></span>
<span class="line" id="L89"><span class="tok-comment">//! pointer is returned unmodified. If a larger size class is required,</span></span>
<span class="line" id="L90"><span class="tok-comment">//! `error.OutOfMemory` is returned.</span></span>
<span class="line" id="L91"><span class="tok-comment">//!</span></span>
<span class="line" id="L92"><span class="tok-comment">//! Large objects are allocated directly using the backing allocator and their metadata is stored</span></span>
<span class="line" id="L93"><span class="tok-comment">//! in a `std.HashMap` using the backing allocator.</span></span>
<span class="line" id="L94"></span>
<span class="line" id="L95"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"std"</span>);</span>
<span class="line" id="L96"><span class="tok-kw">const</span> builtin = <span class="tok-builtin">@import</span>(<span class="tok-str">"builtin"</span>);</span>
<span class="line" id="L97"><span class="tok-kw">const</span> log = std.log.scoped(.gpa);</span>
<span class="line" id="L98"><span class="tok-kw">const</span> math = std.math;</span>
<span class="line" id="L99"><span class="tok-kw">const</span> assert = std.debug.assert;</span>
<span class="line" id="L100"><span class="tok-kw">const</span> mem = std.mem;</span>
<span class="line" id="L101"><span class="tok-kw">const</span> Allocator = std.mem.Allocator;</span>
<span class="line" id="L102"><span class="tok-kw">const</span> page_size = std.mem.page_size;</span>
<span class="line" id="L103"><span class="tok-kw">const</span> StackTrace = std.builtin.StackTrace;</span>
<span class="line" id="L104"></span>
<span class="line" id="L105"><span class="tok-comment">/// Integer type for pointing to slots in a small allocation</span></span>
<span class="line" id="L106"><span class="tok-kw">const</span> SlotIndex = std.meta.Int(.unsigned, math.log2(page_size) + <span class="tok-number">1</span>);</span>
<span class="line" id="L107"></span>
<span class="line" id="L108"><span class="tok-kw">const</span> default_test_stack_trace_frames: <span class="tok-type">usize</span> = <span class="tok-kw">if</span> (builtin.is_test) <span class="tok-number">8</span> <span class="tok-kw">else</span> <span class="tok-number">4</span>;</span>
<span class="line" id="L109"><span class="tok-kw">const</span> default_sys_stack_trace_frames: <span class="tok-type">usize</span> = <span class="tok-kw">if</span> (std.debug.sys_can_stack_trace) default_test_stack_trace_frames <span class="tok-kw">else</span> <span class="tok-number">0</span>;</span>
<span class="line" id="L110"><span class="tok-kw">const</span> default_stack_trace_frames: <span class="tok-type">usize</span> = <span class="tok-kw">switch</span> (builtin.mode) {</span>
<span class="line" id="L111"> .Debug => default_sys_stack_trace_frames,</span>
<span class="line" id="L112"> <span class="tok-kw">else</span> => <span class="tok-number">0</span>,</span>
<span class="line" id="L113">};</span>
<span class="line" id="L114"></span>
<span class="line" id="L115"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> Config = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L116"> <span class="tok-comment">/// Number of stack frames to capture.</span></span>
<span class="line" id="L117"> stack_trace_frames: <span class="tok-type">usize</span> = default_stack_trace_frames,</span>
<span class="line" id="L118"></span>
<span class="line" id="L119"> <span class="tok-comment">/// If true, the allocator will have two fields:</span></span>
<span class="line" id="L120"> <span class="tok-comment">/// * `total_requested_bytes` which tracks the total allocated bytes of memory requested.</span></span>
<span class="line" id="L121"> <span class="tok-comment">/// * `requested_memory_limit` which causes allocations to return `error.OutOfMemory`</span></span>
<span class="line" id="L122"> <span class="tok-comment">/// when the `total_requested_bytes` exceeds this limit.</span></span>
<span class="line" id="L123"> <span class="tok-comment">/// If false, these fields will be `void`.</span></span>
<span class="line" id="L124"> enable_memory_limit: <span class="tok-type">bool</span> = <span class="tok-null">false</span>,</span>
<span class="line" id="L125"></span>
<span class="line" id="L126"> <span class="tok-comment">/// Whether to enable safety checks.</span></span>
<span class="line" id="L127"> safety: <span class="tok-type">bool</span> = std.debug.runtime_safety,</span>
<span class="line" id="L128"></span>
<span class="line" id="L129"> <span class="tok-comment">/// Whether the allocator may be used simultaneously from multiple threads.</span></span>
<span class="line" id="L130"> thread_safe: <span class="tok-type">bool</span> = !builtin.single_threaded,</span>
<span class="line" id="L131"></span>
<span class="line" id="L132"> <span class="tok-comment">/// What type of mutex you'd like to use, for thread safety.</span></span>
<span class="line" id="L133"> <span class="tok-comment">/// when specified, the mutex type must have the same shape as `std.Thread.Mutex` and</span></span>
<span class="line" id="L134"> <span class="tok-comment">/// `DummyMutex`, and have no required fields. Specifying this field causes</span></span>
<span class="line" id="L135"> <span class="tok-comment">/// the `thread_safe` field to be ignored.</span></span>
<span class="line" id="L136"> <span class="tok-comment">///</span></span>
<span class="line" id="L137"> <span class="tok-comment">/// when null (default):</span></span>
<span class="line" id="L138"> <span class="tok-comment">/// * the mutex type defaults to `std.Thread.Mutex` when thread_safe is enabled.</span></span>
<span class="line" id="L139"> <span class="tok-comment">/// * the mutex type defaults to `DummyMutex` otherwise.</span></span>
<span class="line" id="L140"> MutexType: ?<span class="tok-type">type</span> = <span class="tok-null">null</span>,</span>
<span class="line" id="L141"></span>
<span class="line" id="L142"> <span class="tok-comment">/// This is a temporary debugging trick you can use to turn segfaults into more helpful</span></span>
<span class="line" id="L143"> <span class="tok-comment">/// logged error messages with stack trace details. The downside is that every allocation</span></span>
<span class="line" id="L144"> <span class="tok-comment">/// will be leaked, unless used with retain_metadata!</span></span>
<span class="line" id="L145"> never_unmap: <span class="tok-type">bool</span> = <span class="tok-null">false</span>,</span>
<span class="line" id="L146"></span>
<span class="line" id="L147"> <span class="tok-comment">/// This is a temporary debugging aid that retains metadata about allocations indefinitely.</span></span>
<span class="line" id="L148"> <span class="tok-comment">/// This allows a greater range of double frees to be reported. All metadata is freed when</span></span>
<span class="line" id="L149"> <span class="tok-comment">/// deinit is called. When used with never_unmap, deliberately leaked memory is also freed</span></span>
<span class="line" id="L150"> <span class="tok-comment">/// during deinit. Currently should be used with never_unmap to avoid segfaults.</span></span>
<span class="line" id="L151"> <span class="tok-comment">/// TODO https://github.com/ziglang/zig/issues/4298 will allow use without never_unmap</span></span>
<span class="line" id="L152"> retain_metadata: <span class="tok-type">bool</span> = <span class="tok-null">false</span>,</span>
<span class="line" id="L153"></span>
<span class="line" id="L154"> <span class="tok-comment">/// Enables emitting info messages with the size and address of every allocation.</span></span>
<span class="line" id="L155"> verbose_log: <span class="tok-type">bool</span> = <span class="tok-null">false</span>,</span>
<span class="line" id="L156">};</span>
<span class="line" id="L157"></span>
<span class="line" id="L158"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> Check = <span class="tok-kw">enum</span> { ok, leak };</span>
<span class="line" id="L159"></span>
<span class="line" id="L160"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">GeneralPurposeAllocator</span>(<span class="tok-kw">comptime</span> config: Config) <span class="tok-type">type</span> {</span>
<span class="line" id="L161"> <span class="tok-kw">return</span> <span class="tok-kw">struct</span> {</span>
<span class="line" id="L162"> backing_allocator: Allocator = std.heap.page_allocator,</span>
<span class="line" id="L163"> buckets: [small_bucket_count]?*BucketHeader = [<span class="tok-number">1</span>]?*BucketHeader{<span class="tok-null">null</span>} ** small_bucket_count,</span>
<span class="line" id="L164"> large_allocations: LargeAllocTable = .{},</span>
<span class="line" id="L165"> small_allocations: <span class="tok-kw">if</span> (config.safety) SmallAllocTable <span class="tok-kw">else</span> <span class="tok-type">void</span> = <span class="tok-kw">if</span> (config.safety) .{} <span class="tok-kw">else</span> {},</span>
<span class="line" id="L166"> empty_buckets: <span class="tok-kw">if</span> (config.retain_metadata) ?*BucketHeader <span class="tok-kw">else</span> <span class="tok-type">void</span> =</span>
<span class="line" id="L167"> <span class="tok-kw">if</span> (config.retain_metadata) <span class="tok-null">null</span> <span class="tok-kw">else</span> {},</span>
<span class="line" id="L168"></span>
<span class="line" id="L169"> total_requested_bytes: <span class="tok-builtin">@TypeOf</span>(total_requested_bytes_init) = total_requested_bytes_init,</span>
<span class="line" id="L170"> requested_memory_limit: <span class="tok-builtin">@TypeOf</span>(requested_memory_limit_init) = requested_memory_limit_init,</span>
<span class="line" id="L171"></span>
<span class="line" id="L172"> mutex: <span class="tok-builtin">@TypeOf</span>(mutex_init) = mutex_init,</span>
<span class="line" id="L173"></span>
<span class="line" id="L174"> <span class="tok-kw">const</span> Self = <span class="tok-builtin">@This</span>();</span>
<span class="line" id="L175"></span>
<span class="line" id="L176"> <span class="tok-kw">const</span> total_requested_bytes_init = <span class="tok-kw">if</span> (config.enable_memory_limit) <span class="tok-builtin">@as</span>(<span class="tok-type">usize</span>, <span class="tok-number">0</span>) <span class="tok-kw">else</span> {};</span>
<span class="line" id="L177"> <span class="tok-kw">const</span> requested_memory_limit_init = <span class="tok-kw">if</span> (config.enable_memory_limit) <span class="tok-builtin">@as</span>(<span class="tok-type">usize</span>, math.maxInt(<span class="tok-type">usize</span>)) <span class="tok-kw">else</span> {};</span>
<span class="line" id="L178"></span>
<span class="line" id="L179"> <span class="tok-kw">const</span> mutex_init = <span class="tok-kw">if</span> (config.MutexType) |T|</span>
<span class="line" id="L180"> T{}</span>
<span class="line" id="L181"> <span class="tok-kw">else</span> <span class="tok-kw">if</span> (config.thread_safe)</span>
<span class="line" id="L182"> std.Thread.Mutex{}</span>
<span class="line" id="L183"> <span class="tok-kw">else</span></span>
<span class="line" id="L184"> DummyMutex{};</span>
<span class="line" id="L185"></span>
<span class="line" id="L186"> <span class="tok-kw">const</span> DummyMutex = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L187"> <span class="tok-kw">fn</span> <span class="tok-fn">lock</span>(_: *DummyMutex) <span class="tok-type">void</span> {}</span>
<span class="line" id="L188"> <span class="tok-kw">fn</span> <span class="tok-fn">unlock</span>(_: *DummyMutex) <span class="tok-type">void</span> {}</span>
<span class="line" id="L189"> };</span>
<span class="line" id="L190"></span>
<span class="line" id="L191"> <span class="tok-kw">const</span> stack_n = config.stack_trace_frames;</span>
<span class="line" id="L192"> <span class="tok-kw">const</span> one_trace_size = <span class="tok-builtin">@sizeOf</span>(<span class="tok-type">usize</span>) * stack_n;</span>
<span class="line" id="L193"> <span class="tok-kw">const</span> traces_per_slot = <span class="tok-number">2</span>;</span>
<span class="line" id="L194"></span>
<span class="line" id="L195"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> Error = mem.Allocator.Error;</span>
<span class="line" id="L196"></span>
<span class="line" id="L197"> <span class="tok-kw">const</span> small_bucket_count = math.log2(page_size);</span>
<span class="line" id="L198"> <span class="tok-kw">const</span> largest_bucket_object_size = <span class="tok-number">1</span> << (small_bucket_count - <span class="tok-number">1</span>);</span>
<span class="line" id="L199"></span>
<span class="line" id="L200"> <span class="tok-kw">const</span> SmallAlloc = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L201"> requested_size: <span class="tok-type">usize</span>,</span>
<span class="line" id="L202"> log2_ptr_align: <span class="tok-type">u8</span>,</span>
<span class="line" id="L203"> };</span>
<span class="line" id="L204"></span>
<span class="line" id="L205"> <span class="tok-kw">const</span> LargeAlloc = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L206"> bytes: []<span class="tok-type">u8</span>,</span>
<span class="line" id="L207"> requested_size: <span class="tok-kw">if</span> (config.enable_memory_limit) <span class="tok-type">usize</span> <span class="tok-kw">else</span> <span class="tok-type">void</span>,</span>
<span class="line" id="L208"> stack_addresses: [trace_n][stack_n]<span class="tok-type">usize</span>,</span>
<span class="line" id="L209"> freed: <span class="tok-kw">if</span> (config.retain_metadata) <span class="tok-type">bool</span> <span class="tok-kw">else</span> <span class="tok-type">void</span>,</span>
<span class="line" id="L210"> log2_ptr_align: <span class="tok-kw">if</span> (config.never_unmap <span class="tok-kw">and</span> config.retain_metadata) <span class="tok-type">u8</span> <span class="tok-kw">else</span> <span class="tok-type">void</span>,</span>
<span class="line" id="L211"></span>
<span class="line" id="L212"> <span class="tok-kw">const</span> trace_n = <span class="tok-kw">if</span> (config.retain_metadata) traces_per_slot <span class="tok-kw">else</span> <span class="tok-number">1</span>;</span>
<span class="line" id="L213"></span>
<span class="line" id="L214"> <span class="tok-kw">fn</span> <span class="tok-fn">dumpStackTrace</span>(self: *LargeAlloc, trace_kind: TraceKind) <span class="tok-type">void</span> {</span>
<span class="line" id="L215"> std.debug.dumpStackTrace(self.getStackTrace(trace_kind));</span>
<span class="line" id="L216"> }</span>
<span class="line" id="L217"></span>
<span class="line" id="L218"> <span class="tok-kw">fn</span> <span class="tok-fn">getStackTrace</span>(self: *LargeAlloc, trace_kind: TraceKind) std.builtin.StackTrace {</span>
<span class="line" id="L219"> assert(<span class="tok-builtin">@intFromEnum</span>(trace_kind) < trace_n);</span>
<span class="line" id="L220"> <span class="tok-kw">const</span> stack_addresses = &self.stack_addresses[<span class="tok-builtin">@intFromEnum</span>(trace_kind)];</span>
<span class="line" id="L221"> <span class="tok-kw">var</span> len: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L222"> <span class="tok-kw">while</span> (len < stack_n <span class="tok-kw">and</span> stack_addresses[len] != <span class="tok-number">0</span>) {</span>
<span class="line" id="L223"> len += <span class="tok-number">1</span>;</span>
<span class="line" id="L224"> }</span>
<span class="line" id="L225"> <span class="tok-kw">return</span> .{</span>
<span class="line" id="L226"> .instruction_addresses = stack_addresses,</span>
<span class="line" id="L227"> .index = len,</span>
<span class="line" id="L228"> };</span>
<span class="line" id="L229"> }</span>
<span class="line" id="L230"></span>
<span class="line" id="L231"> <span class="tok-kw">fn</span> <span class="tok-fn">captureStackTrace</span>(self: *LargeAlloc, ret_addr: <span class="tok-type">usize</span>, trace_kind: TraceKind) <span class="tok-type">void</span> {</span>
<span class="line" id="L232"> assert(<span class="tok-builtin">@intFromEnum</span>(trace_kind) < trace_n);</span>
<span class="line" id="L233"> <span class="tok-kw">const</span> stack_addresses = &self.stack_addresses[<span class="tok-builtin">@intFromEnum</span>(trace_kind)];</span>
<span class="line" id="L234"> collectStackTrace(ret_addr, stack_addresses);</span>
<span class="line" id="L235"> }</span>
<span class="line" id="L236"> };</span>
<span class="line" id="L237"> <span class="tok-kw">const</span> LargeAllocTable = std.AutoHashMapUnmanaged(<span class="tok-type">usize</span>, LargeAlloc);</span>
<span class="line" id="L238"> <span class="tok-kw">const</span> SmallAllocTable = std.AutoHashMapUnmanaged(<span class="tok-type">usize</span>, SmallAlloc);</span>
<span class="line" id="L239"></span>
<span class="line" id="L240"> <span class="tok-comment">// Bucket: In memory, in order:</span>
</span>
<span class="line" id="L241"> <span class="tok-comment">// * BucketHeader</span>
</span>
<span class="line" id="L242"> <span class="tok-comment">// * bucket_used_bits: [N]u8, // 1 bit for every slot; 1 byte for every 8 slots</span>
</span>
<span class="line" id="L243"> <span class="tok-comment">// * stack_trace_addresses: [N]usize, // traces_per_slot for every allocation</span>
</span>
<span class="line" id="L244"></span>
<span class="line" id="L245"> <span class="tok-kw">const</span> BucketHeader = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L246"> prev: *BucketHeader,</span>
<span class="line" id="L247"> next: *BucketHeader,</span>
<span class="line" id="L248"> page: [*]<span class="tok-kw">align</span>(page_size) <span class="tok-type">u8</span>,</span>
<span class="line" id="L249"> alloc_cursor: SlotIndex,</span>
<span class="line" id="L250"> used_count: SlotIndex,</span>
<span class="line" id="L251"></span>
<span class="line" id="L252"> <span class="tok-kw">fn</span> <span class="tok-fn">usedBits</span>(bucket: *BucketHeader, index: <span class="tok-type">usize</span>) *<span class="tok-type">u8</span> {</span>
<span class="line" id="L253"> <span class="tok-kw">return</span> <span class="tok-builtin">@as</span>(*<span class="tok-type">u8</span>, <span class="tok-builtin">@ptrFromInt</span>(<span class="tok-builtin">@intFromPtr</span>(bucket) + <span class="tok-builtin">@sizeOf</span>(BucketHeader) + index));</span>
<span class="line" id="L254"> }</span>
<span class="line" id="L255"></span>
<span class="line" id="L256"> <span class="tok-kw">fn</span> <span class="tok-fn">stackTracePtr</span>(</span>
<span class="line" id="L257"> bucket: *BucketHeader,</span>
<span class="line" id="L258"> size_class: <span class="tok-type">usize</span>,</span>
<span class="line" id="L259"> slot_index: SlotIndex,</span>
<span class="line" id="L260"> trace_kind: TraceKind,</span>
<span class="line" id="L261"> ) *[stack_n]<span class="tok-type">usize</span> {</span>
<span class="line" id="L262"> <span class="tok-kw">const</span> start_ptr = <span class="tok-builtin">@as</span>([*]<span class="tok-type">u8</span>, <span class="tok-builtin">@ptrCast</span>(bucket)) + bucketStackFramesStart(size_class);</span>
<span class="line" id="L263"> <span class="tok-kw">const</span> addr = start_ptr + one_trace_size * traces_per_slot * slot_index +</span>
<span class="line" id="L264"> <span class="tok-builtin">@intFromEnum</span>(trace_kind) * <span class="tok-builtin">@as</span>(<span class="tok-type">usize</span>, one_trace_size);</span>
<span class="line" id="L265"> <span class="tok-kw">return</span> <span class="tok-builtin">@ptrCast</span>(<span class="tok-builtin">@alignCast</span>(addr));</span>
<span class="line" id="L266"> }</span>
<span class="line" id="L267"></span>
<span class="line" id="L268"> <span class="tok-kw">fn</span> <span class="tok-fn">captureStackTrace</span>(</span>
<span class="line" id="L269"> bucket: *BucketHeader,</span>
<span class="line" id="L270"> ret_addr: <span class="tok-type">usize</span>,</span>
<span class="line" id="L271"> size_class: <span class="tok-type">usize</span>,</span>
<span class="line" id="L272"> slot_index: SlotIndex,</span>
<span class="line" id="L273"> trace_kind: TraceKind,</span>
<span class="line" id="L274"> ) <span class="tok-type">void</span> {</span>
<span class="line" id="L275"> <span class="tok-comment">// Initialize them to 0. When determining the count we must look</span>
</span>
<span class="line" id="L276"> <span class="tok-comment">// for non zero addresses.</span>
</span>
<span class="line" id="L277"> <span class="tok-kw">const</span> stack_addresses = bucket.stackTracePtr(size_class, slot_index, trace_kind);</span>
<span class="line" id="L278"> collectStackTrace(ret_addr, stack_addresses);</span>
<span class="line" id="L279"> }</span>
<span class="line" id="L280"> };</span>
<span class="line" id="L281"></span>
<span class="line" id="L282"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">allocator</span>(self: *Self) Allocator {</span>
<span class="line" id="L283"> <span class="tok-kw">return</span> .{</span>
<span class="line" id="L284"> .ptr = self,</span>
<span class="line" id="L285"> .vtable = &.{</span>
<span class="line" id="L286"> .alloc = alloc,</span>
<span class="line" id="L287"> .resize = resize,</span>
<span class="line" id="L288"> .free = free,</span>
<span class="line" id="L289"> },</span>
<span class="line" id="L290"> };</span>
<span class="line" id="L291"> }</span>
<span class="line" id="L292"></span>
<span class="line" id="L293"> <span class="tok-kw">fn</span> <span class="tok-fn">bucketStackTrace</span>(</span>
<span class="line" id="L294"> bucket: *BucketHeader,</span>
<span class="line" id="L295"> size_class: <span class="tok-type">usize</span>,</span>
<span class="line" id="L296"> slot_index: SlotIndex,</span>
<span class="line" id="L297"> trace_kind: TraceKind,</span>
<span class="line" id="L298"> ) StackTrace {</span>
<span class="line" id="L299"> <span class="tok-kw">const</span> stack_addresses = bucket.stackTracePtr(size_class, slot_index, trace_kind);</span>
<span class="line" id="L300"> <span class="tok-kw">var</span> len: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L301"> <span class="tok-kw">while</span> (len < stack_n <span class="tok-kw">and</span> stack_addresses[len] != <span class="tok-number">0</span>) {</span>
<span class="line" id="L302"> len += <span class="tok-number">1</span>;</span>
<span class="line" id="L303"> }</span>
<span class="line" id="L304"> <span class="tok-kw">return</span> StackTrace{</span>
<span class="line" id="L305"> .instruction_addresses = stack_addresses,</span>
<span class="line" id="L306"> .index = len,</span>
<span class="line" id="L307"> };</span>
<span class="line" id="L308"> }</span>
<span class="line" id="L309"></span>
<span class="line" id="L310"> <span class="tok-kw">fn</span> <span class="tok-fn">bucketStackFramesStart</span>(size_class: <span class="tok-type">usize</span>) <span class="tok-type">usize</span> {</span>
<span class="line" id="L311"> <span class="tok-kw">return</span> mem.alignForward(</span>
<span class="line" id="L312"> <span class="tok-type">usize</span>,</span>
<span class="line" id="L313"> <span class="tok-builtin">@sizeOf</span>(BucketHeader) + usedBitsCount(size_class),</span>
<span class="line" id="L314"> <span class="tok-builtin">@alignOf</span>(<span class="tok-type">usize</span>),</span>
<span class="line" id="L315"> );</span>
<span class="line" id="L316"> }</span>
<span class="line" id="L317"></span>
<span class="line" id="L318"> <span class="tok-kw">fn</span> <span class="tok-fn">bucketSize</span>(size_class: <span class="tok-type">usize</span>) <span class="tok-type">usize</span> {</span>
<span class="line" id="L319"> <span class="tok-kw">const</span> slot_count = <span class="tok-builtin">@divExact</span>(page_size, size_class);</span>
<span class="line" id="L320"> <span class="tok-kw">return</span> bucketStackFramesStart(size_class) + one_trace_size * traces_per_slot * slot_count;</span>
<span class="line" id="L321"> }</span>
<span class="line" id="L322"></span>
<span class="line" id="L323"> <span class="tok-kw">fn</span> <span class="tok-fn">usedBitsCount</span>(size_class: <span class="tok-type">usize</span>) <span class="tok-type">usize</span> {</span>
<span class="line" id="L324"> <span class="tok-kw">const</span> slot_count = <span class="tok-builtin">@divExact</span>(page_size, size_class);</span>
<span class="line" id="L325"> <span class="tok-kw">if</span> (slot_count < <span class="tok-number">8</span>) <span class="tok-kw">return</span> <span class="tok-number">1</span>;</span>
<span class="line" id="L326"> <span class="tok-kw">return</span> <span class="tok-builtin">@divExact</span>(slot_count, <span class="tok-number">8</span>);</span>
<span class="line" id="L327"> }</span>
<span class="line" id="L328"></span>
<span class="line" id="L329"> <span class="tok-kw">fn</span> <span class="tok-fn">detectLeaksInBucket</span>(</span>
<span class="line" id="L330"> bucket: *BucketHeader,</span>
<span class="line" id="L331"> size_class: <span class="tok-type">usize</span>,</span>
<span class="line" id="L332"> used_bits_count: <span class="tok-type">usize</span>,</span>
<span class="line" id="L333"> ) <span class="tok-type">bool</span> {</span>
<span class="line" id="L334"> <span class="tok-kw">var</span> leaks = <span class="tok-null">false</span>;</span>
<span class="line" id="L335"> <span class="tok-kw">var</span> used_bits_byte: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L336"> <span class="tok-kw">while</span> (used_bits_byte < used_bits_count) : (used_bits_byte += <span class="tok-number">1</span>) {</span>
<span class="line" id="L337"> <span class="tok-kw">const</span> used_byte = bucket.usedBits(used_bits_byte).*;</span>
<span class="line" id="L338"> <span class="tok-kw">if</span> (used_byte != <span class="tok-number">0</span>) {</span>
<span class="line" id="L339"> <span class="tok-kw">var</span> bit_index: <span class="tok-type">u3</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L340"> <span class="tok-kw">while</span> (<span class="tok-null">true</span>) : (bit_index += <span class="tok-number">1</span>) {</span>
<span class="line" id="L341"> <span class="tok-kw">const</span> is_used = <span class="tok-builtin">@as</span>(<span class="tok-type">u1</span>, <span class="tok-builtin">@truncate</span>(used_byte >> bit_index)) != <span class="tok-number">0</span>;</span>
<span class="line" id="L342"> <span class="tok-kw">if</span> (is_used) {</span>
<span class="line" id="L343"> <span class="tok-kw">const</span> slot_index = <span class="tok-builtin">@as</span>(SlotIndex, <span class="tok-builtin">@intCast</span>(used_bits_byte * <span class="tok-number">8</span> + bit_index));</span>
<span class="line" id="L344"> <span class="tok-kw">const</span> stack_trace = bucketStackTrace(bucket, size_class, slot_index, .alloc);</span>
<span class="line" id="L345"> <span class="tok-kw">const</span> addr = bucket.page + slot_index * size_class;</span>
<span class="line" id="L346"> log.err(<span class="tok-str">"memory address 0x{x} leaked: {}"</span>, .{</span>
<span class="line" id="L347"> <span class="tok-builtin">@intFromPtr</span>(addr), stack_trace,</span>
<span class="line" id="L348"> });</span>
<span class="line" id="L349"> leaks = <span class="tok-null">true</span>;</span>
<span class="line" id="L350"> }</span>
<span class="line" id="L351"> <span class="tok-kw">if</span> (bit_index == math.maxInt(<span class="tok-type">u3</span>))</span>
<span class="line" id="L352"> <span class="tok-kw">break</span>;</span>
<span class="line" id="L353"> }</span>
<span class="line" id="L354"> }</span>
<span class="line" id="L355"> }</span>
<span class="line" id="L356"> <span class="tok-kw">return</span> leaks;</span>
<span class="line" id="L357"> }</span>
<span class="line" id="L358"></span>
<span class="line" id="L359"> <span class="tok-comment">/// Emits log messages for leaks and then returns whether there were any leaks.</span></span>
<span class="line" id="L360"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">detectLeaks</span>(self: *Self) <span class="tok-type">bool</span> {</span>
<span class="line" id="L361"> <span class="tok-kw">var</span> leaks = <span class="tok-null">false</span>;</span>
<span class="line" id="L362"> <span class="tok-kw">for</span> (self.buckets, <span class="tok-number">0</span>..) |optional_bucket, bucket_i| {</span>
<span class="line" id="L363"> <span class="tok-kw">const</span> first_bucket = optional_bucket <span class="tok-kw">orelse</span> <span class="tok-kw">continue</span>;</span>
<span class="line" id="L364"> <span class="tok-kw">const</span> size_class = <span class="tok-builtin">@as</span>(<span class="tok-type">usize</span>, <span class="tok-number">1</span>) << <span class="tok-builtin">@as</span>(math.Log2Int(<span class="tok-type">usize</span>), <span class="tok-builtin">@intCast</span>(bucket_i));</span>
<span class="line" id="L365"> <span class="tok-kw">const</span> used_bits_count = usedBitsCount(size_class);</span>
<span class="line" id="L366"> <span class="tok-kw">var</span> bucket = first_bucket;</span>
<span class="line" id="L367"> <span class="tok-kw">while</span> (<span class="tok-null">true</span>) {</span>
<span class="line" id="L368"> leaks = detectLeaksInBucket(bucket, size_class, used_bits_count) <span class="tok-kw">or</span> leaks;</span>
<span class="line" id="L369"> bucket = bucket.next;</span>
<span class="line" id="L370"> <span class="tok-kw">if</span> (bucket == first_bucket)</span>
<span class="line" id="L371"> <span class="tok-kw">break</span>;</span>
<span class="line" id="L372"> }</span>
<span class="line" id="L373"> }</span>
<span class="line" id="L374"> <span class="tok-kw">var</span> it = self.large_allocations.valueIterator();</span>
<span class="line" id="L375"> <span class="tok-kw">while</span> (it.next()) |large_alloc| {</span>
<span class="line" id="L376"> <span class="tok-kw">if</span> (config.retain_metadata <span class="tok-kw">and</span> large_alloc.freed) <span class="tok-kw">continue</span>;</span>
<span class="line" id="L377"> <span class="tok-kw">const</span> stack_trace = large_alloc.getStackTrace(.alloc);</span>
<span class="line" id="L378"> log.err(<span class="tok-str">"memory address 0x{x} leaked: {}"</span>, .{</span>
<span class="line" id="L379"> <span class="tok-builtin">@intFromPtr</span>(large_alloc.bytes.ptr), stack_trace,</span>
<span class="line" id="L380"> });</span>
<span class="line" id="L381"> leaks = <span class="tok-null">true</span>;</span>
<span class="line" id="L382"> }</span>
<span class="line" id="L383"> <span class="tok-kw">return</span> leaks;</span>
<span class="line" id="L384"> }</span>
<span class="line" id="L385"></span>
<span class="line" id="L386"> <span class="tok-kw">fn</span> <span class="tok-fn">freeBucket</span>(self: *Self, bucket: *BucketHeader, size_class: <span class="tok-type">usize</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L387"> <span class="tok-kw">const</span> bucket_size = bucketSize(size_class);</span>
<span class="line" id="L388"> <span class="tok-kw">const</span> bucket_slice = <span class="tok-builtin">@as</span>([*]<span class="tok-kw">align</span>(<span class="tok-builtin">@alignOf</span>(BucketHeader)) <span class="tok-type">u8</span>, <span class="tok-builtin">@ptrCast</span>(bucket))[<span class="tok-number">0</span>..bucket_size];</span>
<span class="line" id="L389"> self.backing_allocator.free(bucket_slice);</span>
<span class="line" id="L390"> }</span>
<span class="line" id="L391"></span>
<span class="line" id="L392"> <span class="tok-kw">fn</span> <span class="tok-fn">freeRetainedMetadata</span>(self: *Self) <span class="tok-type">void</span> {</span>
<span class="line" id="L393"> <span class="tok-kw">if</span> (config.retain_metadata) {</span>
<span class="line" id="L394"> <span class="tok-kw">if</span> (config.never_unmap) {</span>
<span class="line" id="L395"> <span class="tok-comment">// free large allocations that were intentionally leaked by never_unmap</span>
</span>
<span class="line" id="L396"> <span class="tok-kw">var</span> it = self.large_allocations.iterator();</span>
<span class="line" id="L397"> <span class="tok-kw">while</span> (it.next()) |large| {</span>
<span class="line" id="L398"> <span class="tok-kw">if</span> (large.value_ptr.freed) {</span>
<span class="line" id="L399"> self.backing_allocator.rawFree(large.value_ptr.bytes, large.value_ptr.log2_ptr_align, <span class="tok-builtin">@returnAddress</span>());</span>
<span class="line" id="L400"> }</span>
<span class="line" id="L401"> }</span>
<span class="line" id="L402"> }</span>
<span class="line" id="L403"> <span class="tok-comment">// free retained metadata for small allocations</span>
</span>
<span class="line" id="L404"> <span class="tok-kw">if</span> (self.empty_buckets) |first_bucket| {</span>
<span class="line" id="L405"> <span class="tok-kw">var</span> bucket = first_bucket;</span>
<span class="line" id="L406"> <span class="tok-kw">while</span> (<span class="tok-null">true</span>) {</span>
<span class="line" id="L407"> <span class="tok-kw">const</span> prev = bucket.prev;</span>
<span class="line" id="L408"> <span class="tok-kw">if</span> (config.never_unmap) {</span>
<span class="line" id="L409"> <span class="tok-comment">// free page that was intentionally leaked by never_unmap</span>
</span>
<span class="line" id="L410"> self.backing_allocator.free(bucket.page[<span class="tok-number">0</span>..page_size]);</span>
<span class="line" id="L411"> }</span>
<span class="line" id="L412"> <span class="tok-comment">// alloc_cursor was set to slot count when bucket added to empty_buckets</span>
</span>
<span class="line" id="L413"> self.freeBucket(bucket, <span class="tok-builtin">@divExact</span>(page_size, bucket.alloc_cursor));</span>
<span class="line" id="L414"> bucket = prev;</span>
<span class="line" id="L415"> <span class="tok-kw">if</span> (bucket == first_bucket)</span>
<span class="line" id="L416"> <span class="tok-kw">break</span>;</span>
<span class="line" id="L417"> }</span>
<span class="line" id="L418"> self.empty_buckets = <span class="tok-null">null</span>;</span>
<span class="line" id="L419"> }</span>
<span class="line" id="L420"> }</span>
<span class="line" id="L421"> }</span>
<span class="line" id="L422"></span>
<span class="line" id="L423"> <span class="tok-kw">pub</span> <span class="tok-kw">usingnamespace</span> <span class="tok-kw">if</span> (config.retain_metadata) <span class="tok-kw">struct</span> {</span>
<span class="line" id="L424"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">flushRetainedMetadata</span>(self: *Self) <span class="tok-type">void</span> {</span>
<span class="line" id="L425"> self.freeRetainedMetadata();</span>
<span class="line" id="L426"> <span class="tok-comment">// also remove entries from large_allocations</span>
</span>
<span class="line" id="L427"> <span class="tok-kw">var</span> it = self.large_allocations.iterator();</span>
<span class="line" id="L428"> <span class="tok-kw">while</span> (it.next()) |large| {</span>
<span class="line" id="L429"> <span class="tok-kw">if</span> (large.value_ptr.freed) {</span>
<span class="line" id="L430"> _ = self.large_allocations.remove(<span class="tok-builtin">@intFromPtr</span>(large.value_ptr.bytes.ptr));</span>
<span class="line" id="L431"> }</span>
<span class="line" id="L432"> }</span>
<span class="line" id="L433"> }</span>
<span class="line" id="L434"> } <span class="tok-kw">else</span> <span class="tok-kw">struct</span> {};</span>
<span class="line" id="L435"></span>
<span class="line" id="L436"> <span class="tok-comment">/// Returns `Check.leak` if there were leaks; `Check.ok` otherwise.</span></span>
<span class="line" id="L437"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">deinit</span>(self: *Self) Check {</span>
<span class="line" id="L438"> <span class="tok-kw">const</span> leaks = <span class="tok-kw">if</span> (config.safety) self.detectLeaks() <span class="tok-kw">else</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L439"> <span class="tok-kw">if</span> (config.retain_metadata) {</span>
<span class="line" id="L440"> self.freeRetainedMetadata();</span>
<span class="line" id="L441"> }</span>
<span class="line" id="L442"> self.large_allocations.deinit(self.backing_allocator);</span>
<span class="line" id="L443"> <span class="tok-kw">if</span> (config.safety) {</span>
<span class="line" id="L444"> self.small_allocations.deinit(self.backing_allocator);</span>
<span class="line" id="L445"> }</span>
<span class="line" id="L446"> self.* = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L447"> <span class="tok-kw">return</span> <span class="tok-builtin">@as</span>(Check, <span class="tok-builtin">@enumFromInt</span>(<span class="tok-builtin">@intFromBool</span>(leaks)));</span>
<span class="line" id="L448"> }</span>
<span class="line" id="L449"></span>
<span class="line" id="L450"> <span class="tok-kw">fn</span> <span class="tok-fn">collectStackTrace</span>(first_trace_addr: <span class="tok-type">usize</span>, addresses: *[stack_n]<span class="tok-type">usize</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L451"> <span class="tok-kw">if</span> (stack_n == <span class="tok-number">0</span>) <span class="tok-kw">return</span>;</span>
<span class="line" id="L452"> <span class="tok-builtin">@memset</span>(addresses, <span class="tok-number">0</span>);</span>
<span class="line" id="L453"> <span class="tok-kw">var</span> stack_trace = StackTrace{</span>
<span class="line" id="L454"> .instruction_addresses = addresses,</span>
<span class="line" id="L455"> .index = <span class="tok-number">0</span>,</span>
<span class="line" id="L456"> };</span>
<span class="line" id="L457"> std.debug.captureStackTrace(first_trace_addr, &stack_trace);</span>
<span class="line" id="L458"> }</span>
<span class="line" id="L459"></span>
<span class="line" id="L460"> <span class="tok-kw">fn</span> <span class="tok-fn">reportDoubleFree</span>(ret_addr: <span class="tok-type">usize</span>, alloc_stack_trace: StackTrace, free_stack_trace: StackTrace) <span class="tok-type">void</span> {</span>
<span class="line" id="L461"> <span class="tok-kw">var</span> addresses: [stack_n]<span class="tok-type">usize</span> = [<span class="tok-number">1</span>]<span class="tok-type">usize</span>{<span class="tok-number">0</span>} ** stack_n;</span>
<span class="line" id="L462"> <span class="tok-kw">var</span> second_free_stack_trace = StackTrace{</span>
<span class="line" id="L463"> .instruction_addresses = &addresses,</span>
<span class="line" id="L464"> .index = <span class="tok-number">0</span>,</span>
<span class="line" id="L465"> };</span>
<span class="line" id="L466"> std.debug.captureStackTrace(ret_addr, &second_free_stack_trace);</span>
<span class="line" id="L467"> log.err(<span class="tok-str">"Double free detected. Allocation: {} First free: {} Second free: {}"</span>, .{</span>
<span class="line" id="L468"> alloc_stack_trace, free_stack_trace, second_free_stack_trace,</span>
<span class="line" id="L469"> });</span>
<span class="line" id="L470"> }</span>
<span class="line" id="L471"></span>
<span class="line" id="L472"> <span class="tok-kw">fn</span> <span class="tok-fn">allocSlot</span>(self: *Self, size_class: <span class="tok-type">usize</span>, trace_addr: <span class="tok-type">usize</span>) Error![*]<span class="tok-type">u8</span> {</span>
<span class="line" id="L473"> <span class="tok-kw">const</span> bucket_index = math.log2(size_class);</span>
<span class="line" id="L474"> <span class="tok-kw">const</span> first_bucket = self.buckets[bucket_index] <span class="tok-kw">orelse</span> <span class="tok-kw">try</span> self.createBucket(</span>
<span class="line" id="L475"> size_class,</span>
<span class="line" id="L476"> bucket_index,</span>
<span class="line" id="L477"> );</span>
<span class="line" id="L478"> <span class="tok-kw">var</span> bucket = first_bucket;</span>
<span class="line" id="L479"> <span class="tok-kw">const</span> slot_count = <span class="tok-builtin">@divExact</span>(page_size, size_class);</span>
<span class="line" id="L480"> <span class="tok-kw">while</span> (bucket.alloc_cursor == slot_count) {</span>
<span class="line" id="L481"> <span class="tok-kw">const</span> prev_bucket = bucket;</span>
<span class="line" id="L482"> bucket = prev_bucket.next;</span>
<span class="line" id="L483"> <span class="tok-kw">if</span> (bucket == first_bucket) {</span>
<span class="line" id="L484"> <span class="tok-comment">// make a new one</span>
</span>
<span class="line" id="L485"> bucket = <span class="tok-kw">try</span> self.createBucket(size_class, bucket_index);</span>
<span class="line" id="L486"> bucket.prev = prev_bucket;</span>
<span class="line" id="L487"> bucket.next = prev_bucket.next;</span>
<span class="line" id="L488"> prev_bucket.next = bucket;</span>
<span class="line" id="L489"> bucket.next.prev = bucket;</span>
<span class="line" id="L490"> }</span>
<span class="line" id="L491"> }</span>
<span class="line" id="L492"> <span class="tok-comment">// change the allocator's current bucket to be this one</span>
</span>
<span class="line" id="L493"> self.buckets[bucket_index] = bucket;</span>
<span class="line" id="L494"></span>
<span class="line" id="L495"> <span class="tok-kw">const</span> slot_index = bucket.alloc_cursor;</span>
<span class="line" id="L496"> bucket.alloc_cursor += <span class="tok-number">1</span>;</span>
<span class="line" id="L497"></span>
<span class="line" id="L498"> <span class="tok-kw">var</span> used_bits_byte = bucket.usedBits(slot_index / <span class="tok-number">8</span>);</span>
<span class="line" id="L499"> <span class="tok-kw">const</span> used_bit_index: <span class="tok-type">u3</span> = <span class="tok-builtin">@as</span>(<span class="tok-type">u3</span>, <span class="tok-builtin">@intCast</span>(slot_index % <span class="tok-number">8</span>)); <span class="tok-comment">// TODO cast should be unnecessary</span>
</span>
<span class="line" id="L500"> used_bits_byte.* |= (<span class="tok-builtin">@as</span>(<span class="tok-type">u8</span>, <span class="tok-number">1</span>) << used_bit_index);</span>
<span class="line" id="L501"> bucket.used_count += <span class="tok-number">1</span>;</span>
<span class="line" id="L502"> bucket.captureStackTrace(trace_addr, size_class, slot_index, .alloc);</span>
<span class="line" id="L503"> <span class="tok-kw">return</span> bucket.page + slot_index * size_class;</span>
<span class="line" id="L504"> }</span>
<span class="line" id="L505"></span>
<span class="line" id="L506"> <span class="tok-kw">fn</span> <span class="tok-fn">searchBucket</span>(</span>
<span class="line" id="L507"> bucket_list: ?*BucketHeader,</span>
<span class="line" id="L508"> addr: <span class="tok-type">usize</span>,</span>
<span class="line" id="L509"> ) ?*BucketHeader {</span>
<span class="line" id="L510"> <span class="tok-kw">const</span> first_bucket = bucket_list <span class="tok-kw">orelse</span> <span class="tok-kw">return</span> <span class="tok-null">null</span>;</span>
<span class="line" id="L511"> <span class="tok-kw">var</span> bucket = first_bucket;</span>
<span class="line" id="L512"> <span class="tok-kw">while</span> (<span class="tok-null">true</span>) {</span>
<span class="line" id="L513"> <span class="tok-kw">const</span> in_bucket_range = (addr >= <span class="tok-builtin">@intFromPtr</span>(bucket.page) <span class="tok-kw">and</span></span>
<span class="line" id="L514"> addr < <span class="tok-builtin">@intFromPtr</span>(bucket.page) + page_size);</span>
<span class="line" id="L515"> <span class="tok-kw">if</span> (in_bucket_range) <span class="tok-kw">return</span> bucket;</span>
<span class="line" id="L516"> bucket = bucket.prev;</span>
<span class="line" id="L517"> <span class="tok-kw">if</span> (bucket == first_bucket) {</span>
<span class="line" id="L518"> <span class="tok-kw">return</span> <span class="tok-null">null</span>;</span>
<span class="line" id="L519"> }</span>
<span class="line" id="L520"> }</span>
<span class="line" id="L521"> }</span>
<span class="line" id="L522"></span>
<span class="line" id="L523"> <span class="tok-comment">/// This function assumes the object is in the large object storage regardless</span></span>
<span class="line" id="L524"> <span class="tok-comment">/// of the parameters.</span></span>
<span class="line" id="L525"> <span class="tok-kw">fn</span> <span class="tok-fn">resizeLarge</span>(</span>
<span class="line" id="L526"> self: *Self,</span>
<span class="line" id="L527"> old_mem: []<span class="tok-type">u8</span>,</span>
<span class="line" id="L528"> log2_old_align: <span class="tok-type">u8</span>,</span>
<span class="line" id="L529"> new_size: <span class="tok-type">usize</span>,</span>
<span class="line" id="L530"> ret_addr: <span class="tok-type">usize</span>,</span>
<span class="line" id="L531"> ) <span class="tok-type">bool</span> {</span>
<span class="line" id="L532"> <span class="tok-kw">const</span> entry = self.large_allocations.getEntry(<span class="tok-builtin">@intFromPtr</span>(old_mem.ptr)) <span class="tok-kw">orelse</span> {</span>
<span class="line" id="L533"> <span class="tok-kw">if</span> (config.safety) {</span>
<span class="line" id="L534"> <span class="tok-builtin">@panic</span>(<span class="tok-str">"Invalid free"</span>);</span>
<span class="line" id="L535"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L536"> <span class="tok-kw">unreachable</span>;</span>
<span class="line" id="L537"> }</span>
<span class="line" id="L538"> };</span>
<span class="line" id="L539"></span>
<span class="line" id="L540"> <span class="tok-kw">if</span> (config.retain_metadata <span class="tok-kw">and</span> entry.value_ptr.freed) {</span>
<span class="line" id="L541"> <span class="tok-kw">if</span> (config.safety) {</span>
<span class="line" id="L542"> reportDoubleFree(ret_addr, entry.value_ptr.getStackTrace(.alloc), entry.value_ptr.getStackTrace(.free));</span>
<span class="line" id="L543"> <span class="tok-builtin">@panic</span>(<span class="tok-str">"Unrecoverable double free"</span>);</span>
<span class="line" id="L544"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L545"> <span class="tok-kw">unreachable</span>;</span>
<span class="line" id="L546"> }</span>
<span class="line" id="L547"> }</span>
<span class="line" id="L548"></span>
<span class="line" id="L549"> <span class="tok-kw">if</span> (config.safety <span class="tok-kw">and</span> old_mem.len != entry.value_ptr.bytes.len) {</span>
<span class="line" id="L550"> <span class="tok-kw">var</span> addresses: [stack_n]<span class="tok-type">usize</span> = [<span class="tok-number">1</span>]<span class="tok-type">usize</span>{<span class="tok-number">0</span>} ** stack_n;</span>
<span class="line" id="L551"> <span class="tok-kw">var</span> free_stack_trace = StackTrace{</span>
<span class="line" id="L552"> .instruction_addresses = &addresses,</span>
<span class="line" id="L553"> .index = <span class="tok-number">0</span>,</span>
<span class="line" id="L554"> };</span>
<span class="line" id="L555"> std.debug.captureStackTrace(ret_addr, &free_stack_trace);</span>
<span class="line" id="L556"> log.err(<span class="tok-str">"Allocation size {d} bytes does not match free size {d}. Allocation: {} Free: {}"</span>, .{</span>
<span class="line" id="L557"> entry.value_ptr.bytes.len,</span>
<span class="line" id="L558"> old_mem.len,</span>
<span class="line" id="L559"> entry.value_ptr.getStackTrace(.alloc),</span>
<span class="line" id="L560"> free_stack_trace,</span>
<span class="line" id="L561"> });</span>
<span class="line" id="L562"> }</span>
<span class="line" id="L563"></span>
<span class="line" id="L564"> <span class="tok-comment">// Do memory limit accounting with requested sizes rather than what</span>
</span>
<span class="line" id="L565"> <span class="tok-comment">// backing_allocator returns because if we want to return</span>
</span>
<span class="line" id="L566"> <span class="tok-comment">// error.OutOfMemory, we have to leave allocation untouched, and</span>
</span>
<span class="line" id="L567"> <span class="tok-comment">// that is impossible to guarantee after calling</span>
</span>
<span class="line" id="L568"> <span class="tok-comment">// backing_allocator.rawResize.</span>
</span>
<span class="line" id="L569"> <span class="tok-kw">const</span> prev_req_bytes = self.total_requested_bytes;</span>
<span class="line" id="L570"> <span class="tok-kw">if</span> (config.enable_memory_limit) {</span>
<span class="line" id="L571"> <span class="tok-kw">const</span> new_req_bytes = prev_req_bytes + new_size - entry.value_ptr.requested_size;</span>
<span class="line" id="L572"> <span class="tok-kw">if</span> (new_req_bytes > prev_req_bytes <span class="tok-kw">and</span> new_req_bytes > self.requested_memory_limit) {</span>
<span class="line" id="L573"> <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L574"> }</span>
<span class="line" id="L575"> self.total_requested_bytes = new_req_bytes;</span>
<span class="line" id="L576"> }</span>
<span class="line" id="L577"></span>
<span class="line" id="L578"> <span class="tok-kw">if</span> (!self.backing_allocator.rawResize(old_mem, log2_old_align, new_size, ret_addr)) {</span>
<span class="line" id="L579"> <span class="tok-kw">if</span> (config.enable_memory_limit) {</span>
<span class="line" id="L580"> self.total_requested_bytes = prev_req_bytes;</span>
<span class="line" id="L581"> }</span>
<span class="line" id="L582"> <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L583"> }</span>
<span class="line" id="L584"></span>
<span class="line" id="L585"> <span class="tok-kw">if</span> (config.enable_memory_limit) {</span>
<span class="line" id="L586"> entry.value_ptr.requested_size = new_size;</span>
<span class="line" id="L587"> }</span>
<span class="line" id="L588"></span>
<span class="line" id="L589"> <span class="tok-kw">if</span> (config.verbose_log) {</span>
<span class="line" id="L590"> log.info(<span class="tok-str">"large resize {d} bytes at {*} to {d}"</span>, .{</span>
<span class="line" id="L591"> old_mem.len, old_mem.ptr, new_size,</span>
<span class="line" id="L592"> });</span>
<span class="line" id="L593"> }</span>
<span class="line" id="L594"> entry.value_ptr.bytes = old_mem.ptr[<span class="tok-number">0</span>..new_size];</span>
<span class="line" id="L595"> entry.value_ptr.captureStackTrace(ret_addr, .alloc);</span>
<span class="line" id="L596"> <span class="tok-kw">return</span> <span class="tok-null">true</span>;</span>
<span class="line" id="L597"> }</span>
<span class="line" id="L598"></span>
<span class="line" id="L599"> <span class="tok-comment">/// This function assumes the object is in the large object storage regardless</span></span>
<span class="line" id="L600"> <span class="tok-comment">/// of the parameters.</span></span>
<span class="line" id="L601"> <span class="tok-kw">fn</span> <span class="tok-fn">freeLarge</span>(</span>
<span class="line" id="L602"> self: *Self,</span>
<span class="line" id="L603"> old_mem: []<span class="tok-type">u8</span>,</span>
<span class="line" id="L604"> log2_old_align: <span class="tok-type">u8</span>,</span>
<span class="line" id="L605"> ret_addr: <span class="tok-type">usize</span>,</span>
<span class="line" id="L606"> ) <span class="tok-type">void</span> {</span>
<span class="line" id="L607"> <span class="tok-kw">const</span> entry = self.large_allocations.getEntry(<span class="tok-builtin">@intFromPtr</span>(old_mem.ptr)) <span class="tok-kw">orelse</span> {</span>
<span class="line" id="L608"> <span class="tok-kw">if</span> (config.safety) {</span>
<span class="line" id="L609"> <span class="tok-builtin">@panic</span>(<span class="tok-str">"Invalid free"</span>);</span>
<span class="line" id="L610"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L611"> <span class="tok-kw">unreachable</span>;</span>
<span class="line" id="L612"> }</span>
<span class="line" id="L613"> };</span>
<span class="line" id="L614"></span>
<span class="line" id="L615"> <span class="tok-kw">if</span> (config.retain_metadata <span class="tok-kw">and</span> entry.value_ptr.freed) {</span>
<span class="line" id="L616"> <span class="tok-kw">if</span> (config.safety) {</span>
<span class="line" id="L617"> reportDoubleFree(ret_addr, entry.value_ptr.getStackTrace(.alloc), entry.value_ptr.getStackTrace(.free));</span>
<span class="line" id="L618"> <span class="tok-kw">return</span>;</span>
<span class="line" id="L619"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L620"> <span class="tok-kw">unreachable</span>;</span>
<span class="line" id="L621"> }</span>
<span class="line" id="L622"> }</span>
<span class="line" id="L623"></span>
<span class="line" id="L624"> <span class="tok-kw">if</span> (config.safety <span class="tok-kw">and</span> old_mem.len != entry.value_ptr.bytes.len) {</span>
<span class="line" id="L625"> <span class="tok-kw">var</span> addresses: [stack_n]<span class="tok-type">usize</span> = [<span class="tok-number">1</span>]<span class="tok-type">usize</span>{<span class="tok-number">0</span>} ** stack_n;</span>
<span class="line" id="L626"> <span class="tok-kw">var</span> free_stack_trace = StackTrace{</span>
<span class="line" id="L627"> .instruction_addresses = &addresses,</span>
<span class="line" id="L628"> .index = <span class="tok-number">0</span>,</span>
<span class="line" id="L629"> };</span>
<span class="line" id="L630"> std.debug.captureStackTrace(ret_addr, &free_stack_trace);</span>
<span class="line" id="L631"> log.err(<span class="tok-str">"Allocation size {d} bytes does not match free size {d}. Allocation: {} Free: {}"</span>, .{</span>
<span class="line" id="L632"> entry.value_ptr.bytes.len,</span>
<span class="line" id="L633"> old_mem.len,</span>
<span class="line" id="L634"> entry.value_ptr.getStackTrace(.alloc),</span>
<span class="line" id="L635"> free_stack_trace,</span>
<span class="line" id="L636"> });</span>
<span class="line" id="L637"> }</span>
<span class="line" id="L638"></span>
<span class="line" id="L639"> <span class="tok-kw">if</span> (!config.never_unmap) {</span>
<span class="line" id="L640"> self.backing_allocator.rawFree(old_mem, log2_old_align, ret_addr);</span>
<span class="line" id="L641"> }</span>
<span class="line" id="L642"></span>
<span class="line" id="L643"> <span class="tok-kw">if</span> (config.enable_memory_limit) {</span>
<span class="line" id="L644"> self.total_requested_bytes -= entry.value_ptr.requested_size;</span>
<span class="line" id="L645"> }</span>
<span class="line" id="L646"></span>
<span class="line" id="L647"> <span class="tok-kw">if</span> (config.verbose_log) {</span>
<span class="line" id="L648"> log.info(<span class="tok-str">"large free {d} bytes at {*}"</span>, .{ old_mem.len, old_mem.ptr });</span>
<span class="line" id="L649"> }</span>
<span class="line" id="L650"></span>
<span class="line" id="L651"> <span class="tok-kw">if</span> (!config.retain_metadata) {</span>
<span class="line" id="L652"> assert(self.large_allocations.remove(<span class="tok-builtin">@intFromPtr</span>(old_mem.ptr)));</span>
<span class="line" id="L653"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L654"> entry.value_ptr.freed = <span class="tok-null">true</span>;</span>
<span class="line" id="L655"> entry.value_ptr.captureStackTrace(ret_addr, .free);</span>
<span class="line" id="L656"> }</span>
<span class="line" id="L657"> }</span>
<span class="line" id="L658"></span>
<span class="line" id="L659"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">setRequestedMemoryLimit</span>(self: *Self, limit: <span class="tok-type">usize</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L660"> self.requested_memory_limit = limit;</span>
<span class="line" id="L661"> }</span>
<span class="line" id="L662"></span>
<span class="line" id="L663"> <span class="tok-kw">fn</span> <span class="tok-fn">resize</span>(</span>
<span class="line" id="L664"> ctx: *<span class="tok-type">anyopaque</span>,</span>
<span class="line" id="L665"> old_mem: []<span class="tok-type">u8</span>,</span>
<span class="line" id="L666"> log2_old_align_u8: <span class="tok-type">u8</span>,</span>
<span class="line" id="L667"> new_size: <span class="tok-type">usize</span>,</span>
<span class="line" id="L668"> ret_addr: <span class="tok-type">usize</span>,</span>
<span class="line" id="L669"> ) <span class="tok-type">bool</span> {</span>
<span class="line" id="L670"> <span class="tok-kw">const</span> self: *Self = <span class="tok-builtin">@ptrCast</span>(<span class="tok-builtin">@alignCast</span>(ctx));</span>
<span class="line" id="L671"> <span class="tok-kw">const</span> log2_old_align = <span class="tok-builtin">@as</span>(Allocator.Log2Align, <span class="tok-builtin">@intCast</span>(log2_old_align_u8));</span>
<span class="line" id="L672"> self.mutex.lock();</span>
<span class="line" id="L673"> <span class="tok-kw">defer</span> self.mutex.unlock();</span>
<span class="line" id="L674"></span>
<span class="line" id="L675"> assert(old_mem.len != <span class="tok-number">0</span>);</span>
<span class="line" id="L676"></span>
<span class="line" id="L677"> <span class="tok-kw">const</span> aligned_size = <span class="tok-builtin">@max</span>(old_mem.len, <span class="tok-builtin">@as</span>(<span class="tok-type">usize</span>, <span class="tok-number">1</span>) << log2_old_align);</span>
<span class="line" id="L678"> <span class="tok-kw">if</span> (aligned_size > largest_bucket_object_size) {</span>
<span class="line" id="L679"> <span class="tok-kw">return</span> self.resizeLarge(old_mem, log2_old_align, new_size, ret_addr);</span>
<span class="line" id="L680"> }</span>
<span class="line" id="L681"> <span class="tok-kw">const</span> size_class_hint = math.ceilPowerOfTwoAssert(<span class="tok-type">usize</span>, aligned_size);</span>
<span class="line" id="L682"></span>
<span class="line" id="L683"> <span class="tok-kw">var</span> bucket_index = math.log2(size_class_hint);</span>
<span class="line" id="L684"> <span class="tok-kw">var</span> size_class: <span class="tok-type">usize</span> = size_class_hint;</span>
<span class="line" id="L685"> <span class="tok-kw">const</span> bucket = <span class="tok-kw">while</span> (bucket_index < small_bucket_count) : (bucket_index += <span class="tok-number">1</span>) {</span>
<span class="line" id="L686"> <span class="tok-kw">if</span> (searchBucket(self.buckets[bucket_index], <span class="tok-builtin">@intFromPtr</span>(old_mem.ptr))) |bucket| {</span>
<span class="line" id="L687"> <span class="tok-comment">// move bucket to head of list to optimize search for nearby allocations</span>
</span>
<span class="line" id="L688"> self.buckets[bucket_index] = bucket;</span>
<span class="line" id="L689"> <span class="tok-kw">break</span> bucket;</span>
<span class="line" id="L690"> }</span>
<span class="line" id="L691"> size_class *= <span class="tok-number">2</span>;</span>
<span class="line" id="L692"> } <span class="tok-kw">else</span> blk: {</span>
<span class="line" id="L693"> <span class="tok-kw">if</span> (config.retain_metadata) {</span>
<span class="line" id="L694"> <span class="tok-kw">if</span> (!self.large_allocations.contains(<span class="tok-builtin">@intFromPtr</span>(old_mem.ptr))) {</span>
<span class="line" id="L695"> <span class="tok-comment">// object not in active buckets or a large allocation, so search empty buckets</span>
</span>
<span class="line" id="L696"> <span class="tok-kw">if</span> (searchBucket(self.empty_buckets, <span class="tok-builtin">@intFromPtr</span>(old_mem.ptr))) |bucket| {</span>
<span class="line" id="L697"> <span class="tok-comment">// bucket is empty so is_used below will always be false and we exit there</span>
</span>
<span class="line" id="L698"> <span class="tok-kw">break</span> :blk bucket;</span>
<span class="line" id="L699"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L700"> <span class="tok-builtin">@panic</span>(<span class="tok-str">"Invalid free"</span>);</span>
<span class="line" id="L701"> }</span>
<span class="line" id="L702"> }</span>
<span class="line" id="L703"> }</span>
<span class="line" id="L704"> <span class="tok-kw">return</span> self.resizeLarge(old_mem, log2_old_align, new_size, ret_addr);</span>
<span class="line" id="L705"> };</span>
<span class="line" id="L706"> <span class="tok-kw">const</span> byte_offset = <span class="tok-builtin">@intFromPtr</span>(old_mem.ptr) - <span class="tok-builtin">@intFromPtr</span>(bucket.page);</span>
<span class="line" id="L707"> <span class="tok-kw">const</span> slot_index = <span class="tok-builtin">@as</span>(SlotIndex, <span class="tok-builtin">@intCast</span>(byte_offset / size_class));</span>
<span class="line" id="L708"> <span class="tok-kw">const</span> used_byte_index = slot_index / <span class="tok-number">8</span>;</span>
<span class="line" id="L709"> <span class="tok-kw">const</span> used_bit_index = <span class="tok-builtin">@as</span>(<span class="tok-type">u3</span>, <span class="tok-builtin">@intCast</span>(slot_index % <span class="tok-number">8</span>));</span>
<span class="line" id="L710"> <span class="tok-kw">const</span> used_byte = bucket.usedBits(used_byte_index);</span>
<span class="line" id="L711"> <span class="tok-kw">const</span> is_used = <span class="tok-builtin">@as</span>(<span class="tok-type">u1</span>, <span class="tok-builtin">@truncate</span>(used_byte.* >> used_bit_index)) != <span class="tok-number">0</span>;</span>
<span class="line" id="L712"> <span class="tok-kw">if</span> (!is_used) {</span>
<span class="line" id="L713"> <span class="tok-kw">if</span> (config.safety) {</span>
<span class="line" id="L714"> reportDoubleFree(ret_addr, bucketStackTrace(bucket, size_class, slot_index, .alloc), bucketStackTrace(bucket, size_class, slot_index, .free));</span>
<span class="line" id="L715"> <span class="tok-builtin">@panic</span>(<span class="tok-str">"Unrecoverable double free"</span>);</span>
<span class="line" id="L716"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L717"> <span class="tok-kw">unreachable</span>;</span>
<span class="line" id="L718"> }</span>
<span class="line" id="L719"> }</span>
<span class="line" id="L720"></span>
<span class="line" id="L721"> <span class="tok-comment">// Definitely an in-use small alloc now.</span>
</span>
<span class="line" id="L722"> <span class="tok-kw">if</span> (config.safety) {</span>
<span class="line" id="L723"> <span class="tok-kw">const</span> entry = self.small_allocations.getEntry(<span class="tok-builtin">@intFromPtr</span>(old_mem.ptr)) <span class="tok-kw">orelse</span></span>
<span class="line" id="L724"> <span class="tok-builtin">@panic</span>(<span class="tok-str">"Invalid free"</span>);</span>
<span class="line" id="L725"> <span class="tok-kw">if</span> (old_mem.len != entry.value_ptr.requested_size <span class="tok-kw">or</span> log2_old_align != entry.value_ptr.log2_ptr_align) {</span>
<span class="line" id="L726"> <span class="tok-kw">var</span> addresses: [stack_n]<span class="tok-type">usize</span> = [<span class="tok-number">1</span>]<span class="tok-type">usize</span>{<span class="tok-number">0</span>} ** stack_n;</span>
<span class="line" id="L727"> <span class="tok-kw">var</span> free_stack_trace = StackTrace{</span>
<span class="line" id="L728"> .instruction_addresses = &addresses,</span>
<span class="line" id="L729"> .index = <span class="tok-number">0</span>,</span>
<span class="line" id="L730"> };</span>
<span class="line" id="L731"> std.debug.captureStackTrace(ret_addr, &free_stack_trace);</span>
<span class="line" id="L732"> <span class="tok-kw">if</span> (old_mem.len != entry.value_ptr.requested_size) {</span>
<span class="line" id="L733"> log.err(<span class="tok-str">"Allocation size {d} bytes does not match resize size {d}. Allocation: {} Resize: {}"</span>, .{</span>
<span class="line" id="L734"> entry.value_ptr.requested_size,</span>
<span class="line" id="L735"> old_mem.len,</span>
<span class="line" id="L736"> bucketStackTrace(bucket, size_class, slot_index, .alloc),</span>
<span class="line" id="L737"> free_stack_trace,</span>
<span class="line" id="L738"> });</span>
<span class="line" id="L739"> }</span>
<span class="line" id="L740"> <span class="tok-kw">if</span> (log2_old_align != entry.value_ptr.log2_ptr_align) {</span>
<span class="line" id="L741"> log.err(<span class="tok-str">"Allocation alignment {d} does not match resize alignment {d}. Allocation: {} Resize: {}"</span>, .{</span>
<span class="line" id="L742"> <span class="tok-builtin">@as</span>(<span class="tok-type">usize</span>, <span class="tok-number">1</span>) << <span class="tok-builtin">@as</span>(math.Log2Int(<span class="tok-type">usize</span>), <span class="tok-builtin">@intCast</span>(entry.value_ptr.log2_ptr_align)),</span>
<span class="line" id="L743"> <span class="tok-builtin">@as</span>(<span class="tok-type">usize</span>, <span class="tok-number">1</span>) << <span class="tok-builtin">@as</span>(math.Log2Int(<span class="tok-type">usize</span>), <span class="tok-builtin">@intCast</span>(log2_old_align)),</span>
<span class="line" id="L744"> bucketStackTrace(bucket, size_class, slot_index, .alloc),</span>
<span class="line" id="L745"> free_stack_trace,</span>
<span class="line" id="L746"> });</span>
<span class="line" id="L747"> }</span>
<span class="line" id="L748"> }</span>
<span class="line" id="L749"> }</span>
<span class="line" id="L750"> <span class="tok-kw">const</span> prev_req_bytes = self.total_requested_bytes;</span>
<span class="line" id="L751"> <span class="tok-kw">if</span> (config.enable_memory_limit) {</span>
<span class="line" id="L752"> <span class="tok-kw">const</span> new_req_bytes = prev_req_bytes + new_size - old_mem.len;</span>
<span class="line" id="L753"> <span class="tok-kw">if</span> (new_req_bytes > prev_req_bytes <span class="tok-kw">and</span> new_req_bytes > self.requested_memory_limit) {</span>
<span class="line" id="L754"> <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L755"> }</span>
<span class="line" id="L756"> self.total_requested_bytes = new_req_bytes;</span>
<span class="line" id="L757"> }</span>
<span class="line" id="L758"></span>
<span class="line" id="L759"> <span class="tok-kw">const</span> new_aligned_size = <span class="tok-builtin">@max</span>(new_size, <span class="tok-builtin">@as</span>(<span class="tok-type">usize</span>, <span class="tok-number">1</span>) << log2_old_align);</span>
<span class="line" id="L760"> <span class="tok-kw">const</span> new_size_class = math.ceilPowerOfTwoAssert(<span class="tok-type">usize</span>, new_aligned_size);</span>
<span class="line" id="L761"> <span class="tok-kw">if</span> (new_size_class <= size_class) {</span>
<span class="line" id="L762"> <span class="tok-kw">if</span> (old_mem.len > new_size) {</span>
<span class="line" id="L763"> <span class="tok-builtin">@memset</span>(old_mem[new_size..], <span class="tok-null">undefined</span>);</span>
<span class="line" id="L764"> }</span>
<span class="line" id="L765"> <span class="tok-kw">if</span> (config.verbose_log) {</span>
<span class="line" id="L766"> log.info(<span class="tok-str">"small resize {d} bytes at {*} to {d}"</span>, .{</span>
<span class="line" id="L767"> old_mem.len, old_mem.ptr, new_size,</span>
<span class="line" id="L768"> });</span>
<span class="line" id="L769"> }</span>
<span class="line" id="L770"> <span class="tok-kw">if</span> (config.safety) {</span>
<span class="line" id="L771"> <span class="tok-kw">const</span> entry = self.small_allocations.getEntry(<span class="tok-builtin">@intFromPtr</span>(old_mem.ptr)).?;</span>
<span class="line" id="L772"> entry.value_ptr.requested_size = new_size;</span>
<span class="line" id="L773"> }</span>
<span class="line" id="L774"> <span class="tok-kw">return</span> <span class="tok-null">true</span>;</span>
<span class="line" id="L775"> }</span>
<span class="line" id="L776"></span>
<span class="line" id="L777"> <span class="tok-kw">if</span> (config.enable_memory_limit) {</span>
<span class="line" id="L778"> self.total_requested_bytes = prev_req_bytes;</span>
<span class="line" id="L779"> }</span>
<span class="line" id="L780"> <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L781"> }</span>
<span class="line" id="L782"></span>
<span class="line" id="L783"> <span class="tok-kw">fn</span> <span class="tok-fn">free</span>(</span>
<span class="line" id="L784"> ctx: *<span class="tok-type">anyopaque</span>,</span>
<span class="line" id="L785"> old_mem: []<span class="tok-type">u8</span>,</span>
<span class="line" id="L786"> log2_old_align_u8: <span class="tok-type">u8</span>,</span>
<span class="line" id="L787"> ret_addr: <span class="tok-type">usize</span>,</span>
<span class="line" id="L788"> ) <span class="tok-type">void</span> {</span>
<span class="line" id="L789"> <span class="tok-kw">const</span> self: *Self = <span class="tok-builtin">@ptrCast</span>(<span class="tok-builtin">@alignCast</span>(ctx));</span>
<span class="line" id="L790"> <span class="tok-kw">const</span> log2_old_align = <span class="tok-builtin">@as</span>(Allocator.Log2Align, <span class="tok-builtin">@intCast</span>(log2_old_align_u8));</span>
<span class="line" id="L791"> self.mutex.lock();</span>
<span class="line" id="L792"> <span class="tok-kw">defer</span> self.mutex.unlock();</span>
<span class="line" id="L793"></span>
<span class="line" id="L794"> assert(old_mem.len != <span class="tok-number">0</span>);</span>
<span class="line" id="L795"></span>
<span class="line" id="L796"> <span class="tok-kw">const</span> aligned_size = <span class="tok-builtin">@max</span>(old_mem.len, <span class="tok-builtin">@as</span>(<span class="tok-type">usize</span>, <span class="tok-number">1</span>) << log2_old_align);</span>
<span class="line" id="L797"> <span class="tok-kw">if</span> (aligned_size > largest_bucket_object_size) {</span>
<span class="line" id="L798"> self.freeLarge(old_mem, log2_old_align, ret_addr);</span>
<span class="line" id="L799"> <span class="tok-kw">return</span>;</span>
<span class="line" id="L800"> }</span>
<span class="line" id="L801"> <span class="tok-kw">const</span> size_class_hint = math.ceilPowerOfTwoAssert(<span class="tok-type">usize</span>, aligned_size);</span>
<span class="line" id="L802"></span>
<span class="line" id="L803"> <span class="tok-kw">var</span> bucket_index = math.log2(size_class_hint);</span>
<span class="line" id="L804"> <span class="tok-kw">var</span> size_class: <span class="tok-type">usize</span> = size_class_hint;</span>
<span class="line" id="L805"> <span class="tok-kw">const</span> bucket = <span class="tok-kw">while</span> (bucket_index < small_bucket_count) : (bucket_index += <span class="tok-number">1</span>) {</span>
<span class="line" id="L806"> <span class="tok-kw">if</span> (searchBucket(self.buckets[bucket_index], <span class="tok-builtin">@intFromPtr</span>(old_mem.ptr))) |bucket| {</span>
<span class="line" id="L807"> <span class="tok-comment">// move bucket to head of list to optimize search for nearby allocations</span>
</span>
<span class="line" id="L808"> self.buckets[bucket_index] = bucket;</span>
<span class="line" id="L809"> <span class="tok-kw">break</span> bucket;</span>
<span class="line" id="L810"> }</span>
<span class="line" id="L811"> size_class *= <span class="tok-number">2</span>;</span>
<span class="line" id="L812"> } <span class="tok-kw">else</span> blk: {</span>
<span class="line" id="L813"> <span class="tok-kw">if</span> (config.retain_metadata) {</span>
<span class="line" id="L814"> <span class="tok-kw">if</span> (!self.large_allocations.contains(<span class="tok-builtin">@intFromPtr</span>(old_mem.ptr))) {</span>
<span class="line" id="L815"> <span class="tok-comment">// object not in active buckets or a large allocation, so search empty buckets</span>
</span>
<span class="line" id="L816"> <span class="tok-kw">if</span> (searchBucket(self.empty_buckets, <span class="tok-builtin">@intFromPtr</span>(old_mem.ptr))) |bucket| {</span>
<span class="line" id="L817"> <span class="tok-comment">// bucket is empty so is_used below will always be false and we exit there</span>
</span>
<span class="line" id="L818"> <span class="tok-kw">break</span> :blk bucket;</span>
<span class="line" id="L819"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L820"> <span class="tok-builtin">@panic</span>(<span class="tok-str">"Invalid free"</span>);</span>
<span class="line" id="L821"> }</span>
<span class="line" id="L822"> }</span>
<span class="line" id="L823"> }</span>
<span class="line" id="L824"> self.freeLarge(old_mem, log2_old_align, ret_addr);</span>
<span class="line" id="L825"> <span class="tok-kw">return</span>;</span>
<span class="line" id="L826"> };</span>
<span class="line" id="L827"> <span class="tok-kw">const</span> byte_offset = <span class="tok-builtin">@intFromPtr</span>(old_mem.ptr) - <span class="tok-builtin">@intFromPtr</span>(bucket.page);</span>
<span class="line" id="L828"> <span class="tok-kw">const</span> slot_index = <span class="tok-builtin">@as</span>(SlotIndex, <span class="tok-builtin">@intCast</span>(byte_offset / size_class));</span>
<span class="line" id="L829"> <span class="tok-kw">const</span> used_byte_index = slot_index / <span class="tok-number">8</span>;</span>
<span class="line" id="L830"> <span class="tok-kw">const</span> used_bit_index = <span class="tok-builtin">@as</span>(<span class="tok-type">u3</span>, <span class="tok-builtin">@intCast</span>(slot_index % <span class="tok-number">8</span>));</span>
<span class="line" id="L831"> <span class="tok-kw">const</span> used_byte = bucket.usedBits(used_byte_index);</span>
<span class="line" id="L832"> <span class="tok-kw">const</span> is_used = <span class="tok-builtin">@as</span>(<span class="tok-type">u1</span>, <span class="tok-builtin">@truncate</span>(used_byte.* >> used_bit_index)) != <span class="tok-number">0</span>;</span>
<span class="line" id="L833"> <span class="tok-kw">if</span> (!is_used) {</span>
<span class="line" id="L834"> <span class="tok-kw">if</span> (config.safety) {</span>
<span class="line" id="L835"> reportDoubleFree(ret_addr, bucketStackTrace(bucket, size_class, slot_index, .alloc), bucketStackTrace(bucket, size_class, slot_index, .free));</span>
<span class="line" id="L836"> <span class="tok-comment">// Recoverable if this is a free.</span>
</span>
<span class="line" id="L837"> <span class="tok-kw">return</span>;</span>
<span class="line" id="L838"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L839"> <span class="tok-kw">unreachable</span>;</span>
<span class="line" id="L840"> }</span>
<span class="line" id="L841"> }</span>
<span class="line" id="L842"></span>
<span class="line" id="L843"> <span class="tok-comment">// Definitely an in-use small alloc now.</span>
</span>
<span class="line" id="L844"> <span class="tok-kw">if</span> (config.safety) {</span>
<span class="line" id="L845"> <span class="tok-kw">const</span> entry = self.small_allocations.getEntry(<span class="tok-builtin">@intFromPtr</span>(old_mem.ptr)) <span class="tok-kw">orelse</span></span>
<span class="line" id="L846"> <span class="tok-builtin">@panic</span>(<span class="tok-str">"Invalid free"</span>);</span>
<span class="line" id="L847"> <span class="tok-kw">if</span> (old_mem.len != entry.value_ptr.requested_size <span class="tok-kw">or</span> log2_old_align != entry.value_ptr.log2_ptr_align) {</span>
<span class="line" id="L848"> <span class="tok-kw">var</span> addresses: [stack_n]<span class="tok-type">usize</span> = [<span class="tok-number">1</span>]<span class="tok-type">usize</span>{<span class="tok-number">0</span>} ** stack_n;</span>
<span class="line" id="L849"> <span class="tok-kw">var</span> free_stack_trace = StackTrace{</span>
<span class="line" id="L850"> .instruction_addresses = &addresses,</span>
<span class="line" id="L851"> .index = <span class="tok-number">0</span>,</span>
<span class="line" id="L852"> };</span>
<span class="line" id="L853"> std.debug.captureStackTrace(ret_addr, &free_stack_trace);</span>
<span class="line" id="L854"> <span class="tok-kw">if</span> (old_mem.len != entry.value_ptr.requested_size) {</span>
<span class="line" id="L855"> log.err(<span class="tok-str">"Allocation size {d} bytes does not match free size {d}. Allocation: {} Free: {}"</span>, .{</span>
<span class="line" id="L856"> entry.value_ptr.requested_size,</span>
<span class="line" id="L857"> old_mem.len,</span>
<span class="line" id="L858"> bucketStackTrace(bucket, size_class, slot_index, .alloc),</span>
<span class="line" id="L859"> free_stack_trace,</span>
<span class="line" id="L860"> });</span>
<span class="line" id="L861"> }</span>
<span class="line" id="L862"> <span class="tok-kw">if</span> (log2_old_align != entry.value_ptr.log2_ptr_align) {</span>
<span class="line" id="L863"> log.err(<span class="tok-str">"Allocation alignment {d} does not match free alignment {d}. Allocation: {} Free: {}"</span>, .{</span>
<span class="line" id="L864"> <span class="tok-builtin">@as</span>(<span class="tok-type">usize</span>, <span class="tok-number">1</span>) << <span class="tok-builtin">@as</span>(math.Log2Int(<span class="tok-type">usize</span>), <span class="tok-builtin">@intCast</span>(entry.value_ptr.log2_ptr_align)),</span>
<span class="line" id="L865"> <span class="tok-builtin">@as</span>(<span class="tok-type">usize</span>, <span class="tok-number">1</span>) << <span class="tok-builtin">@as</span>(math.Log2Int(<span class="tok-type">usize</span>), <span class="tok-builtin">@intCast</span>(log2_old_align)),</span>
<span class="line" id="L866"> bucketStackTrace(bucket, size_class, slot_index, .alloc),</span>
<span class="line" id="L867"> free_stack_trace,</span>
<span class="line" id="L868"> });</span>
<span class="line" id="L869"> }</span>
<span class="line" id="L870"> }</span>
<span class="line" id="L871"> }</span>
<span class="line" id="L872"></span>
<span class="line" id="L873"> <span class="tok-kw">if</span> (config.enable_memory_limit) {</span>
<span class="line" id="L874"> self.total_requested_bytes -= old_mem.len;</span>
<span class="line" id="L875"> }</span>
<span class="line" id="L876"></span>
<span class="line" id="L877"> <span class="tok-comment">// Capture stack trace to be the "first free", in case a double free happens.</span>
</span>
<span class="line" id="L878"> bucket.captureStackTrace(ret_addr, size_class, slot_index, .free);</span>
<span class="line" id="L879"></span>
<span class="line" id="L880"> used_byte.* &= ~(<span class="tok-builtin">@as</span>(<span class="tok-type">u8</span>, <span class="tok-number">1</span>) << used_bit_index);</span>
<span class="line" id="L881"> bucket.used_count -= <span class="tok-number">1</span>;</span>
<span class="line" id="L882"> <span class="tok-kw">if</span> (bucket.used_count == <span class="tok-number">0</span>) {</span>
<span class="line" id="L883"> <span class="tok-kw">if</span> (bucket.next == bucket) {</span>
<span class="line" id="L884"> <span class="tok-comment">// it's the only bucket and therefore the current one</span>
</span>
<span class="line" id="L885"> self.buckets[bucket_index] = <span class="tok-null">null</span>;</span>
<span class="line" id="L886"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L887"> bucket.next.prev = bucket.prev;</span>
<span class="line" id="L888"> bucket.prev.next = bucket.next;</span>
<span class="line" id="L889"> self.buckets[bucket_index] = bucket.prev;</span>
<span class="line" id="L890"> }</span>
<span class="line" id="L891"> <span class="tok-kw">if</span> (!config.never_unmap) {</span>
<span class="line" id="L892"> self.backing_allocator.free(bucket.page[<span class="tok-number">0</span>..page_size]);</span>
<span class="line" id="L893"> }</span>
<span class="line" id="L894"> <span class="tok-kw">if</span> (!config.retain_metadata) {</span>
<span class="line" id="L895"> self.freeBucket(bucket, size_class);</span>
<span class="line" id="L896"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L897"> <span class="tok-comment">// move alloc_cursor to end so we can tell size_class later</span>
</span>
<span class="line" id="L898"> <span class="tok-kw">const</span> slot_count = <span class="tok-builtin">@divExact</span>(page_size, size_class);</span>
<span class="line" id="L899"> bucket.alloc_cursor = <span class="tok-builtin">@as</span>(SlotIndex, <span class="tok-builtin">@truncate</span>(slot_count));</span>
<span class="line" id="L900"> <span class="tok-kw">if</span> (self.empty_buckets) |prev_bucket| {</span>
<span class="line" id="L901"> <span class="tok-comment">// empty_buckets is ordered newest to oldest through prev so that if</span>
</span>
<span class="line" id="L902"> <span class="tok-comment">// config.never_unmap is false and backing_allocator reuses freed memory</span>
</span>
<span class="line" id="L903"> <span class="tok-comment">// then searchBuckets will always return the newer, relevant bucket</span>
</span>
<span class="line" id="L904"> bucket.prev = prev_bucket;</span>
<span class="line" id="L905"> bucket.next = prev_bucket.next;</span>
<span class="line" id="L906"> prev_bucket.next = bucket;</span>
<span class="line" id="L907"> bucket.next.prev = bucket;</span>
<span class="line" id="L908"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L909"> bucket.prev = bucket;</span>
<span class="line" id="L910"> bucket.next = bucket;</span>
<span class="line" id="L911"> }</span>
<span class="line" id="L912"> self.empty_buckets = bucket;</span>
<span class="line" id="L913"> }</span>
<span class="line" id="L914"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L915"> <span class="tok-builtin">@memset</span>(old_mem, <span class="tok-null">undefined</span>);</span>
<span class="line" id="L916"> }</span>
<span class="line" id="L917"> <span class="tok-kw">if</span> (config.safety) {</span>
<span class="line" id="L918"> assert(self.small_allocations.remove(<span class="tok-builtin">@intFromPtr</span>(old_mem.ptr)));</span>
<span class="line" id="L919"> }</span>
<span class="line" id="L920"> <span class="tok-kw">if</span> (config.verbose_log) {</span>
<span class="line" id="L921"> log.info(<span class="tok-str">"small free {d} bytes at {*}"</span>, .{ old_mem.len, old_mem.ptr });</span>
<span class="line" id="L922"> }</span>
<span class="line" id="L923"> }</span>
<span class="line" id="L924"></span>
<span class="line" id="L925"> <span class="tok-comment">// Returns true if an allocation of `size` bytes is within the specified</span>
</span>
<span class="line" id="L926"> <span class="tok-comment">// limits if enable_memory_limit is true</span>
</span>
<span class="line" id="L927"> <span class="tok-kw">fn</span> <span class="tok-fn">isAllocationAllowed</span>(self: *Self, size: <span class="tok-type">usize</span>) <span class="tok-type">bool</span> {</span>
<span class="line" id="L928"> <span class="tok-kw">if</span> (config.enable_memory_limit) {</span>
<span class="line" id="L929"> <span class="tok-kw">const</span> new_req_bytes = self.total_requested_bytes + size;</span>
<span class="line" id="L930"> <span class="tok-kw">if</span> (new_req_bytes > self.requested_memory_limit)</span>
<span class="line" id="L931"> <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L932"> self.total_requested_bytes = new_req_bytes;</span>
<span class="line" id="L933"> }</span>
<span class="line" id="L934"></span>
<span class="line" id="L935"> <span class="tok-kw">return</span> <span class="tok-null">true</span>;</span>
<span class="line" id="L936"> }</span>
<span class="line" id="L937"></span>
<span class="line" id="L938"> <span class="tok-kw">fn</span> <span class="tok-fn">alloc</span>(ctx: *<span class="tok-type">anyopaque</span>, len: <span class="tok-type">usize</span>, log2_ptr_align: <span class="tok-type">u8</span>, ret_addr: <span class="tok-type">usize</span>) ?[*]<span class="tok-type">u8</span> {</span>
<span class="line" id="L939"> <span class="tok-kw">const</span> self: *Self = <span class="tok-builtin">@ptrCast</span>(<span class="tok-builtin">@alignCast</span>(ctx));</span>
<span class="line" id="L940"> self.mutex.lock();</span>
<span class="line" id="L941"> <span class="tok-kw">defer</span> self.mutex.unlock();</span>
<span class="line" id="L942"> <span class="tok-kw">if</span> (!self.isAllocationAllowed(len)) <span class="tok-kw">return</span> <span class="tok-null">null</span>;</span>
<span class="line" id="L943"> <span class="tok-kw">return</span> allocInner(self, len, <span class="tok-builtin">@as</span>(Allocator.Log2Align, <span class="tok-builtin">@intCast</span>(log2_ptr_align)), ret_addr) <span class="tok-kw">catch</span> <span class="tok-kw">return</span> <span class="tok-null">null</span>;</span>
<span class="line" id="L944"> }</span>
<span class="line" id="L945"></span>
<span class="line" id="L946"> <span class="tok-kw">fn</span> <span class="tok-fn">allocInner</span>(</span>
<span class="line" id="L947"> self: *Self,</span>
<span class="line" id="L948"> len: <span class="tok-type">usize</span>,</span>
<span class="line" id="L949"> log2_ptr_align: Allocator.Log2Align,</span>
<span class="line" id="L950"> ret_addr: <span class="tok-type">usize</span>,</span>
<span class="line" id="L951"> ) Allocator.Error![*]<span class="tok-type">u8</span> {</span>
<span class="line" id="L952"> <span class="tok-kw">const</span> new_aligned_size = <span class="tok-builtin">@max</span>(len, <span class="tok-builtin">@as</span>(<span class="tok-type">usize</span>, <span class="tok-number">1</span>) << <span class="tok-builtin">@as</span>(Allocator.Log2Align, <span class="tok-builtin">@intCast</span>(log2_ptr_align)));</span>
<span class="line" id="L953"> <span class="tok-kw">if</span> (new_aligned_size > largest_bucket_object_size) {</span>
<span class="line" id="L954"> <span class="tok-kw">try</span> self.large_allocations.ensureUnusedCapacity(self.backing_allocator, <span class="tok-number">1</span>);</span>
<span class="line" id="L955"> <span class="tok-kw">const</span> ptr = self.backing_allocator.rawAlloc(len, log2_ptr_align, ret_addr) <span class="tok-kw">orelse</span></span>
<span class="line" id="L956"> <span class="tok-kw">return</span> <span class="tok-kw">error</span>.OutOfMemory;</span>
<span class="line" id="L957"> <span class="tok-kw">const</span> slice = ptr[<span class="tok-number">0</span>..len];</span>
<span class="line" id="L958"></span>
<span class="line" id="L959"> <span class="tok-kw">const</span> gop = self.large_allocations.getOrPutAssumeCapacity(<span class="tok-builtin">@intFromPtr</span>(slice.ptr));</span>
<span class="line" id="L960"> <span class="tok-kw">if</span> (config.retain_metadata <span class="tok-kw">and</span> !config.never_unmap) {</span>
<span class="line" id="L961"> <span class="tok-comment">// Backing allocator may be reusing memory that we're retaining metadata for</span>
</span>
<span class="line" id="L962"> assert(!gop.found_existing <span class="tok-kw">or</span> gop.value_ptr.freed);</span>
<span class="line" id="L963"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L964"> assert(!gop.found_existing); <span class="tok-comment">// This would mean the kernel double-mapped pages.</span>
</span>
<span class="line" id="L965"> }</span>
<span class="line" id="L966"> gop.value_ptr.bytes = slice;</span>
<span class="line" id="L967"> <span class="tok-kw">if</span> (config.enable_memory_limit)</span>
<span class="line" id="L968"> gop.value_ptr.requested_size = len;</span>
<span class="line" id="L969"> gop.value_ptr.captureStackTrace(ret_addr, .alloc);</span>
<span class="line" id="L970"> <span class="tok-kw">if</span> (config.retain_metadata) {</span>
<span class="line" id="L971"> gop.value_ptr.freed = <span class="tok-null">false</span>;</span>
<span class="line" id="L972"> <span class="tok-kw">if</span> (config.never_unmap) {</span>
<span class="line" id="L973"> gop.value_ptr.log2_ptr_align = log2_ptr_align;</span>
<span class="line" id="L974"> }</span>
<span class="line" id="L975"> }</span>
<span class="line" id="L976"></span>
<span class="line" id="L977"> <span class="tok-kw">if</span> (config.verbose_log) {</span>
<span class="line" id="L978"> log.info(<span class="tok-str">"large alloc {d} bytes at {*}"</span>, .{ slice.len, slice.ptr });</span>
<span class="line" id="L979"> }</span>
<span class="line" id="L980"> <span class="tok-kw">return</span> slice.ptr;</span>
<span class="line" id="L981"> }</span>
<span class="line" id="L982"></span>
<span class="line" id="L983"> <span class="tok-kw">if</span> (config.safety) {</span>
<span class="line" id="L984"> <span class="tok-kw">try</span> self.small_allocations.ensureUnusedCapacity(self.backing_allocator, <span class="tok-number">1</span>);</span>
<span class="line" id="L985"> }</span>
<span class="line" id="L986"> <span class="tok-kw">const</span> new_size_class = math.ceilPowerOfTwoAssert(<span class="tok-type">usize</span>, new_aligned_size);</span>
<span class="line" id="L987"> <span class="tok-kw">const</span> ptr = <span class="tok-kw">try</span> self.allocSlot(new_size_class, ret_addr);</span>
<span class="line" id="L988"> <span class="tok-kw">if</span> (config.safety) {</span>
<span class="line" id="L989"> <span class="tok-kw">const</span> gop = self.small_allocations.getOrPutAssumeCapacity(<span class="tok-builtin">@intFromPtr</span>(ptr));</span>
<span class="line" id="L990"> gop.value_ptr.requested_size = len;</span>
<span class="line" id="L991"> gop.value_ptr.log2_ptr_align = log2_ptr_align;</span>
<span class="line" id="L992"> }</span>
<span class="line" id="L993"> <span class="tok-kw">if</span> (config.verbose_log) {</span>
<span class="line" id="L994"> log.info(<span class="tok-str">"small alloc {d} bytes at {*}"</span>, .{ len, ptr });</span>
<span class="line" id="L995"> }</span>
<span class="line" id="L996"> <span class="tok-kw">return</span> ptr;</span>
<span class="line" id="L997"> }</span>
<span class="line" id="L998"></span>
<span class="line" id="L999"> <span class="tok-kw">fn</span> <span class="tok-fn">createBucket</span>(self: *Self, size_class: <span class="tok-type">usize</span>, bucket_index: <span class="tok-type">usize</span>) Error!*BucketHeader {</span>
<span class="line" id="L1000"> <span class="tok-kw">const</span> page = <span class="tok-kw">try</span> self.backing_allocator.alignedAlloc(<span class="tok-type">u8</span>, page_size, page_size);</span>
<span class="line" id="L1001"> <span class="tok-kw">errdefer</span> self.backing_allocator.free(page);</span>
<span class="line" id="L1002"></span>
<span class="line" id="L1003"> <span class="tok-kw">const</span> bucket_size = bucketSize(size_class);</span>
<span class="line" id="L1004"> <span class="tok-kw">const</span> bucket_bytes = <span class="tok-kw">try</span> self.backing_allocator.alignedAlloc(<span class="tok-type">u8</span>, <span class="tok-builtin">@alignOf</span>(BucketHeader), bucket_size);</span>
<span class="line" id="L1005"> <span class="tok-kw">const</span> ptr = <span class="tok-builtin">@as</span>(*BucketHeader, <span class="tok-builtin">@ptrCast</span>(bucket_bytes.ptr));</span>
<span class="line" id="L1006"> ptr.* = BucketHeader{</span>
<span class="line" id="L1007"> .prev = ptr,</span>
<span class="line" id="L1008"> .next = ptr,</span>
<span class="line" id="L1009"> .page = page.ptr,</span>
<span class="line" id="L1010"> .alloc_cursor = <span class="tok-number">0</span>,</span>
<span class="line" id="L1011"> .used_count = <span class="tok-number">0</span>,</span>
<span class="line" id="L1012"> };</span>
<span class="line" id="L1013"> self.buckets[bucket_index] = ptr;</span>
<span class="line" id="L1014"> <span class="tok-comment">// Set the used bits to all zeroes</span>
</span>
<span class="line" id="L1015"> <span class="tok-builtin">@memset</span>(<span class="tok-builtin">@as</span>([*]<span class="tok-type">u8</span>, <span class="tok-builtin">@as</span>(*[<span class="tok-number">1</span>]<span class="tok-type">u8</span>, ptr.usedBits(<span class="tok-number">0</span>)))[<span class="tok-number">0</span>..usedBitsCount(size_class)], <span class="tok-number">0</span>);</span>
<span class="line" id="L1016"> <span class="tok-kw">return</span> ptr;</span>
<span class="line" id="L1017"> }</span>
<span class="line" id="L1018"> };</span>
<span class="line" id="L1019">}</span>
<span class="line" id="L1020"></span>
<span class="line" id="L1021"><span class="tok-kw">const</span> TraceKind = <span class="tok-kw">enum</span> {</span>
<span class="line" id="L1022"> alloc,</span>
<span class="line" id="L1023"> free,</span>
<span class="line" id="L1024">};</span>
<span class="line" id="L1025"></span>
<span class="line" id="L1026"><span class="tok-kw">const</span> test_config = Config{};</span>
<span class="line" id="L1027"></span>
<span class="line" id="L1028"><span class="tok-kw">test</span> <span class="tok-str">"small allocations - free in same order"</span> {</span>
<span class="line" id="L1029"> <span class="tok-kw">var</span> gpa = GeneralPurposeAllocator(test_config){};</span>
<span class="line" id="L1030"> <span class="tok-kw">defer</span> std.testing.expect(gpa.deinit() == .ok) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"leak"</span>);</span>
<span class="line" id="L1031"> <span class="tok-kw">const</span> allocator = gpa.allocator();</span>
<span class="line" id="L1032"></span>
<span class="line" id="L1033"> <span class="tok-kw">var</span> list = std.ArrayList(*<span class="tok-type">u64</span>).init(std.testing.allocator);</span>
<span class="line" id="L1034"> <span class="tok-kw">defer</span> list.deinit();</span>
<span class="line" id="L1035"></span>
<span class="line" id="L1036"> <span class="tok-kw">var</span> i: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L1037"> <span class="tok-kw">while</span> (i < <span class="tok-number">513</span>) : (i += <span class="tok-number">1</span>) {</span>
<span class="line" id="L1038"> <span class="tok-kw">const</span> ptr = <span class="tok-kw">try</span> allocator.create(<span class="tok-type">u64</span>);</span>
<span class="line" id="L1039"> <span class="tok-kw">try</span> list.append(ptr);</span>
<span class="line" id="L1040"> }</span>
<span class="line" id="L1041"></span>
<span class="line" id="L1042"> <span class="tok-kw">for</span> (list.items) |ptr| {</span>
<span class="line" id="L1043"> allocator.destroy(ptr);</span>
<span class="line" id="L1044"> }</span>
<span class="line" id="L1045">}</span>
<span class="line" id="L1046"></span>
<span class="line" id="L1047"><span class="tok-kw">test</span> <span class="tok-str">"small allocations - free in reverse order"</span> {</span>
<span class="line" id="L1048"> <span class="tok-kw">var</span> gpa = GeneralPurposeAllocator(test_config){};</span>
<span class="line" id="L1049"> <span class="tok-kw">defer</span> std.testing.expect(gpa.deinit() == .ok) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"leak"</span>);</span>
<span class="line" id="L1050"> <span class="tok-kw">const</span> allocator = gpa.allocator();</span>
<span class="line" id="L1051"></span>
<span class="line" id="L1052"> <span class="tok-kw">var</span> list = std.ArrayList(*<span class="tok-type">u64</span>).init(std.testing.allocator);</span>
<span class="line" id="L1053"> <span class="tok-kw">defer</span> list.deinit();</span>
<span class="line" id="L1054"></span>
<span class="line" id="L1055"> <span class="tok-kw">var</span> i: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L1056"> <span class="tok-kw">while</span> (i < <span class="tok-number">513</span>) : (i += <span class="tok-number">1</span>) {</span>
<span class="line" id="L1057"> <span class="tok-kw">const</span> ptr = <span class="tok-kw">try</span> allocator.create(<span class="tok-type">u64</span>);</span>
<span class="line" id="L1058"> <span class="tok-kw">try</span> list.append(ptr);</span>
<span class="line" id="L1059"> }</span>
<span class="line" id="L1060"></span>
<span class="line" id="L1061"> <span class="tok-kw">while</span> (list.popOrNull()) |ptr| {</span>
<span class="line" id="L1062"> allocator.destroy(ptr);</span>
<span class="line" id="L1063"> }</span>
<span class="line" id="L1064">}</span>
<span class="line" id="L1065"></span>
<span class="line" id="L1066"><span class="tok-kw">test</span> <span class="tok-str">"large allocations"</span> {</span>
<span class="line" id="L1067"> <span class="tok-kw">var</span> gpa = GeneralPurposeAllocator(test_config){};</span>
<span class="line" id="L1068"> <span class="tok-kw">defer</span> std.testing.expect(gpa.deinit() == .ok) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"leak"</span>);</span>
<span class="line" id="L1069"> <span class="tok-kw">const</span> allocator = gpa.allocator();</span>
<span class="line" id="L1070"></span>
<span class="line" id="L1071"> <span class="tok-kw">const</span> ptr1 = <span class="tok-kw">try</span> allocator.alloc(<span class="tok-type">u64</span>, <span class="tok-number">42768</span>);</span>
<span class="line" id="L1072"> <span class="tok-kw">const</span> ptr2 = <span class="tok-kw">try</span> allocator.alloc(<span class="tok-type">u64</span>, <span class="tok-number">52768</span>);</span>
<span class="line" id="L1073"> allocator.free(ptr1);</span>
<span class="line" id="L1074"> <span class="tok-kw">const</span> ptr3 = <span class="tok-kw">try</span> allocator.alloc(<span class="tok-type">u64</span>, <span class="tok-number">62768</span>);</span>
<span class="line" id="L1075"> allocator.free(ptr3);</span>
<span class="line" id="L1076"> allocator.free(ptr2);</span>
<span class="line" id="L1077">}</span>
<span class="line" id="L1078"></span>
<span class="line" id="L1079"><span class="tok-kw">test</span> <span class="tok-str">"very large allocation"</span> {</span>
<span class="line" id="L1080"> <span class="tok-kw">var</span> gpa = GeneralPurposeAllocator(test_config){};</span>
<span class="line" id="L1081"> <span class="tok-kw">defer</span> std.testing.expect(gpa.deinit() == .ok) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"leak"</span>);</span>
<span class="line" id="L1082"> <span class="tok-kw">const</span> allocator = gpa.allocator();</span>
<span class="line" id="L1083"></span>
<span class="line" id="L1084"> <span class="tok-kw">try</span> std.testing.expectError(<span class="tok-kw">error</span>.OutOfMemory, allocator.alloc(<span class="tok-type">u8</span>, math.maxInt(<span class="tok-type">usize</span>)));</span>
<span class="line" id="L1085">}</span>
<span class="line" id="L1086"></span>
<span class="line" id="L1087"><span class="tok-kw">test</span> <span class="tok-str">"realloc"</span> {</span>
<span class="line" id="L1088"> <span class="tok-kw">var</span> gpa = GeneralPurposeAllocator(test_config){};</span>
<span class="line" id="L1089"> <span class="tok-kw">defer</span> std.testing.expect(gpa.deinit() == .ok) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"leak"</span>);</span>
<span class="line" id="L1090"> <span class="tok-kw">const</span> allocator = gpa.allocator();</span>
<span class="line" id="L1091"></span>
<span class="line" id="L1092"> <span class="tok-kw">var</span> slice = <span class="tok-kw">try</span> allocator.alignedAlloc(<span class="tok-type">u8</span>, <span class="tok-builtin">@alignOf</span>(<span class="tok-type">u32</span>), <span class="tok-number">1</span>);</span>
<span class="line" id="L1093"> <span class="tok-kw">defer</span> allocator.free(slice);</span>
<span class="line" id="L1094"> slice[<span class="tok-number">0</span>] = <span class="tok-number">0x12</span>;</span>
<span class="line" id="L1095"></span>
<span class="line" id="L1096"> <span class="tok-comment">// This reallocation should keep its pointer address.</span>
</span>
<span class="line" id="L1097"> <span class="tok-kw">const</span> old_slice = slice;</span>
<span class="line" id="L1098"> slice = <span class="tok-kw">try</span> allocator.realloc(slice, <span class="tok-number">2</span>);</span>
<span class="line" id="L1099"> <span class="tok-kw">try</span> std.testing.expect(old_slice.ptr == slice.ptr);</span>
<span class="line" id="L1100"> <span class="tok-kw">try</span> std.testing.expect(slice[<span class="tok-number">0</span>] == <span class="tok-number">0x12</span>);</span>
<span class="line" id="L1101"> slice[<span class="tok-number">1</span>] = <span class="tok-number">0x34</span>;</span>
<span class="line" id="L1102"></span>
<span class="line" id="L1103"> <span class="tok-comment">// This requires upgrading to a larger size class</span>
</span>
<span class="line" id="L1104"> slice = <span class="tok-kw">try</span> allocator.realloc(slice, <span class="tok-number">17</span>);</span>
<span class="line" id="L1105"> <span class="tok-kw">try</span> std.testing.expect(slice[<span class="tok-number">0</span>] == <span class="tok-number">0x12</span>);</span>
<span class="line" id="L1106"> <span class="tok-kw">try</span> std.testing.expect(slice[<span class="tok-number">1</span>] == <span class="tok-number">0x34</span>);</span>
<span class="line" id="L1107">}</span>
<span class="line" id="L1108"></span>
<span class="line" id="L1109"><span class="tok-kw">test</span> <span class="tok-str">"shrink"</span> {</span>
<span class="line" id="L1110"> <span class="tok-kw">var</span> gpa = GeneralPurposeAllocator(test_config){};</span>
<span class="line" id="L1111"> <span class="tok-kw">defer</span> std.testing.expect(gpa.deinit() == .ok) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"leak"</span>);</span>
<span class="line" id="L1112"> <span class="tok-kw">const</span> allocator = gpa.allocator();</span>
<span class="line" id="L1113"></span>
<span class="line" id="L1114"> <span class="tok-kw">var</span> slice = <span class="tok-kw">try</span> allocator.alloc(<span class="tok-type">u8</span>, <span class="tok-number">20</span>);</span>
<span class="line" id="L1115"> <span class="tok-kw">defer</span> allocator.free(slice);</span>
<span class="line" id="L1116"></span>
<span class="line" id="L1117"> <span class="tok-builtin">@memset</span>(slice, <span class="tok-number">0x11</span>);</span>
<span class="line" id="L1118"></span>
<span class="line" id="L1119"> <span class="tok-kw">try</span> std.testing.expect(allocator.resize(slice, <span class="tok-number">17</span>));</span>
<span class="line" id="L1120"> slice = slice[<span class="tok-number">0</span>..<span class="tok-number">17</span>];</span>
<span class="line" id="L1121"></span>
<span class="line" id="L1122"> <span class="tok-kw">for</span> (slice) |b| {</span>
<span class="line" id="L1123"> <span class="tok-kw">try</span> std.testing.expect(b == <span class="tok-number">0x11</span>);</span>
<span class="line" id="L1124"> }</span>
<span class="line" id="L1125"></span>
<span class="line" id="L1126"> <span class="tok-kw">try</span> std.testing.expect(allocator.resize(slice, <span class="tok-number">16</span>));</span>
<span class="line" id="L1127"> slice = slice[<span class="tok-number">0</span>..<span class="tok-number">16</span>];</span>
<span class="line" id="L1128"></span>
<span class="line" id="L1129"> <span class="tok-kw">for</span> (slice) |b| {</span>
<span class="line" id="L1130"> <span class="tok-kw">try</span> std.testing.expect(b == <span class="tok-number">0x11</span>);</span>
<span class="line" id="L1131"> }</span>
<span class="line" id="L1132">}</span>
<span class="line" id="L1133"></span>
<span class="line" id="L1134"><span class="tok-kw">test</span> <span class="tok-str">"large object - grow"</span> {</span>
<span class="line" id="L1135"> <span class="tok-kw">var</span> gpa = GeneralPurposeAllocator(test_config){};</span>
<span class="line" id="L1136"> <span class="tok-kw">defer</span> std.testing.expect(gpa.deinit() == .ok) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"leak"</span>);</span>
<span class="line" id="L1137"> <span class="tok-kw">const</span> allocator = gpa.allocator();</span>
<span class="line" id="L1138"></span>
<span class="line" id="L1139"> <span class="tok-kw">var</span> slice1 = <span class="tok-kw">try</span> allocator.alloc(<span class="tok-type">u8</span>, page_size * <span class="tok-number">2</span> - <span class="tok-number">20</span>);</span>
<span class="line" id="L1140"> <span class="tok-kw">defer</span> allocator.free(slice1);</span>
<span class="line" id="L1141"></span>
<span class="line" id="L1142"> <span class="tok-kw">const</span> old = slice1;</span>
<span class="line" id="L1143"> slice1 = <span class="tok-kw">try</span> allocator.realloc(slice1, page_size * <span class="tok-number">2</span> - <span class="tok-number">10</span>);</span>
<span class="line" id="L1144"> <span class="tok-kw">try</span> std.testing.expect(slice1.ptr == old.ptr);</span>
<span class="line" id="L1145"></span>
<span class="line" id="L1146"> slice1 = <span class="tok-kw">try</span> allocator.realloc(slice1, page_size * <span class="tok-number">2</span>);</span>
<span class="line" id="L1147"> <span class="tok-kw">try</span> std.testing.expect(slice1.ptr == old.ptr);</span>
<span class="line" id="L1148"></span>
<span class="line" id="L1149"> slice1 = <span class="tok-kw">try</span> allocator.realloc(slice1, page_size * <span class="tok-number">2</span> + <span class="tok-number">1</span>);</span>
<span class="line" id="L1150">}</span>
<span class="line" id="L1151"></span>
<span class="line" id="L1152"><span class="tok-kw">test</span> <span class="tok-str">"realloc small object to large object"</span> {</span>
<span class="line" id="L1153"> <span class="tok-kw">var</span> gpa = GeneralPurposeAllocator(test_config){};</span>
<span class="line" id="L1154"> <span class="tok-kw">defer</span> std.testing.expect(gpa.deinit() == .ok) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"leak"</span>);</span>
<span class="line" id="L1155"> <span class="tok-kw">const</span> allocator = gpa.allocator();</span>
<span class="line" id="L1156"></span>
<span class="line" id="L1157"> <span class="tok-kw">var</span> slice = <span class="tok-kw">try</span> allocator.alloc(<span class="tok-type">u8</span>, <span class="tok-number">70</span>);</span>
<span class="line" id="L1158"> <span class="tok-kw">defer</span> allocator.free(slice);</span>
<span class="line" id="L1159"> slice[<span class="tok-number">0</span>] = <span class="tok-number">0x12</span>;</span>
<span class="line" id="L1160"> slice[<span class="tok-number">60</span>] = <span class="tok-number">0x34</span>;</span>
<span class="line" id="L1161"></span>
<span class="line" id="L1162"> <span class="tok-comment">// This requires upgrading to a large object</span>
</span>
<span class="line" id="L1163"> <span class="tok-kw">const</span> large_object_size = page_size * <span class="tok-number">2</span> + <span class="tok-number">50</span>;</span>
<span class="line" id="L1164"> slice = <span class="tok-kw">try</span> allocator.realloc(slice, large_object_size);</span>
<span class="line" id="L1165"> <span class="tok-kw">try</span> std.testing.expect(slice[<span class="tok-number">0</span>] == <span class="tok-number">0x12</span>);</span>
<span class="line" id="L1166"> <span class="tok-kw">try</span> std.testing.expect(slice[<span class="tok-number">60</span>] == <span class="tok-number">0x34</span>);</span>
<span class="line" id="L1167">}</span>
<span class="line" id="L1168"></span>
<span class="line" id="L1169"><span class="tok-kw">test</span> <span class="tok-str">"shrink large object to large object"</span> {</span>
<span class="line" id="L1170"> <span class="tok-kw">var</span> gpa = GeneralPurposeAllocator(test_config){};</span>
<span class="line" id="L1171"> <span class="tok-kw">defer</span> std.testing.expect(gpa.deinit() == .ok) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"leak"</span>);</span>
<span class="line" id="L1172"> <span class="tok-kw">const</span> allocator = gpa.allocator();</span>
<span class="line" id="L1173"></span>
<span class="line" id="L1174"> <span class="tok-kw">var</span> slice = <span class="tok-kw">try</span> allocator.alloc(<span class="tok-type">u8</span>, page_size * <span class="tok-number">2</span> + <span class="tok-number">50</span>);</span>
<span class="line" id="L1175"> <span class="tok-kw">defer</span> allocator.free(slice);</span>
<span class="line" id="L1176"> slice[<span class="tok-number">0</span>] = <span class="tok-number">0x12</span>;</span>
<span class="line" id="L1177"> slice[<span class="tok-number">60</span>] = <span class="tok-number">0x34</span>;</span>
<span class="line" id="L1178"></span>
<span class="line" id="L1179"> <span class="tok-kw">if</span> (!allocator.resize(slice, page_size * <span class="tok-number">2</span> + <span class="tok-number">1</span>)) <span class="tok-kw">return</span>;</span>
<span class="line" id="L1180"> slice = slice.ptr[<span class="tok-number">0</span> .. page_size * <span class="tok-number">2</span> + <span class="tok-number">1</span>];</span>
<span class="line" id="L1181"> <span class="tok-kw">try</span> std.testing.expect(slice[<span class="tok-number">0</span>] == <span class="tok-number">0x12</span>);</span>
<span class="line" id="L1182"> <span class="tok-kw">try</span> std.testing.expect(slice[<span class="tok-number">60</span>] == <span class="tok-number">0x34</span>);</span>
<span class="line" id="L1183"></span>
<span class="line" id="L1184"> <span class="tok-kw">try</span> std.testing.expect(allocator.resize(slice, page_size * <span class="tok-number">2</span> + <span class="tok-number">1</span>));</span>
<span class="line" id="L1185"> slice = slice[<span class="tok-number">0</span> .. page_size * <span class="tok-number">2</span> + <span class="tok-number">1</span>];</span>
<span class="line" id="L1186"> <span class="tok-kw">try</span> std.testing.expect(slice[<span class="tok-number">0</span>] == <span class="tok-number">0x12</span>);</span>
<span class="line" id="L1187"> <span class="tok-kw">try</span> std.testing.expect(slice[<span class="tok-number">60</span>] == <span class="tok-number">0x34</span>);</span>
<span class="line" id="L1188"></span>
<span class="line" id="L1189"> slice = <span class="tok-kw">try</span> allocator.realloc(slice, page_size * <span class="tok-number">2</span>);</span>
<span class="line" id="L1190"> <span class="tok-kw">try</span> std.testing.expect(slice[<span class="tok-number">0</span>] == <span class="tok-number">0x12</span>);</span>
<span class="line" id="L1191"> <span class="tok-kw">try</span> std.testing.expect(slice[<span class="tok-number">60</span>] == <span class="tok-number">0x34</span>);</span>
<span class="line" id="L1192">}</span>
<span class="line" id="L1193"></span>
<span class="line" id="L1194"><span class="tok-kw">test</span> <span class="tok-str">"shrink large object to large object with larger alignment"</span> {</span>
<span class="line" id="L1195"> <span class="tok-kw">var</span> gpa = GeneralPurposeAllocator(test_config){};</span>
<span class="line" id="L1196"> <span class="tok-kw">defer</span> std.testing.expect(gpa.deinit() == .ok) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"leak"</span>);</span>
<span class="line" id="L1197"> <span class="tok-kw">const</span> allocator = gpa.allocator();</span>
<span class="line" id="L1198"></span>
<span class="line" id="L1199"> <span class="tok-kw">var</span> debug_buffer: [<span class="tok-number">1000</span>]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L1200"> <span class="tok-kw">var</span> fba = std.heap.FixedBufferAllocator.init(&debug_buffer);</span>
<span class="line" id="L1201"> <span class="tok-kw">const</span> debug_allocator = fba.allocator();</span>
<span class="line" id="L1202"></span>
<span class="line" id="L1203"> <span class="tok-kw">const</span> alloc_size = page_size * <span class="tok-number">2</span> + <span class="tok-number">50</span>;</span>
<span class="line" id="L1204"> <span class="tok-kw">var</span> slice = <span class="tok-kw">try</span> allocator.alignedAlloc(<span class="tok-type">u8</span>, <span class="tok-number">16</span>, alloc_size);</span>
<span class="line" id="L1205"> <span class="tok-kw">defer</span> allocator.free(slice);</span>
<span class="line" id="L1206"></span>
<span class="line" id="L1207"> <span class="tok-kw">const</span> big_alignment: <span class="tok-type">usize</span> = <span class="tok-kw">switch</span> (builtin.os.tag) {</span>
<span class="line" id="L1208"> .windows => page_size * <span class="tok-number">32</span>, <span class="tok-comment">// Windows aligns to 64K.</span>
</span>
<span class="line" id="L1209"> <span class="tok-kw">else</span> => page_size * <span class="tok-number">2</span>,</span>
<span class="line" id="L1210"> };</span>
<span class="line" id="L1211"> <span class="tok-comment">// This loop allocates until we find a page that is not aligned to the big</span>
</span>
<span class="line" id="L1212"> <span class="tok-comment">// alignment. Then we shrink the allocation after the loop, but increase the</span>
</span>
<span class="line" id="L1213"> <span class="tok-comment">// alignment to the higher one, that we know will force it to realloc.</span>
</span>
<span class="line" id="L1214"> <span class="tok-kw">var</span> stuff_to_free = std.ArrayList([]<span class="tok-kw">align</span>(<span class="tok-number">16</span>) <span class="tok-type">u8</span>).init(debug_allocator);</span>
<span class="line" id="L1215"> <span class="tok-kw">while</span> (mem.isAligned(<span class="tok-builtin">@intFromPtr</span>(slice.ptr), big_alignment)) {</span>
<span class="line" id="L1216"> <span class="tok-kw">try</span> stuff_to_free.append(slice);</span>
<span class="line" id="L1217"> slice = <span class="tok-kw">try</span> allocator.alignedAlloc(<span class="tok-type">u8</span>, <span class="tok-number">16</span>, alloc_size);</span>
<span class="line" id="L1218"> }</span>
<span class="line" id="L1219"> <span class="tok-kw">while</span> (stuff_to_free.popOrNull()) |item| {</span>
<span class="line" id="L1220"> allocator.free(item);</span>
<span class="line" id="L1221"> }</span>
<span class="line" id="L1222"> slice[<span class="tok-number">0</span>] = <span class="tok-number">0x12</span>;</span>
<span class="line" id="L1223"> slice[<span class="tok-number">60</span>] = <span class="tok-number">0x34</span>;</span>
<span class="line" id="L1224"></span>
<span class="line" id="L1225"> slice = <span class="tok-kw">try</span> allocator.reallocAdvanced(slice, big_alignment, alloc_size / <span class="tok-number">2</span>);</span>
<span class="line" id="L1226"> <span class="tok-kw">try</span> std.testing.expect(slice[<span class="tok-number">0</span>] == <span class="tok-number">0x12</span>);</span>
<span class="line" id="L1227"> <span class="tok-kw">try</span> std.testing.expect(slice[<span class="tok-number">60</span>] == <span class="tok-number">0x34</span>);</span>
<span class="line" id="L1228">}</span>
<span class="line" id="L1229"></span>
<span class="line" id="L1230"><span class="tok-kw">test</span> <span class="tok-str">"realloc large object to small object"</span> {</span>
<span class="line" id="L1231"> <span class="tok-kw">var</span> gpa = GeneralPurposeAllocator(test_config){};</span>
<span class="line" id="L1232"> <span class="tok-kw">defer</span> std.testing.expect(gpa.deinit() == .ok) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"leak"</span>);</span>
<span class="line" id="L1233"> <span class="tok-kw">const</span> allocator = gpa.allocator();</span>
<span class="line" id="L1234"></span>
<span class="line" id="L1235"> <span class="tok-kw">var</span> slice = <span class="tok-kw">try</span> allocator.alloc(<span class="tok-type">u8</span>, page_size * <span class="tok-number">2</span> + <span class="tok-number">50</span>);</span>
<span class="line" id="L1236"> <span class="tok-kw">defer</span> allocator.free(slice);</span>
<span class="line" id="L1237"> slice[<span class="tok-number">0</span>] = <span class="tok-number">0x12</span>;</span>
<span class="line" id="L1238"> slice[<span class="tok-number">16</span>] = <span class="tok-number">0x34</span>;</span>
<span class="line" id="L1239"></span>
<span class="line" id="L1240"> slice = <span class="tok-kw">try</span> allocator.realloc(slice, <span class="tok-number">19</span>);</span>
<span class="line" id="L1241"> <span class="tok-kw">try</span> std.testing.expect(slice[<span class="tok-number">0</span>] == <span class="tok-number">0x12</span>);</span>
<span class="line" id="L1242"> <span class="tok-kw">try</span> std.testing.expect(slice[<span class="tok-number">16</span>] == <span class="tok-number">0x34</span>);</span>
<span class="line" id="L1243">}</span>
<span class="line" id="L1244"></span>
<span class="line" id="L1245"><span class="tok-kw">test</span> <span class="tok-str">"overridable mutexes"</span> {</span>
<span class="line" id="L1246"> <span class="tok-kw">var</span> gpa = GeneralPurposeAllocator(.{ .MutexType = std.Thread.Mutex }){</span>
<span class="line" id="L1247"> .backing_allocator = std.testing.allocator,</span>
<span class="line" id="L1248"> .mutex = std.Thread.Mutex{},</span>
<span class="line" id="L1249"> };</span>
<span class="line" id="L1250"> <span class="tok-kw">defer</span> std.testing.expect(gpa.deinit() == .ok) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"leak"</span>);</span>
<span class="line" id="L1251"> <span class="tok-kw">const</span> allocator = gpa.allocator();</span>
<span class="line" id="L1252"></span>
<span class="line" id="L1253"> <span class="tok-kw">const</span> ptr = <span class="tok-kw">try</span> allocator.create(<span class="tok-type">i32</span>);</span>
<span class="line" id="L1254"> <span class="tok-kw">defer</span> allocator.destroy(ptr);</span>
<span class="line" id="L1255">}</span>
<span class="line" id="L1256"></span>
<span class="line" id="L1257"><span class="tok-kw">test</span> <span class="tok-str">"non-page-allocator backing allocator"</span> {</span>
<span class="line" id="L1258"> <span class="tok-kw">var</span> gpa = GeneralPurposeAllocator(.{}){ .backing_allocator = std.testing.allocator };</span>
<span class="line" id="L1259"> <span class="tok-kw">defer</span> std.testing.expect(gpa.deinit() == .ok) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"leak"</span>);</span>
<span class="line" id="L1260"> <span class="tok-kw">const</span> allocator = gpa.allocator();</span>
<span class="line" id="L1261"></span>
<span class="line" id="L1262"> <span class="tok-kw">const</span> ptr = <span class="tok-kw">try</span> allocator.create(<span class="tok-type">i32</span>);</span>
<span class="line" id="L1263"> <span class="tok-kw">defer</span> allocator.destroy(ptr);</span>
<span class="line" id="L1264">}</span>
<span class="line" id="L1265"></span>
<span class="line" id="L1266"><span class="tok-kw">test</span> <span class="tok-str">"realloc large object to larger alignment"</span> {</span>
<span class="line" id="L1267"> <span class="tok-kw">var</span> gpa = GeneralPurposeAllocator(test_config){};</span>
<span class="line" id="L1268"> <span class="tok-kw">defer</span> std.testing.expect(gpa.deinit() == .ok) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"leak"</span>);</span>
<span class="line" id="L1269"> <span class="tok-kw">const</span> allocator = gpa.allocator();</span>
<span class="line" id="L1270"></span>
<span class="line" id="L1271"> <span class="tok-kw">var</span> debug_buffer: [<span class="tok-number">1000</span>]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L1272"> <span class="tok-kw">var</span> fba = std.heap.FixedBufferAllocator.init(&debug_buffer);</span>
<span class="line" id="L1273"> <span class="tok-kw">const</span> debug_allocator = fba.allocator();</span>
<span class="line" id="L1274"></span>
<span class="line" id="L1275"> <span class="tok-kw">var</span> slice = <span class="tok-kw">try</span> allocator.alignedAlloc(<span class="tok-type">u8</span>, <span class="tok-number">16</span>, page_size * <span class="tok-number">2</span> + <span class="tok-number">50</span>);</span>
<span class="line" id="L1276"> <span class="tok-kw">defer</span> allocator.free(slice);</span>
<span class="line" id="L1277"></span>
<span class="line" id="L1278"> <span class="tok-kw">const</span> big_alignment: <span class="tok-type">usize</span> = <span class="tok-kw">switch</span> (builtin.os.tag) {</span>
<span class="line" id="L1279"> .windows => page_size * <span class="tok-number">32</span>, <span class="tok-comment">// Windows aligns to 64K.</span>
</span>
<span class="line" id="L1280"> <span class="tok-kw">else</span> => page_size * <span class="tok-number">2</span>,</span>
<span class="line" id="L1281"> };</span>
<span class="line" id="L1282"> <span class="tok-comment">// This loop allocates until we find a page that is not aligned to the big alignment.</span>
</span>
<span class="line" id="L1283"> <span class="tok-kw">var</span> stuff_to_free = std.ArrayList([]<span class="tok-kw">align</span>(<span class="tok-number">16</span>) <span class="tok-type">u8</span>).init(debug_allocator);</span>
<span class="line" id="L1284"> <span class="tok-kw">while</span> (mem.isAligned(<span class="tok-builtin">@intFromPtr</span>(slice.ptr), big_alignment)) {</span>
<span class="line" id="L1285"> <span class="tok-kw">try</span> stuff_to_free.append(slice);</span>
<span class="line" id="L1286"> slice = <span class="tok-kw">try</span> allocator.alignedAlloc(<span class="tok-type">u8</span>, <span class="tok-number">16</span>, page_size * <span class="tok-number">2</span> + <span class="tok-number">50</span>);</span>
<span class="line" id="L1287"> }</span>
<span class="line" id="L1288"> <span class="tok-kw">while</span> (stuff_to_free.popOrNull()) |item| {</span>
<span class="line" id="L1289"> allocator.free(item);</span>
<span class="line" id="L1290"> }</span>
<span class="line" id="L1291"> slice[<span class="tok-number">0</span>] = <span class="tok-number">0x12</span>;</span>
<span class="line" id="L1292"> slice[<span class="tok-number">16</span>] = <span class="tok-number">0x34</span>;</span>
<span class="line" id="L1293"></span>
<span class="line" id="L1294"> slice = <span class="tok-kw">try</span> allocator.reallocAdvanced(slice, <span class="tok-number">32</span>, page_size * <span class="tok-number">2</span> + <span class="tok-number">100</span>);</span>
<span class="line" id="L1295"> <span class="tok-kw">try</span> std.testing.expect(slice[<span class="tok-number">0</span>] == <span class="tok-number">0x12</span>);</span>
<span class="line" id="L1296"> <span class="tok-kw">try</span> std.testing.expect(slice[<span class="tok-number">16</span>] == <span class="tok-number">0x34</span>);</span>
<span class="line" id="L1297"></span>
<span class="line" id="L1298"> slice = <span class="tok-kw">try</span> allocator.reallocAdvanced(slice, <span class="tok-number">32</span>, page_size * <span class="tok-number">2</span> + <span class="tok-number">25</span>);</span>
<span class="line" id="L1299"> <span class="tok-kw">try</span> std.testing.expect(slice[<span class="tok-number">0</span>] == <span class="tok-number">0x12</span>);</span>
<span class="line" id="L1300"> <span class="tok-kw">try</span> std.testing.expect(slice[<span class="tok-number">16</span>] == <span class="tok-number">0x34</span>);</span>
<span class="line" id="L1301"></span>
<span class="line" id="L1302"> slice = <span class="tok-kw">try</span> allocator.reallocAdvanced(slice, big_alignment, page_size * <span class="tok-number">2</span> + <span class="tok-number">100</span>);</span>
<span class="line" id="L1303"> <span class="tok-kw">try</span> std.testing.expect(slice[<span class="tok-number">0</span>] == <span class="tok-number">0x12</span>);</span>
<span class="line" id="L1304"> <span class="tok-kw">try</span> std.testing.expect(slice[<span class="tok-number">16</span>] == <span class="tok-number">0x34</span>);</span>
<span class="line" id="L1305">}</span>
<span class="line" id="L1306"></span>
<span class="line" id="L1307"><span class="tok-kw">test</span> <span class="tok-str">"large object shrinks to small but allocation fails during shrink"</span> {</span>
<span class="line" id="L1308"> <span class="tok-kw">var</span> failing_allocator = std.testing.FailingAllocator.init(std.heap.page_allocator, <span class="tok-number">3</span>);</span>
<span class="line" id="L1309"> <span class="tok-kw">var</span> gpa = GeneralPurposeAllocator(.{}){ .backing_allocator = failing_allocator.allocator() };</span>
<span class="line" id="L1310"> <span class="tok-kw">defer</span> std.testing.expect(gpa.deinit() == .ok) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"leak"</span>);</span>
<span class="line" id="L1311"> <span class="tok-kw">const</span> allocator = gpa.allocator();</span>
<span class="line" id="L1312"></span>
<span class="line" id="L1313"> <span class="tok-kw">var</span> slice = <span class="tok-kw">try</span> allocator.alloc(<span class="tok-type">u8</span>, page_size * <span class="tok-number">2</span> + <span class="tok-number">50</span>);</span>
<span class="line" id="L1314"> <span class="tok-kw">defer</span> allocator.free(slice);</span>
<span class="line" id="L1315"> slice[<span class="tok-number">0</span>] = <span class="tok-number">0x12</span>;</span>
<span class="line" id="L1316"> slice[<span class="tok-number">3</span>] = <span class="tok-number">0x34</span>;</span>
<span class="line" id="L1317"></span>
<span class="line" id="L1318"> <span class="tok-comment">// Next allocation will fail in the backing allocator of the GeneralPurposeAllocator</span>
</span>
<span class="line" id="L1319"></span>
<span class="line" id="L1320"> <span class="tok-kw">try</span> std.testing.expect(allocator.resize(slice, <span class="tok-number">4</span>));</span>
<span class="line" id="L1321"> slice = slice[<span class="tok-number">0</span>..<span class="tok-number">4</span>];</span>
<span class="line" id="L1322"> <span class="tok-kw">try</span> std.testing.expect(slice[<span class="tok-number">0</span>] == <span class="tok-number">0x12</span>);</span>
<span class="line" id="L1323"> <span class="tok-kw">try</span> std.testing.expect(slice[<span class="tok-number">3</span>] == <span class="tok-number">0x34</span>);</span>
<span class="line" id="L1324">}</span>
<span class="line" id="L1325"></span>
<span class="line" id="L1326"><span class="tok-kw">test</span> <span class="tok-str">"objects of size 1024 and 2048"</span> {</span>
<span class="line" id="L1327"> <span class="tok-kw">var</span> gpa = GeneralPurposeAllocator(test_config){};</span>
<span class="line" id="L1328"> <span class="tok-kw">defer</span> std.testing.expect(gpa.deinit() == .ok) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"leak"</span>);</span>
<span class="line" id="L1329"> <span class="tok-kw">const</span> allocator = gpa.allocator();</span>
<span class="line" id="L1330"></span>
<span class="line" id="L1331"> <span class="tok-kw">const</span> slice = <span class="tok-kw">try</span> allocator.alloc(<span class="tok-type">u8</span>, <span class="tok-number">1025</span>);</span>
<span class="line" id="L1332"> <span class="tok-kw">const</span> slice2 = <span class="tok-kw">try</span> allocator.alloc(<span class="tok-type">u8</span>, <span class="tok-number">3000</span>);</span>
<span class="line" id="L1333"></span>
<span class="line" id="L1334"> allocator.free(slice);</span>
<span class="line" id="L1335"> allocator.free(slice2);</span>
<span class="line" id="L1336">}</span>
<span class="line" id="L1337"></span>
<span class="line" id="L1338"><span class="tok-kw">test</span> <span class="tok-str">"setting a memory cap"</span> {</span>
<span class="line" id="L1339"> <span class="tok-kw">var</span> gpa = GeneralPurposeAllocator(.{ .enable_memory_limit = <span class="tok-null">true</span> }){};</span>
<span class="line" id="L1340"> <span class="tok-kw">defer</span> std.testing.expect(gpa.deinit() == .ok) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"leak"</span>);</span>
<span class="line" id="L1341"> <span class="tok-kw">const</span> allocator = gpa.allocator();</span>
<span class="line" id="L1342"></span>
<span class="line" id="L1343"> gpa.setRequestedMemoryLimit(<span class="tok-number">1010</span>);</span>
<span class="line" id="L1344"></span>
<span class="line" id="L1345"> <span class="tok-kw">const</span> small = <span class="tok-kw">try</span> allocator.create(<span class="tok-type">i32</span>);</span>
<span class="line" id="L1346"> <span class="tok-kw">try</span> std.testing.expect(gpa.total_requested_bytes == <span class="tok-number">4</span>);</span>
<span class="line" id="L1347"></span>
<span class="line" id="L1348"> <span class="tok-kw">const</span> big = <span class="tok-kw">try</span> allocator.alloc(<span class="tok-type">u8</span>, <span class="tok-number">1000</span>);</span>
<span class="line" id="L1349"> <span class="tok-kw">try</span> std.testing.expect(gpa.total_requested_bytes == <span class="tok-number">1004</span>);</span>
<span class="line" id="L1350"></span>
<span class="line" id="L1351"> <span class="tok-kw">try</span> std.testing.expectError(<span class="tok-kw">error</span>.OutOfMemory, allocator.create(<span class="tok-type">u64</span>));</span>
<span class="line" id="L1352"></span>
<span class="line" id="L1353"> allocator.destroy(small);</span>
<span class="line" id="L1354"> <span class="tok-kw">try</span> std.testing.expect(gpa.total_requested_bytes == <span class="tok-number">1000</span>);</span>
<span class="line" id="L1355"></span>
<span class="line" id="L1356"> allocator.free(big);</span>
<span class="line" id="L1357"> <span class="tok-kw">try</span> std.testing.expect(gpa.total_requested_bytes == <span class="tok-number">0</span>);</span>
<span class="line" id="L1358"></span>
<span class="line" id="L1359"> <span class="tok-kw">const</span> exact = <span class="tok-kw">try</span> allocator.alloc(<span class="tok-type">u8</span>, <span class="tok-number">1010</span>);</span>
<span class="line" id="L1360"> <span class="tok-kw">try</span> std.testing.expect(gpa.total_requested_bytes == <span class="tok-number">1010</span>);</span>
<span class="line" id="L1361"> allocator.free(exact);</span>
<span class="line" id="L1362">}</span>
<span class="line" id="L1363"></span>
<span class="line" id="L1364"><span class="tok-kw">test</span> <span class="tok-str">"double frees"</span> {</span>
<span class="line" id="L1365"> <span class="tok-comment">// use a GPA to back a GPA to check for leaks of the latter's metadata</span>
</span>
<span class="line" id="L1366"> <span class="tok-kw">var</span> backing_gpa = GeneralPurposeAllocator(.{ .safety = <span class="tok-null">true</span> }){};</span>
<span class="line" id="L1367"> <span class="tok-kw">defer</span> std.testing.expect(backing_gpa.deinit() == .ok) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"leak"</span>);</span>
<span class="line" id="L1368"></span>
<span class="line" id="L1369"> <span class="tok-kw">const</span> GPA = GeneralPurposeAllocator(.{ .safety = <span class="tok-null">true</span>, .never_unmap = <span class="tok-null">true</span>, .retain_metadata = <span class="tok-null">true</span> });</span>
<span class="line" id="L1370"> <span class="tok-kw">var</span> gpa = GPA{ .backing_allocator = backing_gpa.allocator() };</span>
<span class="line" id="L1371"> <span class="tok-kw">defer</span> std.testing.expect(gpa.deinit() == .ok) <span class="tok-kw">catch</span> <span class="tok-builtin">@panic</span>(<span class="tok-str">"leak"</span>);</span>
<span class="line" id="L1372"> <span class="tok-kw">const</span> allocator = gpa.allocator();</span>
<span class="line" id="L1373"></span>
<span class="line" id="L1374"> <span class="tok-comment">// detect a small allocation double free, even though bucket is emptied</span>
</span>
<span class="line" id="L1375"> <span class="tok-kw">const</span> index: <span class="tok-type">usize</span> = <span class="tok-number">6</span>;</span>
<span class="line" id="L1376"> <span class="tok-kw">const</span> size_class: <span class="tok-type">usize</span> = <span class="tok-builtin">@as</span>(<span class="tok-type">usize</span>, <span class="tok-number">1</span>) << <span class="tok-number">6</span>;</span>
<span class="line" id="L1377"> <span class="tok-kw">const</span> small = <span class="tok-kw">try</span> allocator.alloc(<span class="tok-type">u8</span>, size_class);</span>
<span class="line" id="L1378"> <span class="tok-kw">try</span> std.testing.expect(GPA.searchBucket(gpa.buckets[index], <span class="tok-builtin">@intFromPtr</span>(small.ptr)) != <span class="tok-null">null</span>);</span>
<span class="line" id="L1379"> allocator.free(small);</span>
<span class="line" id="L1380"> <span class="tok-kw">try</span> std.testing.expect(GPA.searchBucket(gpa.buckets[index], <span class="tok-builtin">@intFromPtr</span>(small.ptr)) == <span class="tok-null">null</span>);</span>
<span class="line" id="L1381"> <span class="tok-kw">try</span> std.testing.expect(GPA.searchBucket(gpa.empty_buckets, <span class="tok-builtin">@intFromPtr</span>(small.ptr)) != <span class="tok-null">null</span>);</span>
<span class="line" id="L1382"></span>
<span class="line" id="L1383"> <span class="tok-comment">// detect a large allocation double free</span>
</span>
<span class="line" id="L1384"> <span class="tok-kw">const</span> large = <span class="tok-kw">try</span> allocator.alloc(<span class="tok-type">u8</span>, <span class="tok-number">2</span> * page_size);</span>
<span class="line" id="L1385"> <span class="tok-kw">try</span> std.testing.expect(gpa.large_allocations.contains(<span class="tok-builtin">@intFromPtr</span>(large.ptr)));</span>
<span class="line" id="L1386"> <span class="tok-kw">try</span> std.testing.expectEqual(gpa.large_allocations.getEntry(<span class="tok-builtin">@intFromPtr</span>(large.ptr)).?.value_ptr.bytes, large);</span>
<span class="line" id="L1387"> allocator.free(large);</span>
<span class="line" id="L1388"> <span class="tok-kw">try</span> std.testing.expect(gpa.large_allocations.contains(<span class="tok-builtin">@intFromPtr</span>(large.ptr)));</span>
<span class="line" id="L1389"> <span class="tok-kw">try</span> std.testing.expect(gpa.large_allocations.getEntry(<span class="tok-builtin">@intFromPtr</span>(large.ptr)).?.value_ptr.freed);</span>
<span class="line" id="L1390"></span>
<span class="line" id="L1391"> <span class="tok-kw">const</span> normal_small = <span class="tok-kw">try</span> allocator.alloc(<span class="tok-type">u8</span>, size_class);</span>
<span class="line" id="L1392"> <span class="tok-kw">defer</span> allocator.free(normal_small);</span>
<span class="line" id="L1393"> <span class="tok-kw">const</span> normal_large = <span class="tok-kw">try</span> allocator.alloc(<span class="tok-type">u8</span>, <span class="tok-number">2</span> * page_size);</span>
<span class="line" id="L1394"> <span class="tok-kw">defer</span> allocator.free(normal_large);</span>
<span class="line" id="L1395"></span>
<span class="line" id="L1396"> <span class="tok-comment">// check that flushing retained metadata doesn't disturb live allocations</span>
</span>
<span class="line" id="L1397"> gpa.flushRetainedMetadata();</span>
<span class="line" id="L1398"> <span class="tok-kw">try</span> std.testing.expect(gpa.empty_buckets == <span class="tok-null">null</span>);</span>
<span class="line" id="L1399"> <span class="tok-kw">try</span> std.testing.expect(GPA.searchBucket(gpa.buckets[index], <span class="tok-builtin">@intFromPtr</span>(normal_small.ptr)) != <span class="tok-null">null</span>);</span>
<span class="line" id="L1400"> <span class="tok-kw">try</span> std.testing.expect(gpa.large_allocations.contains(<span class="tok-builtin">@intFromPtr</span>(normal_large.ptr)));</span>
<span class="line" id="L1401"> <span class="tok-kw">try</span> std.testing.expect(!gpa.large_allocations.contains(<span class="tok-builtin">@intFromPtr</span>(large.ptr)));</span>
<span class="line" id="L1402">}</span>
<span class="line" id="L1403"></span>
<span class="line" id="L1404"><span class="tok-kw">test</span> <span class="tok-str">"bug 9995 fix, large allocs count requested size not backing size"</span> {</span>
<span class="line" id="L1405"> <span class="tok-comment">// with AtLeast, buffer likely to be larger than requested, especially when shrinking</span>
</span>
<span class="line" id="L1406"> <span class="tok-kw">var</span> gpa = GeneralPurposeAllocator(.{ .enable_memory_limit = <span class="tok-null">true</span> }){};</span>
<span class="line" id="L1407"> <span class="tok-kw">const</span> allocator = gpa.allocator();</span>
<span class="line" id="L1408"></span>
<span class="line" id="L1409"> <span class="tok-kw">var</span> buf = <span class="tok-kw">try</span> allocator.alignedAlloc(<span class="tok-type">u8</span>, <span class="tok-number">1</span>, page_size + <span class="tok-number">1</span>);</span>
<span class="line" id="L1410"> <span class="tok-kw">try</span> std.testing.expect(gpa.total_requested_bytes == page_size + <span class="tok-number">1</span>);</span>
<span class="line" id="L1411"> buf = <span class="tok-kw">try</span> allocator.realloc(buf, <span class="tok-number">1</span>);</span>
<span class="line" id="L1412"> <span class="tok-kw">try</span> std.testing.expect(gpa.total_requested_bytes == <span class="tok-number">1</span>);</span>
<span class="line" id="L1413"> buf = <span class="tok-kw">try</span> allocator.realloc(buf, <span class="tok-number">2</span>);</span>
<span class="line" id="L1414"> <span class="tok-kw">try</span> std.testing.expect(gpa.total_requested_bytes == <span class="tok-number">2</span>);</span>
<span class="line" id="L1415">}</span>
<span class="line" id="L1416"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/heap/PageAllocator.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>heap/PageAllocator.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../std.zig"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> builtin = <span class="tok-builtin">@import</span>(<span class="tok-str">"builtin"</span>);</span>
<span class="line" id="L3"><span class="tok-kw">const</span> Allocator = std.mem.Allocator;</span>
<span class="line" id="L4"><span class="tok-kw">const</span> mem = std.mem;</span>
<span class="line" id="L5"><span class="tok-kw">const</span> os = std.os;</span>
<span class="line" id="L6"><span class="tok-kw">const</span> maxInt = std.math.maxInt;</span>
<span class="line" id="L7"><span class="tok-kw">const</span> assert = std.debug.assert;</span>
<span class="line" id="L8"></span>
<span class="line" id="L9"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> vtable = Allocator.VTable{</span>
<span class="line" id="L10"> .alloc = alloc,</span>
<span class="line" id="L11"> .resize = resize,</span>
<span class="line" id="L12"> .free = free,</span>
<span class="line" id="L13">};</span>
<span class="line" id="L14"></span>
<span class="line" id="L15"><span class="tok-kw">fn</span> <span class="tok-fn">alloc</span>(_: *<span class="tok-type">anyopaque</span>, n: <span class="tok-type">usize</span>, log2_align: <span class="tok-type">u8</span>, ra: <span class="tok-type">usize</span>) ?[*]<span class="tok-type">u8</span> {</span>
<span class="line" id="L16"> _ = ra;</span>
<span class="line" id="L17"> _ = log2_align;</span>
<span class="line" id="L18"> assert(n > <span class="tok-number">0</span>);</span>
<span class="line" id="L19"> <span class="tok-kw">if</span> (n > maxInt(<span class="tok-type">usize</span>) - (mem.page_size - <span class="tok-number">1</span>)) <span class="tok-kw">return</span> <span class="tok-null">null</span>;</span>
<span class="line" id="L20"> <span class="tok-kw">const</span> aligned_len = mem.alignForward(<span class="tok-type">usize</span>, n, mem.page_size);</span>
<span class="line" id="L21"></span>
<span class="line" id="L22"> <span class="tok-kw">if</span> (builtin.os.tag == .windows) {</span>
<span class="line" id="L23"> <span class="tok-kw">const</span> w = os.windows;</span>
<span class="line" id="L24"> <span class="tok-kw">const</span> addr = w.VirtualAlloc(</span>
<span class="line" id="L25"> <span class="tok-null">null</span>,</span>
<span class="line" id="L26"> aligned_len,</span>
<span class="line" id="L27"> w.MEM_COMMIT | w.MEM_RESERVE,</span>
<span class="line" id="L28"> w.PAGE_READWRITE,</span>
<span class="line" id="L29"> ) <span class="tok-kw">catch</span> <span class="tok-kw">return</span> <span class="tok-null">null</span>;</span>
<span class="line" id="L30"> <span class="tok-kw">return</span> <span class="tok-builtin">@ptrCast</span>(addr);</span>
<span class="line" id="L31"> }</span>
<span class="line" id="L32"></span>
<span class="line" id="L33"> <span class="tok-kw">const</span> hint = <span class="tok-builtin">@atomicLoad</span>(<span class="tok-builtin">@TypeOf</span>(std.heap.next_mmap_addr_hint), &std.heap.next_mmap_addr_hint, .Unordered);</span>
<span class="line" id="L34"> <span class="tok-kw">const</span> slice = os.mmap(</span>
<span class="line" id="L35"> hint,</span>
<span class="line" id="L36"> aligned_len,</span>
<span class="line" id="L37"> os.PROT.READ | os.PROT.WRITE,</span>
<span class="line" id="L38"> os.MAP.PRIVATE | os.MAP.ANONYMOUS,</span>
<span class="line" id="L39"> -<span class="tok-number">1</span>,</span>
<span class="line" id="L40"> <span class="tok-number">0</span>,</span>
<span class="line" id="L41"> ) <span class="tok-kw">catch</span> <span class="tok-kw">return</span> <span class="tok-null">null</span>;</span>
<span class="line" id="L42"> assert(mem.isAligned(<span class="tok-builtin">@intFromPtr</span>(slice.ptr), mem.page_size));</span>
<span class="line" id="L43"> <span class="tok-kw">const</span> new_hint: [*]<span class="tok-kw">align</span>(mem.page_size) <span class="tok-type">u8</span> = <span class="tok-builtin">@alignCast</span>(slice.ptr + aligned_len);</span>
<span class="line" id="L44"> _ = <span class="tok-builtin">@cmpxchgStrong</span>(<span class="tok-builtin">@TypeOf</span>(std.heap.next_mmap_addr_hint), &std.heap.next_mmap_addr_hint, hint, new_hint, .Monotonic, .Monotonic);</span>
<span class="line" id="L45"> <span class="tok-kw">return</span> slice.ptr;</span>
<span class="line" id="L46">}</span>
<span class="line" id="L47"></span>
<span class="line" id="L48"><span class="tok-kw">fn</span> <span class="tok-fn">resize</span>(</span>
<span class="line" id="L49"> _: *<span class="tok-type">anyopaque</span>,</span>
<span class="line" id="L50"> buf_unaligned: []<span class="tok-type">u8</span>,</span>
<span class="line" id="L51"> log2_buf_align: <span class="tok-type">u8</span>,</span>
<span class="line" id="L52"> new_size: <span class="tok-type">usize</span>,</span>
<span class="line" id="L53"> return_address: <span class="tok-type">usize</span>,</span>
<span class="line" id="L54">) <span class="tok-type">bool</span> {</span>
<span class="line" id="L55"> _ = log2_buf_align;</span>
<span class="line" id="L56"> _ = return_address;</span>
<span class="line" id="L57"> <span class="tok-kw">const</span> new_size_aligned = mem.alignForward(<span class="tok-type">usize</span>, new_size, mem.page_size);</span>
<span class="line" id="L58"></span>
<span class="line" id="L59"> <span class="tok-kw">if</span> (builtin.os.tag == .windows) {</span>
<span class="line" id="L60"> <span class="tok-kw">const</span> w = os.windows;</span>
<span class="line" id="L61"> <span class="tok-kw">if</span> (new_size <= buf_unaligned.len) {</span>
<span class="line" id="L62"> <span class="tok-kw">const</span> base_addr = <span class="tok-builtin">@intFromPtr</span>(buf_unaligned.ptr);</span>
<span class="line" id="L63"> <span class="tok-kw">const</span> old_addr_end = base_addr + buf_unaligned.len;</span>
<span class="line" id="L64"> <span class="tok-kw">const</span> new_addr_end = mem.alignForward(<span class="tok-type">usize</span>, base_addr + new_size, mem.page_size);</span>
<span class="line" id="L65"> <span class="tok-kw">if</span> (old_addr_end > new_addr_end) {</span>
<span class="line" id="L66"> <span class="tok-comment">// For shrinking that is not releasing, we will only</span>
</span>
<span class="line" id="L67"> <span class="tok-comment">// decommit the pages not needed anymore.</span>
</span>
<span class="line" id="L68"> w.VirtualFree(</span>
<span class="line" id="L69"> <span class="tok-builtin">@as</span>(*<span class="tok-type">anyopaque</span>, <span class="tok-builtin">@ptrFromInt</span>(new_addr_end)),</span>
<span class="line" id="L70"> old_addr_end - new_addr_end,</span>
<span class="line" id="L71"> w.MEM_DECOMMIT,</span>
<span class="line" id="L72"> );</span>
<span class="line" id="L73"> }</span>
<span class="line" id="L74"> <span class="tok-kw">return</span> <span class="tok-null">true</span>;</span>
<span class="line" id="L75"> }</span>
<span class="line" id="L76"> <span class="tok-kw">const</span> old_size_aligned = mem.alignForward(<span class="tok-type">usize</span>, buf_unaligned.len, mem.page_size);</span>
<span class="line" id="L77"> <span class="tok-kw">if</span> (new_size_aligned <= old_size_aligned) {</span>
<span class="line" id="L78"> <span class="tok-kw">return</span> <span class="tok-null">true</span>;</span>
<span class="line" id="L79"> }</span>
<span class="line" id="L80"> <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L81"> }</span>
<span class="line" id="L82"></span>
<span class="line" id="L83"> <span class="tok-kw">const</span> buf_aligned_len = mem.alignForward(<span class="tok-type">usize</span>, buf_unaligned.len, mem.page_size);</span>
<span class="line" id="L84"> <span class="tok-kw">if</span> (new_size_aligned == buf_aligned_len)</span>
<span class="line" id="L85"> <span class="tok-kw">return</span> <span class="tok-null">true</span>;</span>
<span class="line" id="L86"></span>
<span class="line" id="L87"> <span class="tok-kw">if</span> (new_size_aligned < buf_aligned_len) {</span>
<span class="line" id="L88"> <span class="tok-kw">const</span> ptr = buf_unaligned.ptr + new_size_aligned;</span>
<span class="line" id="L89"> <span class="tok-comment">// TODO: if the next_mmap_addr_hint is within the unmapped range, update it</span>
</span>
<span class="line" id="L90"> os.munmap(<span class="tok-builtin">@alignCast</span>(ptr[<span class="tok-number">0</span> .. buf_aligned_len - new_size_aligned]));</span>
<span class="line" id="L91"> <span class="tok-kw">return</span> <span class="tok-null">true</span>;</span>
<span class="line" id="L92"> }</span>
<span class="line" id="L93"></span>
<span class="line" id="L94"> <span class="tok-comment">// TODO: call mremap</span>
</span>
<span class="line" id="L95"> <span class="tok-comment">// TODO: if the next_mmap_addr_hint is within the remapped range, update it</span>
</span>
<span class="line" id="L96"> <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L97">}</span>
<span class="line" id="L98"></span>
<span class="line" id="L99"><span class="tok-kw">fn</span> <span class="tok-fn">free</span>(_: *<span class="tok-type">anyopaque</span>, slice: []<span class="tok-type">u8</span>, log2_buf_align: <span class="tok-type">u8</span>, return_address: <span class="tok-type">usize</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L100"> _ = log2_buf_align;</span>
<span class="line" id="L101"> _ = return_address;</span>
<span class="line" id="L102"></span>
<span class="line" id="L103"> <span class="tok-kw">if</span> (builtin.os.tag == .windows) {</span>
<span class="line" id="L104"> os.windows.VirtualFree(slice.ptr, <span class="tok-number">0</span>, os.windows.MEM_RELEASE);</span>
<span class="line" id="L105"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L106"> <span class="tok-kw">const</span> buf_aligned_len = mem.alignForward(<span class="tok-type">usize</span>, slice.len, mem.page_size);</span>
<span class="line" id="L107"> os.munmap(<span class="tok-builtin">@alignCast</span>(slice.ptr[<span class="tok-number">0</span>..buf_aligned_len]));</span>
<span class="line" id="L108"> }</span>
<span class="line" id="L109">}</span>
<span class="line" id="L110"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/heap/arena_allocator.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>heap/arena_allocator.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../std.zig"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> assert = std.debug.assert;</span>
<span class="line" id="L3"><span class="tok-kw">const</span> mem = std.mem;</span>
<span class="line" id="L4"><span class="tok-kw">const</span> Allocator = std.mem.Allocator;</span>
<span class="line" id="L5"></span>
<span class="line" id="L6"><span class="tok-comment">/// This allocator takes an existing allocator, wraps it, and provides an interface</span></span>
<span class="line" id="L7"><span class="tok-comment">/// where you can allocate without freeing, and then free it all together.</span></span>
<span class="line" id="L8"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> ArenaAllocator = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L9"> child_allocator: Allocator,</span>
<span class="line" id="L10"> state: State,</span>
<span class="line" id="L11"></span>
<span class="line" id="L12"> <span class="tok-comment">/// Inner state of ArenaAllocator. Can be stored rather than the entire ArenaAllocator</span></span>
<span class="line" id="L13"> <span class="tok-comment">/// as a memory-saving optimization.</span></span>
<span class="line" id="L14"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> State = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L15"> buffer_list: std.SinglyLinkedList(<span class="tok-type">usize</span>) = .{},</span>
<span class="line" id="L16"> end_index: <span class="tok-type">usize</span> = <span class="tok-number">0</span>,</span>
<span class="line" id="L17"></span>
<span class="line" id="L18"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">promote</span>(self: State, child_allocator: Allocator) ArenaAllocator {</span>
<span class="line" id="L19"> <span class="tok-kw">return</span> .{</span>
<span class="line" id="L20"> .child_allocator = child_allocator,</span>
<span class="line" id="L21"> .state = self,</span>
<span class="line" id="L22"> };</span>
<span class="line" id="L23"> }</span>
<span class="line" id="L24"> };</span>
<span class="line" id="L25"></span>
<span class="line" id="L26"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">allocator</span>(self: *ArenaAllocator) Allocator {</span>
<span class="line" id="L27"> <span class="tok-kw">return</span> .{</span>
<span class="line" id="L28"> .ptr = self,</span>
<span class="line" id="L29"> .vtable = &.{</span>
<span class="line" id="L30"> .alloc = alloc,</span>
<span class="line" id="L31"> .resize = resize,</span>
<span class="line" id="L32"> .free = free,</span>
<span class="line" id="L33"> },</span>
<span class="line" id="L34"> };</span>
<span class="line" id="L35"> }</span>
<span class="line" id="L36"></span>
<span class="line" id="L37"> <span class="tok-kw">const</span> BufNode = std.SinglyLinkedList(<span class="tok-type">usize</span>).Node;</span>
<span class="line" id="L38"></span>
<span class="line" id="L39"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">init</span>(child_allocator: Allocator) ArenaAllocator {</span>
<span class="line" id="L40"> <span class="tok-kw">return</span> (State{}).promote(child_allocator);</span>
<span class="line" id="L41"> }</span>
<span class="line" id="L42"></span>
<span class="line" id="L43"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">deinit</span>(self: ArenaAllocator) <span class="tok-type">void</span> {</span>
<span class="line" id="L44"> <span class="tok-comment">// NOTE: When changing this, make sure `reset()` is adjusted accordingly!</span>
</span>
<span class="line" id="L45"></span>
<span class="line" id="L46"> <span class="tok-kw">var</span> it = self.state.buffer_list.first;</span>
<span class="line" id="L47"> <span class="tok-kw">while</span> (it) |node| {</span>
<span class="line" id="L48"> <span class="tok-comment">// this has to occur before the free because the free frees node</span>
</span>
<span class="line" id="L49"> <span class="tok-kw">const</span> next_it = node.next;</span>
<span class="line" id="L50"> <span class="tok-kw">const</span> align_bits = std.math.log2_int(<span class="tok-type">usize</span>, <span class="tok-builtin">@alignOf</span>(BufNode));</span>
<span class="line" id="L51"> <span class="tok-kw">const</span> alloc_buf = <span class="tok-builtin">@as</span>([*]<span class="tok-type">u8</span>, <span class="tok-builtin">@ptrCast</span>(node))[<span class="tok-number">0</span>..node.data];</span>
<span class="line" id="L52"> self.child_allocator.rawFree(alloc_buf, align_bits, <span class="tok-builtin">@returnAddress</span>());</span>
<span class="line" id="L53"> it = next_it;</span>
<span class="line" id="L54"> }</span>
<span class="line" id="L55"> }</span>
<span class="line" id="L56"></span>
<span class="line" id="L57"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> ResetMode = <span class="tok-kw">union</span>(<span class="tok-kw">enum</span>) {</span>
<span class="line" id="L58"> <span class="tok-comment">/// Releases all allocated memory in the arena.</span></span>
<span class="line" id="L59"> free_all,</span>
<span class="line" id="L60"> <span class="tok-comment">/// This will pre-heat the arena for future allocations by allocating a</span></span>
<span class="line" id="L61"> <span class="tok-comment">/// large enough buffer for all previously done allocations.</span></span>
<span class="line" id="L62"> <span class="tok-comment">/// Preheating will speed up the allocation process by invoking the backing allocator</span></span>
<span class="line" id="L63"> <span class="tok-comment">/// less often than before. If `reset()` is used in a loop, this means that after the</span></span>
<span class="line" id="L64"> <span class="tok-comment">/// biggest operation, no memory allocations are performed anymore.</span></span>
<span class="line" id="L65"> retain_capacity,</span>
<span class="line" id="L66"> <span class="tok-comment">/// This is the same as `retain_capacity`, but the memory will be shrunk to</span></span>
<span class="line" id="L67"> <span class="tok-comment">/// this value if it exceeds the limit.</span></span>
<span class="line" id="L68"> retain_with_limit: <span class="tok-type">usize</span>,</span>
<span class="line" id="L69"> };</span>
<span class="line" id="L70"> <span class="tok-comment">/// Queries the current memory use of this arena.</span></span>
<span class="line" id="L71"> <span class="tok-comment">/// This will **not** include the storage required for internal keeping.</span></span>
<span class="line" id="L72"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">queryCapacity</span>(self: ArenaAllocator) <span class="tok-type">usize</span> {</span>
<span class="line" id="L73"> <span class="tok-kw">var</span> size: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L74"> <span class="tok-kw">var</span> it = self.state.buffer_list.first;</span>
<span class="line" id="L75"> <span class="tok-kw">while</span> (it) |node| : (it = node.next) {</span>
<span class="line" id="L76"> <span class="tok-comment">// Compute the actually allocated size excluding the</span>
</span>
<span class="line" id="L77"> <span class="tok-comment">// linked list node.</span>
</span>
<span class="line" id="L78"> size += node.data - <span class="tok-builtin">@sizeOf</span>(BufNode);</span>
<span class="line" id="L79"> }</span>
<span class="line" id="L80"> <span class="tok-kw">return</span> size;</span>
<span class="line" id="L81"> }</span>
<span class="line" id="L82"> <span class="tok-comment">/// Resets the arena allocator and frees all allocated memory.</span></span>
<span class="line" id="L83"> <span class="tok-comment">///</span></span>
<span class="line" id="L84"> <span class="tok-comment">/// `mode` defines how the currently allocated memory is handled.</span></span>
<span class="line" id="L85"> <span class="tok-comment">/// See the variant documentation for `ResetMode` for the effects of each mode.</span></span>
<span class="line" id="L86"> <span class="tok-comment">///</span></span>
<span class="line" id="L87"> <span class="tok-comment">/// The function will return whether the reset operation was successful or not.</span></span>
<span class="line" id="L88"> <span class="tok-comment">/// If the reallocation failed `false` is returned. The arena will still be fully</span></span>
<span class="line" id="L89"> <span class="tok-comment">/// functional in that case, all memory is released. Future allocations just might</span></span>
<span class="line" id="L90"> <span class="tok-comment">/// be slower.</span></span>
<span class="line" id="L91"> <span class="tok-comment">///</span></span>
<span class="line" id="L92"> <span class="tok-comment">/// NOTE: If `mode` is `free_mode`, the function will always return `true`.</span></span>
<span class="line" id="L93"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">reset</span>(self: *ArenaAllocator, mode: ResetMode) <span class="tok-type">bool</span> {</span>
<span class="line" id="L94"> <span class="tok-comment">// Some words on the implementation:</span>
</span>
<span class="line" id="L95"> <span class="tok-comment">// The reset function can be implemented with two basic approaches:</span>
</span>
<span class="line" id="L96"> <span class="tok-comment">// - Counting how much bytes were allocated since the last reset, and storing that</span>
</span>
<span class="line" id="L97"> <span class="tok-comment">// information in State. This will make reset fast and alloc only a teeny tiny bit</span>
</span>
<span class="line" id="L98"> <span class="tok-comment">// slower.</span>
</span>
<span class="line" id="L99"> <span class="tok-comment">// - Counting how much bytes were allocated by iterating the chunk linked list. This</span>
</span>
<span class="line" id="L100"> <span class="tok-comment">// will make reset slower, but alloc() keeps the same speed when reset() as if reset()</span>
</span>
<span class="line" id="L101"> <span class="tok-comment">// would not exist.</span>
</span>
<span class="line" id="L102"> <span class="tok-comment">//</span>
</span>
<span class="line" id="L103"> <span class="tok-comment">// The second variant was chosen for implementation, as with more and more calls to reset(),</span>
</span>
<span class="line" id="L104"> <span class="tok-comment">// the function will get faster and faster. At one point, the complexity of the function</span>
</span>
<span class="line" id="L105"> <span class="tok-comment">// will drop to amortized O(1), as we're only ever having a single chunk that will not be</span>
</span>
<span class="line" id="L106"> <span class="tok-comment">// reallocated, and we're not even touching the backing allocator anymore.</span>
</span>
<span class="line" id="L107"> <span class="tok-comment">//</span>
</span>
<span class="line" id="L108"> <span class="tok-comment">// Thus, only the first hand full of calls to reset() will actually need to iterate the linked</span>
</span>
<span class="line" id="L109"> <span class="tok-comment">// list, all future calls are just taking the first node, and only resetting the `end_index`</span>
</span>
<span class="line" id="L110"> <span class="tok-comment">// value.</span>
</span>
<span class="line" id="L111"> <span class="tok-kw">const</span> requested_capacity = <span class="tok-kw">switch</span> (mode) {</span>
<span class="line" id="L112"> .retain_capacity => self.queryCapacity(),</span>
<span class="line" id="L113"> .retain_with_limit => |limit| <span class="tok-builtin">@min</span>(limit, self.queryCapacity()),</span>
<span class="line" id="L114"> .free_all => <span class="tok-number">0</span>,</span>
<span class="line" id="L115"> };</span>
<span class="line" id="L116"> <span class="tok-kw">if</span> (requested_capacity == <span class="tok-number">0</span>) {</span>
<span class="line" id="L117"> <span class="tok-comment">// just reset when we don't have anything to reallocate</span>
</span>
<span class="line" id="L118"> self.deinit();</span>
<span class="line" id="L119"> self.state = State{};</span>
<span class="line" id="L120"> <span class="tok-kw">return</span> <span class="tok-null">true</span>;</span>
<span class="line" id="L121"> }</span>
<span class="line" id="L122"> <span class="tok-kw">const</span> total_size = requested_capacity + <span class="tok-builtin">@sizeOf</span>(BufNode);</span>
<span class="line" id="L123"> <span class="tok-kw">const</span> align_bits = std.math.log2_int(<span class="tok-type">usize</span>, <span class="tok-builtin">@alignOf</span>(BufNode));</span>
<span class="line" id="L124"> <span class="tok-comment">// Free all nodes except for the last one</span>
</span>
<span class="line" id="L125"> <span class="tok-kw">var</span> it = self.state.buffer_list.first;</span>
<span class="line" id="L126"> <span class="tok-kw">const</span> maybe_first_node = <span class="tok-kw">while</span> (it) |node| {</span>
<span class="line" id="L127"> <span class="tok-comment">// this has to occur before the free because the free frees node</span>
</span>
<span class="line" id="L128"> <span class="tok-kw">const</span> next_it = node.next;</span>
<span class="line" id="L129"> <span class="tok-kw">if</span> (next_it == <span class="tok-null">null</span>)</span>
<span class="line" id="L130"> <span class="tok-kw">break</span> node;</span>
<span class="line" id="L131"> <span class="tok-kw">const</span> alloc_buf = <span class="tok-builtin">@as</span>([*]<span class="tok-type">u8</span>, <span class="tok-builtin">@ptrCast</span>(node))[<span class="tok-number">0</span>..node.data];</span>
<span class="line" id="L132"> self.child_allocator.rawFree(alloc_buf, align_bits, <span class="tok-builtin">@returnAddress</span>());</span>
<span class="line" id="L133"> it = next_it;</span>
<span class="line" id="L134"> } <span class="tok-kw">else</span> <span class="tok-null">null</span>;</span>
<span class="line" id="L135"> std.debug.assert(maybe_first_node == <span class="tok-null">null</span> <span class="tok-kw">or</span> maybe_first_node.?.next == <span class="tok-null">null</span>);</span>
<span class="line" id="L136"> <span class="tok-comment">// reset the state before we try resizing the buffers, so we definitely have reset the arena to 0.</span>
</span>
<span class="line" id="L137"> self.state.end_index = <span class="tok-number">0</span>;</span>
<span class="line" id="L138"> <span class="tok-kw">if</span> (maybe_first_node) |first_node| {</span>
<span class="line" id="L139"> self.state.buffer_list.first = first_node;</span>
<span class="line" id="L140"> <span class="tok-comment">// perfect, no need to invoke the child_allocator</span>
</span>
<span class="line" id="L141"> <span class="tok-kw">if</span> (first_node.data == total_size)</span>
<span class="line" id="L142"> <span class="tok-kw">return</span> <span class="tok-null">true</span>;</span>
<span class="line" id="L143"> <span class="tok-kw">const</span> first_alloc_buf = <span class="tok-builtin">@as</span>([*]<span class="tok-type">u8</span>, <span class="tok-builtin">@ptrCast</span>(first_node))[<span class="tok-number">0</span>..first_node.data];</span>
<span class="line" id="L144"> <span class="tok-kw">if</span> (self.child_allocator.rawResize(first_alloc_buf, align_bits, total_size, <span class="tok-builtin">@returnAddress</span>())) {</span>
<span class="line" id="L145"> <span class="tok-comment">// successful resize</span>
</span>
<span class="line" id="L146"> first_node.data = total_size;</span>
<span class="line" id="L147"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L148"> <span class="tok-comment">// manual realloc</span>
</span>
<span class="line" id="L149"> <span class="tok-kw">const</span> new_ptr = self.child_allocator.rawAlloc(total_size, align_bits, <span class="tok-builtin">@returnAddress</span>()) <span class="tok-kw">orelse</span> {</span>
<span class="line" id="L150"> <span class="tok-comment">// we failed to preheat the arena properly, signal this to the user.</span>
</span>
<span class="line" id="L151"> <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L152"> };</span>
<span class="line" id="L153"> self.child_allocator.rawFree(first_alloc_buf, align_bits, <span class="tok-builtin">@returnAddress</span>());</span>
<span class="line" id="L154"> <span class="tok-kw">const</span> node: *BufNode = <span class="tok-builtin">@ptrCast</span>(<span class="tok-builtin">@alignCast</span>(new_ptr));</span>
<span class="line" id="L155"> node.* = .{ .data = total_size };</span>
<span class="line" id="L156"> self.state.buffer_list.first = node;</span>
<span class="line" id="L157"> }</span>
<span class="line" id="L158"> }</span>
<span class="line" id="L159"> <span class="tok-kw">return</span> <span class="tok-null">true</span>;</span>
<span class="line" id="L160"> }</span>
<span class="line" id="L161"></span>
<span class="line" id="L162"> <span class="tok-kw">fn</span> <span class="tok-fn">createNode</span>(self: *ArenaAllocator, prev_len: <span class="tok-type">usize</span>, minimum_size: <span class="tok-type">usize</span>) ?*BufNode {</span>
<span class="line" id="L163"> <span class="tok-kw">const</span> actual_min_size = minimum_size + (<span class="tok-builtin">@sizeOf</span>(BufNode) + <span class="tok-number">16</span>);</span>
<span class="line" id="L164"> <span class="tok-kw">const</span> big_enough_len = prev_len + actual_min_size;</span>
<span class="line" id="L165"> <span class="tok-kw">const</span> len = big_enough_len + big_enough_len / <span class="tok-number">2</span>;</span>
<span class="line" id="L166"> <span class="tok-kw">const</span> log2_align = <span class="tok-kw">comptime</span> std.math.log2_int(<span class="tok-type">usize</span>, <span class="tok-builtin">@alignOf</span>(BufNode));</span>
<span class="line" id="L167"> <span class="tok-kw">const</span> ptr = self.child_allocator.rawAlloc(len, log2_align, <span class="tok-builtin">@returnAddress</span>()) <span class="tok-kw">orelse</span></span>
<span class="line" id="L168"> <span class="tok-kw">return</span> <span class="tok-null">null</span>;</span>
<span class="line" id="L169"> <span class="tok-kw">const</span> buf_node: *BufNode = <span class="tok-builtin">@ptrCast</span>(<span class="tok-builtin">@alignCast</span>(ptr));</span>
<span class="line" id="L170"> buf_node.* = .{ .data = len };</span>
<span class="line" id="L171"> self.state.buffer_list.prepend(buf_node);</span>
<span class="line" id="L172"> self.state.end_index = <span class="tok-number">0</span>;</span>
<span class="line" id="L173"> <span class="tok-kw">return</span> buf_node;</span>
<span class="line" id="L174"> }</span>
<span class="line" id="L175"></span>
<span class="line" id="L176"> <span class="tok-kw">fn</span> <span class="tok-fn">alloc</span>(ctx: *<span class="tok-type">anyopaque</span>, n: <span class="tok-type">usize</span>, log2_ptr_align: <span class="tok-type">u8</span>, ra: <span class="tok-type">usize</span>) ?[*]<span class="tok-type">u8</span> {</span>
<span class="line" id="L177"> <span class="tok-kw">const</span> self: *ArenaAllocator = <span class="tok-builtin">@ptrCast</span>(<span class="tok-builtin">@alignCast</span>(ctx));</span>
<span class="line" id="L178"> _ = ra;</span>
<span class="line" id="L179"></span>
<span class="line" id="L180"> <span class="tok-kw">const</span> ptr_align = <span class="tok-builtin">@as</span>(<span class="tok-type">usize</span>, <span class="tok-number">1</span>) << <span class="tok-builtin">@as</span>(Allocator.Log2Align, <span class="tok-builtin">@intCast</span>(log2_ptr_align));</span>
<span class="line" id="L181"> <span class="tok-kw">var</span> cur_node = <span class="tok-kw">if</span> (self.state.buffer_list.first) |first_node|</span>
<span class="line" id="L182"> first_node</span>
<span class="line" id="L183"> <span class="tok-kw">else</span></span>
<span class="line" id="L184"> (self.createNode(<span class="tok-number">0</span>, n + ptr_align) <span class="tok-kw">orelse</span> <span class="tok-kw">return</span> <span class="tok-null">null</span>);</span>
<span class="line" id="L185"> <span class="tok-kw">while</span> (<span class="tok-null">true</span>) {</span>
<span class="line" id="L186"> <span class="tok-kw">const</span> cur_alloc_buf = <span class="tok-builtin">@as</span>([*]<span class="tok-type">u8</span>, <span class="tok-builtin">@ptrCast</span>(cur_node))[<span class="tok-number">0</span>..cur_node.data];</span>
<span class="line" id="L187"> <span class="tok-kw">const</span> cur_buf = cur_alloc_buf[<span class="tok-builtin">@sizeOf</span>(BufNode)..];</span>
<span class="line" id="L188"> <span class="tok-kw">const</span> addr = <span class="tok-builtin">@intFromPtr</span>(cur_buf.ptr) + self.state.end_index;</span>
<span class="line" id="L189"> <span class="tok-kw">const</span> adjusted_addr = mem.alignForward(<span class="tok-type">usize</span>, addr, ptr_align);</span>
<span class="line" id="L190"> <span class="tok-kw">const</span> adjusted_index = self.state.end_index + (adjusted_addr - addr);</span>
<span class="line" id="L191"> <span class="tok-kw">const</span> new_end_index = adjusted_index + n;</span>
<span class="line" id="L192"></span>
<span class="line" id="L193"> <span class="tok-kw">if</span> (new_end_index <= cur_buf.len) {</span>
<span class="line" id="L194"> <span class="tok-kw">const</span> result = cur_buf[adjusted_index..new_end_index];</span>
<span class="line" id="L195"> self.state.end_index = new_end_index;</span>
<span class="line" id="L196"> <span class="tok-kw">return</span> result.ptr;</span>
<span class="line" id="L197"> }</span>
<span class="line" id="L198"></span>
<span class="line" id="L199"> <span class="tok-kw">const</span> bigger_buf_size = <span class="tok-builtin">@sizeOf</span>(BufNode) + new_end_index;</span>
<span class="line" id="L200"> <span class="tok-kw">const</span> log2_align = <span class="tok-kw">comptime</span> std.math.log2_int(<span class="tok-type">usize</span>, <span class="tok-builtin">@alignOf</span>(BufNode));</span>
<span class="line" id="L201"> <span class="tok-kw">if</span> (self.child_allocator.rawResize(cur_alloc_buf, log2_align, bigger_buf_size, <span class="tok-builtin">@returnAddress</span>())) {</span>
<span class="line" id="L202"> cur_node.data = bigger_buf_size;</span>
<span class="line" id="L203"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L204"> <span class="tok-comment">// Allocate a new node if that's not possible</span>
</span>
<span class="line" id="L205"> cur_node = self.createNode(cur_buf.len, n + ptr_align) <span class="tok-kw">orelse</span> <span class="tok-kw">return</span> <span class="tok-null">null</span>;</span>
<span class="line" id="L206"> }</span>
<span class="line" id="L207"> }</span>
<span class="line" id="L208"> }</span>
<span class="line" id="L209"></span>
<span class="line" id="L210"> <span class="tok-kw">fn</span> <span class="tok-fn">resize</span>(ctx: *<span class="tok-type">anyopaque</span>, buf: []<span class="tok-type">u8</span>, log2_buf_align: <span class="tok-type">u8</span>, new_len: <span class="tok-type">usize</span>, ret_addr: <span class="tok-type">usize</span>) <span class="tok-type">bool</span> {</span>
<span class="line" id="L211"> <span class="tok-kw">const</span> self: *ArenaAllocator = <span class="tok-builtin">@ptrCast</span>(<span class="tok-builtin">@alignCast</span>(ctx));</span>
<span class="line" id="L212"> _ = log2_buf_align;</span>
<span class="line" id="L213"> _ = ret_addr;</span>
<span class="line" id="L214"></span>
<span class="line" id="L215"> <span class="tok-kw">const</span> cur_node = self.state.buffer_list.first <span class="tok-kw">orelse</span> <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L216"> <span class="tok-kw">const</span> cur_buf = <span class="tok-builtin">@as</span>([*]<span class="tok-type">u8</span>, <span class="tok-builtin">@ptrCast</span>(cur_node))[<span class="tok-builtin">@sizeOf</span>(BufNode)..cur_node.data];</span>
<span class="line" id="L217"> <span class="tok-kw">if</span> (<span class="tok-builtin">@intFromPtr</span>(cur_buf.ptr) + self.state.end_index != <span class="tok-builtin">@intFromPtr</span>(buf.ptr) + buf.len) {</span>
<span class="line" id="L218"> <span class="tok-comment">// It's not the most recent allocation, so it cannot be expanded,</span>
</span>
<span class="line" id="L219"> <span class="tok-comment">// but it's fine if they want to make it smaller.</span>
</span>
<span class="line" id="L220"> <span class="tok-kw">return</span> new_len <= buf.len;</span>
<span class="line" id="L221"> }</span>
<span class="line" id="L222"></span>
<span class="line" id="L223"> <span class="tok-kw">if</span> (buf.len >= new_len) {</span>
<span class="line" id="L224"> self.state.end_index -= buf.len - new_len;</span>
<span class="line" id="L225"> <span class="tok-kw">return</span> <span class="tok-null">true</span>;</span>
<span class="line" id="L226"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (cur_buf.len - self.state.end_index >= new_len - buf.len) {</span>
<span class="line" id="L227"> self.state.end_index += new_len - buf.len;</span>
<span class="line" id="L228"> <span class="tok-kw">return</span> <span class="tok-null">true</span>;</span>
<span class="line" id="L229"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L230"> <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L231"> }</span>
<span class="line" id="L232"> }</span>
<span class="line" id="L233"></span>
<span class="line" id="L234"> <span class="tok-kw">fn</span> <span class="tok-fn">free</span>(ctx: *<span class="tok-type">anyopaque</span>, buf: []<span class="tok-type">u8</span>, log2_buf_align: <span class="tok-type">u8</span>, ret_addr: <span class="tok-type">usize</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L235"> _ = log2_buf_align;</span>
<span class="line" id="L236"> _ = ret_addr;</span>
<span class="line" id="L237"></span>
<span class="line" id="L238"> <span class="tok-kw">const</span> self: *ArenaAllocator = <span class="tok-builtin">@ptrCast</span>(<span class="tok-builtin">@alignCast</span>(ctx));</span>
<span class="line" id="L239"></span>
<span class="line" id="L240"> <span class="tok-kw">const</span> cur_node = self.state.buffer_list.first <span class="tok-kw">orelse</span> <span class="tok-kw">return</span>;</span>
<span class="line" id="L241"> <span class="tok-kw">const</span> cur_buf = <span class="tok-builtin">@as</span>([*]<span class="tok-type">u8</span>, <span class="tok-builtin">@ptrCast</span>(cur_node))[<span class="tok-builtin">@sizeOf</span>(BufNode)..cur_node.data];</span>
<span class="line" id="L242"></span>
<span class="line" id="L243"> <span class="tok-kw">if</span> (<span class="tok-builtin">@intFromPtr</span>(cur_buf.ptr) + self.state.end_index == <span class="tok-builtin">@intFromPtr</span>(buf.ptr) + buf.len) {</span>
<span class="line" id="L244"> self.state.end_index -= buf.len;</span>
<span class="line" id="L245"> }</span>
<span class="line" id="L246"> }</span>
<span class="line" id="L247">};</span>
<span class="line" id="L248"></span>
<span class="line" id="L249"><span class="tok-kw">test</span> <span class="tok-str">"ArenaAllocator (reset with preheating)"</span> {</span>
<span class="line" id="L250"> <span class="tok-kw">var</span> arena_allocator = ArenaAllocator.init(std.testing.allocator);</span>
<span class="line" id="L251"> <span class="tok-kw">defer</span> arena_allocator.deinit();</span>
<span class="line" id="L252"> <span class="tok-comment">// provides some variance in the allocated data</span>
</span>
<span class="line" id="L253"> <span class="tok-kw">var</span> rng_src = std.rand.DefaultPrng.init(<span class="tok-number">19930913</span>);</span>
<span class="line" id="L254"> <span class="tok-kw">const</span> random = rng_src.random();</span>
<span class="line" id="L255"> <span class="tok-kw">var</span> rounds: <span class="tok-type">usize</span> = <span class="tok-number">25</span>;</span>
<span class="line" id="L256"> <span class="tok-kw">while</span> (rounds > <span class="tok-number">0</span>) {</span>
<span class="line" id="L257"> rounds -= <span class="tok-number">1</span>;</span>
<span class="line" id="L258"> _ = arena_allocator.reset(.retain_capacity);</span>
<span class="line" id="L259"> <span class="tok-kw">var</span> alloced_bytes: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L260"> <span class="tok-kw">var</span> total_size: <span class="tok-type">usize</span> = random.intRangeAtMost(<span class="tok-type">usize</span>, <span class="tok-number">256</span>, <span class="tok-number">16384</span>);</span>
<span class="line" id="L261"> <span class="tok-kw">while</span> (alloced_bytes < total_size) {</span>
<span class="line" id="L262"> <span class="tok-kw">const</span> size = random.intRangeAtMost(<span class="tok-type">usize</span>, <span class="tok-number">16</span>, <span class="tok-number">256</span>);</span>
<span class="line" id="L263"> <span class="tok-kw">const</span> alignment = <span class="tok-number">32</span>;</span>
<span class="line" id="L264"> <span class="tok-kw">const</span> slice = <span class="tok-kw">try</span> arena_allocator.allocator().alignedAlloc(<span class="tok-type">u8</span>, alignment, size);</span>
<span class="line" id="L265"> <span class="tok-kw">try</span> std.testing.expect(std.mem.isAligned(<span class="tok-builtin">@intFromPtr</span>(slice.ptr), alignment));</span>
<span class="line" id="L266"> <span class="tok-kw">try</span> std.testing.expectEqual(size, slice.len);</span>
<span class="line" id="L267"> alloced_bytes += slice.len;</span>
<span class="line" id="L268"> }</span>
<span class="line" id="L269"> }</span>
<span class="line" id="L270">}</span>
<span class="line" id="L271"></span>
<span class="line" id="L272"><span class="tok-kw">test</span> <span class="tok-str">"ArenaAllocator (reset while retaining a buffer)"</span> {</span>
<span class="line" id="L273"> <span class="tok-kw">var</span> arena_allocator = ArenaAllocator.init(std.testing.allocator);</span>
<span class="line" id="L274"> <span class="tok-kw">defer</span> arena_allocator.deinit();</span>
<span class="line" id="L275"> <span class="tok-kw">const</span> a = arena_allocator.allocator();</span>
<span class="line" id="L276"></span>
<span class="line" id="L277"> <span class="tok-comment">// Create two internal buffers</span>
</span>
<span class="line" id="L278"> _ = <span class="tok-kw">try</span> a.alloc(<span class="tok-type">u8</span>, <span class="tok-number">1</span>);</span>
<span class="line" id="L279"> _ = <span class="tok-kw">try</span> a.alloc(<span class="tok-type">u8</span>, <span class="tok-number">1000</span>);</span>
<span class="line" id="L280"></span>
<span class="line" id="L281"> <span class="tok-comment">// Check that we have at least two buffers</span>
</span>
<span class="line" id="L282"> <span class="tok-kw">try</span> std.testing.expect(arena_allocator.state.buffer_list.first.?.next != <span class="tok-null">null</span>);</span>
<span class="line" id="L283"></span>
<span class="line" id="L284"> <span class="tok-comment">// This retains the first allocated buffer</span>
</span>
<span class="line" id="L285"> <span class="tok-kw">try</span> std.testing.expect(arena_allocator.reset(.{ .retain_with_limit = <span class="tok-number">1</span> }));</span>
<span class="line" id="L286">}</span>
<span class="line" id="L287"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/io/change_detection_stream.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>io/change_detection_stream.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../std.zig"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> io = std.io;</span>
<span class="line" id="L3"><span class="tok-kw">const</span> mem = std.mem;</span>
<span class="line" id="L4"><span class="tok-kw">const</span> assert = std.debug.assert;</span>
<span class="line" id="L5"></span>
<span class="line" id="L6"><span class="tok-comment">/// Used to detect if the data written to a stream differs from a source buffer</span></span>
<span class="line" id="L7"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">ChangeDetectionStream</span>(<span class="tok-kw">comptime</span> WriterType: <span class="tok-type">type</span>) <span class="tok-type">type</span> {</span>
<span class="line" id="L8"> <span class="tok-kw">return</span> <span class="tok-kw">struct</span> {</span>
<span class="line" id="L9"> <span class="tok-kw">const</span> Self = <span class="tok-builtin">@This</span>();</span>
<span class="line" id="L10"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> Error = WriterType.Error;</span>
<span class="line" id="L11"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> Writer = io.Writer(*Self, Error, write);</span>
<span class="line" id="L12"></span>
<span class="line" id="L13"> anything_changed: <span class="tok-type">bool</span>,</span>
<span class="line" id="L14"> underlying_writer: WriterType,</span>
<span class="line" id="L15"> source_index: <span class="tok-type">usize</span>,</span>
<span class="line" id="L16"> source: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L17"></span>
<span class="line" id="L18"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">writer</span>(self: *Self) Writer {</span>
<span class="line" id="L19"> <span class="tok-kw">return</span> .{ .context = self };</span>
<span class="line" id="L20"> }</span>
<span class="line" id="L21"></span>
<span class="line" id="L22"> <span class="tok-kw">fn</span> <span class="tok-fn">write</span>(self: *Self, bytes: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) Error!<span class="tok-type">usize</span> {</span>
<span class="line" id="L23"> <span class="tok-kw">if</span> (!self.anything_changed) {</span>
<span class="line" id="L24"> <span class="tok-kw">const</span> end = self.source_index + bytes.len;</span>
<span class="line" id="L25"> <span class="tok-kw">if</span> (end > self.source.len) {</span>
<span class="line" id="L26"> self.anything_changed = <span class="tok-null">true</span>;</span>
<span class="line" id="L27"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L28"> <span class="tok-kw">const</span> src_slice = self.source[self.source_index..end];</span>
<span class="line" id="L29"> self.source_index += bytes.len;</span>
<span class="line" id="L30"> <span class="tok-kw">if</span> (!mem.eql(<span class="tok-type">u8</span>, bytes, src_slice)) {</span>
<span class="line" id="L31"> self.anything_changed = <span class="tok-null">true</span>;</span>
<span class="line" id="L32"> }</span>
<span class="line" id="L33"> }</span>
<span class="line" id="L34"> }</span>
<span class="line" id="L35"></span>
<span class="line" id="L36"> <span class="tok-kw">return</span> self.underlying_writer.write(bytes);</span>
<span class="line" id="L37"> }</span>
<span class="line" id="L38"></span>
<span class="line" id="L39"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">changeDetected</span>(self: *Self) <span class="tok-type">bool</span> {</span>
<span class="line" id="L40"> <span class="tok-kw">return</span> self.anything_changed <span class="tok-kw">or</span> (self.source_index != self.source.len);</span>
<span class="line" id="L41"> }</span>
<span class="line" id="L42"> };</span>
<span class="line" id="L43">}</span>
<span class="line" id="L44"></span>
<span class="line" id="L45"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">changeDetectionStream</span>(</span>
<span class="line" id="L46"> source: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L47"> underlying_writer: <span class="tok-kw">anytype</span>,</span>
<span class="line" id="L48">) ChangeDetectionStream(<span class="tok-builtin">@TypeOf</span>(underlying_writer)) {</span>
<span class="line" id="L49"> <span class="tok-kw">return</span> ChangeDetectionStream(<span class="tok-builtin">@TypeOf</span>(underlying_writer)){</span>
<span class="line" id="L50"> .anything_changed = <span class="tok-null">false</span>,</span>
<span class="line" id="L51"> .underlying_writer = underlying_writer,</span>
<span class="line" id="L52"> .source_index = <span class="tok-number">0</span>,</span>
<span class="line" id="L53"> .source = source,</span>
<span class="line" id="L54"> };</span>
<span class="line" id="L55">}</span>
<span class="line" id="L56"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/io/counting_reader.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>io/counting_reader.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../std.zig"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> io = std.io;</span>
<span class="line" id="L3"><span class="tok-kw">const</span> testing = std.testing;</span>
<span class="line" id="L4"></span>
<span class="line" id="L5"><span class="tok-comment">/// A Reader that counts how many bytes has been read from it.</span></span>
<span class="line" id="L6"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">CountingReader</span>(<span class="tok-kw">comptime</span> ReaderType: <span class="tok-kw">anytype</span>) <span class="tok-type">type</span> {</span>
<span class="line" id="L7"> <span class="tok-kw">return</span> <span class="tok-kw">struct</span> {</span>
<span class="line" id="L8"> child_reader: ReaderType,</span>
<span class="line" id="L9"> bytes_read: <span class="tok-type">u64</span> = <span class="tok-number">0</span>,</span>
<span class="line" id="L10"></span>
<span class="line" id="L11"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> Error = ReaderType.Error;</span>
<span class="line" id="L12"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> Reader = io.Reader(*<span class="tok-builtin">@This</span>(), Error, read);</span>
<span class="line" id="L13"></span>
<span class="line" id="L14"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">read</span>(self: *<span class="tok-builtin">@This</span>(), buf: []<span class="tok-type">u8</span>) Error!<span class="tok-type">usize</span> {</span>
<span class="line" id="L15"> <span class="tok-kw">const</span> amt = <span class="tok-kw">try</span> self.child_reader.read(buf);</span>
<span class="line" id="L16"> self.bytes_read += amt;</span>
<span class="line" id="L17"> <span class="tok-kw">return</span> amt;</span>
<span class="line" id="L18"> }</span>
<span class="line" id="L19"></span>
<span class="line" id="L20"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">reader</span>(self: *<span class="tok-builtin">@This</span>()) Reader {</span>
<span class="line" id="L21"> <span class="tok-kw">return</span> .{ .context = self };</span>
<span class="line" id="L22"> }</span>
<span class="line" id="L23"> };</span>
<span class="line" id="L24">}</span>
<span class="line" id="L25"></span>
<span class="line" id="L26"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">countingReader</span>(reader: <span class="tok-kw">anytype</span>) CountingReader(<span class="tok-builtin">@TypeOf</span>(reader)) {</span>
<span class="line" id="L27"> <span class="tok-kw">return</span> .{ .child_reader = reader };</span>
<span class="line" id="L28">}</span>
<span class="line" id="L29"></span>
<span class="line" id="L30"><span class="tok-kw">test</span> <span class="tok-str">"io.CountingReader"</span> {</span>
<span class="line" id="L31"> <span class="tok-kw">const</span> bytes = <span class="tok-str">"yay"</span> ** <span class="tok-number">100</span>;</span>
<span class="line" id="L32"> <span class="tok-kw">var</span> fbs = io.fixedBufferStream(bytes);</span>
<span class="line" id="L33"></span>
<span class="line" id="L34"> <span class="tok-kw">var</span> counting_stream = countingReader(fbs.reader());</span>
<span class="line" id="L35"> <span class="tok-kw">const</span> stream = counting_stream.reader();</span>
<span class="line" id="L36"></span>
<span class="line" id="L37"> <span class="tok-comment">//read and discard all bytes</span>
</span>
<span class="line" id="L38"> <span class="tok-kw">while</span> (stream.readByte()) |_| {} <span class="tok-kw">else</span> |err| {</span>
<span class="line" id="L39"> <span class="tok-kw">try</span> testing.expect(err == <span class="tok-kw">error</span>.EndOfStream);</span>
<span class="line" id="L40"> }</span>
<span class="line" id="L41"></span>
<span class="line" id="L42"> <span class="tok-kw">try</span> testing.expect(counting_stream.bytes_read == bytes.len);</span>
<span class="line" id="L43">}</span>
<span class="line" id="L44"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/io/buffered_writer.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>io/buffered_writer.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../std.zig"</span>);</span>
<span class="line" id="L2"></span>
<span class="line" id="L3"><span class="tok-kw">const</span> io = std.io;</span>
<span class="line" id="L4"><span class="tok-kw">const</span> mem = std.mem;</span>
<span class="line" id="L5"></span>
<span class="line" id="L6"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">BufferedWriter</span>(<span class="tok-kw">comptime</span> buffer_size: <span class="tok-type">usize</span>, <span class="tok-kw">comptime</span> WriterType: <span class="tok-type">type</span>) <span class="tok-type">type</span> {</span>
<span class="line" id="L7"> <span class="tok-kw">return</span> <span class="tok-kw">struct</span> {</span>
<span class="line" id="L8"> unbuffered_writer: WriterType,</span>
<span class="line" id="L9"> buf: [buffer_size]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>,</span>
<span class="line" id="L10"> end: <span class="tok-type">usize</span> = <span class="tok-number">0</span>,</span>
<span class="line" id="L11"></span>
<span class="line" id="L12"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> Error = WriterType.Error;</span>
<span class="line" id="L13"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> Writer = io.Writer(*Self, Error, write);</span>
<span class="line" id="L14"></span>
<span class="line" id="L15"> <span class="tok-kw">const</span> Self = <span class="tok-builtin">@This</span>();</span>
<span class="line" id="L16"></span>
<span class="line" id="L17"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">flush</span>(self: *Self) !<span class="tok-type">void</span> {</span>
<span class="line" id="L18"> <span class="tok-kw">try</span> self.unbuffered_writer.writeAll(self.buf[<span class="tok-number">0</span>..self.end]);</span>
<span class="line" id="L19"> self.end = <span class="tok-number">0</span>;</span>
<span class="line" id="L20"> }</span>
<span class="line" id="L21"></span>
<span class="line" id="L22"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">writer</span>(self: *Self) Writer {</span>
<span class="line" id="L23"> <span class="tok-kw">return</span> .{ .context = self };</span>
<span class="line" id="L24"> }</span>
<span class="line" id="L25"></span>
<span class="line" id="L26"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">write</span>(self: *Self, bytes: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) Error!<span class="tok-type">usize</span> {</span>
<span class="line" id="L27"> <span class="tok-kw">if</span> (self.end + bytes.len > self.buf.len) {</span>
<span class="line" id="L28"> <span class="tok-kw">try</span> self.flush();</span>
<span class="line" id="L29"> <span class="tok-kw">if</span> (bytes.len > self.buf.len)</span>
<span class="line" id="L30"> <span class="tok-kw">return</span> self.unbuffered_writer.write(bytes);</span>
<span class="line" id="L31"> }</span>
<span class="line" id="L32"></span>
<span class="line" id="L33"> <span class="tok-kw">const</span> new_end = self.end + bytes.len;</span>
<span class="line" id="L34"> <span class="tok-builtin">@memcpy</span>(self.buf[self.end..new_end], bytes);</span>
<span class="line" id="L35"> self.end = new_end;</span>
<span class="line" id="L36"> <span class="tok-kw">return</span> bytes.len;</span>
<span class="line" id="L37"> }</span>
<span class="line" id="L38"> };</span>
<span class="line" id="L39">}</span>
<span class="line" id="L40"></span>
<span class="line" id="L41"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">bufferedWriter</span>(underlying_stream: <span class="tok-kw">anytype</span>) BufferedWriter(<span class="tok-number">4096</span>, <span class="tok-builtin">@TypeOf</span>(underlying_stream)) {</span>
<span class="line" id="L42"> <span class="tok-kw">return</span> .{ .unbuffered_writer = underlying_stream };</span>
<span class="line" id="L43">}</span>
<span class="line" id="L44"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/io/stream_source.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>io/stream_source.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../std.zig"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> builtin = <span class="tok-builtin">@import</span>(<span class="tok-str">"builtin"</span>);</span>
<span class="line" id="L3"><span class="tok-kw">const</span> io = std.io;</span>
<span class="line" id="L4"></span>
<span class="line" id="L5"><span class="tok-comment">/// Provides `io.Reader`, `io.Writer`, and `io.SeekableStream` for in-memory buffers as</span></span>
<span class="line" id="L6"><span class="tok-comment">/// well as files.</span></span>
<span class="line" id="L7"><span class="tok-comment">/// For memory sources, if the supplied byte buffer is const, then `io.Writer` is not available.</span></span>
<span class="line" id="L8"><span class="tok-comment">/// The error set of the stream functions is the error set of the corresponding file functions.</span></span>
<span class="line" id="L9"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> StreamSource = <span class="tok-kw">union</span>(<span class="tok-kw">enum</span>) {</span>
<span class="line" id="L10"> <span class="tok-comment">// TODO: expose UEFI files to std.os in a way that allows this to be true</span>
</span>
<span class="line" id="L11"> <span class="tok-kw">const</span> has_file = (builtin.os.tag != .freestanding <span class="tok-kw">and</span> builtin.os.tag != .uefi);</span>
<span class="line" id="L12"></span>
<span class="line" id="L13"> <span class="tok-comment">/// The stream access is redirected to this buffer.</span></span>
<span class="line" id="L14"> buffer: io.FixedBufferStream([]<span class="tok-type">u8</span>),</span>
<span class="line" id="L15"></span>
<span class="line" id="L16"> <span class="tok-comment">/// The stream access is redirected to this buffer.</span></span>
<span class="line" id="L17"> <span class="tok-comment">/// Writing to the source will always yield `error.AccessDenied`.</span></span>
<span class="line" id="L18"> const_buffer: io.FixedBufferStream([]<span class="tok-kw">const</span> <span class="tok-type">u8</span>),</span>
<span class="line" id="L19"></span>
<span class="line" id="L20"> <span class="tok-comment">/// The stream access is redirected to this file.</span></span>
<span class="line" id="L21"> <span class="tok-comment">/// On freestanding, this must never be initialized!</span></span>
<span class="line" id="L22"> file: <span class="tok-kw">if</span> (has_file) std.fs.File <span class="tok-kw">else</span> <span class="tok-type">void</span>,</span>
<span class="line" id="L23"></span>
<span class="line" id="L24"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> ReadError = io.FixedBufferStream([]<span class="tok-type">u8</span>).ReadError || (<span class="tok-kw">if</span> (has_file) std.fs.File.ReadError <span class="tok-kw">else</span> <span class="tok-kw">error</span>{});</span>
<span class="line" id="L25"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> WriteError = <span class="tok-kw">error</span>{AccessDenied} || io.FixedBufferStream([]<span class="tok-type">u8</span>).WriteError || (<span class="tok-kw">if</span> (has_file) std.fs.File.WriteError <span class="tok-kw">else</span> <span class="tok-kw">error</span>{});</span>
<span class="line" id="L26"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> SeekError = io.FixedBufferStream([]<span class="tok-type">u8</span>).SeekError || (<span class="tok-kw">if</span> (has_file) std.fs.File.SeekError <span class="tok-kw">else</span> <span class="tok-kw">error</span>{});</span>
<span class="line" id="L27"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> GetSeekPosError = io.FixedBufferStream([]<span class="tok-type">u8</span>).GetSeekPosError || (<span class="tok-kw">if</span> (has_file) std.fs.File.GetSeekPosError <span class="tok-kw">else</span> <span class="tok-kw">error</span>{});</span>
<span class="line" id="L28"></span>
<span class="line" id="L29"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> Reader = io.Reader(*StreamSource, ReadError, read);</span>
<span class="line" id="L30"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> Writer = io.Writer(*StreamSource, WriteError, write);</span>
<span class="line" id="L31"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> SeekableStream = io.SeekableStream(</span>
<span class="line" id="L32"> *StreamSource,</span>
<span class="line" id="L33"> SeekError,</span>
<span class="line" id="L34"> GetSeekPosError,</span>
<span class="line" id="L35"> seekTo,</span>
<span class="line" id="L36"> seekBy,</span>
<span class="line" id="L37"> getPos,</span>
<span class="line" id="L38"> getEndPos,</span>
<span class="line" id="L39"> );</span>
<span class="line" id="L40"></span>
<span class="line" id="L41"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">read</span>(self: *StreamSource, dest: []<span class="tok-type">u8</span>) ReadError!<span class="tok-type">usize</span> {</span>
<span class="line" id="L42"> <span class="tok-kw">switch</span> (self.*) {</span>
<span class="line" id="L43"> .buffer => |*x| <span class="tok-kw">return</span> x.read(dest),</span>
<span class="line" id="L44"> .const_buffer => |*x| <span class="tok-kw">return</span> x.read(dest),</span>
<span class="line" id="L45"> .file => |x| <span class="tok-kw">if</span> (!has_file) <span class="tok-kw">unreachable</span> <span class="tok-kw">else</span> <span class="tok-kw">return</span> x.read(dest),</span>
<span class="line" id="L46"> }</span>
<span class="line" id="L47"> }</span>
<span class="line" id="L48"></span>
<span class="line" id="L49"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">write</span>(self: *StreamSource, bytes: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) WriteError!<span class="tok-type">usize</span> {</span>
<span class="line" id="L50"> <span class="tok-kw">switch</span> (self.*) {</span>
<span class="line" id="L51"> .buffer => |*x| <span class="tok-kw">return</span> x.write(bytes),</span>
<span class="line" id="L52"> .const_buffer => <span class="tok-kw">return</span> <span class="tok-kw">error</span>.AccessDenied,</span>
<span class="line" id="L53"> .file => |x| <span class="tok-kw">if</span> (!has_file) <span class="tok-kw">unreachable</span> <span class="tok-kw">else</span> <span class="tok-kw">return</span> x.write(bytes),</span>
<span class="line" id="L54"> }</span>
<span class="line" id="L55"> }</span>
<span class="line" id="L56"></span>
<span class="line" id="L57"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">seekTo</span>(self: *StreamSource, pos: <span class="tok-type">u64</span>) SeekError!<span class="tok-type">void</span> {</span>
<span class="line" id="L58"> <span class="tok-kw">switch</span> (self.*) {</span>
<span class="line" id="L59"> .buffer => |*x| <span class="tok-kw">return</span> x.seekTo(pos),</span>
<span class="line" id="L60"> .const_buffer => |*x| <span class="tok-kw">return</span> x.seekTo(pos),</span>
<span class="line" id="L61"> .file => |x| <span class="tok-kw">if</span> (!has_file) <span class="tok-kw">unreachable</span> <span class="tok-kw">else</span> <span class="tok-kw">return</span> x.seekTo(pos),</span>
<span class="line" id="L62"> }</span>
<span class="line" id="L63"> }</span>
<span class="line" id="L64"></span>
<span class="line" id="L65"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">seekBy</span>(self: *StreamSource, amt: <span class="tok-type">i64</span>) SeekError!<span class="tok-type">void</span> {</span>
<span class="line" id="L66"> <span class="tok-kw">switch</span> (self.*) {</span>
<span class="line" id="L67"> .buffer => |*x| <span class="tok-kw">return</span> x.seekBy(amt),</span>
<span class="line" id="L68"> .const_buffer => |*x| <span class="tok-kw">return</span> x.seekBy(amt),</span>
<span class="line" id="L69"> .file => |x| <span class="tok-kw">if</span> (!has_file) <span class="tok-kw">unreachable</span> <span class="tok-kw">else</span> <span class="tok-kw">return</span> x.seekBy(amt),</span>
<span class="line" id="L70"> }</span>
<span class="line" id="L71"> }</span>
<span class="line" id="L72"></span>
<span class="line" id="L73"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">getEndPos</span>(self: *StreamSource) GetSeekPosError!<span class="tok-type">u64</span> {</span>
<span class="line" id="L74"> <span class="tok-kw">switch</span> (self.*) {</span>
<span class="line" id="L75"> .buffer => |*x| <span class="tok-kw">return</span> x.getEndPos(),</span>
<span class="line" id="L76"> .const_buffer => |*x| <span class="tok-kw">return</span> x.getEndPos(),</span>
<span class="line" id="L77"> .file => |x| <span class="tok-kw">if</span> (!has_file) <span class="tok-kw">unreachable</span> <span class="tok-kw">else</span> <span class="tok-kw">return</span> x.getEndPos(),</span>
<span class="line" id="L78"> }</span>
<span class="line" id="L79"> }</span>
<span class="line" id="L80"></span>
<span class="line" id="L81"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">getPos</span>(self: *StreamSource) GetSeekPosError!<span class="tok-type">u64</span> {</span>
<span class="line" id="L82"> <span class="tok-kw">switch</span> (self.*) {</span>
<span class="line" id="L83"> .buffer => |*x| <span class="tok-kw">return</span> x.getPos(),</span>
<span class="line" id="L84"> .const_buffer => |*x| <span class="tok-kw">return</span> x.getPos(),</span>
<span class="line" id="L85"> .file => |x| <span class="tok-kw">if</span> (!has_file) <span class="tok-kw">unreachable</span> <span class="tok-kw">else</span> <span class="tok-kw">return</span> x.getPos(),</span>
<span class="line" id="L86"> }</span>
<span class="line" id="L87"> }</span>
<span class="line" id="L88"></span>
<span class="line" id="L89"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">reader</span>(self: *StreamSource) Reader {</span>
<span class="line" id="L90"> <span class="tok-kw">return</span> .{ .context = self };</span>
<span class="line" id="L91"> }</span>
<span class="line" id="L92"></span>
<span class="line" id="L93"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">writer</span>(self: *StreamSource) Writer {</span>
<span class="line" id="L94"> <span class="tok-kw">return</span> .{ .context = self };</span>
<span class="line" id="L95"> }</span>
<span class="line" id="L96"></span>
<span class="line" id="L97"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">seekableStream</span>(self: *StreamSource) SeekableStream {</span>
<span class="line" id="L98"> <span class="tok-kw">return</span> .{ .context = self };</span>
<span class="line" id="L99"> }</span>
<span class="line" id="L100">};</span>
<span class="line" id="L101"></span>
<span class="line" id="L102"><span class="tok-kw">test</span> <span class="tok-str">"StreamSource (refs)"</span> {</span>
<span class="line" id="L103"> std.testing.refAllDecls(StreamSource);</span>
<span class="line" id="L104">}</span>
<span class="line" id="L105"></span>
<span class="line" id="L106"><span class="tok-kw">test</span> <span class="tok-str">"StreamSource (mutable buffer)"</span> {</span>
<span class="line" id="L107"> <span class="tok-kw">var</span> buffer: [<span class="tok-number">64</span>]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L108"> <span class="tok-kw">var</span> source = StreamSource{ .buffer = std.io.fixedBufferStream(&buffer) };</span>
<span class="line" id="L109"></span>
<span class="line" id="L110"> <span class="tok-kw">var</span> writer = source.writer();</span>
<span class="line" id="L111"></span>
<span class="line" id="L112"> <span class="tok-kw">try</span> writer.writeAll(<span class="tok-str">"Hello, World!"</span>);</span>
<span class="line" id="L113"></span>
<span class="line" id="L114"> <span class="tok-kw">try</span> std.testing.expectEqualStrings(<span class="tok-str">"Hello, World!"</span>, source.buffer.getWritten());</span>
<span class="line" id="L115">}</span>
<span class="line" id="L116"></span>
<span class="line" id="L117"><span class="tok-kw">test</span> <span class="tok-str">"StreamSource (const buffer)"</span> {</span>
<span class="line" id="L118"> <span class="tok-kw">const</span> buffer: [<span class="tok-number">64</span>]<span class="tok-type">u8</span> = <span class="tok-str">"Hello, World!"</span>.* ++ ([<span class="tok-number">1</span>]<span class="tok-type">u8</span>{<span class="tok-number">0xAA</span>} ** <span class="tok-number">51</span>);</span>
<span class="line" id="L119"> <span class="tok-kw">var</span> source = StreamSource{ .const_buffer = std.io.fixedBufferStream(&buffer) };</span>
<span class="line" id="L120"></span>
<span class="line" id="L121"> <span class="tok-kw">var</span> reader = source.reader();</span>
<span class="line" id="L122"></span>
<span class="line" id="L123"> <span class="tok-kw">var</span> dst_buffer: [<span class="tok-number">13</span>]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L124"> <span class="tok-kw">try</span> reader.readNoEof(&dst_buffer);</span>
<span class="line" id="L125"></span>
<span class="line" id="L126"> <span class="tok-kw">try</span> std.testing.expectEqualStrings(<span class="tok-str">"Hello, World!"</span>, &dst_buffer);</span>
<span class="line" id="L127">}</span>
<span class="line" id="L128"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/io/limited_reader.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>io/limited_reader.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../std.zig"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> io = std.io;</span>
<span class="line" id="L3"><span class="tok-kw">const</span> assert = std.debug.assert;</span>
<span class="line" id="L4"><span class="tok-kw">const</span> testing = std.testing;</span>
<span class="line" id="L5"></span>
<span class="line" id="L6"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">LimitedReader</span>(<span class="tok-kw">comptime</span> ReaderType: <span class="tok-type">type</span>) <span class="tok-type">type</span> {</span>
<span class="line" id="L7"> <span class="tok-kw">return</span> <span class="tok-kw">struct</span> {</span>
<span class="line" id="L8"> inner_reader: ReaderType,</span>
<span class="line" id="L9"> bytes_left: <span class="tok-type">u64</span>,</span>
<span class="line" id="L10"></span>
<span class="line" id="L11"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> Error = ReaderType.Error;</span>
<span class="line" id="L12"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> Reader = io.Reader(*Self, Error, read);</span>
<span class="line" id="L13"></span>
<span class="line" id="L14"> <span class="tok-kw">const</span> Self = <span class="tok-builtin">@This</span>();</span>
<span class="line" id="L15"></span>
<span class="line" id="L16"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">read</span>(self: *Self, dest: []<span class="tok-type">u8</span>) Error!<span class="tok-type">usize</span> {</span>
<span class="line" id="L17"> <span class="tok-kw">const</span> max_read = <span class="tok-builtin">@min</span>(self.bytes_left, dest.len);</span>
<span class="line" id="L18"> <span class="tok-kw">const</span> n = <span class="tok-kw">try</span> self.inner_reader.read(dest[<span class="tok-number">0</span>..max_read]);</span>
<span class="line" id="L19"> self.bytes_left -= n;</span>
<span class="line" id="L20"> <span class="tok-kw">return</span> n;</span>
<span class="line" id="L21"> }</span>
<span class="line" id="L22"></span>
<span class="line" id="L23"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">reader</span>(self: *Self) Reader {</span>
<span class="line" id="L24"> <span class="tok-kw">return</span> .{ .context = self };</span>
<span class="line" id="L25"> }</span>
<span class="line" id="L26"> };</span>
<span class="line" id="L27">}</span>
<span class="line" id="L28"></span>
<span class="line" id="L29"><span class="tok-comment">/// Returns an initialised `LimitedReader`</span></span>
<span class="line" id="L30"><span class="tok-comment">/// `bytes_left` is a `u64` to be able to take 64 bit file offsets</span></span>
<span class="line" id="L31"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">limitedReader</span>(inner_reader: <span class="tok-kw">anytype</span>, bytes_left: <span class="tok-type">u64</span>) LimitedReader(<span class="tok-builtin">@TypeOf</span>(inner_reader)) {</span>
<span class="line" id="L32"> <span class="tok-kw">return</span> .{ .inner_reader = inner_reader, .bytes_left = bytes_left };</span>
<span class="line" id="L33">}</span>
<span class="line" id="L34"></span>
<span class="line" id="L35"><span class="tok-kw">test</span> <span class="tok-str">"basic usage"</span> {</span>
<span class="line" id="L36"> <span class="tok-kw">const</span> data = <span class="tok-str">"hello world"</span>;</span>
<span class="line" id="L37"> <span class="tok-kw">var</span> fbs = std.io.fixedBufferStream(data);</span>
<span class="line" id="L38"> <span class="tok-kw">var</span> early_stream = limitedReader(fbs.reader(), <span class="tok-number">3</span>);</span>
<span class="line" id="L39"></span>
<span class="line" id="L40"> <span class="tok-kw">var</span> buf: [<span class="tok-number">5</span>]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L41"> <span class="tok-kw">try</span> testing.expectEqual(<span class="tok-builtin">@as</span>(<span class="tok-type">usize</span>, <span class="tok-number">3</span>), <span class="tok-kw">try</span> early_stream.reader().read(&buf));</span>
<span class="line" id="L42"> <span class="tok-kw">try</span> testing.expectEqualSlices(<span class="tok-type">u8</span>, data[<span class="tok-number">0</span>..<span class="tok-number">3</span>], buf[<span class="tok-number">0</span>..<span class="tok-number">3</span>]);</span>
<span class="line" id="L43"> <span class="tok-kw">try</span> testing.expectEqual(<span class="tok-builtin">@as</span>(<span class="tok-type">usize</span>, <span class="tok-number">0</span>), <span class="tok-kw">try</span> early_stream.reader().read(&buf));</span>
<span class="line" id="L44"> <span class="tok-kw">try</span> testing.expectError(<span class="tok-kw">error</span>.EndOfStream, early_stream.reader().skipBytes(<span class="tok-number">10</span>, .{}));</span>
<span class="line" id="L45">}</span>
<span class="line" id="L46"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/io/peek_stream.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>io/peek_stream.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../std.zig"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> io = std.io;</span>
<span class="line" id="L3"><span class="tok-kw">const</span> mem = std.mem;</span>
<span class="line" id="L4"><span class="tok-kw">const</span> testing = std.testing;</span>
<span class="line" id="L5"></span>
<span class="line" id="L6"><span class="tok-comment">/// Creates a stream which supports 'un-reading' data, so that it can be read again.</span></span>
<span class="line" id="L7"><span class="tok-comment">/// This makes look-ahead style parsing much easier.</span></span>
<span class="line" id="L8"><span class="tok-comment">/// TODO merge this with `std.io.BufferedReader`: https://github.com/ziglang/zig/issues/4501</span></span>
<span class="line" id="L9"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">PeekStream</span>(</span>
<span class="line" id="L10"> <span class="tok-kw">comptime</span> buffer_type: std.fifo.LinearFifoBufferType,</span>
<span class="line" id="L11"> <span class="tok-kw">comptime</span> ReaderType: <span class="tok-type">type</span>,</span>
<span class="line" id="L12">) <span class="tok-type">type</span> {</span>
<span class="line" id="L13"> <span class="tok-kw">return</span> <span class="tok-kw">struct</span> {</span>
<span class="line" id="L14"> unbuffered_reader: ReaderType,</span>
<span class="line" id="L15"> fifo: FifoType,</span>
<span class="line" id="L16"></span>
<span class="line" id="L17"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> Error = ReaderType.Error;</span>
<span class="line" id="L18"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> Reader = io.Reader(*Self, Error, read);</span>
<span class="line" id="L19"></span>
<span class="line" id="L20"> <span class="tok-kw">const</span> Self = <span class="tok-builtin">@This</span>();</span>
<span class="line" id="L21"> <span class="tok-kw">const</span> FifoType = std.fifo.LinearFifo(<span class="tok-type">u8</span>, buffer_type);</span>
<span class="line" id="L22"></span>
<span class="line" id="L23"> <span class="tok-kw">pub</span> <span class="tok-kw">usingnamespace</span> <span class="tok-kw">switch</span> (buffer_type) {</span>
<span class="line" id="L24"> .Static => <span class="tok-kw">struct</span> {</span>
<span class="line" id="L25"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">init</span>(base: ReaderType) Self {</span>
<span class="line" id="L26"> <span class="tok-kw">return</span> .{</span>
<span class="line" id="L27"> .unbuffered_reader = base,</span>
<span class="line" id="L28"> .fifo = FifoType.init(),</span>
<span class="line" id="L29"> };</span>
<span class="line" id="L30"> }</span>
<span class="line" id="L31"> },</span>
<span class="line" id="L32"> .Slice => <span class="tok-kw">struct</span> {</span>
<span class="line" id="L33"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">init</span>(base: ReaderType, buf: []<span class="tok-type">u8</span>) Self {</span>
<span class="line" id="L34"> <span class="tok-kw">return</span> .{</span>
<span class="line" id="L35"> .unbuffered_reader = base,</span>
<span class="line" id="L36"> .fifo = FifoType.init(buf),</span>
<span class="line" id="L37"> };</span>
<span class="line" id="L38"> }</span>
<span class="line" id="L39"> },</span>
<span class="line" id="L40"> .Dynamic => <span class="tok-kw">struct</span> {</span>
<span class="line" id="L41"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">init</span>(base: ReaderType, allocator: mem.Allocator) Self {</span>
<span class="line" id="L42"> <span class="tok-kw">return</span> .{</span>
<span class="line" id="L43"> .unbuffered_reader = base,</span>
<span class="line" id="L44"> .fifo = FifoType.init(allocator),</span>
<span class="line" id="L45"> };</span>
<span class="line" id="L46"> }</span>
<span class="line" id="L47"> },</span>
<span class="line" id="L48"> };</span>
<span class="line" id="L49"></span>
<span class="line" id="L50"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">putBackByte</span>(self: *Self, byte: <span class="tok-type">u8</span>) !<span class="tok-type">void</span> {</span>
<span class="line" id="L51"> <span class="tok-kw">try</span> self.putBack(&[_]<span class="tok-type">u8</span>{byte});</span>
<span class="line" id="L52"> }</span>
<span class="line" id="L53"></span>
<span class="line" id="L54"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">putBack</span>(self: *Self, bytes: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) !<span class="tok-type">void</span> {</span>
<span class="line" id="L55"> <span class="tok-kw">try</span> self.fifo.unget(bytes);</span>
<span class="line" id="L56"> }</span>
<span class="line" id="L57"></span>
<span class="line" id="L58"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">read</span>(self: *Self, dest: []<span class="tok-type">u8</span>) Error!<span class="tok-type">usize</span> {</span>
<span class="line" id="L59"> <span class="tok-comment">// copy over anything putBack()'d</span>
</span>
<span class="line" id="L60"> <span class="tok-kw">var</span> dest_index = self.fifo.read(dest);</span>
<span class="line" id="L61"> <span class="tok-kw">if</span> (dest_index == dest.len) <span class="tok-kw">return</span> dest_index;</span>
<span class="line" id="L62"></span>
<span class="line" id="L63"> <span class="tok-comment">// ask the backing stream for more</span>
</span>
<span class="line" id="L64"> dest_index += <span class="tok-kw">try</span> self.unbuffered_reader.read(dest[dest_index..]);</span>
<span class="line" id="L65"> <span class="tok-kw">return</span> dest_index;</span>
<span class="line" id="L66"> }</span>
<span class="line" id="L67"></span>
<span class="line" id="L68"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">reader</span>(self: *Self) Reader {</span>
<span class="line" id="L69"> <span class="tok-kw">return</span> .{ .context = self };</span>
<span class="line" id="L70"> }</span>
<span class="line" id="L71"> };</span>
<span class="line" id="L72">}</span>
<span class="line" id="L73"></span>
<span class="line" id="L74"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">peekStream</span>(</span>
<span class="line" id="L75"> <span class="tok-kw">comptime</span> lookahead: <span class="tok-type">comptime_int</span>,</span>
<span class="line" id="L76"> underlying_stream: <span class="tok-kw">anytype</span>,</span>
<span class="line" id="L77">) PeekStream(.{ .Static = lookahead }, <span class="tok-builtin">@TypeOf</span>(underlying_stream)) {</span>
<span class="line" id="L78"> <span class="tok-kw">return</span> PeekStream(.{ .Static = lookahead }, <span class="tok-builtin">@TypeOf</span>(underlying_stream)).init(underlying_stream);</span>
<span class="line" id="L79">}</span>
<span class="line" id="L80"></span>
<span class="line" id="L81"><span class="tok-kw">test</span> <span class="tok-str">"PeekStream"</span> {</span>
<span class="line" id="L82"> <span class="tok-kw">const</span> bytes = [_]<span class="tok-type">u8</span>{ <span class="tok-number">1</span>, <span class="tok-number">2</span>, <span class="tok-number">3</span>, <span class="tok-number">4</span>, <span class="tok-number">5</span>, <span class="tok-number">6</span>, <span class="tok-number">7</span>, <span class="tok-number">8</span> };</span>
<span class="line" id="L83"> <span class="tok-kw">var</span> fbs = io.fixedBufferStream(&bytes);</span>
<span class="line" id="L84"> <span class="tok-kw">var</span> ps = peekStream(<span class="tok-number">2</span>, fbs.reader());</span>
<span class="line" id="L85"></span>
<span class="line" id="L86"> <span class="tok-kw">var</span> dest: [<span class="tok-number">4</span>]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L87"></span>
<span class="line" id="L88"> <span class="tok-kw">try</span> ps.putBackByte(<span class="tok-number">9</span>);</span>
<span class="line" id="L89"> <span class="tok-kw">try</span> ps.putBackByte(<span class="tok-number">10</span>);</span>
<span class="line" id="L90"></span>
<span class="line" id="L91"> <span class="tok-kw">var</span> read = <span class="tok-kw">try</span> ps.reader().read(dest[<span class="tok-number">0</span>..<span class="tok-number">4</span>]);</span>
<span class="line" id="L92"> <span class="tok-kw">try</span> testing.expect(read == <span class="tok-number">4</span>);</span>
<span class="line" id="L93"> <span class="tok-kw">try</span> testing.expect(dest[<span class="tok-number">0</span>] == <span class="tok-number">10</span>);</span>
<span class="line" id="L94"> <span class="tok-kw">try</span> testing.expect(dest[<span class="tok-number">1</span>] == <span class="tok-number">9</span>);</span>
<span class="line" id="L95"> <span class="tok-kw">try</span> testing.expect(mem.eql(<span class="tok-type">u8</span>, dest[<span class="tok-number">2</span>..<span class="tok-number">4</span>], bytes[<span class="tok-number">0</span>..<span class="tok-number">2</span>]));</span>
<span class="line" id="L96"></span>
<span class="line" id="L97"> read = <span class="tok-kw">try</span> ps.reader().read(dest[<span class="tok-number">0</span>..<span class="tok-number">4</span>]);</span>
<span class="line" id="L98"> <span class="tok-kw">try</span> testing.expect(read == <span class="tok-number">4</span>);</span>
<span class="line" id="L99"> <span class="tok-kw">try</span> testing.expect(mem.eql(<span class="tok-type">u8</span>, dest[<span class="tok-number">0</span>..<span class="tok-number">4</span>], bytes[<span class="tok-number">2</span>..<span class="tok-number">6</span>]));</span>
<span class="line" id="L100"></span>
<span class="line" id="L101"> read = <span class="tok-kw">try</span> ps.reader().read(dest[<span class="tok-number">0</span>..<span class="tok-number">4</span>]);</span>
<span class="line" id="L102"> <span class="tok-kw">try</span> testing.expect(read == <span class="tok-number">2</span>);</span>
<span class="line" id="L103"> <span class="tok-kw">try</span> testing.expect(mem.eql(<span class="tok-type">u8</span>, dest[<span class="tok-number">0</span>..<span class="tok-number">2</span>], bytes[<span class="tok-number">6</span>..<span class="tok-number">8</span>]));</span>
<span class="line" id="L104"></span>
<span class="line" id="L105"> <span class="tok-kw">try</span> ps.putBackByte(<span class="tok-number">11</span>);</span>
<span class="line" id="L106"> <span class="tok-kw">try</span> ps.putBackByte(<span class="tok-number">12</span>);</span>
<span class="line" id="L107"></span>
<span class="line" id="L108"> read = <span class="tok-kw">try</span> ps.reader().read(dest[<span class="tok-number">0</span>..<span class="tok-number">4</span>]);</span>
<span class="line" id="L109"> <span class="tok-kw">try</span> testing.expect(read == <span class="tok-number">2</span>);</span>
<span class="line" id="L110"> <span class="tok-kw">try</span> testing.expect(dest[<span class="tok-number">0</span>] == <span class="tok-number">12</span>);</span>
<span class="line" id="L111"> <span class="tok-kw">try</span> testing.expect(dest[<span class="tok-number">1</span>] == <span class="tok-number">11</span>);</span>
<span class="line" id="L112">}</span>
<span class="line" id="L113"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/io/fixed_buffer_stream.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>io/fixed_buffer_stream.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../std.zig"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> io = std.io;</span>
<span class="line" id="L3"><span class="tok-kw">const</span> testing = std.testing;</span>
<span class="line" id="L4"><span class="tok-kw">const</span> mem = std.mem;</span>
<span class="line" id="L5"><span class="tok-kw">const</span> assert = std.debug.assert;</span>
<span class="line" id="L6"></span>
<span class="line" id="L7"><span class="tok-comment">/// This turns a byte buffer into an `io.Writer`, `io.Reader`, or `io.SeekableStream`.</span></span>
<span class="line" id="L8"><span class="tok-comment">/// If the supplied byte buffer is const, then `io.Writer` is not available.</span></span>
<span class="line" id="L9"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">FixedBufferStream</span>(<span class="tok-kw">comptime</span> Buffer: <span class="tok-type">type</span>) <span class="tok-type">type</span> {</span>
<span class="line" id="L10"> <span class="tok-kw">return</span> <span class="tok-kw">struct</span> {</span>
<span class="line" id="L11"> <span class="tok-comment">/// `Buffer` is either a `[]u8` or `[]const u8`.</span></span>
<span class="line" id="L12"> buffer: Buffer,</span>
<span class="line" id="L13"> pos: <span class="tok-type">usize</span>,</span>
<span class="line" id="L14"></span>
<span class="line" id="L15"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> ReadError = <span class="tok-kw">error</span>{};</span>
<span class="line" id="L16"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> WriteError = <span class="tok-kw">error</span>{NoSpaceLeft};</span>
<span class="line" id="L17"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> SeekError = <span class="tok-kw">error</span>{};</span>
<span class="line" id="L18"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> GetSeekPosError = <span class="tok-kw">error</span>{};</span>
<span class="line" id="L19"></span>
<span class="line" id="L20"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> Reader = io.Reader(*Self, ReadError, read);</span>
<span class="line" id="L21"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> Writer = io.Writer(*Self, WriteError, write);</span>
<span class="line" id="L22"></span>
<span class="line" id="L23"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> SeekableStream = io.SeekableStream(</span>
<span class="line" id="L24"> *Self,</span>
<span class="line" id="L25"> SeekError,</span>
<span class="line" id="L26"> GetSeekPosError,</span>
<span class="line" id="L27"> seekTo,</span>
<span class="line" id="L28"> seekBy,</span>
<span class="line" id="L29"> getPos,</span>
<span class="line" id="L30"> getEndPos,</span>
<span class="line" id="L31"> );</span>
<span class="line" id="L32"></span>
<span class="line" id="L33"> <span class="tok-kw">const</span> Self = <span class="tok-builtin">@This</span>();</span>
<span class="line" id="L34"></span>
<span class="line" id="L35"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">reader</span>(self: *Self) Reader {</span>
<span class="line" id="L36"> <span class="tok-kw">return</span> .{ .context = self };</span>
<span class="line" id="L37"> }</span>
<span class="line" id="L38"></span>
<span class="line" id="L39"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">writer</span>(self: *Self) Writer {</span>
<span class="line" id="L40"> <span class="tok-kw">return</span> .{ .context = self };</span>
<span class="line" id="L41"> }</span>
<span class="line" id="L42"></span>
<span class="line" id="L43"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">seekableStream</span>(self: *Self) SeekableStream {</span>
<span class="line" id="L44"> <span class="tok-kw">return</span> .{ .context = self };</span>
<span class="line" id="L45"> }</span>
<span class="line" id="L46"></span>
<span class="line" id="L47"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">read</span>(self: *Self, dest: []<span class="tok-type">u8</span>) ReadError!<span class="tok-type">usize</span> {</span>
<span class="line" id="L48"> <span class="tok-kw">const</span> size = <span class="tok-builtin">@min</span>(dest.len, self.buffer.len - self.pos);</span>
<span class="line" id="L49"> <span class="tok-kw">const</span> end = self.pos + size;</span>
<span class="line" id="L50"></span>
<span class="line" id="L51"> <span class="tok-builtin">@memcpy</span>(dest[<span class="tok-number">0</span>..size], self.buffer[self.pos..end]);</span>
<span class="line" id="L52"> self.pos = end;</span>
<span class="line" id="L53"></span>
<span class="line" id="L54"> <span class="tok-kw">return</span> size;</span>
<span class="line" id="L55"> }</span>
<span class="line" id="L56"></span>
<span class="line" id="L57"> <span class="tok-comment">/// If the returned number of bytes written is less than requested, the</span></span>
<span class="line" id="L58"> <span class="tok-comment">/// buffer is full. Returns `error.NoSpaceLeft` when no bytes would be written.</span></span>
<span class="line" id="L59"> <span class="tok-comment">/// Note: `error.NoSpaceLeft` matches the corresponding error from</span></span>
<span class="line" id="L60"> <span class="tok-comment">/// `std.fs.File.WriteError`.</span></span>
<span class="line" id="L61"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">write</span>(self: *Self, bytes: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) WriteError!<span class="tok-type">usize</span> {</span>
<span class="line" id="L62"> <span class="tok-kw">if</span> (bytes.len == <span class="tok-number">0</span>) <span class="tok-kw">return</span> <span class="tok-number">0</span>;</span>
<span class="line" id="L63"> <span class="tok-kw">if</span> (self.pos >= self.buffer.len) <span class="tok-kw">return</span> <span class="tok-kw">error</span>.NoSpaceLeft;</span>
<span class="line" id="L64"></span>
<span class="line" id="L65"> <span class="tok-kw">const</span> n = <span class="tok-kw">if</span> (self.pos + bytes.len <= self.buffer.len)</span>
<span class="line" id="L66"> bytes.len</span>
<span class="line" id="L67"> <span class="tok-kw">else</span></span>
<span class="line" id="L68"> self.buffer.len - self.pos;</span>
<span class="line" id="L69"></span>
<span class="line" id="L70"> <span class="tok-builtin">@memcpy</span>(self.buffer[self.pos..][<span class="tok-number">0</span>..n], bytes[<span class="tok-number">0</span>..n]);</span>
<span class="line" id="L71"> self.pos += n;</span>
<span class="line" id="L72"></span>
<span class="line" id="L73"> <span class="tok-kw">if</span> (n == <span class="tok-number">0</span>) <span class="tok-kw">return</span> <span class="tok-kw">error</span>.NoSpaceLeft;</span>
<span class="line" id="L74"></span>
<span class="line" id="L75"> <span class="tok-kw">return</span> n;</span>
<span class="line" id="L76"> }</span>
<span class="line" id="L77"></span>
<span class="line" id="L78"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">seekTo</span>(self: *Self, pos: <span class="tok-type">u64</span>) SeekError!<span class="tok-type">void</span> {</span>
<span class="line" id="L79"> self.pos = <span class="tok-kw">if</span> (std.math.cast(<span class="tok-type">usize</span>, pos)) |x| <span class="tok-builtin">@min</span>(self.buffer.len, x) <span class="tok-kw">else</span> self.buffer.len;</span>
<span class="line" id="L80"> }</span>
<span class="line" id="L81"></span>
<span class="line" id="L82"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">seekBy</span>(self: *Self, amt: <span class="tok-type">i64</span>) SeekError!<span class="tok-type">void</span> {</span>
<span class="line" id="L83"> <span class="tok-kw">if</span> (amt < <span class="tok-number">0</span>) {</span>
<span class="line" id="L84"> <span class="tok-kw">const</span> abs_amt = std.math.absCast(amt);</span>
<span class="line" id="L85"> <span class="tok-kw">const</span> abs_amt_usize = std.math.cast(<span class="tok-type">usize</span>, abs_amt) <span class="tok-kw">orelse</span> std.math.maxInt(<span class="tok-type">usize</span>);</span>
<span class="line" id="L86"> <span class="tok-kw">if</span> (abs_amt_usize > self.pos) {</span>
<span class="line" id="L87"> self.pos = <span class="tok-number">0</span>;</span>
<span class="line" id="L88"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L89"> self.pos -= abs_amt_usize;</span>
<span class="line" id="L90"> }</span>
<span class="line" id="L91"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L92"> <span class="tok-kw">const</span> amt_usize = std.math.cast(<span class="tok-type">usize</span>, amt) <span class="tok-kw">orelse</span> std.math.maxInt(<span class="tok-type">usize</span>);</span>
<span class="line" id="L93"> <span class="tok-kw">const</span> new_pos = std.math.add(<span class="tok-type">usize</span>, self.pos, amt_usize) <span class="tok-kw">catch</span> std.math.maxInt(<span class="tok-type">usize</span>);</span>
<span class="line" id="L94"> self.pos = <span class="tok-builtin">@min</span>(self.buffer.len, new_pos);</span>
<span class="line" id="L95"> }</span>
<span class="line" id="L96"> }</span>
<span class="line" id="L97"></span>
<span class="line" id="L98"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">getEndPos</span>(self: *Self) GetSeekPosError!<span class="tok-type">u64</span> {</span>
<span class="line" id="L99"> <span class="tok-kw">return</span> self.buffer.len;</span>
<span class="line" id="L100"> }</span>
<span class="line" id="L101"></span>
<span class="line" id="L102"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">getPos</span>(self: *Self) GetSeekPosError!<span class="tok-type">u64</span> {</span>
<span class="line" id="L103"> <span class="tok-kw">return</span> self.pos;</span>
<span class="line" id="L104"> }</span>
<span class="line" id="L105"></span>
<span class="line" id="L106"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">getWritten</span>(self: Self) Buffer {</span>
<span class="line" id="L107"> <span class="tok-kw">return</span> self.buffer[<span class="tok-number">0</span>..self.pos];</span>
<span class="line" id="L108"> }</span>
<span class="line" id="L109"></span>
<span class="line" id="L110"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">reset</span>(self: *Self) <span class="tok-type">void</span> {</span>
<span class="line" id="L111"> self.pos = <span class="tok-number">0</span>;</span>
<span class="line" id="L112"> }</span>
<span class="line" id="L113"> };</span>
<span class="line" id="L114">}</span>
<span class="line" id="L115"></span>
<span class="line" id="L116"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">fixedBufferStream</span>(buffer: <span class="tok-kw">anytype</span>) FixedBufferStream(Slice(<span class="tok-builtin">@TypeOf</span>(buffer))) {</span>
<span class="line" id="L117"> <span class="tok-kw">return</span> .{ .buffer = buffer, .pos = <span class="tok-number">0</span> };</span>
<span class="line" id="L118">}</span>
<span class="line" id="L119"></span>
<span class="line" id="L120"><span class="tok-kw">fn</span> <span class="tok-fn">Slice</span>(<span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>) <span class="tok-type">type</span> {</span>
<span class="line" id="L121"> <span class="tok-kw">switch</span> (<span class="tok-builtin">@typeInfo</span>(T)) {</span>
<span class="line" id="L122"> .Pointer => |ptr_info| {</span>
<span class="line" id="L123"> <span class="tok-kw">var</span> new_ptr_info = ptr_info;</span>
<span class="line" id="L124"> <span class="tok-kw">switch</span> (ptr_info.size) {</span>
<span class="line" id="L125"> .Slice => {},</span>
<span class="line" id="L126"> .One => <span class="tok-kw">switch</span> (<span class="tok-builtin">@typeInfo</span>(ptr_info.child)) {</span>
<span class="line" id="L127"> .Array => |info| new_ptr_info.child = info.child,</span>
<span class="line" id="L128"> <span class="tok-kw">else</span> => <span class="tok-builtin">@compileError</span>(<span class="tok-str">"invalid type given to fixedBufferStream"</span>),</span>
<span class="line" id="L129"> },</span>
<span class="line" id="L130"> <span class="tok-kw">else</span> => <span class="tok-builtin">@compileError</span>(<span class="tok-str">"invalid type given to fixedBufferStream"</span>),</span>
<span class="line" id="L131"> }</span>
<span class="line" id="L132"> new_ptr_info.size = .Slice;</span>
<span class="line" id="L133"> <span class="tok-kw">return</span> <span class="tok-builtin">@Type</span>(.{ .Pointer = new_ptr_info });</span>
<span class="line" id="L134"> },</span>
<span class="line" id="L135"> <span class="tok-kw">else</span> => <span class="tok-builtin">@compileError</span>(<span class="tok-str">"invalid type given to fixedBufferStream"</span>),</span>
<span class="line" id="L136"> }</span>
<span class="line" id="L137">}</span>
<span class="line" id="L138"></span>
<span class="line" id="L139"><span class="tok-kw">test</span> <span class="tok-str">"FixedBufferStream output"</span> {</span>
<span class="line" id="L140"> <span class="tok-kw">var</span> buf: [<span class="tok-number">255</span>]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L141"> <span class="tok-kw">var</span> fbs = fixedBufferStream(&buf);</span>
<span class="line" id="L142"> <span class="tok-kw">const</span> stream = fbs.writer();</span>
<span class="line" id="L143"></span>
<span class="line" id="L144"> <span class="tok-kw">try</span> stream.print(<span class="tok-str">"{s}{s}!"</span>, .{ <span class="tok-str">"Hello"</span>, <span class="tok-str">"World"</span> });</span>
<span class="line" id="L145"> <span class="tok-kw">try</span> testing.expectEqualSlices(<span class="tok-type">u8</span>, <span class="tok-str">"HelloWorld!"</span>, fbs.getWritten());</span>
<span class="line" id="L146">}</span>
<span class="line" id="L147"></span>
<span class="line" id="L148"><span class="tok-kw">test</span> <span class="tok-str">"FixedBufferStream output at comptime"</span> {</span>
<span class="line" id="L149"> <span class="tok-kw">comptime</span> {</span>
<span class="line" id="L150"> <span class="tok-kw">var</span> buf: [<span class="tok-number">255</span>]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L151"> <span class="tok-kw">var</span> fbs = fixedBufferStream(&buf);</span>
<span class="line" id="L152"> <span class="tok-kw">const</span> stream = fbs.writer();</span>
<span class="line" id="L153"></span>
<span class="line" id="L154"> <span class="tok-kw">try</span> stream.print(<span class="tok-str">"{s}{s}!"</span>, .{ <span class="tok-str">"Hello"</span>, <span class="tok-str">"World"</span> });</span>
<span class="line" id="L155"> <span class="tok-kw">try</span> testing.expectEqualSlices(<span class="tok-type">u8</span>, <span class="tok-str">"HelloWorld!"</span>, fbs.getWritten());</span>
<span class="line" id="L156"> }</span>
<span class="line" id="L157">}</span>
<span class="line" id="L158"></span>
<span class="line" id="L159"><span class="tok-kw">test</span> <span class="tok-str">"FixedBufferStream output 2"</span> {</span>
<span class="line" id="L160"> <span class="tok-kw">var</span> buffer: [<span class="tok-number">10</span>]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L161"> <span class="tok-kw">var</span> fbs = fixedBufferStream(&buffer);</span>
<span class="line" id="L162"></span>
<span class="line" id="L163"> <span class="tok-kw">try</span> fbs.writer().writeAll(<span class="tok-str">"Hello"</span>);</span>
<span class="line" id="L164"> <span class="tok-kw">try</span> testing.expect(mem.eql(<span class="tok-type">u8</span>, fbs.getWritten(), <span class="tok-str">"Hello"</span>));</span>
<span class="line" id="L165"></span>
<span class="line" id="L166"> <span class="tok-kw">try</span> fbs.writer().writeAll(<span class="tok-str">"world"</span>);</span>
<span class="line" id="L167"> <span class="tok-kw">try</span> testing.expect(mem.eql(<span class="tok-type">u8</span>, fbs.getWritten(), <span class="tok-str">"Helloworld"</span>));</span>
<span class="line" id="L168"></span>
<span class="line" id="L169"> <span class="tok-kw">try</span> testing.expectError(<span class="tok-kw">error</span>.NoSpaceLeft, fbs.writer().writeAll(<span class="tok-str">"!"</span>));</span>
<span class="line" id="L170"> <span class="tok-kw">try</span> testing.expect(mem.eql(<span class="tok-type">u8</span>, fbs.getWritten(), <span class="tok-str">"Helloworld"</span>));</span>
<span class="line" id="L171"></span>
<span class="line" id="L172"> fbs.reset();</span>
<span class="line" id="L173"> <span class="tok-kw">try</span> testing.expect(fbs.getWritten().len == <span class="tok-number">0</span>);</span>
<span class="line" id="L174"></span>
<span class="line" id="L175"> <span class="tok-kw">try</span> testing.expectError(<span class="tok-kw">error</span>.NoSpaceLeft, fbs.writer().writeAll(<span class="tok-str">"Hello world!"</span>));</span>
<span class="line" id="L176"> <span class="tok-kw">try</span> testing.expect(mem.eql(<span class="tok-type">u8</span>, fbs.getWritten(), <span class="tok-str">"Hello worl"</span>));</span>
<span class="line" id="L177"></span>
<span class="line" id="L178"> <span class="tok-kw">try</span> fbs.seekTo((<span class="tok-kw">try</span> fbs.getEndPos()) + <span class="tok-number">1</span>);</span>
<span class="line" id="L179"> <span class="tok-kw">try</span> testing.expectError(<span class="tok-kw">error</span>.NoSpaceLeft, fbs.writer().writeAll(<span class="tok-str">"H"</span>));</span>
<span class="line" id="L180">}</span>
<span class="line" id="L181"></span>
<span class="line" id="L182"><span class="tok-kw">test</span> <span class="tok-str">"FixedBufferStream input"</span> {</span>
<span class="line" id="L183"> <span class="tok-kw">const</span> bytes = [_]<span class="tok-type">u8</span>{ <span class="tok-number">1</span>, <span class="tok-number">2</span>, <span class="tok-number">3</span>, <span class="tok-number">4</span>, <span class="tok-number">5</span>, <span class="tok-number">6</span>, <span class="tok-number">7</span> };</span>
<span class="line" id="L184"> <span class="tok-kw">var</span> fbs = fixedBufferStream(&bytes);</span>
<span class="line" id="L185"></span>
<span class="line" id="L186"> <span class="tok-kw">var</span> dest: [<span class="tok-number">4</span>]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L187"></span>
<span class="line" id="L188"> <span class="tok-kw">var</span> read = <span class="tok-kw">try</span> fbs.reader().read(&dest);</span>
<span class="line" id="L189"> <span class="tok-kw">try</span> testing.expect(read == <span class="tok-number">4</span>);</span>
<span class="line" id="L190"> <span class="tok-kw">try</span> testing.expect(mem.eql(<span class="tok-type">u8</span>, dest[<span class="tok-number">0</span>..<span class="tok-number">4</span>], bytes[<span class="tok-number">0</span>..<span class="tok-number">4</span>]));</span>
<span class="line" id="L191"></span>
<span class="line" id="L192"> read = <span class="tok-kw">try</span> fbs.reader().read(&dest);</span>
<span class="line" id="L193"> <span class="tok-kw">try</span> testing.expect(read == <span class="tok-number">3</span>);</span>
<span class="line" id="L194"> <span class="tok-kw">try</span> testing.expect(mem.eql(<span class="tok-type">u8</span>, dest[<span class="tok-number">0</span>..<span class="tok-number">3</span>], bytes[<span class="tok-number">4</span>..<span class="tok-number">7</span>]));</span>
<span class="line" id="L195"></span>
<span class="line" id="L196"> read = <span class="tok-kw">try</span> fbs.reader().read(&dest);</span>
<span class="line" id="L197"> <span class="tok-kw">try</span> testing.expect(read == <span class="tok-number">0</span>);</span>
<span class="line" id="L198"></span>
<span class="line" id="L199"> <span class="tok-kw">try</span> fbs.seekTo((<span class="tok-kw">try</span> fbs.getEndPos()) + <span class="tok-number">1</span>);</span>
<span class="line" id="L200"> read = <span class="tok-kw">try</span> fbs.reader().read(&dest);</span>
<span class="line" id="L201"> <span class="tok-kw">try</span> testing.expect(read == <span class="tok-number">0</span>);</span>
<span class="line" id="L202">}</span>
<span class="line" id="L203"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/io/tty.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>io/tty.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"std"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> builtin = <span class="tok-builtin">@import</span>(<span class="tok-str">"builtin"</span>);</span>
<span class="line" id="L3"><span class="tok-kw">const</span> File = std.fs.File;</span>
<span class="line" id="L4"><span class="tok-kw">const</span> process = std.process;</span>
<span class="line" id="L5"><span class="tok-kw">const</span> windows = std.os.windows;</span>
<span class="line" id="L6"><span class="tok-kw">const</span> native_os = builtin.os.tag;</span>
<span class="line" id="L7"></span>
<span class="line" id="L8"><span class="tok-comment">/// Detect suitable TTY configuration options for the given file (commonly stdout/stderr).</span></span>
<span class="line" id="L9"><span class="tok-comment">/// This includes feature checks for ANSI escape codes and the Windows console API, as well as</span></span>
<span class="line" id="L10"><span class="tok-comment">/// respecting the `NO_COLOR` and `YES_COLOR` environment variables to override the default.</span></span>
<span class="line" id="L11"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">detectConfig</span>(file: File) Config {</span>
<span class="line" id="L12"> <span class="tok-kw">const</span> force_color: ?<span class="tok-type">bool</span> = <span class="tok-kw">if</span> (builtin.os.tag == .wasi)</span>
<span class="line" id="L13"> <span class="tok-null">null</span> <span class="tok-comment">// wasi does not support environment variables</span>
</span>
<span class="line" id="L14"> <span class="tok-kw">else</span> <span class="tok-kw">if</span> (process.hasEnvVarConstant(<span class="tok-str">"NO_COLOR"</span>))</span>
<span class="line" id="L15"> <span class="tok-null">false</span></span>
<span class="line" id="L16"> <span class="tok-kw">else</span> <span class="tok-kw">if</span> (process.hasEnvVarConstant(<span class="tok-str">"YES_COLOR"</span>))</span>
<span class="line" id="L17"> <span class="tok-null">true</span></span>
<span class="line" id="L18"> <span class="tok-kw">else</span></span>
<span class="line" id="L19"> <span class="tok-null">null</span>;</span>
<span class="line" id="L20"></span>
<span class="line" id="L21"> <span class="tok-kw">if</span> (force_color == <span class="tok-null">false</span>) <span class="tok-kw">return</span> .no_color;</span>
<span class="line" id="L22"></span>
<span class="line" id="L23"> <span class="tok-kw">if</span> (file.supportsAnsiEscapeCodes()) <span class="tok-kw">return</span> .escape_codes;</span>
<span class="line" id="L24"></span>
<span class="line" id="L25"> <span class="tok-kw">if</span> (native_os == .windows <span class="tok-kw">and</span> file.isTty()) {</span>
<span class="line" id="L26"> <span class="tok-kw">var</span> info: windows.CONSOLE_SCREEN_BUFFER_INFO = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L27"> <span class="tok-kw">if</span> (windows.kernel32.GetConsoleScreenBufferInfo(file.handle, &info) != windows.TRUE) {</span>
<span class="line" id="L28"> <span class="tok-kw">return</span> <span class="tok-kw">if</span> (force_color == <span class="tok-null">true</span>) .escape_codes <span class="tok-kw">else</span> .no_color;</span>
<span class="line" id="L29"> }</span>
<span class="line" id="L30"> <span class="tok-kw">return</span> .{ .windows_api = .{</span>
<span class="line" id="L31"> .handle = file.handle,</span>
<span class="line" id="L32"> .reset_attributes = info.wAttributes,</span>
<span class="line" id="L33"> } };</span>
<span class="line" id="L34"> }</span>
<span class="line" id="L35"></span>
<span class="line" id="L36"> <span class="tok-kw">return</span> <span class="tok-kw">if</span> (force_color == <span class="tok-null">true</span>) .escape_codes <span class="tok-kw">else</span> .no_color;</span>
<span class="line" id="L37">}</span>
<span class="line" id="L38"></span>
<span class="line" id="L39"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> Color = <span class="tok-kw">enum</span> {</span>
<span class="line" id="L40"> black,</span>
<span class="line" id="L41"> red,</span>
<span class="line" id="L42"> green,</span>
<span class="line" id="L43"> yellow,</span>
<span class="line" id="L44"> blue,</span>
<span class="line" id="L45"> magenta,</span>
<span class="line" id="L46"> cyan,</span>
<span class="line" id="L47"> white,</span>
<span class="line" id="L48"> bright_black,</span>
<span class="line" id="L49"> bright_red,</span>
<span class="line" id="L50"> bright_green,</span>
<span class="line" id="L51"> bright_yellow,</span>
<span class="line" id="L52"> bright_blue,</span>
<span class="line" id="L53"> bright_magenta,</span>
<span class="line" id="L54"> bright_cyan,</span>
<span class="line" id="L55"> bright_white,</span>
<span class="line" id="L56"> dim,</span>
<span class="line" id="L57"> bold,</span>
<span class="line" id="L58"> reset,</span>
<span class="line" id="L59">};</span>
<span class="line" id="L60"></span>
<span class="line" id="L61"><span class="tok-comment">/// Provides simple functionality for manipulating the terminal in some way,</span></span>
<span class="line" id="L62"><span class="tok-comment">/// such as coloring text, etc.</span></span>
<span class="line" id="L63"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> Config = <span class="tok-kw">union</span>(<span class="tok-kw">enum</span>) {</span>
<span class="line" id="L64"> no_color,</span>
<span class="line" id="L65"> escape_codes,</span>
<span class="line" id="L66"> windows_api: <span class="tok-kw">if</span> (native_os == .windows) WindowsContext <span class="tok-kw">else</span> <span class="tok-type">void</span>,</span>
<span class="line" id="L67"></span>
<span class="line" id="L68"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> WindowsContext = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L69"> handle: File.Handle,</span>
<span class="line" id="L70"> reset_attributes: <span class="tok-type">u16</span>,</span>
<span class="line" id="L71"> };</span>
<span class="line" id="L72"></span>
<span class="line" id="L73"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">setColor</span>(conf: Config, out_stream: <span class="tok-kw">anytype</span>, color: Color) !<span class="tok-type">void</span> {</span>
<span class="line" id="L74"> <span class="tok-kw">nosuspend</span> <span class="tok-kw">switch</span> (conf) {</span>
<span class="line" id="L75"> .no_color => <span class="tok-kw">return</span>,</span>
<span class="line" id="L76"> .escape_codes => {</span>
<span class="line" id="L77"> <span class="tok-kw">const</span> color_string = <span class="tok-kw">switch</span> (color) {</span>
<span class="line" id="L78"> .black => <span class="tok-str">"\x1b[30m"</span>,</span>
<span class="line" id="L79"> .red => <span class="tok-str">"\x1b[31m"</span>,</span>
<span class="line" id="L80"> .green => <span class="tok-str">"\x1b[32m"</span>,</span>
<span class="line" id="L81"> .yellow => <span class="tok-str">"\x1b[33m"</span>,</span>
<span class="line" id="L82"> .blue => <span class="tok-str">"\x1b[34m"</span>,</span>
<span class="line" id="L83"> .magenta => <span class="tok-str">"\x1b[35m"</span>,</span>
<span class="line" id="L84"> .cyan => <span class="tok-str">"\x1b[36m"</span>,</span>
<span class="line" id="L85"> .white => <span class="tok-str">"\x1b[37m"</span>,</span>
<span class="line" id="L86"> .bright_black => <span class="tok-str">"\x1b[90m"</span>,</span>
<span class="line" id="L87"> .bright_red => <span class="tok-str">"\x1b[91m"</span>,</span>
<span class="line" id="L88"> .bright_green => <span class="tok-str">"\x1b[92m"</span>,</span>
<span class="line" id="L89"> .bright_yellow => <span class="tok-str">"\x1b[93m"</span>,</span>
<span class="line" id="L90"> .bright_blue => <span class="tok-str">"\x1b[94m"</span>,</span>
<span class="line" id="L91"> .bright_magenta => <span class="tok-str">"\x1b[95m"</span>,</span>
<span class="line" id="L92"> .bright_cyan => <span class="tok-str">"\x1b[96m"</span>,</span>
<span class="line" id="L93"> .bright_white => <span class="tok-str">"\x1b[97m"</span>,</span>
<span class="line" id="L94"> .bold => <span class="tok-str">"\x1b[1m"</span>,</span>
<span class="line" id="L95"> .dim => <span class="tok-str">"\x1b[2m"</span>,</span>
<span class="line" id="L96"> .reset => <span class="tok-str">"\x1b[0m"</span>,</span>
<span class="line" id="L97"> };</span>
<span class="line" id="L98"> <span class="tok-kw">try</span> out_stream.writeAll(color_string);</span>
<span class="line" id="L99"> },</span>
<span class="line" id="L100"> .windows_api => |ctx| <span class="tok-kw">if</span> (native_os == .windows) {</span>
<span class="line" id="L101"> <span class="tok-kw">const</span> attributes = <span class="tok-kw">switch</span> (color) {</span>
<span class="line" id="L102"> .black => <span class="tok-number">0</span>,</span>
<span class="line" id="L103"> .red => windows.FOREGROUND_RED,</span>
<span class="line" id="L104"> .green => windows.FOREGROUND_GREEN,</span>
<span class="line" id="L105"> .yellow => windows.FOREGROUND_RED | windows.FOREGROUND_GREEN,</span>
<span class="line" id="L106"> .blue => windows.FOREGROUND_BLUE,</span>
<span class="line" id="L107"> .magenta => windows.FOREGROUND_RED | windows.FOREGROUND_BLUE,</span>
<span class="line" id="L108"> .cyan => windows.FOREGROUND_GREEN | windows.FOREGROUND_BLUE,</span>
<span class="line" id="L109"> .white => windows.FOREGROUND_RED | windows.FOREGROUND_GREEN | windows.FOREGROUND_BLUE,</span>
<span class="line" id="L110"> .bright_black => windows.FOREGROUND_INTENSITY,</span>
<span class="line" id="L111"> .bright_red => windows.FOREGROUND_RED | windows.FOREGROUND_INTENSITY,</span>
<span class="line" id="L112"> .bright_green => windows.FOREGROUND_GREEN | windows.FOREGROUND_INTENSITY,</span>
<span class="line" id="L113"> .bright_yellow => windows.FOREGROUND_RED | windows.FOREGROUND_GREEN | windows.FOREGROUND_INTENSITY,</span>
<span class="line" id="L114"> .bright_blue => windows.FOREGROUND_BLUE | windows.FOREGROUND_INTENSITY,</span>
<span class="line" id="L115"> .bright_magenta => windows.FOREGROUND_RED | windows.FOREGROUND_BLUE | windows.FOREGROUND_INTENSITY,</span>
<span class="line" id="L116"> .bright_cyan => windows.FOREGROUND_GREEN | windows.FOREGROUND_BLUE | windows.FOREGROUND_INTENSITY,</span>
<span class="line" id="L117"> .bright_white, .bold => windows.FOREGROUND_RED | windows.FOREGROUND_GREEN | windows.FOREGROUND_BLUE | windows.FOREGROUND_INTENSITY,</span>
<span class="line" id="L118"> <span class="tok-comment">// "dim" is not supported using basic character attributes, but let's still make it do *something*.</span>
</span>
<span class="line" id="L119"> <span class="tok-comment">// This matches the old behavior of TTY.Color before the bright variants were added.</span>
</span>
<span class="line" id="L120"> .dim => windows.FOREGROUND_INTENSITY,</span>
<span class="line" id="L121"> .reset => ctx.reset_attributes,</span>
<span class="line" id="L122"> };</span>
<span class="line" id="L123"> <span class="tok-kw">try</span> windows.SetConsoleTextAttribute(ctx.handle, attributes);</span>
<span class="line" id="L124"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L125"> <span class="tok-kw">unreachable</span>;</span>
<span class="line" id="L126"> },</span>
<span class="line" id="L127"> };</span>
<span class="line" id="L128"> }</span>
<span class="line" id="L129">};</span>
<span class="line" id="L130"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/io/buffered_atomic_file.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>io/buffered_atomic_file.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../std.zig"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> mem = std.mem;</span>
<span class="line" id="L3"><span class="tok-kw">const</span> fs = std.fs;</span>
<span class="line" id="L4"><span class="tok-kw">const</span> File = std.fs.File;</span>
<span class="line" id="L5"></span>
<span class="line" id="L6"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> BufferedAtomicFile = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L7"> atomic_file: fs.AtomicFile,</span>
<span class="line" id="L8"> file_writer: File.Writer,</span>
<span class="line" id="L9"> buffered_writer: BufferedWriter,</span>
<span class="line" id="L10"> allocator: mem.Allocator,</span>
<span class="line" id="L11"></span>
<span class="line" id="L12"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> buffer_size = <span class="tok-number">4096</span>;</span>
<span class="line" id="L13"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> BufferedWriter = std.io.BufferedWriter(buffer_size, File.Writer);</span>
<span class="line" id="L14"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> Writer = std.io.Writer(*BufferedWriter, BufferedWriter.Error, BufferedWriter.write);</span>
<span class="line" id="L15"></span>
<span class="line" id="L16"> <span class="tok-comment">/// TODO when https://github.com/ziglang/zig/issues/2761 is solved</span></span>
<span class="line" id="L17"> <span class="tok-comment">/// this API will not need an allocator</span></span>
<span class="line" id="L18"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">create</span>(</span>
<span class="line" id="L19"> allocator: mem.Allocator,</span>
<span class="line" id="L20"> dir: fs.Dir,</span>
<span class="line" id="L21"> dest_path: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L22"> atomic_file_options: fs.Dir.AtomicFileOptions,</span>
<span class="line" id="L23"> ) !*BufferedAtomicFile {</span>
<span class="line" id="L24"> <span class="tok-kw">var</span> self = <span class="tok-kw">try</span> allocator.create(BufferedAtomicFile);</span>
<span class="line" id="L25"> self.* = BufferedAtomicFile{</span>
<span class="line" id="L26"> .atomic_file = <span class="tok-null">undefined</span>,</span>
<span class="line" id="L27"> .file_writer = <span class="tok-null">undefined</span>,</span>
<span class="line" id="L28"> .buffered_writer = <span class="tok-null">undefined</span>,</span>
<span class="line" id="L29"> .allocator = allocator,</span>
<span class="line" id="L30"> };</span>
<span class="line" id="L31"> <span class="tok-kw">errdefer</span> allocator.destroy(self);</span>
<span class="line" id="L32"></span>
<span class="line" id="L33"> self.atomic_file = <span class="tok-kw">try</span> dir.atomicFile(dest_path, atomic_file_options);</span>
<span class="line" id="L34"> <span class="tok-kw">errdefer</span> self.atomic_file.deinit();</span>
<span class="line" id="L35"></span>
<span class="line" id="L36"> self.file_writer = self.atomic_file.file.writer();</span>
<span class="line" id="L37"> self.buffered_writer = .{ .unbuffered_writer = self.file_writer };</span>
<span class="line" id="L38"> <span class="tok-kw">return</span> self;</span>
<span class="line" id="L39"> }</span>
<span class="line" id="L40"></span>
<span class="line" id="L41"> <span class="tok-comment">/// always call destroy, even after successful finish()</span></span>
<span class="line" id="L42"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">destroy</span>(self: *BufferedAtomicFile) <span class="tok-type">void</span> {</span>
<span class="line" id="L43"> self.atomic_file.deinit();</span>
<span class="line" id="L44"> self.allocator.destroy(self);</span>
<span class="line" id="L45"> }</span>
<span class="line" id="L46"></span>
<span class="line" id="L47"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">finish</span>(self: *BufferedAtomicFile) !<span class="tok-type">void</span> {</span>
<span class="line" id="L48"> <span class="tok-kw">try</span> self.buffered_writer.flush();</span>
<span class="line" id="L49"> <span class="tok-kw">try</span> self.atomic_file.finish();</span>
<span class="line" id="L50"> }</span>
<span class="line" id="L51"></span>
<span class="line" id="L52"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">writer</span>(self: *BufferedAtomicFile) Writer {</span>
<span class="line" id="L53"> <span class="tok-kw">return</span> .{ .context = &self.buffered_writer };</span>
<span class="line" id="L54"> }</span>
<span class="line" id="L55">};</span>
<span class="line" id="L56"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/io/multi_writer.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>io/multi_writer.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../std.zig"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> io = std.io;</span>
<span class="line" id="L3"></span>
<span class="line" id="L4"><span class="tok-comment">/// Takes a tuple of streams, and constructs a new stream that writes to all of them</span></span>
<span class="line" id="L5"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">MultiWriter</span>(<span class="tok-kw">comptime</span> Writers: <span class="tok-type">type</span>) <span class="tok-type">type</span> {</span>
<span class="line" id="L6"> <span class="tok-kw">comptime</span> <span class="tok-kw">var</span> ErrSet = <span class="tok-kw">error</span>{};</span>
<span class="line" id="L7"> <span class="tok-kw">inline</span> <span class="tok-kw">for</span> (<span class="tok-builtin">@typeInfo</span>(Writers).Struct.fields) |field| {</span>
<span class="line" id="L8"> <span class="tok-kw">const</span> StreamType = field.<span class="tok-type">type</span>;</span>
<span class="line" id="L9"> ErrSet = ErrSet || StreamType.Error;</span>
<span class="line" id="L10"> }</span>
<span class="line" id="L11"></span>
<span class="line" id="L12"> <span class="tok-kw">return</span> <span class="tok-kw">struct</span> {</span>
<span class="line" id="L13"> <span class="tok-kw">const</span> Self = <span class="tok-builtin">@This</span>();</span>
<span class="line" id="L14"></span>
<span class="line" id="L15"> streams: Writers,</span>
<span class="line" id="L16"></span>
<span class="line" id="L17"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> Error = ErrSet;</span>
<span class="line" id="L18"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> Writer = io.Writer(*Self, Error, write);</span>
<span class="line" id="L19"></span>
<span class="line" id="L20"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">writer</span>(self: *Self) Writer {</span>
<span class="line" id="L21"> <span class="tok-kw">return</span> .{ .context = self };</span>
<span class="line" id="L22"> }</span>
<span class="line" id="L23"></span>
<span class="line" id="L24"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">write</span>(self: *Self, bytes: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) Error!<span class="tok-type">usize</span> {</span>
<span class="line" id="L25"> <span class="tok-kw">inline</span> <span class="tok-kw">for</span> (self.streams) |stream|</span>
<span class="line" id="L26"> <span class="tok-kw">try</span> stream.writeAll(bytes);</span>
<span class="line" id="L27"> <span class="tok-kw">return</span> bytes.len;</span>
<span class="line" id="L28"> }</span>
<span class="line" id="L29"> };</span>
<span class="line" id="L30">}</span>
<span class="line" id="L31"></span>
<span class="line" id="L32"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">multiWriter</span>(streams: <span class="tok-kw">anytype</span>) MultiWriter(<span class="tok-builtin">@TypeOf</span>(streams)) {</span>
<span class="line" id="L33"> <span class="tok-kw">return</span> .{ .streams = streams };</span>
<span class="line" id="L34">}</span>
<span class="line" id="L35"></span>
<span class="line" id="L36"><span class="tok-kw">const</span> testing = std.testing;</span>
<span class="line" id="L37"></span>
<span class="line" id="L38"><span class="tok-kw">test</span> <span class="tok-str">"MultiWriter"</span> {</span>
<span class="line" id="L39"> <span class="tok-kw">var</span> tmp = testing.tmpDir(.{});</span>
<span class="line" id="L40"> <span class="tok-kw">defer</span> tmp.cleanup();</span>
<span class="line" id="L41"> <span class="tok-kw">var</span> f = <span class="tok-kw">try</span> tmp.dir.createFile(<span class="tok-str">"t.txt"</span>, .{});</span>
<span class="line" id="L42"></span>
<span class="line" id="L43"> <span class="tok-kw">var</span> buf1: [<span class="tok-number">255</span>]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L44"> <span class="tok-kw">var</span> fbs1 = io.fixedBufferStream(&buf1);</span>
<span class="line" id="L45"> <span class="tok-kw">var</span> buf2: [<span class="tok-number">255</span>]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L46"> <span class="tok-kw">var</span> stream = multiWriter(.{ fbs1.writer(), f.writer() });</span>
<span class="line" id="L47"></span>
<span class="line" id="L48"> <span class="tok-kw">try</span> stream.writer().print(<span class="tok-str">"HI"</span>, .{});</span>
<span class="line" id="L49"> f.close();</span>
<span class="line" id="L50"></span>
<span class="line" id="L51"> <span class="tok-kw">try</span> testing.expectEqualSlices(<span class="tok-type">u8</span>, <span class="tok-str">"HI"</span>, fbs1.getWritten());</span>
<span class="line" id="L52"> <span class="tok-kw">try</span> testing.expectEqualSlices(<span class="tok-type">u8</span>, <span class="tok-str">"HI"</span>, <span class="tok-kw">try</span> tmp.dir.readFile(<span class="tok-str">"t.txt"</span>, &buf2));</span>
<span class="line" id="L53">}</span>
<span class="line" id="L54"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/io/find_byte_writer.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>io/find_byte_writer.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../std.zig"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> io = std.io;</span>
<span class="line" id="L3"><span class="tok-kw">const</span> assert = std.debug.assert;</span>
<span class="line" id="L4"></span>
<span class="line" id="L5"><span class="tok-comment">/// A Writer that returns whether the given character has been written to it.</span></span>
<span class="line" id="L6"><span class="tok-comment">/// The contents are not written to anything.</span></span>
<span class="line" id="L7"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">FindByteWriter</span>(<span class="tok-kw">comptime</span> UnderlyingWriter: <span class="tok-type">type</span>) <span class="tok-type">type</span> {</span>
<span class="line" id="L8"> <span class="tok-kw">return</span> <span class="tok-kw">struct</span> {</span>
<span class="line" id="L9"> <span class="tok-kw">const</span> Self = <span class="tok-builtin">@This</span>();</span>
<span class="line" id="L10"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> Error = UnderlyingWriter.Error;</span>
<span class="line" id="L11"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> Writer = io.Writer(*Self, Error, write);</span>
<span class="line" id="L12"></span>
<span class="line" id="L13"> underlying_writer: UnderlyingWriter,</span>
<span class="line" id="L14"> byte_found: <span class="tok-type">bool</span>,</span>
<span class="line" id="L15"> byte: <span class="tok-type">u8</span>,</span>
<span class="line" id="L16"></span>
<span class="line" id="L17"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">writer</span>(self: *Self) Writer {</span>
<span class="line" id="L18"> <span class="tok-kw">return</span> .{ .context = self };</span>
<span class="line" id="L19"> }</span>
<span class="line" id="L20"></span>
<span class="line" id="L21"> <span class="tok-kw">fn</span> <span class="tok-fn">write</span>(self: *Self, bytes: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) Error!<span class="tok-type">usize</span> {</span>
<span class="line" id="L22"> <span class="tok-kw">if</span> (!self.byte_found) {</span>
<span class="line" id="L23"> self.byte_found = blk: {</span>
<span class="line" id="L24"> <span class="tok-kw">for</span> (bytes) |b|</span>
<span class="line" id="L25"> <span class="tok-kw">if</span> (b == self.byte) <span class="tok-kw">break</span> :blk <span class="tok-null">true</span>;</span>
<span class="line" id="L26"> <span class="tok-kw">break</span> :blk <span class="tok-null">false</span>;</span>
<span class="line" id="L27"> };</span>
<span class="line" id="L28"> }</span>
<span class="line" id="L29"> <span class="tok-kw">return</span> self.underlying_writer.write(bytes);</span>
<span class="line" id="L30"> }</span>
<span class="line" id="L31"> };</span>
<span class="line" id="L32">}</span>
<span class="line" id="L33"></span>
<span class="line" id="L34"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">findByteWriter</span>(byte: <span class="tok-type">u8</span>, underlying_writer: <span class="tok-kw">anytype</span>) FindByteWriter(<span class="tok-builtin">@TypeOf</span>(underlying_writer)) {</span>
<span class="line" id="L35"> <span class="tok-kw">return</span> FindByteWriter(<span class="tok-builtin">@TypeOf</span>(underlying_writer)){</span>
<span class="line" id="L36"> .underlying_writer = underlying_writer,</span>
<span class="line" id="L37"> .byte = byte,</span>
<span class="line" id="L38"> .byte_found = <span class="tok-null">false</span>,</span>
<span class="line" id="L39"> };</span>
<span class="line" id="L40">}</span>
<span class="line" id="L41"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/io/buffered_reader.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>io/buffered_reader.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../std.zig"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> io = std.io;</span>
<span class="line" id="L3"><span class="tok-kw">const</span> mem = std.mem;</span>
<span class="line" id="L4"><span class="tok-kw">const</span> assert = std.debug.assert;</span>
<span class="line" id="L5"><span class="tok-kw">const</span> testing = std.testing;</span>
<span class="line" id="L6"></span>
<span class="line" id="L7"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">BufferedReader</span>(<span class="tok-kw">comptime</span> buffer_size: <span class="tok-type">usize</span>, <span class="tok-kw">comptime</span> ReaderType: <span class="tok-type">type</span>) <span class="tok-type">type</span> {</span>
<span class="line" id="L8"> <span class="tok-kw">return</span> <span class="tok-kw">struct</span> {</span>
<span class="line" id="L9"> unbuffered_reader: ReaderType,</span>
<span class="line" id="L10"> buf: [buffer_size]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>,</span>
<span class="line" id="L11"> start: <span class="tok-type">usize</span> = <span class="tok-number">0</span>,</span>
<span class="line" id="L12"> end: <span class="tok-type">usize</span> = <span class="tok-number">0</span>,</span>
<span class="line" id="L13"></span>
<span class="line" id="L14"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> Error = ReaderType.Error;</span>
<span class="line" id="L15"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> Reader = io.Reader(*Self, Error, read);</span>
<span class="line" id="L16"></span>
<span class="line" id="L17"> <span class="tok-kw">const</span> Self = <span class="tok-builtin">@This</span>();</span>
<span class="line" id="L18"></span>
<span class="line" id="L19"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">read</span>(self: *Self, dest: []<span class="tok-type">u8</span>) Error!<span class="tok-type">usize</span> {</span>
<span class="line" id="L20"> <span class="tok-kw">var</span> dest_index: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L21"></span>
<span class="line" id="L22"> <span class="tok-kw">while</span> (dest_index < dest.len) {</span>
<span class="line" id="L23"> <span class="tok-kw">const</span> written = <span class="tok-builtin">@min</span>(dest.len - dest_index, self.end - self.start);</span>
<span class="line" id="L24"> <span class="tok-builtin">@memcpy</span>(dest[dest_index..][<span class="tok-number">0</span>..written], self.buf[self.start..][<span class="tok-number">0</span>..written]);</span>
<span class="line" id="L25"> <span class="tok-kw">if</span> (written == <span class="tok-number">0</span>) {</span>
<span class="line" id="L26"> <span class="tok-comment">// buf empty, fill it</span>
</span>
<span class="line" id="L27"> <span class="tok-kw">const</span> n = <span class="tok-kw">try</span> self.unbuffered_reader.read(self.buf[<span class="tok-number">0</span>..]);</span>
<span class="line" id="L28"> <span class="tok-kw">if</span> (n == <span class="tok-number">0</span>) {</span>
<span class="line" id="L29"> <span class="tok-comment">// reading from the unbuffered stream returned nothing</span>
</span>
<span class="line" id="L30"> <span class="tok-comment">// so we have nothing left to read.</span>
</span>
<span class="line" id="L31"> <span class="tok-kw">return</span> dest_index;</span>
<span class="line" id="L32"> }</span>
<span class="line" id="L33"> self.start = <span class="tok-number">0</span>;</span>
<span class="line" id="L34"> self.end = n;</span>
<span class="line" id="L35"> }</span>
<span class="line" id="L36"> self.start += written;</span>
<span class="line" id="L37"> dest_index += written;</span>
<span class="line" id="L38"> }</span>
<span class="line" id="L39"> <span class="tok-kw">return</span> dest.len;</span>
<span class="line" id="L40"> }</span>
<span class="line" id="L41"></span>
<span class="line" id="L42"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">reader</span>(self: *Self) Reader {</span>
<span class="line" id="L43"> <span class="tok-kw">return</span> .{ .context = self };</span>
<span class="line" id="L44"> }</span>
<span class="line" id="L45"> };</span>
<span class="line" id="L46">}</span>
<span class="line" id="L47"></span>
<span class="line" id="L48"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">bufferedReader</span>(reader: <span class="tok-kw">anytype</span>) BufferedReader(<span class="tok-number">4096</span>, <span class="tok-builtin">@TypeOf</span>(reader)) {</span>
<span class="line" id="L49"> <span class="tok-kw">return</span> .{ .unbuffered_reader = reader };</span>
<span class="line" id="L50">}</span>
<span class="line" id="L51"></span>
<span class="line" id="L52"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">bufferedReaderSize</span>(<span class="tok-kw">comptime</span> size: <span class="tok-type">usize</span>, reader: <span class="tok-kw">anytype</span>) BufferedReader(size, <span class="tok-builtin">@TypeOf</span>(reader)) {</span>
<span class="line" id="L53"> <span class="tok-kw">return</span> .{ .unbuffered_reader = reader };</span>
<span class="line" id="L54">}</span>
<span class="line" id="L55"></span>
<span class="line" id="L56"><span class="tok-kw">test</span> <span class="tok-str">"io.BufferedReader OneByte"</span> {</span>
<span class="line" id="L57"> <span class="tok-kw">const</span> OneByteReadReader = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L58"> str: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L59"> curr: <span class="tok-type">usize</span>,</span>
<span class="line" id="L60"></span>
<span class="line" id="L61"> <span class="tok-kw">const</span> Error = <span class="tok-kw">error</span>{NoError};</span>
<span class="line" id="L62"> <span class="tok-kw">const</span> Self = <span class="tok-builtin">@This</span>();</span>
<span class="line" id="L63"> <span class="tok-kw">const</span> Reader = io.Reader(*Self, Error, read);</span>
<span class="line" id="L64"></span>
<span class="line" id="L65"> <span class="tok-kw">fn</span> <span class="tok-fn">init</span>(str: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) Self {</span>
<span class="line" id="L66"> <span class="tok-kw">return</span> Self{</span>
<span class="line" id="L67"> .str = str,</span>
<span class="line" id="L68"> .curr = <span class="tok-number">0</span>,</span>
<span class="line" id="L69"> };</span>
<span class="line" id="L70"> }</span>
<span class="line" id="L71"></span>
<span class="line" id="L72"> <span class="tok-kw">fn</span> <span class="tok-fn">read</span>(self: *Self, dest: []<span class="tok-type">u8</span>) Error!<span class="tok-type">usize</span> {</span>
<span class="line" id="L73"> <span class="tok-kw">if</span> (self.str.len <= self.curr <span class="tok-kw">or</span> dest.len == <span class="tok-number">0</span>)</span>
<span class="line" id="L74"> <span class="tok-kw">return</span> <span class="tok-number">0</span>;</span>
<span class="line" id="L75"></span>
<span class="line" id="L76"> dest[<span class="tok-number">0</span>] = self.str[self.curr];</span>
<span class="line" id="L77"> self.curr += <span class="tok-number">1</span>;</span>
<span class="line" id="L78"> <span class="tok-kw">return</span> <span class="tok-number">1</span>;</span>
<span class="line" id="L79"> }</span>
<span class="line" id="L80"></span>
<span class="line" id="L81"> <span class="tok-kw">fn</span> <span class="tok-fn">reader</span>(self: *Self) Reader {</span>
<span class="line" id="L82"> <span class="tok-kw">return</span> .{ .context = self };</span>
<span class="line" id="L83"> }</span>
<span class="line" id="L84"> };</span>
<span class="line" id="L85"></span>
<span class="line" id="L86"> <span class="tok-kw">const</span> str = <span class="tok-str">"This is a test"</span>;</span>
<span class="line" id="L87"> <span class="tok-kw">var</span> one_byte_stream = OneByteReadReader.init(str);</span>
<span class="line" id="L88"> <span class="tok-kw">var</span> buf_reader = bufferedReader(one_byte_stream.reader());</span>
<span class="line" id="L89"> <span class="tok-kw">const</span> stream = buf_reader.reader();</span>
<span class="line" id="L90"></span>
<span class="line" id="L91"> <span class="tok-kw">const</span> res = <span class="tok-kw">try</span> stream.readAllAlloc(testing.allocator, str.len + <span class="tok-number">1</span>);</span>
<span class="line" id="L92"> <span class="tok-kw">defer</span> testing.allocator.free(res);</span>
<span class="line" id="L93"> <span class="tok-kw">try</span> testing.expectEqualSlices(<span class="tok-type">u8</span>, str, res);</span>
<span class="line" id="L94">}</span>
<span class="line" id="L95"></span>
<span class="line" id="L96"><span class="tok-kw">fn</span> <span class="tok-fn">smallBufferedReader</span>(underlying_stream: <span class="tok-kw">anytype</span>) BufferedReader(<span class="tok-number">8</span>, <span class="tok-builtin">@TypeOf</span>(underlying_stream)) {</span>
<span class="line" id="L97"> <span class="tok-kw">return</span> .{ .unbuffered_reader = underlying_stream };</span>
<span class="line" id="L98">}</span>
<span class="line" id="L99"><span class="tok-kw">test</span> <span class="tok-str">"io.BufferedReader Block"</span> {</span>
<span class="line" id="L100"> <span class="tok-kw">const</span> BlockReader = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L101"> block: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>,</span>
<span class="line" id="L102"> reads_allowed: <span class="tok-type">usize</span>,</span>
<span class="line" id="L103"> curr_read: <span class="tok-type">usize</span>,</span>
<span class="line" id="L104"></span>
<span class="line" id="L105"> <span class="tok-kw">const</span> Error = <span class="tok-kw">error</span>{NoError};</span>
<span class="line" id="L106"> <span class="tok-kw">const</span> Self = <span class="tok-builtin">@This</span>();</span>
<span class="line" id="L107"> <span class="tok-kw">const</span> Reader = io.Reader(*Self, Error, read);</span>
<span class="line" id="L108"></span>
<span class="line" id="L109"> <span class="tok-kw">fn</span> <span class="tok-fn">init</span>(block: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>, reads_allowed: <span class="tok-type">usize</span>) Self {</span>
<span class="line" id="L110"> <span class="tok-kw">return</span> Self{</span>
<span class="line" id="L111"> .block = block,</span>
<span class="line" id="L112"> .reads_allowed = reads_allowed,</span>
<span class="line" id="L113"> .curr_read = <span class="tok-number">0</span>,</span>
<span class="line" id="L114"> };</span>
<span class="line" id="L115"> }</span>
<span class="line" id="L116"></span>
<span class="line" id="L117"> <span class="tok-kw">fn</span> <span class="tok-fn">read</span>(self: *Self, dest: []<span class="tok-type">u8</span>) Error!<span class="tok-type">usize</span> {</span>
<span class="line" id="L118"> <span class="tok-kw">if</span> (self.curr_read >= self.reads_allowed) <span class="tok-kw">return</span> <span class="tok-number">0</span>;</span>
<span class="line" id="L119"> <span class="tok-builtin">@memcpy</span>(dest[<span class="tok-number">0</span>..self.block.len], self.block);</span>
<span class="line" id="L120"></span>
<span class="line" id="L121"> self.curr_read += <span class="tok-number">1</span>;</span>
<span class="line" id="L122"> <span class="tok-kw">return</span> self.block.len;</span>
<span class="line" id="L123"> }</span>
<span class="line" id="L124"></span>
<span class="line" id="L125"> <span class="tok-kw">fn</span> <span class="tok-fn">reader</span>(self: *Self) Reader {</span>
<span class="line" id="L126"> <span class="tok-kw">return</span> .{ .context = self };</span>
<span class="line" id="L127"> }</span>
<span class="line" id="L128"> };</span>
<span class="line" id="L129"></span>
<span class="line" id="L130"> <span class="tok-kw">const</span> block = <span class="tok-str">"0123"</span>;</span>
<span class="line" id="L131"></span>
<span class="line" id="L132"> <span class="tok-comment">// len out == block</span>
</span>
<span class="line" id="L133"> {</span>
<span class="line" id="L134"> <span class="tok-kw">var</span> block_reader = BlockReader.init(block, <span class="tok-number">2</span>);</span>
<span class="line" id="L135"> <span class="tok-kw">var</span> test_buf_reader = BufferedReader(<span class="tok-number">4</span>, BlockReader){ .unbuffered_reader = block_reader };</span>
<span class="line" id="L136"> <span class="tok-kw">var</span> out_buf: [<span class="tok-number">4</span>]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L137"> _ = <span class="tok-kw">try</span> test_buf_reader.read(&out_buf);</span>
<span class="line" id="L138"> <span class="tok-kw">try</span> testing.expectEqualSlices(<span class="tok-type">u8</span>, &out_buf, block);</span>
<span class="line" id="L139"> _ = <span class="tok-kw">try</span> test_buf_reader.read(&out_buf);</span>
<span class="line" id="L140"> <span class="tok-kw">try</span> testing.expectEqualSlices(<span class="tok-type">u8</span>, &out_buf, block);</span>
<span class="line" id="L141"> <span class="tok-kw">try</span> testing.expectEqual(<span class="tok-kw">try</span> test_buf_reader.read(&out_buf), <span class="tok-number">0</span>);</span>
<span class="line" id="L142"> }</span>
<span class="line" id="L143"></span>
<span class="line" id="L144"> <span class="tok-comment">// len out < block</span>
</span>
<span class="line" id="L145"> {</span>
<span class="line" id="L146"> <span class="tok-kw">var</span> block_reader = BlockReader.init(block, <span class="tok-number">2</span>);</span>
<span class="line" id="L147"> <span class="tok-kw">var</span> test_buf_reader = BufferedReader(<span class="tok-number">4</span>, BlockReader){ .unbuffered_reader = block_reader };</span>
<span class="line" id="L148"> <span class="tok-kw">var</span> out_buf: [<span class="tok-number">3</span>]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L149"> _ = <span class="tok-kw">try</span> test_buf_reader.read(&out_buf);</span>
<span class="line" id="L150"> <span class="tok-kw">try</span> testing.expectEqualSlices(<span class="tok-type">u8</span>, &out_buf, <span class="tok-str">"012"</span>);</span>
<span class="line" id="L151"> _ = <span class="tok-kw">try</span> test_buf_reader.read(&out_buf);</span>
<span class="line" id="L152"> <span class="tok-kw">try</span> testing.expectEqualSlices(<span class="tok-type">u8</span>, &out_buf, <span class="tok-str">"301"</span>);</span>
<span class="line" id="L153"> <span class="tok-kw">const</span> n = <span class="tok-kw">try</span> test_buf_reader.read(&out_buf);</span>
<span class="line" id="L154"> <span class="tok-kw">try</span> testing.expectEqualSlices(<span class="tok-type">u8</span>, out_buf[<span class="tok-number">0</span>..n], <span class="tok-str">"23"</span>);</span>
<span class="line" id="L155"> <span class="tok-kw">try</span> testing.expectEqual(<span class="tok-kw">try</span> test_buf_reader.read(&out_buf), <span class="tok-number">0</span>);</span>
<span class="line" id="L156"> }</span>
<span class="line" id="L157"></span>
<span class="line" id="L158"> <span class="tok-comment">// len out > block</span>
</span>
<span class="line" id="L159"> {</span>
<span class="line" id="L160"> <span class="tok-kw">var</span> block_reader = BlockReader.init(block, <span class="tok-number">2</span>);</span>
<span class="line" id="L161"> <span class="tok-kw">var</span> test_buf_reader = BufferedReader(<span class="tok-number">4</span>, BlockReader){ .unbuffered_reader = block_reader };</span>
<span class="line" id="L162"> <span class="tok-kw">var</span> out_buf: [<span class="tok-number">5</span>]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L163"> _ = <span class="tok-kw">try</span> test_buf_reader.read(&out_buf);</span>
<span class="line" id="L164"> <span class="tok-kw">try</span> testing.expectEqualSlices(<span class="tok-type">u8</span>, &out_buf, <span class="tok-str">"01230"</span>);</span>
<span class="line" id="L165"> <span class="tok-kw">const</span> n = <span class="tok-kw">try</span> test_buf_reader.read(&out_buf);</span>
<span class="line" id="L166"> <span class="tok-kw">try</span> testing.expectEqualSlices(<span class="tok-type">u8</span>, out_buf[<span class="tok-number">0</span>..n], <span class="tok-str">"123"</span>);</span>
<span class="line" id="L167"> <span class="tok-kw">try</span> testing.expectEqual(<span class="tok-kw">try</span> test_buf_reader.read(&out_buf), <span class="tok-number">0</span>);</span>
<span class="line" id="L168"> }</span>
<span class="line" id="L169"></span>
<span class="line" id="L170"> <span class="tok-comment">// len out == 0</span>
</span>
<span class="line" id="L171"> {</span>
<span class="line" id="L172"> <span class="tok-kw">var</span> block_reader = BlockReader.init(block, <span class="tok-number">2</span>);</span>
<span class="line" id="L173"> <span class="tok-kw">var</span> test_buf_reader = BufferedReader(<span class="tok-number">4</span>, BlockReader){ .unbuffered_reader = block_reader };</span>
<span class="line" id="L174"> <span class="tok-kw">var</span> out_buf: [<span class="tok-number">0</span>]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L175"> _ = <span class="tok-kw">try</span> test_buf_reader.read(&out_buf);</span>
<span class="line" id="L176"> <span class="tok-kw">try</span> testing.expectEqualSlices(<span class="tok-type">u8</span>, &out_buf, <span class="tok-str">""</span>);</span>
<span class="line" id="L177"> }</span>
<span class="line" id="L178"></span>
<span class="line" id="L179"> <span class="tok-comment">// len bufreader buf > block</span>
</span>
<span class="line" id="L180"> {</span>
<span class="line" id="L181"> <span class="tok-kw">var</span> block_reader = BlockReader.init(block, <span class="tok-number">2</span>);</span>
<span class="line" id="L182"> <span class="tok-kw">var</span> test_buf_reader = BufferedReader(<span class="tok-number">5</span>, BlockReader){ .unbuffered_reader = block_reader };</span>
<span class="line" id="L183"> <span class="tok-kw">var</span> out_buf: [<span class="tok-number">4</span>]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L184"> _ = <span class="tok-kw">try</span> test_buf_reader.read(&out_buf);</span>
<span class="line" id="L185"> <span class="tok-kw">try</span> testing.expectEqualSlices(<span class="tok-type">u8</span>, &out_buf, block);</span>
<span class="line" id="L186"> _ = <span class="tok-kw">try</span> test_buf_reader.read(&out_buf);</span>
<span class="line" id="L187"> <span class="tok-kw">try</span> testing.expectEqualSlices(<span class="tok-type">u8</span>, &out_buf, block);</span>
<span class="line" id="L188"> <span class="tok-kw">try</span> testing.expectEqual(<span class="tok-kw">try</span> test_buf_reader.read(&out_buf), <span class="tok-number">0</span>);</span>
<span class="line" id="L189"> }</span>
<span class="line" id="L190">}</span>
<span class="line" id="L191"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/io/reader.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>io/reader.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../std.zig"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> math = std.math;</span>
<span class="line" id="L3"><span class="tok-kw">const</span> assert = std.debug.assert;</span>
<span class="line" id="L4"><span class="tok-kw">const</span> mem = std.mem;</span>
<span class="line" id="L5"><span class="tok-kw">const</span> testing = std.testing;</span>
<span class="line" id="L6"><span class="tok-kw">const</span> native_endian = <span class="tok-builtin">@import</span>(<span class="tok-str">"builtin"</span>).target.cpu.arch.endian();</span>
<span class="line" id="L7"></span>
<span class="line" id="L8"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">Reader</span>(</span>
<span class="line" id="L9"> <span class="tok-kw">comptime</span> Context: <span class="tok-type">type</span>,</span>
<span class="line" id="L10"> <span class="tok-kw">comptime</span> ReadError: <span class="tok-type">type</span>,</span>
<span class="line" id="L11"> <span class="tok-comment">/// Returns the number of bytes read. It may be less than buffer.len.</span></span>
<span class="line" id="L12"> <span class="tok-comment">/// If the number of bytes read is 0, it means end of stream.</span></span>
<span class="line" id="L13"> <span class="tok-comment">/// End of stream is not an error condition.</span></span>
<span class="line" id="L14"> <span class="tok-kw">comptime</span> readFn: <span class="tok-kw">fn</span> (context: Context, buffer: []<span class="tok-type">u8</span>) ReadError!<span class="tok-type">usize</span>,</span>
<span class="line" id="L15">) <span class="tok-type">type</span> {</span>
<span class="line" id="L16"> <span class="tok-kw">return</span> <span class="tok-kw">struct</span> {</span>
<span class="line" id="L17"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> Error = ReadError;</span>
<span class="line" id="L18"></span>
<span class="line" id="L19"> context: Context,</span>
<span class="line" id="L20"></span>
<span class="line" id="L21"> <span class="tok-kw">const</span> Self = <span class="tok-builtin">@This</span>();</span>
<span class="line" id="L22"></span>
<span class="line" id="L23"> <span class="tok-comment">/// Returns the number of bytes read. It may be less than buffer.len.</span></span>
<span class="line" id="L24"> <span class="tok-comment">/// If the number of bytes read is 0, it means end of stream.</span></span>
<span class="line" id="L25"> <span class="tok-comment">/// End of stream is not an error condition.</span></span>
<span class="line" id="L26"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">read</span>(self: Self, buffer: []<span class="tok-type">u8</span>) Error!<span class="tok-type">usize</span> {</span>
<span class="line" id="L27"> <span class="tok-kw">return</span> readFn(self.context, buffer);</span>
<span class="line" id="L28"> }</span>
<span class="line" id="L29"></span>
<span class="line" id="L30"> <span class="tok-comment">/// Returns the number of bytes read. If the number read is smaller than `buffer.len`, it</span></span>
<span class="line" id="L31"> <span class="tok-comment">/// means the stream reached the end. Reaching the end of a stream is not an error</span></span>
<span class="line" id="L32"> <span class="tok-comment">/// condition.</span></span>
<span class="line" id="L33"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">readAll</span>(self: Self, buffer: []<span class="tok-type">u8</span>) Error!<span class="tok-type">usize</span> {</span>
<span class="line" id="L34"> <span class="tok-kw">return</span> readAtLeast(self, buffer, buffer.len);</span>
<span class="line" id="L35"> }</span>
<span class="line" id="L36"></span>
<span class="line" id="L37"> <span class="tok-comment">/// Returns the number of bytes read, calling the underlying read</span></span>
<span class="line" id="L38"> <span class="tok-comment">/// function the minimal number of times until the buffer has at least</span></span>
<span class="line" id="L39"> <span class="tok-comment">/// `len` bytes filled. If the number read is less than `len` it means</span></span>
<span class="line" id="L40"> <span class="tok-comment">/// the stream reached the end. Reaching the end of the stream is not</span></span>
<span class="line" id="L41"> <span class="tok-comment">/// an error condition.</span></span>
<span class="line" id="L42"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">readAtLeast</span>(self: Self, buffer: []<span class="tok-type">u8</span>, len: <span class="tok-type">usize</span>) Error!<span class="tok-type">usize</span> {</span>
<span class="line" id="L43"> assert(len <= buffer.len);</span>
<span class="line" id="L44"> <span class="tok-kw">var</span> index: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L45"> <span class="tok-kw">while</span> (index < len) {</span>
<span class="line" id="L46"> <span class="tok-kw">const</span> amt = <span class="tok-kw">try</span> self.read(buffer[index..]);</span>
<span class="line" id="L47"> <span class="tok-kw">if</span> (amt == <span class="tok-number">0</span>) <span class="tok-kw">break</span>;</span>
<span class="line" id="L48"> index += amt;</span>
<span class="line" id="L49"> }</span>
<span class="line" id="L50"> <span class="tok-kw">return</span> index;</span>
<span class="line" id="L51"> }</span>
<span class="line" id="L52"></span>
<span class="line" id="L53"> <span class="tok-comment">/// If the number read would be smaller than `buf.len`, `error.EndOfStream` is returned instead.</span></span>
<span class="line" id="L54"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">readNoEof</span>(self: Self, buf: []<span class="tok-type">u8</span>) (Error || <span class="tok-kw">error</span>{EndOfStream})!<span class="tok-type">void</span> {</span>
<span class="line" id="L55"> <span class="tok-kw">const</span> amt_read = <span class="tok-kw">try</span> self.readAll(buf);</span>
<span class="line" id="L56"> <span class="tok-kw">if</span> (amt_read < buf.len) <span class="tok-kw">return</span> <span class="tok-kw">error</span>.EndOfStream;</span>
<span class="line" id="L57"> }</span>
<span class="line" id="L58"></span>
<span class="line" id="L59"> <span class="tok-comment">/// Appends to the `std.ArrayList` contents by reading from the stream</span></span>
<span class="line" id="L60"> <span class="tok-comment">/// until end of stream is found.</span></span>
<span class="line" id="L61"> <span class="tok-comment">/// If the number of bytes appended would exceed `max_append_size`,</span></span>
<span class="line" id="L62"> <span class="tok-comment">/// `error.StreamTooLong` is returned</span></span>
<span class="line" id="L63"> <span class="tok-comment">/// and the `std.ArrayList` has exactly `max_append_size` bytes appended.</span></span>
<span class="line" id="L64"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">readAllArrayList</span>(self: Self, array_list: *std.ArrayList(<span class="tok-type">u8</span>), max_append_size: <span class="tok-type">usize</span>) !<span class="tok-type">void</span> {</span>
<span class="line" id="L65"> <span class="tok-kw">return</span> self.readAllArrayListAligned(<span class="tok-null">null</span>, array_list, max_append_size);</span>
<span class="line" id="L66"> }</span>
<span class="line" id="L67"></span>
<span class="line" id="L68"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">readAllArrayListAligned</span>(</span>
<span class="line" id="L69"> self: Self,</span>
<span class="line" id="L70"> <span class="tok-kw">comptime</span> alignment: ?<span class="tok-type">u29</span>,</span>
<span class="line" id="L71"> array_list: *std.ArrayListAligned(<span class="tok-type">u8</span>, alignment),</span>
<span class="line" id="L72"> max_append_size: <span class="tok-type">usize</span>,</span>
<span class="line" id="L73"> ) !<span class="tok-type">void</span> {</span>
<span class="line" id="L74"> <span class="tok-kw">try</span> array_list.ensureTotalCapacity(<span class="tok-builtin">@min</span>(max_append_size, <span class="tok-number">4096</span>));</span>
<span class="line" id="L75"> <span class="tok-kw">const</span> original_len = array_list.items.len;</span>
<span class="line" id="L76"> <span class="tok-kw">var</span> start_index: <span class="tok-type">usize</span> = original_len;</span>
<span class="line" id="L77"> <span class="tok-kw">while</span> (<span class="tok-null">true</span>) {</span>
<span class="line" id="L78"> array_list.expandToCapacity();</span>
<span class="line" id="L79"> <span class="tok-kw">const</span> dest_slice = array_list.items[start_index..];</span>
<span class="line" id="L80"> <span class="tok-kw">const</span> bytes_read = <span class="tok-kw">try</span> self.readAll(dest_slice);</span>
<span class="line" id="L81"> start_index += bytes_read;</span>
<span class="line" id="L82"></span>
<span class="line" id="L83"> <span class="tok-kw">if</span> (start_index - original_len > max_append_size) {</span>
<span class="line" id="L84"> array_list.shrinkAndFree(original_len + max_append_size);</span>
<span class="line" id="L85"> <span class="tok-kw">return</span> <span class="tok-kw">error</span>.StreamTooLong;</span>
<span class="line" id="L86"> }</span>
<span class="line" id="L87"></span>
<span class="line" id="L88"> <span class="tok-kw">if</span> (bytes_read != dest_slice.len) {</span>
<span class="line" id="L89"> array_list.shrinkAndFree(start_index);</span>
<span class="line" id="L90"> <span class="tok-kw">return</span>;</span>
<span class="line" id="L91"> }</span>
<span class="line" id="L92"></span>
<span class="line" id="L93"> <span class="tok-comment">// This will trigger ArrayList to expand superlinearly at whatever its growth rate is.</span>
</span>
<span class="line" id="L94"> <span class="tok-kw">try</span> array_list.ensureTotalCapacity(start_index + <span class="tok-number">1</span>);</span>
<span class="line" id="L95"> }</span>
<span class="line" id="L96"> }</span>
<span class="line" id="L97"></span>
<span class="line" id="L98"> <span class="tok-comment">/// Allocates enough memory to hold all the contents of the stream. If the allocated</span></span>
<span class="line" id="L99"> <span class="tok-comment">/// memory would be greater than `max_size`, returns `error.StreamTooLong`.</span></span>
<span class="line" id="L100"> <span class="tok-comment">/// Caller owns returned memory.</span></span>
<span class="line" id="L101"> <span class="tok-comment">/// If this function returns an error, the contents from the stream read so far are lost.</span></span>
<span class="line" id="L102"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">readAllAlloc</span>(self: Self, allocator: mem.Allocator, max_size: <span class="tok-type">usize</span>) ![]<span class="tok-type">u8</span> {</span>
<span class="line" id="L103"> <span class="tok-kw">var</span> array_list = std.ArrayList(<span class="tok-type">u8</span>).init(allocator);</span>
<span class="line" id="L104"> <span class="tok-kw">defer</span> array_list.deinit();</span>
<span class="line" id="L105"> <span class="tok-kw">try</span> self.readAllArrayList(&array_list, max_size);</span>
<span class="line" id="L106"> <span class="tok-kw">return</span> <span class="tok-kw">try</span> array_list.toOwnedSlice();</span>
<span class="line" id="L107"> }</span>
<span class="line" id="L108"></span>
<span class="line" id="L109"> <span class="tok-comment">/// Deprecated: use `streamUntilDelimiter` with ArrayList's writer instead.</span></span>
<span class="line" id="L110"> <span class="tok-comment">/// Replaces the `std.ArrayList` contents by reading from the stream until `delimiter` is found.</span></span>
<span class="line" id="L111"> <span class="tok-comment">/// Does not include the delimiter in the result.</span></span>
<span class="line" id="L112"> <span class="tok-comment">/// If the `std.ArrayList` length would exceed `max_size`, `error.StreamTooLong` is returned and the</span></span>
<span class="line" id="L113"> <span class="tok-comment">/// `std.ArrayList` is populated with `max_size` bytes from the stream.</span></span>
<span class="line" id="L114"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">readUntilDelimiterArrayList</span>(</span>
<span class="line" id="L115"> self: Self,</span>
<span class="line" id="L116"> array_list: *std.ArrayList(<span class="tok-type">u8</span>),</span>
<span class="line" id="L117"> delimiter: <span class="tok-type">u8</span>,</span>
<span class="line" id="L118"> max_size: <span class="tok-type">usize</span>,</span>
<span class="line" id="L119"> ) !<span class="tok-type">void</span> {</span>
<span class="line" id="L120"> array_list.shrinkRetainingCapacity(<span class="tok-number">0</span>);</span>
<span class="line" id="L121"> <span class="tok-kw">try</span> self.streamUntilDelimiter(array_list.writer(), delimiter, max_size);</span>
<span class="line" id="L122"> }</span>
<span class="line" id="L123"></span>
<span class="line" id="L124"> <span class="tok-comment">/// Deprecated: use `streamUntilDelimiter` with ArrayList's writer instead.</span></span>
<span class="line" id="L125"> <span class="tok-comment">/// Allocates enough memory to read until `delimiter`. If the allocated</span></span>
<span class="line" id="L126"> <span class="tok-comment">/// memory would be greater than `max_size`, returns `error.StreamTooLong`.</span></span>
<span class="line" id="L127"> <span class="tok-comment">/// Caller owns returned memory.</span></span>
<span class="line" id="L128"> <span class="tok-comment">/// If this function returns an error, the contents from the stream read so far are lost.</span></span>
<span class="line" id="L129"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">readUntilDelimiterAlloc</span>(</span>
<span class="line" id="L130"> self: Self,</span>
<span class="line" id="L131"> allocator: mem.Allocator,</span>
<span class="line" id="L132"> delimiter: <span class="tok-type">u8</span>,</span>
<span class="line" id="L133"> max_size: <span class="tok-type">usize</span>,</span>
<span class="line" id="L134"> ) ![]<span class="tok-type">u8</span> {</span>
<span class="line" id="L135"> <span class="tok-kw">var</span> array_list = std.ArrayList(<span class="tok-type">u8</span>).init(allocator);</span>
<span class="line" id="L136"> <span class="tok-kw">defer</span> array_list.deinit();</span>
<span class="line" id="L137"> <span class="tok-kw">try</span> self.streamUntilDelimiter(array_list.writer(), delimiter, max_size);</span>
<span class="line" id="L138"> <span class="tok-kw">return</span> <span class="tok-kw">try</span> array_list.toOwnedSlice();</span>
<span class="line" id="L139"> }</span>
<span class="line" id="L140"></span>
<span class="line" id="L141"> <span class="tok-comment">/// Deprecated: use `streamUntilDelimiter` with FixedBufferStream's writer instead.</span></span>
<span class="line" id="L142"> <span class="tok-comment">/// Reads from the stream until specified byte is found. If the buffer is not</span></span>
<span class="line" id="L143"> <span class="tok-comment">/// large enough to hold the entire contents, `error.StreamTooLong` is returned.</span></span>
<span class="line" id="L144"> <span class="tok-comment">/// If end-of-stream is found, `error.EndOfStream` is returned.</span></span>
<span class="line" id="L145"> <span class="tok-comment">/// Returns a slice of the stream data, with ptr equal to `buf.ptr`. The</span></span>
<span class="line" id="L146"> <span class="tok-comment">/// delimiter byte is written to the output buffer but is not included</span></span>
<span class="line" id="L147"> <span class="tok-comment">/// in the returned slice.</span></span>
<span class="line" id="L148"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">readUntilDelimiter</span>(self: Self, buf: []<span class="tok-type">u8</span>, delimiter: <span class="tok-type">u8</span>) ![]<span class="tok-type">u8</span> {</span>
<span class="line" id="L149"> <span class="tok-kw">var</span> fbs = std.io.fixedBufferStream(buf);</span>
<span class="line" id="L150"> <span class="tok-kw">try</span> self.streamUntilDelimiter(fbs.writer(), delimiter, fbs.buffer.len);</span>
<span class="line" id="L151"> <span class="tok-kw">const</span> output = fbs.getWritten();</span>
<span class="line" id="L152"> buf[output.len] = delimiter; <span class="tok-comment">// emulating old behaviour</span>
</span>
<span class="line" id="L153"> <span class="tok-kw">return</span> output;</span>
<span class="line" id="L154"> }</span>
<span class="line" id="L155"></span>
<span class="line" id="L156"> <span class="tok-comment">/// Deprecated: use `streamUntilDelimiter` with ArrayList's (or any other's) writer instead.</span></span>
<span class="line" id="L157"> <span class="tok-comment">/// Allocates enough memory to read until `delimiter` or end-of-stream.</span></span>
<span class="line" id="L158"> <span class="tok-comment">/// If the allocated memory would be greater than `max_size`, returns</span></span>
<span class="line" id="L159"> <span class="tok-comment">/// `error.StreamTooLong`. If end-of-stream is found, returns the rest</span></span>
<span class="line" id="L160"> <span class="tok-comment">/// of the stream. If this function is called again after that, returns</span></span>
<span class="line" id="L161"> <span class="tok-comment">/// null.</span></span>
<span class="line" id="L162"> <span class="tok-comment">/// Caller owns returned memory.</span></span>
<span class="line" id="L163"> <span class="tok-comment">/// If this function returns an error, the contents from the stream read so far are lost.</span></span>
<span class="line" id="L164"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">readUntilDelimiterOrEofAlloc</span>(</span>
<span class="line" id="L165"> self: Self,</span>
<span class="line" id="L166"> allocator: mem.Allocator,</span>
<span class="line" id="L167"> delimiter: <span class="tok-type">u8</span>,</span>
<span class="line" id="L168"> max_size: <span class="tok-type">usize</span>,</span>
<span class="line" id="L169"> ) !?[]<span class="tok-type">u8</span> {</span>
<span class="line" id="L170"> <span class="tok-kw">var</span> array_list = std.ArrayList(<span class="tok-type">u8</span>).init(allocator);</span>
<span class="line" id="L171"> <span class="tok-kw">defer</span> array_list.deinit();</span>
<span class="line" id="L172"> self.streamUntilDelimiter(array_list.writer(), delimiter, max_size) <span class="tok-kw">catch</span> |err| <span class="tok-kw">switch</span> (err) {</span>
<span class="line" id="L173"> <span class="tok-kw">error</span>.EndOfStream => <span class="tok-kw">if</span> (array_list.items.len == <span class="tok-number">0</span>) {</span>
<span class="line" id="L174"> <span class="tok-kw">return</span> <span class="tok-null">null</span>;</span>
<span class="line" id="L175"> },</span>
<span class="line" id="L176"> <span class="tok-kw">else</span> => |e| <span class="tok-kw">return</span> e,</span>
<span class="line" id="L177"> };</span>
<span class="line" id="L178"> <span class="tok-kw">return</span> <span class="tok-kw">try</span> array_list.toOwnedSlice();</span>
<span class="line" id="L179"> }</span>
<span class="line" id="L180"></span>
<span class="line" id="L181"> <span class="tok-comment">/// Deprecated: use `streamUntilDelimiter` with FixedBufferStream's writer instead.</span></span>
<span class="line" id="L182"> <span class="tok-comment">/// Reads from the stream until specified byte is found. If the buffer is not</span></span>
<span class="line" id="L183"> <span class="tok-comment">/// large enough to hold the entire contents, `error.StreamTooLong` is returned.</span></span>
<span class="line" id="L184"> <span class="tok-comment">/// If end-of-stream is found, returns the rest of the stream. If this</span></span>
<span class="line" id="L185"> <span class="tok-comment">/// function is called again after that, returns null.</span></span>
<span class="line" id="L186"> <span class="tok-comment">/// Returns a slice of the stream data, with ptr equal to `buf.ptr`. The</span></span>
<span class="line" id="L187"> <span class="tok-comment">/// delimiter byte is written to the output buffer but is not included</span></span>
<span class="line" id="L188"> <span class="tok-comment">/// in the returned slice.</span></span>
<span class="line" id="L189"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">readUntilDelimiterOrEof</span>(self: Self, buf: []<span class="tok-type">u8</span>, delimiter: <span class="tok-type">u8</span>) !?[]<span class="tok-type">u8</span> {</span>
<span class="line" id="L190"> <span class="tok-kw">var</span> fbs = std.io.fixedBufferStream(buf);</span>
<span class="line" id="L191"> self.streamUntilDelimiter(fbs.writer(), delimiter, fbs.buffer.len) <span class="tok-kw">catch</span> |err| <span class="tok-kw">switch</span> (err) {</span>
<span class="line" id="L192"> <span class="tok-kw">error</span>.EndOfStream => <span class="tok-kw">if</span> (fbs.getWritten().len == <span class="tok-number">0</span>) {</span>
<span class="line" id="L193"> <span class="tok-kw">return</span> <span class="tok-null">null</span>;</span>
<span class="line" id="L194"> },</span>
<span class="line" id="L195"></span>
<span class="line" id="L196"> <span class="tok-kw">else</span> => |e| <span class="tok-kw">return</span> e,</span>
<span class="line" id="L197"> };</span>
<span class="line" id="L198"> <span class="tok-kw">const</span> output = fbs.getWritten();</span>
<span class="line" id="L199"> buf[output.len] = delimiter; <span class="tok-comment">// emulating old behaviour</span>
</span>
<span class="line" id="L200"> <span class="tok-kw">return</span> output;</span>
<span class="line" id="L201"> }</span>
<span class="line" id="L202"></span>
<span class="line" id="L203"> <span class="tok-comment">/// Appends to the `writer` contents by reading from the stream until `delimiter` is found.</span></span>
<span class="line" id="L204"> <span class="tok-comment">/// Does not write the delimiter itself.</span></span>
<span class="line" id="L205"> <span class="tok-comment">/// If `optional_max_size` is not null and amount of written bytes exceeds `optional_max_size`,</span></span>
<span class="line" id="L206"> <span class="tok-comment">/// returns `error.StreamTooLong` and finishes appending.</span></span>
<span class="line" id="L207"> <span class="tok-comment">/// If `optional_max_size` is null, appending is unbounded.</span></span>
<span class="line" id="L208"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">streamUntilDelimiter</span>(self: Self, writer: <span class="tok-kw">anytype</span>, delimiter: <span class="tok-type">u8</span>, optional_max_size: ?<span class="tok-type">usize</span>) (Error || <span class="tok-kw">error</span>{ EndOfStream, StreamTooLong } || <span class="tok-builtin">@TypeOf</span>(writer).Error)!<span class="tok-type">void</span> {</span>
<span class="line" id="L209"> <span class="tok-kw">if</span> (optional_max_size) |max_size| {</span>
<span class="line" id="L210"> <span class="tok-kw">for</span> (<span class="tok-number">0</span>..max_size) |_| {</span>
<span class="line" id="L211"> <span class="tok-kw">const</span> byte: <span class="tok-type">u8</span> = <span class="tok-kw">try</span> self.readByte(); <span class="tok-comment">// (Error || error{EndOfStream})</span>
</span>
<span class="line" id="L212"> <span class="tok-kw">if</span> (byte == delimiter) <span class="tok-kw">return</span>;</span>
<span class="line" id="L213"> <span class="tok-kw">try</span> writer.writeByte(byte); <span class="tok-comment">// @TypeOf(writer).Error</span>
</span>
<span class="line" id="L214"> }</span>
<span class="line" id="L215"> <span class="tok-kw">return</span> <span class="tok-kw">error</span>.StreamTooLong;</span>
<span class="line" id="L216"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L217"> <span class="tok-kw">while</span> (<span class="tok-null">true</span>) {</span>
<span class="line" id="L218"> <span class="tok-kw">const</span> byte: <span class="tok-type">u8</span> = <span class="tok-kw">try</span> self.readByte(); <span class="tok-comment">// (Error || error{EndOfStream})</span>
</span>
<span class="line" id="L219"> <span class="tok-kw">if</span> (byte == delimiter) <span class="tok-kw">return</span>;</span>
<span class="line" id="L220"> <span class="tok-kw">try</span> writer.writeByte(byte); <span class="tok-comment">// @TypeOf(writer).Error</span>
</span>
<span class="line" id="L221"> }</span>
<span class="line" id="L222"> <span class="tok-comment">// Can not throw `error.StreamTooLong` since there are no boundary.</span>
</span>
<span class="line" id="L223"> }</span>
<span class="line" id="L224"> }</span>
<span class="line" id="L225"></span>
<span class="line" id="L226"> <span class="tok-comment">/// Reads from the stream until specified byte is found, discarding all data,</span></span>
<span class="line" id="L227"> <span class="tok-comment">/// including the delimiter.</span></span>
<span class="line" id="L228"> <span class="tok-comment">/// If end-of-stream is found, this function succeeds.</span></span>
<span class="line" id="L229"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">skipUntilDelimiterOrEof</span>(self: Self, delimiter: <span class="tok-type">u8</span>) Error!<span class="tok-type">void</span> {</span>
<span class="line" id="L230"> <span class="tok-kw">while</span> (<span class="tok-null">true</span>) {</span>
<span class="line" id="L231"> <span class="tok-kw">const</span> byte = self.readByte() <span class="tok-kw">catch</span> |err| <span class="tok-kw">switch</span> (err) {</span>
<span class="line" id="L232"> <span class="tok-kw">error</span>.EndOfStream => <span class="tok-kw">return</span>,</span>
<span class="line" id="L233"> <span class="tok-kw">else</span> => |e| <span class="tok-kw">return</span> e,</span>
<span class="line" id="L234"> };</span>
<span class="line" id="L235"> <span class="tok-kw">if</span> (byte == delimiter) <span class="tok-kw">return</span>;</span>
<span class="line" id="L236"> }</span>
<span class="line" id="L237"> }</span>
<span class="line" id="L238"></span>
<span class="line" id="L239"> <span class="tok-comment">/// Reads 1 byte from the stream or returns `error.EndOfStream`.</span></span>
<span class="line" id="L240"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">readByte</span>(self: Self) (Error || <span class="tok-kw">error</span>{EndOfStream})!<span class="tok-type">u8</span> {</span>
<span class="line" id="L241"> <span class="tok-kw">var</span> result: [<span class="tok-number">1</span>]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L242"> <span class="tok-kw">const</span> amt_read = <span class="tok-kw">try</span> self.read(result[<span class="tok-number">0</span>..]);</span>
<span class="line" id="L243"> <span class="tok-kw">if</span> (amt_read < <span class="tok-number">1</span>) <span class="tok-kw">return</span> <span class="tok-kw">error</span>.EndOfStream;</span>
<span class="line" id="L244"> <span class="tok-kw">return</span> result[<span class="tok-number">0</span>];</span>
<span class="line" id="L245"> }</span>
<span class="line" id="L246"></span>
<span class="line" id="L247"> <span class="tok-comment">/// Same as `readByte` except the returned byte is signed.</span></span>
<span class="line" id="L248"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">readByteSigned</span>(self: Self) (Error || <span class="tok-kw">error</span>{EndOfStream})!<span class="tok-type">i8</span> {</span>
<span class="line" id="L249"> <span class="tok-kw">return</span> <span class="tok-builtin">@as</span>(<span class="tok-type">i8</span>, <span class="tok-builtin">@bitCast</span>(<span class="tok-kw">try</span> self.readByte()));</span>
<span class="line" id="L250"> }</span>
<span class="line" id="L251"></span>
<span class="line" id="L252"> <span class="tok-comment">/// Reads exactly `num_bytes` bytes and returns as an array.</span></span>
<span class="line" id="L253"> <span class="tok-comment">/// `num_bytes` must be comptime-known</span></span>
<span class="line" id="L254"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">readBytesNoEof</span>(self: Self, <span class="tok-kw">comptime</span> num_bytes: <span class="tok-type">usize</span>) (Error || <span class="tok-kw">error</span>{EndOfStream})![num_bytes]<span class="tok-type">u8</span> {</span>
<span class="line" id="L255"> <span class="tok-kw">var</span> bytes: [num_bytes]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L256"> <span class="tok-kw">try</span> self.readNoEof(&bytes);</span>
<span class="line" id="L257"> <span class="tok-kw">return</span> bytes;</span>
<span class="line" id="L258"> }</span>
<span class="line" id="L259"></span>
<span class="line" id="L260"> <span class="tok-comment">/// Reads bytes into the bounded array, until</span></span>
<span class="line" id="L261"> <span class="tok-comment">/// the bounded array is full, or the stream ends.</span></span>
<span class="line" id="L262"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">readIntoBoundedBytes</span>(</span>
<span class="line" id="L263"> self: Self,</span>
<span class="line" id="L264"> <span class="tok-kw">comptime</span> num_bytes: <span class="tok-type">usize</span>,</span>
<span class="line" id="L265"> bounded: *std.BoundedArray(<span class="tok-type">u8</span>, num_bytes),</span>
<span class="line" id="L266"> ) Error!<span class="tok-type">void</span> {</span>
<span class="line" id="L267"> <span class="tok-kw">while</span> (bounded.len < num_bytes) {</span>
<span class="line" id="L268"> <span class="tok-kw">const</span> bytes_read = <span class="tok-kw">try</span> self.read(bounded.unusedCapacitySlice());</span>
<span class="line" id="L269"> <span class="tok-kw">if</span> (bytes_read == <span class="tok-number">0</span>) <span class="tok-kw">return</span>;</span>
<span class="line" id="L270"> bounded.len += bytes_read;</span>
<span class="line" id="L271"> }</span>
<span class="line" id="L272"> }</span>
<span class="line" id="L273"></span>
<span class="line" id="L274"> <span class="tok-comment">/// Reads at most `num_bytes` and returns as a bounded array.</span></span>
<span class="line" id="L275"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">readBoundedBytes</span>(self: Self, <span class="tok-kw">comptime</span> num_bytes: <span class="tok-type">usize</span>) Error!std.BoundedArray(<span class="tok-type">u8</span>, num_bytes) {</span>
<span class="line" id="L276"> <span class="tok-kw">var</span> result = std.BoundedArray(<span class="tok-type">u8</span>, num_bytes){};</span>
<span class="line" id="L277"> <span class="tok-kw">try</span> self.readIntoBoundedBytes(num_bytes, &result);</span>
<span class="line" id="L278"> <span class="tok-kw">return</span> result;</span>
<span class="line" id="L279"> }</span>
<span class="line" id="L280"></span>
<span class="line" id="L281"> <span class="tok-comment">/// Reads a native-endian integer</span></span>
<span class="line" id="L282"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">readIntNative</span>(self: Self, <span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>) (Error || <span class="tok-kw">error</span>{EndOfStream})!T {</span>
<span class="line" id="L283"> <span class="tok-kw">const</span> bytes = <span class="tok-kw">try</span> self.readBytesNoEof(<span class="tok-builtin">@as</span>(<span class="tok-type">u16</span>, <span class="tok-builtin">@intCast</span>((<span class="tok-builtin">@as</span>(<span class="tok-type">u17</span>, <span class="tok-builtin">@typeInfo</span>(T).Int.bits) + <span class="tok-number">7</span>) / <span class="tok-number">8</span>)));</span>
<span class="line" id="L284"> <span class="tok-kw">return</span> mem.readIntNative(T, &bytes);</span>
<span class="line" id="L285"> }</span>
<span class="line" id="L286"></span>
<span class="line" id="L287"> <span class="tok-comment">/// Reads a foreign-endian integer</span></span>
<span class="line" id="L288"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">readIntForeign</span>(self: Self, <span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>) (Error || <span class="tok-kw">error</span>{EndOfStream})!T {</span>
<span class="line" id="L289"> <span class="tok-kw">const</span> bytes = <span class="tok-kw">try</span> self.readBytesNoEof(<span class="tok-builtin">@as</span>(<span class="tok-type">u16</span>, <span class="tok-builtin">@intCast</span>((<span class="tok-builtin">@as</span>(<span class="tok-type">u17</span>, <span class="tok-builtin">@typeInfo</span>(T).Int.bits) + <span class="tok-number">7</span>) / <span class="tok-number">8</span>)));</span>
<span class="line" id="L290"> <span class="tok-kw">return</span> mem.readIntForeign(T, &bytes);</span>
<span class="line" id="L291"> }</span>
<span class="line" id="L292"></span>
<span class="line" id="L293"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">readIntLittle</span>(self: Self, <span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>) !T {</span>
<span class="line" id="L294"> <span class="tok-kw">const</span> bytes = <span class="tok-kw">try</span> self.readBytesNoEof(<span class="tok-builtin">@as</span>(<span class="tok-type">u16</span>, <span class="tok-builtin">@intCast</span>((<span class="tok-builtin">@as</span>(<span class="tok-type">u17</span>, <span class="tok-builtin">@typeInfo</span>(T).Int.bits) + <span class="tok-number">7</span>) / <span class="tok-number">8</span>)));</span>
<span class="line" id="L295"> <span class="tok-kw">return</span> mem.readIntLittle(T, &bytes);</span>
<span class="line" id="L296"> }</span>
<span class="line" id="L297"></span>
<span class="line" id="L298"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">readIntBig</span>(self: Self, <span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>) !T {</span>
<span class="line" id="L299"> <span class="tok-kw">const</span> bytes = <span class="tok-kw">try</span> self.readBytesNoEof(<span class="tok-builtin">@as</span>(<span class="tok-type">u16</span>, <span class="tok-builtin">@intCast</span>((<span class="tok-builtin">@as</span>(<span class="tok-type">u17</span>, <span class="tok-builtin">@typeInfo</span>(T).Int.bits) + <span class="tok-number">7</span>) / <span class="tok-number">8</span>)));</span>
<span class="line" id="L300"> <span class="tok-kw">return</span> mem.readIntBig(T, &bytes);</span>
<span class="line" id="L301"> }</span>
<span class="line" id="L302"></span>
<span class="line" id="L303"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">readInt</span>(self: Self, <span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>, endian: std.builtin.Endian) !T {</span>
<span class="line" id="L304"> <span class="tok-kw">const</span> bytes = <span class="tok-kw">try</span> self.readBytesNoEof(<span class="tok-builtin">@as</span>(<span class="tok-type">u16</span>, <span class="tok-builtin">@intCast</span>((<span class="tok-builtin">@as</span>(<span class="tok-type">u17</span>, <span class="tok-builtin">@typeInfo</span>(T).Int.bits) + <span class="tok-number">7</span>) / <span class="tok-number">8</span>)));</span>
<span class="line" id="L305"> <span class="tok-kw">return</span> mem.readInt(T, &bytes, endian);</span>
<span class="line" id="L306"> }</span>
<span class="line" id="L307"></span>
<span class="line" id="L308"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">readVarInt</span>(self: Self, <span class="tok-kw">comptime</span> ReturnType: <span class="tok-type">type</span>, endian: std.builtin.Endian, size: <span class="tok-type">usize</span>) !ReturnType {</span>
<span class="line" id="L309"> assert(size <= <span class="tok-builtin">@sizeOf</span>(ReturnType));</span>
<span class="line" id="L310"> <span class="tok-kw">var</span> bytes_buf: [<span class="tok-builtin">@sizeOf</span>(ReturnType)]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L311"> <span class="tok-kw">const</span> bytes = bytes_buf[<span class="tok-number">0</span>..size];</span>
<span class="line" id="L312"> <span class="tok-kw">try</span> self.readNoEof(bytes);</span>
<span class="line" id="L313"> <span class="tok-kw">return</span> mem.readVarInt(ReturnType, bytes, endian);</span>
<span class="line" id="L314"> }</span>
<span class="line" id="L315"></span>
<span class="line" id="L316"> <span class="tok-comment">/// Optional parameters for `skipBytes`</span></span>
<span class="line" id="L317"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> SkipBytesOptions = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L318"> buf_size: <span class="tok-type">usize</span> = <span class="tok-number">512</span>,</span>
<span class="line" id="L319"> };</span>
<span class="line" id="L320"></span>
<span class="line" id="L321"> <span class="tok-comment">// `num_bytes` is a `u64` to match `off_t`</span>
</span>
<span class="line" id="L322"> <span class="tok-comment">/// Reads `num_bytes` bytes from the stream and discards them</span></span>
<span class="line" id="L323"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">skipBytes</span>(self: Self, num_bytes: <span class="tok-type">u64</span>, <span class="tok-kw">comptime</span> options: SkipBytesOptions) !<span class="tok-type">void</span> {</span>
<span class="line" id="L324"> <span class="tok-kw">var</span> buf: [options.buf_size]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L325"> <span class="tok-kw">var</span> remaining = num_bytes;</span>
<span class="line" id="L326"></span>
<span class="line" id="L327"> <span class="tok-kw">while</span> (remaining > <span class="tok-number">0</span>) {</span>
<span class="line" id="L328"> <span class="tok-kw">const</span> amt = <span class="tok-builtin">@min</span>(remaining, options.buf_size);</span>
<span class="line" id="L329"> <span class="tok-kw">try</span> self.readNoEof(buf[<span class="tok-number">0</span>..amt]);</span>
<span class="line" id="L330"> remaining -= amt;</span>
<span class="line" id="L331"> }</span>
<span class="line" id="L332"> }</span>
<span class="line" id="L333"></span>
<span class="line" id="L334"> <span class="tok-comment">/// Reads `slice.len` bytes from the stream and returns if they are the same as the passed slice</span></span>
<span class="line" id="L335"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">isBytes</span>(self: Self, slice: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) !<span class="tok-type">bool</span> {</span>
<span class="line" id="L336"> <span class="tok-kw">var</span> i: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L337"> <span class="tok-kw">var</span> matches = <span class="tok-null">true</span>;</span>
<span class="line" id="L338"> <span class="tok-kw">while</span> (i < slice.len) : (i += <span class="tok-number">1</span>) {</span>
<span class="line" id="L339"> <span class="tok-kw">if</span> (slice[i] != <span class="tok-kw">try</span> self.readByte()) {</span>
<span class="line" id="L340"> matches = <span class="tok-null">false</span>;</span>
<span class="line" id="L341"> }</span>
<span class="line" id="L342"> }</span>
<span class="line" id="L343"> <span class="tok-kw">return</span> matches;</span>
<span class="line" id="L344"> }</span>
<span class="line" id="L345"></span>
<span class="line" id="L346"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">readStruct</span>(self: Self, <span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>) !T {</span>
<span class="line" id="L347"> <span class="tok-comment">// Only extern and packed structs have defined in-memory layout.</span>
</span>
<span class="line" id="L348"> <span class="tok-kw">comptime</span> assert(<span class="tok-builtin">@typeInfo</span>(T).Struct.layout != .Auto);</span>
<span class="line" id="L349"> <span class="tok-kw">var</span> res: [<span class="tok-number">1</span>]T = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L350"> <span class="tok-kw">try</span> self.readNoEof(mem.sliceAsBytes(res[<span class="tok-number">0</span>..]));</span>
<span class="line" id="L351"> <span class="tok-kw">return</span> res[<span class="tok-number">0</span>];</span>
<span class="line" id="L352"> }</span>
<span class="line" id="L353"></span>
<span class="line" id="L354"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">readStructBig</span>(self: Self, <span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>) !T {</span>
<span class="line" id="L355"> <span class="tok-kw">var</span> res = <span class="tok-kw">try</span> self.readStruct(T);</span>
<span class="line" id="L356"> <span class="tok-kw">if</span> (native_endian != std.builtin.Endian.Big) {</span>
<span class="line" id="L357"> mem.byteSwapAllFields(T, &res);</span>
<span class="line" id="L358"> }</span>
<span class="line" id="L359"> <span class="tok-kw">return</span> res;</span>
<span class="line" id="L360"> }</span>
<span class="line" id="L361"></span>
<span class="line" id="L362"> <span class="tok-comment">/// Reads an integer with the same size as the given enum's tag type. If the integer matches</span></span>
<span class="line" id="L363"> <span class="tok-comment">/// an enum tag, casts the integer to the enum tag and returns it. Otherwise, returns an `error.InvalidValue`.</span></span>
<span class="line" id="L364"> <span class="tok-comment">/// TODO optimization taking advantage of most fields being in order</span></span>
<span class="line" id="L365"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">readEnum</span>(self: Self, <span class="tok-kw">comptime</span> Enum: <span class="tok-type">type</span>, endian: std.builtin.Endian) !Enum {</span>
<span class="line" id="L366"> <span class="tok-kw">const</span> E = <span class="tok-kw">error</span>{</span>
<span class="line" id="L367"> <span class="tok-comment">/// An integer was read, but it did not match any of the tags in the supplied enum.</span></span>
<span class="line" id="L368"> InvalidValue,</span>
<span class="line" id="L369"> };</span>
<span class="line" id="L370"> <span class="tok-kw">const</span> type_info = <span class="tok-builtin">@typeInfo</span>(Enum).Enum;</span>
<span class="line" id="L371"> <span class="tok-kw">const</span> tag = <span class="tok-kw">try</span> self.readInt(type_info.tag_type, endian);</span>
<span class="line" id="L372"></span>
<span class="line" id="L373"> <span class="tok-kw">inline</span> <span class="tok-kw">for</span> (std.meta.fields(Enum)) |field| {</span>
<span class="line" id="L374"> <span class="tok-kw">if</span> (tag == field.value) {</span>
<span class="line" id="L375"> <span class="tok-kw">return</span> <span class="tok-builtin">@field</span>(Enum, field.name);</span>
<span class="line" id="L376"> }</span>
<span class="line" id="L377"> }</span>
<span class="line" id="L378"></span>
<span class="line" id="L379"> <span class="tok-kw">return</span> E.InvalidValue;</span>
<span class="line" id="L380"> }</span>
<span class="line" id="L381"> };</span>
<span class="line" id="L382">}</span>
<span class="line" id="L383"></span>
<span class="line" id="L384"><span class="tok-kw">test</span> <span class="tok-str">"Reader"</span> {</span>
<span class="line" id="L385"> <span class="tok-kw">var</span> buf = <span class="tok-str">"a\x02"</span>.*;</span>
<span class="line" id="L386"> <span class="tok-kw">var</span> fis = std.io.fixedBufferStream(&buf);</span>
<span class="line" id="L387"> <span class="tok-kw">const</span> reader = fis.reader();</span>
<span class="line" id="L388"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> reader.readByte()) == <span class="tok-str">'a'</span>);</span>
<span class="line" id="L389"> <span class="tok-kw">try</span> testing.expect((<span class="tok-kw">try</span> reader.readEnum(<span class="tok-kw">enum</span>(<span class="tok-type">u8</span>) {</span>
<span class="line" id="L390"> a = <span class="tok-number">0</span>,</span>
<span class="line" id="L391"> b = <span class="tok-number">99</span>,</span>
<span class="line" id="L392"> c = <span class="tok-number">2</span>,</span>
<span class="line" id="L393"> d = <span class="tok-number">3</span>,</span>
<span class="line" id="L394"> }, <span class="tok-null">undefined</span>)) == .c);</span>
<span class="line" id="L395"> <span class="tok-kw">try</span> testing.expectError(<span class="tok-kw">error</span>.EndOfStream, reader.readByte());</span>
<span class="line" id="L396">}</span>
<span class="line" id="L397"></span>
<span class="line" id="L398"><span class="tok-kw">test</span> <span class="tok-str">"Reader.isBytes"</span> {</span>
<span class="line" id="L399"> <span class="tok-kw">var</span> fis = std.io.fixedBufferStream(<span class="tok-str">"foobar"</span>);</span>
<span class="line" id="L400"> <span class="tok-kw">const</span> reader = fis.reader();</span>
<span class="line" id="L401"> <span class="tok-kw">try</span> testing.expectEqual(<span class="tok-null">true</span>, <span class="tok-kw">try</span> reader.isBytes(<span class="tok-str">"foo"</span>));</span>
<span class="line" id="L402"> <span class="tok-kw">try</span> testing.expectEqual(<span class="tok-null">false</span>, <span class="tok-kw">try</span> reader.isBytes(<span class="tok-str">"qux"</span>));</span>
<span class="line" id="L403">}</span>
<span class="line" id="L404"></span>
<span class="line" id="L405"><span class="tok-kw">test</span> <span class="tok-str">"Reader.skipBytes"</span> {</span>
<span class="line" id="L406"> <span class="tok-kw">var</span> fis = std.io.fixedBufferStream(<span class="tok-str">"foobar"</span>);</span>
<span class="line" id="L407"> <span class="tok-kw">const</span> reader = fis.reader();</span>
<span class="line" id="L408"> <span class="tok-kw">try</span> reader.skipBytes(<span class="tok-number">3</span>, .{});</span>
<span class="line" id="L409"> <span class="tok-kw">try</span> testing.expect(<span class="tok-kw">try</span> reader.isBytes(<span class="tok-str">"bar"</span>));</span>
<span class="line" id="L410"> <span class="tok-kw">try</span> reader.skipBytes(<span class="tok-number">0</span>, .{});</span>
<span class="line" id="L411"> <span class="tok-kw">try</span> testing.expectError(<span class="tok-kw">error</span>.EndOfStream, reader.skipBytes(<span class="tok-number">1</span>, .{}));</span>
<span class="line" id="L412">}</span>
<span class="line" id="L413"></span>
<span class="line" id="L414"><span class="tok-kw">test</span> <span class="tok-str">"Reader.readUntilDelimiterArrayList returns ArrayLists with bytes read until the delimiter, then EndOfStream"</span> {</span>
<span class="line" id="L415"> <span class="tok-kw">const</span> a = std.testing.allocator;</span>
<span class="line" id="L416"> <span class="tok-kw">var</span> list = std.ArrayList(<span class="tok-type">u8</span>).init(a);</span>
<span class="line" id="L417"> <span class="tok-kw">defer</span> list.deinit();</span>
<span class="line" id="L418"></span>
<span class="line" id="L419"> <span class="tok-kw">var</span> fis = std.io.fixedBufferStream(<span class="tok-str">"0000\n1234\n"</span>);</span>
<span class="line" id="L420"> <span class="tok-kw">const</span> reader = fis.reader();</span>
<span class="line" id="L421"></span>
<span class="line" id="L422"> <span class="tok-kw">try</span> reader.readUntilDelimiterArrayList(&list, <span class="tok-str">'\n'</span>, <span class="tok-number">5</span>);</span>
<span class="line" id="L423"> <span class="tok-kw">try</span> std.testing.expectEqualStrings(<span class="tok-str">"0000"</span>, list.items);</span>
<span class="line" id="L424"> <span class="tok-kw">try</span> reader.readUntilDelimiterArrayList(&list, <span class="tok-str">'\n'</span>, <span class="tok-number">5</span>);</span>
<span class="line" id="L425"> <span class="tok-kw">try</span> std.testing.expectEqualStrings(<span class="tok-str">"1234"</span>, list.items);</span>
<span class="line" id="L426"> <span class="tok-kw">try</span> std.testing.expectError(<span class="tok-kw">error</span>.EndOfStream, reader.readUntilDelimiterArrayList(&list, <span class="tok-str">'\n'</span>, <span class="tok-number">5</span>));</span>
<span class="line" id="L427">}</span>
<span class="line" id="L428"></span>
<span class="line" id="L429"><span class="tok-kw">test</span> <span class="tok-str">"Reader.readUntilDelimiterArrayList returns an empty ArrayList"</span> {</span>
<span class="line" id="L430"> <span class="tok-kw">const</span> a = std.testing.allocator;</span>
<span class="line" id="L431"> <span class="tok-kw">var</span> list = std.ArrayList(<span class="tok-type">u8</span>).init(a);</span>
<span class="line" id="L432"> <span class="tok-kw">defer</span> list.deinit();</span>
<span class="line" id="L433"></span>
<span class="line" id="L434"> <span class="tok-kw">var</span> fis = std.io.fixedBufferStream(<span class="tok-str">"\n"</span>);</span>
<span class="line" id="L435"> <span class="tok-kw">const</span> reader = fis.reader();</span>
<span class="line" id="L436"></span>
<span class="line" id="L437"> <span class="tok-kw">try</span> reader.readUntilDelimiterArrayList(&list, <span class="tok-str">'\n'</span>, <span class="tok-number">5</span>);</span>
<span class="line" id="L438"> <span class="tok-kw">try</span> std.testing.expectEqualStrings(<span class="tok-str">""</span>, list.items);</span>
<span class="line" id="L439">}</span>
<span class="line" id="L440"></span>
<span class="line" id="L441"><span class="tok-kw">test</span> <span class="tok-str">"Reader.readUntilDelimiterArrayList returns StreamTooLong, then an ArrayList with bytes read until the delimiter"</span> {</span>
<span class="line" id="L442"> <span class="tok-kw">const</span> a = std.testing.allocator;</span>
<span class="line" id="L443"> <span class="tok-kw">var</span> list = std.ArrayList(<span class="tok-type">u8</span>).init(a);</span>
<span class="line" id="L444"> <span class="tok-kw">defer</span> list.deinit();</span>
<span class="line" id="L445"></span>
<span class="line" id="L446"> <span class="tok-kw">var</span> fis = std.io.fixedBufferStream(<span class="tok-str">"1234567\n"</span>);</span>
<span class="line" id="L447"> <span class="tok-kw">const</span> reader = fis.reader();</span>
<span class="line" id="L448"></span>
<span class="line" id="L449"> <span class="tok-kw">try</span> std.testing.expectError(<span class="tok-kw">error</span>.StreamTooLong, reader.readUntilDelimiterArrayList(&list, <span class="tok-str">'\n'</span>, <span class="tok-number">5</span>));</span>
<span class="line" id="L450"> <span class="tok-kw">try</span> std.testing.expectEqualStrings(<span class="tok-str">"12345"</span>, list.items);</span>
<span class="line" id="L451"> <span class="tok-kw">try</span> reader.readUntilDelimiterArrayList(&list, <span class="tok-str">'\n'</span>, <span class="tok-number">5</span>);</span>
<span class="line" id="L452"> <span class="tok-kw">try</span> std.testing.expectEqualStrings(<span class="tok-str">"67"</span>, list.items);</span>
<span class="line" id="L453">}</span>
<span class="line" id="L454"></span>
<span class="line" id="L455"><span class="tok-kw">test</span> <span class="tok-str">"Reader.readUntilDelimiterArrayList returns EndOfStream"</span> {</span>
<span class="line" id="L456"> <span class="tok-kw">const</span> a = std.testing.allocator;</span>
<span class="line" id="L457"> <span class="tok-kw">var</span> list = std.ArrayList(<span class="tok-type">u8</span>).init(a);</span>
<span class="line" id="L458"> <span class="tok-kw">defer</span> list.deinit();</span>
<span class="line" id="L459"></span>
<span class="line" id="L460"> <span class="tok-kw">var</span> fis = std.io.fixedBufferStream(<span class="tok-str">"1234"</span>);</span>
<span class="line" id="L461"> <span class="tok-kw">const</span> reader = fis.reader();</span>
<span class="line" id="L462"></span>
<span class="line" id="L463"> <span class="tok-kw">try</span> std.testing.expectError(<span class="tok-kw">error</span>.EndOfStream, reader.readUntilDelimiterArrayList(&list, <span class="tok-str">'\n'</span>, <span class="tok-number">5</span>));</span>
<span class="line" id="L464"> <span class="tok-kw">try</span> std.testing.expectEqualStrings(<span class="tok-str">"1234"</span>, list.items);</span>
<span class="line" id="L465">}</span>
<span class="line" id="L466"></span>
<span class="line" id="L467"><span class="tok-kw">test</span> <span class="tok-str">"Reader.readUntilDelimiterAlloc returns ArrayLists with bytes read until the delimiter, then EndOfStream"</span> {</span>
<span class="line" id="L468"> <span class="tok-kw">const</span> a = std.testing.allocator;</span>
<span class="line" id="L469"></span>
<span class="line" id="L470"> <span class="tok-kw">var</span> fis = std.io.fixedBufferStream(<span class="tok-str">"0000\n1234\n"</span>);</span>
<span class="line" id="L471"> <span class="tok-kw">const</span> reader = fis.reader();</span>
<span class="line" id="L472"></span>
<span class="line" id="L473"> {</span>
<span class="line" id="L474"> <span class="tok-kw">var</span> result = <span class="tok-kw">try</span> reader.readUntilDelimiterAlloc(a, <span class="tok-str">'\n'</span>, <span class="tok-number">5</span>);</span>
<span class="line" id="L475"> <span class="tok-kw">defer</span> a.free(result);</span>
<span class="line" id="L476"> <span class="tok-kw">try</span> std.testing.expectEqualStrings(<span class="tok-str">"0000"</span>, result);</span>
<span class="line" id="L477"> }</span>
<span class="line" id="L478"></span>
<span class="line" id="L479"> {</span>
<span class="line" id="L480"> <span class="tok-kw">var</span> result = <span class="tok-kw">try</span> reader.readUntilDelimiterAlloc(a, <span class="tok-str">'\n'</span>, <span class="tok-number">5</span>);</span>
<span class="line" id="L481"> <span class="tok-kw">defer</span> a.free(result);</span>
<span class="line" id="L482"> <span class="tok-kw">try</span> std.testing.expectEqualStrings(<span class="tok-str">"1234"</span>, result);</span>
<span class="line" id="L483"> }</span>
<span class="line" id="L484"></span>
<span class="line" id="L485"> <span class="tok-kw">try</span> std.testing.expectError(<span class="tok-kw">error</span>.EndOfStream, reader.readUntilDelimiterAlloc(a, <span class="tok-str">'\n'</span>, <span class="tok-number">5</span>));</span>
<span class="line" id="L486">}</span>
<span class="line" id="L487"></span>
<span class="line" id="L488"><span class="tok-kw">test</span> <span class="tok-str">"Reader.readUntilDelimiterAlloc returns an empty ArrayList"</span> {</span>
<span class="line" id="L489"> <span class="tok-kw">const</span> a = std.testing.allocator;</span>
<span class="line" id="L490"></span>
<span class="line" id="L491"> <span class="tok-kw">var</span> fis = std.io.fixedBufferStream(<span class="tok-str">"\n"</span>);</span>
<span class="line" id="L492"> <span class="tok-kw">const</span> reader = fis.reader();</span>
<span class="line" id="L493"></span>
<span class="line" id="L494"> {</span>
<span class="line" id="L495"> <span class="tok-kw">var</span> result = <span class="tok-kw">try</span> reader.readUntilDelimiterAlloc(a, <span class="tok-str">'\n'</span>, <span class="tok-number">5</span>);</span>
<span class="line" id="L496"> <span class="tok-kw">defer</span> a.free(result);</span>
<span class="line" id="L497"> <span class="tok-kw">try</span> std.testing.expectEqualStrings(<span class="tok-str">""</span>, result);</span>
<span class="line" id="L498"> }</span>
<span class="line" id="L499">}</span>
<span class="line" id="L500"></span>
<span class="line" id="L501"><span class="tok-kw">test</span> <span class="tok-str">"Reader.readUntilDelimiterAlloc returns StreamTooLong, then an ArrayList with bytes read until the delimiter"</span> {</span>
<span class="line" id="L502"> <span class="tok-kw">const</span> a = std.testing.allocator;</span>
<span class="line" id="L503"></span>
<span class="line" id="L504"> <span class="tok-kw">var</span> fis = std.io.fixedBufferStream(<span class="tok-str">"1234567\n"</span>);</span>
<span class="line" id="L505"> <span class="tok-kw">const</span> reader = fis.reader();</span>
<span class="line" id="L506"></span>
<span class="line" id="L507"> <span class="tok-kw">try</span> std.testing.expectError(<span class="tok-kw">error</span>.StreamTooLong, reader.readUntilDelimiterAlloc(a, <span class="tok-str">'\n'</span>, <span class="tok-number">5</span>));</span>
<span class="line" id="L508"></span>
<span class="line" id="L509"> <span class="tok-kw">var</span> result = <span class="tok-kw">try</span> reader.readUntilDelimiterAlloc(a, <span class="tok-str">'\n'</span>, <span class="tok-number">5</span>);</span>
<span class="line" id="L510"> <span class="tok-kw">defer</span> a.free(result);</span>
<span class="line" id="L511"> <span class="tok-kw">try</span> std.testing.expectEqualStrings(<span class="tok-str">"67"</span>, result);</span>
<span class="line" id="L512">}</span>
<span class="line" id="L513"></span>
<span class="line" id="L514"><span class="tok-kw">test</span> <span class="tok-str">"Reader.readUntilDelimiterAlloc returns EndOfStream"</span> {</span>
<span class="line" id="L515"> <span class="tok-kw">const</span> a = std.testing.allocator;</span>
<span class="line" id="L516"></span>
<span class="line" id="L517"> <span class="tok-kw">var</span> fis = std.io.fixedBufferStream(<span class="tok-str">"1234"</span>);</span>
<span class="line" id="L518"> <span class="tok-kw">const</span> reader = fis.reader();</span>
<span class="line" id="L519"></span>
<span class="line" id="L520"> <span class="tok-kw">try</span> std.testing.expectError(<span class="tok-kw">error</span>.EndOfStream, reader.readUntilDelimiterAlloc(a, <span class="tok-str">'\n'</span>, <span class="tok-number">5</span>));</span>
<span class="line" id="L521">}</span>
<span class="line" id="L522"></span>
<span class="line" id="L523"><span class="tok-kw">test</span> <span class="tok-str">"Reader.readUntilDelimiter returns bytes read until the delimiter"</span> {</span>
<span class="line" id="L524"> <span class="tok-kw">var</span> buf: [<span class="tok-number">5</span>]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L525"> <span class="tok-kw">var</span> fis = std.io.fixedBufferStream(<span class="tok-str">"0000\n1234\n"</span>);</span>
<span class="line" id="L526"> <span class="tok-kw">const</span> reader = fis.reader();</span>
<span class="line" id="L527"> <span class="tok-kw">try</span> std.testing.expectEqualStrings(<span class="tok-str">"0000"</span>, <span class="tok-kw">try</span> reader.readUntilDelimiter(&buf, <span class="tok-str">'\n'</span>));</span>
<span class="line" id="L528"> <span class="tok-kw">try</span> std.testing.expectEqualStrings(<span class="tok-str">"1234"</span>, <span class="tok-kw">try</span> reader.readUntilDelimiter(&buf, <span class="tok-str">'\n'</span>));</span>
<span class="line" id="L529">}</span>
<span class="line" id="L530"></span>
<span class="line" id="L531"><span class="tok-kw">test</span> <span class="tok-str">"Reader.readUntilDelimiter returns an empty string"</span> {</span>
<span class="line" id="L532"> <span class="tok-kw">var</span> buf: [<span class="tok-number">5</span>]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L533"> <span class="tok-kw">var</span> fis = std.io.fixedBufferStream(<span class="tok-str">"\n"</span>);</span>
<span class="line" id="L534"> <span class="tok-kw">const</span> reader = fis.reader();</span>
<span class="line" id="L535"> <span class="tok-kw">try</span> std.testing.expectEqualStrings(<span class="tok-str">""</span>, <span class="tok-kw">try</span> reader.readUntilDelimiter(&buf, <span class="tok-str">'\n'</span>));</span>
<span class="line" id="L536">}</span>
<span class="line" id="L537"></span>
<span class="line" id="L538"><span class="tok-kw">test</span> <span class="tok-str">"Reader.readUntilDelimiter returns StreamTooLong, then an empty string"</span> {</span>
<span class="line" id="L539"> <span class="tok-kw">var</span> buf: [<span class="tok-number">5</span>]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L540"> <span class="tok-kw">var</span> fis = std.io.fixedBufferStream(<span class="tok-str">"12345\n"</span>);</span>
<span class="line" id="L541"> <span class="tok-kw">const</span> reader = fis.reader();</span>
<span class="line" id="L542"> <span class="tok-kw">try</span> std.testing.expectError(<span class="tok-kw">error</span>.StreamTooLong, reader.readUntilDelimiter(&buf, <span class="tok-str">'\n'</span>));</span>
<span class="line" id="L543"> <span class="tok-kw">try</span> std.testing.expectEqualStrings(<span class="tok-str">""</span>, <span class="tok-kw">try</span> reader.readUntilDelimiter(&buf, <span class="tok-str">'\n'</span>));</span>
<span class="line" id="L544">}</span>
<span class="line" id="L545"></span>
<span class="line" id="L546"><span class="tok-kw">test</span> <span class="tok-str">"Reader.readUntilDelimiter returns StreamTooLong, then bytes read until the delimiter"</span> {</span>
<span class="line" id="L547"> <span class="tok-kw">var</span> buf: [<span class="tok-number">5</span>]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L548"> <span class="tok-kw">var</span> fis = std.io.fixedBufferStream(<span class="tok-str">"1234567\n"</span>);</span>
<span class="line" id="L549"> <span class="tok-kw">const</span> reader = fis.reader();</span>
<span class="line" id="L550"> <span class="tok-kw">try</span> std.testing.expectError(<span class="tok-kw">error</span>.StreamTooLong, reader.readUntilDelimiter(&buf, <span class="tok-str">'\n'</span>));</span>
<span class="line" id="L551"> <span class="tok-kw">try</span> std.testing.expectEqualStrings(<span class="tok-str">"67"</span>, <span class="tok-kw">try</span> reader.readUntilDelimiter(&buf, <span class="tok-str">'\n'</span>));</span>
<span class="line" id="L552">}</span>
<span class="line" id="L553"></span>
<span class="line" id="L554"><span class="tok-kw">test</span> <span class="tok-str">"Reader.readUntilDelimiter returns EndOfStream"</span> {</span>
<span class="line" id="L555"> {</span>
<span class="line" id="L556"> <span class="tok-kw">var</span> buf: [<span class="tok-number">5</span>]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L557"> <span class="tok-kw">var</span> fis = std.io.fixedBufferStream(<span class="tok-str">""</span>);</span>
<span class="line" id="L558"> <span class="tok-kw">const</span> reader = fis.reader();</span>
<span class="line" id="L559"> <span class="tok-kw">try</span> std.testing.expectError(<span class="tok-kw">error</span>.EndOfStream, reader.readUntilDelimiter(&buf, <span class="tok-str">'\n'</span>));</span>
<span class="line" id="L560"> }</span>
<span class="line" id="L561"> {</span>
<span class="line" id="L562"> <span class="tok-kw">var</span> buf: [<span class="tok-number">5</span>]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L563"> <span class="tok-kw">var</span> fis = std.io.fixedBufferStream(<span class="tok-str">"1234"</span>);</span>
<span class="line" id="L564"> <span class="tok-kw">const</span> reader = fis.reader();</span>
<span class="line" id="L565"> <span class="tok-kw">try</span> std.testing.expectError(<span class="tok-kw">error</span>.EndOfStream, reader.readUntilDelimiter(&buf, <span class="tok-str">'\n'</span>));</span>
<span class="line" id="L566"> }</span>
<span class="line" id="L567">}</span>
<span class="line" id="L568"></span>
<span class="line" id="L569"><span class="tok-kw">test</span> <span class="tok-str">"Reader.readUntilDelimiter returns bytes read until delimiter, then EndOfStream"</span> {</span>
<span class="line" id="L570"> <span class="tok-kw">var</span> buf: [<span class="tok-number">5</span>]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L571"> <span class="tok-kw">var</span> fis = std.io.fixedBufferStream(<span class="tok-str">"1234\n"</span>);</span>
<span class="line" id="L572"> <span class="tok-kw">const</span> reader = fis.reader();</span>
<span class="line" id="L573"> <span class="tok-kw">try</span> std.testing.expectEqualStrings(<span class="tok-str">"1234"</span>, <span class="tok-kw">try</span> reader.readUntilDelimiter(&buf, <span class="tok-str">'\n'</span>));</span>
<span class="line" id="L574"> <span class="tok-kw">try</span> std.testing.expectError(<span class="tok-kw">error</span>.EndOfStream, reader.readUntilDelimiter(&buf, <span class="tok-str">'\n'</span>));</span>
<span class="line" id="L575">}</span>
<span class="line" id="L576"></span>
<span class="line" id="L577"><span class="tok-kw">test</span> <span class="tok-str">"Reader.readUntilDelimiter returns StreamTooLong, then EndOfStream"</span> {</span>
<span class="line" id="L578"> <span class="tok-kw">var</span> buf: [<span class="tok-number">5</span>]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L579"> <span class="tok-kw">var</span> fis = std.io.fixedBufferStream(<span class="tok-str">"12345"</span>);</span>
<span class="line" id="L580"> <span class="tok-kw">const</span> reader = fis.reader();</span>
<span class="line" id="L581"> <span class="tok-kw">try</span> std.testing.expectError(<span class="tok-kw">error</span>.StreamTooLong, reader.readUntilDelimiter(&buf, <span class="tok-str">'\n'</span>));</span>
<span class="line" id="L582"> <span class="tok-kw">try</span> std.testing.expectError(<span class="tok-kw">error</span>.EndOfStream, reader.readUntilDelimiter(&buf, <span class="tok-str">'\n'</span>));</span>
<span class="line" id="L583">}</span>
<span class="line" id="L584"></span>
<span class="line" id="L585"><span class="tok-kw">test</span> <span class="tok-str">"Reader.readUntilDelimiter writes all bytes read to the output buffer"</span> {</span>
<span class="line" id="L586"> <span class="tok-kw">var</span> buf: [<span class="tok-number">5</span>]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L587"> <span class="tok-kw">var</span> fis = std.io.fixedBufferStream(<span class="tok-str">"0000\n12345"</span>);</span>
<span class="line" id="L588"> <span class="tok-kw">const</span> reader = fis.reader();</span>
<span class="line" id="L589"> _ = <span class="tok-kw">try</span> reader.readUntilDelimiter(&buf, <span class="tok-str">'\n'</span>);</span>
<span class="line" id="L590"> <span class="tok-kw">try</span> std.testing.expectEqualStrings(<span class="tok-str">"0000\n"</span>, &buf);</span>
<span class="line" id="L591"> <span class="tok-kw">try</span> std.testing.expectError(<span class="tok-kw">error</span>.StreamTooLong, reader.readUntilDelimiter(&buf, <span class="tok-str">'\n'</span>));</span>
<span class="line" id="L592"> <span class="tok-kw">try</span> std.testing.expectEqualStrings(<span class="tok-str">"12345"</span>, &buf);</span>
<span class="line" id="L593">}</span>
<span class="line" id="L594"></span>
<span class="line" id="L595"><span class="tok-kw">test</span> <span class="tok-str">"Reader.readUntilDelimiterOrEofAlloc returns ArrayLists with bytes read until the delimiter, then EndOfStream"</span> {</span>
<span class="line" id="L596"> <span class="tok-kw">const</span> a = std.testing.allocator;</span>
<span class="line" id="L597"></span>
<span class="line" id="L598"> <span class="tok-kw">var</span> fis = std.io.fixedBufferStream(<span class="tok-str">"0000\n1234\n"</span>);</span>
<span class="line" id="L599"> <span class="tok-kw">const</span> reader = fis.reader();</span>
<span class="line" id="L600"></span>
<span class="line" id="L601"> {</span>
<span class="line" id="L602"> <span class="tok-kw">var</span> result = (<span class="tok-kw">try</span> reader.readUntilDelimiterOrEofAlloc(a, <span class="tok-str">'\n'</span>, <span class="tok-number">5</span>)).?;</span>
<span class="line" id="L603"> <span class="tok-kw">defer</span> a.free(result);</span>
<span class="line" id="L604"> <span class="tok-kw">try</span> std.testing.expectEqualStrings(<span class="tok-str">"0000"</span>, result);</span>
<span class="line" id="L605"> }</span>
<span class="line" id="L606"></span>
<span class="line" id="L607"> {</span>
<span class="line" id="L608"> <span class="tok-kw">var</span> result = (<span class="tok-kw">try</span> reader.readUntilDelimiterOrEofAlloc(a, <span class="tok-str">'\n'</span>, <span class="tok-number">5</span>)).?;</span>
<span class="line" id="L609"> <span class="tok-kw">defer</span> a.free(result);</span>
<span class="line" id="L610"> <span class="tok-kw">try</span> std.testing.expectEqualStrings(<span class="tok-str">"1234"</span>, result);</span>
<span class="line" id="L611"> }</span>
<span class="line" id="L612"></span>
<span class="line" id="L613"> <span class="tok-kw">try</span> std.testing.expect((<span class="tok-kw">try</span> reader.readUntilDelimiterOrEofAlloc(a, <span class="tok-str">'\n'</span>, <span class="tok-number">5</span>)) == <span class="tok-null">null</span>);</span>
<span class="line" id="L614">}</span>
<span class="line" id="L615"></span>
<span class="line" id="L616"><span class="tok-kw">test</span> <span class="tok-str">"Reader.readUntilDelimiterOrEofAlloc returns an empty ArrayList"</span> {</span>
<span class="line" id="L617"> <span class="tok-kw">const</span> a = std.testing.allocator;</span>
<span class="line" id="L618"></span>
<span class="line" id="L619"> <span class="tok-kw">var</span> fis = std.io.fixedBufferStream(<span class="tok-str">"\n"</span>);</span>
<span class="line" id="L620"> <span class="tok-kw">const</span> reader = fis.reader();</span>
<span class="line" id="L621"></span>
<span class="line" id="L622"> {</span>
<span class="line" id="L623"> <span class="tok-kw">var</span> result = (<span class="tok-kw">try</span> reader.readUntilDelimiterOrEofAlloc(a, <span class="tok-str">'\n'</span>, <span class="tok-number">5</span>)).?;</span>
<span class="line" id="L624"> <span class="tok-kw">defer</span> a.free(result);</span>
<span class="line" id="L625"> <span class="tok-kw">try</span> std.testing.expectEqualStrings(<span class="tok-str">""</span>, result);</span>
<span class="line" id="L626"> }</span>
<span class="line" id="L627">}</span>
<span class="line" id="L628"></span>
<span class="line" id="L629"><span class="tok-kw">test</span> <span class="tok-str">"Reader.readUntilDelimiterOrEofAlloc returns StreamTooLong, then an ArrayList with bytes read until the delimiter"</span> {</span>
<span class="line" id="L630"> <span class="tok-kw">const</span> a = std.testing.allocator;</span>
<span class="line" id="L631"></span>
<span class="line" id="L632"> <span class="tok-kw">var</span> fis = std.io.fixedBufferStream(<span class="tok-str">"1234567\n"</span>);</span>
<span class="line" id="L633"> <span class="tok-kw">const</span> reader = fis.reader();</span>
<span class="line" id="L634"></span>
<span class="line" id="L635"> <span class="tok-kw">try</span> std.testing.expectError(<span class="tok-kw">error</span>.StreamTooLong, reader.readUntilDelimiterOrEofAlloc(a, <span class="tok-str">'\n'</span>, <span class="tok-number">5</span>));</span>
<span class="line" id="L636"></span>
<span class="line" id="L637"> <span class="tok-kw">var</span> result = (<span class="tok-kw">try</span> reader.readUntilDelimiterOrEofAlloc(a, <span class="tok-str">'\n'</span>, <span class="tok-number">5</span>)).?;</span>
<span class="line" id="L638"> <span class="tok-kw">defer</span> a.free(result);</span>
<span class="line" id="L639"> <span class="tok-kw">try</span> std.testing.expectEqualStrings(<span class="tok-str">"67"</span>, result);</span>
<span class="line" id="L640">}</span>
<span class="line" id="L641"></span>
<span class="line" id="L642"><span class="tok-kw">test</span> <span class="tok-str">"Reader.readUntilDelimiterOrEof returns bytes read until the delimiter"</span> {</span>
<span class="line" id="L643"> <span class="tok-kw">var</span> buf: [<span class="tok-number">5</span>]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L644"> <span class="tok-kw">var</span> fis = std.io.fixedBufferStream(<span class="tok-str">"0000\n1234\n"</span>);</span>
<span class="line" id="L645"> <span class="tok-kw">const</span> reader = fis.reader();</span>
<span class="line" id="L646"> <span class="tok-kw">try</span> std.testing.expectEqualStrings(<span class="tok-str">"0000"</span>, (<span class="tok-kw">try</span> reader.readUntilDelimiterOrEof(&buf, <span class="tok-str">'\n'</span>)).?);</span>
<span class="line" id="L647"> <span class="tok-kw">try</span> std.testing.expectEqualStrings(<span class="tok-str">"1234"</span>, (<span class="tok-kw">try</span> reader.readUntilDelimiterOrEof(&buf, <span class="tok-str">'\n'</span>)).?);</span>
<span class="line" id="L648">}</span>
<span class="line" id="L649"></span>
<span class="line" id="L650"><span class="tok-kw">test</span> <span class="tok-str">"Reader.readUntilDelimiterOrEof returns an empty string"</span> {</span>
<span class="line" id="L651"> <span class="tok-kw">var</span> buf: [<span class="tok-number">5</span>]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L652"> <span class="tok-kw">var</span> fis = std.io.fixedBufferStream(<span class="tok-str">"\n"</span>);</span>
<span class="line" id="L653"> <span class="tok-kw">const</span> reader = fis.reader();</span>
<span class="line" id="L654"> <span class="tok-kw">try</span> std.testing.expectEqualStrings(<span class="tok-str">""</span>, (<span class="tok-kw">try</span> reader.readUntilDelimiterOrEof(&buf, <span class="tok-str">'\n'</span>)).?);</span>
<span class="line" id="L655">}</span>
<span class="line" id="L656"></span>
<span class="line" id="L657"><span class="tok-kw">test</span> <span class="tok-str">"Reader.readUntilDelimiterOrEof returns StreamTooLong, then an empty string"</span> {</span>
<span class="line" id="L658"> <span class="tok-kw">var</span> buf: [<span class="tok-number">5</span>]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L659"> <span class="tok-kw">var</span> fis = std.io.fixedBufferStream(<span class="tok-str">"12345\n"</span>);</span>
<span class="line" id="L660"> <span class="tok-kw">const</span> reader = fis.reader();</span>
<span class="line" id="L661"> <span class="tok-kw">try</span> std.testing.expectError(<span class="tok-kw">error</span>.StreamTooLong, reader.readUntilDelimiterOrEof(&buf, <span class="tok-str">'\n'</span>));</span>
<span class="line" id="L662"> <span class="tok-kw">try</span> std.testing.expectEqualStrings(<span class="tok-str">""</span>, (<span class="tok-kw">try</span> reader.readUntilDelimiterOrEof(&buf, <span class="tok-str">'\n'</span>)).?);</span>
<span class="line" id="L663">}</span>
<span class="line" id="L664"></span>
<span class="line" id="L665"><span class="tok-kw">test</span> <span class="tok-str">"Reader.readUntilDelimiterOrEof returns StreamTooLong, then bytes read until the delimiter"</span> {</span>
<span class="line" id="L666"> <span class="tok-kw">var</span> buf: [<span class="tok-number">5</span>]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L667"> <span class="tok-kw">var</span> fis = std.io.fixedBufferStream(<span class="tok-str">"1234567\n"</span>);</span>
<span class="line" id="L668"> <span class="tok-kw">const</span> reader = fis.reader();</span>
<span class="line" id="L669"> <span class="tok-kw">try</span> std.testing.expectError(<span class="tok-kw">error</span>.StreamTooLong, reader.readUntilDelimiterOrEof(&buf, <span class="tok-str">'\n'</span>));</span>
<span class="line" id="L670"> <span class="tok-kw">try</span> std.testing.expectEqualStrings(<span class="tok-str">"67"</span>, (<span class="tok-kw">try</span> reader.readUntilDelimiterOrEof(&buf, <span class="tok-str">'\n'</span>)).?);</span>
<span class="line" id="L671">}</span>
<span class="line" id="L672"></span>
<span class="line" id="L673"><span class="tok-kw">test</span> <span class="tok-str">"Reader.readUntilDelimiterOrEof returns null"</span> {</span>
<span class="line" id="L674"> <span class="tok-kw">var</span> buf: [<span class="tok-number">5</span>]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L675"> <span class="tok-kw">var</span> fis = std.io.fixedBufferStream(<span class="tok-str">""</span>);</span>
<span class="line" id="L676"> <span class="tok-kw">const</span> reader = fis.reader();</span>
<span class="line" id="L677"> <span class="tok-kw">try</span> std.testing.expect((<span class="tok-kw">try</span> reader.readUntilDelimiterOrEof(&buf, <span class="tok-str">'\n'</span>)) == <span class="tok-null">null</span>);</span>
<span class="line" id="L678">}</span>
<span class="line" id="L679"></span>
<span class="line" id="L680"><span class="tok-kw">test</span> <span class="tok-str">"Reader.readUntilDelimiterOrEof returns bytes read until delimiter, then null"</span> {</span>
<span class="line" id="L681"> <span class="tok-kw">var</span> buf: [<span class="tok-number">5</span>]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L682"> <span class="tok-kw">var</span> fis = std.io.fixedBufferStream(<span class="tok-str">"1234\n"</span>);</span>
<span class="line" id="L683"> <span class="tok-kw">const</span> reader = fis.reader();</span>
<span class="line" id="L684"> <span class="tok-kw">try</span> std.testing.expectEqualStrings(<span class="tok-str">"1234"</span>, (<span class="tok-kw">try</span> reader.readUntilDelimiterOrEof(&buf, <span class="tok-str">'\n'</span>)).?);</span>
<span class="line" id="L685"> <span class="tok-kw">try</span> std.testing.expect((<span class="tok-kw">try</span> reader.readUntilDelimiterOrEof(&buf, <span class="tok-str">'\n'</span>)) == <span class="tok-null">null</span>);</span>
<span class="line" id="L686">}</span>
<span class="line" id="L687"></span>
<span class="line" id="L688"><span class="tok-kw">test</span> <span class="tok-str">"Reader.readUntilDelimiterOrEof returns bytes read until end-of-stream"</span> {</span>
<span class="line" id="L689"> <span class="tok-kw">var</span> buf: [<span class="tok-number">5</span>]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L690"> <span class="tok-kw">var</span> fis = std.io.fixedBufferStream(<span class="tok-str">"1234"</span>);</span>
<span class="line" id="L691"> <span class="tok-kw">const</span> reader = fis.reader();</span>
<span class="line" id="L692"> <span class="tok-kw">try</span> std.testing.expectEqualStrings(<span class="tok-str">"1234"</span>, (<span class="tok-kw">try</span> reader.readUntilDelimiterOrEof(&buf, <span class="tok-str">'\n'</span>)).?);</span>
<span class="line" id="L693">}</span>
<span class="line" id="L694"></span>
<span class="line" id="L695"><span class="tok-kw">test</span> <span class="tok-str">"Reader.readUntilDelimiterOrEof returns StreamTooLong, then bytes read until end-of-stream"</span> {</span>
<span class="line" id="L696"> <span class="tok-kw">var</span> buf: [<span class="tok-number">5</span>]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L697"> <span class="tok-kw">var</span> fis = std.io.fixedBufferStream(<span class="tok-str">"1234567"</span>);</span>
<span class="line" id="L698"> <span class="tok-kw">const</span> reader = fis.reader();</span>
<span class="line" id="L699"> <span class="tok-kw">try</span> std.testing.expectError(<span class="tok-kw">error</span>.StreamTooLong, reader.readUntilDelimiterOrEof(&buf, <span class="tok-str">'\n'</span>));</span>
<span class="line" id="L700"> <span class="tok-kw">try</span> std.testing.expectEqualStrings(<span class="tok-str">"67"</span>, (<span class="tok-kw">try</span> reader.readUntilDelimiterOrEof(&buf, <span class="tok-str">'\n'</span>)).?);</span>
<span class="line" id="L701">}</span>
<span class="line" id="L702"></span>
<span class="line" id="L703"><span class="tok-kw">test</span> <span class="tok-str">"Reader.readUntilDelimiterOrEof writes all bytes read to the output buffer"</span> {</span>
<span class="line" id="L704"> <span class="tok-kw">var</span> buf: [<span class="tok-number">5</span>]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L705"> <span class="tok-kw">var</span> fis = std.io.fixedBufferStream(<span class="tok-str">"0000\n12345"</span>);</span>
<span class="line" id="L706"> <span class="tok-kw">const</span> reader = fis.reader();</span>
<span class="line" id="L707"> _ = <span class="tok-kw">try</span> reader.readUntilDelimiterOrEof(&buf, <span class="tok-str">'\n'</span>);</span>
<span class="line" id="L708"> <span class="tok-kw">try</span> std.testing.expectEqualStrings(<span class="tok-str">"0000\n"</span>, &buf);</span>
<span class="line" id="L709"> <span class="tok-kw">try</span> std.testing.expectError(<span class="tok-kw">error</span>.StreamTooLong, reader.readUntilDelimiterOrEof(&buf, <span class="tok-str">'\n'</span>));</span>
<span class="line" id="L710"> <span class="tok-kw">try</span> std.testing.expectEqualStrings(<span class="tok-str">"12345"</span>, &buf);</span>
<span class="line" id="L711">}</span>
<span class="line" id="L712"></span>
<span class="line" id="L713"><span class="tok-kw">test</span> <span class="tok-str">"Reader.streamUntilDelimiter writes all bytes without delimiter to the output"</span> {</span>
<span class="line" id="L714"> <span class="tok-kw">const</span> input_string = <span class="tok-str">"some_string_with_delimiter!"</span>;</span>
<span class="line" id="L715"> <span class="tok-kw">var</span> input_fbs = std.io.fixedBufferStream(input_string);</span>
<span class="line" id="L716"> <span class="tok-kw">const</span> reader = input_fbs.reader();</span>
<span class="line" id="L717"></span>
<span class="line" id="L718"> <span class="tok-kw">var</span> output: [input_string.len]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L719"> <span class="tok-kw">var</span> output_fbs = std.io.fixedBufferStream(&output);</span>
<span class="line" id="L720"> <span class="tok-kw">const</span> writer = output_fbs.writer();</span>
<span class="line" id="L721"></span>
<span class="line" id="L722"> <span class="tok-kw">try</span> reader.streamUntilDelimiter(writer, <span class="tok-str">'!'</span>, input_fbs.buffer.len);</span>
<span class="line" id="L723"> <span class="tok-kw">try</span> std.testing.expectEqualStrings(<span class="tok-str">"some_string_with_delimiter"</span>, output_fbs.getWritten());</span>
<span class="line" id="L724"> <span class="tok-kw">try</span> std.testing.expectError(<span class="tok-kw">error</span>.EndOfStream, reader.streamUntilDelimiter(writer, <span class="tok-str">'!'</span>, input_fbs.buffer.len));</span>
<span class="line" id="L725"></span>
<span class="line" id="L726"> input_fbs.reset();</span>
<span class="line" id="L727"> output_fbs.reset();</span>
<span class="line" id="L728"></span>
<span class="line" id="L729"> <span class="tok-kw">try</span> std.testing.expectError(<span class="tok-kw">error</span>.StreamTooLong, reader.streamUntilDelimiter(writer, <span class="tok-str">'!'</span>, <span class="tok-number">5</span>));</span>
<span class="line" id="L730">}</span>
<span class="line" id="L731"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/io/writer.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>io/writer.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../std.zig"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> assert = std.debug.assert;</span>
<span class="line" id="L3"><span class="tok-kw">const</span> mem = std.mem;</span>
<span class="line" id="L4"></span>
<span class="line" id="L5"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">Writer</span>(</span>
<span class="line" id="L6"> <span class="tok-kw">comptime</span> Context: <span class="tok-type">type</span>,</span>
<span class="line" id="L7"> <span class="tok-kw">comptime</span> WriteError: <span class="tok-type">type</span>,</span>
<span class="line" id="L8"> <span class="tok-kw">comptime</span> writeFn: <span class="tok-kw">fn</span> (context: Context, bytes: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) WriteError!<span class="tok-type">usize</span>,</span>
<span class="line" id="L9">) <span class="tok-type">type</span> {</span>
<span class="line" id="L10"> <span class="tok-kw">return</span> <span class="tok-kw">struct</span> {</span>
<span class="line" id="L11"> context: Context,</span>
<span class="line" id="L12"></span>
<span class="line" id="L13"> <span class="tok-kw">const</span> Self = <span class="tok-builtin">@This</span>();</span>
<span class="line" id="L14"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> Error = WriteError;</span>
<span class="line" id="L15"></span>
<span class="line" id="L16"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">write</span>(self: Self, bytes: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) Error!<span class="tok-type">usize</span> {</span>
<span class="line" id="L17"> <span class="tok-kw">return</span> writeFn(self.context, bytes);</span>
<span class="line" id="L18"> }</span>
<span class="line" id="L19"></span>
<span class="line" id="L20"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">writeAll</span>(self: Self, bytes: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) Error!<span class="tok-type">void</span> {</span>
<span class="line" id="L21"> <span class="tok-kw">var</span> index: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L22"> <span class="tok-kw">while</span> (index != bytes.len) {</span>
<span class="line" id="L23"> index += <span class="tok-kw">try</span> self.write(bytes[index..]);</span>
<span class="line" id="L24"> }</span>
<span class="line" id="L25"> }</span>
<span class="line" id="L26"></span>
<span class="line" id="L27"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">print</span>(self: Self, <span class="tok-kw">comptime</span> format: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>, args: <span class="tok-kw">anytype</span>) Error!<span class="tok-type">void</span> {</span>
<span class="line" id="L28"> <span class="tok-kw">return</span> std.fmt.format(self, format, args);</span>
<span class="line" id="L29"> }</span>
<span class="line" id="L30"></span>
<span class="line" id="L31"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">writeByte</span>(self: Self, byte: <span class="tok-type">u8</span>) Error!<span class="tok-type">void</span> {</span>
<span class="line" id="L32"> <span class="tok-kw">const</span> array = [<span class="tok-number">1</span>]<span class="tok-type">u8</span>{byte};</span>
<span class="line" id="L33"> <span class="tok-kw">return</span> self.writeAll(&array);</span>
<span class="line" id="L34"> }</span>
<span class="line" id="L35"></span>
<span class="line" id="L36"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">writeByteNTimes</span>(self: Self, byte: <span class="tok-type">u8</span>, n: <span class="tok-type">usize</span>) Error!<span class="tok-type">void</span> {</span>
<span class="line" id="L37"> <span class="tok-kw">var</span> bytes: [<span class="tok-number">256</span>]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L38"> <span class="tok-builtin">@memset</span>(bytes[<span class="tok-number">0</span>..], byte);</span>
<span class="line" id="L39"></span>
<span class="line" id="L40"> <span class="tok-kw">var</span> remaining: <span class="tok-type">usize</span> = n;</span>
<span class="line" id="L41"> <span class="tok-kw">while</span> (remaining > <span class="tok-number">0</span>) {</span>
<span class="line" id="L42"> <span class="tok-kw">const</span> to_write = <span class="tok-builtin">@min</span>(remaining, bytes.len);</span>
<span class="line" id="L43"> <span class="tok-kw">try</span> self.writeAll(bytes[<span class="tok-number">0</span>..to_write]);</span>
<span class="line" id="L44"> remaining -= to_write;</span>
<span class="line" id="L45"> }</span>
<span class="line" id="L46"> }</span>
<span class="line" id="L47"></span>
<span class="line" id="L48"> <span class="tok-comment">/// Write a native-endian integer.</span></span>
<span class="line" id="L49"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">writeIntNative</span>(self: Self, <span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>, value: T) Error!<span class="tok-type">void</span> {</span>
<span class="line" id="L50"> <span class="tok-kw">var</span> bytes: [<span class="tok-builtin">@as</span>(<span class="tok-type">u16</span>, <span class="tok-builtin">@intCast</span>((<span class="tok-builtin">@as</span>(<span class="tok-type">u17</span>, <span class="tok-builtin">@typeInfo</span>(T).Int.bits) + <span class="tok-number">7</span>) / <span class="tok-number">8</span>))]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L51"> mem.writeIntNative(std.math.ByteAlignedInt(<span class="tok-builtin">@TypeOf</span>(value)), &bytes, value);</span>
<span class="line" id="L52"> <span class="tok-kw">return</span> self.writeAll(&bytes);</span>
<span class="line" id="L53"> }</span>
<span class="line" id="L54"></span>
<span class="line" id="L55"> <span class="tok-comment">/// Write a foreign-endian integer.</span></span>
<span class="line" id="L56"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">writeIntForeign</span>(self: Self, <span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>, value: T) Error!<span class="tok-type">void</span> {</span>
<span class="line" id="L57"> <span class="tok-kw">var</span> bytes: [<span class="tok-builtin">@as</span>(<span class="tok-type">u16</span>, <span class="tok-builtin">@intCast</span>((<span class="tok-builtin">@as</span>(<span class="tok-type">u17</span>, <span class="tok-builtin">@typeInfo</span>(T).Int.bits) + <span class="tok-number">7</span>) / <span class="tok-number">8</span>))]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L58"> mem.writeIntForeign(std.math.ByteAlignedInt(<span class="tok-builtin">@TypeOf</span>(value)), &bytes, value);</span>
<span class="line" id="L59"> <span class="tok-kw">return</span> self.writeAll(&bytes);</span>
<span class="line" id="L60"> }</span>
<span class="line" id="L61"></span>
<span class="line" id="L62"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">writeIntLittle</span>(self: Self, <span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>, value: T) Error!<span class="tok-type">void</span> {</span>
<span class="line" id="L63"> <span class="tok-kw">var</span> bytes: [<span class="tok-builtin">@as</span>(<span class="tok-type">u16</span>, <span class="tok-builtin">@intCast</span>((<span class="tok-builtin">@as</span>(<span class="tok-type">u17</span>, <span class="tok-builtin">@typeInfo</span>(T).Int.bits) + <span class="tok-number">7</span>) / <span class="tok-number">8</span>))]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L64"> mem.writeIntLittle(std.math.ByteAlignedInt(<span class="tok-builtin">@TypeOf</span>(value)), &bytes, value);</span>
<span class="line" id="L65"> <span class="tok-kw">return</span> self.writeAll(&bytes);</span>
<span class="line" id="L66"> }</span>
<span class="line" id="L67"></span>
<span class="line" id="L68"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">writeIntBig</span>(self: Self, <span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>, value: T) Error!<span class="tok-type">void</span> {</span>
<span class="line" id="L69"> <span class="tok-kw">var</span> bytes: [<span class="tok-builtin">@as</span>(<span class="tok-type">u16</span>, <span class="tok-builtin">@intCast</span>((<span class="tok-builtin">@as</span>(<span class="tok-type">u17</span>, <span class="tok-builtin">@typeInfo</span>(T).Int.bits) + <span class="tok-number">7</span>) / <span class="tok-number">8</span>))]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L70"> mem.writeIntBig(std.math.ByteAlignedInt(<span class="tok-builtin">@TypeOf</span>(value)), &bytes, value);</span>
<span class="line" id="L71"> <span class="tok-kw">return</span> self.writeAll(&bytes);</span>
<span class="line" id="L72"> }</span>
<span class="line" id="L73"></span>
<span class="line" id="L74"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">writeInt</span>(self: Self, <span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>, value: T, endian: std.builtin.Endian) Error!<span class="tok-type">void</span> {</span>
<span class="line" id="L75"> <span class="tok-kw">var</span> bytes: [<span class="tok-builtin">@as</span>(<span class="tok-type">u16</span>, <span class="tok-builtin">@intCast</span>((<span class="tok-builtin">@as</span>(<span class="tok-type">u17</span>, <span class="tok-builtin">@typeInfo</span>(T).Int.bits) + <span class="tok-number">7</span>) / <span class="tok-number">8</span>))]<span class="tok-type">u8</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L76"> mem.writeInt(std.math.ByteAlignedInt(<span class="tok-builtin">@TypeOf</span>(value)), &bytes, value, endian);</span>
<span class="line" id="L77"> <span class="tok-kw">return</span> self.writeAll(&bytes);</span>
<span class="line" id="L78"> }</span>
<span class="line" id="L79"></span>
<span class="line" id="L80"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">writeStruct</span>(self: Self, value: <span class="tok-kw">anytype</span>) Error!<span class="tok-type">void</span> {</span>
<span class="line" id="L81"> <span class="tok-comment">// Only extern and packed structs have defined in-memory layout.</span>
</span>
<span class="line" id="L82"> <span class="tok-kw">comptime</span> assert(<span class="tok-builtin">@typeInfo</span>(<span class="tok-builtin">@TypeOf</span>(value)).Struct.layout != .Auto);</span>
<span class="line" id="L83"> <span class="tok-kw">return</span> self.writeAll(mem.asBytes(&value));</span>
<span class="line" id="L84"> }</span>
<span class="line" id="L85"> };</span>
<span class="line" id="L86">}</span>
<span class="line" id="L87"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/io/c_writer.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>io/c_writer.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../std.zig"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> builtin = <span class="tok-builtin">@import</span>(<span class="tok-str">"builtin"</span>);</span>
<span class="line" id="L3"><span class="tok-kw">const</span> io = std.io;</span>
<span class="line" id="L4"><span class="tok-kw">const</span> testing = std.testing;</span>
<span class="line" id="L5"><span class="tok-kw">const</span> os = std.os;</span>
<span class="line" id="L6"></span>
<span class="line" id="L7"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> CWriter = io.Writer(*std.c.FILE, std.fs.File.WriteError, cWriterWrite);</span>
<span class="line" id="L8"></span>
<span class="line" id="L9"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">cWriter</span>(c_file: *std.c.FILE) CWriter {</span>
<span class="line" id="L10"> <span class="tok-kw">return</span> .{ .context = c_file };</span>
<span class="line" id="L11">}</span>
<span class="line" id="L12"></span>
<span class="line" id="L13"><span class="tok-kw">fn</span> <span class="tok-fn">cWriterWrite</span>(c_file: *std.c.FILE, bytes: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) std.fs.File.WriteError!<span class="tok-type">usize</span> {</span>
<span class="line" id="L14"> <span class="tok-kw">const</span> amt_written = std.c.fwrite(bytes.ptr, <span class="tok-number">1</span>, bytes.len, c_file);</span>
<span class="line" id="L15"> <span class="tok-kw">if</span> (amt_written >= <span class="tok-number">0</span>) <span class="tok-kw">return</span> amt_written;</span>
<span class="line" id="L16"> <span class="tok-kw">switch</span> (<span class="tok-builtin">@as</span>(os.E, <span class="tok-builtin">@enumFromInt</span>(std.c._errno().*))) {</span>
<span class="line" id="L17"> .SUCCESS => <span class="tok-kw">unreachable</span>,</span>
<span class="line" id="L18"> .INVAL => <span class="tok-kw">unreachable</span>,</span>
<span class="line" id="L19"> .FAULT => <span class="tok-kw">unreachable</span>,</span>
<span class="line" id="L20"> .AGAIN => <span class="tok-kw">unreachable</span>, <span class="tok-comment">// this is a blocking API</span>
</span>
<span class="line" id="L21"> .BADF => <span class="tok-kw">unreachable</span>, <span class="tok-comment">// always a race condition</span>
</span>
<span class="line" id="L22"> .DESTADDRREQ => <span class="tok-kw">unreachable</span>, <span class="tok-comment">// connect was never called</span>
</span>
<span class="line" id="L23"> .DQUOT => <span class="tok-kw">return</span> <span class="tok-kw">error</span>.DiskQuota,</span>
<span class="line" id="L24"> .FBIG => <span class="tok-kw">return</span> <span class="tok-kw">error</span>.FileTooBig,</span>
<span class="line" id="L25"> .IO => <span class="tok-kw">return</span> <span class="tok-kw">error</span>.InputOutput,</span>
<span class="line" id="L26"> .NOSPC => <span class="tok-kw">return</span> <span class="tok-kw">error</span>.NoSpaceLeft,</span>
<span class="line" id="L27"> .PERM => <span class="tok-kw">return</span> <span class="tok-kw">error</span>.AccessDenied,</span>
<span class="line" id="L28"> .PIPE => <span class="tok-kw">return</span> <span class="tok-kw">error</span>.BrokenPipe,</span>
<span class="line" id="L29"> <span class="tok-kw">else</span> => |err| <span class="tok-kw">return</span> os.unexpectedErrno(err),</span>
<span class="line" id="L30"> }</span>
<span class="line" id="L31">}</span>
<span class="line" id="L32"></span>
<span class="line" id="L33"><span class="tok-kw">test</span> <span class="tok-str">"C Writer"</span> {</span>
<span class="line" id="L34"> <span class="tok-kw">if</span> (!builtin.link_libc <span class="tok-kw">or</span> builtin.os.tag == .wasi) <span class="tok-kw">return</span> <span class="tok-kw">error</span>.SkipZigTest;</span>
<span class="line" id="L35"></span>
<span class="line" id="L36"> <span class="tok-kw">const</span> filename = <span class="tok-str">"tmp_io_test_file.txt"</span>;</span>
<span class="line" id="L37"> <span class="tok-kw">const</span> out_file = std.c.fopen(filename, <span class="tok-str">"w"</span>) <span class="tok-kw">orelse</span> <span class="tok-kw">return</span> <span class="tok-kw">error</span>.UnableToOpenTestFile;</span>
<span class="line" id="L38"> <span class="tok-kw">defer</span> {</span>
<span class="line" id="L39"> _ = std.c.fclose(out_file);</span>
<span class="line" id="L40"> std.fs.cwd().deleteFileZ(filename) <span class="tok-kw">catch</span> {};</span>
<span class="line" id="L41"> }</span>
<span class="line" id="L42"></span>
<span class="line" id="L43"> <span class="tok-kw">const</span> writer = cWriter(out_file);</span>
<span class="line" id="L44"> <span class="tok-kw">try</span> writer.print(<span class="tok-str">"hi: {}\n"</span>, .{<span class="tok-builtin">@as</span>(<span class="tok-type">i32</span>, <span class="tok-number">123</span>)});</span>
<span class="line" id="L45">}</span>
<span class="line" id="L46"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/io/seekable_stream.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>io/seekable_stream.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../std.zig"</span>);</span>
<span class="line" id="L2"></span>
<span class="line" id="L3"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">SeekableStream</span>(</span>
<span class="line" id="L4"> <span class="tok-kw">comptime</span> Context: <span class="tok-type">type</span>,</span>
<span class="line" id="L5"> <span class="tok-kw">comptime</span> SeekErrorType: <span class="tok-type">type</span>,</span>
<span class="line" id="L6"> <span class="tok-kw">comptime</span> GetSeekPosErrorType: <span class="tok-type">type</span>,</span>
<span class="line" id="L7"> <span class="tok-kw">comptime</span> seekToFn: <span class="tok-kw">fn</span> (context: Context, pos: <span class="tok-type">u64</span>) SeekErrorType!<span class="tok-type">void</span>,</span>
<span class="line" id="L8"> <span class="tok-kw">comptime</span> seekByFn: <span class="tok-kw">fn</span> (context: Context, pos: <span class="tok-type">i64</span>) SeekErrorType!<span class="tok-type">void</span>,</span>
<span class="line" id="L9"> <span class="tok-kw">comptime</span> getPosFn: <span class="tok-kw">fn</span> (context: Context) GetSeekPosErrorType!<span class="tok-type">u64</span>,</span>
<span class="line" id="L10"> <span class="tok-kw">comptime</span> getEndPosFn: <span class="tok-kw">fn</span> (context: Context) GetSeekPosErrorType!<span class="tok-type">u64</span>,</span>
<span class="line" id="L11">) <span class="tok-type">type</span> {</span>
<span class="line" id="L12"> <span class="tok-kw">return</span> <span class="tok-kw">struct</span> {</span>
<span class="line" id="L13"> context: Context,</span>
<span class="line" id="L14"></span>
<span class="line" id="L15"> <span class="tok-kw">const</span> Self = <span class="tok-builtin">@This</span>();</span>
<span class="line" id="L16"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> SeekError = SeekErrorType;</span>
<span class="line" id="L17"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> GetSeekPosError = GetSeekPosErrorType;</span>
<span class="line" id="L18"></span>
<span class="line" id="L19"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">seekTo</span>(self: Self, pos: <span class="tok-type">u64</span>) SeekError!<span class="tok-type">void</span> {</span>
<span class="line" id="L20"> <span class="tok-kw">return</span> seekToFn(self.context, pos);</span>
<span class="line" id="L21"> }</span>
<span class="line" id="L22"></span>
<span class="line" id="L23"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">seekBy</span>(self: Self, amt: <span class="tok-type">i64</span>) SeekError!<span class="tok-type">void</span> {</span>
<span class="line" id="L24"> <span class="tok-kw">return</span> seekByFn(self.context, amt);</span>
<span class="line" id="L25"> }</span>
<span class="line" id="L26"></span>
<span class="line" id="L27"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">getEndPos</span>(self: Self) GetSeekPosError!<span class="tok-type">u64</span> {</span>
<span class="line" id="L28"> <span class="tok-kw">return</span> getEndPosFn(self.context);</span>
<span class="line" id="L29"> }</span>
<span class="line" id="L30"></span>
<span class="line" id="L31"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">getPos</span>(self: Self) GetSeekPosError!<span class="tok-type">u64</span> {</span>
<span class="line" id="L32"> <span class="tok-kw">return</span> getPosFn(self.context);</span>
<span class="line" id="L33"> }</span>
<span class="line" id="L34"> };</span>
<span class="line" id="L35">}</span>
<span class="line" id="L36"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/io/bit_writer.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>io/bit_writer.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../std.zig"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> io = std.io;</span>
<span class="line" id="L3"><span class="tok-kw">const</span> testing = std.testing;</span>
<span class="line" id="L4"><span class="tok-kw">const</span> assert = std.debug.assert;</span>
<span class="line" id="L5"><span class="tok-kw">const</span> trait = std.meta.trait;</span>
<span class="line" id="L6"><span class="tok-kw">const</span> meta = std.meta;</span>
<span class="line" id="L7"><span class="tok-kw">const</span> math = std.math;</span>
<span class="line" id="L8"></span>
<span class="line" id="L9"><span class="tok-comment">/// Creates a stream which allows for writing bit fields to another stream</span></span>
<span class="line" id="L10"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">BitWriter</span>(<span class="tok-kw">comptime</span> endian: std.builtin.Endian, <span class="tok-kw">comptime</span> WriterType: <span class="tok-type">type</span>) <span class="tok-type">type</span> {</span>
<span class="line" id="L11"> <span class="tok-kw">return</span> <span class="tok-kw">struct</span> {</span>
<span class="line" id="L12"> forward_writer: WriterType,</span>
<span class="line" id="L13"> bit_buffer: <span class="tok-type">u8</span>,</span>
<span class="line" id="L14"> bit_count: <span class="tok-type">u4</span>,</span>
<span class="line" id="L15"></span>
<span class="line" id="L16"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> Error = WriterType.Error;</span>
<span class="line" id="L17"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> Writer = io.Writer(*Self, Error, write);</span>
<span class="line" id="L18"></span>
<span class="line" id="L19"> <span class="tok-kw">const</span> Self = <span class="tok-builtin">@This</span>();</span>
<span class="line" id="L20"> <span class="tok-kw">const</span> u8_bit_count = <span class="tok-builtin">@bitSizeOf</span>(<span class="tok-type">u8</span>);</span>
<span class="line" id="L21"> <span class="tok-kw">const</span> u4_bit_count = <span class="tok-builtin">@bitSizeOf</span>(<span class="tok-type">u4</span>);</span>
<span class="line" id="L22"></span>
<span class="line" id="L23"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">init</span>(forward_writer: WriterType) Self {</span>
<span class="line" id="L24"> <span class="tok-kw">return</span> Self{</span>
<span class="line" id="L25"> .forward_writer = forward_writer,</span>
<span class="line" id="L26"> .bit_buffer = <span class="tok-number">0</span>,</span>
<span class="line" id="L27"> .bit_count = <span class="tok-number">0</span>,</span>
<span class="line" id="L28"> };</span>
<span class="line" id="L29"> }</span>
<span class="line" id="L30"></span>
<span class="line" id="L31"> <span class="tok-comment">/// Write the specified number of bits to the stream from the least significant bits of</span></span>
<span class="line" id="L32"> <span class="tok-comment">/// the specified unsigned int value. Bits will only be written to the stream when there</span></span>
<span class="line" id="L33"> <span class="tok-comment">/// are enough to fill a byte.</span></span>
<span class="line" id="L34"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">writeBits</span>(self: *Self, value: <span class="tok-kw">anytype</span>, bits: <span class="tok-type">usize</span>) Error!<span class="tok-type">void</span> {</span>
<span class="line" id="L35"> <span class="tok-kw">if</span> (bits == <span class="tok-number">0</span>) <span class="tok-kw">return</span>;</span>
<span class="line" id="L36"></span>
<span class="line" id="L37"> <span class="tok-kw">const</span> U = <span class="tok-builtin">@TypeOf</span>(value);</span>
<span class="line" id="L38"> <span class="tok-kw">comptime</span> assert(trait.isUnsignedInt(U));</span>
<span class="line" id="L39"></span>
<span class="line" id="L40"> <span class="tok-comment">//by extending the buffer to a minimum of u8 we can cover a number of edge cases</span>
</span>
<span class="line" id="L41"> <span class="tok-comment">// related to shifting and casting.</span>
</span>
<span class="line" id="L42"> <span class="tok-kw">const</span> u_bit_count = <span class="tok-builtin">@bitSizeOf</span>(U);</span>
<span class="line" id="L43"> <span class="tok-kw">const</span> buf_bit_count = bc: {</span>
<span class="line" id="L44"> assert(u_bit_count >= bits);</span>
<span class="line" id="L45"> <span class="tok-kw">break</span> :bc <span class="tok-kw">if</span> (u_bit_count <= u8_bit_count) u8_bit_count <span class="tok-kw">else</span> u_bit_count;</span>
<span class="line" id="L46"> };</span>
<span class="line" id="L47"> <span class="tok-kw">const</span> Buf = std.meta.Int(.unsigned, buf_bit_count);</span>
<span class="line" id="L48"> <span class="tok-kw">const</span> BufShift = math.Log2Int(Buf);</span>
<span class="line" id="L49"></span>
<span class="line" id="L50"> <span class="tok-kw">const</span> buf_value = <span class="tok-builtin">@as</span>(Buf, <span class="tok-builtin">@intCast</span>(value));</span>
<span class="line" id="L51"></span>
<span class="line" id="L52"> <span class="tok-kw">const</span> high_byte_shift = <span class="tok-builtin">@as</span>(BufShift, <span class="tok-builtin">@intCast</span>(buf_bit_count - u8_bit_count));</span>
<span class="line" id="L53"> <span class="tok-kw">var</span> in_buffer = <span class="tok-kw">switch</span> (endian) {</span>
<span class="line" id="L54"> .Big => buf_value << <span class="tok-builtin">@as</span>(BufShift, <span class="tok-builtin">@intCast</span>(buf_bit_count - bits)),</span>
<span class="line" id="L55"> .Little => buf_value,</span>
<span class="line" id="L56"> };</span>
<span class="line" id="L57"> <span class="tok-kw">var</span> in_bits = bits;</span>
<span class="line" id="L58"></span>
<span class="line" id="L59"> <span class="tok-kw">if</span> (self.bit_count > <span class="tok-number">0</span>) {</span>
<span class="line" id="L60"> <span class="tok-kw">const</span> bits_remaining = u8_bit_count - self.bit_count;</span>
<span class="line" id="L61"> <span class="tok-kw">const</span> n = <span class="tok-builtin">@as</span>(<span class="tok-type">u3</span>, <span class="tok-builtin">@intCast</span>(<span class="tok-kw">if</span> (bits_remaining > bits) bits <span class="tok-kw">else</span> bits_remaining));</span>
<span class="line" id="L62"> <span class="tok-kw">switch</span> (endian) {</span>
<span class="line" id="L63"> .Big => {</span>
<span class="line" id="L64"> <span class="tok-kw">const</span> shift = <span class="tok-builtin">@as</span>(BufShift, <span class="tok-builtin">@intCast</span>(high_byte_shift + self.bit_count));</span>
<span class="line" id="L65"> <span class="tok-kw">const</span> v = <span class="tok-builtin">@as</span>(<span class="tok-type">u8</span>, <span class="tok-builtin">@intCast</span>(in_buffer >> shift));</span>
<span class="line" id="L66"> self.bit_buffer |= v;</span>
<span class="line" id="L67"> in_buffer <<= n;</span>
<span class="line" id="L68"> },</span>
<span class="line" id="L69"> .Little => {</span>
<span class="line" id="L70"> <span class="tok-kw">const</span> v = <span class="tok-builtin">@as</span>(<span class="tok-type">u8</span>, <span class="tok-builtin">@truncate</span>(in_buffer)) << <span class="tok-builtin">@as</span>(<span class="tok-type">u3</span>, <span class="tok-builtin">@intCast</span>(self.bit_count));</span>
<span class="line" id="L71"> self.bit_buffer |= v;</span>
<span class="line" id="L72"> in_buffer >>= n;</span>
<span class="line" id="L73"> },</span>
<span class="line" id="L74"> }</span>
<span class="line" id="L75"> self.bit_count += n;</span>
<span class="line" id="L76"> in_bits -= n;</span>
<span class="line" id="L77"></span>
<span class="line" id="L78"> <span class="tok-comment">//if we didn't fill the buffer, it's because bits < bits_remaining;</span>
</span>
<span class="line" id="L79"> <span class="tok-kw">if</span> (self.bit_count != u8_bit_count) <span class="tok-kw">return</span>;</span>
<span class="line" id="L80"> <span class="tok-kw">try</span> self.forward_writer.writeByte(self.bit_buffer);</span>
<span class="line" id="L81"> self.bit_buffer = <span class="tok-number">0</span>;</span>
<span class="line" id="L82"> self.bit_count = <span class="tok-number">0</span>;</span>
<span class="line" id="L83"> }</span>
<span class="line" id="L84"> <span class="tok-comment">//at this point we know bit_buffer is empty</span>
</span>
<span class="line" id="L85"></span>
<span class="line" id="L86"> <span class="tok-comment">//copy bytes until we can't fill one anymore, then leave the rest in bit_buffer</span>
</span>
<span class="line" id="L87"> <span class="tok-kw">while</span> (in_bits >= u8_bit_count) {</span>
<span class="line" id="L88"> <span class="tok-kw">switch</span> (endian) {</span>
<span class="line" id="L89"> .Big => {</span>
<span class="line" id="L90"> <span class="tok-kw">const</span> v = <span class="tok-builtin">@as</span>(<span class="tok-type">u8</span>, <span class="tok-builtin">@intCast</span>(in_buffer >> high_byte_shift));</span>
<span class="line" id="L91"> <span class="tok-kw">try</span> self.forward_writer.writeByte(v);</span>
<span class="line" id="L92"> in_buffer <<= <span class="tok-builtin">@as</span>(<span class="tok-type">u3</span>, <span class="tok-builtin">@intCast</span>(u8_bit_count - <span class="tok-number">1</span>));</span>
<span class="line" id="L93"> in_buffer <<= <span class="tok-number">1</span>;</span>
<span class="line" id="L94"> },</span>
<span class="line" id="L95"> .Little => {</span>
<span class="line" id="L96"> <span class="tok-kw">const</span> v = <span class="tok-builtin">@as</span>(<span class="tok-type">u8</span>, <span class="tok-builtin">@truncate</span>(in_buffer));</span>
<span class="line" id="L97"> <span class="tok-kw">try</span> self.forward_writer.writeByte(v);</span>
<span class="line" id="L98"> in_buffer >>= <span class="tok-builtin">@as</span>(<span class="tok-type">u3</span>, <span class="tok-builtin">@intCast</span>(u8_bit_count - <span class="tok-number">1</span>));</span>
<span class="line" id="L99"> in_buffer >>= <span class="tok-number">1</span>;</span>
<span class="line" id="L100"> },</span>
<span class="line" id="L101"> }</span>
<span class="line" id="L102"> in_bits -= u8_bit_count;</span>
<span class="line" id="L103"> }</span>
<span class="line" id="L104"></span>
<span class="line" id="L105"> <span class="tok-kw">if</span> (in_bits > <span class="tok-number">0</span>) {</span>
<span class="line" id="L106"> self.bit_count = <span class="tok-builtin">@as</span>(<span class="tok-type">u4</span>, <span class="tok-builtin">@intCast</span>(in_bits));</span>
<span class="line" id="L107"> self.bit_buffer = <span class="tok-kw">switch</span> (endian) {</span>
<span class="line" id="L108"> .Big => <span class="tok-builtin">@as</span>(<span class="tok-type">u8</span>, <span class="tok-builtin">@truncate</span>(in_buffer >> high_byte_shift)),</span>
<span class="line" id="L109"> .Little => <span class="tok-builtin">@as</span>(<span class="tok-type">u8</span>, <span class="tok-builtin">@truncate</span>(in_buffer)),</span>
<span class="line" id="L110"> };</span>
<span class="line" id="L111"> }</span>
<span class="line" id="L112"> }</span>
<span class="line" id="L113"></span>
<span class="line" id="L114"> <span class="tok-comment">/// Flush any remaining bits to the stream.</span></span>
<span class="line" id="L115"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">flushBits</span>(self: *Self) Error!<span class="tok-type">void</span> {</span>
<span class="line" id="L116"> <span class="tok-kw">if</span> (self.bit_count == <span class="tok-number">0</span>) <span class="tok-kw">return</span>;</span>
<span class="line" id="L117"> <span class="tok-kw">try</span> self.forward_writer.writeByte(self.bit_buffer);</span>
<span class="line" id="L118"> self.bit_buffer = <span class="tok-number">0</span>;</span>
<span class="line" id="L119"> self.bit_count = <span class="tok-number">0</span>;</span>
<span class="line" id="L120"> }</span>
<span class="line" id="L121"></span>
<span class="line" id="L122"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">write</span>(self: *Self, buffer: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) Error!<span class="tok-type">usize</span> {</span>
<span class="line" id="L123"> <span class="tok-comment">// TODO: I'm not sure this is a good idea, maybe flushBits should be forced</span>
</span>
<span class="line" id="L124"> <span class="tok-kw">if</span> (self.bit_count > <span class="tok-number">0</span>) {</span>
<span class="line" id="L125"> <span class="tok-kw">for</span> (buffer) |b|</span>
<span class="line" id="L126"> <span class="tok-kw">try</span> self.writeBits(b, u8_bit_count);</span>
<span class="line" id="L127"> <span class="tok-kw">return</span> buffer.len;</span>
<span class="line" id="L128"> }</span>
<span class="line" id="L129"></span>
<span class="line" id="L130"> <span class="tok-kw">return</span> self.forward_writer.write(buffer);</span>
<span class="line" id="L131"> }</span>
<span class="line" id="L132"></span>
<span class="line" id="L133"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">writer</span>(self: *Self) Writer {</span>
<span class="line" id="L134"> <span class="tok-kw">return</span> .{ .context = self };</span>
<span class="line" id="L135"> }</span>
<span class="line" id="L136"> };</span>
<span class="line" id="L137">}</span>
<span class="line" id="L138"></span>
<span class="line" id="L139"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">bitWriter</span>(</span>
<span class="line" id="L140"> <span class="tok-kw">comptime</span> endian: std.builtin.Endian,</span>
<span class="line" id="L141"> underlying_stream: <span class="tok-kw">anytype</span>,</span>
<span class="line" id="L142">) BitWriter(endian, <span class="tok-builtin">@TypeOf</span>(underlying_stream)) {</span>
<span class="line" id="L143"> <span class="tok-kw">return</span> BitWriter(endian, <span class="tok-builtin">@TypeOf</span>(underlying_stream)).init(underlying_stream);</span>
<span class="line" id="L144">}</span>
<span class="line" id="L145"></span>
<span class="line" id="L146"><span class="tok-kw">test</span> <span class="tok-str">"api coverage"</span> {</span>
<span class="line" id="L147"> <span class="tok-kw">var</span> mem_be = [_]<span class="tok-type">u8</span>{<span class="tok-number">0</span>} ** <span class="tok-number">2</span>;</span>
<span class="line" id="L148"> <span class="tok-kw">var</span> mem_le = [_]<span class="tok-type">u8</span>{<span class="tok-number">0</span>} ** <span class="tok-number">2</span>;</span>
<span class="line" id="L149"></span>
<span class="line" id="L150"> <span class="tok-kw">var</span> mem_out_be = io.fixedBufferStream(&mem_be);</span>
<span class="line" id="L151"> <span class="tok-kw">var</span> bit_stream_be = bitWriter(.Big, mem_out_be.writer());</span>
<span class="line" id="L152"></span>
<span class="line" id="L153"> <span class="tok-kw">try</span> bit_stream_be.writeBits(<span class="tok-builtin">@as</span>(<span class="tok-type">u2</span>, <span class="tok-number">1</span>), <span class="tok-number">1</span>);</span>
<span class="line" id="L154"> <span class="tok-kw">try</span> bit_stream_be.writeBits(<span class="tok-builtin">@as</span>(<span class="tok-type">u5</span>, <span class="tok-number">2</span>), <span class="tok-number">2</span>);</span>
<span class="line" id="L155"> <span class="tok-kw">try</span> bit_stream_be.writeBits(<span class="tok-builtin">@as</span>(<span class="tok-type">u128</span>, <span class="tok-number">3</span>), <span class="tok-number">3</span>);</span>
<span class="line" id="L156"> <span class="tok-kw">try</span> bit_stream_be.writeBits(<span class="tok-builtin">@as</span>(<span class="tok-type">u8</span>, <span class="tok-number">4</span>), <span class="tok-number">4</span>);</span>
<span class="line" id="L157"> <span class="tok-kw">try</span> bit_stream_be.writeBits(<span class="tok-builtin">@as</span>(<span class="tok-type">u9</span>, <span class="tok-number">5</span>), <span class="tok-number">5</span>);</span>
<span class="line" id="L158"> <span class="tok-kw">try</span> bit_stream_be.writeBits(<span class="tok-builtin">@as</span>(<span class="tok-type">u1</span>, <span class="tok-number">1</span>), <span class="tok-number">1</span>);</span>
<span class="line" id="L159"></span>
<span class="line" id="L160"> <span class="tok-kw">try</span> testing.expect(mem_be[<span class="tok-number">0</span>] == <span class="tok-number">0b11001101</span> <span class="tok-kw">and</span> mem_be[<span class="tok-number">1</span>] == <span class="tok-number">0b00001011</span>);</span>
<span class="line" id="L161"></span>
<span class="line" id="L162"> mem_out_be.pos = <span class="tok-number">0</span>;</span>
<span class="line" id="L163"></span>
<span class="line" id="L164"> <span class="tok-kw">try</span> bit_stream_be.writeBits(<span class="tok-builtin">@as</span>(<span class="tok-type">u15</span>, <span class="tok-number">0b110011010000101</span>), <span class="tok-number">15</span>);</span>
<span class="line" id="L165"> <span class="tok-kw">try</span> bit_stream_be.flushBits();</span>
<span class="line" id="L166"> <span class="tok-kw">try</span> testing.expect(mem_be[<span class="tok-number">0</span>] == <span class="tok-number">0b11001101</span> <span class="tok-kw">and</span> mem_be[<span class="tok-number">1</span>] == <span class="tok-number">0b00001010</span>);</span>
<span class="line" id="L167"></span>
<span class="line" id="L168"> mem_out_be.pos = <span class="tok-number">0</span>;</span>
<span class="line" id="L169"> <span class="tok-kw">try</span> bit_stream_be.writeBits(<span class="tok-builtin">@as</span>(<span class="tok-type">u32</span>, <span class="tok-number">0b110011010000101</span>), <span class="tok-number">16</span>);</span>
<span class="line" id="L170"> <span class="tok-kw">try</span> testing.expect(mem_be[<span class="tok-number">0</span>] == <span class="tok-number">0b01100110</span> <span class="tok-kw">and</span> mem_be[<span class="tok-number">1</span>] == <span class="tok-number">0b10000101</span>);</span>
<span class="line" id="L171"></span>
<span class="line" id="L172"> <span class="tok-kw">try</span> bit_stream_be.writeBits(<span class="tok-builtin">@as</span>(<span class="tok-type">u0</span>, <span class="tok-number">0</span>), <span class="tok-number">0</span>);</span>
<span class="line" id="L173"></span>
<span class="line" id="L174"> <span class="tok-kw">var</span> mem_out_le = io.fixedBufferStream(&mem_le);</span>
<span class="line" id="L175"> <span class="tok-kw">var</span> bit_stream_le = bitWriter(.Little, mem_out_le.writer());</span>
<span class="line" id="L176"></span>
<span class="line" id="L177"> <span class="tok-kw">try</span> bit_stream_le.writeBits(<span class="tok-builtin">@as</span>(<span class="tok-type">u2</span>, <span class="tok-number">1</span>), <span class="tok-number">1</span>);</span>
<span class="line" id="L178"> <span class="tok-kw">try</span> bit_stream_le.writeBits(<span class="tok-builtin">@as</span>(<span class="tok-type">u5</span>, <span class="tok-number">2</span>), <span class="tok-number">2</span>);</span>
<span class="line" id="L179"> <span class="tok-kw">try</span> bit_stream_le.writeBits(<span class="tok-builtin">@as</span>(<span class="tok-type">u128</span>, <span class="tok-number">3</span>), <span class="tok-number">3</span>);</span>
<span class="line" id="L180"> <span class="tok-kw">try</span> bit_stream_le.writeBits(<span class="tok-builtin">@as</span>(<span class="tok-type">u8</span>, <span class="tok-number">4</span>), <span class="tok-number">4</span>);</span>
<span class="line" id="L181"> <span class="tok-kw">try</span> bit_stream_le.writeBits(<span class="tok-builtin">@as</span>(<span class="tok-type">u9</span>, <span class="tok-number">5</span>), <span class="tok-number">5</span>);</span>
<span class="line" id="L182"> <span class="tok-kw">try</span> bit_stream_le.writeBits(<span class="tok-builtin">@as</span>(<span class="tok-type">u1</span>, <span class="tok-number">1</span>), <span class="tok-number">1</span>);</span>
<span class="line" id="L183"></span>
<span class="line" id="L184"> <span class="tok-kw">try</span> testing.expect(mem_le[<span class="tok-number">0</span>] == <span class="tok-number">0b00011101</span> <span class="tok-kw">and</span> mem_le[<span class="tok-number">1</span>] == <span class="tok-number">0b10010101</span>);</span>
<span class="line" id="L185"></span>
<span class="line" id="L186"> mem_out_le.pos = <span class="tok-number">0</span>;</span>
<span class="line" id="L187"> <span class="tok-kw">try</span> bit_stream_le.writeBits(<span class="tok-builtin">@as</span>(<span class="tok-type">u15</span>, <span class="tok-number">0b110011010000101</span>), <span class="tok-number">15</span>);</span>
<span class="line" id="L188"> <span class="tok-kw">try</span> bit_stream_le.flushBits();</span>
<span class="line" id="L189"> <span class="tok-kw">try</span> testing.expect(mem_le[<span class="tok-number">0</span>] == <span class="tok-number">0b10000101</span> <span class="tok-kw">and</span> mem_le[<span class="tok-number">1</span>] == <span class="tok-number">0b01100110</span>);</span>
<span class="line" id="L190"></span>
<span class="line" id="L191"> mem_out_le.pos = <span class="tok-number">0</span>;</span>
<span class="line" id="L192"> <span class="tok-kw">try</span> bit_stream_le.writeBits(<span class="tok-builtin">@as</span>(<span class="tok-type">u32</span>, <span class="tok-number">0b1100110100001011</span>), <span class="tok-number">16</span>);</span>
<span class="line" id="L193"> <span class="tok-kw">try</span> testing.expect(mem_le[<span class="tok-number">0</span>] == <span class="tok-number">0b00001011</span> <span class="tok-kw">and</span> mem_le[<span class="tok-number">1</span>] == <span class="tok-number">0b11001101</span>);</span>
<span class="line" id="L194"></span>
<span class="line" id="L195"> <span class="tok-kw">try</span> bit_stream_le.writeBits(<span class="tok-builtin">@as</span>(<span class="tok-type">u0</span>, <span class="tok-number">0</span>), <span class="tok-number">0</span>);</span>
<span class="line" id="L196">}</span>
<span class="line" id="L197"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/io/counting_writer.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>io/counting_writer.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../std.zig"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> io = std.io;</span>
<span class="line" id="L3"><span class="tok-kw">const</span> testing = std.testing;</span>
<span class="line" id="L4"></span>
<span class="line" id="L5"><span class="tok-comment">/// A Writer that counts how many bytes has been written to it.</span></span>
<span class="line" id="L6"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">CountingWriter</span>(<span class="tok-kw">comptime</span> WriterType: <span class="tok-type">type</span>) <span class="tok-type">type</span> {</span>
<span class="line" id="L7"> <span class="tok-kw">return</span> <span class="tok-kw">struct</span> {</span>
<span class="line" id="L8"> bytes_written: <span class="tok-type">u64</span>,</span>
<span class="line" id="L9"> child_stream: WriterType,</span>
<span class="line" id="L10"></span>
<span class="line" id="L11"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> Error = WriterType.Error;</span>
<span class="line" id="L12"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> Writer = io.Writer(*Self, Error, write);</span>
<span class="line" id="L13"></span>
<span class="line" id="L14"> <span class="tok-kw">const</span> Self = <span class="tok-builtin">@This</span>();</span>
<span class="line" id="L15"></span>
<span class="line" id="L16"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">write</span>(self: *Self, bytes: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) Error!<span class="tok-type">usize</span> {</span>
<span class="line" id="L17"> <span class="tok-kw">const</span> amt = <span class="tok-kw">try</span> self.child_stream.write(bytes);</span>
<span class="line" id="L18"> self.bytes_written += amt;</span>
<span class="line" id="L19"> <span class="tok-kw">return</span> amt;</span>
<span class="line" id="L20"> }</span>
<span class="line" id="L21"></span>
<span class="line" id="L22"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">writer</span>(self: *Self) Writer {</span>
<span class="line" id="L23"> <span class="tok-kw">return</span> .{ .context = self };</span>
<span class="line" id="L24"> }</span>
<span class="line" id="L25"> };</span>
<span class="line" id="L26">}</span>
<span class="line" id="L27"></span>
<span class="line" id="L28"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">countingWriter</span>(child_stream: <span class="tok-kw">anytype</span>) CountingWriter(<span class="tok-builtin">@TypeOf</span>(child_stream)) {</span>
<span class="line" id="L29"> <span class="tok-kw">return</span> .{ .bytes_written = <span class="tok-number">0</span>, .child_stream = child_stream };</span>
<span class="line" id="L30">}</span>
<span class="line" id="L31"></span>
<span class="line" id="L32"><span class="tok-kw">test</span> <span class="tok-str">"io.CountingWriter"</span> {</span>
<span class="line" id="L33"> <span class="tok-kw">var</span> counting_stream = countingWriter(std.io.null_writer);</span>
<span class="line" id="L34"> <span class="tok-kw">const</span> stream = counting_stream.writer();</span>
<span class="line" id="L35"></span>
<span class="line" id="L36"> <span class="tok-kw">const</span> bytes = <span class="tok-str">"yay"</span> ** <span class="tok-number">100</span>;</span>
<span class="line" id="L37"> stream.writeAll(bytes) <span class="tok-kw">catch</span> <span class="tok-kw">unreachable</span>;</span>
<span class="line" id="L38"> <span class="tok-kw">try</span> testing.expect(counting_stream.bytes_written == bytes.len);</span>
<span class="line" id="L39">}</span>
<span class="line" id="L40"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/io/bit_reader.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>io/bit_reader.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../std.zig"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> io = std.io;</span>
<span class="line" id="L3"><span class="tok-kw">const</span> assert = std.debug.assert;</span>
<span class="line" id="L4"><span class="tok-kw">const</span> testing = std.testing;</span>
<span class="line" id="L5"><span class="tok-kw">const</span> trait = std.meta.trait;</span>
<span class="line" id="L6"><span class="tok-kw">const</span> meta = std.meta;</span>
<span class="line" id="L7"><span class="tok-kw">const</span> math = std.math;</span>
<span class="line" id="L8"></span>
<span class="line" id="L9"><span class="tok-comment">/// Creates a stream which allows for reading bit fields from another stream</span></span>
<span class="line" id="L10"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">BitReader</span>(<span class="tok-kw">comptime</span> endian: std.builtin.Endian, <span class="tok-kw">comptime</span> ReaderType: <span class="tok-type">type</span>) <span class="tok-type">type</span> {</span>
<span class="line" id="L11"> <span class="tok-kw">return</span> <span class="tok-kw">struct</span> {</span>
<span class="line" id="L12"> forward_reader: ReaderType,</span>
<span class="line" id="L13"> bit_buffer: <span class="tok-type">u7</span>,</span>
<span class="line" id="L14"> bit_count: <span class="tok-type">u3</span>,</span>
<span class="line" id="L15"></span>
<span class="line" id="L16"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> Error = ReaderType.Error;</span>
<span class="line" id="L17"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> Reader = io.Reader(*Self, Error, read);</span>
<span class="line" id="L18"></span>
<span class="line" id="L19"> <span class="tok-kw">const</span> Self = <span class="tok-builtin">@This</span>();</span>
<span class="line" id="L20"> <span class="tok-kw">const</span> u8_bit_count = <span class="tok-builtin">@bitSizeOf</span>(<span class="tok-type">u8</span>);</span>
<span class="line" id="L21"> <span class="tok-kw">const</span> u7_bit_count = <span class="tok-builtin">@bitSizeOf</span>(<span class="tok-type">u7</span>);</span>
<span class="line" id="L22"> <span class="tok-kw">const</span> u4_bit_count = <span class="tok-builtin">@bitSizeOf</span>(<span class="tok-type">u4</span>);</span>
<span class="line" id="L23"></span>
<span class="line" id="L24"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">init</span>(forward_reader: ReaderType) Self {</span>
<span class="line" id="L25"> <span class="tok-kw">return</span> Self{</span>
<span class="line" id="L26"> .forward_reader = forward_reader,</span>
<span class="line" id="L27"> .bit_buffer = <span class="tok-number">0</span>,</span>
<span class="line" id="L28"> .bit_count = <span class="tok-number">0</span>,</span>
<span class="line" id="L29"> };</span>
<span class="line" id="L30"> }</span>
<span class="line" id="L31"></span>
<span class="line" id="L32"> <span class="tok-comment">/// Reads `bits` bits from the stream and returns a specified unsigned int type</span></span>
<span class="line" id="L33"> <span class="tok-comment">/// containing them in the least significant end, returning an error if the</span></span>
<span class="line" id="L34"> <span class="tok-comment">/// specified number of bits could not be read.</span></span>
<span class="line" id="L35"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">readBitsNoEof</span>(self: *Self, <span class="tok-kw">comptime</span> U: <span class="tok-type">type</span>, bits: <span class="tok-type">usize</span>) !U {</span>
<span class="line" id="L36"> <span class="tok-kw">var</span> n: <span class="tok-type">usize</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L37"> <span class="tok-kw">const</span> result = <span class="tok-kw">try</span> self.readBits(U, bits, &n);</span>
<span class="line" id="L38"> <span class="tok-kw">if</span> (n < bits) <span class="tok-kw">return</span> <span class="tok-kw">error</span>.EndOfStream;</span>
<span class="line" id="L39"> <span class="tok-kw">return</span> result;</span>
<span class="line" id="L40"> }</span>
<span class="line" id="L41"></span>
<span class="line" id="L42"> <span class="tok-comment">/// Reads `bits` bits from the stream and returns a specified unsigned int type</span></span>
<span class="line" id="L43"> <span class="tok-comment">/// containing them in the least significant end. The number of bits successfully</span></span>
<span class="line" id="L44"> <span class="tok-comment">/// read is placed in `out_bits`, as reaching the end of the stream is not an error.</span></span>
<span class="line" id="L45"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">readBits</span>(self: *Self, <span class="tok-kw">comptime</span> U: <span class="tok-type">type</span>, bits: <span class="tok-type">usize</span>, out_bits: *<span class="tok-type">usize</span>) Error!U {</span>
<span class="line" id="L46"> <span class="tok-kw">comptime</span> assert(trait.isUnsignedInt(U));</span>
<span class="line" id="L47"></span>
<span class="line" id="L48"> <span class="tok-comment">//by extending the buffer to a minimum of u8 we can cover a number of edge cases</span>
</span>
<span class="line" id="L49"> <span class="tok-comment">// related to shifting and casting.</span>
</span>
<span class="line" id="L50"> <span class="tok-kw">const</span> u_bit_count = <span class="tok-builtin">@bitSizeOf</span>(U);</span>
<span class="line" id="L51"> <span class="tok-kw">const</span> buf_bit_count = bc: {</span>
<span class="line" id="L52"> assert(u_bit_count >= bits);</span>
<span class="line" id="L53"> <span class="tok-kw">break</span> :bc <span class="tok-kw">if</span> (u_bit_count <= u8_bit_count) u8_bit_count <span class="tok-kw">else</span> u_bit_count;</span>
<span class="line" id="L54"> };</span>
<span class="line" id="L55"> <span class="tok-kw">const</span> Buf = std.meta.Int(.unsigned, buf_bit_count);</span>
<span class="line" id="L56"> <span class="tok-kw">const</span> BufShift = math.Log2Int(Buf);</span>
<span class="line" id="L57"></span>
<span class="line" id="L58"> out_bits.* = <span class="tok-builtin">@as</span>(<span class="tok-type">usize</span>, <span class="tok-number">0</span>);</span>
<span class="line" id="L59"> <span class="tok-kw">if</span> (U == <span class="tok-type">u0</span> <span class="tok-kw">or</span> bits == <span class="tok-number">0</span>) <span class="tok-kw">return</span> <span class="tok-number">0</span>;</span>
<span class="line" id="L60"> <span class="tok-kw">var</span> out_buffer = <span class="tok-builtin">@as</span>(Buf, <span class="tok-number">0</span>);</span>
<span class="line" id="L61"></span>
<span class="line" id="L62"> <span class="tok-kw">if</span> (self.bit_count > <span class="tok-number">0</span>) {</span>
<span class="line" id="L63"> <span class="tok-kw">const</span> n = <span class="tok-kw">if</span> (self.bit_count >= bits) <span class="tok-builtin">@as</span>(<span class="tok-type">u3</span>, <span class="tok-builtin">@intCast</span>(bits)) <span class="tok-kw">else</span> self.bit_count;</span>
<span class="line" id="L64"> <span class="tok-kw">const</span> shift = u7_bit_count - n;</span>
<span class="line" id="L65"> <span class="tok-kw">switch</span> (endian) {</span>
<span class="line" id="L66"> .Big => {</span>
<span class="line" id="L67"> out_buffer = <span class="tok-builtin">@as</span>(Buf, self.bit_buffer >> shift);</span>
<span class="line" id="L68"> <span class="tok-kw">if</span> (n >= u7_bit_count)</span>
<span class="line" id="L69"> self.bit_buffer = <span class="tok-number">0</span></span>
<span class="line" id="L70"> <span class="tok-kw">else</span></span>
<span class="line" id="L71"> self.bit_buffer <<= n;</span>
<span class="line" id="L72"> },</span>
<span class="line" id="L73"> .Little => {</span>
<span class="line" id="L74"> <span class="tok-kw">const</span> value = (self.bit_buffer << shift) >> shift;</span>
<span class="line" id="L75"> out_buffer = <span class="tok-builtin">@as</span>(Buf, value);</span>
<span class="line" id="L76"> <span class="tok-kw">if</span> (n >= u7_bit_count)</span>
<span class="line" id="L77"> self.bit_buffer = <span class="tok-number">0</span></span>
<span class="line" id="L78"> <span class="tok-kw">else</span></span>
<span class="line" id="L79"> self.bit_buffer >>= n;</span>
<span class="line" id="L80"> },</span>
<span class="line" id="L81"> }</span>
<span class="line" id="L82"> self.bit_count -= n;</span>
<span class="line" id="L83"> out_bits.* = n;</span>
<span class="line" id="L84"> }</span>
<span class="line" id="L85"> <span class="tok-comment">//at this point we know bit_buffer is empty</span>
</span>
<span class="line" id="L86"></span>
<span class="line" id="L87"> <span class="tok-comment">//copy bytes until we have enough bits, then leave the rest in bit_buffer</span>
</span>
<span class="line" id="L88"> <span class="tok-kw">while</span> (out_bits.* < bits) {</span>
<span class="line" id="L89"> <span class="tok-kw">const</span> n = bits - out_bits.*;</span>
<span class="line" id="L90"> <span class="tok-kw">const</span> next_byte = self.forward_reader.readByte() <span class="tok-kw">catch</span> |err| <span class="tok-kw">switch</span> (err) {</span>
<span class="line" id="L91"> <span class="tok-kw">error</span>.EndOfStream => <span class="tok-kw">return</span> <span class="tok-builtin">@as</span>(U, <span class="tok-builtin">@intCast</span>(out_buffer)),</span>
<span class="line" id="L92"> <span class="tok-kw">else</span> => |e| <span class="tok-kw">return</span> e,</span>
<span class="line" id="L93"> };</span>
<span class="line" id="L94"></span>
<span class="line" id="L95"> <span class="tok-kw">switch</span> (endian) {</span>
<span class="line" id="L96"> .Big => {</span>
<span class="line" id="L97"> <span class="tok-kw">if</span> (n >= u8_bit_count) {</span>
<span class="line" id="L98"> out_buffer <<= <span class="tok-builtin">@as</span>(<span class="tok-type">u3</span>, <span class="tok-builtin">@intCast</span>(u8_bit_count - <span class="tok-number">1</span>));</span>
<span class="line" id="L99"> out_buffer <<= <span class="tok-number">1</span>;</span>
<span class="line" id="L100"> out_buffer |= <span class="tok-builtin">@as</span>(Buf, next_byte);</span>
<span class="line" id="L101"> out_bits.* += u8_bit_count;</span>
<span class="line" id="L102"> <span class="tok-kw">continue</span>;</span>
<span class="line" id="L103"> }</span>
<span class="line" id="L104"></span>
<span class="line" id="L105"> <span class="tok-kw">const</span> shift = <span class="tok-builtin">@as</span>(<span class="tok-type">u3</span>, <span class="tok-builtin">@intCast</span>(u8_bit_count - n));</span>
<span class="line" id="L106"> out_buffer <<= <span class="tok-builtin">@as</span>(BufShift, <span class="tok-builtin">@intCast</span>(n));</span>
<span class="line" id="L107"> out_buffer |= <span class="tok-builtin">@as</span>(Buf, next_byte >> shift);</span>
<span class="line" id="L108"> out_bits.* += n;</span>
<span class="line" id="L109"> self.bit_buffer = <span class="tok-builtin">@as</span>(<span class="tok-type">u7</span>, <span class="tok-builtin">@truncate</span>(next_byte << <span class="tok-builtin">@as</span>(<span class="tok-type">u3</span>, <span class="tok-builtin">@intCast</span>(n - <span class="tok-number">1</span>))));</span>
<span class="line" id="L110"> self.bit_count = shift;</span>
<span class="line" id="L111"> },</span>
<span class="line" id="L112"> .Little => {</span>
<span class="line" id="L113"> <span class="tok-kw">if</span> (n >= u8_bit_count) {</span>
<span class="line" id="L114"> out_buffer |= <span class="tok-builtin">@as</span>(Buf, next_byte) << <span class="tok-builtin">@as</span>(BufShift, <span class="tok-builtin">@intCast</span>(out_bits.*));</span>
<span class="line" id="L115"> out_bits.* += u8_bit_count;</span>
<span class="line" id="L116"> <span class="tok-kw">continue</span>;</span>
<span class="line" id="L117"> }</span>
<span class="line" id="L118"></span>
<span class="line" id="L119"> <span class="tok-kw">const</span> shift = <span class="tok-builtin">@as</span>(<span class="tok-type">u3</span>, <span class="tok-builtin">@intCast</span>(u8_bit_count - n));</span>
<span class="line" id="L120"> <span class="tok-kw">const</span> value = (next_byte << shift) >> shift;</span>
<span class="line" id="L121"> out_buffer |= <span class="tok-builtin">@as</span>(Buf, value) << <span class="tok-builtin">@as</span>(BufShift, <span class="tok-builtin">@intCast</span>(out_bits.*));</span>
<span class="line" id="L122"> out_bits.* += n;</span>
<span class="line" id="L123"> self.bit_buffer = <span class="tok-builtin">@as</span>(<span class="tok-type">u7</span>, <span class="tok-builtin">@truncate</span>(next_byte >> <span class="tok-builtin">@as</span>(<span class="tok-type">u3</span>, <span class="tok-builtin">@intCast</span>(n))));</span>
<span class="line" id="L124"> self.bit_count = shift;</span>
<span class="line" id="L125"> },</span>
<span class="line" id="L126"> }</span>
<span class="line" id="L127"> }</span>
<span class="line" id="L128"></span>
<span class="line" id="L129"> <span class="tok-kw">return</span> <span class="tok-builtin">@as</span>(U, <span class="tok-builtin">@intCast</span>(out_buffer));</span>
<span class="line" id="L130"> }</span>
<span class="line" id="L131"></span>
<span class="line" id="L132"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">alignToByte</span>(self: *Self) <span class="tok-type">void</span> {</span>
<span class="line" id="L133"> self.bit_buffer = <span class="tok-number">0</span>;</span>
<span class="line" id="L134"> self.bit_count = <span class="tok-number">0</span>;</span>
<span class="line" id="L135"> }</span>
<span class="line" id="L136"></span>
<span class="line" id="L137"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">read</span>(self: *Self, buffer: []<span class="tok-type">u8</span>) Error!<span class="tok-type">usize</span> {</span>
<span class="line" id="L138"> <span class="tok-kw">var</span> out_bits: <span class="tok-type">usize</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L139"> <span class="tok-kw">var</span> out_bits_total = <span class="tok-builtin">@as</span>(<span class="tok-type">usize</span>, <span class="tok-number">0</span>);</span>
<span class="line" id="L140"> <span class="tok-comment">//@NOTE: I'm not sure this is a good idea, maybe alignToByte should be forced</span>
</span>
<span class="line" id="L141"> <span class="tok-kw">if</span> (self.bit_count > <span class="tok-number">0</span>) {</span>
<span class="line" id="L142"> <span class="tok-kw">for</span> (buffer) |*b| {</span>
<span class="line" id="L143"> b.* = <span class="tok-kw">try</span> self.readBits(<span class="tok-type">u8</span>, u8_bit_count, &out_bits);</span>
<span class="line" id="L144"> out_bits_total += out_bits;</span>
<span class="line" id="L145"> }</span>
<span class="line" id="L146"> <span class="tok-kw">const</span> incomplete_byte = <span class="tok-builtin">@intFromBool</span>(out_bits_total % u8_bit_count > <span class="tok-number">0</span>);</span>
<span class="line" id="L147"> <span class="tok-kw">return</span> (out_bits_total / u8_bit_count) + incomplete_byte;</span>
<span class="line" id="L148"> }</span>
<span class="line" id="L149"></span>
<span class="line" id="L150"> <span class="tok-kw">return</span> self.forward_reader.read(buffer);</span>
<span class="line" id="L151"> }</span>
<span class="line" id="L152"></span>
<span class="line" id="L153"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">reader</span>(self: *Self) Reader {</span>
<span class="line" id="L154"> <span class="tok-kw">return</span> .{ .context = self };</span>
<span class="line" id="L155"> }</span>
<span class="line" id="L156"> };</span>
<span class="line" id="L157">}</span>
<span class="line" id="L158"></span>
<span class="line" id="L159"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">bitReader</span>(</span>
<span class="line" id="L160"> <span class="tok-kw">comptime</span> endian: std.builtin.Endian,</span>
<span class="line" id="L161"> underlying_stream: <span class="tok-kw">anytype</span>,</span>
<span class="line" id="L162">) BitReader(endian, <span class="tok-builtin">@TypeOf</span>(underlying_stream)) {</span>
<span class="line" id="L163"> <span class="tok-kw">return</span> BitReader(endian, <span class="tok-builtin">@TypeOf</span>(underlying_stream)).init(underlying_stream);</span>
<span class="line" id="L164">}</span>
<span class="line" id="L165"></span>
<span class="line" id="L166"><span class="tok-kw">test</span> <span class="tok-str">"api coverage"</span> {</span>
<span class="line" id="L167"> <span class="tok-kw">const</span> mem_be = [_]<span class="tok-type">u8</span>{ <span class="tok-number">0b11001101</span>, <span class="tok-number">0b00001011</span> };</span>
<span class="line" id="L168"> <span class="tok-kw">const</span> mem_le = [_]<span class="tok-type">u8</span>{ <span class="tok-number">0b00011101</span>, <span class="tok-number">0b10010101</span> };</span>
<span class="line" id="L169"></span>
<span class="line" id="L170"> <span class="tok-kw">var</span> mem_in_be = io.fixedBufferStream(&mem_be);</span>
<span class="line" id="L171"> <span class="tok-kw">var</span> bit_stream_be = bitReader(.Big, mem_in_be.reader());</span>
<span class="line" id="L172"></span>
<span class="line" id="L173"> <span class="tok-kw">var</span> out_bits: <span class="tok-type">usize</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L174"></span>
<span class="line" id="L175"> <span class="tok-kw">const</span> expect = testing.expect;</span>
<span class="line" id="L176"> <span class="tok-kw">const</span> expectError = testing.expectError;</span>
<span class="line" id="L177"></span>
<span class="line" id="L178"> <span class="tok-kw">try</span> expect(<span class="tok-number">1</span> == <span class="tok-kw">try</span> bit_stream_be.readBits(<span class="tok-type">u2</span>, <span class="tok-number">1</span>, &out_bits));</span>
<span class="line" id="L179"> <span class="tok-kw">try</span> expect(out_bits == <span class="tok-number">1</span>);</span>
<span class="line" id="L180"> <span class="tok-kw">try</span> expect(<span class="tok-number">2</span> == <span class="tok-kw">try</span> bit_stream_be.readBits(<span class="tok-type">u5</span>, <span class="tok-number">2</span>, &out_bits));</span>
<span class="line" id="L181"> <span class="tok-kw">try</span> expect(out_bits == <span class="tok-number">2</span>);</span>
<span class="line" id="L182"> <span class="tok-kw">try</span> expect(<span class="tok-number">3</span> == <span class="tok-kw">try</span> bit_stream_be.readBits(<span class="tok-type">u128</span>, <span class="tok-number">3</span>, &out_bits));</span>
<span class="line" id="L183"> <span class="tok-kw">try</span> expect(out_bits == <span class="tok-number">3</span>);</span>
<span class="line" id="L184"> <span class="tok-kw">try</span> expect(<span class="tok-number">4</span> == <span class="tok-kw">try</span> bit_stream_be.readBits(<span class="tok-type">u8</span>, <span class="tok-number">4</span>, &out_bits));</span>
<span class="line" id="L185"> <span class="tok-kw">try</span> expect(out_bits == <span class="tok-number">4</span>);</span>
<span class="line" id="L186"> <span class="tok-kw">try</span> expect(<span class="tok-number">5</span> == <span class="tok-kw">try</span> bit_stream_be.readBits(<span class="tok-type">u9</span>, <span class="tok-number">5</span>, &out_bits));</span>
<span class="line" id="L187"> <span class="tok-kw">try</span> expect(out_bits == <span class="tok-number">5</span>);</span>
<span class="line" id="L188"> <span class="tok-kw">try</span> expect(<span class="tok-number">1</span> == <span class="tok-kw">try</span> bit_stream_be.readBits(<span class="tok-type">u1</span>, <span class="tok-number">1</span>, &out_bits));</span>
<span class="line" id="L189"> <span class="tok-kw">try</span> expect(out_bits == <span class="tok-number">1</span>);</span>
<span class="line" id="L190"></span>
<span class="line" id="L191"> mem_in_be.pos = <span class="tok-number">0</span>;</span>
<span class="line" id="L192"> bit_stream_be.bit_count = <span class="tok-number">0</span>;</span>
<span class="line" id="L193"> <span class="tok-kw">try</span> expect(<span class="tok-number">0b110011010000101</span> == <span class="tok-kw">try</span> bit_stream_be.readBits(<span class="tok-type">u15</span>, <span class="tok-number">15</span>, &out_bits));</span>
<span class="line" id="L194"> <span class="tok-kw">try</span> expect(out_bits == <span class="tok-number">15</span>);</span>
<span class="line" id="L195"></span>
<span class="line" id="L196"> mem_in_be.pos = <span class="tok-number">0</span>;</span>
<span class="line" id="L197"> bit_stream_be.bit_count = <span class="tok-number">0</span>;</span>
<span class="line" id="L198"> <span class="tok-kw">try</span> expect(<span class="tok-number">0b1100110100001011</span> == <span class="tok-kw">try</span> bit_stream_be.readBits(<span class="tok-type">u16</span>, <span class="tok-number">16</span>, &out_bits));</span>
<span class="line" id="L199"> <span class="tok-kw">try</span> expect(out_bits == <span class="tok-number">16</span>);</span>
<span class="line" id="L200"></span>
<span class="line" id="L201"> _ = <span class="tok-kw">try</span> bit_stream_be.readBits(<span class="tok-type">u0</span>, <span class="tok-number">0</span>, &out_bits);</span>
<span class="line" id="L202"></span>
<span class="line" id="L203"> <span class="tok-kw">try</span> expect(<span class="tok-number">0</span> == <span class="tok-kw">try</span> bit_stream_be.readBits(<span class="tok-type">u1</span>, <span class="tok-number">1</span>, &out_bits));</span>
<span class="line" id="L204"> <span class="tok-kw">try</span> expect(out_bits == <span class="tok-number">0</span>);</span>
<span class="line" id="L205"> <span class="tok-kw">try</span> expectError(<span class="tok-kw">error</span>.EndOfStream, bit_stream_be.readBitsNoEof(<span class="tok-type">u1</span>, <span class="tok-number">1</span>));</span>
<span class="line" id="L206"></span>
<span class="line" id="L207"> <span class="tok-kw">var</span> mem_in_le = io.fixedBufferStream(&mem_le);</span>
<span class="line" id="L208"> <span class="tok-kw">var</span> bit_stream_le = bitReader(.Little, mem_in_le.reader());</span>
<span class="line" id="L209"></span>
<span class="line" id="L210"> <span class="tok-kw">try</span> expect(<span class="tok-number">1</span> == <span class="tok-kw">try</span> bit_stream_le.readBits(<span class="tok-type">u2</span>, <span class="tok-number">1</span>, &out_bits));</span>
<span class="line" id="L211"> <span class="tok-kw">try</span> expect(out_bits == <span class="tok-number">1</span>);</span>
<span class="line" id="L212"> <span class="tok-kw">try</span> expect(<span class="tok-number">2</span> == <span class="tok-kw">try</span> bit_stream_le.readBits(<span class="tok-type">u5</span>, <span class="tok-number">2</span>, &out_bits));</span>
<span class="line" id="L213"> <span class="tok-kw">try</span> expect(out_bits == <span class="tok-number">2</span>);</span>
<span class="line" id="L214"> <span class="tok-kw">try</span> expect(<span class="tok-number">3</span> == <span class="tok-kw">try</span> bit_stream_le.readBits(<span class="tok-type">u128</span>, <span class="tok-number">3</span>, &out_bits));</span>
<span class="line" id="L215"> <span class="tok-kw">try</span> expect(out_bits == <span class="tok-number">3</span>);</span>
<span class="line" id="L216"> <span class="tok-kw">try</span> expect(<span class="tok-number">4</span> == <span class="tok-kw">try</span> bit_stream_le.readBits(<span class="tok-type">u8</span>, <span class="tok-number">4</span>, &out_bits));</span>
<span class="line" id="L217"> <span class="tok-kw">try</span> expect(out_bits == <span class="tok-number">4</span>);</span>
<span class="line" id="L218"> <span class="tok-kw">try</span> expect(<span class="tok-number">5</span> == <span class="tok-kw">try</span> bit_stream_le.readBits(<span class="tok-type">u9</span>, <span class="tok-number">5</span>, &out_bits));</span>
<span class="line" id="L219"> <span class="tok-kw">try</span> expect(out_bits == <span class="tok-number">5</span>);</span>
<span class="line" id="L220"> <span class="tok-kw">try</span> expect(<span class="tok-number">1</span> == <span class="tok-kw">try</span> bit_stream_le.readBits(<span class="tok-type">u1</span>, <span class="tok-number">1</span>, &out_bits));</span>
<span class="line" id="L221"> <span class="tok-kw">try</span> expect(out_bits == <span class="tok-number">1</span>);</span>
<span class="line" id="L222"></span>
<span class="line" id="L223"> mem_in_le.pos = <span class="tok-number">0</span>;</span>
<span class="line" id="L224"> bit_stream_le.bit_count = <span class="tok-number">0</span>;</span>
<span class="line" id="L225"> <span class="tok-kw">try</span> expect(<span class="tok-number">0b001010100011101</span> == <span class="tok-kw">try</span> bit_stream_le.readBits(<span class="tok-type">u15</span>, <span class="tok-number">15</span>, &out_bits));</span>
<span class="line" id="L226"> <span class="tok-kw">try</span> expect(out_bits == <span class="tok-number">15</span>);</span>
<span class="line" id="L227"></span>
<span class="line" id="L228"> mem_in_le.pos = <span class="tok-number">0</span>;</span>
<span class="line" id="L229"> bit_stream_le.bit_count = <span class="tok-number">0</span>;</span>
<span class="line" id="L230"> <span class="tok-kw">try</span> expect(<span class="tok-number">0b1001010100011101</span> == <span class="tok-kw">try</span> bit_stream_le.readBits(<span class="tok-type">u16</span>, <span class="tok-number">16</span>, &out_bits));</span>
<span class="line" id="L231"> <span class="tok-kw">try</span> expect(out_bits == <span class="tok-number">16</span>);</span>
<span class="line" id="L232"></span>
<span class="line" id="L233"> _ = <span class="tok-kw">try</span> bit_stream_le.readBits(<span class="tok-type">u0</span>, <span class="tok-number">0</span>, &out_bits);</span>
<span class="line" id="L234"></span>
<span class="line" id="L235"> <span class="tok-kw">try</span> expect(<span class="tok-number">0</span> == <span class="tok-kw">try</span> bit_stream_le.readBits(<span class="tok-type">u1</span>, <span class="tok-number">1</span>, &out_bits));</span>
<span class="line" id="L236"> <span class="tok-kw">try</span> expect(out_bits == <span class="tok-number">0</span>);</span>
<span class="line" id="L237"> <span class="tok-kw">try</span> expectError(<span class="tok-kw">error</span>.EndOfStream, bit_stream_le.readBitsNoEof(<span class="tok-type">u1</span>, <span class="tok-number">1</span>));</span>
<span class="line" id="L238">}</span>
<span class="line" id="L239"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/sort/pdq.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>sort/pdq.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../std.zig"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> sort = std.sort;</span>
<span class="line" id="L3"><span class="tok-kw">const</span> mem = std.mem;</span>
<span class="line" id="L4"><span class="tok-kw">const</span> math = std.math;</span>
<span class="line" id="L5"><span class="tok-kw">const</span> testing = std.testing;</span>
<span class="line" id="L6"></span>
<span class="line" id="L7"><span class="tok-comment">/// Unstable in-place sort. n best case, n*log(n) worst case and average case.</span></span>
<span class="line" id="L8"><span class="tok-comment">/// log(n) memory (no allocator required).</span></span>
<span class="line" id="L9"><span class="tok-comment">///</span></span>
<span class="line" id="L10"><span class="tok-comment">/// Sorts in ascending order with respect to the given `lessThan` function.</span></span>
<span class="line" id="L11"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">pdq</span>(</span>
<span class="line" id="L12"> <span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>,</span>
<span class="line" id="L13"> items: []T,</span>
<span class="line" id="L14"> context: <span class="tok-kw">anytype</span>,</span>
<span class="line" id="L15"> <span class="tok-kw">comptime</span> lessThanFn: <span class="tok-kw">fn</span> (context: <span class="tok-builtin">@TypeOf</span>(context), lhs: T, rhs: T) <span class="tok-type">bool</span>,</span>
<span class="line" id="L16">) <span class="tok-type">void</span> {</span>
<span class="line" id="L17"> <span class="tok-kw">const</span> Context = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L18"> items: []T,</span>
<span class="line" id="L19"> sub_ctx: <span class="tok-builtin">@TypeOf</span>(context),</span>
<span class="line" id="L20"></span>
<span class="line" id="L21"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">lessThan</span>(ctx: <span class="tok-builtin">@This</span>(), a: <span class="tok-type">usize</span>, b: <span class="tok-type">usize</span>) <span class="tok-type">bool</span> {</span>
<span class="line" id="L22"> <span class="tok-kw">return</span> lessThanFn(ctx.sub_ctx, ctx.items[a], ctx.items[b]);</span>
<span class="line" id="L23"> }</span>
<span class="line" id="L24"></span>
<span class="line" id="L25"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">swap</span>(ctx: <span class="tok-builtin">@This</span>(), a: <span class="tok-type">usize</span>, b: <span class="tok-type">usize</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L26"> <span class="tok-kw">return</span> mem.swap(T, &ctx.items[a], &ctx.items[b]);</span>
<span class="line" id="L27"> }</span>
<span class="line" id="L28"> };</span>
<span class="line" id="L29"> pdqContext(<span class="tok-number">0</span>, items.len, Context{ .items = items, .sub_ctx = context });</span>
<span class="line" id="L30">}</span>
<span class="line" id="L31"></span>
<span class="line" id="L32"><span class="tok-kw">const</span> Hint = <span class="tok-kw">enum</span> {</span>
<span class="line" id="L33"> increasing,</span>
<span class="line" id="L34"> decreasing,</span>
<span class="line" id="L35"> unknown,</span>
<span class="line" id="L36">};</span>
<span class="line" id="L37"></span>
<span class="line" id="L38"><span class="tok-comment">/// Unstable in-place sort. O(n) best case, O(n*log(n)) worst case and average case.</span></span>
<span class="line" id="L39"><span class="tok-comment">/// O(log(n)) memory (no allocator required).</span></span>
<span class="line" id="L40"><span class="tok-comment">/// `context` must have methods `swap` and `lessThan`,</span></span>
<span class="line" id="L41"><span class="tok-comment">/// which each take 2 `usize` parameters indicating the index of an item.</span></span>
<span class="line" id="L42"><span class="tok-comment">/// Sorts in ascending order with respect to `lessThan`.</span></span>
<span class="line" id="L43"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">pdqContext</span>(a: <span class="tok-type">usize</span>, b: <span class="tok-type">usize</span>, context: <span class="tok-kw">anytype</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L44"> <span class="tok-comment">// slices of up to this length get sorted using insertion sort.</span>
</span>
<span class="line" id="L45"> <span class="tok-kw">const</span> max_insertion = <span class="tok-number">24</span>;</span>
<span class="line" id="L46"> <span class="tok-comment">// number of allowed imbalanced partitions before switching to heap sort.</span>
</span>
<span class="line" id="L47"> <span class="tok-kw">const</span> max_limit = std.math.floorPowerOfTwo(<span class="tok-type">usize</span>, b - a) + <span class="tok-number">1</span>;</span>
<span class="line" id="L48"></span>
<span class="line" id="L49"> <span class="tok-comment">// set upper bound on stack memory usage.</span>
</span>
<span class="line" id="L50"> <span class="tok-kw">const</span> Range = <span class="tok-kw">struct</span> { a: <span class="tok-type">usize</span>, b: <span class="tok-type">usize</span>, limit: <span class="tok-type">usize</span> };</span>
<span class="line" id="L51"> <span class="tok-kw">const</span> stack_size = math.log2(math.maxInt(<span class="tok-type">usize</span>) + <span class="tok-number">1</span>);</span>
<span class="line" id="L52"> <span class="tok-kw">var</span> stack: [stack_size]Range = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L53"> <span class="tok-kw">var</span> range = Range{ .a = a, .b = b, .limit = max_limit };</span>
<span class="line" id="L54"> <span class="tok-kw">var</span> top: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L55"></span>
<span class="line" id="L56"> <span class="tok-kw">while</span> (<span class="tok-null">true</span>) {</span>
<span class="line" id="L57"> <span class="tok-kw">var</span> was_balanced = <span class="tok-null">true</span>;</span>
<span class="line" id="L58"> <span class="tok-kw">var</span> was_partitioned = <span class="tok-null">true</span>;</span>
<span class="line" id="L59"></span>
<span class="line" id="L60"> <span class="tok-kw">while</span> (<span class="tok-null">true</span>) {</span>
<span class="line" id="L61"> <span class="tok-kw">const</span> len = range.b - range.a;</span>
<span class="line" id="L62"></span>
<span class="line" id="L63"> <span class="tok-comment">// very short slices get sorted using insertion sort.</span>
</span>
<span class="line" id="L64"> <span class="tok-kw">if</span> (len <= max_insertion) {</span>
<span class="line" id="L65"> <span class="tok-kw">break</span> sort.insertionContext(range.a, range.b, context);</span>
<span class="line" id="L66"> }</span>
<span class="line" id="L67"></span>
<span class="line" id="L68"> <span class="tok-comment">// if too many bad pivot choices were made, simply fall back to heapsort in order to</span>
</span>
<span class="line" id="L69"> <span class="tok-comment">// guarantee O(n*log(n)) worst-case.</span>
</span>
<span class="line" id="L70"> <span class="tok-kw">if</span> (range.limit == <span class="tok-number">0</span>) {</span>
<span class="line" id="L71"> <span class="tok-kw">break</span> sort.heapContext(range.a, range.b, context);</span>
<span class="line" id="L72"> }</span>
<span class="line" id="L73"></span>
<span class="line" id="L74"> <span class="tok-comment">// if the last partitioning was imbalanced, try breaking patterns in the slice by shuffling</span>
</span>
<span class="line" id="L75"> <span class="tok-comment">// some elements around. Hopefully we'll choose a better pivot this time.</span>
</span>
<span class="line" id="L76"> <span class="tok-kw">if</span> (!was_balanced) {</span>
<span class="line" id="L77"> breakPatterns(range.a, range.b, context);</span>
<span class="line" id="L78"> range.limit -= <span class="tok-number">1</span>;</span>
<span class="line" id="L79"> }</span>
<span class="line" id="L80"></span>
<span class="line" id="L81"> <span class="tok-comment">// choose a pivot and try guessing whether the slice is already sorted.</span>
</span>
<span class="line" id="L82"> <span class="tok-kw">var</span> pivot: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L83"> <span class="tok-kw">var</span> hint = chosePivot(range.a, range.b, &pivot, context);</span>
<span class="line" id="L84"></span>
<span class="line" id="L85"> <span class="tok-kw">if</span> (hint == .decreasing) {</span>
<span class="line" id="L86"> <span class="tok-comment">// The maximum number of swaps was performed, so items are likely</span>
</span>
<span class="line" id="L87"> <span class="tok-comment">// in reverse order. Reverse it to make sorting faster.</span>
</span>
<span class="line" id="L88"> reverseRange(range.a, range.b, context);</span>
<span class="line" id="L89"> pivot = (range.b - <span class="tok-number">1</span>) - (pivot - range.a);</span>
<span class="line" id="L90"> hint = .increasing;</span>
<span class="line" id="L91"> }</span>
<span class="line" id="L92"></span>
<span class="line" id="L93"> <span class="tok-comment">// if the last partitioning was decently balanced and didn't shuffle elements, and if pivot</span>
</span>
<span class="line" id="L94"> <span class="tok-comment">// selection predicts the slice is likely already sorted...</span>
</span>
<span class="line" id="L95"> <span class="tok-kw">if</span> (was_balanced <span class="tok-kw">and</span> was_partitioned <span class="tok-kw">and</span> hint == .increasing) {</span>
<span class="line" id="L96"> <span class="tok-comment">// try identifying several out-of-order elements and shifting them to correct</span>
</span>
<span class="line" id="L97"> <span class="tok-comment">// positions. If the slice ends up being completely sorted, we're done.</span>
</span>
<span class="line" id="L98"> <span class="tok-kw">if</span> (partialInsertionSort(range.a, range.b, context)) <span class="tok-kw">break</span>;</span>
<span class="line" id="L99"> }</span>
<span class="line" id="L100"></span>
<span class="line" id="L101"> <span class="tok-comment">// if the chosen pivot is equal to the predecessor, then it's the smallest element in the</span>
</span>
<span class="line" id="L102"> <span class="tok-comment">// slice. Partition the slice into elements equal to and elements greater than the pivot.</span>
</span>
<span class="line" id="L103"> <span class="tok-comment">// This case is usually hit when the slice contains many duplicate elements.</span>
</span>
<span class="line" id="L104"> <span class="tok-kw">if</span> (range.a > a <span class="tok-kw">and</span> !context.lessThan(range.a - <span class="tok-number">1</span>, pivot)) {</span>
<span class="line" id="L105"> range.a = partitionEqual(range.a, range.b, pivot, context);</span>
<span class="line" id="L106"> <span class="tok-kw">continue</span>;</span>
<span class="line" id="L107"> }</span>
<span class="line" id="L108"></span>
<span class="line" id="L109"> <span class="tok-comment">// partition the slice.</span>
</span>
<span class="line" id="L110"> <span class="tok-kw">var</span> mid = pivot;</span>
<span class="line" id="L111"> was_partitioned = partition(range.a, range.b, &mid, context);</span>
<span class="line" id="L112"></span>
<span class="line" id="L113"> <span class="tok-kw">const</span> left_len = mid - range.a;</span>
<span class="line" id="L114"> <span class="tok-kw">const</span> right_len = range.b - mid;</span>
<span class="line" id="L115"> <span class="tok-kw">const</span> balanced_threshold = len / <span class="tok-number">8</span>;</span>
<span class="line" id="L116"> <span class="tok-kw">if</span> (left_len < right_len) {</span>
<span class="line" id="L117"> was_balanced = left_len >= balanced_threshold;</span>
<span class="line" id="L118"> stack[top] = .{ .a = range.a, .b = mid, .limit = range.limit };</span>
<span class="line" id="L119"> top += <span class="tok-number">1</span>;</span>
<span class="line" id="L120"> range.a = mid + <span class="tok-number">1</span>;</span>
<span class="line" id="L121"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L122"> was_balanced = right_len >= balanced_threshold;</span>
<span class="line" id="L123"> stack[top] = .{ .a = mid + <span class="tok-number">1</span>, .b = range.b, .limit = range.limit };</span>
<span class="line" id="L124"> top += <span class="tok-number">1</span>;</span>
<span class="line" id="L125"> range.b = mid;</span>
<span class="line" id="L126"> }</span>
<span class="line" id="L127"> }</span>
<span class="line" id="L128"></span>
<span class="line" id="L129"> top = math.sub(<span class="tok-type">usize</span>, top, <span class="tok-number">1</span>) <span class="tok-kw">catch</span> <span class="tok-kw">break</span>;</span>
<span class="line" id="L130"> range = stack[top];</span>
<span class="line" id="L131"> }</span>
<span class="line" id="L132">}</span>
<span class="line" id="L133"></span>
<span class="line" id="L134"><span class="tok-comment">/// partitions `items[a..b]` into elements smaller than `items[pivot]`,</span></span>
<span class="line" id="L135"><span class="tok-comment">/// followed by elements greater than or equal to `items[pivot]`.</span></span>
<span class="line" id="L136"><span class="tok-comment">///</span></span>
<span class="line" id="L137"><span class="tok-comment">/// sets the new pivot.</span></span>
<span class="line" id="L138"><span class="tok-comment">/// returns `true` if already partitioned.</span></span>
<span class="line" id="L139"><span class="tok-kw">fn</span> <span class="tok-fn">partition</span>(a: <span class="tok-type">usize</span>, b: <span class="tok-type">usize</span>, pivot: *<span class="tok-type">usize</span>, context: <span class="tok-kw">anytype</span>) <span class="tok-type">bool</span> {</span>
<span class="line" id="L140"> <span class="tok-comment">// move pivot to the first place</span>
</span>
<span class="line" id="L141"> context.swap(a, pivot.*);</span>
<span class="line" id="L142"></span>
<span class="line" id="L143"> <span class="tok-kw">var</span> i = a + <span class="tok-number">1</span>;</span>
<span class="line" id="L144"> <span class="tok-kw">var</span> j = b - <span class="tok-number">1</span>;</span>
<span class="line" id="L145"></span>
<span class="line" id="L146"> <span class="tok-kw">while</span> (i <= j <span class="tok-kw">and</span> context.lessThan(i, a)) i += <span class="tok-number">1</span>;</span>
<span class="line" id="L147"> <span class="tok-kw">while</span> (i <= j <span class="tok-kw">and</span> !context.lessThan(j, a)) j -= <span class="tok-number">1</span>;</span>
<span class="line" id="L148"></span>
<span class="line" id="L149"> <span class="tok-comment">// check if items are already partitioned (no item to swap)</span>
</span>
<span class="line" id="L150"> <span class="tok-kw">if</span> (i > j) {</span>
<span class="line" id="L151"> <span class="tok-comment">// put pivot back to the middle</span>
</span>
<span class="line" id="L152"> context.swap(j, a);</span>
<span class="line" id="L153"> pivot.* = j;</span>
<span class="line" id="L154"> <span class="tok-kw">return</span> <span class="tok-null">true</span>;</span>
<span class="line" id="L155"> }</span>
<span class="line" id="L156"></span>
<span class="line" id="L157"> context.swap(i, j);</span>
<span class="line" id="L158"> i += <span class="tok-number">1</span>;</span>
<span class="line" id="L159"> j -= <span class="tok-number">1</span>;</span>
<span class="line" id="L160"></span>
<span class="line" id="L161"> <span class="tok-kw">while</span> (<span class="tok-null">true</span>) {</span>
<span class="line" id="L162"> <span class="tok-kw">while</span> (i <= j <span class="tok-kw">and</span> context.lessThan(i, a)) i += <span class="tok-number">1</span>;</span>
<span class="line" id="L163"> <span class="tok-kw">while</span> (i <= j <span class="tok-kw">and</span> !context.lessThan(j, a)) j -= <span class="tok-number">1</span>;</span>
<span class="line" id="L164"> <span class="tok-kw">if</span> (i > j) <span class="tok-kw">break</span>;</span>
<span class="line" id="L165"></span>
<span class="line" id="L166"> context.swap(i, j);</span>
<span class="line" id="L167"> i += <span class="tok-number">1</span>;</span>
<span class="line" id="L168"> j -= <span class="tok-number">1</span>;</span>
<span class="line" id="L169"> }</span>
<span class="line" id="L170"></span>
<span class="line" id="L171"> <span class="tok-comment">// TODO: Enable the BlockQuicksort optimization</span>
</span>
<span class="line" id="L172"></span>
<span class="line" id="L173"> context.swap(j, a);</span>
<span class="line" id="L174"> pivot.* = j;</span>
<span class="line" id="L175"> <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L176">}</span>
<span class="line" id="L177"></span>
<span class="line" id="L178"><span class="tok-comment">/// partitions items into elements equal to `items[pivot]`</span></span>
<span class="line" id="L179"><span class="tok-comment">/// followed by elements greater than `items[pivot]`.</span></span>
<span class="line" id="L180"><span class="tok-comment">///</span></span>
<span class="line" id="L181"><span class="tok-comment">/// it assumed that `items[a..b]` does not contain elements smaller than the `items[pivot]`.</span></span>
<span class="line" id="L182"><span class="tok-kw">fn</span> <span class="tok-fn">partitionEqual</span>(a: <span class="tok-type">usize</span>, b: <span class="tok-type">usize</span>, pivot: <span class="tok-type">usize</span>, context: <span class="tok-kw">anytype</span>) <span class="tok-type">usize</span> {</span>
<span class="line" id="L183"> <span class="tok-comment">// move pivot to the first place</span>
</span>
<span class="line" id="L184"> context.swap(a, pivot);</span>
<span class="line" id="L185"></span>
<span class="line" id="L186"> <span class="tok-kw">var</span> i = a + <span class="tok-number">1</span>;</span>
<span class="line" id="L187"> <span class="tok-kw">var</span> j = b - <span class="tok-number">1</span>;</span>
<span class="line" id="L188"></span>
<span class="line" id="L189"> <span class="tok-kw">while</span> (<span class="tok-null">true</span>) {</span>
<span class="line" id="L190"> <span class="tok-kw">while</span> (i <= j <span class="tok-kw">and</span> !context.lessThan(a, i)) i += <span class="tok-number">1</span>;</span>
<span class="line" id="L191"> <span class="tok-kw">while</span> (i <= j <span class="tok-kw">and</span> context.lessThan(a, j)) j -= <span class="tok-number">1</span>;</span>
<span class="line" id="L192"> <span class="tok-kw">if</span> (i > j) <span class="tok-kw">break</span>;</span>
<span class="line" id="L193"></span>
<span class="line" id="L194"> context.swap(i, j);</span>
<span class="line" id="L195"> i += <span class="tok-number">1</span>;</span>
<span class="line" id="L196"> j -= <span class="tok-number">1</span>;</span>
<span class="line" id="L197"> }</span>
<span class="line" id="L198"></span>
<span class="line" id="L199"> <span class="tok-kw">return</span> i;</span>
<span class="line" id="L200">}</span>
<span class="line" id="L201"></span>
<span class="line" id="L202"><span class="tok-comment">/// partially sorts a slice by shifting several out-of-order elements around.</span></span>
<span class="line" id="L203"><span class="tok-comment">///</span></span>
<span class="line" id="L204"><span class="tok-comment">/// returns `true` if the slice is sorted at the end. This function is `O(n)` worst-case.</span></span>
<span class="line" id="L205"><span class="tok-kw">fn</span> <span class="tok-fn">partialInsertionSort</span>(a: <span class="tok-type">usize</span>, b: <span class="tok-type">usize</span>, context: <span class="tok-kw">anytype</span>) <span class="tok-type">bool</span> {</span>
<span class="line" id="L206"> <span class="tok-builtin">@setCold</span>(<span class="tok-null">true</span>);</span>
<span class="line" id="L207"></span>
<span class="line" id="L208"> <span class="tok-comment">// maximum number of adjacent out-of-order pairs that will get shifted</span>
</span>
<span class="line" id="L209"> <span class="tok-kw">const</span> max_steps = <span class="tok-number">5</span>;</span>
<span class="line" id="L210"> <span class="tok-comment">// if the slice is shorter than this, don't shift any elements</span>
</span>
<span class="line" id="L211"> <span class="tok-kw">const</span> shortest_shifting = <span class="tok-number">50</span>;</span>
<span class="line" id="L212"></span>
<span class="line" id="L213"> <span class="tok-kw">var</span> i = a + <span class="tok-number">1</span>;</span>
<span class="line" id="L214"> <span class="tok-kw">for</span> (<span class="tok-number">0</span>..max_steps) |_| {</span>
<span class="line" id="L215"> <span class="tok-comment">// find the next pair of adjacent out-of-order elements.</span>
</span>
<span class="line" id="L216"> <span class="tok-kw">while</span> (i < b <span class="tok-kw">and</span> !context.lessThan(i, i - <span class="tok-number">1</span>)) i += <span class="tok-number">1</span>;</span>
<span class="line" id="L217"></span>
<span class="line" id="L218"> <span class="tok-comment">// are we done?</span>
</span>
<span class="line" id="L219"> <span class="tok-kw">if</span> (i == b) <span class="tok-kw">return</span> <span class="tok-null">true</span>;</span>
<span class="line" id="L220"></span>
<span class="line" id="L221"> <span class="tok-comment">// don't shift elements on short arrays, that has a performance cost.</span>
</span>
<span class="line" id="L222"> <span class="tok-kw">if</span> (b - a < shortest_shifting) <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L223"></span>
<span class="line" id="L224"> <span class="tok-comment">// swap the found pair of elements. This puts them in correct order.</span>
</span>
<span class="line" id="L225"> context.swap(i, i - <span class="tok-number">1</span>);</span>
<span class="line" id="L226"></span>
<span class="line" id="L227"> <span class="tok-comment">// shift the smaller element to the left.</span>
</span>
<span class="line" id="L228"> <span class="tok-kw">if</span> (i - a >= <span class="tok-number">2</span>) {</span>
<span class="line" id="L229"> <span class="tok-kw">var</span> j = i - <span class="tok-number">1</span>;</span>
<span class="line" id="L230"> <span class="tok-kw">while</span> (j >= <span class="tok-number">1</span>) : (j -= <span class="tok-number">1</span>) {</span>
<span class="line" id="L231"> <span class="tok-kw">if</span> (!context.lessThan(j, j - <span class="tok-number">1</span>)) <span class="tok-kw">break</span>;</span>
<span class="line" id="L232"> context.swap(j, j - <span class="tok-number">1</span>);</span>
<span class="line" id="L233"> }</span>
<span class="line" id="L234"> }</span>
<span class="line" id="L235"></span>
<span class="line" id="L236"> <span class="tok-comment">// shift the greater element to the right.</span>
</span>
<span class="line" id="L237"> <span class="tok-kw">if</span> (b - i >= <span class="tok-number">2</span>) {</span>
<span class="line" id="L238"> <span class="tok-kw">var</span> j = i + <span class="tok-number">1</span>;</span>
<span class="line" id="L239"> <span class="tok-kw">while</span> (j < b) : (j += <span class="tok-number">1</span>) {</span>
<span class="line" id="L240"> <span class="tok-kw">if</span> (!context.lessThan(j, j - <span class="tok-number">1</span>)) <span class="tok-kw">break</span>;</span>
<span class="line" id="L241"> context.swap(j, j - <span class="tok-number">1</span>);</span>
<span class="line" id="L242"> }</span>
<span class="line" id="L243"> }</span>
<span class="line" id="L244"> }</span>
<span class="line" id="L245"></span>
<span class="line" id="L246"> <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L247">}</span>
<span class="line" id="L248"></span>
<span class="line" id="L249"><span class="tok-kw">fn</span> <span class="tok-fn">breakPatterns</span>(a: <span class="tok-type">usize</span>, b: <span class="tok-type">usize</span>, context: <span class="tok-kw">anytype</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L250"> <span class="tok-builtin">@setCold</span>(<span class="tok-null">true</span>);</span>
<span class="line" id="L251"></span>
<span class="line" id="L252"> <span class="tok-kw">const</span> len = b - a;</span>
<span class="line" id="L253"> <span class="tok-kw">if</span> (len < <span class="tok-number">8</span>) <span class="tok-kw">return</span>;</span>
<span class="line" id="L254"></span>
<span class="line" id="L255"> <span class="tok-kw">var</span> rand = <span class="tok-builtin">@as</span>(<span class="tok-type">u64</span>, <span class="tok-builtin">@intCast</span>(len));</span>
<span class="line" id="L256"> <span class="tok-kw">const</span> modulus = math.ceilPowerOfTwoAssert(<span class="tok-type">u64</span>, len);</span>
<span class="line" id="L257"></span>
<span class="line" id="L258"> <span class="tok-kw">var</span> i = a + (len / <span class="tok-number">4</span>) * <span class="tok-number">2</span> - <span class="tok-number">1</span>;</span>
<span class="line" id="L259"> <span class="tok-kw">while</span> (i <= a + (len / <span class="tok-number">4</span>) * <span class="tok-number">2</span> + <span class="tok-number">1</span>) : (i += <span class="tok-number">1</span>) {</span>
<span class="line" id="L260"> <span class="tok-comment">// xorshift64</span>
</span>
<span class="line" id="L261"> rand ^= rand << <span class="tok-number">13</span>;</span>
<span class="line" id="L262"> rand ^= rand >> <span class="tok-number">7</span>;</span>
<span class="line" id="L263"> rand ^= rand << <span class="tok-number">17</span>;</span>
<span class="line" id="L264"></span>
<span class="line" id="L265"> <span class="tok-kw">var</span> other = <span class="tok-builtin">@as</span>(<span class="tok-type">usize</span>, <span class="tok-builtin">@intCast</span>(rand & (modulus - <span class="tok-number">1</span>)));</span>
<span class="line" id="L266"> <span class="tok-kw">if</span> (other >= len) other -= len;</span>
<span class="line" id="L267"> context.swap(i, a + other);</span>
<span class="line" id="L268"> }</span>
<span class="line" id="L269">}</span>
<span class="line" id="L270"></span>
<span class="line" id="L271"><span class="tok-comment">/// choses a pivot in `items[a..b]`.</span></span>
<span class="line" id="L272"><span class="tok-comment">/// swaps likely_sorted when `items[a..b]` seems to be already sorted.</span></span>
<span class="line" id="L273"><span class="tok-kw">fn</span> <span class="tok-fn">chosePivot</span>(a: <span class="tok-type">usize</span>, b: <span class="tok-type">usize</span>, pivot: *<span class="tok-type">usize</span>, context: <span class="tok-kw">anytype</span>) Hint {</span>
<span class="line" id="L274"> <span class="tok-comment">// minimum length for using the Tukey's ninther method</span>
</span>
<span class="line" id="L275"> <span class="tok-kw">const</span> shortest_ninther = <span class="tok-number">50</span>;</span>
<span class="line" id="L276"> <span class="tok-comment">// max_swaps is the maximum number of swaps allowed in this function</span>
</span>
<span class="line" id="L277"> <span class="tok-kw">const</span> max_swaps = <span class="tok-number">4</span> * <span class="tok-number">3</span>;</span>
<span class="line" id="L278"></span>
<span class="line" id="L279"> <span class="tok-kw">var</span> len = b - a;</span>
<span class="line" id="L280"> <span class="tok-kw">var</span> i = a + len / <span class="tok-number">4</span> * <span class="tok-number">1</span>;</span>
<span class="line" id="L281"> <span class="tok-kw">var</span> j = a + len / <span class="tok-number">4</span> * <span class="tok-number">2</span>;</span>
<span class="line" id="L282"> <span class="tok-kw">var</span> k = a + len / <span class="tok-number">4</span> * <span class="tok-number">3</span>;</span>
<span class="line" id="L283"> <span class="tok-kw">var</span> swaps: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L284"></span>
<span class="line" id="L285"> <span class="tok-kw">if</span> (len >= <span class="tok-number">8</span>) {</span>
<span class="line" id="L286"> <span class="tok-kw">if</span> (len >= shortest_ninther) {</span>
<span class="line" id="L287"> <span class="tok-comment">// find medians in the neighborhoods of `i`, `j` and `k`</span>
</span>
<span class="line" id="L288"> sort3(i - <span class="tok-number">1</span>, i, i + <span class="tok-number">1</span>, &swaps, context);</span>
<span class="line" id="L289"> sort3(j - <span class="tok-number">1</span>, j, j + <span class="tok-number">1</span>, &swaps, context);</span>
<span class="line" id="L290"> sort3(k - <span class="tok-number">1</span>, k, k + <span class="tok-number">1</span>, &swaps, context);</span>
<span class="line" id="L291"> }</span>
<span class="line" id="L292"></span>
<span class="line" id="L293"> <span class="tok-comment">// find the median among `i`, `j` and `k` and stores it in `j`</span>
</span>
<span class="line" id="L294"> sort3(i, j, k, &swaps, context);</span>
<span class="line" id="L295"> }</span>
<span class="line" id="L296"></span>
<span class="line" id="L297"> pivot.* = j;</span>
<span class="line" id="L298"> <span class="tok-kw">return</span> <span class="tok-kw">switch</span> (swaps) {</span>
<span class="line" id="L299"> <span class="tok-number">0</span> => .increasing,</span>
<span class="line" id="L300"> max_swaps => .decreasing,</span>
<span class="line" id="L301"> <span class="tok-kw">else</span> => .unknown,</span>
<span class="line" id="L302"> };</span>
<span class="line" id="L303">}</span>
<span class="line" id="L304"></span>
<span class="line" id="L305"><span class="tok-kw">fn</span> <span class="tok-fn">sort3</span>(a: <span class="tok-type">usize</span>, b: <span class="tok-type">usize</span>, c: <span class="tok-type">usize</span>, swaps: *<span class="tok-type">usize</span>, context: <span class="tok-kw">anytype</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L306"> <span class="tok-kw">if</span> (context.lessThan(b, a)) {</span>
<span class="line" id="L307"> swaps.* += <span class="tok-number">1</span>;</span>
<span class="line" id="L308"> context.swap(b, a);</span>
<span class="line" id="L309"> }</span>
<span class="line" id="L310"></span>
<span class="line" id="L311"> <span class="tok-kw">if</span> (context.lessThan(c, b)) {</span>
<span class="line" id="L312"> swaps.* += <span class="tok-number">1</span>;</span>
<span class="line" id="L313"> context.swap(c, b);</span>
<span class="line" id="L314"> }</span>
<span class="line" id="L315"></span>
<span class="line" id="L316"> <span class="tok-kw">if</span> (context.lessThan(b, a)) {</span>
<span class="line" id="L317"> swaps.* += <span class="tok-number">1</span>;</span>
<span class="line" id="L318"> context.swap(b, a);</span>
<span class="line" id="L319"> }</span>
<span class="line" id="L320">}</span>
<span class="line" id="L321"></span>
<span class="line" id="L322"><span class="tok-kw">fn</span> <span class="tok-fn">reverseRange</span>(a: <span class="tok-type">usize</span>, b: <span class="tok-type">usize</span>, context: <span class="tok-kw">anytype</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L323"> <span class="tok-kw">var</span> i = a;</span>
<span class="line" id="L324"> <span class="tok-kw">var</span> j = b - <span class="tok-number">1</span>;</span>
<span class="line" id="L325"> <span class="tok-kw">while</span> (i < j) {</span>
<span class="line" id="L326"> context.swap(i, j);</span>
<span class="line" id="L327"> i += <span class="tok-number">1</span>;</span>
<span class="line" id="L328"> j -= <span class="tok-number">1</span>;</span>
<span class="line" id="L329"> }</span>
<span class="line" id="L330">}</span>
<span class="line" id="L331"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/sort/block.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>sort/block.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> builtin = <span class="tok-builtin">@import</span>(<span class="tok-str">"builtin"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../std.zig"</span>);</span>
<span class="line" id="L3"><span class="tok-kw">const</span> sort = std.sort;</span>
<span class="line" id="L4"><span class="tok-kw">const</span> math = std.math;</span>
<span class="line" id="L5"><span class="tok-kw">const</span> mem = std.mem;</span>
<span class="line" id="L6"></span>
<span class="line" id="L7"><span class="tok-kw">const</span> Range = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L8"> start: <span class="tok-type">usize</span>,</span>
<span class="line" id="L9"> end: <span class="tok-type">usize</span>,</span>
<span class="line" id="L10"></span>
<span class="line" id="L11"> <span class="tok-kw">fn</span> <span class="tok-fn">init</span>(start: <span class="tok-type">usize</span>, end: <span class="tok-type">usize</span>) Range {</span>
<span class="line" id="L12"> <span class="tok-kw">return</span> Range{</span>
<span class="line" id="L13"> .start = start,</span>
<span class="line" id="L14"> .end = end,</span>
<span class="line" id="L15"> };</span>
<span class="line" id="L16"> }</span>
<span class="line" id="L17"></span>
<span class="line" id="L18"> <span class="tok-kw">fn</span> <span class="tok-fn">length</span>(self: Range) <span class="tok-type">usize</span> {</span>
<span class="line" id="L19"> <span class="tok-kw">return</span> self.end - self.start;</span>
<span class="line" id="L20"> }</span>
<span class="line" id="L21">};</span>
<span class="line" id="L22"></span>
<span class="line" id="L23"><span class="tok-kw">const</span> Iterator = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L24"> size: <span class="tok-type">usize</span>,</span>
<span class="line" id="L25"> power_of_two: <span class="tok-type">usize</span>,</span>
<span class="line" id="L26"> numerator: <span class="tok-type">usize</span>,</span>
<span class="line" id="L27"> decimal: <span class="tok-type">usize</span>,</span>
<span class="line" id="L28"> denominator: <span class="tok-type">usize</span>,</span>
<span class="line" id="L29"> decimal_step: <span class="tok-type">usize</span>,</span>
<span class="line" id="L30"> numerator_step: <span class="tok-type">usize</span>,</span>
<span class="line" id="L31"></span>
<span class="line" id="L32"> <span class="tok-kw">fn</span> <span class="tok-fn">init</span>(size2: <span class="tok-type">usize</span>, min_level: <span class="tok-type">usize</span>) Iterator {</span>
<span class="line" id="L33"> <span class="tok-kw">const</span> power_of_two = math.floorPowerOfTwo(<span class="tok-type">usize</span>, size2);</span>
<span class="line" id="L34"> <span class="tok-kw">const</span> denominator = power_of_two / min_level;</span>
<span class="line" id="L35"> <span class="tok-kw">return</span> Iterator{</span>
<span class="line" id="L36"> .numerator = <span class="tok-number">0</span>,</span>
<span class="line" id="L37"> .decimal = <span class="tok-number">0</span>,</span>
<span class="line" id="L38"> .size = size2,</span>
<span class="line" id="L39"> .power_of_two = power_of_two,</span>
<span class="line" id="L40"> .denominator = denominator,</span>
<span class="line" id="L41"> .decimal_step = size2 / denominator,</span>
<span class="line" id="L42"> .numerator_step = size2 % denominator,</span>
<span class="line" id="L43"> };</span>
<span class="line" id="L44"> }</span>
<span class="line" id="L45"></span>
<span class="line" id="L46"> <span class="tok-kw">fn</span> <span class="tok-fn">begin</span>(self: *Iterator) <span class="tok-type">void</span> {</span>
<span class="line" id="L47"> self.numerator = <span class="tok-number">0</span>;</span>
<span class="line" id="L48"> self.decimal = <span class="tok-number">0</span>;</span>
<span class="line" id="L49"> }</span>
<span class="line" id="L50"></span>
<span class="line" id="L51"> <span class="tok-kw">fn</span> <span class="tok-fn">nextRange</span>(self: *Iterator) Range {</span>
<span class="line" id="L52"> <span class="tok-kw">const</span> start = self.decimal;</span>
<span class="line" id="L53"></span>
<span class="line" id="L54"> self.decimal += self.decimal_step;</span>
<span class="line" id="L55"> self.numerator += self.numerator_step;</span>
<span class="line" id="L56"> <span class="tok-kw">if</span> (self.numerator >= self.denominator) {</span>
<span class="line" id="L57"> self.numerator -= self.denominator;</span>
<span class="line" id="L58"> self.decimal += <span class="tok-number">1</span>;</span>
<span class="line" id="L59"> }</span>
<span class="line" id="L60"></span>
<span class="line" id="L61"> <span class="tok-kw">return</span> Range{</span>
<span class="line" id="L62"> .start = start,</span>
<span class="line" id="L63"> .end = self.decimal,</span>
<span class="line" id="L64"> };</span>
<span class="line" id="L65"> }</span>
<span class="line" id="L66"></span>
<span class="line" id="L67"> <span class="tok-kw">fn</span> <span class="tok-fn">finished</span>(self: *Iterator) <span class="tok-type">bool</span> {</span>
<span class="line" id="L68"> <span class="tok-kw">return</span> self.decimal >= self.size;</span>
<span class="line" id="L69"> }</span>
<span class="line" id="L70"></span>
<span class="line" id="L71"> <span class="tok-kw">fn</span> <span class="tok-fn">nextLevel</span>(self: *Iterator) <span class="tok-type">bool</span> {</span>
<span class="line" id="L72"> self.decimal_step += self.decimal_step;</span>
<span class="line" id="L73"> self.numerator_step += self.numerator_step;</span>
<span class="line" id="L74"> <span class="tok-kw">if</span> (self.numerator_step >= self.denominator) {</span>
<span class="line" id="L75"> self.numerator_step -= self.denominator;</span>
<span class="line" id="L76"> self.decimal_step += <span class="tok-number">1</span>;</span>
<span class="line" id="L77"> }</span>
<span class="line" id="L78"></span>
<span class="line" id="L79"> <span class="tok-kw">return</span> (self.decimal_step < self.size);</span>
<span class="line" id="L80"> }</span>
<span class="line" id="L81"></span>
<span class="line" id="L82"> <span class="tok-kw">fn</span> <span class="tok-fn">length</span>(self: *Iterator) <span class="tok-type">usize</span> {</span>
<span class="line" id="L83"> <span class="tok-kw">return</span> self.decimal_step;</span>
<span class="line" id="L84"> }</span>
<span class="line" id="L85">};</span>
<span class="line" id="L86"></span>
<span class="line" id="L87"><span class="tok-kw">const</span> Pull = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L88"> from: <span class="tok-type">usize</span>,</span>
<span class="line" id="L89"> to: <span class="tok-type">usize</span>,</span>
<span class="line" id="L90"> count: <span class="tok-type">usize</span>,</span>
<span class="line" id="L91"> range: Range,</span>
<span class="line" id="L92">};</span>
<span class="line" id="L93"></span>
<span class="line" id="L94"><span class="tok-comment">/// Stable in-place sort. O(n) best case, O(n*log(n)) worst case and average case.</span></span>
<span class="line" id="L95"><span class="tok-comment">/// O(1) memory (no allocator required).</span></span>
<span class="line" id="L96"><span class="tok-comment">/// Sorts in ascending order with respect to the given `lessThan` function.</span></span>
<span class="line" id="L97"><span class="tok-comment">///</span></span>
<span class="line" id="L98"><span class="tok-comment">/// NOTE: the algorithm only work when the comparison is less-than or greater-than</span></span>
<span class="line" id="L99"><span class="tok-comment">/// (See https://github.com/ziglang/zig/issues/8289)</span></span>
<span class="line" id="L100"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">block</span>(</span>
<span class="line" id="L101"> <span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>,</span>
<span class="line" id="L102"> items: []T,</span>
<span class="line" id="L103"> context: <span class="tok-kw">anytype</span>,</span>
<span class="line" id="L104"> <span class="tok-kw">comptime</span> lessThanFn: <span class="tok-kw">fn</span> (<span class="tok-builtin">@TypeOf</span>(context), lhs: T, rhs: T) <span class="tok-type">bool</span>,</span>
<span class="line" id="L105">) <span class="tok-type">void</span> {</span>
<span class="line" id="L106"> <span class="tok-kw">const</span> lessThan = <span class="tok-kw">if</span> (builtin.mode == .Debug) <span class="tok-kw">struct</span> {</span>
<span class="line" id="L107"> <span class="tok-kw">fn</span> <span class="tok-fn">lessThan</span>(ctx: <span class="tok-builtin">@TypeOf</span>(context), lhs: T, rhs: T) <span class="tok-type">bool</span> {</span>
<span class="line" id="L108"> <span class="tok-kw">const</span> lt = lessThanFn(ctx, lhs, rhs);</span>
<span class="line" id="L109"> <span class="tok-kw">const</span> gt = lessThanFn(ctx, rhs, lhs);</span>
<span class="line" id="L110"> std.debug.assert(!(lt <span class="tok-kw">and</span> gt));</span>
<span class="line" id="L111"> <span class="tok-kw">return</span> lt;</span>
<span class="line" id="L112"> }</span>
<span class="line" id="L113"> }.lessThan <span class="tok-kw">else</span> lessThanFn;</span>
<span class="line" id="L114"></span>
<span class="line" id="L115"> <span class="tok-comment">// Implementation ported from https://github.com/BonzaiThePenguin/WikiSort/blob/master/WikiSort.c</span>
</span>
<span class="line" id="L116"> <span class="tok-kw">var</span> cache: [<span class="tok-number">512</span>]T = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L117"></span>
<span class="line" id="L118"> <span class="tok-kw">if</span> (items.len < <span class="tok-number">4</span>) {</span>
<span class="line" id="L119"> <span class="tok-kw">if</span> (items.len == <span class="tok-number">3</span>) {</span>
<span class="line" id="L120"> <span class="tok-comment">// hard coded insertion sort</span>
</span>
<span class="line" id="L121"> <span class="tok-kw">if</span> (lessThan(context, items[<span class="tok-number">1</span>], items[<span class="tok-number">0</span>])) mem.swap(T, &items[<span class="tok-number">0</span>], &items[<span class="tok-number">1</span>]);</span>
<span class="line" id="L122"> <span class="tok-kw">if</span> (lessThan(context, items[<span class="tok-number">2</span>], items[<span class="tok-number">1</span>])) {</span>
<span class="line" id="L123"> mem.swap(T, &items[<span class="tok-number">1</span>], &items[<span class="tok-number">2</span>]);</span>
<span class="line" id="L124"> <span class="tok-kw">if</span> (lessThan(context, items[<span class="tok-number">1</span>], items[<span class="tok-number">0</span>])) mem.swap(T, &items[<span class="tok-number">0</span>], &items[<span class="tok-number">1</span>]);</span>
<span class="line" id="L125"> }</span>
<span class="line" id="L126"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (items.len == <span class="tok-number">2</span>) {</span>
<span class="line" id="L127"> <span class="tok-kw">if</span> (lessThan(context, items[<span class="tok-number">1</span>], items[<span class="tok-number">0</span>])) mem.swap(T, &items[<span class="tok-number">0</span>], &items[<span class="tok-number">1</span>]);</span>
<span class="line" id="L128"> }</span>
<span class="line" id="L129"> <span class="tok-kw">return</span>;</span>
<span class="line" id="L130"> }</span>
<span class="line" id="L131"></span>
<span class="line" id="L132"> <span class="tok-comment">// sort groups of 4-8 items at a time using an unstable sorting network,</span>
</span>
<span class="line" id="L133"> <span class="tok-comment">// but keep track of the original item orders to force it to be stable</span>
</span>
<span class="line" id="L134"> <span class="tok-comment">// http://pages.ripco.net/~jgamble/nw.html</span>
</span>
<span class="line" id="L135"> <span class="tok-kw">var</span> iterator = Iterator.init(items.len, <span class="tok-number">4</span>);</span>
<span class="line" id="L136"> <span class="tok-kw">while</span> (!iterator.finished()) {</span>
<span class="line" id="L137"> <span class="tok-kw">var</span> order = [_]<span class="tok-type">u8</span>{ <span class="tok-number">0</span>, <span class="tok-number">1</span>, <span class="tok-number">2</span>, <span class="tok-number">3</span>, <span class="tok-number">4</span>, <span class="tok-number">5</span>, <span class="tok-number">6</span>, <span class="tok-number">7</span> };</span>
<span class="line" id="L138"> <span class="tok-kw">const</span> range = iterator.nextRange();</span>
<span class="line" id="L139"></span>
<span class="line" id="L140"> <span class="tok-kw">const</span> sliced_items = items[range.start..];</span>
<span class="line" id="L141"> <span class="tok-kw">switch</span> (range.length()) {</span>
<span class="line" id="L142"> <span class="tok-number">8</span> => {</span>
<span class="line" id="L143"> swap(T, sliced_items, &order, <span class="tok-number">0</span>, <span class="tok-number">1</span>, context, lessThan);</span>
<span class="line" id="L144"> swap(T, sliced_items, &order, <span class="tok-number">2</span>, <span class="tok-number">3</span>, context, lessThan);</span>
<span class="line" id="L145"> swap(T, sliced_items, &order, <span class="tok-number">4</span>, <span class="tok-number">5</span>, context, lessThan);</span>
<span class="line" id="L146"> swap(T, sliced_items, &order, <span class="tok-number">6</span>, <span class="tok-number">7</span>, context, lessThan);</span>
<span class="line" id="L147"> swap(T, sliced_items, &order, <span class="tok-number">0</span>, <span class="tok-number">2</span>, context, lessThan);</span>
<span class="line" id="L148"> swap(T, sliced_items, &order, <span class="tok-number">1</span>, <span class="tok-number">3</span>, context, lessThan);</span>
<span class="line" id="L149"> swap(T, sliced_items, &order, <span class="tok-number">4</span>, <span class="tok-number">6</span>, context, lessThan);</span>
<span class="line" id="L150"> swap(T, sliced_items, &order, <span class="tok-number">5</span>, <span class="tok-number">7</span>, context, lessThan);</span>
<span class="line" id="L151"> swap(T, sliced_items, &order, <span class="tok-number">1</span>, <span class="tok-number">2</span>, context, lessThan);</span>
<span class="line" id="L152"> swap(T, sliced_items, &order, <span class="tok-number">5</span>, <span class="tok-number">6</span>, context, lessThan);</span>
<span class="line" id="L153"> swap(T, sliced_items, &order, <span class="tok-number">0</span>, <span class="tok-number">4</span>, context, lessThan);</span>
<span class="line" id="L154"> swap(T, sliced_items, &order, <span class="tok-number">3</span>, <span class="tok-number">7</span>, context, lessThan);</span>
<span class="line" id="L155"> swap(T, sliced_items, &order, <span class="tok-number">1</span>, <span class="tok-number">5</span>, context, lessThan);</span>
<span class="line" id="L156"> swap(T, sliced_items, &order, <span class="tok-number">2</span>, <span class="tok-number">6</span>, context, lessThan);</span>
<span class="line" id="L157"> swap(T, sliced_items, &order, <span class="tok-number">1</span>, <span class="tok-number">4</span>, context, lessThan);</span>
<span class="line" id="L158"> swap(T, sliced_items, &order, <span class="tok-number">3</span>, <span class="tok-number">6</span>, context, lessThan);</span>
<span class="line" id="L159"> swap(T, sliced_items, &order, <span class="tok-number">2</span>, <span class="tok-number">4</span>, context, lessThan);</span>
<span class="line" id="L160"> swap(T, sliced_items, &order, <span class="tok-number">3</span>, <span class="tok-number">5</span>, context, lessThan);</span>
<span class="line" id="L161"> swap(T, sliced_items, &order, <span class="tok-number">3</span>, <span class="tok-number">4</span>, context, lessThan);</span>
<span class="line" id="L162"> },</span>
<span class="line" id="L163"> <span class="tok-number">7</span> => {</span>
<span class="line" id="L164"> swap(T, sliced_items, &order, <span class="tok-number">1</span>, <span class="tok-number">2</span>, context, lessThan);</span>
<span class="line" id="L165"> swap(T, sliced_items, &order, <span class="tok-number">3</span>, <span class="tok-number">4</span>, context, lessThan);</span>
<span class="line" id="L166"> swap(T, sliced_items, &order, <span class="tok-number">5</span>, <span class="tok-number">6</span>, context, lessThan);</span>
<span class="line" id="L167"> swap(T, sliced_items, &order, <span class="tok-number">0</span>, <span class="tok-number">2</span>, context, lessThan);</span>
<span class="line" id="L168"> swap(T, sliced_items, &order, <span class="tok-number">3</span>, <span class="tok-number">5</span>, context, lessThan);</span>
<span class="line" id="L169"> swap(T, sliced_items, &order, <span class="tok-number">4</span>, <span class="tok-number">6</span>, context, lessThan);</span>
<span class="line" id="L170"> swap(T, sliced_items, &order, <span class="tok-number">0</span>, <span class="tok-number">1</span>, context, lessThan);</span>
<span class="line" id="L171"> swap(T, sliced_items, &order, <span class="tok-number">4</span>, <span class="tok-number">5</span>, context, lessThan);</span>
<span class="line" id="L172"> swap(T, sliced_items, &order, <span class="tok-number">2</span>, <span class="tok-number">6</span>, context, lessThan);</span>
<span class="line" id="L173"> swap(T, sliced_items, &order, <span class="tok-number">0</span>, <span class="tok-number">4</span>, context, lessThan);</span>
<span class="line" id="L174"> swap(T, sliced_items, &order, <span class="tok-number">1</span>, <span class="tok-number">5</span>, context, lessThan);</span>
<span class="line" id="L175"> swap(T, sliced_items, &order, <span class="tok-number">0</span>, <span class="tok-number">3</span>, context, lessThan);</span>
<span class="line" id="L176"> swap(T, sliced_items, &order, <span class="tok-number">2</span>, <span class="tok-number">5</span>, context, lessThan);</span>
<span class="line" id="L177"> swap(T, sliced_items, &order, <span class="tok-number">1</span>, <span class="tok-number">3</span>, context, lessThan);</span>
<span class="line" id="L178"> swap(T, sliced_items, &order, <span class="tok-number">2</span>, <span class="tok-number">4</span>, context, lessThan);</span>
<span class="line" id="L179"> swap(T, sliced_items, &order, <span class="tok-number">2</span>, <span class="tok-number">3</span>, context, lessThan);</span>
<span class="line" id="L180"> },</span>
<span class="line" id="L181"> <span class="tok-number">6</span> => {</span>
<span class="line" id="L182"> swap(T, sliced_items, &order, <span class="tok-number">1</span>, <span class="tok-number">2</span>, context, lessThan);</span>
<span class="line" id="L183"> swap(T, sliced_items, &order, <span class="tok-number">4</span>, <span class="tok-number">5</span>, context, lessThan);</span>
<span class="line" id="L184"> swap(T, sliced_items, &order, <span class="tok-number">0</span>, <span class="tok-number">2</span>, context, lessThan);</span>
<span class="line" id="L185"> swap(T, sliced_items, &order, <span class="tok-number">3</span>, <span class="tok-number">5</span>, context, lessThan);</span>
<span class="line" id="L186"> swap(T, sliced_items, &order, <span class="tok-number">0</span>, <span class="tok-number">1</span>, context, lessThan);</span>
<span class="line" id="L187"> swap(T, sliced_items, &order, <span class="tok-number">3</span>, <span class="tok-number">4</span>, context, lessThan);</span>
<span class="line" id="L188"> swap(T, sliced_items, &order, <span class="tok-number">2</span>, <span class="tok-number">5</span>, context, lessThan);</span>
<span class="line" id="L189"> swap(T, sliced_items, &order, <span class="tok-number">0</span>, <span class="tok-number">3</span>, context, lessThan);</span>
<span class="line" id="L190"> swap(T, sliced_items, &order, <span class="tok-number">1</span>, <span class="tok-number">4</span>, context, lessThan);</span>
<span class="line" id="L191"> swap(T, sliced_items, &order, <span class="tok-number">2</span>, <span class="tok-number">4</span>, context, lessThan);</span>
<span class="line" id="L192"> swap(T, sliced_items, &order, <span class="tok-number">1</span>, <span class="tok-number">3</span>, context, lessThan);</span>
<span class="line" id="L193"> swap(T, sliced_items, &order, <span class="tok-number">2</span>, <span class="tok-number">3</span>, context, lessThan);</span>
<span class="line" id="L194"> },</span>
<span class="line" id="L195"> <span class="tok-number">5</span> => {</span>
<span class="line" id="L196"> swap(T, sliced_items, &order, <span class="tok-number">0</span>, <span class="tok-number">1</span>, context, lessThan);</span>
<span class="line" id="L197"> swap(T, sliced_items, &order, <span class="tok-number">3</span>, <span class="tok-number">4</span>, context, lessThan);</span>
<span class="line" id="L198"> swap(T, sliced_items, &order, <span class="tok-number">2</span>, <span class="tok-number">4</span>, context, lessThan);</span>
<span class="line" id="L199"> swap(T, sliced_items, &order, <span class="tok-number">2</span>, <span class="tok-number">3</span>, context, lessThan);</span>
<span class="line" id="L200"> swap(T, sliced_items, &order, <span class="tok-number">1</span>, <span class="tok-number">4</span>, context, lessThan);</span>
<span class="line" id="L201"> swap(T, sliced_items, &order, <span class="tok-number">0</span>, <span class="tok-number">3</span>, context, lessThan);</span>
<span class="line" id="L202"> swap(T, sliced_items, &order, <span class="tok-number">0</span>, <span class="tok-number">2</span>, context, lessThan);</span>
<span class="line" id="L203"> swap(T, sliced_items, &order, <span class="tok-number">1</span>, <span class="tok-number">3</span>, context, lessThan);</span>
<span class="line" id="L204"> swap(T, sliced_items, &order, <span class="tok-number">1</span>, <span class="tok-number">2</span>, context, lessThan);</span>
<span class="line" id="L205"> },</span>
<span class="line" id="L206"> <span class="tok-number">4</span> => {</span>
<span class="line" id="L207"> swap(T, sliced_items, &order, <span class="tok-number">0</span>, <span class="tok-number">1</span>, context, lessThan);</span>
<span class="line" id="L208"> swap(T, sliced_items, &order, <span class="tok-number">2</span>, <span class="tok-number">3</span>, context, lessThan);</span>
<span class="line" id="L209"> swap(T, sliced_items, &order, <span class="tok-number">0</span>, <span class="tok-number">2</span>, context, lessThan);</span>
<span class="line" id="L210"> swap(T, sliced_items, &order, <span class="tok-number">1</span>, <span class="tok-number">3</span>, context, lessThan);</span>
<span class="line" id="L211"> swap(T, sliced_items, &order, <span class="tok-number">1</span>, <span class="tok-number">2</span>, context, lessThan);</span>
<span class="line" id="L212"> },</span>
<span class="line" id="L213"> <span class="tok-kw">else</span> => {},</span>
<span class="line" id="L214"> }</span>
<span class="line" id="L215"> }</span>
<span class="line" id="L216"> <span class="tok-kw">if</span> (items.len < <span class="tok-number">8</span>) <span class="tok-kw">return</span>;</span>
<span class="line" id="L217"></span>
<span class="line" id="L218"> <span class="tok-comment">// then merge sort the higher levels, which can be 8-15, 16-31, 32-63, 64-127, etc.</span>
</span>
<span class="line" id="L219"> <span class="tok-kw">while</span> (<span class="tok-null">true</span>) {</span>
<span class="line" id="L220"> <span class="tok-comment">// if every A and B block will fit into the cache, use a special branch</span>
</span>
<span class="line" id="L221"> <span class="tok-comment">// specifically for merging with the cache</span>
</span>
<span class="line" id="L222"> <span class="tok-comment">// (we use < rather than <= since the block size might be one more than</span>
</span>
<span class="line" id="L223"> <span class="tok-comment">// iterator.length())</span>
</span>
<span class="line" id="L224"> <span class="tok-kw">if</span> (iterator.length() < cache.len) {</span>
<span class="line" id="L225"> <span class="tok-comment">// if four subarrays fit into the cache, it's faster to merge both</span>
</span>
<span class="line" id="L226"> <span class="tok-comment">// pairs of subarrays into the cache,</span>
</span>
<span class="line" id="L227"> <span class="tok-comment">// then merge the two merged subarrays from the cache back into the original array</span>
</span>
<span class="line" id="L228"> <span class="tok-kw">if</span> ((iterator.length() + <span class="tok-number">1</span>) * <span class="tok-number">4</span> <= cache.len <span class="tok-kw">and</span> iterator.length() * <span class="tok-number">4</span> <= items.len) {</span>
<span class="line" id="L229"> iterator.begin();</span>
<span class="line" id="L230"> <span class="tok-kw">while</span> (!iterator.finished()) {</span>
<span class="line" id="L231"> <span class="tok-comment">// merge A1 and B1 into the cache</span>
</span>
<span class="line" id="L232"> <span class="tok-kw">var</span> A1 = iterator.nextRange();</span>
<span class="line" id="L233"> <span class="tok-kw">var</span> B1 = iterator.nextRange();</span>
<span class="line" id="L234"> <span class="tok-kw">var</span> A2 = iterator.nextRange();</span>
<span class="line" id="L235"> <span class="tok-kw">var</span> B2 = iterator.nextRange();</span>
<span class="line" id="L236"></span>
<span class="line" id="L237"> <span class="tok-kw">if</span> (lessThan(context, items[B1.end - <span class="tok-number">1</span>], items[A1.start])) {</span>
<span class="line" id="L238"> <span class="tok-comment">// the two ranges are in reverse order, so copy them in reverse order into the cache</span>
</span>
<span class="line" id="L239"> <span class="tok-kw">const</span> a1_items = items[A1.start..A1.end];</span>
<span class="line" id="L240"> <span class="tok-builtin">@memcpy</span>(cache[B1.length()..][<span class="tok-number">0</span>..a1_items.len], a1_items);</span>
<span class="line" id="L241"> <span class="tok-kw">const</span> b1_items = items[B1.start..B1.end];</span>
<span class="line" id="L242"> <span class="tok-builtin">@memcpy</span>(cache[<span class="tok-number">0</span>..b1_items.len], b1_items);</span>
<span class="line" id="L243"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (lessThan(context, items[B1.start], items[A1.end - <span class="tok-number">1</span>])) {</span>
<span class="line" id="L244"> <span class="tok-comment">// these two ranges weren't already in order, so merge them into the cache</span>
</span>
<span class="line" id="L245"> mergeInto(T, items, A1, B1, cache[<span class="tok-number">0</span>..], context, lessThan);</span>
<span class="line" id="L246"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L247"> <span class="tok-comment">// if A1, B1, A2, and B2 are all in order, skip doing anything else</span>
</span>
<span class="line" id="L248"> <span class="tok-kw">if</span> (!lessThan(context, items[B2.start], items[A2.end - <span class="tok-number">1</span>]) <span class="tok-kw">and</span> !lessThan(context, items[A2.start], items[B1.end - <span class="tok-number">1</span>])) <span class="tok-kw">continue</span>;</span>
<span class="line" id="L249"></span>
<span class="line" id="L250"> <span class="tok-comment">// copy A1 and B1 into the cache in the same order</span>
</span>
<span class="line" id="L251"> <span class="tok-kw">const</span> a1_items = items[A1.start..A1.end];</span>
<span class="line" id="L252"> <span class="tok-builtin">@memcpy</span>(cache[<span class="tok-number">0</span>..a1_items.len], a1_items);</span>
<span class="line" id="L253"> <span class="tok-kw">const</span> b1_items = items[B1.start..B1.end];</span>
<span class="line" id="L254"> <span class="tok-builtin">@memcpy</span>(cache[A1.length()..][<span class="tok-number">0</span>..b1_items.len], b1_items);</span>
<span class="line" id="L255"> }</span>
<span class="line" id="L256"> A1 = Range.init(A1.start, B1.end);</span>
<span class="line" id="L257"></span>
<span class="line" id="L258"> <span class="tok-comment">// merge A2 and B2 into the cache</span>
</span>
<span class="line" id="L259"> <span class="tok-kw">if</span> (lessThan(context, items[B2.end - <span class="tok-number">1</span>], items[A2.start])) {</span>
<span class="line" id="L260"> <span class="tok-comment">// the two ranges are in reverse order, so copy them in reverse order into the cache</span>
</span>
<span class="line" id="L261"> <span class="tok-kw">const</span> a2_items = items[A2.start..A2.end];</span>
<span class="line" id="L262"> <span class="tok-builtin">@memcpy</span>(cache[A1.length() + B2.length() ..][<span class="tok-number">0</span>..a2_items.len], a2_items);</span>
<span class="line" id="L263"> <span class="tok-kw">const</span> b2_items = items[B2.start..B2.end];</span>
<span class="line" id="L264"> <span class="tok-builtin">@memcpy</span>(cache[A1.length()..][<span class="tok-number">0</span>..b2_items.len], b2_items);</span>
<span class="line" id="L265"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (lessThan(context, items[B2.start], items[A2.end - <span class="tok-number">1</span>])) {</span>
<span class="line" id="L266"> <span class="tok-comment">// these two ranges weren't already in order, so merge them into the cache</span>
</span>
<span class="line" id="L267"> mergeInto(T, items, A2, B2, cache[A1.length()..], context, lessThan);</span>
<span class="line" id="L268"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L269"> <span class="tok-comment">// copy A2 and B2 into the cache in the same order</span>
</span>
<span class="line" id="L270"> <span class="tok-kw">const</span> a2_items = items[A2.start..A2.end];</span>
<span class="line" id="L271"> <span class="tok-builtin">@memcpy</span>(cache[A1.length()..][<span class="tok-number">0</span>..a2_items.len], a2_items);</span>
<span class="line" id="L272"> <span class="tok-kw">const</span> b2_items = items[B2.start..B2.end];</span>
<span class="line" id="L273"> <span class="tok-builtin">@memcpy</span>(cache[A1.length() + A2.length() ..][<span class="tok-number">0</span>..b2_items.len], b2_items);</span>
<span class="line" id="L274"> }</span>
<span class="line" id="L275"> A2 = Range.init(A2.start, B2.end);</span>
<span class="line" id="L276"></span>
<span class="line" id="L277"> <span class="tok-comment">// merge A1 and A2 from the cache into the items</span>
</span>
<span class="line" id="L278"> <span class="tok-kw">const</span> A3 = Range.init(<span class="tok-number">0</span>, A1.length());</span>
<span class="line" id="L279"> <span class="tok-kw">const</span> B3 = Range.init(A1.length(), A1.length() + A2.length());</span>
<span class="line" id="L280"></span>
<span class="line" id="L281"> <span class="tok-kw">if</span> (lessThan(context, cache[B3.end - <span class="tok-number">1</span>], cache[A3.start])) {</span>
<span class="line" id="L282"> <span class="tok-comment">// the two ranges are in reverse order, so copy them in reverse order into the items</span>
</span>
<span class="line" id="L283"> <span class="tok-kw">const</span> a3_items = cache[A3.start..A3.end];</span>
<span class="line" id="L284"> <span class="tok-builtin">@memcpy</span>(items[A1.start + A2.length() ..][<span class="tok-number">0</span>..a3_items.len], a3_items);</span>
<span class="line" id="L285"> <span class="tok-kw">const</span> b3_items = cache[B3.start..B3.end];</span>
<span class="line" id="L286"> <span class="tok-builtin">@memcpy</span>(items[A1.start..][<span class="tok-number">0</span>..b3_items.len], b3_items);</span>
<span class="line" id="L287"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (lessThan(context, cache[B3.start], cache[A3.end - <span class="tok-number">1</span>])) {</span>
<span class="line" id="L288"> <span class="tok-comment">// these two ranges weren't already in order, so merge them back into the items</span>
</span>
<span class="line" id="L289"> mergeInto(T, cache[<span class="tok-number">0</span>..], A3, B3, items[A1.start..], context, lessThan);</span>
<span class="line" id="L290"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L291"> <span class="tok-comment">// copy A3 and B3 into the items in the same order</span>
</span>
<span class="line" id="L292"> <span class="tok-kw">const</span> a3_items = cache[A3.start..A3.end];</span>
<span class="line" id="L293"> <span class="tok-builtin">@memcpy</span>(items[A1.start..][<span class="tok-number">0</span>..a3_items.len], a3_items);</span>
<span class="line" id="L294"> <span class="tok-kw">const</span> b3_items = cache[B3.start..B3.end];</span>
<span class="line" id="L295"> <span class="tok-builtin">@memcpy</span>(items[A1.start + A1.length() ..][<span class="tok-number">0</span>..b3_items.len], b3_items);</span>
<span class="line" id="L296"> }</span>
<span class="line" id="L297"> }</span>
<span class="line" id="L298"></span>
<span class="line" id="L299"> <span class="tok-comment">// we merged two levels at the same time, so we're done with this level already</span>
</span>
<span class="line" id="L300"> <span class="tok-comment">// (iterator.nextLevel() is called again at the bottom of this outer merge loop)</span>
</span>
<span class="line" id="L301"> _ = iterator.nextLevel();</span>
<span class="line" id="L302"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L303"> iterator.begin();</span>
<span class="line" id="L304"> <span class="tok-kw">while</span> (!iterator.finished()) {</span>
<span class="line" id="L305"> <span class="tok-kw">var</span> A = iterator.nextRange();</span>
<span class="line" id="L306"> <span class="tok-kw">var</span> B = iterator.nextRange();</span>
<span class="line" id="L307"></span>
<span class="line" id="L308"> <span class="tok-kw">if</span> (lessThan(context, items[B.end - <span class="tok-number">1</span>], items[A.start])) {</span>
<span class="line" id="L309"> <span class="tok-comment">// the two ranges are in reverse order, so a simple rotation should fix it</span>
</span>
<span class="line" id="L310"> mem.rotate(T, items[A.start..B.end], A.length());</span>
<span class="line" id="L311"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (lessThan(context, items[B.start], items[A.end - <span class="tok-number">1</span>])) {</span>
<span class="line" id="L312"> <span class="tok-comment">// these two ranges weren't already in order, so we'll need to merge them!</span>
</span>
<span class="line" id="L313"> <span class="tok-kw">const</span> a_items = items[A.start..A.end];</span>
<span class="line" id="L314"> <span class="tok-builtin">@memcpy</span>(cache[<span class="tok-number">0</span>..a_items.len], a_items);</span>
<span class="line" id="L315"> mergeExternal(T, items, A, B, cache[<span class="tok-number">0</span>..], context, lessThan);</span>
<span class="line" id="L316"> }</span>
<span class="line" id="L317"> }</span>
<span class="line" id="L318"> }</span>
<span class="line" id="L319"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L320"> <span class="tok-comment">// this is where the in-place merge logic starts!</span>
</span>
<span class="line" id="L321"> <span class="tok-comment">// 1. pull out two internal buffers each containing √A unique values</span>
</span>
<span class="line" id="L322"> <span class="tok-comment">// 1a. adjust block_size and buffer_size if we couldn't find enough unique values</span>
</span>
<span class="line" id="L323"> <span class="tok-comment">// 2. loop over the A and B subarrays within this level of the merge sort</span>
</span>
<span class="line" id="L324"> <span class="tok-comment">// 3. break A and B into blocks of size 'block_size'</span>
</span>
<span class="line" id="L325"> <span class="tok-comment">// 4. "tag" each of the A blocks with values from the first internal buffer</span>
</span>
<span class="line" id="L326"> <span class="tok-comment">// 5. roll the A blocks through the B blocks and drop/rotate them where they belong</span>
</span>
<span class="line" id="L327"> <span class="tok-comment">// 6. merge each A block with any B values that follow, using the cache or the second internal buffer</span>
</span>
<span class="line" id="L328"> <span class="tok-comment">// 7. sort the second internal buffer if it exists</span>
</span>
<span class="line" id="L329"> <span class="tok-comment">// 8. redistribute the two internal buffers back into the items</span>
</span>
<span class="line" id="L330"> <span class="tok-kw">var</span> block_size: <span class="tok-type">usize</span> = math.sqrt(iterator.length());</span>
<span class="line" id="L331"> <span class="tok-kw">var</span> buffer_size = iterator.length() / block_size + <span class="tok-number">1</span>;</span>
<span class="line" id="L332"></span>
<span class="line" id="L333"> <span class="tok-comment">// as an optimization, we really only need to pull out the internal buffers once for each level of merges</span>
</span>
<span class="line" id="L334"> <span class="tok-comment">// after that we can reuse the same buffers over and over, then redistribute it when we're finished with this level</span>
</span>
<span class="line" id="L335"> <span class="tok-kw">var</span> A: Range = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L336"> <span class="tok-kw">var</span> B: Range = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L337"> <span class="tok-kw">var</span> index: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L338"> <span class="tok-kw">var</span> last: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L339"> <span class="tok-kw">var</span> count: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L340"> <span class="tok-kw">var</span> find: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L341"> <span class="tok-kw">var</span> start: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L342"> <span class="tok-kw">var</span> pull_index: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L343"> <span class="tok-kw">var</span> pull = [_]Pull{</span>
<span class="line" id="L344"> Pull{</span>
<span class="line" id="L345"> .from = <span class="tok-number">0</span>,</span>
<span class="line" id="L346"> .to = <span class="tok-number">0</span>,</span>
<span class="line" id="L347"> .count = <span class="tok-number">0</span>,</span>
<span class="line" id="L348"> .range = Range.init(<span class="tok-number">0</span>, <span class="tok-number">0</span>),</span>
<span class="line" id="L349"> },</span>
<span class="line" id="L350"> Pull{</span>
<span class="line" id="L351"> .from = <span class="tok-number">0</span>,</span>
<span class="line" id="L352"> .to = <span class="tok-number">0</span>,</span>
<span class="line" id="L353"> .count = <span class="tok-number">0</span>,</span>
<span class="line" id="L354"> .range = Range.init(<span class="tok-number">0</span>, <span class="tok-number">0</span>),</span>
<span class="line" id="L355"> },</span>
<span class="line" id="L356"> };</span>
<span class="line" id="L357"></span>
<span class="line" id="L358"> <span class="tok-kw">var</span> buffer1 = Range.init(<span class="tok-number">0</span>, <span class="tok-number">0</span>);</span>
<span class="line" id="L359"> <span class="tok-kw">var</span> buffer2 = Range.init(<span class="tok-number">0</span>, <span class="tok-number">0</span>);</span>
<span class="line" id="L360"></span>
<span class="line" id="L361"> <span class="tok-comment">// find two internal buffers of size 'buffer_size' each</span>
</span>
<span class="line" id="L362"> find = buffer_size + buffer_size;</span>
<span class="line" id="L363"> <span class="tok-kw">var</span> find_separately = <span class="tok-null">false</span>;</span>
<span class="line" id="L364"></span>
<span class="line" id="L365"> <span class="tok-kw">if</span> (block_size <= cache.len) {</span>
<span class="line" id="L366"> <span class="tok-comment">// if every A block fits into the cache then we won't need the second internal buffer,</span>
</span>
<span class="line" id="L367"> <span class="tok-comment">// so we really only need to find 'buffer_size' unique values</span>
</span>
<span class="line" id="L368"> find = buffer_size;</span>
<span class="line" id="L369"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (find > iterator.length()) {</span>
<span class="line" id="L370"> <span class="tok-comment">// we can't fit both buffers into the same A or B subarray, so find two buffers separately</span>
</span>
<span class="line" id="L371"> find = buffer_size;</span>
<span class="line" id="L372"> find_separately = <span class="tok-null">true</span>;</span>
<span class="line" id="L373"> }</span>
<span class="line" id="L374"></span>
<span class="line" id="L375"> <span class="tok-comment">// we need to find either a single contiguous space containing 2√A unique values (which will be split up into two buffers of size √A each),</span>
</span>
<span class="line" id="L376"> <span class="tok-comment">// or we need to find one buffer of < 2√A unique values, and a second buffer of √A unique values,</span>
</span>
<span class="line" id="L377"> <span class="tok-comment">// OR if we couldn't find that many unique values, we need the largest possible buffer we can get</span>
</span>
<span class="line" id="L378"></span>
<span class="line" id="L379"> <span class="tok-comment">// in the case where it couldn't find a single buffer of at least √A unique values,</span>
</span>
<span class="line" id="L380"> <span class="tok-comment">// all of the Merge steps must be replaced by a different merge algorithm (MergeInPlace)</span>
</span>
<span class="line" id="L381"> iterator.begin();</span>
<span class="line" id="L382"> <span class="tok-kw">while</span> (!iterator.finished()) {</span>
<span class="line" id="L383"> A = iterator.nextRange();</span>
<span class="line" id="L384"> B = iterator.nextRange();</span>
<span class="line" id="L385"></span>
<span class="line" id="L386"> <span class="tok-comment">// just store information about where the values will be pulled from and to,</span>
</span>
<span class="line" id="L387"> <span class="tok-comment">// as well as how many values there are, to create the two internal buffers</span>
</span>
<span class="line" id="L388"></span>
<span class="line" id="L389"> <span class="tok-comment">// check A for the number of unique values we need to fill an internal buffer</span>
</span>
<span class="line" id="L390"> <span class="tok-comment">// these values will be pulled out to the start of A</span>
</span>
<span class="line" id="L391"> last = A.start;</span>
<span class="line" id="L392"> count = <span class="tok-number">1</span>;</span>
<span class="line" id="L393"> <span class="tok-kw">while</span> (count < find) : ({</span>
<span class="line" id="L394"> last = index;</span>
<span class="line" id="L395"> count += <span class="tok-number">1</span>;</span>
<span class="line" id="L396"> }) {</span>
<span class="line" id="L397"> index = findLastForward(T, items, items[last], Range.init(last + <span class="tok-number">1</span>, A.end), find - count, context, lessThan);</span>
<span class="line" id="L398"> <span class="tok-kw">if</span> (index == A.end) <span class="tok-kw">break</span>;</span>
<span class="line" id="L399"> }</span>
<span class="line" id="L400"> index = last;</span>
<span class="line" id="L401"></span>
<span class="line" id="L402"> <span class="tok-kw">if</span> (count >= buffer_size) {</span>
<span class="line" id="L403"> <span class="tok-comment">// keep track of the range within the items where we'll need to "pull out" these values to create the internal buffer</span>
</span>
<span class="line" id="L404"> pull[pull_index] = Pull{</span>
<span class="line" id="L405"> .range = Range.init(A.start, B.end),</span>
<span class="line" id="L406"> .count = count,</span>
<span class="line" id="L407"> .from = index,</span>
<span class="line" id="L408"> .to = A.start,</span>
<span class="line" id="L409"> };</span>
<span class="line" id="L410"> pull_index = <span class="tok-number">1</span>;</span>
<span class="line" id="L411"></span>
<span class="line" id="L412"> <span class="tok-kw">if</span> (count == buffer_size + buffer_size) {</span>
<span class="line" id="L413"> <span class="tok-comment">// we were able to find a single contiguous section containing 2√A unique values,</span>
</span>
<span class="line" id="L414"> <span class="tok-comment">// so this section can be used to contain both of the internal buffers we'll need</span>
</span>
<span class="line" id="L415"> buffer1 = Range.init(A.start, A.start + buffer_size);</span>
<span class="line" id="L416"> buffer2 = Range.init(A.start + buffer_size, A.start + count);</span>
<span class="line" id="L417"> <span class="tok-kw">break</span>;</span>
<span class="line" id="L418"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (find == buffer_size + buffer_size) {</span>
<span class="line" id="L419"> <span class="tok-comment">// we found a buffer that contains at least √A unique values, but did not contain the full 2√A unique values,</span>
</span>
<span class="line" id="L420"> <span class="tok-comment">// so we still need to find a second separate buffer of at least √A unique values</span>
</span>
<span class="line" id="L421"> buffer1 = Range.init(A.start, A.start + count);</span>
<span class="line" id="L422"> find = buffer_size;</span>
<span class="line" id="L423"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (block_size <= cache.len) {</span>
<span class="line" id="L424"> <span class="tok-comment">// we found the first and only internal buffer that we need, so we're done!</span>
</span>
<span class="line" id="L425"> buffer1 = Range.init(A.start, A.start + count);</span>
<span class="line" id="L426"> <span class="tok-kw">break</span>;</span>
<span class="line" id="L427"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (find_separately) {</span>
<span class="line" id="L428"> <span class="tok-comment">// found one buffer, but now find the other one</span>
</span>
<span class="line" id="L429"> buffer1 = Range.init(A.start, A.start + count);</span>
<span class="line" id="L430"> find_separately = <span class="tok-null">false</span>;</span>
<span class="line" id="L431"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L432"> <span class="tok-comment">// we found a second buffer in an 'A' subarray containing √A unique values, so we're done!</span>
</span>
<span class="line" id="L433"> buffer2 = Range.init(A.start, A.start + count);</span>
<span class="line" id="L434"> <span class="tok-kw">break</span>;</span>
<span class="line" id="L435"> }</span>
<span class="line" id="L436"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (pull_index == <span class="tok-number">0</span> <span class="tok-kw">and</span> count > buffer1.length()) {</span>
<span class="line" id="L437"> <span class="tok-comment">// keep track of the largest buffer we were able to find</span>
</span>
<span class="line" id="L438"> buffer1 = Range.init(A.start, A.start + count);</span>
<span class="line" id="L439"> pull[pull_index] = Pull{</span>
<span class="line" id="L440"> .range = Range.init(A.start, B.end),</span>
<span class="line" id="L441"> .count = count,</span>
<span class="line" id="L442"> .from = index,</span>
<span class="line" id="L443"> .to = A.start,</span>
<span class="line" id="L444"> };</span>
<span class="line" id="L445"> }</span>
<span class="line" id="L446"></span>
<span class="line" id="L447"> <span class="tok-comment">// check B for the number of unique values we need to fill an internal buffer</span>
</span>
<span class="line" id="L448"> <span class="tok-comment">// these values will be pulled out to the end of B</span>
</span>
<span class="line" id="L449"> last = B.end - <span class="tok-number">1</span>;</span>
<span class="line" id="L450"> count = <span class="tok-number">1</span>;</span>
<span class="line" id="L451"> <span class="tok-kw">while</span> (count < find) : ({</span>
<span class="line" id="L452"> last = index - <span class="tok-number">1</span>;</span>
<span class="line" id="L453"> count += <span class="tok-number">1</span>;</span>
<span class="line" id="L454"> }) {</span>
<span class="line" id="L455"> index = findFirstBackward(T, items, items[last], Range.init(B.start, last), find - count, context, lessThan);</span>
<span class="line" id="L456"> <span class="tok-kw">if</span> (index == B.start) <span class="tok-kw">break</span>;</span>
<span class="line" id="L457"> }</span>
<span class="line" id="L458"> index = last;</span>
<span class="line" id="L459"></span>
<span class="line" id="L460"> <span class="tok-kw">if</span> (count >= buffer_size) {</span>
<span class="line" id="L461"> <span class="tok-comment">// keep track of the range within the items where we'll need to "pull out" these values to create the internal buffe</span>
</span>
<span class="line" id="L462"> pull[pull_index] = Pull{</span>
<span class="line" id="L463"> .range = Range.init(A.start, B.end),</span>
<span class="line" id="L464"> .count = count,</span>
<span class="line" id="L465"> .from = index,</span>
<span class="line" id="L466"> .to = B.end,</span>
<span class="line" id="L467"> };</span>
<span class="line" id="L468"> pull_index = <span class="tok-number">1</span>;</span>
<span class="line" id="L469"></span>
<span class="line" id="L470"> <span class="tok-kw">if</span> (count == buffer_size + buffer_size) {</span>
<span class="line" id="L471"> <span class="tok-comment">// we were able to find a single contiguous section containing 2√A unique values,</span>
</span>
<span class="line" id="L472"> <span class="tok-comment">// so this section can be used to contain both of the internal buffers we'll need</span>
</span>
<span class="line" id="L473"> buffer1 = Range.init(B.end - count, B.end - buffer_size);</span>
<span class="line" id="L474"> buffer2 = Range.init(B.end - buffer_size, B.end);</span>
<span class="line" id="L475"> <span class="tok-kw">break</span>;</span>
<span class="line" id="L476"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (find == buffer_size + buffer_size) {</span>
<span class="line" id="L477"> <span class="tok-comment">// we found a buffer that contains at least √A unique values, but did not contain the full 2√A unique values,</span>
</span>
<span class="line" id="L478"> <span class="tok-comment">// so we still need to find a second separate buffer of at least √A unique values</span>
</span>
<span class="line" id="L479"> buffer1 = Range.init(B.end - count, B.end);</span>
<span class="line" id="L480"> find = buffer_size;</span>
<span class="line" id="L481"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (block_size <= cache.len) {</span>
<span class="line" id="L482"> <span class="tok-comment">// we found the first and only internal buffer that we need, so we're done!</span>
</span>
<span class="line" id="L483"> buffer1 = Range.init(B.end - count, B.end);</span>
<span class="line" id="L484"> <span class="tok-kw">break</span>;</span>
<span class="line" id="L485"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (find_separately) {</span>
<span class="line" id="L486"> <span class="tok-comment">// found one buffer, but now find the other one</span>
</span>
<span class="line" id="L487"> buffer1 = Range.init(B.end - count, B.end);</span>
<span class="line" id="L488"> find_separately = <span class="tok-null">false</span>;</span>
<span class="line" id="L489"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L490"> <span class="tok-comment">// buffer2 will be pulled out from a 'B' subarray, so if the first buffer was pulled out from the corresponding 'A' subarray,</span>
</span>
<span class="line" id="L491"> <span class="tok-comment">// we need to adjust the end point for that A subarray so it knows to stop redistributing its values before reaching buffer2</span>
</span>
<span class="line" id="L492"> <span class="tok-kw">if</span> (pull[<span class="tok-number">0</span>].range.start == A.start) pull[<span class="tok-number">0</span>].range.end -= pull[<span class="tok-number">1</span>].count;</span>
<span class="line" id="L493"></span>
<span class="line" id="L494"> <span class="tok-comment">// we found a second buffer in an 'B' subarray containing √A unique values, so we're done!</span>
</span>
<span class="line" id="L495"> buffer2 = Range.init(B.end - count, B.end);</span>
<span class="line" id="L496"> <span class="tok-kw">break</span>;</span>
<span class="line" id="L497"> }</span>
<span class="line" id="L498"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (pull_index == <span class="tok-number">0</span> <span class="tok-kw">and</span> count > buffer1.length()) {</span>
<span class="line" id="L499"> <span class="tok-comment">// keep track of the largest buffer we were able to find</span>
</span>
<span class="line" id="L500"> buffer1 = Range.init(B.end - count, B.end);</span>
<span class="line" id="L501"> pull[pull_index] = Pull{</span>
<span class="line" id="L502"> .range = Range.init(A.start, B.end),</span>
<span class="line" id="L503"> .count = count,</span>
<span class="line" id="L504"> .from = index,</span>
<span class="line" id="L505"> .to = B.end,</span>
<span class="line" id="L506"> };</span>
<span class="line" id="L507"> }</span>
<span class="line" id="L508"> }</span>
<span class="line" id="L509"></span>
<span class="line" id="L510"> <span class="tok-comment">// pull out the two ranges so we can use them as internal buffers</span>
</span>
<span class="line" id="L511"> pull_index = <span class="tok-number">0</span>;</span>
<span class="line" id="L512"> <span class="tok-kw">while</span> (pull_index < <span class="tok-number">2</span>) : (pull_index += <span class="tok-number">1</span>) {</span>
<span class="line" id="L513"> <span class="tok-kw">const</span> length = pull[pull_index].count;</span>
<span class="line" id="L514"></span>
<span class="line" id="L515"> <span class="tok-kw">if</span> (pull[pull_index].to < pull[pull_index].from) {</span>
<span class="line" id="L516"> <span class="tok-comment">// we're pulling the values out to the left, which means the start of an A subarray</span>
</span>
<span class="line" id="L517"> index = pull[pull_index].from;</span>
<span class="line" id="L518"> count = <span class="tok-number">1</span>;</span>
<span class="line" id="L519"> <span class="tok-kw">while</span> (count < length) : (count += <span class="tok-number">1</span>) {</span>
<span class="line" id="L520"> index = findFirstBackward(T, items, items[index - <span class="tok-number">1</span>], Range.init(pull[pull_index].to, pull[pull_index].from - (count - <span class="tok-number">1</span>)), length - count, context, lessThan);</span>
<span class="line" id="L521"> <span class="tok-kw">const</span> range = Range.init(index + <span class="tok-number">1</span>, pull[pull_index].from + <span class="tok-number">1</span>);</span>
<span class="line" id="L522"> mem.rotate(T, items[range.start..range.end], range.length() - count);</span>
<span class="line" id="L523"> pull[pull_index].from = index + count;</span>
<span class="line" id="L524"> }</span>
<span class="line" id="L525"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (pull[pull_index].to > pull[pull_index].from) {</span>
<span class="line" id="L526"> <span class="tok-comment">// we're pulling values out to the right, which means the end of a B subarray</span>
</span>
<span class="line" id="L527"> index = pull[pull_index].from + <span class="tok-number">1</span>;</span>
<span class="line" id="L528"> count = <span class="tok-number">1</span>;</span>
<span class="line" id="L529"> <span class="tok-kw">while</span> (count < length) : (count += <span class="tok-number">1</span>) {</span>
<span class="line" id="L530"> index = findLastForward(T, items, items[index], Range.init(index, pull[pull_index].to), length - count, context, lessThan);</span>
<span class="line" id="L531"> <span class="tok-kw">const</span> range = Range.init(pull[pull_index].from, index - <span class="tok-number">1</span>);</span>
<span class="line" id="L532"> mem.rotate(T, items[range.start..range.end], count);</span>
<span class="line" id="L533"> pull[pull_index].from = index - <span class="tok-number">1</span> - count;</span>
<span class="line" id="L534"> }</span>
<span class="line" id="L535"> }</span>
<span class="line" id="L536"> }</span>
<span class="line" id="L537"></span>
<span class="line" id="L538"> <span class="tok-comment">// adjust block_size and buffer_size based on the values we were able to pull out</span>
</span>
<span class="line" id="L539"> buffer_size = buffer1.length();</span>
<span class="line" id="L540"> block_size = iterator.length() / buffer_size + <span class="tok-number">1</span>;</span>
<span class="line" id="L541"></span>
<span class="line" id="L542"> <span class="tok-comment">// the first buffer NEEDS to be large enough to tag each of the evenly sized A blocks,</span>
</span>
<span class="line" id="L543"> <span class="tok-comment">// so this was originally here to test the math for adjusting block_size above</span>
</span>
<span class="line" id="L544"> <span class="tok-comment">// assert((iterator.length() + 1)/block_size <= buffer_size);</span>
</span>
<span class="line" id="L545"></span>
<span class="line" id="L546"> <span class="tok-comment">// now that the two internal buffers have been created, it's time to merge each A+B combination at this level of the merge sort!</span>
</span>
<span class="line" id="L547"> iterator.begin();</span>
<span class="line" id="L548"> <span class="tok-kw">while</span> (!iterator.finished()) {</span>
<span class="line" id="L549"> A = iterator.nextRange();</span>
<span class="line" id="L550"> B = iterator.nextRange();</span>
<span class="line" id="L551"></span>
<span class="line" id="L552"> <span class="tok-comment">// remove any parts of A or B that are being used by the internal buffers</span>
</span>
<span class="line" id="L553"> start = A.start;</span>
<span class="line" id="L554"> <span class="tok-kw">if</span> (start == pull[<span class="tok-number">0</span>].range.start) {</span>
<span class="line" id="L555"> <span class="tok-kw">if</span> (pull[<span class="tok-number">0</span>].from > pull[<span class="tok-number">0</span>].to) {</span>
<span class="line" id="L556"> A.start += pull[<span class="tok-number">0</span>].count;</span>
<span class="line" id="L557"></span>
<span class="line" id="L558"> <span class="tok-comment">// if the internal buffer takes up the entire A or B subarray, then there's nothing to merge</span>
</span>
<span class="line" id="L559"> <span class="tok-comment">// this only happens for very small subarrays, like √4 = 2, 2 * (2 internal buffers) = 4,</span>
</span>
<span class="line" id="L560"> <span class="tok-comment">// which also only happens when cache.len is small or 0 since it'd otherwise use MergeExternal</span>
</span>
<span class="line" id="L561"> <span class="tok-kw">if</span> (A.length() == <span class="tok-number">0</span>) <span class="tok-kw">continue</span>;</span>
<span class="line" id="L562"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (pull[<span class="tok-number">0</span>].from < pull[<span class="tok-number">0</span>].to) {</span>
<span class="line" id="L563"> B.end -= pull[<span class="tok-number">0</span>].count;</span>
<span class="line" id="L564"> <span class="tok-kw">if</span> (B.length() == <span class="tok-number">0</span>) <span class="tok-kw">continue</span>;</span>
<span class="line" id="L565"> }</span>
<span class="line" id="L566"> }</span>
<span class="line" id="L567"> <span class="tok-kw">if</span> (start == pull[<span class="tok-number">1</span>].range.start) {</span>
<span class="line" id="L568"> <span class="tok-kw">if</span> (pull[<span class="tok-number">1</span>].from > pull[<span class="tok-number">1</span>].to) {</span>
<span class="line" id="L569"> A.start += pull[<span class="tok-number">1</span>].count;</span>
<span class="line" id="L570"> <span class="tok-kw">if</span> (A.length() == <span class="tok-number">0</span>) <span class="tok-kw">continue</span>;</span>
<span class="line" id="L571"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (pull[<span class="tok-number">1</span>].from < pull[<span class="tok-number">1</span>].to) {</span>
<span class="line" id="L572"> B.end -= pull[<span class="tok-number">1</span>].count;</span>
<span class="line" id="L573"> <span class="tok-kw">if</span> (B.length() == <span class="tok-number">0</span>) <span class="tok-kw">continue</span>;</span>
<span class="line" id="L574"> }</span>
<span class="line" id="L575"> }</span>
<span class="line" id="L576"></span>
<span class="line" id="L577"> <span class="tok-kw">if</span> (lessThan(context, items[B.end - <span class="tok-number">1</span>], items[A.start])) {</span>
<span class="line" id="L578"> <span class="tok-comment">// the two ranges are in reverse order, so a simple rotation should fix it</span>
</span>
<span class="line" id="L579"> mem.rotate(T, items[A.start..B.end], A.length());</span>
<span class="line" id="L580"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (lessThan(context, items[A.end], items[A.end - <span class="tok-number">1</span>])) {</span>
<span class="line" id="L581"> <span class="tok-comment">// these two ranges weren't already in order, so we'll need to merge them!</span>
</span>
<span class="line" id="L582"> <span class="tok-kw">var</span> findA: <span class="tok-type">usize</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L583"></span>
<span class="line" id="L584"> <span class="tok-comment">// break the remainder of A into blocks. firstA is the uneven-sized first A block</span>
</span>
<span class="line" id="L585"> <span class="tok-kw">var</span> blockA = Range.init(A.start, A.end);</span>
<span class="line" id="L586"> <span class="tok-kw">var</span> firstA = Range.init(A.start, A.start + blockA.length() % block_size);</span>
<span class="line" id="L587"></span>
<span class="line" id="L588"> <span class="tok-comment">// swap the first value of each A block with the value in buffer1</span>
</span>
<span class="line" id="L589"> <span class="tok-kw">var</span> indexA = buffer1.start;</span>
<span class="line" id="L590"> index = firstA.end;</span>
<span class="line" id="L591"> <span class="tok-kw">while</span> (index < blockA.end) : ({</span>
<span class="line" id="L592"> indexA += <span class="tok-number">1</span>;</span>
<span class="line" id="L593"> index += block_size;</span>
<span class="line" id="L594"> }) {</span>
<span class="line" id="L595"> mem.swap(T, &items[indexA], &items[index]);</span>
<span class="line" id="L596"> }</span>
<span class="line" id="L597"></span>
<span class="line" id="L598"> <span class="tok-comment">// start rolling the A blocks through the B blocks!</span>
</span>
<span class="line" id="L599"> <span class="tok-comment">// whenever we leave an A block behind, we'll need to merge the previous A block with any B blocks that follow it, so track that information as well</span>
</span>
<span class="line" id="L600"> <span class="tok-kw">var</span> lastA = firstA;</span>
<span class="line" id="L601"> <span class="tok-kw">var</span> lastB = Range.init(<span class="tok-number">0</span>, <span class="tok-number">0</span>);</span>
<span class="line" id="L602"> <span class="tok-kw">var</span> blockB = Range.init(B.start, B.start + <span class="tok-builtin">@min</span>(block_size, B.length()));</span>
<span class="line" id="L603"> blockA.start += firstA.length();</span>
<span class="line" id="L604"> indexA = buffer1.start;</span>
<span class="line" id="L605"></span>
<span class="line" id="L606"> <span class="tok-comment">// if the first unevenly sized A block fits into the cache, copy it there for when we go to Merge it</span>
</span>
<span class="line" id="L607"> <span class="tok-comment">// otherwise, if the second buffer is available, block swap the contents into that</span>
</span>
<span class="line" id="L608"> <span class="tok-kw">if</span> (lastA.length() <= cache.len) {</span>
<span class="line" id="L609"> <span class="tok-kw">const</span> last_a_items = items[lastA.start..lastA.end];</span>
<span class="line" id="L610"> <span class="tok-builtin">@memcpy</span>(cache[<span class="tok-number">0</span>..last_a_items.len], last_a_items);</span>
<span class="line" id="L611"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (buffer2.length() > <span class="tok-number">0</span>) {</span>
<span class="line" id="L612"> blockSwap(T, items, lastA.start, buffer2.start, lastA.length());</span>
<span class="line" id="L613"> }</span>
<span class="line" id="L614"></span>
<span class="line" id="L615"> <span class="tok-kw">if</span> (blockA.length() > <span class="tok-number">0</span>) {</span>
<span class="line" id="L616"> <span class="tok-kw">while</span> (<span class="tok-null">true</span>) {</span>
<span class="line" id="L617"> <span class="tok-comment">// if there's a previous B block and the first value of the minimum A block is <= the last value of the previous B block,</span>
</span>
<span class="line" id="L618"> <span class="tok-comment">// then drop that minimum A block behind. or if there are no B blocks left then keep dropping the remaining A blocks.</span>
</span>
<span class="line" id="L619"> <span class="tok-kw">if</span> ((lastB.length() > <span class="tok-number">0</span> <span class="tok-kw">and</span> !lessThan(context, items[lastB.end - <span class="tok-number">1</span>], items[indexA])) <span class="tok-kw">or</span> blockB.length() == <span class="tok-number">0</span>) {</span>
<span class="line" id="L620"> <span class="tok-comment">// figure out where to split the previous B block, and rotate it at the split</span>
</span>
<span class="line" id="L621"> <span class="tok-kw">const</span> B_split = binaryFirst(T, items, items[indexA], lastB, context, lessThan);</span>
<span class="line" id="L622"> <span class="tok-kw">const</span> B_remaining = lastB.end - B_split;</span>
<span class="line" id="L623"></span>
<span class="line" id="L624"> <span class="tok-comment">// swap the minimum A block to the beginning of the rolling A blocks</span>
</span>
<span class="line" id="L625"> <span class="tok-kw">var</span> minA = blockA.start;</span>
<span class="line" id="L626"> findA = minA + block_size;</span>
<span class="line" id="L627"> <span class="tok-kw">while</span> (findA < blockA.end) : (findA += block_size) {</span>
<span class="line" id="L628"> <span class="tok-kw">if</span> (lessThan(context, items[findA], items[minA])) {</span>
<span class="line" id="L629"> minA = findA;</span>
<span class="line" id="L630"> }</span>
<span class="line" id="L631"> }</span>
<span class="line" id="L632"> blockSwap(T, items, blockA.start, minA, block_size);</span>
<span class="line" id="L633"></span>
<span class="line" id="L634"> <span class="tok-comment">// swap the first item of the previous A block back with its original value, which is stored in buffer1</span>
</span>
<span class="line" id="L635"> mem.swap(T, &items[blockA.start], &items[indexA]);</span>
<span class="line" id="L636"> indexA += <span class="tok-number">1</span>;</span>
<span class="line" id="L637"></span>
<span class="line" id="L638"> <span class="tok-comment">// locally merge the previous A block with the B values that follow it</span>
</span>
<span class="line" id="L639"> <span class="tok-comment">// if lastA fits into the external cache we'll use that (with MergeExternal),</span>
</span>
<span class="line" id="L640"> <span class="tok-comment">// or if the second internal buffer exists we'll use that (with MergeInternal),</span>
</span>
<span class="line" id="L641"> <span class="tok-comment">// or failing that we'll use a strictly in-place merge algorithm (MergeInPlace)</span>
</span>
<span class="line" id="L642"></span>
<span class="line" id="L643"> <span class="tok-kw">if</span> (lastA.length() <= cache.len) {</span>
<span class="line" id="L644"> mergeExternal(T, items, lastA, Range.init(lastA.end, B_split), cache[<span class="tok-number">0</span>..], context, lessThan);</span>
<span class="line" id="L645"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (buffer2.length() > <span class="tok-number">0</span>) {</span>
<span class="line" id="L646"> mergeInternal(T, items, lastA, Range.init(lastA.end, B_split), buffer2, context, lessThan);</span>
<span class="line" id="L647"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L648"> mergeInPlace(T, items, lastA, Range.init(lastA.end, B_split), context, lessThan);</span>
<span class="line" id="L649"> }</span>
<span class="line" id="L650"></span>
<span class="line" id="L651"> <span class="tok-kw">if</span> (buffer2.length() > <span class="tok-number">0</span> <span class="tok-kw">or</span> block_size <= cache.len) {</span>
<span class="line" id="L652"> <span class="tok-comment">// copy the previous A block into the cache or buffer2, since that's where we need it to be when we go to merge it anyway</span>
</span>
<span class="line" id="L653"> <span class="tok-kw">if</span> (block_size <= cache.len) {</span>
<span class="line" id="L654"> <span class="tok-builtin">@memcpy</span>(cache[<span class="tok-number">0</span>..block_size], items[blockA.start..][<span class="tok-number">0</span>..block_size]);</span>
<span class="line" id="L655"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L656"> blockSwap(T, items, blockA.start, buffer2.start, block_size);</span>
<span class="line" id="L657"> }</span>
<span class="line" id="L658"></span>
<span class="line" id="L659"> <span class="tok-comment">// this is equivalent to rotating, but faster</span>
</span>
<span class="line" id="L660"> <span class="tok-comment">// the area normally taken up by the A block is either the contents of buffer2, or data we don't need anymore since we memcopied it</span>
</span>
<span class="line" id="L661"> <span class="tok-comment">// either way, we don't need to retain the order of those items, so instead of rotating we can just block swap B to where it belongs</span>
</span>
<span class="line" id="L662"> blockSwap(T, items, B_split, blockA.start + block_size - B_remaining, B_remaining);</span>
<span class="line" id="L663"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L664"> <span class="tok-comment">// we are unable to use the 'buffer2' trick to speed up the rotation operation since buffer2 doesn't exist, so perform a normal rotation</span>
</span>
<span class="line" id="L665"> mem.rotate(T, items[B_split .. blockA.start + block_size], blockA.start - B_split);</span>
<span class="line" id="L666"> }</span>
<span class="line" id="L667"></span>
<span class="line" id="L668"> <span class="tok-comment">// update the range for the remaining A blocks, and the range remaining from the B block after it was split</span>
</span>
<span class="line" id="L669"> lastA = Range.init(blockA.start - B_remaining, blockA.start - B_remaining + block_size);</span>
<span class="line" id="L670"> lastB = Range.init(lastA.end, lastA.end + B_remaining);</span>
<span class="line" id="L671"></span>
<span class="line" id="L672"> <span class="tok-comment">// if there are no more A blocks remaining, this step is finished!</span>
</span>
<span class="line" id="L673"> blockA.start += block_size;</span>
<span class="line" id="L674"> <span class="tok-kw">if</span> (blockA.length() == <span class="tok-number">0</span>) <span class="tok-kw">break</span>;</span>
<span class="line" id="L675"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (blockB.length() < block_size) {</span>
<span class="line" id="L676"> <span class="tok-comment">// move the last B block, which is unevenly sized, to before the remaining A blocks, by using a rotation</span>
</span>
<span class="line" id="L677"> <span class="tok-comment">// the cache is disabled here since it might contain the contents of the previous A block</span>
</span>
<span class="line" id="L678"> mem.rotate(T, items[blockA.start..blockB.end], blockB.start - blockA.start);</span>
<span class="line" id="L679"></span>
<span class="line" id="L680"> lastB = Range.init(blockA.start, blockA.start + blockB.length());</span>
<span class="line" id="L681"> blockA.start += blockB.length();</span>
<span class="line" id="L682"> blockA.end += blockB.length();</span>
<span class="line" id="L683"> blockB.end = blockB.start;</span>
<span class="line" id="L684"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L685"> <span class="tok-comment">// roll the leftmost A block to the end by swapping it with the next B block</span>
</span>
<span class="line" id="L686"> blockSwap(T, items, blockA.start, blockB.start, block_size);</span>
<span class="line" id="L687"> lastB = Range.init(blockA.start, blockA.start + block_size);</span>
<span class="line" id="L688"></span>
<span class="line" id="L689"> blockA.start += block_size;</span>
<span class="line" id="L690"> blockA.end += block_size;</span>
<span class="line" id="L691"> blockB.start += block_size;</span>
<span class="line" id="L692"></span>
<span class="line" id="L693"> <span class="tok-kw">if</span> (blockB.end > B.end - block_size) {</span>
<span class="line" id="L694"> blockB.end = B.end;</span>
<span class="line" id="L695"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L696"> blockB.end += block_size;</span>
<span class="line" id="L697"> }</span>
<span class="line" id="L698"> }</span>
<span class="line" id="L699"> }</span>
<span class="line" id="L700"> }</span>
<span class="line" id="L701"></span>
<span class="line" id="L702"> <span class="tok-comment">// merge the last A block with the remaining B values</span>
</span>
<span class="line" id="L703"> <span class="tok-kw">if</span> (lastA.length() <= cache.len) {</span>
<span class="line" id="L704"> mergeExternal(T, items, lastA, Range.init(lastA.end, B.end), cache[<span class="tok-number">0</span>..], context, lessThan);</span>
<span class="line" id="L705"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (buffer2.length() > <span class="tok-number">0</span>) {</span>
<span class="line" id="L706"> mergeInternal(T, items, lastA, Range.init(lastA.end, B.end), buffer2, context, lessThan);</span>
<span class="line" id="L707"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L708"> mergeInPlace(T, items, lastA, Range.init(lastA.end, B.end), context, lessThan);</span>
<span class="line" id="L709"> }</span>
<span class="line" id="L710"> }</span>
<span class="line" id="L711"> }</span>
<span class="line" id="L712"></span>
<span class="line" id="L713"> <span class="tok-comment">// when we're finished with this merge step we should have the one</span>
</span>
<span class="line" id="L714"> <span class="tok-comment">// or two internal buffers left over, where the second buffer is all jumbled up</span>
</span>
<span class="line" id="L715"> <span class="tok-comment">// insertion sort the second buffer, then redistribute the buffers</span>
</span>
<span class="line" id="L716"> <span class="tok-comment">// back into the items using the opposite process used for creating the buffer</span>
</span>
<span class="line" id="L717"></span>
<span class="line" id="L718"> <span class="tok-comment">// while an unstable sort like quicksort could be applied here, in benchmarks</span>
</span>
<span class="line" id="L719"> <span class="tok-comment">// it was consistently slightly slower than a simple insertion sort,</span>
</span>
<span class="line" id="L720"> <span class="tok-comment">// even for tens of millions of items. this may be because insertion</span>
</span>
<span class="line" id="L721"> <span class="tok-comment">// sort is quite fast when the data is already somewhat sorted, like it is here</span>
</span>
<span class="line" id="L722"> sort.insertion(T, items[buffer2.start..buffer2.end], context, lessThan);</span>
<span class="line" id="L723"></span>
<span class="line" id="L724"> pull_index = <span class="tok-number">0</span>;</span>
<span class="line" id="L725"> <span class="tok-kw">while</span> (pull_index < <span class="tok-number">2</span>) : (pull_index += <span class="tok-number">1</span>) {</span>
<span class="line" id="L726"> <span class="tok-kw">var</span> unique = pull[pull_index].count * <span class="tok-number">2</span>;</span>
<span class="line" id="L727"> <span class="tok-kw">if</span> (pull[pull_index].from > pull[pull_index].to) {</span>
<span class="line" id="L728"> <span class="tok-comment">// the values were pulled out to the left, so redistribute them back to the right</span>
</span>
<span class="line" id="L729"> <span class="tok-kw">var</span> buffer = Range.init(pull[pull_index].range.start, pull[pull_index].range.start + pull[pull_index].count);</span>
<span class="line" id="L730"> <span class="tok-kw">while</span> (buffer.length() > <span class="tok-number">0</span>) {</span>
<span class="line" id="L731"> index = findFirstForward(T, items, items[buffer.start], Range.init(buffer.end, pull[pull_index].range.end), unique, context, lessThan);</span>
<span class="line" id="L732"> <span class="tok-kw">const</span> amount = index - buffer.end;</span>
<span class="line" id="L733"> mem.rotate(T, items[buffer.start..index], buffer.length());</span>
<span class="line" id="L734"> buffer.start += (amount + <span class="tok-number">1</span>);</span>
<span class="line" id="L735"> buffer.end += amount;</span>
<span class="line" id="L736"> unique -= <span class="tok-number">2</span>;</span>
<span class="line" id="L737"> }</span>
<span class="line" id="L738"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (pull[pull_index].from < pull[pull_index].to) {</span>
<span class="line" id="L739"> <span class="tok-comment">// the values were pulled out to the right, so redistribute them back to the left</span>
</span>
<span class="line" id="L740"> <span class="tok-kw">var</span> buffer = Range.init(pull[pull_index].range.end - pull[pull_index].count, pull[pull_index].range.end);</span>
<span class="line" id="L741"> <span class="tok-kw">while</span> (buffer.length() > <span class="tok-number">0</span>) {</span>
<span class="line" id="L742"> index = findLastBackward(T, items, items[buffer.end - <span class="tok-number">1</span>], Range.init(pull[pull_index].range.start, buffer.start), unique, context, lessThan);</span>
<span class="line" id="L743"> <span class="tok-kw">const</span> amount = buffer.start - index;</span>
<span class="line" id="L744"> mem.rotate(T, items[index..buffer.end], amount);</span>
<span class="line" id="L745"> buffer.start -= amount;</span>
<span class="line" id="L746"> buffer.end -= (amount + <span class="tok-number">1</span>);</span>
<span class="line" id="L747"> unique -= <span class="tok-number">2</span>;</span>
<span class="line" id="L748"> }</span>
<span class="line" id="L749"> }</span>
<span class="line" id="L750"> }</span>
<span class="line" id="L751"> }</span>
<span class="line" id="L752"></span>
<span class="line" id="L753"> <span class="tok-comment">// double the size of each A and B subarray that will be merged in the next level</span>
</span>
<span class="line" id="L754"> <span class="tok-kw">if</span> (!iterator.nextLevel()) <span class="tok-kw">break</span>;</span>
<span class="line" id="L755"> }</span>
<span class="line" id="L756">}</span>
<span class="line" id="L757"><span class="tok-comment">// merge operation without a buffer</span>
</span>
<span class="line" id="L758"><span class="tok-kw">fn</span> <span class="tok-fn">mergeInPlace</span>(</span>
<span class="line" id="L759"> <span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>,</span>
<span class="line" id="L760"> items: []T,</span>
<span class="line" id="L761"> A_arg: Range,</span>
<span class="line" id="L762"> B_arg: Range,</span>
<span class="line" id="L763"> context: <span class="tok-kw">anytype</span>,</span>
<span class="line" id="L764"> <span class="tok-kw">comptime</span> lessThan: <span class="tok-kw">fn</span> (<span class="tok-builtin">@TypeOf</span>(context), lhs: T, rhs: T) <span class="tok-type">bool</span>,</span>
<span class="line" id="L765">) <span class="tok-type">void</span> {</span>
<span class="line" id="L766"> <span class="tok-kw">if</span> (A_arg.length() == <span class="tok-number">0</span> <span class="tok-kw">or</span> B_arg.length() == <span class="tok-number">0</span>) <span class="tok-kw">return</span>;</span>
<span class="line" id="L767"></span>
<span class="line" id="L768"> <span class="tok-comment">// this just repeatedly binary searches into B and rotates A into position.</span>
</span>
<span class="line" id="L769"> <span class="tok-comment">// the paper suggests using the 'rotation-based Hwang and Lin algorithm' here,</span>
</span>
<span class="line" id="L770"> <span class="tok-comment">// but I decided to stick with this because it had better situational performance</span>
</span>
<span class="line" id="L771"> <span class="tok-comment">//</span>
</span>
<span class="line" id="L772"> <span class="tok-comment">// (Hwang and Lin is designed for merging subarrays of very different sizes,</span>
</span>
<span class="line" id="L773"> <span class="tok-comment">// but WikiSort almost always uses subarrays that are roughly the same size)</span>
</span>
<span class="line" id="L774"> <span class="tok-comment">//</span>
</span>
<span class="line" id="L775"> <span class="tok-comment">// normally this is incredibly suboptimal, but this function is only called</span>
</span>
<span class="line" id="L776"> <span class="tok-comment">// when none of the A or B blocks in any subarray contained 2√A unique values,</span>
</span>
<span class="line" id="L777"> <span class="tok-comment">// which places a hard limit on the number of times this will ACTUALLY need</span>
</span>
<span class="line" id="L778"> <span class="tok-comment">// to binary search and rotate.</span>
</span>
<span class="line" id="L779"> <span class="tok-comment">//</span>
</span>
<span class="line" id="L780"> <span class="tok-comment">// according to my analysis the worst case is √A rotations performed on √A items</span>
</span>
<span class="line" id="L781"> <span class="tok-comment">// once the constant factors are removed, which ends up being O(n)</span>
</span>
<span class="line" id="L782"> <span class="tok-comment">//</span>
</span>
<span class="line" id="L783"> <span class="tok-comment">// again, this is NOT a general-purpose solution – it only works well in this case!</span>
</span>
<span class="line" id="L784"> <span class="tok-comment">// kind of like how the O(n^2) insertion sort is used in some places</span>
</span>
<span class="line" id="L785"></span>
<span class="line" id="L786"> <span class="tok-kw">var</span> A = A_arg;</span>
<span class="line" id="L787"> <span class="tok-kw">var</span> B = B_arg;</span>
<span class="line" id="L788"></span>
<span class="line" id="L789"> <span class="tok-kw">while</span> (<span class="tok-null">true</span>) {</span>
<span class="line" id="L790"> <span class="tok-comment">// find the first place in B where the first item in A needs to be inserted</span>
</span>
<span class="line" id="L791"> <span class="tok-kw">const</span> mid = binaryFirst(T, items, items[A.start], B, context, lessThan);</span>
<span class="line" id="L792"></span>
<span class="line" id="L793"> <span class="tok-comment">// rotate A into place</span>
</span>
<span class="line" id="L794"> <span class="tok-kw">const</span> amount = mid - A.end;</span>
<span class="line" id="L795"> mem.rotate(T, items[A.start..mid], A.length());</span>
<span class="line" id="L796"> <span class="tok-kw">if</span> (B.end == mid) <span class="tok-kw">break</span>;</span>
<span class="line" id="L797"></span>
<span class="line" id="L798"> <span class="tok-comment">// calculate the new A and B ranges</span>
</span>
<span class="line" id="L799"> B.start = mid;</span>
<span class="line" id="L800"> A = Range.init(A.start + amount, B.start);</span>
<span class="line" id="L801"> A.start = binaryLast(T, items, items[A.start], A, context, lessThan);</span>
<span class="line" id="L802"> <span class="tok-kw">if</span> (A.length() == <span class="tok-number">0</span>) <span class="tok-kw">break</span>;</span>
<span class="line" id="L803"> }</span>
<span class="line" id="L804">}</span>
<span class="line" id="L805"></span>
<span class="line" id="L806"><span class="tok-comment">// merge operation using an internal buffer</span>
</span>
<span class="line" id="L807"><span class="tok-kw">fn</span> <span class="tok-fn">mergeInternal</span>(</span>
<span class="line" id="L808"> <span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>,</span>
<span class="line" id="L809"> items: []T,</span>
<span class="line" id="L810"> A: Range,</span>
<span class="line" id="L811"> B: Range,</span>
<span class="line" id="L812"> buffer: Range,</span>
<span class="line" id="L813"> context: <span class="tok-kw">anytype</span>,</span>
<span class="line" id="L814"> <span class="tok-kw">comptime</span> lessThan: <span class="tok-kw">fn</span> (<span class="tok-builtin">@TypeOf</span>(context), lhs: T, rhs: T) <span class="tok-type">bool</span>,</span>
<span class="line" id="L815">) <span class="tok-type">void</span> {</span>
<span class="line" id="L816"> <span class="tok-comment">// whenever we find a value to add to the final array, swap it with the value that's already in that spot</span>
</span>
<span class="line" id="L817"> <span class="tok-comment">// when this algorithm is finished, 'buffer' will contain its original contents, but in a different order</span>
</span>
<span class="line" id="L818"> <span class="tok-kw">var</span> A_count: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L819"> <span class="tok-kw">var</span> B_count: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L820"> <span class="tok-kw">var</span> insert: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L821"></span>
<span class="line" id="L822"> <span class="tok-kw">if</span> (B.length() > <span class="tok-number">0</span> <span class="tok-kw">and</span> A.length() > <span class="tok-number">0</span>) {</span>
<span class="line" id="L823"> <span class="tok-kw">while</span> (<span class="tok-null">true</span>) {</span>
<span class="line" id="L824"> <span class="tok-kw">if</span> (!lessThan(context, items[B.start + B_count], items[buffer.start + A_count])) {</span>
<span class="line" id="L825"> mem.swap(T, &items[A.start + insert], &items[buffer.start + A_count]);</span>
<span class="line" id="L826"> A_count += <span class="tok-number">1</span>;</span>
<span class="line" id="L827"> insert += <span class="tok-number">1</span>;</span>
<span class="line" id="L828"> <span class="tok-kw">if</span> (A_count >= A.length()) <span class="tok-kw">break</span>;</span>
<span class="line" id="L829"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L830"> mem.swap(T, &items[A.start + insert], &items[B.start + B_count]);</span>
<span class="line" id="L831"> B_count += <span class="tok-number">1</span>;</span>
<span class="line" id="L832"> insert += <span class="tok-number">1</span>;</span>
<span class="line" id="L833"> <span class="tok-kw">if</span> (B_count >= B.length()) <span class="tok-kw">break</span>;</span>
<span class="line" id="L834"> }</span>
<span class="line" id="L835"> }</span>
<span class="line" id="L836"> }</span>
<span class="line" id="L837"></span>
<span class="line" id="L838"> <span class="tok-comment">// swap the remainder of A into the final array</span>
</span>
<span class="line" id="L839"> blockSwap(T, items, buffer.start + A_count, A.start + insert, A.length() - A_count);</span>
<span class="line" id="L840">}</span>
<span class="line" id="L841"></span>
<span class="line" id="L842"><span class="tok-kw">fn</span> <span class="tok-fn">blockSwap</span>(<span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>, items: []T, start1: <span class="tok-type">usize</span>, start2: <span class="tok-type">usize</span>, block_size: <span class="tok-type">usize</span>) <span class="tok-type">void</span> {</span>
<span class="line" id="L843"> <span class="tok-kw">var</span> index: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L844"> <span class="tok-kw">while</span> (index < block_size) : (index += <span class="tok-number">1</span>) {</span>
<span class="line" id="L845"> mem.swap(T, &items[start1 + index], &items[start2 + index]);</span>
<span class="line" id="L846"> }</span>
<span class="line" id="L847">}</span>
<span class="line" id="L848"></span>
<span class="line" id="L849"><span class="tok-comment">// combine a linear search with a binary search to reduce the number of comparisons in situations</span>
</span>
<span class="line" id="L850"><span class="tok-comment">// where have some idea as to how many unique values there are and where the next value might be</span>
</span>
<span class="line" id="L851"><span class="tok-kw">fn</span> <span class="tok-fn">findFirstForward</span>(</span>
<span class="line" id="L852"> <span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>,</span>
<span class="line" id="L853"> items: []T,</span>
<span class="line" id="L854"> value: T,</span>
<span class="line" id="L855"> range: Range,</span>
<span class="line" id="L856"> unique: <span class="tok-type">usize</span>,</span>
<span class="line" id="L857"> context: <span class="tok-kw">anytype</span>,</span>
<span class="line" id="L858"> <span class="tok-kw">comptime</span> lessThan: <span class="tok-kw">fn</span> (<span class="tok-builtin">@TypeOf</span>(context), lhs: T, rhs: T) <span class="tok-type">bool</span>,</span>
<span class="line" id="L859">) <span class="tok-type">usize</span> {</span>
<span class="line" id="L860"> <span class="tok-kw">if</span> (range.length() == <span class="tok-number">0</span>) <span class="tok-kw">return</span> range.start;</span>
<span class="line" id="L861"> <span class="tok-kw">const</span> skip = <span class="tok-builtin">@max</span>(range.length() / unique, <span class="tok-builtin">@as</span>(<span class="tok-type">usize</span>, <span class="tok-number">1</span>));</span>
<span class="line" id="L862"></span>
<span class="line" id="L863"> <span class="tok-kw">var</span> index = range.start + skip;</span>
<span class="line" id="L864"> <span class="tok-kw">while</span> (lessThan(context, items[index - <span class="tok-number">1</span>], value)) : (index += skip) {</span>
<span class="line" id="L865"> <span class="tok-kw">if</span> (index >= range.end - skip) {</span>
<span class="line" id="L866"> <span class="tok-kw">return</span> binaryFirst(T, items, value, Range.init(index, range.end), context, lessThan);</span>
<span class="line" id="L867"> }</span>
<span class="line" id="L868"> }</span>
<span class="line" id="L869"></span>
<span class="line" id="L870"> <span class="tok-kw">return</span> binaryFirst(T, items, value, Range.init(index - skip, index), context, lessThan);</span>
<span class="line" id="L871">}</span>
<span class="line" id="L872"></span>
<span class="line" id="L873"><span class="tok-kw">fn</span> <span class="tok-fn">findFirstBackward</span>(</span>
<span class="line" id="L874"> <span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>,</span>
<span class="line" id="L875"> items: []T,</span>
<span class="line" id="L876"> value: T,</span>
<span class="line" id="L877"> range: Range,</span>
<span class="line" id="L878"> unique: <span class="tok-type">usize</span>,</span>
<span class="line" id="L879"> context: <span class="tok-kw">anytype</span>,</span>
<span class="line" id="L880"> <span class="tok-kw">comptime</span> lessThan: <span class="tok-kw">fn</span> (<span class="tok-builtin">@TypeOf</span>(context), lhs: T, rhs: T) <span class="tok-type">bool</span>,</span>
<span class="line" id="L881">) <span class="tok-type">usize</span> {</span>
<span class="line" id="L882"> <span class="tok-kw">if</span> (range.length() == <span class="tok-number">0</span>) <span class="tok-kw">return</span> range.start;</span>
<span class="line" id="L883"> <span class="tok-kw">const</span> skip = <span class="tok-builtin">@max</span>(range.length() / unique, <span class="tok-builtin">@as</span>(<span class="tok-type">usize</span>, <span class="tok-number">1</span>));</span>
<span class="line" id="L884"></span>
<span class="line" id="L885"> <span class="tok-kw">var</span> index = range.end - skip;</span>
<span class="line" id="L886"> <span class="tok-kw">while</span> (index > range.start <span class="tok-kw">and</span> !lessThan(context, items[index - <span class="tok-number">1</span>], value)) : (index -= skip) {</span>
<span class="line" id="L887"> <span class="tok-kw">if</span> (index < range.start + skip) {</span>
<span class="line" id="L888"> <span class="tok-kw">return</span> binaryFirst(T, items, value, Range.init(range.start, index), context, lessThan);</span>
<span class="line" id="L889"> }</span>
<span class="line" id="L890"> }</span>
<span class="line" id="L891"></span>
<span class="line" id="L892"> <span class="tok-kw">return</span> binaryFirst(T, items, value, Range.init(index, index + skip), context, lessThan);</span>
<span class="line" id="L893">}</span>
<span class="line" id="L894"></span>
<span class="line" id="L895"><span class="tok-kw">fn</span> <span class="tok-fn">findLastForward</span>(</span>
<span class="line" id="L896"> <span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>,</span>
<span class="line" id="L897"> items: []T,</span>
<span class="line" id="L898"> value: T,</span>
<span class="line" id="L899"> range: Range,</span>
<span class="line" id="L900"> unique: <span class="tok-type">usize</span>,</span>
<span class="line" id="L901"> context: <span class="tok-kw">anytype</span>,</span>
<span class="line" id="L902"> <span class="tok-kw">comptime</span> lessThan: <span class="tok-kw">fn</span> (<span class="tok-builtin">@TypeOf</span>(context), lhs: T, rhs: T) <span class="tok-type">bool</span>,</span>
<span class="line" id="L903">) <span class="tok-type">usize</span> {</span>
<span class="line" id="L904"> <span class="tok-kw">if</span> (range.length() == <span class="tok-number">0</span>) <span class="tok-kw">return</span> range.start;</span>
<span class="line" id="L905"> <span class="tok-kw">const</span> skip = <span class="tok-builtin">@max</span>(range.length() / unique, <span class="tok-builtin">@as</span>(<span class="tok-type">usize</span>, <span class="tok-number">1</span>));</span>
<span class="line" id="L906"></span>
<span class="line" id="L907"> <span class="tok-kw">var</span> index = range.start + skip;</span>
<span class="line" id="L908"> <span class="tok-kw">while</span> (!lessThan(context, value, items[index - <span class="tok-number">1</span>])) : (index += skip) {</span>
<span class="line" id="L909"> <span class="tok-kw">if</span> (index >= range.end - skip) {</span>
<span class="line" id="L910"> <span class="tok-kw">return</span> binaryLast(T, items, value, Range.init(index, range.end), context, lessThan);</span>
<span class="line" id="L911"> }</span>
<span class="line" id="L912"> }</span>
<span class="line" id="L913"></span>
<span class="line" id="L914"> <span class="tok-kw">return</span> binaryLast(T, items, value, Range.init(index - skip, index), context, lessThan);</span>
<span class="line" id="L915">}</span>
<span class="line" id="L916"></span>
<span class="line" id="L917"><span class="tok-kw">fn</span> <span class="tok-fn">findLastBackward</span>(</span>
<span class="line" id="L918"> <span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>,</span>
<span class="line" id="L919"> items: []T,</span>
<span class="line" id="L920"> value: T,</span>
<span class="line" id="L921"> range: Range,</span>
<span class="line" id="L922"> unique: <span class="tok-type">usize</span>,</span>
<span class="line" id="L923"> context: <span class="tok-kw">anytype</span>,</span>
<span class="line" id="L924"> <span class="tok-kw">comptime</span> lessThan: <span class="tok-kw">fn</span> (<span class="tok-builtin">@TypeOf</span>(context), lhs: T, rhs: T) <span class="tok-type">bool</span>,</span>
<span class="line" id="L925">) <span class="tok-type">usize</span> {</span>
<span class="line" id="L926"> <span class="tok-kw">if</span> (range.length() == <span class="tok-number">0</span>) <span class="tok-kw">return</span> range.start;</span>
<span class="line" id="L927"> <span class="tok-kw">const</span> skip = <span class="tok-builtin">@max</span>(range.length() / unique, <span class="tok-builtin">@as</span>(<span class="tok-type">usize</span>, <span class="tok-number">1</span>));</span>
<span class="line" id="L928"></span>
<span class="line" id="L929"> <span class="tok-kw">var</span> index = range.end - skip;</span>
<span class="line" id="L930"> <span class="tok-kw">while</span> (index > range.start <span class="tok-kw">and</span> lessThan(context, value, items[index - <span class="tok-number">1</span>])) : (index -= skip) {</span>
<span class="line" id="L931"> <span class="tok-kw">if</span> (index < range.start + skip) {</span>
<span class="line" id="L932"> <span class="tok-kw">return</span> binaryLast(T, items, value, Range.init(range.start, index), context, lessThan);</span>
<span class="line" id="L933"> }</span>
<span class="line" id="L934"> }</span>
<span class="line" id="L935"></span>
<span class="line" id="L936"> <span class="tok-kw">return</span> binaryLast(T, items, value, Range.init(index, index + skip), context, lessThan);</span>
<span class="line" id="L937">}</span>
<span class="line" id="L938"></span>
<span class="line" id="L939"><span class="tok-kw">fn</span> <span class="tok-fn">binaryFirst</span>(</span>
<span class="line" id="L940"> <span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>,</span>
<span class="line" id="L941"> items: []T,</span>
<span class="line" id="L942"> value: T,</span>
<span class="line" id="L943"> range: Range,</span>
<span class="line" id="L944"> context: <span class="tok-kw">anytype</span>,</span>
<span class="line" id="L945"> <span class="tok-kw">comptime</span> lessThan: <span class="tok-kw">fn</span> (<span class="tok-builtin">@TypeOf</span>(context), lhs: T, rhs: T) <span class="tok-type">bool</span>,</span>
<span class="line" id="L946">) <span class="tok-type">usize</span> {</span>
<span class="line" id="L947"> <span class="tok-kw">var</span> curr = range.start;</span>
<span class="line" id="L948"> <span class="tok-kw">var</span> size = range.length();</span>
<span class="line" id="L949"> <span class="tok-kw">if</span> (range.start >= range.end) <span class="tok-kw">return</span> range.end;</span>
<span class="line" id="L950"> <span class="tok-kw">while</span> (size > <span class="tok-number">0</span>) {</span>
<span class="line" id="L951"> <span class="tok-kw">const</span> offset = size % <span class="tok-number">2</span>;</span>
<span class="line" id="L952"></span>
<span class="line" id="L953"> size /= <span class="tok-number">2</span>;</span>
<span class="line" id="L954"> <span class="tok-kw">const</span> mid_item = items[curr + size];</span>
<span class="line" id="L955"> <span class="tok-kw">if</span> (lessThan(context, mid_item, value)) {</span>
<span class="line" id="L956"> curr += size + offset;</span>
<span class="line" id="L957"> }</span>
<span class="line" id="L958"> }</span>
<span class="line" id="L959"> <span class="tok-kw">return</span> curr;</span>
<span class="line" id="L960">}</span>
<span class="line" id="L961"></span>
<span class="line" id="L962"><span class="tok-kw">fn</span> <span class="tok-fn">binaryLast</span>(</span>
<span class="line" id="L963"> <span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>,</span>
<span class="line" id="L964"> items: []T,</span>
<span class="line" id="L965"> value: T,</span>
<span class="line" id="L966"> range: Range,</span>
<span class="line" id="L967"> context: <span class="tok-kw">anytype</span>,</span>
<span class="line" id="L968"> <span class="tok-kw">comptime</span> lessThan: <span class="tok-kw">fn</span> (<span class="tok-builtin">@TypeOf</span>(context), lhs: T, rhs: T) <span class="tok-type">bool</span>,</span>
<span class="line" id="L969">) <span class="tok-type">usize</span> {</span>
<span class="line" id="L970"> <span class="tok-kw">var</span> curr = range.start;</span>
<span class="line" id="L971"> <span class="tok-kw">var</span> size = range.length();</span>
<span class="line" id="L972"> <span class="tok-kw">if</span> (range.start >= range.end) <span class="tok-kw">return</span> range.end;</span>
<span class="line" id="L973"> <span class="tok-kw">while</span> (size > <span class="tok-number">0</span>) {</span>
<span class="line" id="L974"> <span class="tok-kw">const</span> offset = size % <span class="tok-number">2</span>;</span>
<span class="line" id="L975"></span>
<span class="line" id="L976"> size /= <span class="tok-number">2</span>;</span>
<span class="line" id="L977"> <span class="tok-kw">const</span> mid_item = items[curr + size];</span>
<span class="line" id="L978"> <span class="tok-kw">if</span> (!lessThan(context, value, mid_item)) {</span>
<span class="line" id="L979"> curr += size + offset;</span>
<span class="line" id="L980"> }</span>
<span class="line" id="L981"> }</span>
<span class="line" id="L982"> <span class="tok-kw">return</span> curr;</span>
<span class="line" id="L983">}</span>
<span class="line" id="L984"></span>
<span class="line" id="L985"><span class="tok-kw">fn</span> <span class="tok-fn">mergeInto</span>(</span>
<span class="line" id="L986"> <span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>,</span>
<span class="line" id="L987"> from: []T,</span>
<span class="line" id="L988"> A: Range,</span>
<span class="line" id="L989"> B: Range,</span>
<span class="line" id="L990"> into: []T,</span>
<span class="line" id="L991"> context: <span class="tok-kw">anytype</span>,</span>
<span class="line" id="L992"> <span class="tok-kw">comptime</span> lessThan: <span class="tok-kw">fn</span> (<span class="tok-builtin">@TypeOf</span>(context), lhs: T, rhs: T) <span class="tok-type">bool</span>,</span>
<span class="line" id="L993">) <span class="tok-type">void</span> {</span>
<span class="line" id="L994"> <span class="tok-kw">var</span> A_index: <span class="tok-type">usize</span> = A.start;</span>
<span class="line" id="L995"> <span class="tok-kw">var</span> B_index: <span class="tok-type">usize</span> = B.start;</span>
<span class="line" id="L996"> <span class="tok-kw">const</span> A_last = A.end;</span>
<span class="line" id="L997"> <span class="tok-kw">const</span> B_last = B.end;</span>
<span class="line" id="L998"> <span class="tok-kw">var</span> insert_index: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L999"></span>
<span class="line" id="L1000"> <span class="tok-kw">while</span> (<span class="tok-null">true</span>) {</span>
<span class="line" id="L1001"> <span class="tok-kw">if</span> (!lessThan(context, from[B_index], from[A_index])) {</span>
<span class="line" id="L1002"> into[insert_index] = from[A_index];</span>
<span class="line" id="L1003"> A_index += <span class="tok-number">1</span>;</span>
<span class="line" id="L1004"> insert_index += <span class="tok-number">1</span>;</span>
<span class="line" id="L1005"> <span class="tok-kw">if</span> (A_index == A_last) {</span>
<span class="line" id="L1006"> <span class="tok-comment">// copy the remainder of B into the final array</span>
</span>
<span class="line" id="L1007"> <span class="tok-kw">const</span> from_b = from[B_index..B_last];</span>
<span class="line" id="L1008"> <span class="tok-builtin">@memcpy</span>(into[insert_index..][<span class="tok-number">0</span>..from_b.len], from_b);</span>
<span class="line" id="L1009"> <span class="tok-kw">break</span>;</span>
<span class="line" id="L1010"> }</span>
<span class="line" id="L1011"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L1012"> into[insert_index] = from[B_index];</span>
<span class="line" id="L1013"> B_index += <span class="tok-number">1</span>;</span>
<span class="line" id="L1014"> insert_index += <span class="tok-number">1</span>;</span>
<span class="line" id="L1015"> <span class="tok-kw">if</span> (B_index == B_last) {</span>
<span class="line" id="L1016"> <span class="tok-comment">// copy the remainder of A into the final array</span>
</span>
<span class="line" id="L1017"> <span class="tok-kw">const</span> from_a = from[A_index..A_last];</span>
<span class="line" id="L1018"> <span class="tok-builtin">@memcpy</span>(into[insert_index..][<span class="tok-number">0</span>..from_a.len], from_a);</span>
<span class="line" id="L1019"> <span class="tok-kw">break</span>;</span>
<span class="line" id="L1020"> }</span>
<span class="line" id="L1021"> }</span>
<span class="line" id="L1022"> }</span>
<span class="line" id="L1023">}</span>
<span class="line" id="L1024"></span>
<span class="line" id="L1025"><span class="tok-kw">fn</span> <span class="tok-fn">mergeExternal</span>(</span>
<span class="line" id="L1026"> <span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>,</span>
<span class="line" id="L1027"> items: []T,</span>
<span class="line" id="L1028"> A: Range,</span>
<span class="line" id="L1029"> B: Range,</span>
<span class="line" id="L1030"> cache: []T,</span>
<span class="line" id="L1031"> context: <span class="tok-kw">anytype</span>,</span>
<span class="line" id="L1032"> <span class="tok-kw">comptime</span> lessThan: <span class="tok-kw">fn</span> (<span class="tok-builtin">@TypeOf</span>(context), lhs: T, rhs: T) <span class="tok-type">bool</span>,</span>
<span class="line" id="L1033">) <span class="tok-type">void</span> {</span>
<span class="line" id="L1034"> <span class="tok-comment">// A fits into the cache, so use that instead of the internal buffer</span>
</span>
<span class="line" id="L1035"> <span class="tok-kw">var</span> A_index: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L1036"> <span class="tok-kw">var</span> B_index: <span class="tok-type">usize</span> = B.start;</span>
<span class="line" id="L1037"> <span class="tok-kw">var</span> insert_index: <span class="tok-type">usize</span> = A.start;</span>
<span class="line" id="L1038"> <span class="tok-kw">const</span> A_last = A.length();</span>
<span class="line" id="L1039"> <span class="tok-kw">const</span> B_last = B.end;</span>
<span class="line" id="L1040"></span>
<span class="line" id="L1041"> <span class="tok-kw">if</span> (B.length() > <span class="tok-number">0</span> <span class="tok-kw">and</span> A.length() > <span class="tok-number">0</span>) {</span>
<span class="line" id="L1042"> <span class="tok-kw">while</span> (<span class="tok-null">true</span>) {</span>
<span class="line" id="L1043"> <span class="tok-kw">if</span> (!lessThan(context, items[B_index], cache[A_index])) {</span>
<span class="line" id="L1044"> items[insert_index] = cache[A_index];</span>
<span class="line" id="L1045"> A_index += <span class="tok-number">1</span>;</span>
<span class="line" id="L1046"> insert_index += <span class="tok-number">1</span>;</span>
<span class="line" id="L1047"> <span class="tok-kw">if</span> (A_index == A_last) <span class="tok-kw">break</span>;</span>
<span class="line" id="L1048"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L1049"> items[insert_index] = items[B_index];</span>
<span class="line" id="L1050"> B_index += <span class="tok-number">1</span>;</span>
<span class="line" id="L1051"> insert_index += <span class="tok-number">1</span>;</span>
<span class="line" id="L1052"> <span class="tok-kw">if</span> (B_index == B_last) <span class="tok-kw">break</span>;</span>
<span class="line" id="L1053"> }</span>
<span class="line" id="L1054"> }</span>
<span class="line" id="L1055"> }</span>
<span class="line" id="L1056"></span>
<span class="line" id="L1057"> <span class="tok-comment">// copy the remainder of A into the final array</span>
</span>
<span class="line" id="L1058"> <span class="tok-kw">const</span> cache_a = cache[A_index..A_last];</span>
<span class="line" id="L1059"> <span class="tok-builtin">@memcpy</span>(items[insert_index..][<span class="tok-number">0</span>..cache_a.len], cache_a);</span>
<span class="line" id="L1060">}</span>
<span class="line" id="L1061"></span>
<span class="line" id="L1062"><span class="tok-kw">fn</span> <span class="tok-fn">swap</span>(</span>
<span class="line" id="L1063"> <span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>,</span>
<span class="line" id="L1064"> items: []T,</span>
<span class="line" id="L1065"> order: *[<span class="tok-number">8</span>]<span class="tok-type">u8</span>,</span>
<span class="line" id="L1066"> x: <span class="tok-type">usize</span>,</span>
<span class="line" id="L1067"> y: <span class="tok-type">usize</span>,</span>
<span class="line" id="L1068"> context: <span class="tok-kw">anytype</span>,</span>
<span class="line" id="L1069"> <span class="tok-kw">comptime</span> lessThan: <span class="tok-kw">fn</span> (<span class="tok-builtin">@TypeOf</span>(context), lhs: T, rhs: T) <span class="tok-type">bool</span>,</span>
<span class="line" id="L1070">) <span class="tok-type">void</span> {</span>
<span class="line" id="L1071"> <span class="tok-kw">if</span> (lessThan(context, items[y], items[x]) <span class="tok-kw">or</span> ((order.*)[x] > (order.*)[y] <span class="tok-kw">and</span> !lessThan(context, items[x], items[y]))) {</span>
<span class="line" id="L1072"> mem.swap(T, &items[x], &items[y]);</span>
<span class="line" id="L1073"> mem.swap(<span class="tok-type">u8</span>, &(order.*)[x], &(order.*)[y]);</span>
<span class="line" id="L1074"> }</span>
<span class="line" id="L1075">}</span>
<span class="line" id="L1076"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/meta/trait.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>meta/trait.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../std.zig"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> mem = std.mem;</span>
<span class="line" id="L3"><span class="tok-kw">const</span> debug = std.debug;</span>
<span class="line" id="L4"><span class="tok-kw">const</span> testing = std.testing;</span>
<span class="line" id="L5"></span>
<span class="line" id="L6"><span class="tok-kw">const</span> meta = <span class="tok-builtin">@import</span>(<span class="tok-str">"../meta.zig"</span>);</span>
<span class="line" id="L7"></span>
<span class="line" id="L8"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> TraitFn = <span class="tok-kw">fn</span> (<span class="tok-type">type</span>) <span class="tok-type">bool</span>;</span>
<span class="line" id="L9"></span>
<span class="line" id="L10"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">multiTrait</span>(<span class="tok-kw">comptime</span> traits: <span class="tok-kw">anytype</span>) TraitFn {</span>
<span class="line" id="L11"> <span class="tok-kw">const</span> Closure = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L12"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">trait</span>(<span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>) <span class="tok-type">bool</span> {</span>
<span class="line" id="L13"> <span class="tok-kw">inline</span> <span class="tok-kw">for</span> (traits) |t|</span>
<span class="line" id="L14"> <span class="tok-kw">if</span> (!t(T)) <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L15"> <span class="tok-kw">return</span> <span class="tok-null">true</span>;</span>
<span class="line" id="L16"> }</span>
<span class="line" id="L17"> };</span>
<span class="line" id="L18"> <span class="tok-kw">return</span> Closure.trait;</span>
<span class="line" id="L19">}</span>
<span class="line" id="L20"></span>
<span class="line" id="L21"><span class="tok-kw">test</span> <span class="tok-str">"multiTrait"</span> {</span>
<span class="line" id="L22"> <span class="tok-kw">const</span> Vector2 = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L23"> <span class="tok-kw">const</span> MyType = <span class="tok-builtin">@This</span>();</span>
<span class="line" id="L24"></span>
<span class="line" id="L25"> x: <span class="tok-type">u8</span>,</span>
<span class="line" id="L26"> y: <span class="tok-type">u8</span>,</span>
<span class="line" id="L27"></span>
<span class="line" id="L28"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">add</span>(self: MyType, other: MyType) MyType {</span>
<span class="line" id="L29"> <span class="tok-kw">return</span> MyType{</span>
<span class="line" id="L30"> .x = self.x + other.x,</span>
<span class="line" id="L31"> .y = self.y + other.y,</span>
<span class="line" id="L32"> };</span>
<span class="line" id="L33"> }</span>
<span class="line" id="L34"> };</span>
<span class="line" id="L35"></span>
<span class="line" id="L36"> <span class="tok-kw">const</span> isVector = multiTrait(.{</span>
<span class="line" id="L37"> hasFn(<span class="tok-str">"add"</span>),</span>
<span class="line" id="L38"> hasField(<span class="tok-str">"x"</span>),</span>
<span class="line" id="L39"> hasField(<span class="tok-str">"y"</span>),</span>
<span class="line" id="L40"> });</span>
<span class="line" id="L41"> <span class="tok-kw">try</span> testing.expect(isVector(Vector2));</span>
<span class="line" id="L42"> <span class="tok-kw">try</span> testing.expect(!isVector(<span class="tok-type">u8</span>));</span>
<span class="line" id="L43">}</span>
<span class="line" id="L44"></span>
<span class="line" id="L45"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">hasFn</span>(<span class="tok-kw">comptime</span> name: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) TraitFn {</span>
<span class="line" id="L46"> <span class="tok-kw">const</span> Closure = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L47"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">trait</span>(<span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>) <span class="tok-type">bool</span> {</span>
<span class="line" id="L48"> <span class="tok-kw">if</span> (!<span class="tok-kw">comptime</span> isContainer(T)) <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L49"> <span class="tok-kw">if</span> (!<span class="tok-kw">comptime</span> <span class="tok-builtin">@hasDecl</span>(T, name)) <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L50"> <span class="tok-kw">const</span> DeclType = <span class="tok-builtin">@TypeOf</span>(<span class="tok-builtin">@field</span>(T, name));</span>
<span class="line" id="L51"> <span class="tok-kw">return</span> <span class="tok-builtin">@typeInfo</span>(DeclType) == .Fn;</span>
<span class="line" id="L52"> }</span>
<span class="line" id="L53"> };</span>
<span class="line" id="L54"> <span class="tok-kw">return</span> Closure.trait;</span>
<span class="line" id="L55">}</span>
<span class="line" id="L56"></span>
<span class="line" id="L57"><span class="tok-kw">test</span> <span class="tok-str">"hasFn"</span> {</span>
<span class="line" id="L58"> <span class="tok-kw">const</span> TestStruct = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L59"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">useless</span>() <span class="tok-type">void</span> {}</span>
<span class="line" id="L60"> };</span>
<span class="line" id="L61"></span>
<span class="line" id="L62"> <span class="tok-kw">try</span> testing.expect(hasFn(<span class="tok-str">"useless"</span>)(TestStruct));</span>
<span class="line" id="L63"> <span class="tok-kw">try</span> testing.expect(!hasFn(<span class="tok-str">"append"</span>)(TestStruct));</span>
<span class="line" id="L64"> <span class="tok-kw">try</span> testing.expect(!hasFn(<span class="tok-str">"useless"</span>)(<span class="tok-type">u8</span>));</span>
<span class="line" id="L65">}</span>
<span class="line" id="L66"></span>
<span class="line" id="L67"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">hasField</span>(<span class="tok-kw">comptime</span> name: []<span class="tok-kw">const</span> <span class="tok-type">u8</span>) TraitFn {</span>
<span class="line" id="L68"> <span class="tok-kw">const</span> Closure = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L69"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">trait</span>(<span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>) <span class="tok-type">bool</span> {</span>
<span class="line" id="L70"> <span class="tok-kw">const</span> fields = <span class="tok-kw">switch</span> (<span class="tok-builtin">@typeInfo</span>(T)) {</span>
<span class="line" id="L71"> .Struct => |s| s.fields,</span>
<span class="line" id="L72"> .Union => |u| u.fields,</span>
<span class="line" id="L73"> .Enum => |e| e.fields,</span>
<span class="line" id="L74"> <span class="tok-kw">else</span> => <span class="tok-kw">return</span> <span class="tok-null">false</span>,</span>
<span class="line" id="L75"> };</span>
<span class="line" id="L76"></span>
<span class="line" id="L77"> <span class="tok-kw">inline</span> <span class="tok-kw">for</span> (fields) |field| {</span>
<span class="line" id="L78"> <span class="tok-kw">if</span> (mem.eql(<span class="tok-type">u8</span>, field.name, name)) <span class="tok-kw">return</span> <span class="tok-null">true</span>;</span>
<span class="line" id="L79"> }</span>
<span class="line" id="L80"></span>
<span class="line" id="L81"> <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L82"> }</span>
<span class="line" id="L83"> };</span>
<span class="line" id="L84"> <span class="tok-kw">return</span> Closure.trait;</span>
<span class="line" id="L85">}</span>
<span class="line" id="L86"></span>
<span class="line" id="L87"><span class="tok-kw">test</span> <span class="tok-str">"hasField"</span> {</span>
<span class="line" id="L88"> <span class="tok-kw">const</span> TestStruct = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L89"> value: <span class="tok-type">u32</span>,</span>
<span class="line" id="L90"> };</span>
<span class="line" id="L91"></span>
<span class="line" id="L92"> <span class="tok-kw">try</span> testing.expect(hasField(<span class="tok-str">"value"</span>)(TestStruct));</span>
<span class="line" id="L93"> <span class="tok-kw">try</span> testing.expect(!hasField(<span class="tok-str">"value"</span>)(*TestStruct));</span>
<span class="line" id="L94"> <span class="tok-kw">try</span> testing.expect(!hasField(<span class="tok-str">"x"</span>)(TestStruct));</span>
<span class="line" id="L95"> <span class="tok-kw">try</span> testing.expect(!hasField(<span class="tok-str">"x"</span>)(**TestStruct));</span>
<span class="line" id="L96"> <span class="tok-kw">try</span> testing.expect(!hasField(<span class="tok-str">"value"</span>)(<span class="tok-type">u8</span>));</span>
<span class="line" id="L97">}</span>
<span class="line" id="L98"></span>
<span class="line" id="L99"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">is</span>(<span class="tok-kw">comptime</span> id: std.builtin.TypeId) TraitFn {</span>
<span class="line" id="L100"> <span class="tok-kw">const</span> Closure = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L101"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">trait</span>(<span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>) <span class="tok-type">bool</span> {</span>
<span class="line" id="L102"> <span class="tok-kw">return</span> id == <span class="tok-builtin">@typeInfo</span>(T);</span>
<span class="line" id="L103"> }</span>
<span class="line" id="L104"> };</span>
<span class="line" id="L105"> <span class="tok-kw">return</span> Closure.trait;</span>
<span class="line" id="L106">}</span>
<span class="line" id="L107"></span>
<span class="line" id="L108"><span class="tok-kw">test</span> <span class="tok-str">"is"</span> {</span>
<span class="line" id="L109"> <span class="tok-kw">try</span> testing.expect(is(.Int)(<span class="tok-type">u8</span>));</span>
<span class="line" id="L110"> <span class="tok-kw">try</span> testing.expect(!is(.Int)(<span class="tok-type">f32</span>));</span>
<span class="line" id="L111"> <span class="tok-kw">try</span> testing.expect(is(.Pointer)(*<span class="tok-type">u8</span>));</span>
<span class="line" id="L112"> <span class="tok-kw">try</span> testing.expect(is(.Void)(<span class="tok-type">void</span>));</span>
<span class="line" id="L113"> <span class="tok-kw">try</span> testing.expect(!is(.Optional)(<span class="tok-type">anyerror</span>));</span>
<span class="line" id="L114">}</span>
<span class="line" id="L115"></span>
<span class="line" id="L116"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">isPtrTo</span>(<span class="tok-kw">comptime</span> id: std.builtin.TypeId) TraitFn {</span>
<span class="line" id="L117"> <span class="tok-kw">const</span> Closure = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L118"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">trait</span>(<span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>) <span class="tok-type">bool</span> {</span>
<span class="line" id="L119"> <span class="tok-kw">if</span> (!<span class="tok-kw">comptime</span> isSingleItemPtr(T)) <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L120"> <span class="tok-kw">return</span> id == <span class="tok-builtin">@typeInfo</span>(meta.Child(T));</span>
<span class="line" id="L121"> }</span>
<span class="line" id="L122"> };</span>
<span class="line" id="L123"> <span class="tok-kw">return</span> Closure.trait;</span>
<span class="line" id="L124">}</span>
<span class="line" id="L125"></span>
<span class="line" id="L126"><span class="tok-kw">test</span> <span class="tok-str">"isPtrTo"</span> {</span>
<span class="line" id="L127"> <span class="tok-kw">try</span> testing.expect(!isPtrTo(.Struct)(<span class="tok-kw">struct</span> {}));</span>
<span class="line" id="L128"> <span class="tok-kw">try</span> testing.expect(isPtrTo(.Struct)(*<span class="tok-kw">struct</span> {}));</span>
<span class="line" id="L129"> <span class="tok-kw">try</span> testing.expect(!isPtrTo(.Struct)(**<span class="tok-kw">struct</span> {}));</span>
<span class="line" id="L130">}</span>
<span class="line" id="L131"></span>
<span class="line" id="L132"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">isSliceOf</span>(<span class="tok-kw">comptime</span> id: std.builtin.TypeId) TraitFn {</span>
<span class="line" id="L133"> <span class="tok-kw">const</span> Closure = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L134"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">trait</span>(<span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>) <span class="tok-type">bool</span> {</span>
<span class="line" id="L135"> <span class="tok-kw">if</span> (!<span class="tok-kw">comptime</span> isSlice(T)) <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L136"> <span class="tok-kw">return</span> id == <span class="tok-builtin">@typeInfo</span>(meta.Child(T));</span>
<span class="line" id="L137"> }</span>
<span class="line" id="L138"> };</span>
<span class="line" id="L139"> <span class="tok-kw">return</span> Closure.trait;</span>
<span class="line" id="L140">}</span>
<span class="line" id="L141"></span>
<span class="line" id="L142"><span class="tok-kw">test</span> <span class="tok-str">"isSliceOf"</span> {</span>
<span class="line" id="L143"> <span class="tok-kw">try</span> testing.expect(!isSliceOf(.Struct)(<span class="tok-kw">struct</span> {}));</span>
<span class="line" id="L144"> <span class="tok-kw">try</span> testing.expect(isSliceOf(.Struct)([]<span class="tok-kw">struct</span> {}));</span>
<span class="line" id="L145"> <span class="tok-kw">try</span> testing.expect(!isSliceOf(.Struct)([][]<span class="tok-kw">struct</span> {}));</span>
<span class="line" id="L146">}</span>
<span class="line" id="L147"></span>
<span class="line" id="L148"><span class="tok-comment">///////////Strait trait Fns</span>
</span>
<span class="line" id="L149"></span>
<span class="line" id="L150"><span class="tok-comment">//@TODO:</span>
</span>
<span class="line" id="L151"><span class="tok-comment">// Somewhat limited since we can't apply this logic to normal variables, fields, or</span>
</span>
<span class="line" id="L152"><span class="tok-comment">// Fns yet. Should be isExternType?</span>
</span>
<span class="line" id="L153"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">isExtern</span>(<span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>) <span class="tok-type">bool</span> {</span>
<span class="line" id="L154"> <span class="tok-kw">return</span> <span class="tok-kw">switch</span> (<span class="tok-builtin">@typeInfo</span>(T)) {</span>
<span class="line" id="L155"> .Struct => |s| s.layout == .Extern,</span>
<span class="line" id="L156"> .Union => |u| u.layout == .Extern,</span>
<span class="line" id="L157"> <span class="tok-kw">else</span> => <span class="tok-null">false</span>,</span>
<span class="line" id="L158"> };</span>
<span class="line" id="L159">}</span>
<span class="line" id="L160"></span>
<span class="line" id="L161"><span class="tok-kw">test</span> <span class="tok-str">"isExtern"</span> {</span>
<span class="line" id="L162"> <span class="tok-kw">const</span> TestExStruct = <span class="tok-kw">extern</span> <span class="tok-kw">struct</span> {};</span>
<span class="line" id="L163"> <span class="tok-kw">const</span> TestStruct = <span class="tok-kw">struct</span> {};</span>
<span class="line" id="L164"></span>
<span class="line" id="L165"> <span class="tok-kw">try</span> testing.expect(isExtern(TestExStruct));</span>
<span class="line" id="L166"> <span class="tok-kw">try</span> testing.expect(!isExtern(TestStruct));</span>
<span class="line" id="L167"> <span class="tok-kw">try</span> testing.expect(!isExtern(<span class="tok-type">u8</span>));</span>
<span class="line" id="L168">}</span>
<span class="line" id="L169"></span>
<span class="line" id="L170"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">isPacked</span>(<span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>) <span class="tok-type">bool</span> {</span>
<span class="line" id="L171"> <span class="tok-kw">return</span> <span class="tok-kw">switch</span> (<span class="tok-builtin">@typeInfo</span>(T)) {</span>
<span class="line" id="L172"> .Struct => |s| s.layout == .Packed,</span>
<span class="line" id="L173"> .Union => |u| u.layout == .Packed,</span>
<span class="line" id="L174"> <span class="tok-kw">else</span> => <span class="tok-null">false</span>,</span>
<span class="line" id="L175"> };</span>
<span class="line" id="L176">}</span>
<span class="line" id="L177"></span>
<span class="line" id="L178"><span class="tok-kw">test</span> <span class="tok-str">"isPacked"</span> {</span>
<span class="line" id="L179"> <span class="tok-kw">const</span> TestPStruct = <span class="tok-kw">packed</span> <span class="tok-kw">struct</span> {};</span>
<span class="line" id="L180"> <span class="tok-kw">const</span> TestStruct = <span class="tok-kw">struct</span> {};</span>
<span class="line" id="L181"></span>
<span class="line" id="L182"> <span class="tok-kw">try</span> testing.expect(isPacked(TestPStruct));</span>
<span class="line" id="L183"> <span class="tok-kw">try</span> testing.expect(!isPacked(TestStruct));</span>
<span class="line" id="L184"> <span class="tok-kw">try</span> testing.expect(!isPacked(<span class="tok-type">u8</span>));</span>
<span class="line" id="L185">}</span>
<span class="line" id="L186"></span>
<span class="line" id="L187"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">isUnsignedInt</span>(<span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>) <span class="tok-type">bool</span> {</span>
<span class="line" id="L188"> <span class="tok-kw">return</span> <span class="tok-kw">switch</span> (<span class="tok-builtin">@typeInfo</span>(T)) {</span>
<span class="line" id="L189"> .Int => |i| i.signedness == .unsigned,</span>
<span class="line" id="L190"> <span class="tok-kw">else</span> => <span class="tok-null">false</span>,</span>
<span class="line" id="L191"> };</span>
<span class="line" id="L192">}</span>
<span class="line" id="L193"></span>
<span class="line" id="L194"><span class="tok-kw">test</span> <span class="tok-str">"isUnsignedInt"</span> {</span>
<span class="line" id="L195"> <span class="tok-kw">try</span> testing.expect(isUnsignedInt(<span class="tok-type">u32</span>) == <span class="tok-null">true</span>);</span>
<span class="line" id="L196"> <span class="tok-kw">try</span> testing.expect(isUnsignedInt(<span class="tok-type">comptime_int</span>) == <span class="tok-null">false</span>);</span>
<span class="line" id="L197"> <span class="tok-kw">try</span> testing.expect(isUnsignedInt(<span class="tok-type">i64</span>) == <span class="tok-null">false</span>);</span>
<span class="line" id="L198"> <span class="tok-kw">try</span> testing.expect(isUnsignedInt(<span class="tok-type">f64</span>) == <span class="tok-null">false</span>);</span>
<span class="line" id="L199">}</span>
<span class="line" id="L200"></span>
<span class="line" id="L201"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">isSignedInt</span>(<span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>) <span class="tok-type">bool</span> {</span>
<span class="line" id="L202"> <span class="tok-kw">return</span> <span class="tok-kw">switch</span> (<span class="tok-builtin">@typeInfo</span>(T)) {</span>
<span class="line" id="L203"> .ComptimeInt => <span class="tok-null">true</span>,</span>
<span class="line" id="L204"> .Int => |i| i.signedness == .signed,</span>
<span class="line" id="L205"> <span class="tok-kw">else</span> => <span class="tok-null">false</span>,</span>
<span class="line" id="L206"> };</span>
<span class="line" id="L207">}</span>
<span class="line" id="L208"></span>
<span class="line" id="L209"><span class="tok-kw">test</span> <span class="tok-str">"isSignedInt"</span> {</span>
<span class="line" id="L210"> <span class="tok-kw">try</span> testing.expect(isSignedInt(<span class="tok-type">u32</span>) == <span class="tok-null">false</span>);</span>
<span class="line" id="L211"> <span class="tok-kw">try</span> testing.expect(isSignedInt(<span class="tok-type">comptime_int</span>) == <span class="tok-null">true</span>);</span>
<span class="line" id="L212"> <span class="tok-kw">try</span> testing.expect(isSignedInt(<span class="tok-type">i64</span>) == <span class="tok-null">true</span>);</span>
<span class="line" id="L213"> <span class="tok-kw">try</span> testing.expect(isSignedInt(<span class="tok-type">f64</span>) == <span class="tok-null">false</span>);</span>
<span class="line" id="L214">}</span>
<span class="line" id="L215"></span>
<span class="line" id="L216"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">isSingleItemPtr</span>(<span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>) <span class="tok-type">bool</span> {</span>
<span class="line" id="L217"> <span class="tok-kw">if</span> (<span class="tok-kw">comptime</span> is(.Pointer)(T)) {</span>
<span class="line" id="L218"> <span class="tok-kw">return</span> <span class="tok-builtin">@typeInfo</span>(T).Pointer.size == .One;</span>
<span class="line" id="L219"> }</span>
<span class="line" id="L220"> <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L221">}</span>
<span class="line" id="L222"></span>
<span class="line" id="L223"><span class="tok-kw">test</span> <span class="tok-str">"isSingleItemPtr"</span> {</span>
<span class="line" id="L224"> <span class="tok-kw">const</span> array = [_]<span class="tok-type">u8</span>{<span class="tok-number">0</span>} ** <span class="tok-number">10</span>;</span>
<span class="line" id="L225"> <span class="tok-kw">try</span> <span class="tok-kw">comptime</span> testing.expect(isSingleItemPtr(<span class="tok-builtin">@TypeOf</span>(&array[<span class="tok-number">0</span>])));</span>
<span class="line" id="L226"> <span class="tok-kw">try</span> <span class="tok-kw">comptime</span> testing.expect(!isSingleItemPtr(<span class="tok-builtin">@TypeOf</span>(array)));</span>
<span class="line" id="L227"> <span class="tok-kw">var</span> runtime_zero: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L228"> <span class="tok-kw">try</span> testing.expect(!isSingleItemPtr(<span class="tok-builtin">@TypeOf</span>(array[runtime_zero..<span class="tok-number">1</span>])));</span>
<span class="line" id="L229">}</span>
<span class="line" id="L230"></span>
<span class="line" id="L231"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">isManyItemPtr</span>(<span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>) <span class="tok-type">bool</span> {</span>
<span class="line" id="L232"> <span class="tok-kw">if</span> (<span class="tok-kw">comptime</span> is(.Pointer)(T)) {</span>
<span class="line" id="L233"> <span class="tok-kw">return</span> <span class="tok-builtin">@typeInfo</span>(T).Pointer.size == .Many;</span>
<span class="line" id="L234"> }</span>
<span class="line" id="L235"> <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L236">}</span>
<span class="line" id="L237"></span>
<span class="line" id="L238"><span class="tok-kw">test</span> <span class="tok-str">"isManyItemPtr"</span> {</span>
<span class="line" id="L239"> <span class="tok-kw">const</span> array = [_]<span class="tok-type">u8</span>{<span class="tok-number">0</span>} ** <span class="tok-number">10</span>;</span>
<span class="line" id="L240"> <span class="tok-kw">const</span> mip = <span class="tok-builtin">@as</span>([*]<span class="tok-kw">const</span> <span class="tok-type">u8</span>, <span class="tok-builtin">@ptrCast</span>(&array[<span class="tok-number">0</span>]));</span>
<span class="line" id="L241"> <span class="tok-kw">try</span> testing.expect(isManyItemPtr(<span class="tok-builtin">@TypeOf</span>(mip)));</span>
<span class="line" id="L242"> <span class="tok-kw">try</span> testing.expect(!isManyItemPtr(<span class="tok-builtin">@TypeOf</span>(array)));</span>
<span class="line" id="L243"> <span class="tok-kw">try</span> testing.expect(!isManyItemPtr(<span class="tok-builtin">@TypeOf</span>(array[<span class="tok-number">0</span>..<span class="tok-number">1</span>])));</span>
<span class="line" id="L244">}</span>
<span class="line" id="L245"></span>
<span class="line" id="L246"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">isSlice</span>(<span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>) <span class="tok-type">bool</span> {</span>
<span class="line" id="L247"> <span class="tok-kw">if</span> (<span class="tok-kw">comptime</span> is(.Pointer)(T)) {</span>
<span class="line" id="L248"> <span class="tok-kw">return</span> <span class="tok-builtin">@typeInfo</span>(T).Pointer.size == .Slice;</span>
<span class="line" id="L249"> }</span>
<span class="line" id="L250"> <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L251">}</span>
<span class="line" id="L252"></span>
<span class="line" id="L253"><span class="tok-kw">test</span> <span class="tok-str">"isSlice"</span> {</span>
<span class="line" id="L254"> <span class="tok-kw">const</span> array = [_]<span class="tok-type">u8</span>{<span class="tok-number">0</span>} ** <span class="tok-number">10</span>;</span>
<span class="line" id="L255"> <span class="tok-kw">var</span> runtime_zero: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L256"> <span class="tok-kw">try</span> testing.expect(isSlice(<span class="tok-builtin">@TypeOf</span>(array[runtime_zero..])));</span>
<span class="line" id="L257"> <span class="tok-kw">try</span> testing.expect(!isSlice(<span class="tok-builtin">@TypeOf</span>(array)));</span>
<span class="line" id="L258"> <span class="tok-kw">try</span> testing.expect(!isSlice(<span class="tok-builtin">@TypeOf</span>(&array[<span class="tok-number">0</span>])));</span>
<span class="line" id="L259">}</span>
<span class="line" id="L260"></span>
<span class="line" id="L261"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">isIndexable</span>(<span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>) <span class="tok-type">bool</span> {</span>
<span class="line" id="L262"> <span class="tok-kw">if</span> (<span class="tok-kw">comptime</span> is(.Pointer)(T)) {</span>
<span class="line" id="L263"> <span class="tok-kw">if</span> (<span class="tok-builtin">@typeInfo</span>(T).Pointer.size == .One) {</span>
<span class="line" id="L264"> <span class="tok-kw">return</span> (<span class="tok-kw">comptime</span> is(.Array)(meta.Child(T)));</span>
<span class="line" id="L265"> }</span>
<span class="line" id="L266"> <span class="tok-kw">return</span> <span class="tok-null">true</span>;</span>
<span class="line" id="L267"> }</span>
<span class="line" id="L268"> <span class="tok-kw">return</span> <span class="tok-kw">comptime</span> is(.Array)(T) <span class="tok-kw">or</span> is(.Vector)(T) <span class="tok-kw">or</span> isTuple(T);</span>
<span class="line" id="L269">}</span>
<span class="line" id="L270"></span>
<span class="line" id="L271"><span class="tok-kw">test</span> <span class="tok-str">"isIndexable"</span> {</span>
<span class="line" id="L272"> <span class="tok-kw">const</span> array = [_]<span class="tok-type">u8</span>{<span class="tok-number">0</span>} ** <span class="tok-number">10</span>;</span>
<span class="line" id="L273"> <span class="tok-kw">const</span> slice = <span class="tok-builtin">@as</span>([]<span class="tok-kw">const</span> <span class="tok-type">u8</span>, &array);</span>
<span class="line" id="L274"> <span class="tok-kw">const</span> vector: <span class="tok-builtin">@Vector</span>(<span class="tok-number">2</span>, <span class="tok-type">u32</span>) = [_]<span class="tok-type">u32</span>{<span class="tok-number">0</span>} ** <span class="tok-number">2</span>;</span>
<span class="line" id="L275"> <span class="tok-kw">const</span> tuple = .{ <span class="tok-number">1</span>, <span class="tok-number">2</span>, <span class="tok-number">3</span> };</span>
<span class="line" id="L276"></span>
<span class="line" id="L277"> <span class="tok-kw">try</span> testing.expect(isIndexable(<span class="tok-builtin">@TypeOf</span>(array)));</span>
<span class="line" id="L278"> <span class="tok-kw">try</span> testing.expect(isIndexable(<span class="tok-builtin">@TypeOf</span>(&array)));</span>
<span class="line" id="L279"> <span class="tok-kw">try</span> testing.expect(isIndexable(<span class="tok-builtin">@TypeOf</span>(slice)));</span>
<span class="line" id="L280"> <span class="tok-kw">try</span> testing.expect(!isIndexable(meta.Child(<span class="tok-builtin">@TypeOf</span>(slice))));</span>
<span class="line" id="L281"> <span class="tok-kw">try</span> testing.expect(isIndexable(<span class="tok-builtin">@TypeOf</span>(vector)));</span>
<span class="line" id="L282"> <span class="tok-kw">try</span> testing.expect(isIndexable(<span class="tok-builtin">@TypeOf</span>(tuple)));</span>
<span class="line" id="L283">}</span>
<span class="line" id="L284"></span>
<span class="line" id="L285"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">isNumber</span>(<span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>) <span class="tok-type">bool</span> {</span>
<span class="line" id="L286"> <span class="tok-kw">return</span> <span class="tok-kw">switch</span> (<span class="tok-builtin">@typeInfo</span>(T)) {</span>
<span class="line" id="L287"> .Int, .Float, .ComptimeInt, .ComptimeFloat => <span class="tok-null">true</span>,</span>
<span class="line" id="L288"> <span class="tok-kw">else</span> => <span class="tok-null">false</span>,</span>
<span class="line" id="L289"> };</span>
<span class="line" id="L290">}</span>
<span class="line" id="L291"></span>
<span class="line" id="L292"><span class="tok-kw">test</span> <span class="tok-str">"isNumber"</span> {</span>
<span class="line" id="L293"> <span class="tok-kw">const</span> NotANumber = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L294"> number: <span class="tok-type">u8</span>,</span>
<span class="line" id="L295"> };</span>
<span class="line" id="L296"></span>
<span class="line" id="L297"> <span class="tok-kw">try</span> testing.expect(isNumber(<span class="tok-type">u32</span>));</span>
<span class="line" id="L298"> <span class="tok-kw">try</span> testing.expect(isNumber(<span class="tok-type">f32</span>));</span>
<span class="line" id="L299"> <span class="tok-kw">try</span> testing.expect(isNumber(<span class="tok-type">u64</span>));</span>
<span class="line" id="L300"> <span class="tok-kw">try</span> testing.expect(isNumber(<span class="tok-builtin">@TypeOf</span>(<span class="tok-number">102</span>)));</span>
<span class="line" id="L301"> <span class="tok-kw">try</span> testing.expect(isNumber(<span class="tok-builtin">@TypeOf</span>(<span class="tok-number">102.123</span>)));</span>
<span class="line" id="L302"> <span class="tok-kw">try</span> testing.expect(!isNumber([]<span class="tok-type">u8</span>));</span>
<span class="line" id="L303"> <span class="tok-kw">try</span> testing.expect(!isNumber(NotANumber));</span>
<span class="line" id="L304">}</span>
<span class="line" id="L305"></span>
<span class="line" id="L306"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">isIntegral</span>(<span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>) <span class="tok-type">bool</span> {</span>
<span class="line" id="L307"> <span class="tok-kw">return</span> <span class="tok-kw">switch</span> (<span class="tok-builtin">@typeInfo</span>(T)) {</span>
<span class="line" id="L308"> .Int, .ComptimeInt => <span class="tok-null">true</span>,</span>
<span class="line" id="L309"> <span class="tok-kw">else</span> => <span class="tok-null">false</span>,</span>
<span class="line" id="L310"> };</span>
<span class="line" id="L311">}</span>
<span class="line" id="L312"></span>
<span class="line" id="L313"><span class="tok-kw">test</span> <span class="tok-str">"isIntegral"</span> {</span>
<span class="line" id="L314"> <span class="tok-kw">try</span> testing.expect(isIntegral(<span class="tok-type">u32</span>));</span>
<span class="line" id="L315"> <span class="tok-kw">try</span> testing.expect(!isIntegral(<span class="tok-type">f32</span>));</span>
<span class="line" id="L316"> <span class="tok-kw">try</span> testing.expect(isIntegral(<span class="tok-builtin">@TypeOf</span>(<span class="tok-number">102</span>)));</span>
<span class="line" id="L317"> <span class="tok-kw">try</span> testing.expect(!isIntegral(<span class="tok-builtin">@TypeOf</span>(<span class="tok-number">102.123</span>)));</span>
<span class="line" id="L318"> <span class="tok-kw">try</span> testing.expect(!isIntegral(*<span class="tok-type">u8</span>));</span>
<span class="line" id="L319"> <span class="tok-kw">try</span> testing.expect(!isIntegral([]<span class="tok-type">u8</span>));</span>
<span class="line" id="L320">}</span>
<span class="line" id="L321"></span>
<span class="line" id="L322"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">isFloat</span>(<span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>) <span class="tok-type">bool</span> {</span>
<span class="line" id="L323"> <span class="tok-kw">return</span> <span class="tok-kw">switch</span> (<span class="tok-builtin">@typeInfo</span>(T)) {</span>
<span class="line" id="L324"> .Float, .ComptimeFloat => <span class="tok-null">true</span>,</span>
<span class="line" id="L325"> <span class="tok-kw">else</span> => <span class="tok-null">false</span>,</span>
<span class="line" id="L326"> };</span>
<span class="line" id="L327">}</span>
<span class="line" id="L328"></span>
<span class="line" id="L329"><span class="tok-kw">test</span> <span class="tok-str">"isFloat"</span> {</span>
<span class="line" id="L330"> <span class="tok-kw">try</span> testing.expect(!isFloat(<span class="tok-type">u32</span>));</span>
<span class="line" id="L331"> <span class="tok-kw">try</span> testing.expect(isFloat(<span class="tok-type">f32</span>));</span>
<span class="line" id="L332"> <span class="tok-kw">try</span> testing.expect(!isFloat(<span class="tok-builtin">@TypeOf</span>(<span class="tok-number">102</span>)));</span>
<span class="line" id="L333"> <span class="tok-kw">try</span> testing.expect(isFloat(<span class="tok-builtin">@TypeOf</span>(<span class="tok-number">102.123</span>)));</span>
<span class="line" id="L334"> <span class="tok-kw">try</span> testing.expect(!isFloat(*<span class="tok-type">f64</span>));</span>
<span class="line" id="L335"> <span class="tok-kw">try</span> testing.expect(!isFloat([]<span class="tok-type">f32</span>));</span>
<span class="line" id="L336">}</span>
<span class="line" id="L337"></span>
<span class="line" id="L338"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">isConstPtr</span>(<span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>) <span class="tok-type">bool</span> {</span>
<span class="line" id="L339"> <span class="tok-kw">if</span> (!<span class="tok-kw">comptime</span> is(.Pointer)(T)) <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L340"> <span class="tok-kw">return</span> <span class="tok-builtin">@typeInfo</span>(T).Pointer.is_const;</span>
<span class="line" id="L341">}</span>
<span class="line" id="L342"></span>
<span class="line" id="L343"><span class="tok-kw">test</span> <span class="tok-str">"isConstPtr"</span> {</span>
<span class="line" id="L344"> <span class="tok-kw">var</span> t = <span class="tok-builtin">@as</span>(<span class="tok-type">u8</span>, <span class="tok-number">0</span>);</span>
<span class="line" id="L345"> <span class="tok-kw">const</span> c = <span class="tok-builtin">@as</span>(<span class="tok-type">u8</span>, <span class="tok-number">0</span>);</span>
<span class="line" id="L346"> <span class="tok-kw">try</span> testing.expect(isConstPtr(*<span class="tok-kw">const</span> <span class="tok-builtin">@TypeOf</span>(t)));</span>
<span class="line" id="L347"> <span class="tok-kw">try</span> testing.expect(isConstPtr(<span class="tok-builtin">@TypeOf</span>(&c)));</span>
<span class="line" id="L348"> <span class="tok-kw">try</span> testing.expect(!isConstPtr(*<span class="tok-builtin">@TypeOf</span>(t)));</span>
<span class="line" id="L349"> <span class="tok-kw">try</span> testing.expect(!isConstPtr(<span class="tok-builtin">@TypeOf</span>(<span class="tok-number">6</span>)));</span>
<span class="line" id="L350">}</span>
<span class="line" id="L351"></span>
<span class="line" id="L352"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">isContainer</span>(<span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>) <span class="tok-type">bool</span> {</span>
<span class="line" id="L353"> <span class="tok-kw">return</span> <span class="tok-kw">switch</span> (<span class="tok-builtin">@typeInfo</span>(T)) {</span>
<span class="line" id="L354"> .Struct, .Union, .Enum, .Opaque => <span class="tok-null">true</span>,</span>
<span class="line" id="L355"> <span class="tok-kw">else</span> => <span class="tok-null">false</span>,</span>
<span class="line" id="L356"> };</span>
<span class="line" id="L357">}</span>
<span class="line" id="L358"></span>
<span class="line" id="L359"><span class="tok-kw">test</span> <span class="tok-str">"isContainer"</span> {</span>
<span class="line" id="L360"> <span class="tok-kw">const</span> TestStruct = <span class="tok-kw">struct</span> {};</span>
<span class="line" id="L361"> <span class="tok-kw">const</span> TestUnion = <span class="tok-kw">union</span> {</span>
<span class="line" id="L362"> a: <span class="tok-type">void</span>,</span>
<span class="line" id="L363"> };</span>
<span class="line" id="L364"> <span class="tok-kw">const</span> TestEnum = <span class="tok-kw">enum</span> {</span>
<span class="line" id="L365"> A,</span>
<span class="line" id="L366"> B,</span>
<span class="line" id="L367"> };</span>
<span class="line" id="L368"> <span class="tok-kw">const</span> TestOpaque = <span class="tok-kw">opaque</span> {};</span>
<span class="line" id="L369"></span>
<span class="line" id="L370"> <span class="tok-kw">try</span> testing.expect(isContainer(TestStruct));</span>
<span class="line" id="L371"> <span class="tok-kw">try</span> testing.expect(isContainer(TestUnion));</span>
<span class="line" id="L372"> <span class="tok-kw">try</span> testing.expect(isContainer(TestEnum));</span>
<span class="line" id="L373"> <span class="tok-kw">try</span> testing.expect(isContainer(TestOpaque));</span>
<span class="line" id="L374"> <span class="tok-kw">try</span> testing.expect(!isContainer(<span class="tok-type">u8</span>));</span>
<span class="line" id="L375">}</span>
<span class="line" id="L376"></span>
<span class="line" id="L377"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">isTuple</span>(<span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>) <span class="tok-type">bool</span> {</span>
<span class="line" id="L378"> <span class="tok-kw">return</span> is(.Struct)(T) <span class="tok-kw">and</span> <span class="tok-builtin">@typeInfo</span>(T).Struct.is_tuple;</span>
<span class="line" id="L379">}</span>
<span class="line" id="L380"></span>
<span class="line" id="L381"><span class="tok-kw">test</span> <span class="tok-str">"isTuple"</span> {</span>
<span class="line" id="L382"> <span class="tok-kw">const</span> t1 = <span class="tok-kw">struct</span> {};</span>
<span class="line" id="L383"> <span class="tok-kw">const</span> t2 = .{ .a = <span class="tok-number">0</span> };</span>
<span class="line" id="L384"> <span class="tok-kw">const</span> t3 = .{ <span class="tok-number">1</span>, <span class="tok-number">2</span>, <span class="tok-number">3</span> };</span>
<span class="line" id="L385"> <span class="tok-kw">try</span> testing.expect(!isTuple(t1));</span>
<span class="line" id="L386"> <span class="tok-kw">try</span> testing.expect(!isTuple(<span class="tok-builtin">@TypeOf</span>(t2)));</span>
<span class="line" id="L387"> <span class="tok-kw">try</span> testing.expect(isTuple(<span class="tok-builtin">@TypeOf</span>(t3)));</span>
<span class="line" id="L388">}</span>
<span class="line" id="L389"></span>
<span class="line" id="L390"><span class="tok-comment">/// Returns true if the passed type will coerce to []const u8.</span></span>
<span class="line" id="L391"><span class="tok-comment">/// Any of the following are considered strings:</span></span>
<span class="line" id="L392"><span class="tok-comment">/// ```</span></span>
<span class="line" id="L393"><span class="tok-comment">/// []const u8, [:S]const u8, *const [N]u8, *const [N:S]u8,</span></span>
<span class="line" id="L394"><span class="tok-comment">/// []u8, [:S]u8, *[:S]u8, *[N:S]u8.</span></span>
<span class="line" id="L395"><span class="tok-comment">/// ```</span></span>
<span class="line" id="L396"><span class="tok-comment">/// These types are not considered strings:</span></span>
<span class="line" id="L397"><span class="tok-comment">/// ```</span></span>
<span class="line" id="L398"><span class="tok-comment">/// u8, [N]u8, [*]const u8, [*:0]const u8,</span></span>
<span class="line" id="L399"><span class="tok-comment">/// [*]const [N]u8, []const u16, []const i8,</span></span>
<span class="line" id="L400"><span class="tok-comment">/// *const u8, ?[]const u8, ?*const [N]u8.</span></span>
<span class="line" id="L401"><span class="tok-comment">/// ```</span></span>
<span class="line" id="L402"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">isZigString</span>(<span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>) <span class="tok-type">bool</span> {</span>
<span class="line" id="L403"> <span class="tok-kw">return</span> <span class="tok-kw">comptime</span> blk: {</span>
<span class="line" id="L404"> <span class="tok-comment">// Only pointer types can be strings, no optionals</span>
</span>
<span class="line" id="L405"> <span class="tok-kw">const</span> info = <span class="tok-builtin">@typeInfo</span>(T);</span>
<span class="line" id="L406"> <span class="tok-kw">if</span> (info != .Pointer) <span class="tok-kw">break</span> :blk <span class="tok-null">false</span>;</span>
<span class="line" id="L407"></span>
<span class="line" id="L408"> <span class="tok-kw">const</span> ptr = &info.Pointer;</span>
<span class="line" id="L409"> <span class="tok-comment">// Check for CV qualifiers that would prevent coerction to []const u8</span>
</span>
<span class="line" id="L410"> <span class="tok-kw">if</span> (ptr.is_volatile <span class="tok-kw">or</span> ptr.is_allowzero) <span class="tok-kw">break</span> :blk <span class="tok-null">false</span>;</span>
<span class="line" id="L411"></span>
<span class="line" id="L412"> <span class="tok-comment">// If it's already a slice, simple check.</span>
</span>
<span class="line" id="L413"> <span class="tok-kw">if</span> (ptr.size == .Slice) {</span>
<span class="line" id="L414"> <span class="tok-kw">break</span> :blk ptr.child == <span class="tok-type">u8</span>;</span>
<span class="line" id="L415"> }</span>
<span class="line" id="L416"></span>
<span class="line" id="L417"> <span class="tok-comment">// Otherwise check if it's an array type that coerces to slice.</span>
</span>
<span class="line" id="L418"> <span class="tok-kw">if</span> (ptr.size == .One) {</span>
<span class="line" id="L419"> <span class="tok-kw">const</span> child = <span class="tok-builtin">@typeInfo</span>(ptr.child);</span>
<span class="line" id="L420"> <span class="tok-kw">if</span> (child == .Array) {</span>
<span class="line" id="L421"> <span class="tok-kw">const</span> arr = &child.Array;</span>
<span class="line" id="L422"> <span class="tok-kw">break</span> :blk arr.child == <span class="tok-type">u8</span>;</span>
<span class="line" id="L423"> }</span>
<span class="line" id="L424"> }</span>
<span class="line" id="L425"></span>
<span class="line" id="L426"> <span class="tok-kw">break</span> :blk <span class="tok-null">false</span>;</span>
<span class="line" id="L427"> };</span>
<span class="line" id="L428">}</span>
<span class="line" id="L429"></span>
<span class="line" id="L430"><span class="tok-kw">test</span> <span class="tok-str">"isZigString"</span> {</span>
<span class="line" id="L431"> <span class="tok-kw">try</span> testing.expect(isZigString([]<span class="tok-kw">const</span> <span class="tok-type">u8</span>));</span>
<span class="line" id="L432"> <span class="tok-kw">try</span> testing.expect(isZigString([]<span class="tok-type">u8</span>));</span>
<span class="line" id="L433"> <span class="tok-kw">try</span> testing.expect(isZigString([:<span class="tok-number">0</span>]<span class="tok-kw">const</span> <span class="tok-type">u8</span>));</span>
<span class="line" id="L434"> <span class="tok-kw">try</span> testing.expect(isZigString([:<span class="tok-number">0</span>]<span class="tok-type">u8</span>));</span>
<span class="line" id="L435"> <span class="tok-kw">try</span> testing.expect(isZigString([:<span class="tok-number">5</span>]<span class="tok-kw">const</span> <span class="tok-type">u8</span>));</span>
<span class="line" id="L436"> <span class="tok-kw">try</span> testing.expect(isZigString([:<span class="tok-number">5</span>]<span class="tok-type">u8</span>));</span>
<span class="line" id="L437"> <span class="tok-kw">try</span> testing.expect(isZigString(*<span class="tok-kw">const</span> [<span class="tok-number">0</span>]<span class="tok-type">u8</span>));</span>
<span class="line" id="L438"> <span class="tok-kw">try</span> testing.expect(isZigString(*[<span class="tok-number">0</span>]<span class="tok-type">u8</span>));</span>
<span class="line" id="L439"> <span class="tok-kw">try</span> testing.expect(isZigString(*<span class="tok-kw">const</span> [<span class="tok-number">0</span>:<span class="tok-number">0</span>]<span class="tok-type">u8</span>));</span>
<span class="line" id="L440"> <span class="tok-kw">try</span> testing.expect(isZigString(*[<span class="tok-number">0</span>:<span class="tok-number">0</span>]<span class="tok-type">u8</span>));</span>
<span class="line" id="L441"> <span class="tok-kw">try</span> testing.expect(isZigString(*<span class="tok-kw">const</span> [<span class="tok-number">0</span>:<span class="tok-number">5</span>]<span class="tok-type">u8</span>));</span>
<span class="line" id="L442"> <span class="tok-kw">try</span> testing.expect(isZigString(*[<span class="tok-number">0</span>:<span class="tok-number">5</span>]<span class="tok-type">u8</span>));</span>
<span class="line" id="L443"> <span class="tok-kw">try</span> testing.expect(isZigString(*<span class="tok-kw">const</span> [<span class="tok-number">10</span>]<span class="tok-type">u8</span>));</span>
<span class="line" id="L444"> <span class="tok-kw">try</span> testing.expect(isZigString(*[<span class="tok-number">10</span>]<span class="tok-type">u8</span>));</span>
<span class="line" id="L445"> <span class="tok-kw">try</span> testing.expect(isZigString(*<span class="tok-kw">const</span> [<span class="tok-number">10</span>:<span class="tok-number">0</span>]<span class="tok-type">u8</span>));</span>
<span class="line" id="L446"> <span class="tok-kw">try</span> testing.expect(isZigString(*[<span class="tok-number">10</span>:<span class="tok-number">0</span>]<span class="tok-type">u8</span>));</span>
<span class="line" id="L447"> <span class="tok-kw">try</span> testing.expect(isZigString(*<span class="tok-kw">const</span> [<span class="tok-number">10</span>:<span class="tok-number">5</span>]<span class="tok-type">u8</span>));</span>
<span class="line" id="L448"> <span class="tok-kw">try</span> testing.expect(isZigString(*[<span class="tok-number">10</span>:<span class="tok-number">5</span>]<span class="tok-type">u8</span>));</span>
<span class="line" id="L449"></span>
<span class="line" id="L450"> <span class="tok-kw">try</span> testing.expect(!isZigString(<span class="tok-type">u8</span>));</span>
<span class="line" id="L451"> <span class="tok-kw">try</span> testing.expect(!isZigString([<span class="tok-number">4</span>]<span class="tok-type">u8</span>));</span>
<span class="line" id="L452"> <span class="tok-kw">try</span> testing.expect(!isZigString([<span class="tok-number">4</span>:<span class="tok-number">0</span>]<span class="tok-type">u8</span>));</span>
<span class="line" id="L453"> <span class="tok-kw">try</span> testing.expect(!isZigString([*]<span class="tok-kw">const</span> <span class="tok-type">u8</span>));</span>
<span class="line" id="L454"> <span class="tok-kw">try</span> testing.expect(!isZigString([*]<span class="tok-kw">const</span> [<span class="tok-number">4</span>]<span class="tok-type">u8</span>));</span>
<span class="line" id="L455"> <span class="tok-kw">try</span> testing.expect(!isZigString([*c]<span class="tok-kw">const</span> <span class="tok-type">u8</span>));</span>
<span class="line" id="L456"> <span class="tok-kw">try</span> testing.expect(!isZigString([*c]<span class="tok-kw">const</span> [<span class="tok-number">4</span>]<span class="tok-type">u8</span>));</span>
<span class="line" id="L457"> <span class="tok-kw">try</span> testing.expect(!isZigString([*:<span class="tok-number">0</span>]<span class="tok-kw">const</span> <span class="tok-type">u8</span>));</span>
<span class="line" id="L458"> <span class="tok-kw">try</span> testing.expect(!isZigString([*:<span class="tok-number">0</span>]<span class="tok-kw">const</span> <span class="tok-type">u8</span>));</span>
<span class="line" id="L459"> <span class="tok-kw">try</span> testing.expect(!isZigString(*[]<span class="tok-kw">const</span> <span class="tok-type">u8</span>));</span>
<span class="line" id="L460"> <span class="tok-kw">try</span> testing.expect(!isZigString(?[]<span class="tok-kw">const</span> <span class="tok-type">u8</span>));</span>
<span class="line" id="L461"> <span class="tok-kw">try</span> testing.expect(!isZigString(?*<span class="tok-kw">const</span> [<span class="tok-number">4</span>]<span class="tok-type">u8</span>));</span>
<span class="line" id="L462"> <span class="tok-kw">try</span> testing.expect(!isZigString([]<span class="tok-kw">allowzero</span> <span class="tok-type">u8</span>));</span>
<span class="line" id="L463"> <span class="tok-kw">try</span> testing.expect(!isZigString([]<span class="tok-kw">volatile</span> <span class="tok-type">u8</span>));</span>
<span class="line" id="L464"> <span class="tok-kw">try</span> testing.expect(!isZigString(*<span class="tok-kw">allowzero</span> [<span class="tok-number">4</span>]<span class="tok-type">u8</span>));</span>
<span class="line" id="L465"> <span class="tok-kw">try</span> testing.expect(!isZigString(*<span class="tok-kw">volatile</span> [<span class="tok-number">4</span>]<span class="tok-type">u8</span>));</span>
<span class="line" id="L466">}</span>
<span class="line" id="L467"></span>
<span class="line" id="L468"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">hasDecls</span>(<span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>, <span class="tok-kw">comptime</span> names: <span class="tok-kw">anytype</span>) <span class="tok-type">bool</span> {</span>
<span class="line" id="L469"> <span class="tok-kw">inline</span> <span class="tok-kw">for</span> (names) |name| {</span>
<span class="line" id="L470"> <span class="tok-kw">if</span> (!<span class="tok-builtin">@hasDecl</span>(T, name))</span>
<span class="line" id="L471"> <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L472"> }</span>
<span class="line" id="L473"> <span class="tok-kw">return</span> <span class="tok-null">true</span>;</span>
<span class="line" id="L474">}</span>
<span class="line" id="L475"></span>
<span class="line" id="L476"><span class="tok-kw">test</span> <span class="tok-str">"hasDecls"</span> {</span>
<span class="line" id="L477"> <span class="tok-kw">const</span> TestStruct1 = <span class="tok-kw">struct</span> {};</span>
<span class="line" id="L478"> <span class="tok-kw">const</span> TestStruct2 = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L479"> <span class="tok-kw">pub</span> <span class="tok-kw">var</span> a: <span class="tok-type">u32</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L480"> <span class="tok-kw">pub</span> <span class="tok-kw">var</span> b: <span class="tok-type">u32</span> = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L481"> c: <span class="tok-type">bool</span>,</span>
<span class="line" id="L482"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">useless</span>() <span class="tok-type">void</span> {}</span>
<span class="line" id="L483"> };</span>
<span class="line" id="L484"></span>
<span class="line" id="L485"> <span class="tok-kw">const</span> tuple = .{ <span class="tok-str">"a"</span>, <span class="tok-str">"b"</span>, <span class="tok-str">"c"</span> };</span>
<span class="line" id="L486"></span>
<span class="line" id="L487"> <span class="tok-kw">try</span> testing.expect(!hasDecls(TestStruct1, .{<span class="tok-str">"a"</span>}));</span>
<span class="line" id="L488"> <span class="tok-kw">try</span> testing.expect(hasDecls(TestStruct2, .{ <span class="tok-str">"a"</span>, <span class="tok-str">"b"</span> }));</span>
<span class="line" id="L489"> <span class="tok-kw">try</span> testing.expect(hasDecls(TestStruct2, .{ <span class="tok-str">"a"</span>, <span class="tok-str">"b"</span>, <span class="tok-str">"useless"</span> }));</span>
<span class="line" id="L490"> <span class="tok-kw">try</span> testing.expect(!hasDecls(TestStruct2, .{ <span class="tok-str">"a"</span>, <span class="tok-str">"b"</span>, <span class="tok-str">"c"</span> }));</span>
<span class="line" id="L491"> <span class="tok-kw">try</span> testing.expect(!hasDecls(TestStruct2, tuple));</span>
<span class="line" id="L492">}</span>
<span class="line" id="L493"></span>
<span class="line" id="L494"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">hasFields</span>(<span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>, <span class="tok-kw">comptime</span> names: <span class="tok-kw">anytype</span>) <span class="tok-type">bool</span> {</span>
<span class="line" id="L495"> <span class="tok-kw">inline</span> <span class="tok-kw">for</span> (names) |name| {</span>
<span class="line" id="L496"> <span class="tok-kw">if</span> (!<span class="tok-builtin">@hasField</span>(T, name))</span>
<span class="line" id="L497"> <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L498"> }</span>
<span class="line" id="L499"> <span class="tok-kw">return</span> <span class="tok-null">true</span>;</span>
<span class="line" id="L500">}</span>
<span class="line" id="L501"></span>
<span class="line" id="L502"><span class="tok-kw">test</span> <span class="tok-str">"hasFields"</span> {</span>
<span class="line" id="L503"> <span class="tok-kw">const</span> TestStruct1 = <span class="tok-kw">struct</span> {};</span>
<span class="line" id="L504"> <span class="tok-kw">const</span> TestStruct2 = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L505"> a: <span class="tok-type">u32</span>,</span>
<span class="line" id="L506"> b: <span class="tok-type">u32</span>,</span>
<span class="line" id="L507"> c: <span class="tok-type">bool</span>,</span>
<span class="line" id="L508"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">useless</span>() <span class="tok-type">void</span> {}</span>
<span class="line" id="L509"> };</span>
<span class="line" id="L510"></span>
<span class="line" id="L511"> <span class="tok-kw">const</span> tuple = .{ <span class="tok-str">"a"</span>, <span class="tok-str">"b"</span>, <span class="tok-str">"c"</span> };</span>
<span class="line" id="L512"></span>
<span class="line" id="L513"> <span class="tok-kw">try</span> testing.expect(!hasFields(TestStruct1, .{<span class="tok-str">"a"</span>}));</span>
<span class="line" id="L514"> <span class="tok-kw">try</span> testing.expect(hasFields(TestStruct2, .{ <span class="tok-str">"a"</span>, <span class="tok-str">"b"</span> }));</span>
<span class="line" id="L515"> <span class="tok-kw">try</span> testing.expect(hasFields(TestStruct2, .{ <span class="tok-str">"a"</span>, <span class="tok-str">"b"</span>, <span class="tok-str">"c"</span> }));</span>
<span class="line" id="L516"> <span class="tok-kw">try</span> testing.expect(hasFields(TestStruct2, tuple));</span>
<span class="line" id="L517"> <span class="tok-kw">try</span> testing.expect(!hasFields(TestStruct2, .{ <span class="tok-str">"a"</span>, <span class="tok-str">"b"</span>, <span class="tok-str">"useless"</span> }));</span>
<span class="line" id="L518">}</span>
<span class="line" id="L519"></span>
<span class="line" id="L520"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">hasFunctions</span>(<span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>, <span class="tok-kw">comptime</span> names: <span class="tok-kw">anytype</span>) <span class="tok-type">bool</span> {</span>
<span class="line" id="L521"> <span class="tok-kw">inline</span> <span class="tok-kw">for</span> (names) |name| {</span>
<span class="line" id="L522"> <span class="tok-kw">if</span> (!hasFn(name)(T))</span>
<span class="line" id="L523"> <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L524"> }</span>
<span class="line" id="L525"> <span class="tok-kw">return</span> <span class="tok-null">true</span>;</span>
<span class="line" id="L526">}</span>
<span class="line" id="L527"></span>
<span class="line" id="L528"><span class="tok-kw">test</span> <span class="tok-str">"hasFunctions"</span> {</span>
<span class="line" id="L529"> <span class="tok-kw">const</span> TestStruct1 = <span class="tok-kw">struct</span> {};</span>
<span class="line" id="L530"> <span class="tok-kw">const</span> TestStruct2 = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L531"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">a</span>() <span class="tok-type">void</span> {}</span>
<span class="line" id="L532"> <span class="tok-kw">fn</span> <span class="tok-fn">b</span>() <span class="tok-type">void</span> {}</span>
<span class="line" id="L533"> };</span>
<span class="line" id="L534"></span>
<span class="line" id="L535"> <span class="tok-kw">const</span> tuple = .{ <span class="tok-str">"a"</span>, <span class="tok-str">"b"</span>, <span class="tok-str">"c"</span> };</span>
<span class="line" id="L536"></span>
<span class="line" id="L537"> <span class="tok-kw">try</span> testing.expect(!hasFunctions(TestStruct1, .{<span class="tok-str">"a"</span>}));</span>
<span class="line" id="L538"> <span class="tok-kw">try</span> testing.expect(hasFunctions(TestStruct2, .{ <span class="tok-str">"a"</span>, <span class="tok-str">"b"</span> }));</span>
<span class="line" id="L539"> <span class="tok-kw">try</span> testing.expect(!hasFunctions(TestStruct2, .{ <span class="tok-str">"a"</span>, <span class="tok-str">"b"</span>, <span class="tok-str">"c"</span> }));</span>
<span class="line" id="L540"> <span class="tok-kw">try</span> testing.expect(!hasFunctions(TestStruct2, tuple));</span>
<span class="line" id="L541">}</span>
<span class="line" id="L542"></span>
<span class="line" id="L543"><span class="tok-comment">/// True if every value of the type `T` has a unique bit pattern representing it.</span></span>
<span class="line" id="L544"><span class="tok-comment">/// In other words, `T` has no unused bits and no padding.</span></span>
<span class="line" id="L545"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">hasUniqueRepresentation</span>(<span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>) <span class="tok-type">bool</span> {</span>
<span class="line" id="L546"> <span class="tok-kw">switch</span> (<span class="tok-builtin">@typeInfo</span>(T)) {</span>
<span class="line" id="L547"> <span class="tok-kw">else</span> => <span class="tok-kw">return</span> <span class="tok-null">false</span>, <span class="tok-comment">// TODO can we know if it's true for some of these types ?</span>
</span>
<span class="line" id="L548"></span>
<span class="line" id="L549"> .AnyFrame,</span>
<span class="line" id="L550"> .Enum,</span>
<span class="line" id="L551"> .ErrorSet,</span>
<span class="line" id="L552"> .Fn,</span>
<span class="line" id="L553"> => <span class="tok-kw">return</span> <span class="tok-null">true</span>,</span>
<span class="line" id="L554"></span>
<span class="line" id="L555"> .Bool => <span class="tok-kw">return</span> <span class="tok-null">false</span>,</span>
<span class="line" id="L556"></span>
<span class="line" id="L557"> .Int => |info| <span class="tok-kw">return</span> <span class="tok-builtin">@sizeOf</span>(T) * <span class="tok-number">8</span> == info.bits,</span>
<span class="line" id="L558"></span>
<span class="line" id="L559"> .Pointer => |info| <span class="tok-kw">return</span> info.size != .Slice,</span>
<span class="line" id="L560"></span>
<span class="line" id="L561"> .Array => |info| <span class="tok-kw">return</span> <span class="tok-kw">comptime</span> hasUniqueRepresentation(info.child),</span>
<span class="line" id="L562"></span>
<span class="line" id="L563"> .Struct => |info| {</span>
<span class="line" id="L564"> <span class="tok-kw">var</span> sum_size = <span class="tok-builtin">@as</span>(<span class="tok-type">usize</span>, <span class="tok-number">0</span>);</span>
<span class="line" id="L565"></span>
<span class="line" id="L566"> <span class="tok-kw">inline</span> <span class="tok-kw">for</span> (info.fields) |field| {</span>
<span class="line" id="L567"> <span class="tok-kw">const</span> FieldType = field.<span class="tok-type">type</span>;</span>
<span class="line" id="L568"> <span class="tok-kw">if</span> (<span class="tok-kw">comptime</span> !hasUniqueRepresentation(FieldType)) <span class="tok-kw">return</span> <span class="tok-null">false</span>;</span>
<span class="line" id="L569"> sum_size += <span class="tok-builtin">@sizeOf</span>(FieldType);</span>
<span class="line" id="L570"> }</span>
<span class="line" id="L571"></span>
<span class="line" id="L572"> <span class="tok-kw">return</span> <span class="tok-builtin">@sizeOf</span>(T) == sum_size;</span>
<span class="line" id="L573"> },</span>
<span class="line" id="L574"></span>
<span class="line" id="L575"> .Vector => |info| <span class="tok-kw">return</span> <span class="tok-kw">comptime</span> hasUniqueRepresentation(info.child) <span class="tok-kw">and</span></span>
<span class="line" id="L576"> <span class="tok-builtin">@sizeOf</span>(T) == <span class="tok-builtin">@sizeOf</span>(info.child) * info.len,</span>
<span class="line" id="L577"> }</span>
<span class="line" id="L578">}</span>
<span class="line" id="L579"></span>
<span class="line" id="L580"><span class="tok-kw">test</span> <span class="tok-str">"hasUniqueRepresentation"</span> {</span>
<span class="line" id="L581"> <span class="tok-kw">const</span> TestStruct1 = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L582"> a: <span class="tok-type">u32</span>,</span>
<span class="line" id="L583"> b: <span class="tok-type">u32</span>,</span>
<span class="line" id="L584"> };</span>
<span class="line" id="L585"></span>
<span class="line" id="L586"> <span class="tok-kw">try</span> testing.expect(hasUniqueRepresentation(TestStruct1));</span>
<span class="line" id="L587"></span>
<span class="line" id="L588"> <span class="tok-kw">const</span> TestStruct2 = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L589"> a: <span class="tok-type">u32</span>,</span>
<span class="line" id="L590"> b: <span class="tok-type">u16</span>,</span>
<span class="line" id="L591"> };</span>
<span class="line" id="L592"></span>
<span class="line" id="L593"> <span class="tok-kw">try</span> testing.expect(!hasUniqueRepresentation(TestStruct2));</span>
<span class="line" id="L594"></span>
<span class="line" id="L595"> <span class="tok-kw">const</span> TestStruct3 = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L596"> a: <span class="tok-type">u32</span>,</span>
<span class="line" id="L597"> b: <span class="tok-type">u32</span>,</span>
<span class="line" id="L598"> };</span>
<span class="line" id="L599"></span>
<span class="line" id="L600"> <span class="tok-kw">try</span> testing.expect(hasUniqueRepresentation(TestStruct3));</span>
<span class="line" id="L601"></span>
<span class="line" id="L602"> <span class="tok-kw">const</span> TestStruct4 = <span class="tok-kw">struct</span> { a: []<span class="tok-kw">const</span> <span class="tok-type">u8</span> };</span>
<span class="line" id="L603"></span>
<span class="line" id="L604"> <span class="tok-kw">try</span> testing.expect(!hasUniqueRepresentation(TestStruct4));</span>
<span class="line" id="L605"></span>
<span class="line" id="L606"> <span class="tok-kw">const</span> TestStruct5 = <span class="tok-kw">struct</span> { a: TestStruct4 };</span>
<span class="line" id="L607"></span>
<span class="line" id="L608"> <span class="tok-kw">try</span> testing.expect(!hasUniqueRepresentation(TestStruct5));</span>
<span class="line" id="L609"></span>
<span class="line" id="L610"> <span class="tok-kw">const</span> TestUnion1 = <span class="tok-kw">packed</span> <span class="tok-kw">union</span> {</span>
<span class="line" id="L611"> a: <span class="tok-type">u32</span>,</span>
<span class="line" id="L612"> b: <span class="tok-type">u16</span>,</span>
<span class="line" id="L613"> };</span>
<span class="line" id="L614"></span>
<span class="line" id="L615"> <span class="tok-kw">try</span> testing.expect(!hasUniqueRepresentation(TestUnion1));</span>
<span class="line" id="L616"></span>
<span class="line" id="L617"> <span class="tok-kw">const</span> TestUnion2 = <span class="tok-kw">extern</span> <span class="tok-kw">union</span> {</span>
<span class="line" id="L618"> a: <span class="tok-type">u32</span>,</span>
<span class="line" id="L619"> b: <span class="tok-type">u16</span>,</span>
<span class="line" id="L620"> };</span>
<span class="line" id="L621"></span>
<span class="line" id="L622"> <span class="tok-kw">try</span> testing.expect(!hasUniqueRepresentation(TestUnion2));</span>
<span class="line" id="L623"></span>
<span class="line" id="L624"> <span class="tok-kw">const</span> TestUnion3 = <span class="tok-kw">union</span> {</span>
<span class="line" id="L625"> a: <span class="tok-type">u32</span>,</span>
<span class="line" id="L626"> b: <span class="tok-type">u16</span>,</span>
<span class="line" id="L627"> };</span>
<span class="line" id="L628"></span>
<span class="line" id="L629"> <span class="tok-kw">try</span> testing.expect(!hasUniqueRepresentation(TestUnion3));</span>
<span class="line" id="L630"></span>
<span class="line" id="L631"> <span class="tok-kw">const</span> TestUnion4 = <span class="tok-kw">union</span>(<span class="tok-kw">enum</span>) {</span>
<span class="line" id="L632"> a: <span class="tok-type">u32</span>,</span>
<span class="line" id="L633"> b: <span class="tok-type">u16</span>,</span>
<span class="line" id="L634"> };</span>
<span class="line" id="L635"></span>
<span class="line" id="L636"> <span class="tok-kw">try</span> testing.expect(!hasUniqueRepresentation(TestUnion4));</span>
<span class="line" id="L637"></span>
<span class="line" id="L638"> <span class="tok-kw">inline</span> <span class="tok-kw">for</span> ([_]<span class="tok-type">type</span>{ <span class="tok-type">i0</span>, <span class="tok-type">u8</span>, <span class="tok-type">i16</span>, <span class="tok-type">u32</span>, <span class="tok-type">i64</span> }) |T| {</span>
<span class="line" id="L639"> <span class="tok-kw">try</span> testing.expect(hasUniqueRepresentation(T));</span>
<span class="line" id="L640"> }</span>
<span class="line" id="L641"> <span class="tok-kw">inline</span> <span class="tok-kw">for</span> ([_]<span class="tok-type">type</span>{ <span class="tok-type">i1</span>, <span class="tok-type">u9</span>, <span class="tok-type">i17</span>, <span class="tok-type">u33</span>, <span class="tok-type">i24</span> }) |T| {</span>
<span class="line" id="L642"> <span class="tok-kw">try</span> testing.expect(!hasUniqueRepresentation(T));</span>
<span class="line" id="L643"> }</span>
<span class="line" id="L644"></span>
<span class="line" id="L645"> <span class="tok-kw">try</span> testing.expect(!hasUniqueRepresentation([]<span class="tok-type">u8</span>));</span>
<span class="line" id="L646"> <span class="tok-kw">try</span> testing.expect(!hasUniqueRepresentation([]<span class="tok-kw">const</span> <span class="tok-type">u8</span>));</span>
<span class="line" id="L647"></span>
<span class="line" id="L648"> <span class="tok-kw">try</span> testing.expect(hasUniqueRepresentation(<span class="tok-builtin">@Vector</span>(<span class="tok-number">4</span>, <span class="tok-type">u16</span>)));</span>
<span class="line" id="L649">}</span>
<span class="line" id="L650"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/meta/trailer_flags.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>meta/trailer_flags.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../std.zig"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> meta = std.meta;</span>
<span class="line" id="L3"><span class="tok-kw">const</span> testing = std.testing;</span>
<span class="line" id="L4"><span class="tok-kw">const</span> mem = std.mem;</span>
<span class="line" id="L5"><span class="tok-kw">const</span> assert = std.debug.assert;</span>
<span class="line" id="L6"><span class="tok-kw">const</span> Type = std.builtin.Type;</span>
<span class="line" id="L7"></span>
<span class="line" id="L8"><span class="tok-comment">/// This is useful for saving memory when allocating an object that has many</span></span>
<span class="line" id="L9"><span class="tok-comment">/// optional components. The optional objects are allocated sequentially in</span></span>
<span class="line" id="L10"><span class="tok-comment">/// memory, and a single integer is used to represent each optional object</span></span>
<span class="line" id="L11"><span class="tok-comment">/// and whether it is present based on each corresponding bit.</span></span>
<span class="line" id="L12"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">TrailerFlags</span>(<span class="tok-kw">comptime</span> Fields: <span class="tok-type">type</span>) <span class="tok-type">type</span> {</span>
<span class="line" id="L13"> <span class="tok-kw">return</span> <span class="tok-kw">struct</span> {</span>
<span class="line" id="L14"> bits: Int,</span>
<span class="line" id="L15"></span>
<span class="line" id="L16"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> Int = meta.Int(.unsigned, bit_count);</span>
<span class="line" id="L17"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> bit_count = <span class="tok-builtin">@typeInfo</span>(Fields).Struct.fields.len;</span>
<span class="line" id="L18"></span>
<span class="line" id="L19"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> FieldEnum = std.meta.FieldEnum(Fields);</span>
<span class="line" id="L20"></span>
<span class="line" id="L21"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> ActiveFields = std.enums.EnumFieldStruct(FieldEnum, <span class="tok-type">bool</span>, <span class="tok-null">false</span>);</span>
<span class="line" id="L22"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> FieldValues = blk: {</span>
<span class="line" id="L23"> <span class="tok-kw">comptime</span> <span class="tok-kw">var</span> fields: [bit_count]Type.StructField = <span class="tok-null">undefined</span>;</span>
<span class="line" id="L24"> <span class="tok-kw">inline</span> <span class="tok-kw">for</span> (<span class="tok-builtin">@typeInfo</span>(Fields).Struct.fields, <span class="tok-number">0</span>..) |struct_field, i| {</span>
<span class="line" id="L25"> fields[i] = Type.StructField{</span>
<span class="line" id="L26"> .name = struct_field.name,</span>
<span class="line" id="L27"> .<span class="tok-type">type</span> = ?struct_field.<span class="tok-type">type</span>,</span>
<span class="line" id="L28"> .default_value = &<span class="tok-builtin">@as</span>(?struct_field.<span class="tok-type">type</span>, <span class="tok-null">null</span>),</span>
<span class="line" id="L29"> .is_comptime = <span class="tok-null">false</span>,</span>
<span class="line" id="L30"> .alignment = <span class="tok-builtin">@alignOf</span>(?struct_field.<span class="tok-type">type</span>),</span>
<span class="line" id="L31"> };</span>
<span class="line" id="L32"> }</span>
<span class="line" id="L33"> <span class="tok-kw">break</span> :blk <span class="tok-builtin">@Type</span>(.{</span>
<span class="line" id="L34"> .Struct = .{</span>
<span class="line" id="L35"> .layout = .Auto,</span>
<span class="line" id="L36"> .fields = &fields,</span>
<span class="line" id="L37"> .decls = &.{},</span>
<span class="line" id="L38"> .is_tuple = <span class="tok-null">false</span>,</span>
<span class="line" id="L39"> },</span>
<span class="line" id="L40"> });</span>
<span class="line" id="L41"> };</span>
<span class="line" id="L42"></span>
<span class="line" id="L43"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> Self = <span class="tok-builtin">@This</span>();</span>
<span class="line" id="L44"></span>
<span class="line" id="L45"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">has</span>(self: Self, <span class="tok-kw">comptime</span> field: FieldEnum) <span class="tok-type">bool</span> {</span>
<span class="line" id="L46"> <span class="tok-kw">const</span> field_index = <span class="tok-builtin">@intFromEnum</span>(field);</span>
<span class="line" id="L47"> <span class="tok-kw">return</span> (self.bits & (<span class="tok-number">1</span> << field_index)) != <span class="tok-number">0</span>;</span>
<span class="line" id="L48"> }</span>
<span class="line" id="L49"></span>
<span class="line" id="L50"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">get</span>(self: Self, p: [*]<span class="tok-kw">align</span>(<span class="tok-builtin">@alignOf</span>(Fields)) <span class="tok-kw">const</span> <span class="tok-type">u8</span>, <span class="tok-kw">comptime</span> field: FieldEnum) ?Field(field) {</span>
<span class="line" id="L51"> <span class="tok-kw">if</span> (!self.has(field))</span>
<span class="line" id="L52"> <span class="tok-kw">return</span> <span class="tok-null">null</span>;</span>
<span class="line" id="L53"> <span class="tok-kw">return</span> self.ptrConst(p, field).*;</span>
<span class="line" id="L54"> }</span>
<span class="line" id="L55"></span>
<span class="line" id="L56"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">setFlag</span>(self: *Self, <span class="tok-kw">comptime</span> field: FieldEnum) <span class="tok-type">void</span> {</span>
<span class="line" id="L57"> <span class="tok-kw">const</span> field_index = <span class="tok-builtin">@intFromEnum</span>(field);</span>
<span class="line" id="L58"> self.bits |= <span class="tok-number">1</span> << field_index;</span>
<span class="line" id="L59"> }</span>
<span class="line" id="L60"></span>
<span class="line" id="L61"> <span class="tok-comment">/// `fields` is a boolean struct where each active field is set to `true`</span></span>
<span class="line" id="L62"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">init</span>(fields: ActiveFields) Self {</span>
<span class="line" id="L63"> <span class="tok-kw">var</span> self: Self = .{ .bits = <span class="tok-number">0</span> };</span>
<span class="line" id="L64"> <span class="tok-kw">inline</span> <span class="tok-kw">for</span> (<span class="tok-builtin">@typeInfo</span>(Fields).Struct.fields, <span class="tok-number">0</span>..) |field, i| {</span>
<span class="line" id="L65"> <span class="tok-kw">if</span> (<span class="tok-builtin">@field</span>(fields, field.name))</span>
<span class="line" id="L66"> self.bits |= <span class="tok-number">1</span> << i;</span>
<span class="line" id="L67"> }</span>
<span class="line" id="L68"> <span class="tok-kw">return</span> self;</span>
<span class="line" id="L69"> }</span>
<span class="line" id="L70"></span>
<span class="line" id="L71"> <span class="tok-comment">/// `fields` is a struct with each field set to an optional value</span></span>
<span class="line" id="L72"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">setMany</span>(self: Self, p: [*]<span class="tok-kw">align</span>(<span class="tok-builtin">@alignOf</span>(Fields)) <span class="tok-type">u8</span>, fields: FieldValues) <span class="tok-type">void</span> {</span>
<span class="line" id="L73"> <span class="tok-kw">inline</span> <span class="tok-kw">for</span> (<span class="tok-builtin">@typeInfo</span>(Fields).Struct.fields, <span class="tok-number">0</span>..) |field, i| {</span>
<span class="line" id="L74"> <span class="tok-kw">if</span> (<span class="tok-builtin">@field</span>(fields, field.name)) |value|</span>
<span class="line" id="L75"> self.set(p, <span class="tok-builtin">@as</span>(FieldEnum, <span class="tok-builtin">@enumFromInt</span>(i)), value);</span>
<span class="line" id="L76"> }</span>
<span class="line" id="L77"> }</span>
<span class="line" id="L78"></span>
<span class="line" id="L79"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">set</span>(</span>
<span class="line" id="L80"> self: Self,</span>
<span class="line" id="L81"> p: [*]<span class="tok-kw">align</span>(<span class="tok-builtin">@alignOf</span>(Fields)) <span class="tok-type">u8</span>,</span>
<span class="line" id="L82"> <span class="tok-kw">comptime</span> field: FieldEnum,</span>
<span class="line" id="L83"> value: Field(field),</span>
<span class="line" id="L84"> ) <span class="tok-type">void</span> {</span>
<span class="line" id="L85"> self.ptr(p, field).* = value;</span>
<span class="line" id="L86"> }</span>
<span class="line" id="L87"></span>
<span class="line" id="L88"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">ptr</span>(self: Self, p: [*]<span class="tok-kw">align</span>(<span class="tok-builtin">@alignOf</span>(Fields)) <span class="tok-type">u8</span>, <span class="tok-kw">comptime</span> field: FieldEnum) *Field(field) {</span>
<span class="line" id="L89"> <span class="tok-kw">if</span> (<span class="tok-builtin">@sizeOf</span>(Field(field)) == <span class="tok-number">0</span>)</span>
<span class="line" id="L90"> <span class="tok-kw">return</span> <span class="tok-null">undefined</span>;</span>
<span class="line" id="L91"> <span class="tok-kw">const</span> off = self.offset(field);</span>
<span class="line" id="L92"> <span class="tok-kw">return</span> <span class="tok-builtin">@ptrCast</span>(<span class="tok-builtin">@alignCast</span>(p + off));</span>
<span class="line" id="L93"> }</span>
<span class="line" id="L94"></span>
<span class="line" id="L95"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">ptrConst</span>(self: Self, p: [*]<span class="tok-kw">align</span>(<span class="tok-builtin">@alignOf</span>(Fields)) <span class="tok-kw">const</span> <span class="tok-type">u8</span>, <span class="tok-kw">comptime</span> field: FieldEnum) *<span class="tok-kw">const</span> Field(field) {</span>
<span class="line" id="L96"> <span class="tok-kw">if</span> (<span class="tok-builtin">@sizeOf</span>(Field(field)) == <span class="tok-number">0</span>)</span>
<span class="line" id="L97"> <span class="tok-kw">return</span> <span class="tok-null">undefined</span>;</span>
<span class="line" id="L98"> <span class="tok-kw">const</span> off = self.offset(field);</span>
<span class="line" id="L99"> <span class="tok-kw">return</span> <span class="tok-builtin">@ptrCast</span>(<span class="tok-builtin">@alignCast</span>(p + off));</span>
<span class="line" id="L100"> }</span>
<span class="line" id="L101"></span>
<span class="line" id="L102"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">offset</span>(self: Self, <span class="tok-kw">comptime</span> field: FieldEnum) <span class="tok-type">usize</span> {</span>
<span class="line" id="L103"> <span class="tok-kw">var</span> off: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L104"> <span class="tok-kw">inline</span> <span class="tok-kw">for</span> (<span class="tok-builtin">@typeInfo</span>(Fields).Struct.fields, <span class="tok-number">0</span>..) |field_info, i| {</span>
<span class="line" id="L105"> <span class="tok-kw">const</span> active = (self.bits & (<span class="tok-number">1</span> << i)) != <span class="tok-number">0</span>;</span>
<span class="line" id="L106"> <span class="tok-kw">if</span> (i == <span class="tok-builtin">@intFromEnum</span>(field)) {</span>
<span class="line" id="L107"> assert(active);</span>
<span class="line" id="L108"> <span class="tok-kw">return</span> mem.alignForward(<span class="tok-type">usize</span>, off, <span class="tok-builtin">@alignOf</span>(field_info.<span class="tok-type">type</span>));</span>
<span class="line" id="L109"> } <span class="tok-kw">else</span> <span class="tok-kw">if</span> (active) {</span>
<span class="line" id="L110"> off = mem.alignForward(<span class="tok-type">usize</span>, off, <span class="tok-builtin">@alignOf</span>(field_info.<span class="tok-type">type</span>));</span>
<span class="line" id="L111"> off += <span class="tok-builtin">@sizeOf</span>(field_info.<span class="tok-type">type</span>);</span>
<span class="line" id="L112"> }</span>
<span class="line" id="L113"> }</span>
<span class="line" id="L114"> }</span>
<span class="line" id="L115"></span>
<span class="line" id="L116"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">Field</span>(<span class="tok-kw">comptime</span> field: FieldEnum) <span class="tok-type">type</span> {</span>
<span class="line" id="L117"> <span class="tok-kw">return</span> <span class="tok-builtin">@typeInfo</span>(Fields).Struct.fields[<span class="tok-builtin">@intFromEnum</span>(field)].<span class="tok-type">type</span>;</span>
<span class="line" id="L118"> }</span>
<span class="line" id="L119"></span>
<span class="line" id="L120"> <span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">sizeInBytes</span>(self: Self) <span class="tok-type">usize</span> {</span>
<span class="line" id="L121"> <span class="tok-kw">var</span> off: <span class="tok-type">usize</span> = <span class="tok-number">0</span>;</span>
<span class="line" id="L122"> <span class="tok-kw">inline</span> <span class="tok-kw">for</span> (<span class="tok-builtin">@typeInfo</span>(Fields).Struct.fields, <span class="tok-number">0</span>..) |field, i| {</span>
<span class="line" id="L123"> <span class="tok-kw">if</span> (<span class="tok-builtin">@sizeOf</span>(field.<span class="tok-type">type</span>) == <span class="tok-number">0</span>)</span>
<span class="line" id="L124"> <span class="tok-kw">continue</span>;</span>
<span class="line" id="L125"> <span class="tok-kw">if</span> ((self.bits & (<span class="tok-number">1</span> << i)) != <span class="tok-number">0</span>) {</span>
<span class="line" id="L126"> off = mem.alignForward(<span class="tok-type">usize</span>, off, <span class="tok-builtin">@alignOf</span>(field.<span class="tok-type">type</span>));</span>
<span class="line" id="L127"> off += <span class="tok-builtin">@sizeOf</span>(field.<span class="tok-type">type</span>);</span>
<span class="line" id="L128"> }</span>
<span class="line" id="L129"> }</span>
<span class="line" id="L130"> <span class="tok-kw">return</span> off;</span>
<span class="line" id="L131"> }</span>
<span class="line" id="L132"> };</span>
<span class="line" id="L133">}</span>
<span class="line" id="L134"></span>
<span class="line" id="L135"><span class="tok-kw">test</span> <span class="tok-str">"TrailerFlags"</span> {</span>
<span class="line" id="L136"> <span class="tok-kw">const</span> Flags = TrailerFlags(<span class="tok-kw">struct</span> {</span>
<span class="line" id="L137"> a: <span class="tok-type">i32</span>,</span>
<span class="line" id="L138"> b: <span class="tok-type">bool</span>,</span>
<span class="line" id="L139"> c: <span class="tok-type">u64</span>,</span>
<span class="line" id="L140"> });</span>
<span class="line" id="L141"> <span class="tok-kw">try</span> testing.expectEqual(<span class="tok-type">u2</span>, meta.Tag(Flags.FieldEnum));</span>
<span class="line" id="L142"></span>
<span class="line" id="L143"> <span class="tok-kw">var</span> flags = Flags.init(.{</span>
<span class="line" id="L144"> .b = <span class="tok-null">true</span>,</span>
<span class="line" id="L145"> .c = <span class="tok-null">true</span>,</span>
<span class="line" id="L146"> });</span>
<span class="line" id="L147"> <span class="tok-kw">const</span> slice = <span class="tok-kw">try</span> testing.allocator.alignedAlloc(<span class="tok-type">u8</span>, <span class="tok-number">8</span>, flags.sizeInBytes());</span>
<span class="line" id="L148"> <span class="tok-kw">defer</span> testing.allocator.free(slice);</span>
<span class="line" id="L149"></span>
<span class="line" id="L150"> flags.set(slice.ptr, .b, <span class="tok-null">false</span>);</span>
<span class="line" id="L151"> flags.set(slice.ptr, .c, <span class="tok-number">12345678</span>);</span>
<span class="line" id="L152"></span>
<span class="line" id="L153"> <span class="tok-kw">try</span> testing.expect(flags.get(slice.ptr, .a) == <span class="tok-null">null</span>);</span>
<span class="line" id="L154"> <span class="tok-kw">try</span> testing.expect(!flags.get(slice.ptr, .b).?);</span>
<span class="line" id="L155"> <span class="tok-kw">try</span> testing.expect(flags.get(slice.ptr, .c).? == <span class="tok-number">12345678</span>);</span>
<span class="line" id="L156"></span>
<span class="line" id="L157"> flags.setMany(slice.ptr, .{</span>
<span class="line" id="L158"> .b = <span class="tok-null">true</span>,</span>
<span class="line" id="L159"> .c = <span class="tok-number">5678</span>,</span>
<span class="line" id="L160"> });</span>
<span class="line" id="L161"></span>
<span class="line" id="L162"> <span class="tok-kw">try</span> testing.expect(flags.get(slice.ptr, .a) == <span class="tok-null">null</span>);</span>
<span class="line" id="L163"> <span class="tok-kw">try</span> testing.expect(flags.get(slice.ptr, .b).?);</span>
<span class="line" id="L164"> <span class="tok-kw">try</span> testing.expect(flags.get(slice.ptr, .c).? == <span class="tok-number">5678</span>);</span>
<span class="line" id="L165">}</span>
<span class="line" id="L166"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/dwarf/FORM.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>dwarf/FORM.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> addr = <span class="tok-number">0x01</span>;</span>
<span class="line" id="L2"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> block2 = <span class="tok-number">0x03</span>;</span>
<span class="line" id="L3"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> block4 = <span class="tok-number">0x04</span>;</span>
<span class="line" id="L4"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> data2 = <span class="tok-number">0x05</span>;</span>
<span class="line" id="L5"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> data4 = <span class="tok-number">0x06</span>;</span>
<span class="line" id="L6"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> data8 = <span class="tok-number">0x07</span>;</span>
<span class="line" id="L7"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> string = <span class="tok-number">0x08</span>;</span>
<span class="line" id="L8"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> block = <span class="tok-number">0x09</span>;</span>
<span class="line" id="L9"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> block1 = <span class="tok-number">0x0a</span>;</span>
<span class="line" id="L10"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> data1 = <span class="tok-number">0x0b</span>;</span>
<span class="line" id="L11"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> flag = <span class="tok-number">0x0c</span>;</span>
<span class="line" id="L12"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> sdata = <span class="tok-number">0x0d</span>;</span>
<span class="line" id="L13"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> strp = <span class="tok-number">0x0e</span>;</span>
<span class="line" id="L14"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> udata = <span class="tok-number">0x0f</span>;</span>
<span class="line" id="L15"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> ref_addr = <span class="tok-number">0x10</span>;</span>
<span class="line" id="L16"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> ref1 = <span class="tok-number">0x11</span>;</span>
<span class="line" id="L17"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> ref2 = <span class="tok-number">0x12</span>;</span>
<span class="line" id="L18"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> ref4 = <span class="tok-number">0x13</span>;</span>
<span class="line" id="L19"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> ref8 = <span class="tok-number">0x14</span>;</span>
<span class="line" id="L20"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> ref_udata = <span class="tok-number">0x15</span>;</span>
<span class="line" id="L21"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> indirect = <span class="tok-number">0x16</span>;</span>
<span class="line" id="L22"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> sec_offset = <span class="tok-number">0x17</span>;</span>
<span class="line" id="L23"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> exprloc = <span class="tok-number">0x18</span>;</span>
<span class="line" id="L24"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> flag_present = <span class="tok-number">0x19</span>;</span>
<span class="line" id="L25"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> strx = <span class="tok-number">0x1a</span>;</span>
<span class="line" id="L26"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> addrx = <span class="tok-number">0x1b</span>;</span>
<span class="line" id="L27"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> ref_sup4 = <span class="tok-number">0x1c</span>;</span>
<span class="line" id="L28"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> strp_sup = <span class="tok-number">0x1d</span>;</span>
<span class="line" id="L29"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> data16 = <span class="tok-number">0x1e</span>;</span>
<span class="line" id="L30"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> line_strp = <span class="tok-number">0x1f</span>;</span>
<span class="line" id="L31"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> ref_sig8 = <span class="tok-number">0x20</span>;</span>
<span class="line" id="L32"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> implicit_const = <span class="tok-number">0x21</span>;</span>
<span class="line" id="L33"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> loclistx = <span class="tok-number">0x22</span>;</span>
<span class="line" id="L34"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> rnglistx = <span class="tok-number">0x23</span>;</span>
<span class="line" id="L35"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> ref_sup8 = <span class="tok-number">0x24</span>;</span>
<span class="line" id="L36"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> strx1 = <span class="tok-number">0x25</span>;</span>
<span class="line" id="L37"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> strx2 = <span class="tok-number">0x26</span>;</span>
<span class="line" id="L38"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> strx3 = <span class="tok-number">0x27</span>;</span>
<span class="line" id="L39"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> strx4 = <span class="tok-number">0x28</span>;</span>
<span class="line" id="L40"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> addrx1 = <span class="tok-number">0x29</span>;</span>
<span class="line" id="L41"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> addrx2 = <span class="tok-number">0x2a</span>;</span>
<span class="line" id="L42"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> addrx3 = <span class="tok-number">0x2b</span>;</span>
<span class="line" id="L43"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> addrx4 = <span class="tok-number">0x2c</span>;</span>
<span class="line" id="L44"></span>
<span class="line" id="L45"><span class="tok-comment">// Extensions for Fission. See http://gcc.gnu.org/wiki/DebugFission.</span>
</span>
<span class="line" id="L46"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> GNU_addr_index = <span class="tok-number">0x1f01</span>;</span>
<span class="line" id="L47"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> GNU_str_index = <span class="tok-number">0x1f02</span>;</span>
<span class="line" id="L48"></span>
<span class="line" id="L49"><span class="tok-comment">// Extensions for DWZ multifile.</span>
</span>
<span class="line" id="L50"><span class="tok-comment">// See http://www.dwarfstd.org/ShowIssue.php?issue=120604.1&type=open .</span>
</span>
<span class="line" id="L51"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> GNU_ref_alt = <span class="tok-number">0x1f20</span>;</span>
<span class="line" id="L52"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> GNU_strp_alt = <span class="tok-number">0x1f21</span>;</span>
<span class="line" id="L53"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/dwarf/AT.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>dwarf/AT.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> sibling = <span class="tok-number">0x01</span>;</span>
<span class="line" id="L2"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> location = <span class="tok-number">0x02</span>;</span>
<span class="line" id="L3"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> name = <span class="tok-number">0x03</span>;</span>
<span class="line" id="L4"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> ordering = <span class="tok-number">0x09</span>;</span>
<span class="line" id="L5"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> subscr_data = <span class="tok-number">0x0a</span>;</span>
<span class="line" id="L6"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> byte_size = <span class="tok-number">0x0b</span>;</span>
<span class="line" id="L7"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> bit_offset = <span class="tok-number">0x0c</span>;</span>
<span class="line" id="L8"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> bit_size = <span class="tok-number">0x0d</span>;</span>
<span class="line" id="L9"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> element_list = <span class="tok-number">0x0f</span>;</span>
<span class="line" id="L10"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> stmt_list = <span class="tok-number">0x10</span>;</span>
<span class="line" id="L11"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> low_pc = <span class="tok-number">0x11</span>;</span>
<span class="line" id="L12"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> high_pc = <span class="tok-number">0x12</span>;</span>
<span class="line" id="L13"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> language = <span class="tok-number">0x13</span>;</span>
<span class="line" id="L14"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> member = <span class="tok-number">0x14</span>;</span>
<span class="line" id="L15"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> discr = <span class="tok-number">0x15</span>;</span>
<span class="line" id="L16"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> discr_value = <span class="tok-number">0x16</span>;</span>
<span class="line" id="L17"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> visibility = <span class="tok-number">0x17</span>;</span>
<span class="line" id="L18"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> import = <span class="tok-number">0x18</span>;</span>
<span class="line" id="L19"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> string_length = <span class="tok-number">0x19</span>;</span>
<span class="line" id="L20"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> common_reference = <span class="tok-number">0x1a</span>;</span>
<span class="line" id="L21"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> comp_dir = <span class="tok-number">0x1b</span>;</span>
<span class="line" id="L22"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> const_value = <span class="tok-number">0x1c</span>;</span>
<span class="line" id="L23"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> containing_type = <span class="tok-number">0x1d</span>;</span>
<span class="line" id="L24"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> default_value = <span class="tok-number">0x1e</span>;</span>
<span class="line" id="L25"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> @"inline" = <span class="tok-number">0x20</span>;</span>
<span class="line" id="L26"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> is_optional = <span class="tok-number">0x21</span>;</span>
<span class="line" id="L27"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> lower_bound = <span class="tok-number">0x22</span>;</span>
<span class="line" id="L28"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> producer = <span class="tok-number">0x25</span>;</span>
<span class="line" id="L29"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> prototyped = <span class="tok-number">0x27</span>;</span>
<span class="line" id="L30"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> return_addr = <span class="tok-number">0x2a</span>;</span>
<span class="line" id="L31"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> start_scope = <span class="tok-number">0x2c</span>;</span>
<span class="line" id="L32"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> bit_stride = <span class="tok-number">0x2e</span>;</span>
<span class="line" id="L33"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> upper_bound = <span class="tok-number">0x2f</span>;</span>
<span class="line" id="L34"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> abstract_origin = <span class="tok-number">0x31</span>;</span>
<span class="line" id="L35"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> accessibility = <span class="tok-number">0x32</span>;</span>
<span class="line" id="L36"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> address_class = <span class="tok-number">0x33</span>;</span>
<span class="line" id="L37"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> artificial = <span class="tok-number">0x34</span>;</span>
<span class="line" id="L38"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> base_types = <span class="tok-number">0x35</span>;</span>
<span class="line" id="L39"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> calling_convention = <span class="tok-number">0x36</span>;</span>
<span class="line" id="L40"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> count = <span class="tok-number">0x37</span>;</span>
<span class="line" id="L41"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> data_member_location = <span class="tok-number">0x38</span>;</span>
<span class="line" id="L42"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> decl_column = <span class="tok-number">0x39</span>;</span>
<span class="line" id="L43"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> decl_file = <span class="tok-number">0x3a</span>;</span>
<span class="line" id="L44"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> decl_line = <span class="tok-number">0x3b</span>;</span>
<span class="line" id="L45"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> declaration = <span class="tok-number">0x3c</span>;</span>
<span class="line" id="L46"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> discr_list = <span class="tok-number">0x3d</span>;</span>
<span class="line" id="L47"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> encoding = <span class="tok-number">0x3e</span>;</span>
<span class="line" id="L48"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> external = <span class="tok-number">0x3f</span>;</span>
<span class="line" id="L49"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> frame_base = <span class="tok-number">0x40</span>;</span>
<span class="line" id="L50"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> friend = <span class="tok-number">0x41</span>;</span>
<span class="line" id="L51"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> identifier_case = <span class="tok-number">0x42</span>;</span>
<span class="line" id="L52"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> macro_info = <span class="tok-number">0x43</span>;</span>
<span class="line" id="L53"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> namelist_items = <span class="tok-number">0x44</span>;</span>
<span class="line" id="L54"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> priority = <span class="tok-number">0x45</span>;</span>
<span class="line" id="L55"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> segment = <span class="tok-number">0x46</span>;</span>
<span class="line" id="L56"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> specification = <span class="tok-number">0x47</span>;</span>
<span class="line" id="L57"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> static_link = <span class="tok-number">0x48</span>;</span>
<span class="line" id="L58"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> @"type" = <span class="tok-number">0x49</span>;</span>
<span class="line" id="L59"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> use_location = <span class="tok-number">0x4a</span>;</span>
<span class="line" id="L60"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> variable_parameter = <span class="tok-number">0x4b</span>;</span>
<span class="line" id="L61"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> virtuality = <span class="tok-number">0x4c</span>;</span>
<span class="line" id="L62"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> vtable_elem_location = <span class="tok-number">0x4d</span>;</span>
<span class="line" id="L63"></span>
<span class="line" id="L64"><span class="tok-comment">// DWARF 3 values.</span>
</span>
<span class="line" id="L65"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> allocated = <span class="tok-number">0x4e</span>;</span>
<span class="line" id="L66"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> associated = <span class="tok-number">0x4f</span>;</span>
<span class="line" id="L67"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> data_location = <span class="tok-number">0x50</span>;</span>
<span class="line" id="L68"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> byte_stride = <span class="tok-number">0x51</span>;</span>
<span class="line" id="L69"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> entry_pc = <span class="tok-number">0x52</span>;</span>
<span class="line" id="L70"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> use_UTF8 = <span class="tok-number">0x53</span>;</span>
<span class="line" id="L71"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> extension = <span class="tok-number">0x54</span>;</span>
<span class="line" id="L72"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> ranges = <span class="tok-number">0x55</span>;</span>
<span class="line" id="L73"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> trampoline = <span class="tok-number">0x56</span>;</span>
<span class="line" id="L74"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> call_column = <span class="tok-number">0x57</span>;</span>
<span class="line" id="L75"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> call_file = <span class="tok-number">0x58</span>;</span>
<span class="line" id="L76"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> call_line = <span class="tok-number">0x59</span>;</span>
<span class="line" id="L77"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> description = <span class="tok-number">0x5a</span>;</span>
<span class="line" id="L78"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> binary_scale = <span class="tok-number">0x5b</span>;</span>
<span class="line" id="L79"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> decimal_scale = <span class="tok-number">0x5c</span>;</span>
<span class="line" id="L80"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> small = <span class="tok-number">0x5d</span>;</span>
<span class="line" id="L81"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> decimal_sign = <span class="tok-number">0x5e</span>;</span>
<span class="line" id="L82"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> digit_count = <span class="tok-number">0x5f</span>;</span>
<span class="line" id="L83"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> picture_string = <span class="tok-number">0x60</span>;</span>
<span class="line" id="L84"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> mutable = <span class="tok-number">0x61</span>;</span>
<span class="line" id="L85"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> threads_scaled = <span class="tok-number">0x62</span>;</span>
<span class="line" id="L86"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> explicit = <span class="tok-number">0x63</span>;</span>
<span class="line" id="L87"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> object_pointer = <span class="tok-number">0x64</span>;</span>
<span class="line" id="L88"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> endianity = <span class="tok-number">0x65</span>;</span>
<span class="line" id="L89"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> elemental = <span class="tok-number">0x66</span>;</span>
<span class="line" id="L90"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> pure = <span class="tok-number">0x67</span>;</span>
<span class="line" id="L91"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> recursive = <span class="tok-number">0x68</span>;</span>
<span class="line" id="L92"></span>
<span class="line" id="L93"><span class="tok-comment">// DWARF 4.</span>
</span>
<span class="line" id="L94"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> signature = <span class="tok-number">0x69</span>;</span>
<span class="line" id="L95"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> main_subprogram = <span class="tok-number">0x6a</span>;</span>
<span class="line" id="L96"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> data_bit_offset = <span class="tok-number">0x6b</span>;</span>
<span class="line" id="L97"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> const_expr = <span class="tok-number">0x6c</span>;</span>
<span class="line" id="L98"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> enum_class = <span class="tok-number">0x6d</span>;</span>
<span class="line" id="L99"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> linkage_name = <span class="tok-number">0x6e</span>;</span>
<span class="line" id="L100"></span>
<span class="line" id="L101"><span class="tok-comment">// DWARF 5</span>
</span>
<span class="line" id="L102"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> string_length_bit_size = <span class="tok-number">0x6f</span>;</span>
<span class="line" id="L103"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> string_length_byte_size = <span class="tok-number">0x70</span>;</span>
<span class="line" id="L104"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> rank = <span class="tok-number">0x71</span>;</span>
<span class="line" id="L105"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> str_offsets_base = <span class="tok-number">0x72</span>;</span>
<span class="line" id="L106"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> addr_base = <span class="tok-number">0x73</span>;</span>
<span class="line" id="L107"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> rnglists_base = <span class="tok-number">0x74</span>;</span>
<span class="line" id="L108"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> dwo_name = <span class="tok-number">0x76</span>;</span>
<span class="line" id="L109"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> reference = <span class="tok-number">0x77</span>;</span>
<span class="line" id="L110"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> rvalue_reference = <span class="tok-number">0x78</span>;</span>
<span class="line" id="L111"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> macros = <span class="tok-number">0x79</span>;</span>
<span class="line" id="L112"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> call_all_calls = <span class="tok-number">0x7a</span>;</span>
<span class="line" id="L113"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> call_all_source_calls = <span class="tok-number">0x7b</span>;</span>
<span class="line" id="L114"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> call_all_tail_calls = <span class="tok-number">0x7c</span>;</span>
<span class="line" id="L115"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> call_return_pc = <span class="tok-number">0x7d</span>;</span>
<span class="line" id="L116"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> call_value = <span class="tok-number">0x7e</span>;</span>
<span class="line" id="L117"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> call_origin = <span class="tok-number">0x7f</span>;</span>
<span class="line" id="L118"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> call_parameter = <span class="tok-number">0x80</span>;</span>
<span class="line" id="L119"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> call_pc = <span class="tok-number">0x81</span>;</span>
<span class="line" id="L120"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> call_tail_call = <span class="tok-number">0x82</span>;</span>
<span class="line" id="L121"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> call_target = <span class="tok-number">0x83</span>;</span>
<span class="line" id="L122"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> call_target_clobbered = <span class="tok-number">0x84</span>;</span>
<span class="line" id="L123"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> call_data_location = <span class="tok-number">0x85</span>;</span>
<span class="line" id="L124"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> call_data_value = <span class="tok-number">0x86</span>;</span>
<span class="line" id="L125"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> @"noreturn" = <span class="tok-number">0x87</span>;</span>
<span class="line" id="L126"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> alignment = <span class="tok-number">0x88</span>;</span>
<span class="line" id="L127"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> export_symbols = <span class="tok-number">0x89</span>;</span>
<span class="line" id="L128"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> deleted = <span class="tok-number">0x8a</span>;</span>
<span class="line" id="L129"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> defaulted = <span class="tok-number">0x8b</span>;</span>
<span class="line" id="L130"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> loclists_base = <span class="tok-number">0x8c</span>;</span>
<span class="line" id="L131"></span>
<span class="line" id="L132"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> lo_user = <span class="tok-number">0x2000</span>; <span class="tok-comment">// Implementation-defined range start.</span>
</span>
<span class="line" id="L133"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> hi_user = <span class="tok-number">0x3fff</span>; <span class="tok-comment">// Implementation-defined range end.</span>
</span>
<span class="line" id="L134"></span>
<span class="line" id="L135"><span class="tok-comment">// SGI/MIPS extensions.</span>
</span>
<span class="line" id="L136"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> MIPS_fde = <span class="tok-number">0x2001</span>;</span>
<span class="line" id="L137"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> MIPS_loop_begin = <span class="tok-number">0x2002</span>;</span>
<span class="line" id="L138"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> MIPS_tail_loop_begin = <span class="tok-number">0x2003</span>;</span>
<span class="line" id="L139"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> MIPS_epilog_begin = <span class="tok-number">0x2004</span>;</span>
<span class="line" id="L140"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> MIPS_loop_unroll_factor = <span class="tok-number">0x2005</span>;</span>
<span class="line" id="L141"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> MIPS_software_pipeline_depth = <span class="tok-number">0x2006</span>;</span>
<span class="line" id="L142"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> MIPS_linkage_name = <span class="tok-number">0x2007</span>;</span>
<span class="line" id="L143"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> MIPS_stride = <span class="tok-number">0x2008</span>;</span>
<span class="line" id="L144"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> MIPS_abstract_name = <span class="tok-number">0x2009</span>;</span>
<span class="line" id="L145"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> MIPS_clone_origin = <span class="tok-number">0x200a</span>;</span>
<span class="line" id="L146"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> MIPS_has_inlines = <span class="tok-number">0x200b</span>;</span>
<span class="line" id="L147"></span>
<span class="line" id="L148"><span class="tok-comment">// HP extensions.</span>
</span>
<span class="line" id="L149"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> HP_block_index = <span class="tok-number">0x2000</span>;</span>
<span class="line" id="L150"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> HP_unmodifiable = <span class="tok-number">0x2001</span>; <span class="tok-comment">// Same as AT.MIPS_fde.</span>
</span>
<span class="line" id="L151"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> HP_prologue = <span class="tok-number">0x2005</span>; <span class="tok-comment">// Same as AT.MIPS_loop_unroll.</span>
</span>
<span class="line" id="L152"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> HP_epilogue = <span class="tok-number">0x2008</span>; <span class="tok-comment">// Same as AT.MIPS_stride.</span>
</span>
<span class="line" id="L153"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> HP_actuals_stmt_list = <span class="tok-number">0x2010</span>;</span>
<span class="line" id="L154"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> HP_proc_per_section = <span class="tok-number">0x2011</span>;</span>
<span class="line" id="L155"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> HP_raw_data_ptr = <span class="tok-number">0x2012</span>;</span>
<span class="line" id="L156"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> HP_pass_by_reference = <span class="tok-number">0x2013</span>;</span>
<span class="line" id="L157"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> HP_opt_level = <span class="tok-number">0x2014</span>;</span>
<span class="line" id="L158"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> HP_prof_version_id = <span class="tok-number">0x2015</span>;</span>
<span class="line" id="L159"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> HP_opt_flags = <span class="tok-number">0x2016</span>;</span>
<span class="line" id="L160"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> HP_cold_region_low_pc = <span class="tok-number">0x2017</span>;</span>
<span class="line" id="L161"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> HP_cold_region_high_pc = <span class="tok-number">0x2018</span>;</span>
<span class="line" id="L162"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> HP_all_variables_modifiable = <span class="tok-number">0x2019</span>;</span>
<span class="line" id="L163"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> HP_linkage_name = <span class="tok-number">0x201a</span>;</span>
<span class="line" id="L164"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> HP_prof_flags = <span class="tok-number">0x201b</span>; <span class="tok-comment">// In comp unit of procs_info for -g.</span>
</span>
<span class="line" id="L165"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> HP_unit_name = <span class="tok-number">0x201f</span>;</span>
<span class="line" id="L166"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> HP_unit_size = <span class="tok-number">0x2020</span>;</span>
<span class="line" id="L167"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> HP_widened_byte_size = <span class="tok-number">0x2021</span>;</span>
<span class="line" id="L168"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> HP_definition_points = <span class="tok-number">0x2022</span>;</span>
<span class="line" id="L169"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> HP_default_location = <span class="tok-number">0x2023</span>;</span>
<span class="line" id="L170"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> HP_is_result_param = <span class="tok-number">0x2029</span>;</span>
<span class="line" id="L171"></span>
<span class="line" id="L172"><span class="tok-comment">// GNU extensions.</span>
</span>
<span class="line" id="L173"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> sf_names = <span class="tok-number">0x2101</span>;</span>
<span class="line" id="L174"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> src_info = <span class="tok-number">0x2102</span>;</span>
<span class="line" id="L175"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> mac_info = <span class="tok-number">0x2103</span>;</span>
<span class="line" id="L176"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> src_coords = <span class="tok-number">0x2104</span>;</span>
<span class="line" id="L177"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> body_begin = <span class="tok-number">0x2105</span>;</span>
<span class="line" id="L178"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> body_end = <span class="tok-number">0x2106</span>;</span>
<span class="line" id="L179"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> GNU_vector = <span class="tok-number">0x2107</span>;</span>
<span class="line" id="L180"><span class="tok-comment">// Thread-safety annotations.</span>
</span>
<span class="line" id="L181"><span class="tok-comment">// See http://gcc.gnu.org/wiki/ThreadSafetyAnnotation .</span>
</span>
<span class="line" id="L182"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> GNU_guarded_by = <span class="tok-number">0x2108</span>;</span>
<span class="line" id="L183"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> GNU_pt_guarded_by = <span class="tok-number">0x2109</span>;</span>
<span class="line" id="L184"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> GNU_guarded = <span class="tok-number">0x210a</span>;</span>
<span class="line" id="L185"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> GNU_pt_guarded = <span class="tok-number">0x210b</span>;</span>
<span class="line" id="L186"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> GNU_locks_excluded = <span class="tok-number">0x210c</span>;</span>
<span class="line" id="L187"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> GNU_exclusive_locks_required = <span class="tok-number">0x210d</span>;</span>
<span class="line" id="L188"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> GNU_shared_locks_required = <span class="tok-number">0x210e</span>;</span>
<span class="line" id="L189"><span class="tok-comment">// One-definition rule violation detection.</span>
</span>
<span class="line" id="L190"><span class="tok-comment">// See http://gcc.gnu.org/wiki/DwarfSeparateTypeInfo .</span>
</span>
<span class="line" id="L191"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> GNU_odr_signature = <span class="tok-number">0x210f</span>;</span>
<span class="line" id="L192"><span class="tok-comment">// Template template argument name.</span>
</span>
<span class="line" id="L193"><span class="tok-comment">// See http://gcc.gnu.org/wiki/TemplateParmsDwarf .</span>
</span>
<span class="line" id="L194"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> GNU_template_name = <span class="tok-number">0x2110</span>;</span>
<span class="line" id="L195"><span class="tok-comment">// The GNU call site extension.</span>
</span>
<span class="line" id="L196"><span class="tok-comment">// See http://www.dwarfstd.org/ShowIssue.php?issue=100909.2&type=open .</span>
</span>
<span class="line" id="L197"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> GNU_call_site_value = <span class="tok-number">0x2111</span>;</span>
<span class="line" id="L198"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> GNU_call_site_data_value = <span class="tok-number">0x2112</span>;</span>
<span class="line" id="L199"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> GNU_call_site_target = <span class="tok-number">0x2113</span>;</span>
<span class="line" id="L200"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> GNU_call_site_target_clobbered = <span class="tok-number">0x2114</span>;</span>
<span class="line" id="L201"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> GNU_tail_call = <span class="tok-number">0x2115</span>;</span>
<span class="line" id="L202"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> GNU_all_tail_call_sites = <span class="tok-number">0x2116</span>;</span>
<span class="line" id="L203"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> GNU_all_call_sites = <span class="tok-number">0x2117</span>;</span>
<span class="line" id="L204"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> GNU_all_source_call_sites = <span class="tok-number">0x2118</span>;</span>
<span class="line" id="L205"><span class="tok-comment">// Section offset into .debug_macro section.</span>
</span>
<span class="line" id="L206"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> GNU_macros = <span class="tok-number">0x2119</span>;</span>
<span class="line" id="L207"><span class="tok-comment">// Extensions for Fission. See http://gcc.gnu.org/wiki/DebugFission.</span>
</span>
<span class="line" id="L208"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> GNU_dwo_name = <span class="tok-number">0x2130</span>;</span>
<span class="line" id="L209"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> GNU_dwo_id = <span class="tok-number">0x2131</span>;</span>
<span class="line" id="L210"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> GNU_ranges_base = <span class="tok-number">0x2132</span>;</span>
<span class="line" id="L211"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> GNU_addr_base = <span class="tok-number">0x2133</span>;</span>
<span class="line" id="L212"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> GNU_pubnames = <span class="tok-number">0x2134</span>;</span>
<span class="line" id="L213"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> GNU_pubtypes = <span class="tok-number">0x2135</span>;</span>
<span class="line" id="L214"><span class="tok-comment">// VMS extensions.</span>
</span>
<span class="line" id="L215"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> VMS_rtnbeg_pd_address = <span class="tok-number">0x2201</span>;</span>
<span class="line" id="L216"><span class="tok-comment">// GNAT extensions.</span>
</span>
<span class="line" id="L217"><span class="tok-comment">// GNAT descriptive type.</span>
</span>
<span class="line" id="L218"><span class="tok-comment">// See http://gcc.gnu.org/wiki/DW_AT_GNAT_descriptive_type .</span>
</span>
<span class="line" id="L219"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> use_GNAT_descriptive_type = <span class="tok-number">0x2301</span>;</span>
<span class="line" id="L220"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> GNAT_descriptive_type = <span class="tok-number">0x2302</span>;</span>
<span class="line" id="L221"><span class="tok-comment">// UPC extension.</span>
</span>
<span class="line" id="L222"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> upc_threads_scaled = <span class="tok-number">0x3210</span>;</span>
<span class="line" id="L223"><span class="tok-comment">// PGI (STMicroelectronics) extensions.</span>
</span>
<span class="line" id="L224"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> PGI_lbase = <span class="tok-number">0x3a00</span>;</span>
<span class="line" id="L225"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> PGI_soffset = <span class="tok-number">0x3a01</span>;</span>
<span class="line" id="L226"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> PGI_lstride = <span class="tok-number">0x3a02</span>;</span>
<span class="line" id="L227"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/dwarf/OP.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>dwarf/OP.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> addr = <span class="tok-number">0x03</span>;</span>
<span class="line" id="L2"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> deref = <span class="tok-number">0x06</span>;</span>
<span class="line" id="L3"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> const1u = <span class="tok-number">0x08</span>;</span>
<span class="line" id="L4"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> const1s = <span class="tok-number">0x09</span>;</span>
<span class="line" id="L5"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> const2u = <span class="tok-number">0x0a</span>;</span>
<span class="line" id="L6"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> const2s = <span class="tok-number">0x0b</span>;</span>
<span class="line" id="L7"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> const4u = <span class="tok-number">0x0c</span>;</span>
<span class="line" id="L8"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> const4s = <span class="tok-number">0x0d</span>;</span>
<span class="line" id="L9"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> const8u = <span class="tok-number">0x0e</span>;</span>
<span class="line" id="L10"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> const8s = <span class="tok-number">0x0f</span>;</span>
<span class="line" id="L11"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> constu = <span class="tok-number">0x10</span>;</span>
<span class="line" id="L12"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> consts = <span class="tok-number">0x11</span>;</span>
<span class="line" id="L13"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> dup = <span class="tok-number">0x12</span>;</span>
<span class="line" id="L14"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> drop = <span class="tok-number">0x13</span>;</span>
<span class="line" id="L15"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> over = <span class="tok-number">0x14</span>;</span>
<span class="line" id="L16"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> pick = <span class="tok-number">0x15</span>;</span>
<span class="line" id="L17"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> swap = <span class="tok-number">0x16</span>;</span>
<span class="line" id="L18"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> rot = <span class="tok-number">0x17</span>;</span>
<span class="line" id="L19"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> xderef = <span class="tok-number">0x18</span>;</span>
<span class="line" id="L20"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> abs = <span class="tok-number">0x19</span>;</span>
<span class="line" id="L21"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> @"and" = <span class="tok-number">0x1a</span>;</span>
<span class="line" id="L22"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> div = <span class="tok-number">0x1b</span>;</span>
<span class="line" id="L23"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> minus = <span class="tok-number">0x1c</span>;</span>
<span class="line" id="L24"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> mod = <span class="tok-number">0x1d</span>;</span>
<span class="line" id="L25"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> mul = <span class="tok-number">0x1e</span>;</span>
<span class="line" id="L26"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> neg = <span class="tok-number">0x1f</span>;</span>
<span class="line" id="L27"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> not = <span class="tok-number">0x20</span>;</span>
<span class="line" id="L28"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> @"or" = <span class="tok-number">0x21</span>;</span>
<span class="line" id="L29"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> plus = <span class="tok-number">0x22</span>;</span>
<span class="line" id="L30"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> plus_uconst = <span class="tok-number">0x23</span>;</span>
<span class="line" id="L31"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> shl = <span class="tok-number">0x24</span>;</span>
<span class="line" id="L32"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> shr = <span class="tok-number">0x25</span>;</span>
<span class="line" id="L33"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> shra = <span class="tok-number">0x26</span>;</span>
<span class="line" id="L34"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> xor = <span class="tok-number">0x27</span>;</span>
<span class="line" id="L35"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> bra = <span class="tok-number">0x28</span>;</span>
<span class="line" id="L36"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> eq = <span class="tok-number">0x29</span>;</span>
<span class="line" id="L37"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> ge = <span class="tok-number">0x2a</span>;</span>
<span class="line" id="L38"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> gt = <span class="tok-number">0x2b</span>;</span>
<span class="line" id="L39"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> le = <span class="tok-number">0x2c</span>;</span>
<span class="line" id="L40"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> lt = <span class="tok-number">0x2d</span>;</span>
<span class="line" id="L41"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> ne = <span class="tok-number">0x2e</span>;</span>
<span class="line" id="L42"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> skip = <span class="tok-number">0x2f</span>;</span>
<span class="line" id="L43"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> lit0 = <span class="tok-number">0x30</span>;</span>
<span class="line" id="L44"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> lit1 = <span class="tok-number">0x31</span>;</span>
<span class="line" id="L45"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> lit2 = <span class="tok-number">0x32</span>;</span>
<span class="line" id="L46"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> lit3 = <span class="tok-number">0x33</span>;</span>
<span class="line" id="L47"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> lit4 = <span class="tok-number">0x34</span>;</span>
<span class="line" id="L48"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> lit5 = <span class="tok-number">0x35</span>;</span>
<span class="line" id="L49"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> lit6 = <span class="tok-number">0x36</span>;</span>
<span class="line" id="L50"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> lit7 = <span class="tok-number">0x37</span>;</span>
<span class="line" id="L51"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> lit8 = <span class="tok-number">0x38</span>;</span>
<span class="line" id="L52"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> lit9 = <span class="tok-number">0x39</span>;</span>
<span class="line" id="L53"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> lit10 = <span class="tok-number">0x3a</span>;</span>
<span class="line" id="L54"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> lit11 = <span class="tok-number">0x3b</span>;</span>
<span class="line" id="L55"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> lit12 = <span class="tok-number">0x3c</span>;</span>
<span class="line" id="L56"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> lit13 = <span class="tok-number">0x3d</span>;</span>
<span class="line" id="L57"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> lit14 = <span class="tok-number">0x3e</span>;</span>
<span class="line" id="L58"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> lit15 = <span class="tok-number">0x3f</span>;</span>
<span class="line" id="L59"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> lit16 = <span class="tok-number">0x40</span>;</span>
<span class="line" id="L60"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> lit17 = <span class="tok-number">0x41</span>;</span>
<span class="line" id="L61"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> lit18 = <span class="tok-number">0x42</span>;</span>
<span class="line" id="L62"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> lit19 = <span class="tok-number">0x43</span>;</span>
<span class="line" id="L63"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> lit20 = <span class="tok-number">0x44</span>;</span>
<span class="line" id="L64"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> lit21 = <span class="tok-number">0x45</span>;</span>
<span class="line" id="L65"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> lit22 = <span class="tok-number">0x46</span>;</span>
<span class="line" id="L66"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> lit23 = <span class="tok-number">0x47</span>;</span>
<span class="line" id="L67"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> lit24 = <span class="tok-number">0x48</span>;</span>
<span class="line" id="L68"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> lit25 = <span class="tok-number">0x49</span>;</span>
<span class="line" id="L69"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> lit26 = <span class="tok-number">0x4a</span>;</span>
<span class="line" id="L70"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> lit27 = <span class="tok-number">0x4b</span>;</span>
<span class="line" id="L71"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> lit28 = <span class="tok-number">0x4c</span>;</span>
<span class="line" id="L72"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> lit29 = <span class="tok-number">0x4d</span>;</span>
<span class="line" id="L73"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> lit30 = <span class="tok-number">0x4e</span>;</span>
<span class="line" id="L74"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> lit31 = <span class="tok-number">0x4f</span>;</span>
<span class="line" id="L75"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> reg0 = <span class="tok-number">0x50</span>;</span>
<span class="line" id="L76"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> reg1 = <span class="tok-number">0x51</span>;</span>
<span class="line" id="L77"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> reg2 = <span class="tok-number">0x52</span>;</span>
<span class="line" id="L78"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> reg3 = <span class="tok-number">0x53</span>;</span>
<span class="line" id="L79"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> reg4 = <span class="tok-number">0x54</span>;</span>
<span class="line" id="L80"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> reg5 = <span class="tok-number">0x55</span>;</span>
<span class="line" id="L81"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> reg6 = <span class="tok-number">0x56</span>;</span>
<span class="line" id="L82"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> reg7 = <span class="tok-number">0x57</span>;</span>
<span class="line" id="L83"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> reg8 = <span class="tok-number">0x58</span>;</span>
<span class="line" id="L84"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> reg9 = <span class="tok-number">0x59</span>;</span>
<span class="line" id="L85"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> reg10 = <span class="tok-number">0x5a</span>;</span>
<span class="line" id="L86"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> reg11 = <span class="tok-number">0x5b</span>;</span>
<span class="line" id="L87"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> reg12 = <span class="tok-number">0x5c</span>;</span>
<span class="line" id="L88"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> reg13 = <span class="tok-number">0x5d</span>;</span>
<span class="line" id="L89"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> reg14 = <span class="tok-number">0x5e</span>;</span>
<span class="line" id="L90"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> reg15 = <span class="tok-number">0x5f</span>;</span>
<span class="line" id="L91"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> reg16 = <span class="tok-number">0x60</span>;</span>
<span class="line" id="L92"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> reg17 = <span class="tok-number">0x61</span>;</span>
<span class="line" id="L93"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> reg18 = <span class="tok-number">0x62</span>;</span>
<span class="line" id="L94"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> reg19 = <span class="tok-number">0x63</span>;</span>
<span class="line" id="L95"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> reg20 = <span class="tok-number">0x64</span>;</span>
<span class="line" id="L96"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> reg21 = <span class="tok-number">0x65</span>;</span>
<span class="line" id="L97"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> reg22 = <span class="tok-number">0x66</span>;</span>
<span class="line" id="L98"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> reg23 = <span class="tok-number">0x67</span>;</span>
<span class="line" id="L99"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> reg24 = <span class="tok-number">0x68</span>;</span>
<span class="line" id="L100"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> reg25 = <span class="tok-number">0x69</span>;</span>
<span class="line" id="L101"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> reg26 = <span class="tok-number">0x6a</span>;</span>
<span class="line" id="L102"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> reg27 = <span class="tok-number">0x6b</span>;</span>
<span class="line" id="L103"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> reg28 = <span class="tok-number">0x6c</span>;</span>
<span class="line" id="L104"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> reg29 = <span class="tok-number">0x6d</span>;</span>
<span class="line" id="L105"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> reg30 = <span class="tok-number">0x6e</span>;</span>
<span class="line" id="L106"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> reg31 = <span class="tok-number">0x6f</span>;</span>
<span class="line" id="L107"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> breg0 = <span class="tok-number">0x70</span>;</span>
<span class="line" id="L108"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> breg1 = <span class="tok-number">0x71</span>;</span>
<span class="line" id="L109"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> breg2 = <span class="tok-number">0x72</span>;</span>
<span class="line" id="L110"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> breg3 = <span class="tok-number">0x73</span>;</span>
<span class="line" id="L111"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> breg4 = <span class="tok-number">0x74</span>;</span>
<span class="line" id="L112"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> breg5 = <span class="tok-number">0x75</span>;</span>
<span class="line" id="L113"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> breg6 = <span class="tok-number">0x76</span>;</span>
<span class="line" id="L114"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> breg7 = <span class="tok-number">0x77</span>;</span>
<span class="line" id="L115"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> breg8 = <span class="tok-number">0x78</span>;</span>
<span class="line" id="L116"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> breg9 = <span class="tok-number">0x79</span>;</span>
<span class="line" id="L117"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> breg10 = <span class="tok-number">0x7a</span>;</span>
<span class="line" id="L118"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> breg11 = <span class="tok-number">0x7b</span>;</span>
<span class="line" id="L119"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> breg12 = <span class="tok-number">0x7c</span>;</span>
<span class="line" id="L120"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> breg13 = <span class="tok-number">0x7d</span>;</span>
<span class="line" id="L121"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> breg14 = <span class="tok-number">0x7e</span>;</span>
<span class="line" id="L122"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> breg15 = <span class="tok-number">0x7f</span>;</span>
<span class="line" id="L123"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> breg16 = <span class="tok-number">0x80</span>;</span>
<span class="line" id="L124"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> breg17 = <span class="tok-number">0x81</span>;</span>
<span class="line" id="L125"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> breg18 = <span class="tok-number">0x82</span>;</span>
<span class="line" id="L126"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> breg19 = <span class="tok-number">0x83</span>;</span>
<span class="line" id="L127"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> breg20 = <span class="tok-number">0x84</span>;</span>
<span class="line" id="L128"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> breg21 = <span class="tok-number">0x85</span>;</span>
<span class="line" id="L129"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> breg22 = <span class="tok-number">0x86</span>;</span>
<span class="line" id="L130"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> breg23 = <span class="tok-number">0x87</span>;</span>
<span class="line" id="L131"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> breg24 = <span class="tok-number">0x88</span>;</span>
<span class="line" id="L132"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> breg25 = <span class="tok-number">0x89</span>;</span>
<span class="line" id="L133"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> breg26 = <span class="tok-number">0x8a</span>;</span>
<span class="line" id="L134"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> breg27 = <span class="tok-number">0x8b</span>;</span>
<span class="line" id="L135"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> breg28 = <span class="tok-number">0x8c</span>;</span>
<span class="line" id="L136"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> breg29 = <span class="tok-number">0x8d</span>;</span>
<span class="line" id="L137"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> breg30 = <span class="tok-number">0x8e</span>;</span>
<span class="line" id="L138"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> breg31 = <span class="tok-number">0x8f</span>;</span>
<span class="line" id="L139"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> regx = <span class="tok-number">0x90</span>;</span>
<span class="line" id="L140"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> fbreg = <span class="tok-number">0x91</span>;</span>
<span class="line" id="L141"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> bregx = <span class="tok-number">0x92</span>;</span>
<span class="line" id="L142"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> piece = <span class="tok-number">0x93</span>;</span>
<span class="line" id="L143"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> deref_size = <span class="tok-number">0x94</span>;</span>
<span class="line" id="L144"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> xderef_size = <span class="tok-number">0x95</span>;</span>
<span class="line" id="L145"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> nop = <span class="tok-number">0x96</span>;</span>
<span class="line" id="L146"></span>
<span class="line" id="L147"><span class="tok-comment">// DWARF 3 extensions.</span>
</span>
<span class="line" id="L148"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> push_object_address = <span class="tok-number">0x97</span>;</span>
<span class="line" id="L149"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> call2 = <span class="tok-number">0x98</span>;</span>
<span class="line" id="L150"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> call4 = <span class="tok-number">0x99</span>;</span>
<span class="line" id="L151"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> call_ref = <span class="tok-number">0x9a</span>;</span>
<span class="line" id="L152"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> form_tls_address = <span class="tok-number">0x9b</span>;</span>
<span class="line" id="L153"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> call_frame_cfa = <span class="tok-number">0x9c</span>;</span>
<span class="line" id="L154"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> bit_piece = <span class="tok-number">0x9d</span>;</span>
<span class="line" id="L155"></span>
<span class="line" id="L156"><span class="tok-comment">// DWARF 4 extensions.</span>
</span>
<span class="line" id="L157"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> implicit_value = <span class="tok-number">0x9e</span>;</span>
<span class="line" id="L158"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> stack_value = <span class="tok-number">0x9f</span>;</span>
<span class="line" id="L159"></span>
<span class="line" id="L160"><span class="tok-comment">// DWARF 5 extensions.</span>
</span>
<span class="line" id="L161"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> implicit_pointer = <span class="tok-number">0xa0</span>;</span>
<span class="line" id="L162"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> addrx = <span class="tok-number">0xa1</span>;</span>
<span class="line" id="L163"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> constx = <span class="tok-number">0xa2</span>;</span>
<span class="line" id="L164"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> entry_value = <span class="tok-number">0xa3</span>;</span>
<span class="line" id="L165"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> const_type = <span class="tok-number">0xa4</span>;</span>
<span class="line" id="L166"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> regval_type = <span class="tok-number">0xa5</span>;</span>
<span class="line" id="L167"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> deref_type = <span class="tok-number">0xa6</span>;</span>
<span class="line" id="L168"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> xderef_type = <span class="tok-number">0xa7</span>;</span>
<span class="line" id="L169"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> convert = <span class="tok-number">0xa8</span>;</span>
<span class="line" id="L170"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> reinterpret = <span class="tok-number">0xa9</span>;</span>
<span class="line" id="L171"></span>
<span class="line" id="L172"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> lo_user = <span class="tok-number">0xe0</span>; <span class="tok-comment">// Implementation-defined range start.</span>
</span>
<span class="line" id="L173"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> hi_user = <span class="tok-number">0xff</span>; <span class="tok-comment">// Implementation-defined range end.</span>
</span>
<span class="line" id="L174"></span>
<span class="line" id="L175"><span class="tok-comment">// GNU extensions.</span>
</span>
<span class="line" id="L176"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> GNU_push_tls_address = <span class="tok-number">0xe0</span>;</span>
<span class="line" id="L177"><span class="tok-comment">// The following is for marking variables that are uninitialized.</span>
</span>
<span class="line" id="L178"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> GNU_uninit = <span class="tok-number">0xf0</span>;</span>
<span class="line" id="L179"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> GNU_encoded_addr = <span class="tok-number">0xf1</span>;</span>
<span class="line" id="L180"><span class="tok-comment">// The GNU implicit pointer extension.</span>
</span>
<span class="line" id="L181"><span class="tok-comment">// See http://www.dwarfstd.org/ShowIssue.php?issue=100831.1&type=open .</span>
</span>
<span class="line" id="L182"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> GNU_implicit_pointer = <span class="tok-number">0xf2</span>;</span>
<span class="line" id="L183"><span class="tok-comment">// The GNU entry value extension.</span>
</span>
<span class="line" id="L184"><span class="tok-comment">// See http://www.dwarfstd.org/ShowIssue.php?issue=100909.1&type=open .</span>
</span>
<span class="line" id="L185"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> GNU_entry_value = <span class="tok-number">0xf3</span>;</span>
<span class="line" id="L186"><span class="tok-comment">// The GNU typed stack extension.</span>
</span>
<span class="line" id="L187"><span class="tok-comment">// See http://www.dwarfstd.org/doc/040408.1.html .</span>
</span>
<span class="line" id="L188"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> GNU_const_type = <span class="tok-number">0xf4</span>;</span>
<span class="line" id="L189"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> GNU_regval_type = <span class="tok-number">0xf5</span>;</span>
<span class="line" id="L190"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> GNU_deref_type = <span class="tok-number">0xf6</span>;</span>
<span class="line" id="L191"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> GNU_convert = <span class="tok-number">0xf7</span>;</span>
<span class="line" id="L192"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> GNU_reinterpret = <span class="tok-number">0xf9</span>;</span>
<span class="line" id="L193"><span class="tok-comment">// The GNU parameter ref extension.</span>
</span>
<span class="line" id="L194"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> GNU_parameter_ref = <span class="tok-number">0xfa</span>;</span>
<span class="line" id="L195"><span class="tok-comment">// Extension for Fission. See http://gcc.gnu.org/wiki/DebugFission.</span>
</span>
<span class="line" id="L196"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> GNU_addr_index = <span class="tok-number">0xfb</span>;</span>
<span class="line" id="L197"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> GNU_const_index = <span class="tok-number">0xfc</span>;</span>
<span class="line" id="L198"><span class="tok-comment">// HP extensions.</span>
</span>
<span class="line" id="L199"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> HP_unknown = <span class="tok-number">0xe0</span>; <span class="tok-comment">// Ouch, the same as GNU_push_tls_address.</span>
</span>
<span class="line" id="L200"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> HP_is_value = <span class="tok-number">0xe1</span>;</span>
<span class="line" id="L201"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> HP_fltconst4 = <span class="tok-number">0xe2</span>;</span>
<span class="line" id="L202"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> HP_fltconst8 = <span class="tok-number">0xe3</span>;</span>
<span class="line" id="L203"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> HP_mod_range = <span class="tok-number">0xe4</span>;</span>
<span class="line" id="L204"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> HP_unmod_range = <span class="tok-number">0xe5</span>;</span>
<span class="line" id="L205"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> HP_tls = <span class="tok-number">0xe6</span>;</span>
<span class="line" id="L206"><span class="tok-comment">// PGI (STMicroelectronics) extensions.</span>
</span>
<span class="line" id="L207"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> PGI_omp_thread_num = <span class="tok-number">0xf8</span>;</span>
<span class="line" id="L208"><span class="tok-comment">// Wasm extensions.</span>
</span>
<span class="line" id="L209"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> WASM_location = <span class="tok-number">0xed</span>;</span>
<span class="line" id="L210"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> WASM_local = <span class="tok-number">0x00</span>;</span>
<span class="line" id="L211"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> WASM_global = <span class="tok-number">0x01</span>;</span>
<span class="line" id="L212"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> WASM_global_u32 = <span class="tok-number">0x03</span>;</span>
<span class="line" id="L213"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> WASM_operand_stack = <span class="tok-number">0x02</span>;</span>
<span class="line" id="L214"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/dwarf/abi.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>dwarf/abi.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">const</span> builtin = <span class="tok-builtin">@import</span>(<span class="tok-str">"builtin"</span>);</span>
<span class="line" id="L2"><span class="tok-kw">const</span> std = <span class="tok-builtin">@import</span>(<span class="tok-str">"../std.zig"</span>);</span>
<span class="line" id="L3"><span class="tok-kw">const</span> os = std.os;</span>
<span class="line" id="L4"><span class="tok-kw">const</span> mem = std.mem;</span>
<span class="line" id="L5"></span>
<span class="line" id="L6"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">isSupportedArch</span>(arch: std.Target.Cpu.Arch) <span class="tok-type">bool</span> {</span>
<span class="line" id="L7"> <span class="tok-kw">return</span> <span class="tok-kw">switch</span> (arch) {</span>
<span class="line" id="L8"> .x86,</span>
<span class="line" id="L9"> .x86_64,</span>
<span class="line" id="L10"> .arm,</span>
<span class="line" id="L11"> .aarch64,</span>
<span class="line" id="L12"> => <span class="tok-null">true</span>,</span>
<span class="line" id="L13"> <span class="tok-kw">else</span> => <span class="tok-null">false</span>,</span>
<span class="line" id="L14"> };</span>
<span class="line" id="L15">}</span>
<span class="line" id="L16"></span>
<span class="line" id="L17"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">ipRegNum</span>() <span class="tok-type">u8</span> {</span>
<span class="line" id="L18"> <span class="tok-kw">return</span> <span class="tok-kw">switch</span> (builtin.cpu.arch) {</span>
<span class="line" id="L19"> .x86 => <span class="tok-number">8</span>,</span>
<span class="line" id="L20"> .x86_64 => <span class="tok-number">16</span>,</span>
<span class="line" id="L21"> .arm => <span class="tok-number">15</span>,</span>
<span class="line" id="L22"> .aarch64 => <span class="tok-number">32</span>,</span>
<span class="line" id="L23"> <span class="tok-kw">else</span> => <span class="tok-kw">unreachable</span>,</span>
<span class="line" id="L24"> };</span>
<span class="line" id="L25">}</span>
<span class="line" id="L26"></span>
<span class="line" id="L27"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">fpRegNum</span>(reg_context: RegisterContext) <span class="tok-type">u8</span> {</span>
<span class="line" id="L28"> <span class="tok-kw">return</span> <span class="tok-kw">switch</span> (builtin.cpu.arch) {</span>
<span class="line" id="L29"> <span class="tok-comment">// GCC on OS X historicaly did the opposite of ELF for these registers (only in .eh_frame), and that is now the convention for MachO</span>
</span>
<span class="line" id="L30"> .x86 => <span class="tok-kw">if</span> (reg_context.eh_frame <span class="tok-kw">and</span> reg_context.is_macho) <span class="tok-number">4</span> <span class="tok-kw">else</span> <span class="tok-number">5</span>,</span>
<span class="line" id="L31"> .x86_64 => <span class="tok-number">6</span>,</span>
<span class="line" id="L32"> .arm => <span class="tok-number">11</span>,</span>
<span class="line" id="L33"> .aarch64 => <span class="tok-number">29</span>,</span>
<span class="line" id="L34"> <span class="tok-kw">else</span> => <span class="tok-kw">unreachable</span>,</span>
<span class="line" id="L35"> };</span>
<span class="line" id="L36">}</span>
<span class="line" id="L37"></span>
<span class="line" id="L38"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">spRegNum</span>(reg_context: RegisterContext) <span class="tok-type">u8</span> {</span>
<span class="line" id="L39"> <span class="tok-kw">return</span> <span class="tok-kw">switch</span> (builtin.cpu.arch) {</span>
<span class="line" id="L40"> .x86 => <span class="tok-kw">if</span> (reg_context.eh_frame <span class="tok-kw">and</span> reg_context.is_macho) <span class="tok-number">5</span> <span class="tok-kw">else</span> <span class="tok-number">4</span>,</span>
<span class="line" id="L41"> .x86_64 => <span class="tok-number">7</span>,</span>
<span class="line" id="L42"> .arm => <span class="tok-number">13</span>,</span>
<span class="line" id="L43"> .aarch64 => <span class="tok-number">31</span>,</span>
<span class="line" id="L44"> <span class="tok-kw">else</span> => <span class="tok-kw">unreachable</span>,</span>
<span class="line" id="L45"> };</span>
<span class="line" id="L46">}</span>
<span class="line" id="L47"></span>
<span class="line" id="L48"><span class="tok-comment">/// Some platforms use pointer authentication - the upper bits of instruction pointers contain a signature.</span></span>
<span class="line" id="L49"><span class="tok-comment">/// This function clears these signature bits to make the pointer usable.</span></span>
<span class="line" id="L50"><span class="tok-kw">pub</span> <span class="tok-kw">inline</span> <span class="tok-kw">fn</span> <span class="tok-fn">stripInstructionPtrAuthCode</span>(ptr: <span class="tok-type">usize</span>) <span class="tok-type">usize</span> {</span>
<span class="line" id="L51"> <span class="tok-kw">if</span> (builtin.cpu.arch == .aarch64) {</span>
<span class="line" id="L52"> <span class="tok-comment">// `hint 0x07` maps to `xpaclri` (or `nop` if the hardware doesn't support it)</span>
</span>
<span class="line" id="L53"> <span class="tok-comment">// The save / restore is because `xpaclri` operates on x30 (LR)</span>
</span>
<span class="line" id="L54"> <span class="tok-kw">return</span> <span class="tok-kw">asm</span> (</span>
<span class="line" id="L55"> <span class="tok-str">\\mov x16, x30</span></span>
<span class="line" id="L56"> <span class="tok-str">\\mov x30, x15</span></span>
<span class="line" id="L57"> <span class="tok-str">\\hint 0x07</span></span>
<span class="line" id="L58"> <span class="tok-str">\\mov x15, x30</span></span>
<span class="line" id="L59"> <span class="tok-str">\\mov x30, x16</span></span>
<span class="line" id="L60"> : [ret] <span class="tok-str">"={x15}"</span> (-> <span class="tok-type">usize</span>),</span>
<span class="line" id="L61"> : [ptr] <span class="tok-str">"{x15}"</span> (ptr),</span>
<span class="line" id="L62"> : <span class="tok-str">"x16"</span></span>
<span class="line" id="L63"> );</span>
<span class="line" id="L64"> }</span>
<span class="line" id="L65"></span>
<span class="line" id="L66"> <span class="tok-kw">return</span> ptr;</span>
<span class="line" id="L67">}</span>
<span class="line" id="L68"></span>
<span class="line" id="L69"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> RegisterContext = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L70"> eh_frame: <span class="tok-type">bool</span>,</span>
<span class="line" id="L71"> is_macho: <span class="tok-type">bool</span>,</span>
<span class="line" id="L72">};</span>
<span class="line" id="L73"></span>
<span class="line" id="L74"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> AbiError = <span class="tok-kw">error</span>{</span>
<span class="line" id="L75"> InvalidRegister,</span>
<span class="line" id="L76"> UnimplementedArch,</span>
<span class="line" id="L77"> UnimplementedOs,</span>
<span class="line" id="L78"> RegisterContextRequired,</span>
<span class="line" id="L79"> ThreadContextNotSupported,</span>
<span class="line" id="L80">};</span>
<span class="line" id="L81"></span>
<span class="line" id="L82"><span class="tok-kw">fn</span> <span class="tok-fn">RegValueReturnType</span>(<span class="tok-kw">comptime</span> ContextPtrType: <span class="tok-type">type</span>, <span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>) <span class="tok-type">type</span> {</span>
<span class="line" id="L83"> <span class="tok-kw">const</span> reg_bytes_type = <span class="tok-kw">comptime</span> RegBytesReturnType(ContextPtrType);</span>
<span class="line" id="L84"> <span class="tok-kw">const</span> info = <span class="tok-builtin">@typeInfo</span>(reg_bytes_type).Pointer;</span>
<span class="line" id="L85"> <span class="tok-kw">return</span> <span class="tok-builtin">@Type</span>(.{</span>
<span class="line" id="L86"> .Pointer = .{</span>
<span class="line" id="L87"> .size = .One,</span>
<span class="line" id="L88"> .is_const = info.is_const,</span>
<span class="line" id="L89"> .is_volatile = info.is_volatile,</span>
<span class="line" id="L90"> .is_allowzero = info.is_allowzero,</span>
<span class="line" id="L91"> .alignment = info.alignment,</span>
<span class="line" id="L92"> .address_space = info.address_space,</span>
<span class="line" id="L93"> .child = T,</span>
<span class="line" id="L94"> .sentinel = <span class="tok-null">null</span>,</span>
<span class="line" id="L95"> },</span>
<span class="line" id="L96"> });</span>
<span class="line" id="L97">}</span>
<span class="line" id="L98"></span>
<span class="line" id="L99"><span class="tok-comment">/// Returns a pointer to a register stored in a ThreadContext, preserving the pointer attributes of the context.</span></span>
<span class="line" id="L100"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">regValueNative</span>(</span>
<span class="line" id="L101"> <span class="tok-kw">comptime</span> T: <span class="tok-type">type</span>,</span>
<span class="line" id="L102"> thread_context_ptr: <span class="tok-kw">anytype</span>,</span>
<span class="line" id="L103"> reg_number: <span class="tok-type">u8</span>,</span>
<span class="line" id="L104"> reg_context: ?RegisterContext,</span>
<span class="line" id="L105">) !RegValueReturnType(<span class="tok-builtin">@TypeOf</span>(thread_context_ptr), T) {</span>
<span class="line" id="L106"> <span class="tok-kw">const</span> reg_bytes = <span class="tok-kw">try</span> regBytes(thread_context_ptr, reg_number, reg_context);</span>
<span class="line" id="L107"> <span class="tok-kw">if</span> (<span class="tok-builtin">@sizeOf</span>(T) != reg_bytes.len) <span class="tok-kw">return</span> <span class="tok-kw">error</span>.IncompatibleRegisterSize;</span>
<span class="line" id="L108"> <span class="tok-kw">return</span> mem.bytesAsValue(T, reg_bytes[<span class="tok-number">0</span>..<span class="tok-builtin">@sizeOf</span>(T)]);</span>
<span class="line" id="L109">}</span>
<span class="line" id="L110"></span>
<span class="line" id="L111"><span class="tok-kw">fn</span> <span class="tok-fn">RegBytesReturnType</span>(<span class="tok-kw">comptime</span> ContextPtrType: <span class="tok-type">type</span>) <span class="tok-type">type</span> {</span>
<span class="line" id="L112"> <span class="tok-kw">const</span> info = <span class="tok-builtin">@typeInfo</span>(ContextPtrType);</span>
<span class="line" id="L113"> <span class="tok-kw">if</span> (info != .Pointer <span class="tok-kw">or</span> info.Pointer.child != std.debug.ThreadContext) {</span>
<span class="line" id="L114"> <span class="tok-builtin">@compileError</span>(<span class="tok-str">"Expected a pointer to std.debug.ThreadContext, got "</span> ++ <span class="tok-builtin">@typeName</span>(<span class="tok-builtin">@TypeOf</span>(ContextPtrType)));</span>
<span class="line" id="L115"> }</span>
<span class="line" id="L116"></span>
<span class="line" id="L117"> <span class="tok-kw">return</span> <span class="tok-kw">if</span> (info.Pointer.is_const) <span class="tok-kw">return</span> []<span class="tok-kw">const</span> <span class="tok-type">u8</span> <span class="tok-kw">else</span> []<span class="tok-type">u8</span>;</span>
<span class="line" id="L118">}</span>
<span class="line" id="L119"></span>
<span class="line" id="L120"><span class="tok-comment">/// Returns a slice containing the backing storage for `reg_number`.</span></span>
<span class="line" id="L121"><span class="tok-comment">///</span></span>
<span class="line" id="L122"><span class="tok-comment">/// `reg_context` describes in what context the register number is used, as it can have different</span></span>
<span class="line" id="L123"><span class="tok-comment">/// meanings depending on the DWARF container. It is only required when getting the stack or</span></span>
<span class="line" id="L124"><span class="tok-comment">/// frame pointer register on some architectures.</span></span>
<span class="line" id="L125"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">regBytes</span>(</span>
<span class="line" id="L126"> thread_context_ptr: <span class="tok-kw">anytype</span>,</span>
<span class="line" id="L127"> reg_number: <span class="tok-type">u8</span>,</span>
<span class="line" id="L128"> reg_context: ?RegisterContext,</span>
<span class="line" id="L129">) AbiError!RegBytesReturnType(<span class="tok-builtin">@TypeOf</span>(thread_context_ptr)) {</span>
<span class="line" id="L130"> <span class="tok-kw">if</span> (builtin.os.tag == .windows) {</span>
<span class="line" id="L131"> <span class="tok-kw">return</span> <span class="tok-kw">switch</span> (builtin.cpu.arch) {</span>
<span class="line" id="L132"> .x86 => <span class="tok-kw">switch</span> (reg_number) {</span>
<span class="line" id="L133"> <span class="tok-number">0</span> => mem.asBytes(&thread_context_ptr.Eax),</span>
<span class="line" id="L134"> <span class="tok-number">1</span> => mem.asBytes(&thread_context_ptr.Ecx),</span>
<span class="line" id="L135"> <span class="tok-number">2</span> => mem.asBytes(&thread_context_ptr.Edx),</span>
<span class="line" id="L136"> <span class="tok-number">3</span> => mem.asBytes(&thread_context_ptr.Ebx),</span>
<span class="line" id="L137"> <span class="tok-number">4</span> => mem.asBytes(&thread_context_ptr.Esp),</span>
<span class="line" id="L138"> <span class="tok-number">5</span> => mem.asBytes(&thread_context_ptr.Ebp),</span>
<span class="line" id="L139"> <span class="tok-number">6</span> => mem.asBytes(&thread_context_ptr.Esi),</span>
<span class="line" id="L140"> <span class="tok-number">7</span> => mem.asBytes(&thread_context_ptr.Edi),</span>
<span class="line" id="L141"> <span class="tok-number">8</span> => mem.asBytes(&thread_context_ptr.Eip),</span>
<span class="line" id="L142"> <span class="tok-number">9</span> => mem.asBytes(&thread_context_ptr.EFlags),</span>
<span class="line" id="L143"> <span class="tok-number">10</span> => mem.asBytes(&thread_context_ptr.SegCs),</span>
<span class="line" id="L144"> <span class="tok-number">11</span> => mem.asBytes(&thread_context_ptr.SegSs),</span>
<span class="line" id="L145"> <span class="tok-number">12</span> => mem.asBytes(&thread_context_ptr.SegDs),</span>
<span class="line" id="L146"> <span class="tok-number">13</span> => mem.asBytes(&thread_context_ptr.SegEs),</span>
<span class="line" id="L147"> <span class="tok-number">14</span> => mem.asBytes(&thread_context_ptr.SegFs),</span>
<span class="line" id="L148"> <span class="tok-number">15</span> => mem.asBytes(&thread_context_ptr.SegGs),</span>
<span class="line" id="L149"> <span class="tok-kw">else</span> => <span class="tok-kw">error</span>.InvalidRegister,</span>
<span class="line" id="L150"> },</span>
<span class="line" id="L151"> .x86_64 => <span class="tok-kw">switch</span> (reg_number) {</span>
<span class="line" id="L152"> <span class="tok-number">0</span> => mem.asBytes(&thread_context_ptr.Rax),</span>
<span class="line" id="L153"> <span class="tok-number">1</span> => mem.asBytes(&thread_context_ptr.Rdx),</span>
<span class="line" id="L154"> <span class="tok-number">2</span> => mem.asBytes(&thread_context_ptr.Rcx),</span>
<span class="line" id="L155"> <span class="tok-number">3</span> => mem.asBytes(&thread_context_ptr.Rbx),</span>
<span class="line" id="L156"> <span class="tok-number">4</span> => mem.asBytes(&thread_context_ptr.Rsi),</span>
<span class="line" id="L157"> <span class="tok-number">5</span> => mem.asBytes(&thread_context_ptr.Rdi),</span>
<span class="line" id="L158"> <span class="tok-number">6</span> => mem.asBytes(&thread_context_ptr.Rbp),</span>
<span class="line" id="L159"> <span class="tok-number">7</span> => mem.asBytes(&thread_context_ptr.Rsp),</span>
<span class="line" id="L160"> <span class="tok-number">8</span> => mem.asBytes(&thread_context_ptr.R8),</span>
<span class="line" id="L161"> <span class="tok-number">9</span> => mem.asBytes(&thread_context_ptr.R9),</span>
<span class="line" id="L162"> <span class="tok-number">10</span> => mem.asBytes(&thread_context_ptr.R10),</span>
<span class="line" id="L163"> <span class="tok-number">11</span> => mem.asBytes(&thread_context_ptr.R11),</span>
<span class="line" id="L164"> <span class="tok-number">12</span> => mem.asBytes(&thread_context_ptr.R12),</span>
<span class="line" id="L165"> <span class="tok-number">13</span> => mem.asBytes(&thread_context_ptr.R13),</span>
<span class="line" id="L166"> <span class="tok-number">14</span> => mem.asBytes(&thread_context_ptr.R14),</span>
<span class="line" id="L167"> <span class="tok-number">15</span> => mem.asBytes(&thread_context_ptr.R15),</span>
<span class="line" id="L168"> <span class="tok-number">16</span> => mem.asBytes(&thread_context_ptr.Rip),</span>
<span class="line" id="L169"> <span class="tok-kw">else</span> => <span class="tok-kw">error</span>.InvalidRegister,</span>
<span class="line" id="L170"> },</span>
<span class="line" id="L171"> .aarch64 => <span class="tok-kw">switch</span> (reg_number) {</span>
<span class="line" id="L172"> <span class="tok-number">0</span>...<span class="tok-number">30</span> => mem.asBytes(&thread_context_ptr.DUMMYUNIONNAME.X[reg_number]),</span>
<span class="line" id="L173"> <span class="tok-number">31</span> => mem.asBytes(&thread_context_ptr.Sp),</span>
<span class="line" id="L174"> <span class="tok-number">32</span> => mem.asBytes(&thread_context_ptr.Pc),</span>
<span class="line" id="L175"> <span class="tok-kw">else</span> => <span class="tok-kw">error</span>.InvalidRegister,</span>
<span class="line" id="L176"> },</span>
<span class="line" id="L177"> <span class="tok-kw">else</span> => <span class="tok-kw">error</span>.UnimplementedArch,</span>
<span class="line" id="L178"> };</span>
<span class="line" id="L179"> }</span>
<span class="line" id="L180"></span>
<span class="line" id="L181"> <span class="tok-kw">if</span> (!std.debug.have_ucontext) <span class="tok-kw">return</span> <span class="tok-kw">error</span>.ThreadContextNotSupported;</span>
<span class="line" id="L182"></span>
<span class="line" id="L183"> <span class="tok-kw">const</span> ucontext_ptr = thread_context_ptr;</span>
<span class="line" id="L184"> <span class="tok-kw">return</span> <span class="tok-kw">switch</span> (builtin.cpu.arch) {</span>
<span class="line" id="L185"> .x86 => <span class="tok-kw">switch</span> (builtin.os.tag) {</span>
<span class="line" id="L186"> .linux, .netbsd, .solaris => <span class="tok-kw">switch</span> (reg_number) {</span>
<span class="line" id="L187"> <span class="tok-number">0</span> => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.EAX]),</span>
<span class="line" id="L188"> <span class="tok-number">1</span> => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.ECX]),</span>
<span class="line" id="L189"> <span class="tok-number">2</span> => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.EDX]),</span>
<span class="line" id="L190"> <span class="tok-number">3</span> => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.EBX]),</span>
<span class="line" id="L191"> <span class="tok-number">4</span>...<span class="tok-number">5</span> => <span class="tok-kw">if</span> (reg_context) |r| bytes: {</span>
<span class="line" id="L192"> <span class="tok-kw">if</span> (reg_number == <span class="tok-number">4</span>) {</span>
<span class="line" id="L193"> <span class="tok-kw">break</span> :bytes <span class="tok-kw">if</span> (r.eh_frame <span class="tok-kw">and</span> r.is_macho)</span>
<span class="line" id="L194"> mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.EBP])</span>
<span class="line" id="L195"> <span class="tok-kw">else</span></span>
<span class="line" id="L196"> mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.ESP]);</span>
<span class="line" id="L197"> } <span class="tok-kw">else</span> {</span>
<span class="line" id="L198"> <span class="tok-kw">break</span> :bytes <span class="tok-kw">if</span> (r.eh_frame <span class="tok-kw">and</span> r.is_macho)</span>
<span class="line" id="L199"> mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.ESP])</span>
<span class="line" id="L200"> <span class="tok-kw">else</span></span>
<span class="line" id="L201"> mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.EBP]);</span>
<span class="line" id="L202"> }</span>
<span class="line" id="L203"> } <span class="tok-kw">else</span> <span class="tok-kw">error</span>.RegisterContextRequired,</span>
<span class="line" id="L204"> <span class="tok-number">6</span> => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.ESI]),</span>
<span class="line" id="L205"> <span class="tok-number">7</span> => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.EDI]),</span>
<span class="line" id="L206"> <span class="tok-number">8</span> => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.EIP]),</span>
<span class="line" id="L207"> <span class="tok-number">9</span> => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.EFL]),</span>
<span class="line" id="L208"> <span class="tok-number">10</span> => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.CS]),</span>
<span class="line" id="L209"> <span class="tok-number">11</span> => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.SS]),</span>
<span class="line" id="L210"> <span class="tok-number">12</span> => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.DS]),</span>
<span class="line" id="L211"> <span class="tok-number">13</span> => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.ES]),</span>
<span class="line" id="L212"> <span class="tok-number">14</span> => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.FS]),</span>
<span class="line" id="L213"> <span class="tok-number">15</span> => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.GS]),</span>
<span class="line" id="L214"> <span class="tok-number">16</span>...<span class="tok-number">23</span> => <span class="tok-kw">error</span>.InvalidRegister, <span class="tok-comment">// TODO: Support loading ST0-ST7 from mcontext.fpregs</span>
</span>
<span class="line" id="L215"> <span class="tok-number">32</span>...<span class="tok-number">39</span> => <span class="tok-kw">error</span>.InvalidRegister, <span class="tok-comment">// TODO: Support loading XMM0-XMM7 from mcontext.fpregs</span>
</span>
<span class="line" id="L216"> <span class="tok-kw">else</span> => <span class="tok-kw">error</span>.InvalidRegister,</span>
<span class="line" id="L217"> },</span>
<span class="line" id="L218"> <span class="tok-kw">else</span> => <span class="tok-kw">error</span>.UnimplementedOs,</span>
<span class="line" id="L219"> },</span>
<span class="line" id="L220"> .x86_64 => <span class="tok-kw">switch</span> (builtin.os.tag) {</span>
<span class="line" id="L221"> .linux, .netbsd, .solaris => <span class="tok-kw">switch</span> (reg_number) {</span>
<span class="line" id="L222"> <span class="tok-number">0</span> => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.RAX]),</span>
<span class="line" id="L223"> <span class="tok-number">1</span> => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.RDX]),</span>
<span class="line" id="L224"> <span class="tok-number">2</span> => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.RCX]),</span>
<span class="line" id="L225"> <span class="tok-number">3</span> => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.RBX]),</span>
<span class="line" id="L226"> <span class="tok-number">4</span> => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.RSI]),</span>
<span class="line" id="L227"> <span class="tok-number">5</span> => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.RDI]),</span>
<span class="line" id="L228"> <span class="tok-number">6</span> => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.RBP]),</span>
<span class="line" id="L229"> <span class="tok-number">7</span> => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.RSP]),</span>
<span class="line" id="L230"> <span class="tok-number">8</span> => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.R8]),</span>
<span class="line" id="L231"> <span class="tok-number">9</span> => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.R9]),</span>
<span class="line" id="L232"> <span class="tok-number">10</span> => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.R10]),</span>
<span class="line" id="L233"> <span class="tok-number">11</span> => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.R11]),</span>
<span class="line" id="L234"> <span class="tok-number">12</span> => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.R12]),</span>
<span class="line" id="L235"> <span class="tok-number">13</span> => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.R13]),</span>
<span class="line" id="L236"> <span class="tok-number">14</span> => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.R14]),</span>
<span class="line" id="L237"> <span class="tok-number">15</span> => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.R15]),</span>
<span class="line" id="L238"> <span class="tok-number">16</span> => mem.asBytes(&ucontext_ptr.mcontext.gregs[os.REG.RIP]),</span>
<span class="line" id="L239"> <span class="tok-number">17</span>...<span class="tok-number">32</span> => |i| mem.asBytes(&ucontext_ptr.mcontext.fpregs.xmm[i - <span class="tok-number">17</span>]),</span>
<span class="line" id="L240"> <span class="tok-kw">else</span> => <span class="tok-kw">error</span>.InvalidRegister,</span>
<span class="line" id="L241"> },</span>
<span class="line" id="L242"> .freebsd => <span class="tok-kw">switch</span> (reg_number) {</span>
<span class="line" id="L243"> <span class="tok-number">0</span> => mem.asBytes(&ucontext_ptr.mcontext.rax),</span>
<span class="line" id="L244"> <span class="tok-number">1</span> => mem.asBytes(&ucontext_ptr.mcontext.rdx),</span>
<span class="line" id="L245"> <span class="tok-number">2</span> => mem.asBytes(&ucontext_ptr.mcontext.rcx),</span>
<span class="line" id="L246"> <span class="tok-number">3</span> => mem.asBytes(&ucontext_ptr.mcontext.rbx),</span>
<span class="line" id="L247"> <span class="tok-number">4</span> => mem.asBytes(&ucontext_ptr.mcontext.rsi),</span>
<span class="line" id="L248"> <span class="tok-number">5</span> => mem.asBytes(&ucontext_ptr.mcontext.rdi),</span>
<span class="line" id="L249"> <span class="tok-number">6</span> => mem.asBytes(&ucontext_ptr.mcontext.rbp),</span>
<span class="line" id="L250"> <span class="tok-number">7</span> => mem.asBytes(&ucontext_ptr.mcontext.rsp),</span>
<span class="line" id="L251"> <span class="tok-number">8</span> => mem.asBytes(&ucontext_ptr.mcontext.r8),</span>
<span class="line" id="L252"> <span class="tok-number">9</span> => mem.asBytes(&ucontext_ptr.mcontext.r9),</span>
<span class="line" id="L253"> <span class="tok-number">10</span> => mem.asBytes(&ucontext_ptr.mcontext.r10),</span>
<span class="line" id="L254"> <span class="tok-number">11</span> => mem.asBytes(&ucontext_ptr.mcontext.r11),</span>
<span class="line" id="L255"> <span class="tok-number">12</span> => mem.asBytes(&ucontext_ptr.mcontext.r12),</span>
<span class="line" id="L256"> <span class="tok-number">13</span> => mem.asBytes(&ucontext_ptr.mcontext.r13),</span>
<span class="line" id="L257"> <span class="tok-number">14</span> => mem.asBytes(&ucontext_ptr.mcontext.r14),</span>
<span class="line" id="L258"> <span class="tok-number">15</span> => mem.asBytes(&ucontext_ptr.mcontext.r15),</span>
<span class="line" id="L259"> <span class="tok-number">16</span> => mem.asBytes(&ucontext_ptr.mcontext.rip),</span>
<span class="line" id="L260"> <span class="tok-comment">// TODO: Extract xmm state from mcontext.fpstate?</span>
</span>
<span class="line" id="L261"> <span class="tok-kw">else</span> => <span class="tok-kw">error</span>.InvalidRegister,</span>
<span class="line" id="L262"> },</span>
<span class="line" id="L263"> .openbsd => <span class="tok-kw">switch</span> (reg_number) {</span>
<span class="line" id="L264"> <span class="tok-number">0</span> => mem.asBytes(&ucontext_ptr.sc_rax),</span>
<span class="line" id="L265"> <span class="tok-number">1</span> => mem.asBytes(&ucontext_ptr.sc_rdx),</span>
<span class="line" id="L266"> <span class="tok-number">2</span> => mem.asBytes(&ucontext_ptr.sc_rcx),</span>
<span class="line" id="L267"> <span class="tok-number">3</span> => mem.asBytes(&ucontext_ptr.sc_rbx),</span>
<span class="line" id="L268"> <span class="tok-number">4</span> => mem.asBytes(&ucontext_ptr.sc_rsi),</span>
<span class="line" id="L269"> <span class="tok-number">5</span> => mem.asBytes(&ucontext_ptr.sc_rdi),</span>
<span class="line" id="L270"> <span class="tok-number">6</span> => mem.asBytes(&ucontext_ptr.sc_rbp),</span>
<span class="line" id="L271"> <span class="tok-number">7</span> => mem.asBytes(&ucontext_ptr.sc_rsp),</span>
<span class="line" id="L272"> <span class="tok-number">8</span> => mem.asBytes(&ucontext_ptr.sc_r8),</span>
<span class="line" id="L273"> <span class="tok-number">9</span> => mem.asBytes(&ucontext_ptr.sc_r9),</span>
<span class="line" id="L274"> <span class="tok-number">10</span> => mem.asBytes(&ucontext_ptr.sc_r10),</span>
<span class="line" id="L275"> <span class="tok-number">11</span> => mem.asBytes(&ucontext_ptr.sc_r11),</span>
<span class="line" id="L276"> <span class="tok-number">12</span> => mem.asBytes(&ucontext_ptr.sc_r12),</span>
<span class="line" id="L277"> <span class="tok-number">13</span> => mem.asBytes(&ucontext_ptr.sc_r13),</span>
<span class="line" id="L278"> <span class="tok-number">14</span> => mem.asBytes(&ucontext_ptr.sc_r14),</span>
<span class="line" id="L279"> <span class="tok-number">15</span> => mem.asBytes(&ucontext_ptr.sc_r15),</span>
<span class="line" id="L280"> <span class="tok-number">16</span> => mem.asBytes(&ucontext_ptr.sc_rip),</span>
<span class="line" id="L281"> <span class="tok-comment">// TODO: Extract xmm state from sc_fpstate?</span>
</span>
<span class="line" id="L282"> <span class="tok-kw">else</span> => <span class="tok-kw">error</span>.InvalidRegister,</span>
<span class="line" id="L283"> },</span>
<span class="line" id="L284"> .macos => <span class="tok-kw">switch</span> (reg_number) {</span>
<span class="line" id="L285"> <span class="tok-number">0</span> => mem.asBytes(&ucontext_ptr.mcontext.ss.rax),</span>
<span class="line" id="L286"> <span class="tok-number">1</span> => mem.asBytes(&ucontext_ptr.mcontext.ss.rdx),</span>
<span class="line" id="L287"> <span class="tok-number">2</span> => mem.asBytes(&ucontext_ptr.mcontext.ss.rcx),</span>
<span class="line" id="L288"> <span class="tok-number">3</span> => mem.asBytes(&ucontext_ptr.mcontext.ss.rbx),</span>
<span class="line" id="L289"> <span class="tok-number">4</span> => mem.asBytes(&ucontext_ptr.mcontext.ss.rsi),</span>
<span class="line" id="L290"> <span class="tok-number">5</span> => mem.asBytes(&ucontext_ptr.mcontext.ss.rdi),</span>
<span class="line" id="L291"> <span class="tok-number">6</span> => mem.asBytes(&ucontext_ptr.mcontext.ss.rbp),</span>
<span class="line" id="L292"> <span class="tok-number">7</span> => mem.asBytes(&ucontext_ptr.mcontext.ss.rsp),</span>
<span class="line" id="L293"> <span class="tok-number">8</span> => mem.asBytes(&ucontext_ptr.mcontext.ss.r8),</span>
<span class="line" id="L294"> <span class="tok-number">9</span> => mem.asBytes(&ucontext_ptr.mcontext.ss.r9),</span>
<span class="line" id="L295"> <span class="tok-number">10</span> => mem.asBytes(&ucontext_ptr.mcontext.ss.r10),</span>
<span class="line" id="L296"> <span class="tok-number">11</span> => mem.asBytes(&ucontext_ptr.mcontext.ss.r11),</span>
<span class="line" id="L297"> <span class="tok-number">12</span> => mem.asBytes(&ucontext_ptr.mcontext.ss.r12),</span>
<span class="line" id="L298"> <span class="tok-number">13</span> => mem.asBytes(&ucontext_ptr.mcontext.ss.r13),</span>
<span class="line" id="L299"> <span class="tok-number">14</span> => mem.asBytes(&ucontext_ptr.mcontext.ss.r14),</span>
<span class="line" id="L300"> <span class="tok-number">15</span> => mem.asBytes(&ucontext_ptr.mcontext.ss.r15),</span>
<span class="line" id="L301"> <span class="tok-number">16</span> => mem.asBytes(&ucontext_ptr.mcontext.ss.rip),</span>
<span class="line" id="L302"> <span class="tok-kw">else</span> => <span class="tok-kw">error</span>.InvalidRegister,</span>
<span class="line" id="L303"> },</span>
<span class="line" id="L304"> <span class="tok-kw">else</span> => <span class="tok-kw">error</span>.UnimplementedOs,</span>
<span class="line" id="L305"> },</span>
<span class="line" id="L306"> .arm => <span class="tok-kw">switch</span> (builtin.os.tag) {</span>
<span class="line" id="L307"> .linux => <span class="tok-kw">switch</span> (reg_number) {</span>
<span class="line" id="L308"> <span class="tok-number">0</span> => mem.asBytes(&ucontext_ptr.mcontext.arm_r0),</span>
<span class="line" id="L309"> <span class="tok-number">1</span> => mem.asBytes(&ucontext_ptr.mcontext.arm_r1),</span>
<span class="line" id="L310"> <span class="tok-number">2</span> => mem.asBytes(&ucontext_ptr.mcontext.arm_r2),</span>
<span class="line" id="L311"> <span class="tok-number">3</span> => mem.asBytes(&ucontext_ptr.mcontext.arm_r3),</span>
<span class="line" id="L312"> <span class="tok-number">4</span> => mem.asBytes(&ucontext_ptr.mcontext.arm_r4),</span>
<span class="line" id="L313"> <span class="tok-number">5</span> => mem.asBytes(&ucontext_ptr.mcontext.arm_r5),</span>
<span class="line" id="L314"> <span class="tok-number">6</span> => mem.asBytes(&ucontext_ptr.mcontext.arm_r6),</span>
<span class="line" id="L315"> <span class="tok-number">7</span> => mem.asBytes(&ucontext_ptr.mcontext.arm_r7),</span>
<span class="line" id="L316"> <span class="tok-number">8</span> => mem.asBytes(&ucontext_ptr.mcontext.arm_r8),</span>
<span class="line" id="L317"> <span class="tok-number">9</span> => mem.asBytes(&ucontext_ptr.mcontext.arm_r9),</span>
<span class="line" id="L318"> <span class="tok-number">10</span> => mem.asBytes(&ucontext_ptr.mcontext.arm_r10),</span>
<span class="line" id="L319"> <span class="tok-number">11</span> => mem.asBytes(&ucontext_ptr.mcontext.arm_fp),</span>
<span class="line" id="L320"> <span class="tok-number">12</span> => mem.asBytes(&ucontext_ptr.mcontext.arm_ip),</span>
<span class="line" id="L321"> <span class="tok-number">13</span> => mem.asBytes(&ucontext_ptr.mcontext.arm_sp),</span>
<span class="line" id="L322"> <span class="tok-number">14</span> => mem.asBytes(&ucontext_ptr.mcontext.arm_lr),</span>
<span class="line" id="L323"> <span class="tok-number">15</span> => mem.asBytes(&ucontext_ptr.mcontext.arm_pc),</span>
<span class="line" id="L324"> <span class="tok-comment">// CPSR is not allocated a register number (See: https://github.com/ARM-software/abi-aa/blob/main/aadwarf32/aadwarf32.rst, Section 4.1)</span>
</span>
<span class="line" id="L325"> <span class="tok-kw">else</span> => <span class="tok-kw">error</span>.InvalidRegister,</span>
<span class="line" id="L326"> },</span>
<span class="line" id="L327"> <span class="tok-kw">else</span> => <span class="tok-kw">error</span>.UnimplementedOs,</span>
<span class="line" id="L328"> },</span>
<span class="line" id="L329"> .aarch64 => <span class="tok-kw">switch</span> (builtin.os.tag) {</span>
<span class="line" id="L330"> .macos => <span class="tok-kw">switch</span> (reg_number) {</span>
<span class="line" id="L331"> <span class="tok-number">0</span>...<span class="tok-number">28</span> => mem.asBytes(&ucontext_ptr.mcontext.ss.regs[reg_number]),</span>
<span class="line" id="L332"> <span class="tok-number">29</span> => mem.asBytes(&ucontext_ptr.mcontext.ss.fp),</span>
<span class="line" id="L333"> <span class="tok-number">30</span> => mem.asBytes(&ucontext_ptr.mcontext.ss.lr),</span>
<span class="line" id="L334"> <span class="tok-number">31</span> => mem.asBytes(&ucontext_ptr.mcontext.ss.sp),</span>
<span class="line" id="L335"> <span class="tok-number">32</span> => mem.asBytes(&ucontext_ptr.mcontext.ss.pc),</span>
<span class="line" id="L336"></span>
<span class="line" id="L337"> <span class="tok-comment">// TODO: Find storage for this state</span>
</span>
<span class="line" id="L338"> <span class="tok-comment">//34 => mem.asBytes(&ucontext_ptr.ra_sign_state),</span>
</span>
<span class="line" id="L339"></span>
<span class="line" id="L340"> <span class="tok-comment">// V0-V31</span>
</span>
<span class="line" id="L341"> <span class="tok-number">64</span>...<span class="tok-number">95</span> => mem.asBytes(&ucontext_ptr.mcontext.ns.q[reg_number - <span class="tok-number">64</span>]),</span>
<span class="line" id="L342"> <span class="tok-kw">else</span> => <span class="tok-kw">error</span>.InvalidRegister,</span>
<span class="line" id="L343"> },</span>
<span class="line" id="L344"> .netbsd => <span class="tok-kw">switch</span> (reg_number) {</span>
<span class="line" id="L345"> <span class="tok-number">0</span>...<span class="tok-number">34</span> => mem.asBytes(&ucontext_ptr.mcontext.gregs[reg_number]),</span>
<span class="line" id="L346"> <span class="tok-kw">else</span> => <span class="tok-kw">error</span>.InvalidRegister,</span>
<span class="line" id="L347"> },</span>
<span class="line" id="L348"> .freebsd => <span class="tok-kw">switch</span> (reg_number) {</span>
<span class="line" id="L349"> <span class="tok-number">0</span>...<span class="tok-number">29</span> => mem.asBytes(&ucontext_ptr.mcontext.gpregs.x[reg_number]),</span>
<span class="line" id="L350"> <span class="tok-number">30</span> => mem.asBytes(&ucontext_ptr.mcontext.gpregs.lr),</span>
<span class="line" id="L351"> <span class="tok-number">31</span> => mem.asBytes(&ucontext_ptr.mcontext.gpregs.sp),</span>
<span class="line" id="L352"></span>
<span class="line" id="L353"> <span class="tok-comment">// TODO: This seems wrong, but it was in the previous debug.zig code for mapping PC, check this</span>
</span>
<span class="line" id="L354"> <span class="tok-number">32</span> => mem.asBytes(&ucontext_ptr.mcontext.gpregs.elr),</span>
<span class="line" id="L355"></span>
<span class="line" id="L356"> <span class="tok-kw">else</span> => <span class="tok-kw">error</span>.InvalidRegister,</span>
<span class="line" id="L357"> },</span>
<span class="line" id="L358"> <span class="tok-kw">else</span> => <span class="tok-kw">switch</span> (reg_number) {</span>
<span class="line" id="L359"> <span class="tok-number">0</span>...<span class="tok-number">30</span> => mem.asBytes(&ucontext_ptr.mcontext.regs[reg_number]),</span>
<span class="line" id="L360"> <span class="tok-number">31</span> => mem.asBytes(&ucontext_ptr.mcontext.sp),</span>
<span class="line" id="L361"> <span class="tok-number">32</span> => mem.asBytes(&ucontext_ptr.mcontext.pc),</span>
<span class="line" id="L362"> <span class="tok-kw">else</span> => <span class="tok-kw">error</span>.InvalidRegister,</span>
<span class="line" id="L363"> },</span>
<span class="line" id="L364"> },</span>
<span class="line" id="L365"> <span class="tok-kw">else</span> => <span class="tok-kw">error</span>.UnimplementedArch,</span>
<span class="line" id="L366"> };</span>
<span class="line" id="L367">}</span>
<span class="line" id="L368"></span>
<span class="line" id="L369"><span class="tok-comment">/// Returns the ABI-defined default value this register has in the unwinding table</span></span>
<span class="line" id="L370"><span class="tok-comment">/// before running any of the CIE instructions. The DWARF spec defines these as having</span></span>
<span class="line" id="L371"><span class="tok-comment">/// the .undefined rule by default, but allows ABI authors to override that.</span></span>
<span class="line" id="L372"><span class="tok-kw">pub</span> <span class="tok-kw">fn</span> <span class="tok-fn">getRegDefaultValue</span>(reg_number: <span class="tok-type">u8</span>, context: *std.dwarf.UnwindContext, out: []<span class="tok-type">u8</span>) !<span class="tok-type">void</span> {</span>
<span class="line" id="L373"> <span class="tok-kw">switch</span> (builtin.cpu.arch) {</span>
<span class="line" id="L374"> .aarch64 => {</span>
<span class="line" id="L375"> <span class="tok-comment">// Callee-saved registers are initialized as if they had the .same_value rule</span>
</span>
<span class="line" id="L376"> <span class="tok-kw">if</span> (reg_number >= <span class="tok-number">19</span> <span class="tok-kw">and</span> reg_number <= <span class="tok-number">28</span>) {</span>
<span class="line" id="L377"> <span class="tok-kw">const</span> src = <span class="tok-kw">try</span> regBytes(context.thread_context, reg_number, context.reg_context);</span>
<span class="line" id="L378"> <span class="tok-kw">if</span> (src.len != out.len) <span class="tok-kw">return</span> <span class="tok-kw">error</span>.RegisterSizeMismatch;</span>
<span class="line" id="L379"> <span class="tok-builtin">@memcpy</span>(out, src);</span>
<span class="line" id="L380"> <span class="tok-kw">return</span>;</span>
<span class="line" id="L381"> }</span>
<span class="line" id="L382"> },</span>
<span class="line" id="L383"> <span class="tok-kw">else</span> => {},</span>
<span class="line" id="L384"> }</span>
<span class="line" id="L385"></span>
<span class="line" id="L386"> <span class="tok-builtin">@memset</span>(out, <span class="tok-null">undefined</span>);</span>
<span class="line" id="L387">}</span>
<span class="line" id="L388"></span>
</code></pre></body>
</html> |
0 | repos/yazap/docs/src/std | repos/yazap/docs/src/std/dwarf/EH.zig.html | <!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>dwarf/EH.zig - source view</title>
<link rel="icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAPNJREFUeNpi/P//PwMlgOXHUjly9E0G4hwgZmQiQZMqEK8H4v9QzUEgQSaoADK+zhH9iAGL+C0gDoAaNg9mGLoLfgA1awK9hS9gzgJxA9RQBmQDrgMxJzRMGKE4HYj/Ial5A8QmQLwCJoBsgBYW2+TR1ChDaWt4LOBxKsi/VUh8XiD+gq4IVyzwQAMJBoKwacZlAB8Qf0bi96IZhtOAe1D6LpqaEiz6rmEzQAeIzwGxCJpieFqApo/vQKyJboAaEBsAsSEupwI1MwKjGBTVHOhegMX5UajYRqiBjMgYmj400cVh0XgTiKdC0zhJgJHS7AwQYABm9EAdCKrEfAAAAABJRU5ErkJggg=="/>
<style>
body{
font-family: system-ui, -apple-system, Roboto, "Segoe UI", sans-serif;
margin: 0;
line-height: 1.5;
}
pre > code {
display: block;
overflow: auto;
line-height: normal;
margin: 0em;
}
.tok-kw {
color: #333;
font-weight: bold;
}
.tok-str {
color: #d14;
}
.tok-builtin {
color: #005C7A;
}
.tok-comment {
color: #545454;
font-style: italic;
}
.tok-fn {
color: #900;
font-weight: bold;
}
.tok-null {
color: #005C5C;
}
.tok-number {
color: #005C5C;
}
.tok-type {
color: #458;
font-weight: bold;
}
pre {
counter-reset: line;
}
pre .line:before {
counter-increment: line;
content: counter(line);
display: inline-block;
padding-right: 1em;
width: 2em;
text-align: right;
color: #999;
}
.line {
width: 100%;
display: inline-block;
}
.line:target {
border-top: 1px solid #ccc;
border-bottom: 1px solid #ccc;
background: #fafafa;
}
@media (prefers-color-scheme: dark) {
body{
background:#222;
color: #ccc;
}
pre > code {
color: #ccc;
background: #222;
border: unset;
}
.line:target {
border-top: 1px solid #444;
border-bottom: 1px solid #444;
background: #333;
}
.tok-kw {
color: #eee;
}
.tok-str {
color: #2e5;
}
.tok-builtin {
color: #ff894c;
}
.tok-comment {
color: #aa7;
}
.tok-fn {
color: #B1A0F8;
}
.tok-null {
color: #ff8080;
}
.tok-number {
color: #ff8080;
}
.tok-type {
color: #68f;
}
}
</style>
</head>
<body>
<pre><code><span class="line" id="L1"><span class="tok-kw">pub</span> <span class="tok-kw">const</span> PE = <span class="tok-kw">struct</span> {</span>
<span class="line" id="L2"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> absptr = <span class="tok-number">0x00</span>;</span>
<span class="line" id="L3"></span>
<span class="line" id="L4"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> size_mask = <span class="tok-number">0x7</span>;</span>
<span class="line" id="L5"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> sign_mask = <span class="tok-number">0x8</span>;</span>
<span class="line" id="L6"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> type_mask = size_mask | sign_mask;</span>
<span class="line" id="L7"></span>
<span class="line" id="L8"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> uleb128 = <span class="tok-number">0x01</span>;</span>
<span class="line" id="L9"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> udata2 = <span class="tok-number">0x02</span>;</span>
<span class="line" id="L10"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> udata4 = <span class="tok-number">0x03</span>;</span>
<span class="line" id="L11"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> udata8 = <span class="tok-number">0x04</span>;</span>
<span class="line" id="L12"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> sleb128 = <span class="tok-number">0x09</span>;</span>
<span class="line" id="L13"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> sdata2 = <span class="tok-number">0x0A</span>;</span>
<span class="line" id="L14"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> sdata4 = <span class="tok-number">0x0B</span>;</span>
<span class="line" id="L15"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> sdata8 = <span class="tok-number">0x0C</span>;</span>
<span class="line" id="L16"></span>
<span class="line" id="L17"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> rel_mask = <span class="tok-number">0x70</span>;</span>
<span class="line" id="L18"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> pcrel = <span class="tok-number">0x10</span>;</span>
<span class="line" id="L19"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> textrel = <span class="tok-number">0x20</span>;</span>
<span class="line" id="L20"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> datarel = <span class="tok-number">0x30</span>;</span>
<span class="line" id="L21"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> funcrel = <span class="tok-number">0x40</span>;</span>
<span class="line" id="L22"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> aligned = <span class="tok-number">0x50</span>;</span>
<span class="line" id="L23"></span>
<span class="line" id="L24"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> indirect = <span class="tok-number">0x80</span>;</span>
<span class="line" id="L25"></span>
<span class="line" id="L26"> <span class="tok-kw">pub</span> <span class="tok-kw">const</span> omit = <span class="tok-number">0xff</span>;</span>
<span class="line" id="L27">};</span>
<span class="line" id="L28"></span>
</code></pre></body>
</html> |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.