Commit 8c1872543c8cf76215cc4bf3ced4637bb1065a4e | zig

author	tgschultz <tgschultz@gmail.com> 2018-05-11 21:36:02-05:00
committer	GitHub <noreply@github.com> 2018-05-11 21:36:02-05:00
log	8c1872543c8cf76215cc4bf3ced4637bb1065a4e
tree	72dfebb643ab61579e3fb8dd58cd4610ffe876fa
parent	7186e92c86982950d0aa7c0c2deef9ef96bc1264
parent	6e821078f625a03eb8b7794c983da0f7793366ab
signature	Signed by PGP key 4AEE18F83AFDEB23

Merge pull request #1 from zig-lang/master

Sync with zig-lang/zig master

143 files changed, 23753 insertions(+), 5164 deletions(-)

.travis.yml
CMakeLists.txt
README.md
ci
- travis_linux_script
deps
- lld
  - ELF
    MarkLive.cpp
doc
- docgen.zig
- langref.html.in
src-self-hosted
src
std
- array_list.zig
- atomic
- buf_map.zig
- buf_set.zig
- buffer.zig
- build.zig
- c
- crypto
  - throughput_test.zig
- debug
  - index.zig
- elf.zig
- endian.zig
- event.zig
- fmt
  - errol
    index.zig
  - index.zig
- hash_map.zig
- heap.zig
- index.zig
- io.zig
- io_test.zig
- json.zig
- json_test.zig
- linked_list.zig
- math
  - complex
    abs.zig
    acos.zig
    acosh.zig
    arg.zig
    asin.zig
    asinh.zig
    atan.zig
    atanh.zig
    conj.zig
    cos.zig
    cosh.zig
    exp.zig
    index.zig
    ldexp.zig
    log.zig
    pow.zig
    proj.zig
    sin.zig
    sinh.zig
    sqrt.zig
    tan.zig
    tanh.zig
  - exp.zig
  - index.zig
  - ln.zig
  - log2.zig
  - sqrt.zig
  - x86_64
    sqrt.zig
- mem.zig
- net.zig
- os
  - darwin.zig
  - epoch.zig
  - file.zig
  - index.zig
  - linux
    i386.zig
    index.zig
    test.zig
    vdso.zig
    x86_64.zig
  - test.zig
  - time.zig
  - windows
    index.zig
- rand
  - index.zig
  - ziggurat.zig
- segmented_list.zig
- special
- unicode.zig
- zig
test

.travis.yml+13-9

...	...	@@ -1,18 +1,22 @@
1	1	sudo: required
2	2	services:
3		- docker
	3	- docker
4	4	os:
5		- linux
6		- osx
	5	- linux
	6	- osx
7	7	dist: trusty
8	8	osx_image: xcode8.3
9	9	language: cpp
10	10	before_install:
11		- if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then ci/travis_linux_before_install; fi
12		- if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then ci/travis_osx_before_install; fi
	11	- if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then ci/travis_linux_before_install; fi
	12	- if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then ci/travis_osx_before_install; fi
13	13	install:
14		- if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then ci/travis_linux_install; fi
15		- if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then ci/travis_osx_install; fi
	14	- if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then ci/travis_linux_install; fi
	15	- if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then ci/travis_osx_install; fi
16	16	script:
17		- if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then ci/travis_linux_script; fi
18		- if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then ci/travis_osx_script; fi
	17	- if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then ci/travis_linux_script; fi
	18	- if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then ci/travis_osx_script; fi
	19	env:
	20	global:
	21	- secure: QmJ+eLOxj3Irl5SHxt6lQvrj7++1AIz8bYri6RScAQGHQPIztkmbpBjAkpFgYaWPkZ04ROtamFXdS7oHtJHSECesgPoqM/CHIychQkgpDq30+TsFyYbBpDGHY+N6r2WnQTvg+9EuAp6P365us6qFS0D5zQ3P40c56uMbazFu3J4W1HZP+pLWlLjEXaN88ePhHWqNZyvwGMkLpYl3ghcrE9H4vGZQ7jenRW4UmskLEkuhUPJbQiow3Td8arJiRmLVISzWqneqNraLUpGyUVr4F3Rbjzacfoo3r9ZZynhY0mFsEye82x6TMGgH2xsNGkd91zpQuckWUT+pQv/G6FXpnEnjIJSO2Z5WAxXrx6xB1k2HZ17/4NWLF3fJVhdQJm3mS6odeGzUjgGrl1A42evxU+7VbcofEJq1aMiLgU1jUT2pt+pefCwmKJYLpEsSzuyrVxgvskQz0QpC053TAYSNf2Jj6Qhg9YDWyOeemYmDgffTqErF7AYhc6NKH0s0XKkIiNFSxorkEsfG/Ck1o+15slHNmWZXlmXToxDqFkLDoPvfGKg7koU5YTGvci/F9ZKb1juhGLxZbwap/18zN40BqA+Ip2yDBJAKxsIiwSjSIguy6g/Z1I50s0xNGOr36urfRRQX5H+rqr/xCZ63B6WSe6qBcZboWAQMDn8HLS9Xiwc=
	22	- secure: dnb7r5guUeMOX9e7XlPUSZzmga8VW3G9Q1aa7LxEKiTjSnWhu5KpPDe8o1X3Rj6nc5iXDqmBH/C/7eNXPDyXJJWPvpE2YRpGymyUkRaakul0QBKJEaMvwy2SuAfS69CWC+TSzfGRvtSYkdpBhhLvs0h5S819S5jYbCNSCmOKfFucaP5NsHNIZ/I19oIeTPTa0/UnVm7DLFZXZjvbS+czkdyH1DhbT85sLj+XqNTzLePImE68efrjaHnlSy/CzBVJzj55UgD5i9fxNCQWzGWim/SD5xZ0zKtLycSOf6wQN2lCo0lkjw9rDlYz69mM5L9ikfYL9oHDPZnh84oXKglQ5miOHCgqs/qs4439I05lIu8i/EfbFA55YG4NyO3rL9YVOOt5gwiwvJYhDcnkVVzSl0o5bsoZgQfYvPWaIQKNkl3C53zfDQjgqS54CeDzlZpFrQTDQ1RrH8oeVC1gfYAeMabMDadox5rfZmLIN5JTf/F8iD/QdxGcoUvkEENcQgfP9PnubExtexgHGsEmqbm6ORSZ1MkEh2m3fo0f8KE6TbN1UigmcQ8nTkWBHsSmfHnB8HwJQp8mwQmDamXA+Hl3e3w4LOdYkJVlNW1/TTyJJOOvjMQCjF8SJmPHuh+QpqKbSaT9XM/vBhxbIZEufH8kawJKCBBcCNspGMNjhXfNjM0=

CMakeLists.txt+43-8

...	...	@@ -5,6 +5,11 @@ if(NOT CMAKE_BUILD_TYPE)
5	5	"Choose the type of build, options are: Debug Release RelWithDebInfo MinSizeRel." FORCE)
6	6	endif()
7	7
	8	if(NOT CMAKE_INSTALL_PREFIX)
	9	set(CMAKE_INSTALL_PREFIX "${CMAKE_BINARY_DIR}" CACHE STRING
	10	"Directory to install zig to" FORCE)
	11	endif()
	12
8	13	project(zig C CXX)
9	14	set(CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake ${CMAKE_MODULE_PATH})
10	15
...	...	@@ -410,6 +415,9 @@ set(ZIG_CPP_SOURCES
410	415
411	416	set(ZIG_STD_FILES
412	417	"array_list.zig"
	418	"atomic/index.zig"
	419	"atomic/queue.zig"
	420	"atomic/stack.zig"
413	421	"base64.zig"
414	422	"buf_map.zig"
415	423	"buf_set.zig"
...	...	@@ -419,33 +427,34 @@ set(ZIG_STD_FILES
419	427	"c/index.zig"
420	428	"c/linux.zig"
421	429	"c/windows.zig"
	430	"crypto/blake2.zig"
	431	"crypto/hmac.zig"
422	432	"crypto/index.zig"
423	433	"crypto/md5.zig"
424	434	"crypto/sha1.zig"
425	435	"crypto/sha2.zig"
426	436	"crypto/sha3.zig"
427		"crypto/blake2.zig"
428		"crypto/hmac.zig"
429	437	"cstr.zig"
430	438	"debug/failing_allocator.zig"
431	439	"debug/index.zig"
432	440	"dwarf.zig"
433	441	"elf.zig"
434	442	"empty.zig"
435		"endian.zig"
	443	"event.zig"
436	444	"fmt/errol/enum3.zig"
437	445	"fmt/errol/index.zig"
438	446	"fmt/errol/lookup.zig"
439	447	"fmt/index.zig"
440		"hash_map.zig"
441		"hash/index.zig"
442	448	"hash/adler.zig"
443	449	"hash/crc.zig"
444	450	"hash/fnv.zig"
	451	"hash/index.zig"
445	452	"hash/siphash.zig"
	453	"hash_map.zig"
446	454	"heap.zig"
447	455	"index.zig"
448	456	"io.zig"
	457	"json.zig"
449	458	"linked_list.zig"
450	459	"macho.zig"
451	460	"math/acos.zig"
...	...	@@ -457,6 +466,28 @@ set(ZIG_STD_FILES
457	466	"math/atanh.zig"
458	467	"math/cbrt.zig"
459	468	"math/ceil.zig"
	469	"math/complex/abs.zig"
	470	"math/complex/acos.zig"
	471	"math/complex/acosh.zig"
	472	"math/complex/arg.zig"
	473	"math/complex/asin.zig"
	474	"math/complex/asinh.zig"
	475	"math/complex/atan.zig"
	476	"math/complex/atanh.zig"
	477	"math/complex/conj.zig"
	478	"math/complex/cos.zig"
	479	"math/complex/cosh.zig"
	480	"math/complex/exp.zig"
	481	"math/complex/index.zig"
	482	"math/complex/ldexp.zig"
	483	"math/complex/log.zig"
	484	"math/complex/pow.zig"
	485	"math/complex/proj.zig"
	486	"math/complex/sin.zig"
	487	"math/complex/sinh.zig"
	488	"math/complex/sqrt.zig"
	489	"math/complex/tan.zig"
	490	"math/complex/tanh.zig"
460	491	"math/copysign.zig"
461	492	"math/cos.zig"
462	493	"math/cosh.zig"
...	...	@@ -493,25 +524,28 @@ set(ZIG_STD_FILES
493	524	"math/tan.zig"
494	525	"math/tanh.zig"
495	526	"math/trunc.zig"
496		"math/x86_64/sqrt.zig"
497	527	"mem.zig"
498	528	"net.zig"
499	529	"os/child_process.zig"
500	530	"os/darwin.zig"
501	531	"os/darwin_errno.zig"
	532	"os/epoch.zig"
502	533	"os/file.zig"
503	534	"os/get_user_id.zig"
504	535	"os/index.zig"
505	536	"os/linux/errno.zig"
506		"os/linux/i386.zig"
507	537	"os/linux/index.zig"
	538	"os/linux/vdso.zig"
508	539	"os/linux/x86_64.zig"
509	540	"os/path.zig"
	541	"os/time.zig"
510	542	"os/windows/error.zig"
511	543	"os/windows/index.zig"
512	544	"os/windows/util.zig"
513	545	"os/zen.zig"
514	546	"rand/index.zig"
	547	"rand/ziggurat.zig"
	548	"segmented_list.zig"
515	549	"sort.zig"
516	550	"special/bootstrap.zig"
517	551	"special/bootstrap_lib.zig"
...	...	@@ -542,7 +576,8 @@ set(ZIG_STD_FILES
542	576	"unicode.zig"
543	577	"zig/ast.zig"
544	578	"zig/index.zig"
545		"zig/parser.zig"
	579	"zig/parse.zig"
	580	"zig/render.zig"
546	581	"zig/tokenizer.zig"
547	582	)
548	583

README.md+4-4

...	...	@@ -141,10 +141,10 @@ libc. Create demo games using Zig.
141	141	```
142	142	mkdir build
143	143	cd build
144		cmake .. -DCMAKE_INSTALL_PREFIX=$(pwd)
	144	cmake ..
145	145	make
146	146	make install
147		./zig build --build-file ../build.zig test
	147	bin/zig build --build-file ../build.zig test
148	148	```
149	149
150	150	##### MacOS
...	...	@@ -154,9 +154,9 @@ brew install cmake llvm@6
154	154	brew outdated llvm@6 \|\| brew upgrade llvm@6
155	155	mkdir build
156	156	cd build
157		cmake .. -DCMAKE_PREFIX_PATH=/usr/local/opt/llvm@6/ -DCMAKE_INSTALL_PREFIX=$(pwd)
	157	cmake .. -DCMAKE_PREFIX_PATH=/usr/local/opt/llvm@6/
158	158	make install
159		./zig build --build-file ../build.zig test
	159	bin/zig build --build-file ../build.zig test
160	160	```
161	161
162	162	##### Windows

ci/travis_linux_script+1-1

...	...	@@ -19,5 +19,5 @@ if [ "${TRAVIS_PULL_REQUEST}" = "false" ]; then
19	19	echo "secret_key = $AWS_SECRET_ACCESS_KEY" >> ~/.s3cfg
20	20	s3cmd put -P $TRAVIS_BUILD_DIR/artifacts/* s3://ziglang.org/builds/
21	21	touch empty
22		s3cmd put -P empty s3://ziglang.org/builds/zig-linux-x86_64-$TRAVIS_BRANCH.tar.xz --add-header=x-amz-website-redirect-location:/builds/$(ls $TRAVIS_BUILD_DIR/artifacts)
	22	s3cmd put -P empty s3://ziglang.org/builds/zig-linux-x86_64-$TRAVIS_BRANCH.tar.xz --add-header="Cache-Control: max-age=0, must-revalidate" --add-header=x-amz-website-redirect-location:/builds/$(ls $TRAVIS_BUILD_DIR/artifacts)
23	23	fi

deps/lld/ELF/MarkLive.cpp+9

...	...	@@ -301,6 +301,15 @@ template <class ELFT> void elf::markLive() {
301	301	// Follow the graph to mark all live sections.
302	302	doGcSections<ELFT>();
303	303
	304	// If all references to a DSO happen to be weak, the DSO is removed from
	305	// DT_NEEDED, which creates dangling shared symbols to non-existent DSO.
	306	// We'll replace such symbols with undefined ones to fix it.
	307	for (Symbol *Sym : Symtab->getSymbols())
	308	if (auto *S = dyn_cast<SharedSymbol>(Sym))
	309	if (S->isWeak() && !S->getFile<ELFT>().IsNeeded)
	310	replaceSymbol<Undefined>(S, nullptr, S->getName(), STB_WEAK, S->StOther,
	311	S->Type);
	312
304	313	// Report garbage-collected sections.
305	314	if (Config->PrintGcSections)
306	315	for (InputSectionBase *Sec : InputSections)

doc/docgen.zig+19

...	...	@@ -749,6 +749,10 @@ fn genHtml(allocator: &mem.Allocator, tokenizer: &Tokenizer, toc: &Toc, out: var
749	749	try build_args.append("--release-fast");
750	750	try out.print(" --release-fast");
751	751	},
	752	builtin.Mode.ReleaseSmall => {
	753	try build_args.append("--release-small");
	754	try out.print(" --release-small");
	755	},
752	756	}
753	757	for (code.link_objects) \|link_object\| {
754	758	const name_with_ext = try std.fmt.allocPrint(allocator, "{}{}", link_object, obj_ext);
...	...	@@ -810,6 +814,10 @@ fn genHtml(allocator: &mem.Allocator, tokenizer: &Tokenizer, toc: &Toc, out: var
810	814	try test_args.append("--release-fast");
811	815	try out.print(" --release-fast");
812	816	},
	817	builtin.Mode.ReleaseSmall => {
	818	try test_args.append("--release-small");
	819	try out.print(" --release-small");
	820	},
813	821	}
814	822	if (code.target_windows) {
815	823	try test_args.appendSlice([][]const u8{
...	...	@@ -840,6 +848,10 @@ fn genHtml(allocator: &mem.Allocator, tokenizer: &Tokenizer, toc: &Toc, out: var
840	848	try test_args.append("--release-fast");
841	849	try out.print(" --release-fast");
842	850	},
	851	builtin.Mode.ReleaseSmall => {
	852	try test_args.append("--release-small");
	853	try out.print(" --release-small");
	854	},
843	855	}
844	856	const result = try os.ChildProcess.exec(allocator, test_args.toSliceConst(), null, null, max_doc_file_size);
845	857	switch (result.term) {
...	...	@@ -874,6 +886,7 @@ fn genHtml(allocator: &mem.Allocator, tokenizer: &Tokenizer, toc: &Toc, out: var
874	886	builtin.Mode.Debug => {},
875	887	builtin.Mode.ReleaseSafe => try test_args.append("--release-safe"),
876	888	builtin.Mode.ReleaseFast => try test_args.append("--release-fast"),
	889	builtin.Mode.ReleaseSmall => try test_args.append("--release-small"),
877	890	}
878	891
879	892	const result = try os.ChildProcess.exec(allocator, test_args.toSliceConst(), null, null, max_doc_file_size);
...	...	@@ -927,6 +940,12 @@ fn genHtml(allocator: &mem.Allocator, tokenizer: &Tokenizer, toc: &Toc, out: var
927	940	try out.print(" --release-fast");
928	941	}
929	942	},
	943	builtin.Mode.ReleaseSmall => {
	944	try build_args.append("--release-small");
	945	if (!code.is_inline) {
	946	try out.print(" --release-small");
	947	}
	948	},
930	949	}
931	950
932	951	if (maybe_error_match) \|error_match\| {

doc/langref.html.in+509-13

...	...	@@ -1947,8 +1947,24 @@ const Foo = extern enum { A, B, C };
1947	1947	export fn entry(foo: Foo) void { }
1948	1948	{#code_end#}
1949	1949	{#header_close#}
1950		<p>TODO packed enum</p>
1951		{#see_also\|@memberName\|@memberCount\|@tagName#}
	1950	{#header_open\|packed enum#}
	1951	<p>By default, the size of enums is not guaranteed.</p>
	1952	<p><code>packed enum</code> causes the size of the enum to be the same as the size of the integer tag type
	1953	of the enum:</p>
	1954	{#code_begin\|test#}
	1955	const std = @import("std");
	1956
	1957	test "packed enum" {
	1958	const Number = packed enum(u8) {
	1959	One,
	1960	Two,
	1961	Three,
	1962	};
	1963	std.debug.assert(@sizeOf(Number) == @sizeOf(u8));
	1964	}
	1965	{#code_end#}
	1966	{#header_close#}
	1967	{#see_also\|@memberName\|@memberCount\|@tagName\|@sizeOf#}
1952	1968	{#header_close#}
1953	1969	{#header_open\|union#}
1954	1970	{#code_begin\|test\|union#}
...	...	@@ -2017,7 +2033,27 @@ test "union variant switch" {
2017	2033	assert(mem.eql(u8, what_is_it, "this is a number"));
2018	2034	}
2019	2035
2020		// TODO union methods
	2036	// Unions can have methods just like structs and enums:
	2037
	2038	const Variant = union(enum) {
	2039	Int: i32,
	2040	Bool: bool,
	2041
	2042	fn truthy(self: &const Variant) bool {
	2043	return switch (*self) {
	2044	Variant.Int => \|x_int\| x_int != 0,
	2045	Variant.Bool => \|x_bool\| x_bool,
	2046	};
	2047	}
	2048	};
	2049
	2050	test "union method" {
	2051	var v1 = Variant { .Int = 1 };
	2052	var v2 = Variant { .Bool = false };
	2053
	2054	assert(v1.truthy());
	2055	assert(!v2.truthy());
	2056	}
2021	2057
2022	2058
2023	2059	const Small = union {
...	...	@@ -3844,6 +3880,25 @@ pub fn main() void {
3844	3880	{#header_open\|@ArgType#}
3845	3881	<p>TODO</p>
3846	3882	{#header_close#}
	3883	{#header_open\|@atomicLoad#}
	3884	<pre><code class="zig">@atomicLoad(comptime T: type, ptr: &const T, comptime ordering: builtin.AtomicOrder) -> T</code></pre>
	3885	<p>
	3886	This builtin function atomically dereferences a pointer and returns the value.
	3887	</p>
	3888	<p>
	3889	<code>T</code> must be a pointer type, a <code>bool</code>,
	3890	or an integer whose bit count meets these requirements:
	3891	</p>
	3892	<ul>
	3893	<li>At least 8</li>
	3894	<li>At most the same as usize</li>
	3895	<li>Power of 2</li>
	3896	</ul>
	3897	<p>
	3898	TODO right now bool is not accepted. Also I think we could make non powers of 2 work fine, maybe
	3899	we can remove this restriction
	3900	</p>
	3901	{#header_close#}
3847	3902	{#header_open\|@atomicRmw#}
3848	3903	<pre><code class="zig">@atomicRmw(comptime T: type, ptr: &T, comptime op: builtin.AtomicRmwOp, operand: T, comptime ordering: builtin.AtomicOrder) -> T</code></pre>
3849	3904	<p>
...	...	@@ -4010,16 +4065,60 @@ comptime {
4010	4065	</p>
4011	4066
4012	4067	{#header_close#}
4013		{#header_open\|@cmpxchg#}
4014		<pre><code class="zig">@cmpxchg(ptr: &T, cmp: T, new: T, success_order: AtomicOrder, fail_order: AtomicOrder) -> bool</code></pre>
	4068	{#header_open\|@cmpxchgStrong#}
	4069	<pre><code class="zig">@cmpxchgStrong(comptime T: type, ptr: &T, expected_value: T, new_value: T, success_order: AtomicOrder, fail_order: AtomicOrder) -> ?T</code></pre>
	4070	<p>
	4071	This function performs a strong atomic compare exchange operation. It's the equivalent of this code,
	4072	except atomic:
	4073	</p>
	4074	{#code_begin\|syntax#}
	4075	fn cmpxchgStrongButNotAtomic(comptime T: type, ptr: &T, expected_value: T, new_value: T) ?T {
	4076	const old_value = *ptr;
	4077	if (old_value == expected_value) {
	4078	*ptr = new_value;
	4079	return null;
	4080	} else {
	4081	return old_value;
	4082	}
	4083	}
	4084	{#code_end#}
4015	4085	<p>
4016		This function performs an atomic compare exchange operation.
	4086	If you are using cmpxchg in a loop, {#link\|@cmpxchgWeak#} is the better choice, because it can be implemented
	4087	more efficiently in machine instructions.
4017	4088	</p>
4018	4089	<p>
4019	4090	<code>AtomicOrder</code> can be found with <code>@import("builtin").AtomicOrder</code>.
4020	4091	</p>
4021	4092	<p><code>@typeOf(ptr).alignment</code> must be <code>>= @sizeOf(T).</code></p>
4022		{#see_also\|Compile Variables#}
	4093	{#see_also\|Compile Variables\|cmpxchgWeak#}
	4094	{#header_close#}
	4095	{#header_open\|@cmpxchgWeak#}
	4096	<pre><code class="zig">@cmpxchgWeak(comptime T: type, ptr: &T, expected_value: T, new_value: T, success_order: AtomicOrder, fail_order: AtomicOrder) -> ?T</code></pre>
	4097	<p>
	4098	This function performs a weak atomic compare exchange operation. It's the equivalent of this code,
	4099	except atomic:
	4100	</p>
	4101	{#code_begin\|syntax#}
	4102	fn cmpxchgWeakButNotAtomic(comptime T: type, ptr: &T, expected_value: T, new_value: T) ?T {
	4103	const old_value = *ptr;
	4104	if (old_value == expected_value and usuallyTrueButSometimesFalse()) {
	4105	*ptr = new_value;
	4106	return null;
	4107	} else {
	4108	return old_value;
	4109	}
	4110	}
	4111	{#code_end#}
	4112	<p>
	4113	If you are using cmpxchg in a loop, the sporadic failure will be no problem, and <code>cmpxchgWeak</code>
	4114	is the better choice, because it can be implemented more efficiently in machine instructions.
	4115	However if you need a stronger guarantee, use {#link\|@cmpxchgStrong#}.
	4116	</p>
	4117	<p>
	4118	<code>AtomicOrder</code> can be found with <code>@import("builtin").AtomicOrder</code>.
	4119	</p>
	4120	<p><code>@typeOf(ptr).alignment</code> must be <code>>= @sizeOf(T).</code></p>
	4121	{#see_also\|Compile Variables\|cmpxchgStrong#}
4023	4122	{#header_close#}
4024	4123	{#header_open\|@compileError#}
4025	4124	<pre><code class="zig">@compileError(comptime msg: []u8)</code></pre>
...	...	@@ -4313,6 +4412,10 @@ fn add(a: i32, b: i32) i32 { return a + b; }
4313	4412	It does not include functions, variables, or constants.
4314	4413	</p>
4315	4414	{#header_close#}
	4415	{#header_open\|@field#}
	4416	<pre><code class="zig">@field(lhs: var, comptime field_name: []const u8) -> (field)</code></pre>
	4417	<p>Preforms field access equivalent to <code>lhs.-&gtfield_name-&lt</code>.</p>
	4418	{#header_close#}
4316	4419	{#header_open\|@memberType#}
4317	4420	<pre><code class="zig">@memberType(comptime T: type, comptime index: usize) -> type</code></pre>
4318	4421	<p>Returns the field type of a struct or union.</p>
...	...	@@ -4633,6 +4736,16 @@ pub const FloatMode = enum {
4633	4736	The result is a target-specific compile time constant.
4634	4737	</p>
4635	4738	{#header_close#}
	4739	{#header_open\|@sqrt#}
	4740	<pre><code class="zig">@sqrt(comptime T: type, value: T) -> T</code></pre>
	4741	<p>
	4742	Performs the square root of a floating point number. Uses a dedicated hardware instruction
	4743	when available. Currently only supports f32 and f64 at runtime. f128 at runtime is TODO.
	4744	</p>
	4745	<p>
	4746	This is a low-level intrinsic. Most code can use <code>std.math.sqrt</code> instead.
	4747	</p>
	4748	{#header_close#}
4636	4749	{#header_open\|@subWithOverflow#}
4637	4750	<pre><code class="zig">@subWithOverflow(comptime T: type, a: T, b: T, result: &T) -> bool</code></pre>
4638	4751	<p>
...	...	@@ -4696,6 +4809,182 @@ pub const TypeId = enum {
4696	4809	BoundFn,
4697	4810	ArgTuple,
4698	4811	Opaque,
	4812	};
	4813	{#code_end#}
	4814	{#header_close#}
	4815	{#header_open\|@typeInfo#}
	4816	<pre><code class="zig">@typeInfo(comptime T: type) -> @import("builtin").TypeInfo</code></pre>
	4817	<p>
	4818	Returns information on the type. Returns a value of the following union:
	4819	</p>
	4820	{#code_begin\|syntax#}
	4821	pub const TypeInfo = union(TypeId) {
	4822	Type: void,
	4823	Void: void,
	4824	Bool: void,
	4825	NoReturn: void,
	4826	Int: Int,
	4827	Float: Float,
	4828	Pointer: Pointer,
	4829	Array: Array,
	4830	Struct: Struct,
	4831	FloatLiteral: void,
	4832	IntLiteral: void,
	4833	UndefinedLiteral: void,
	4834	NullLiteral: void,
	4835	Nullable: Nullable,
	4836	ErrorUnion: ErrorUnion,
	4837	ErrorSet: ErrorSet,
	4838	Enum: Enum,
	4839	Union: Union,
	4840	Fn: Fn,
	4841	Namespace: void,
	4842	Block: void,
	4843	BoundFn: Fn,
	4844	ArgTuple: void,
	4845	Opaque: void,
	4846	Promise: Promise,
	4847
	4848
	4849	pub const Int = struct {
	4850	is_signed: bool,
	4851	bits: u8,
	4852	};
	4853
	4854	pub const Float = struct {
	4855	bits: u8,
	4856	};
	4857
	4858	pub const Pointer = struct {
	4859	is_const: bool,
	4860	is_volatile: bool,
	4861	alignment: u32,
	4862	child: type,
	4863	};
	4864
	4865	pub const Array = struct {
	4866	len: usize,
	4867	child: type,
	4868	};
	4869
	4870	pub const ContainerLayout = enum {
	4871	Auto,
	4872	Extern,
	4873	Packed,
	4874	};
	4875
	4876	pub const StructField = struct {
	4877	name: []const u8,
	4878	offset: ?usize,
	4879	field_type: type,
	4880	};
	4881
	4882	pub const Struct = struct {
	4883	layout: ContainerLayout,
	4884	fields: []StructField,
	4885	defs: []Definition,
	4886	};
	4887
	4888	pub const Nullable = struct {
	4889	child: type,
	4890	};
	4891
	4892	pub const ErrorUnion = struct {
	4893	error_set: type,
	4894	payload: type,
	4895	};
	4896
	4897	pub const Error = struct {
	4898	name: []const u8,
	4899	value: usize,
	4900	};
	4901
	4902	pub const ErrorSet = struct {
	4903	errors: []Error,
	4904	};
	4905
	4906	pub const EnumField = struct {
	4907	name: []const u8,
	4908	value: usize,
	4909	};
	4910
	4911	pub const Enum = struct {
	4912	layout: ContainerLayout,
	4913	tag_type: type,
	4914	fields: []EnumField,
	4915	defs: []Definition,
	4916	};
	4917
	4918	pub const UnionField = struct {
	4919	name: []const u8,
	4920	enum_field: ?EnumField,
	4921	field_type: type,
	4922	};
	4923
	4924	pub const Union = struct {
	4925	layout: ContainerLayout,
	4926	tag_type: type,
	4927	fields: []UnionField,
	4928	defs: []Definition,
	4929	};
	4930
	4931	pub const CallingConvention = enum {
	4932	Unspecified,
	4933	C,
	4934	Cold,
	4935	Naked,
	4936	Stdcall,
	4937	Async,
	4938	};
	4939
	4940	pub const FnArg = struct {
	4941	is_generic: bool,
	4942	is_noalias: bool,
	4943	arg_type: type,
	4944	};
	4945
	4946	pub const Fn = struct {
	4947	calling_convention: CallingConvention,
	4948	is_generic: bool,
	4949	is_var_args: bool,
	4950	return_type: type,
	4951	async_allocator_type: type,
	4952	args: []FnArg,
	4953	};
	4954
	4955	pub const Promise = struct {
	4956	child: type,
	4957	};
	4958
	4959	pub const Definition = struct {
	4960	name: []const u8,
	4961	is_pub: bool,
	4962	data: Data,
	4963
	4964	pub const Data = union(enum) {
	4965	Type: type,
	4966	Var: type,
	4967	Fn: FnDef,
	4968
	4969	pub const FnDef = struct {
	4970	fn_type: type,
	4971	inline_type: Inline,
	4972	calling_convention: CallingConvention,
	4973	is_var_args: bool,
	4974	is_extern: bool,
	4975	is_export: bool,
	4976	lib_name: ?[]const u8,
	4977	return_type: type,
	4978	arg_names: [][] const u8,
	4979
	4980	pub const Inline = enum {
	4981	Auto,
	4982	Always,
	4983	Never,
	4984	};
	4985	};
	4986	};
	4987	};
4699	4988	};
4700	4989	{#code_end#}
4701	4990	{#header_close#}
...	...	@@ -5113,7 +5402,6 @@ pub const Os = enum {
5113	5402	rtems,
5114	5403	nacl,
5115	5404	cnk,
5116		bitrig,
5117	5405	aix,
5118	5406	cuda,
5119	5407	nvcl,
...	...	@@ -5124,10 +5412,12 @@ pub const Os = enum {
5124	5412	watchos,
5125	5413	mesa3d,
5126	5414	contiki,
	5415	amdpal,
5127	5416	zen,
5128	5417	};
5129	5418
5130	5419	pub const Arch = enum {
	5420	armv8_3a,
5131	5421	armv8_2a,
5132	5422	armv8_1a,
5133	5423	armv8,
...	...	@@ -5147,9 +5437,29 @@ pub const Arch = enum {
5147	5437	armv5,
5148	5438	armv5te,
5149	5439	armv4t,
5150		armeb,
	5440	armebv8_3a,
	5441	armebv8_2a,
	5442	armebv8_1a,
	5443	armebv8,
	5444	armebv8r,
	5445	armebv8m_baseline,
	5446	armebv8m_mainline,
	5447	armebv7,
	5448	armebv7em,
	5449	armebv7m,
	5450	armebv7s,
	5451	armebv7k,
	5452	armebv7ve,
	5453	armebv6,
	5454	armebv6m,
	5455	armebv6k,
	5456	armebv6t2,
	5457	armebv5,
	5458	armebv5te,
	5459	armebv4t,
5151	5460	aarch64,
5152	5461	aarch64_be,
	5462	arc,
5153	5463	avr,
5154	5464	bpfel,
5155	5465	bpfeb,
...	...	@@ -5202,6 +5512,7 @@ pub const Arch = enum {
5202	5512	pub const Environ = enum {
5203	5513	unknown,
5204	5514	gnu,
	5515	gnuabin32,
5205	5516	gnuabi64,
5206	5517	gnueabi,
5207	5518	gnueabihf,
...	...	@@ -5219,6 +5530,7 @@ pub const Environ = enum {
5219	5530	amdopencl,
5220	5531	coreclr,
5221	5532	opencl,
	5533	simulator,
5222	5534	};
5223	5535
5224	5536	pub const ObjectFormat = enum {
...	...	@@ -5245,10 +5557,23 @@ pub const AtomicOrder = enum {
5245	5557	SeqCst,
5246	5558	};
5247	5559
	5560	pub const AtomicRmwOp = enum {
	5561	Xchg,
	5562	Add,
	5563	Sub,
	5564	And,
	5565	Nand,
	5566	Or,
	5567	Xor,
	5568	Max,
	5569	Min,
	5570	};
	5571
5248	5572	pub const Mode = enum {
5249	5573	Debug,
5250	5574	ReleaseSafe,
5251	5575	ReleaseFast,
	5576	ReleaseSmall,
5252	5577	};
5253	5578
5254	5579	pub const TypeId = enum {
...	...	@@ -5267,7 +5592,7 @@ pub const TypeId = enum {
5267	5592	NullLiteral,
5268	5593	Nullable,
5269	5594	ErrorUnion,
5270		Error,
	5595	ErrorSet,
5271	5596	Enum,
5272	5597	Union,
5273	5598	Fn,
...	...	@@ -5276,6 +5601,176 @@ pub const TypeId = enum {
5276	5601	BoundFn,
5277	5602	ArgTuple,
5278	5603	Opaque,
	5604	Promise,
	5605	};
	5606
	5607	pub const TypeInfo = union(TypeId) {
	5608	Type: void,
	5609	Void: void,
	5610	Bool: void,
	5611	NoReturn: void,
	5612	Int: Int,
	5613	Float: Float,
	5614	Pointer: Pointer,
	5615	Array: Array,
	5616	Struct: Struct,
	5617	FloatLiteral: void,
	5618	IntLiteral: void,
	5619	UndefinedLiteral: void,
	5620	NullLiteral: void,
	5621	Nullable: Nullable,
	5622	ErrorUnion: ErrorUnion,
	5623	ErrorSet: ErrorSet,
	5624	Enum: Enum,
	5625	Union: Union,
	5626	Fn: Fn,
	5627	Namespace: void,
	5628	Block: void,
	5629	BoundFn: Fn,
	5630	ArgTuple: void,
	5631	Opaque: void,
	5632	Promise: Promise,
	5633
	5634
	5635	pub const Int = struct {
	5636	is_signed: bool,
	5637	bits: u8,
	5638	};
	5639
	5640	pub const Float = struct {
	5641	bits: u8,
	5642	};
	5643
	5644	pub const Pointer = struct {
	5645	is_const: bool,
	5646	is_volatile: bool,
	5647	alignment: u32,
	5648	child: type,
	5649	};
	5650
	5651	pub const Array = struct {
	5652	len: usize,
	5653	child: type,
	5654	};
	5655
	5656	pub const ContainerLayout = enum {
	5657	Auto,
	5658	Extern,
	5659	Packed,
	5660	};
	5661
	5662	pub const StructField = struct {
	5663	name: []const u8,
	5664	offset: ?usize,
	5665	field_type: type,
	5666	};
	5667
	5668	pub const Struct = struct {
	5669	layout: ContainerLayout,
	5670	fields: []StructField,
	5671	defs: []Definition,
	5672	};
	5673
	5674	pub const Nullable = struct {
	5675	child: type,
	5676	};
	5677
	5678	pub const ErrorUnion = struct {
	5679	error_set: type,
	5680	payload: type,
	5681	};
	5682
	5683	pub const Error = struct {
	5684	name: []const u8,
	5685	value: usize,
	5686	};
	5687
	5688	pub const ErrorSet = struct {
	5689	errors: []Error,
	5690	};
	5691
	5692	pub const EnumField = struct {
	5693	name: []const u8,
	5694	value: usize,
	5695	};
	5696
	5697	pub const Enum = struct {
	5698	layout: ContainerLayout,
	5699	tag_type: type,
	5700	fields: []EnumField,
	5701	defs: []Definition,
	5702	};
	5703
	5704	pub const UnionField = struct {
	5705	name: []const u8,
	5706	enum_field: ?EnumField,
	5707	field_type: type,
	5708	};
	5709
	5710	pub const Union = struct {
	5711	layout: ContainerLayout,
	5712	tag_type: type,
	5713	fields: []UnionField,
	5714	defs: []Definition,
	5715	};
	5716
	5717	pub const CallingConvention = enum {
	5718	Unspecified,
	5719	C,
	5720	Cold,
	5721	Naked,
	5722	Stdcall,
	5723	Async,
	5724	};
	5725
	5726	pub const FnArg = struct {
	5727	is_generic: bool,
	5728	is_noalias: bool,
	5729	arg_type: type,
	5730	};
	5731
	5732	pub const Fn = struct {
	5733	calling_convention: CallingConvention,
	5734	is_generic: bool,
	5735	is_var_args: bool,
	5736	return_type: type,
	5737	async_allocator_type: type,
	5738	args: []FnArg,
	5739	};
	5740
	5741	pub const Promise = struct {
	5742	child: type,
	5743	};
	5744
	5745	pub const Definition = struct {
	5746	name: []const u8,
	5747	is_pub: bool,
	5748	data: Data,
	5749
	5750	pub const Data = union(enum) {
	5751	Type: type,
	5752	Var: type,
	5753	Fn: FnDef,
	5754
	5755	pub const FnDef = struct {
	5756	fn_type: type,
	5757	inline_type: Inline,
	5758	calling_convention: CallingConvention,
	5759	is_var_args: bool,
	5760	is_extern: bool,
	5761	is_export: bool,
	5762	lib_name: ?[]const u8,
	5763	return_type: type,
	5764	arg_names: [][] const u8,
	5765
	5766	pub const Inline = enum {
	5767	Auto,
	5768	Always,
	5769	Never,
	5770	};
	5771	};
	5772	};
	5773	};
5279	5774	};
5280	5775
5281	5776	pub const FloatMode = enum {
...	...	@@ -5289,7 +5784,7 @@ pub const Endian = enum {
5289	5784	};
5290	5785
5291	5786	pub const endian = Endian.Little;
5292		pub const is_test = false;
	5787	pub const is_test = true;
5293	5788	pub const os = Os.linux;
5294	5789	pub const arch = Arch.x86_64;
5295	5790	pub const environ = Environ.gnu;
...	...	@@ -5297,6 +5792,7 @@ pub const object_format = ObjectFormat.elf;
5297	5792	pub const mode = Mode.Debug;
5298	5793	pub const link_libc = false;
5299	5794	pub const have_error_return_tracing = true;
	5795	pub const __zig_test_fn_slice = {}; // overwritten later
5300	5796	{#code_end#}
5301	5797	{#see_also\|Build Mode#}
5302	5798	{#header_close#}
...	...	@@ -5809,7 +6305,7 @@ Defer(body) = ("defer" \| "deferror") body
5809	6305
5810	6306	IfExpression(body) = "if" "(" Expression ")" body option("else" BlockExpression(body))
5811	6307
5812		SuspendExpression(body) = "suspend" option(("\|" Symbol "\|" body))
	6308	SuspendExpression(body) = option(Symbol ":") "suspend" option(("\|" Symbol "\|" body))
5813	6309
5814	6310	IfErrorExpression(body) = "if" "(" Expression ")" option("\|" option("*") Symbol "\|") body "else" "\|" Symbol "\|" BlockExpression(body)
5815	6311
...	...	@@ -5955,7 +6451,7 @@ hljs.registerLanguage("zig", function(t) {
5955	6451	a = t.IR + "\\s*\\(",
5956	6452	c = {
5957	6453	keyword: "const align var extern stdcallcc nakedcc volatile export pub noalias inline struct packed enum union break return try catch test continue unreachable comptime and or asm defer errdefer if else switch while for fn use bool f32 f64 void type noreturn error i8 u8 i16 u16 i32 u32 i64 u64 isize usize i8w u8w i16w i32w u32w i64w u64w isizew usizew c_short c_ushort c_int c_uint c_long c_ulong c_longlong c_ulonglong",
5958		built_in: "breakpoint returnAddress frameAddress fieldParentPtr setFloatMode IntType OpaqueType compileError compileLog setCold setRuntimeSafety setEvalBranchQuota offsetOf memcpy inlineCall setGlobalLinkage setGlobalSection divTrunc divFloor enumTagName intToPtr ptrToInt panic canImplicitCast ptrCast bitCast rem mod memset sizeOf alignOf alignCast maxValue minValue memberCount memberName memberType typeOf addWithOverflow subWithOverflow mulWithOverflow shlWithOverflow shlExact shrExact cInclude cDefine cUndef ctz clz import cImport errorName embedFile cmpxchg fence divExact truncate atomicRmw",
	6454	built_in: "atomicLoad breakpoint returnAddress frameAddress fieldParentPtr setFloatMode IntType OpaqueType compileError compileLog setCold setRuntimeSafety setEvalBranchQuota offsetOf memcpy inlineCall setGlobalLinkage setGlobalSection divTrunc divFloor enumTagName intToPtr ptrToInt panic canImplicitCast ptrCast bitCast rem mod memset sizeOf alignOf alignCast maxValue minValue memberCount memberName memberType typeOf addWithOverflow subWithOverflow mulWithOverflow shlWithOverflow shlExact shrExact cInclude cDefine cUndef ctz clz import cImport errorName embedFile cmpxchgStrong cmpxchgWeak fence divExact truncate atomicRmw sqrt field typeInfo",
5959	6455	literal: "true false null undefined"
5960	6456	},
5961	6457	n = [e, t.CLCM, t.CBCM, s, r];

src-self-hosted/arg.zig created+284

...	...	@@ -0,0 +1,284 @@
	1	const std = @import("std");
	2	const debug = std.debug;
	3	const mem = std.mem;
	4
	5	const Allocator = mem.Allocator;
	6	const ArrayList = std.ArrayList;
	7	const HashMap = std.HashMap;
	8
	9	fn trimStart(slice: []const u8, ch: u8) []const u8 {
	10	var i: usize = 0;
	11	for (slice) \|b\| {
	12	if (b != '-') break;
	13	i += 1;
	14	}
	15
	16	return slice[i..];
	17	}
	18
	19	fn argInAllowedSet(maybe_set: ?[]const []const u8, arg: []const u8) bool {
	20	if (maybe_set) \|set\| {
	21	for (set) \|possible\| {
	22	if (mem.eql(u8, arg, possible)) {
	23	return true;
	24	}
	25	}
	26	return false;
	27	} else {
	28	return true;
	29	}
	30	}
	31
	32	// Modifies the current argument index during iteration
	33	fn readFlagArguments(allocator: &Allocator, args: []const []const u8, required: usize,
	34	allowed_set: ?[]const []const u8, index: &usize) !FlagArg {
	35
	36	switch (required) {
	37	0 => return FlagArg { .None = undefined }, // TODO: Required to force non-tag but value?
	38	1 => {
	39	if (*index + 1 >= args.len) {
	40	return error.MissingFlagArguments;
	41	}
	42
	43	*index += 1;
	44	const arg = args[*index];
	45
	46	if (!argInAllowedSet(allowed_set, arg)) {
	47	return error.ArgumentNotInAllowedSet;
	48	}
	49
	50	return FlagArg { .Single = arg };
	51	},
	52	else => \|needed\| {
	53	var extra = ArrayList([]const u8).init(allocator);
	54	errdefer extra.deinit();
	55
	56	var j: usize = 0;
	57	while (j < needed) : (j += 1) {
	58	if (*index + 1 >= args.len) {
	59	return error.MissingFlagArguments;
	60	}
	61
	62	*index += 1;
	63	const arg = args[*index];
	64
	65	if (!argInAllowedSet(allowed_set, arg)) {
	66	return error.ArgumentNotInAllowedSet;
	67	}
	68
	69	try extra.append(arg);
	70	}
	71
	72	return FlagArg { .Many = extra };
	73	},
	74	}
	75	}
	76
	77	const HashMapFlags = HashMap([]const u8, FlagArg, std.hash.Fnv1a_32.hash, mem.eql_slice_u8);
	78
	79	// A store for querying found flags and positional arguments.
	80	pub const Args = struct {
	81	flags: HashMapFlags,
	82	positionals: ArrayList([]const u8),
	83
	84	pub fn parse(allocator: &Allocator, comptime spec: []const Flag, args: []const []const u8) !Args {
	85	var parsed = Args {
	86	.flags = HashMapFlags.init(allocator),
	87	.positionals = ArrayList([]const u8).init(allocator),
	88	};
	89
	90	var i: usize = 0;
	91	next: while (i < args.len) : (i += 1) {
	92	const arg = args[i];
	93
	94	if (arg.len != 0 and arg[0] == '-') {
	95	// TODO: hashmap, although the linear scan is okay for small argument sets as is
	96	for (spec) \|flag\| {
	97	if (mem.eql(u8, arg, flag.name)) {
	98	const flag_name_trimmed = trimStart(flag.name, '-');
	99	const flag_args = readFlagArguments(allocator, args, flag.required, flag.allowed_set, &i) catch \|err\| {
	100	switch (err) {
	101	error.ArgumentNotInAllowedSet => {
	102	std.debug.warn("argument '{}' is invalid for flag '{}'\n", args[i], arg);
	103	std.debug.warn("allowed options are ");
	104	for (??flag.allowed_set) \|possible\| {
	105	std.debug.warn("'{}' ", possible);
	106	}
	107	std.debug.warn("\n");
	108	},
	109	error.MissingFlagArguments => {
	110	std.debug.warn("missing argument for flag: {}\n", arg);
	111	},
	112	else => {},
	113	}
	114
	115	return err;
	116	};
	117
	118	if (flag.mergable) {
	119	var prev =
	120	if (parsed.flags.get(flag_name_trimmed)) \|entry\|
	121	entry.value.Many
	122	else
	123	ArrayList([]const u8).init(allocator);
	124
	125	// MergeN creation disallows 0 length flag entry (doesn't make sense)
	126	switch (flag_args) {
	127	FlagArg.None => unreachable,
	128	FlagArg.Single => \|inner\| try prev.append(inner),
	129	FlagArg.Many => \|inner\| try prev.appendSlice(inner.toSliceConst()),
	130	}
	131
	132	_ = try parsed.flags.put(flag_name_trimmed, FlagArg { .Many = prev });
	133	} else {
	134	_ = try parsed.flags.put(flag_name_trimmed, flag_args);
	135	}
	136
	137	continue :next;
	138	}
	139	}
	140
	141	// TODO: Better errors with context, global error state and return is sufficient.
	142	std.debug.warn("could not match flag: {}\n", arg);
	143	return error.UnknownFlag;
	144	} else {
	145	try parsed.positionals.append(arg);
	146	}
	147	}
	148
	149	return parsed;
	150	}
	151
	152	pub fn deinit(self: &Args) void {
	153	self.flags.deinit();
	154	self.positionals.deinit();
	155	}
	156
	157	// e.g. --help
	158	pub fn present(self: &Args, name: []const u8) bool {
	159	return self.flags.contains(name);
	160	}
	161
	162	// e.g. --name value
	163	pub fn single(self: &Args, name: []const u8) ?[]const u8 {
	164	if (self.flags.get(name)) \|entry\| {
	165	switch (entry.value) {
	166	FlagArg.Single => \|inner\| { return inner; },
	167	else => @panic("attempted to retrieve flag with wrong type"),
	168	}
	169	} else {
	170	return null;
	171	}
	172	}
	173
	174	// e.g. --names value1 value2 value3
	175	pub fn many(self: &Args, name: []const u8) ?[]const []const u8 {
	176	if (self.flags.get(name)) \|entry\| {
	177	switch (entry.value) {
	178	FlagArg.Many => \|inner\| { return inner.toSliceConst(); },
	179	else => @panic("attempted to retrieve flag with wrong type"),
	180	}
	181	} else {
	182	return null;
	183	}
	184	}
	185	};
	186
	187	// Arguments for a flag. e.g. arg1, arg2 in `--command arg1 arg2`.
	188	const FlagArg = union(enum) {
	189	None,
	190	Single: []const u8,
	191	Many: ArrayList([]const u8),
	192	};
	193
	194	// Specification for how a flag should be parsed.
	195	pub const Flag = struct {
	196	name: []const u8,
	197	required: usize,
	198	mergable: bool,
	199	allowed_set: ?[]const []const u8,
	200
	201	pub fn Bool(comptime name: []const u8) Flag {
	202	return ArgN(name, 0);
	203	}
	204
	205	pub fn Arg1(comptime name: []const u8) Flag {
	206	return ArgN(name, 1);
	207	}
	208
	209	pub fn ArgN(comptime name: []const u8, comptime n: usize) Flag {
	210	return Flag {
	211	.name = name,
	212	.required = n,
	213	.mergable = false,
	214	.allowed_set = null,
	215	};
	216	}
	217
	218	pub fn ArgMergeN(comptime name: []const u8, comptime n: usize) Flag {
	219	if (n == 0) {
	220	@compileError("n must be greater than 0");
	221	}
	222
	223	return Flag {
	224	.name = name,
	225	.required = n,
	226	.mergable = true,
	227	.allowed_set = null,
	228	};
	229	}
	230
	231	pub fn Option(comptime name: []const u8, comptime set: []const []const u8) Flag {
	232	return Flag {
	233	.name = name,
	234	.required = 1,
	235	.mergable = false,
	236	.allowed_set = set,
	237	};
	238	}
	239	};
	240
	241	test "parse arguments" {
	242	const spec1 = comptime []const Flag {
	243	Flag.Bool("--help"),
	244	Flag.Bool("--init"),
	245	Flag.Arg1("--build-file"),
	246	Flag.Option("--color", []const []const u8 { "on", "off", "auto" }),
	247	Flag.ArgN("--pkg-begin", 2),
	248	Flag.ArgMergeN("--object", 1),
	249	Flag.ArgN("--library", 1),
	250	};
	251
	252	const cliargs = []const []const u8 {
	253	"build",
	254	"--help",
	255	"pos1",
	256	"--build-file", "build.zig",
	257	"--object", "obj1",
	258	"--object", "obj2",
	259	"--library", "lib1",
	260	"--library", "lib2",
	261	"--color", "on",
	262	"pos2",
	263	};
	264
	265	var args = try Args.parse(std.debug.global_allocator, spec1, cliargs);
	266
	267	debug.assert(args.present("help"));
	268	debug.assert(!args.present("help2"));
	269	debug.assert(!args.present("init"));
	270
	271	debug.assert(mem.eql(u8, ??args.single("build-file"), "build.zig"));
	272	debug.assert(mem.eql(u8, ??args.single("color"), "on"));
	273
	274	const objects = ??args.many("object");
	275	debug.assert(mem.eql(u8, objects[0], "obj1"));
	276	debug.assert(mem.eql(u8, objects[1], "obj2"));
	277
	278	debug.assert(mem.eql(u8, ??args.single("library"), "lib2"));
	279
	280	const pos = args.positionals.toSliceConst();
	281	debug.assert(mem.eql(u8, pos[0], "build"));
	282	debug.assert(mem.eql(u8, pos[1], "pos1"));
	283	debug.assert(mem.eql(u8, pos[2], "pos2"));
	284	}

src-self-hosted/introspect.zig created+57

...	...	@@ -0,0 +1,57 @@
	1	// Introspection and determination of system libraries needed by zig.
	2
	3	const std = @import("std");
	4	const mem = std.mem;
	5	const os = std.os;
	6
	7	const warn = std.debug.warn;
	8
	9	/// Caller must free result
	10	pub fn testZigInstallPrefix(allocator: &mem.Allocator, test_path: []const u8) ![]u8 {
	11	const test_zig_dir = try os.path.join(allocator, test_path, "lib", "zig");
	12	errdefer allocator.free(test_zig_dir);
	13
	14	const test_index_file = try os.path.join(allocator, test_zig_dir, "std", "index.zig");
	15	defer allocator.free(test_index_file);
	16
	17	var file = try os.File.openRead(allocator, test_index_file);
	18	file.close();
	19
	20	return test_zig_dir;
	21	}
	22
	23	/// Caller must free result
	24	pub fn findZigLibDir(allocator: &mem.Allocator) ![]u8 {
	25	const self_exe_path = try os.selfExeDirPath(allocator);
	26	defer allocator.free(self_exe_path);
	27
	28	var cur_path: []const u8 = self_exe_path;
	29	while (true) {
	30	const test_dir = os.path.dirname(cur_path);
	31
	32	if (mem.eql(u8, test_dir, cur_path)) {
	33	break;
	34	}
	35
	36	return testZigInstallPrefix(allocator, test_dir) catch \|err\| {
	37	cur_path = test_dir;
	38	continue;
	39	};
	40	}
	41
	42	return error.FileNotFound;
	43	}
	44
	45	pub fn resolveZigLibDir(allocator: &mem.Allocator) ![]u8 {
	46	return findZigLibDir(allocator) catch \|err\| {
	47	warn(
	48	\\Unable to find zig lib directory: {}.
	49	\\Reinstall Zig or use --zig-install-prefix.
	50	\\
	51	,
	52	@errorName(err)
	53	);
	54
	55	return error.ZigLibDirNotFound;
	56	};
	57	}

src-self-hosted/main.zig+895-701

...	...	@@ -1,613 +1,165 @@
1	1	const std = @import("std");
2		const mem = std.mem;
3		const io = std.io;
4		const os = std.os;
5		const heap = std.heap;
6		const warn = std.debug.warn;
7		const assert = std.debug.assert;
8		const target = @import("target.zig");
9		const Target = target.Target;
10		const Module = @import("module.zig").Module;
11		const ErrColor = Module.ErrColor;
12		const Emit = Module.Emit;
13	2	const builtin = @import("builtin");
14		const ArrayList = std.ArrayList;
15		const c = @import("c.zig");
16	3
17		const default_zig_cache_name = "zig-cache";
	4	const os = std.os;
	5	const io = std.io;
	6	const mem = std.mem;
	7	const Allocator = mem.Allocator;
	8	const ArrayList = std.ArrayList;
	9	const Buffer = std.Buffer;
18	10
19		const Cmd = enum {
20		None,
21		Build,
22		Test,
23		Version,
24		Zen,
25		TranslateC,
26		Targets,
	11	const arg = @import("arg.zig");
	12	const c = @import("c.zig");
	13	const introspect = @import("introspect.zig");
	14	const Args = arg.Args;
	15	const Flag = arg.Flag;
	16	const Module = @import("module.zig").Module;
	17	const Target = @import("target.zig").Target;
	18
	19	var stderr: &io.OutStream(io.FileOutStream.Error) = undefined;
	20	var stdout: &io.OutStream(io.FileOutStream.Error) = undefined;
	21
	22	const usage =
	23	\\usage: zig [command] [options]
	24	\\
	25	\\Commands:
	26	\\
	27	\\ build Build project from build.zig
	28	\\ build-exe [source] Create executable from source or object files
	29	\\ build-lib [source] Create library from source or object files
	30	\\ build-obj [source] Create object from source or assembly
	31	\\ fmt [source] Parse file and render in canonical zig format
	32	\\ run [source] Create executable and run immediately
	33	\\ targets List available compilation targets
	34	\\ test [source] Create and run a test build
	35	\\ translate-c [source] Convert c code to zig code
	36	\\ version Print version number and exit
	37	\\ zen Print zen of zig and exit
	38	\\
	39	\\
	40	;
	41
	42	const Command = struct {
	43	name: []const u8,
	44	exec: fn(&Allocator, []const []const u8) error!void,
27	45	};
28	46
29		fn badArgs(comptime format: []const u8, args: ...) noreturn {
30		var stderr = io.getStdErr() catch std.os.exit(1);
31		var stderr_stream_adapter = io.FileOutStream.init(&stderr);
32		const stderr_stream = &stderr_stream_adapter.stream;
33		stderr_stream.print(format ++ "\n\n", args) catch std.os.exit(1);
34		printUsage(&stderr_stream_adapter.stream) catch std.os.exit(1);
35		std.os.exit(1);
36		}
37
38	47	pub fn main() !void {
39		const allocator = std.heap.c_allocator;
	48	var allocator = std.heap.c_allocator;
	49
	50	var stdout_file = try std.io.getStdOut();
	51	var stdout_out_stream = std.io.FileOutStream.init(&stdout_file);
	52	stdout = &stdout_out_stream.stream;
	53
	54	var stderr_file = try std.io.getStdErr();
	55	var stderr_out_stream = std.io.FileOutStream.init(&stderr_file);
	56	stderr = &stderr_out_stream.stream;
40	57
41	58	const args = try os.argsAlloc(allocator);
42	59	defer os.argsFree(allocator, args);
43	60
44		if (args.len >= 2 and mem.eql(u8, args[1], "build")) {
45		return buildMain(allocator, args[2..]);
46		}
47
48		if (args.len >= 2 and mem.eql(u8, args[1], "fmt")) {
49		return fmtMain(allocator, args[2..]);
50		}
51
52		var cmd = Cmd.None;
53		var build_kind: Module.Kind = undefined;
54		var build_mode: builtin.Mode = builtin.Mode.Debug;
55		var color = ErrColor.Auto;
56		var emit_file_type = Emit.Binary;
57
58		var strip = false;
59		var is_static = false;
60		var verbose_tokenize = false;
61		var verbose_ast_tree = false;
62		var verbose_ast_fmt = false;
63		var verbose_link = false;
64		var verbose_ir = false;
65		var verbose_llvm_ir = false;
66		var verbose_cimport = false;
67		var mwindows = false;
68		var mconsole = false;
69		var rdynamic = false;
70		var each_lib_rpath = false;
71		var timing_info = false;
72
73		var in_file_arg: ?[]u8 = null;
74		var out_file: ?[]u8 = null;
75		var out_file_h: ?[]u8 = null;
76		var out_name_arg: ?[]u8 = null;
77		var libc_lib_dir_arg: ?[]u8 = null;
78		var libc_static_lib_dir_arg: ?[]u8 = null;
79		var libc_include_dir_arg: ?[]u8 = null;
80		var msvc_lib_dir_arg: ?[]u8 = null;
81		var kernel32_lib_dir_arg: ?[]u8 = null;
82		var zig_install_prefix: ?[]u8 = null;
83		var dynamic_linker_arg: ?[]u8 = null;
84		var cache_dir_arg: ?[]const u8 = null;
85		var target_arch: ?[]u8 = null;
86		var target_os: ?[]u8 = null;
87		var target_environ: ?[]u8 = null;
88		var mmacosx_version_min: ?[]u8 = null;
89		var mios_version_min: ?[]u8 = null;
90		var linker_script_arg: ?[]u8 = null;
91		var test_name_prefix_arg: ?[]u8 = null;
92
93		var test_filters = ArrayList([]const u8).init(allocator);
94		defer test_filters.deinit();
95
96		var lib_dirs = ArrayList([]const u8).init(allocator);
97		defer lib_dirs.deinit();
98
99		var clang_argv = ArrayList([]const u8).init(allocator);
100		defer clang_argv.deinit();
101
102		var llvm_argv = ArrayList([]const u8).init(allocator);
103		defer llvm_argv.deinit();
104
105		var link_libs = ArrayList([]const u8).init(allocator);
106		defer link_libs.deinit();
107
108		var frameworks = ArrayList([]const u8).init(allocator);
109		defer frameworks.deinit();
110
111		var objects = ArrayList([]const u8).init(allocator);
112		defer objects.deinit();
113
114		var asm_files = ArrayList([]const u8).init(allocator);
115		defer asm_files.deinit();
116
117		var rpath_list = ArrayList([]const u8).init(allocator);
118		defer rpath_list.deinit();
119
120		var ver_major: u32 = 0;
121		var ver_minor: u32 = 0;
122		var ver_patch: u32 = 0;
123
124		var arg_i: usize = 1;
125		while (arg_i < args.len) : (arg_i += 1) {
126		const arg = args[arg_i];
127
128		if (arg.len != 0 and arg[0] == '-') {
129		if (mem.eql(u8, arg, "--release-fast")) {
130		build_mode = builtin.Mode.ReleaseFast;
131		} else if (mem.eql(u8, arg, "--release-safe")) {
132		build_mode = builtin.Mode.ReleaseSafe;
133		} else if (mem.eql(u8, arg, "--strip")) {
134		strip = true;
135		} else if (mem.eql(u8, arg, "--static")) {
136		is_static = true;
137		} else if (mem.eql(u8, arg, "--verbose-tokenize")) {
138		verbose_tokenize = true;
139		} else if (mem.eql(u8, arg, "--verbose-ast-tree")) {
140		verbose_ast_tree = true;
141		} else if (mem.eql(u8, arg, "--verbose-ast-fmt")) {
142		verbose_ast_fmt = true;
143		} else if (mem.eql(u8, arg, "--verbose-link")) {
144		verbose_link = true;
145		} else if (mem.eql(u8, arg, "--verbose-ir")) {
146		verbose_ir = true;
147		} else if (mem.eql(u8, arg, "--verbose-llvm-ir")) {
148		verbose_llvm_ir = true;
149		} else if (mem.eql(u8, arg, "--verbose-cimport")) {
150		verbose_cimport = true;
151		} else if (mem.eql(u8, arg, "-mwindows")) {
152		mwindows = true;
153		} else if (mem.eql(u8, arg, "-mconsole")) {
154		mconsole = true;
155		} else if (mem.eql(u8, arg, "-rdynamic")) {
156		rdynamic = true;
157		} else if (mem.eql(u8, arg, "--each-lib-rpath")) {
158		each_lib_rpath = true;
159		} else if (mem.eql(u8, arg, "--enable-timing-info")) {
160		timing_info = true;
161		} else if (mem.eql(u8, arg, "--test-cmd-bin")) {
162		@panic("TODO --test-cmd-bin");
163		} else if (arg[1] == 'L' and arg.len > 2) {
164		// alias for --library-path
165		try lib_dirs.append(arg[1..]);
166		} else if (mem.eql(u8, arg, "--pkg-begin")) {
167		@panic("TODO --pkg-begin");
168		} else if (mem.eql(u8, arg, "--pkg-end")) {
169		@panic("TODO --pkg-end");
170		} else if (arg_i + 1 >= args.len) {
171		badArgs("expected another argument after {}", arg);
172		} else {
173		arg_i += 1;
174		if (mem.eql(u8, arg, "--output")) {
175		out_file = args[arg_i];
176		} else if (mem.eql(u8, arg, "--output-h")) {
177		out_file_h = args[arg_i];
178		} else if (mem.eql(u8, arg, "--color")) {
179		if (mem.eql(u8, args[arg_i], "auto")) {
180		color = ErrColor.Auto;
181		} else if (mem.eql(u8, args[arg_i], "on")) {
182		color = ErrColor.On;
183		} else if (mem.eql(u8, args[arg_i], "off")) {
184		color = ErrColor.Off;
185		} else {
186		badArgs("--color options are 'auto', 'on', or 'off'");
187		}
188		} else if (mem.eql(u8, arg, "--emit")) {
189		if (mem.eql(u8, args[arg_i], "asm")) {
190		emit_file_type = Emit.Assembly;
191		} else if (mem.eql(u8, args[arg_i], "bin")) {
192		emit_file_type = Emit.Binary;
193		} else if (mem.eql(u8, args[arg_i], "llvm-ir")) {
194		emit_file_type = Emit.LlvmIr;
195		} else {
196		badArgs("--emit options are 'asm', 'bin', or 'llvm-ir'");
197		}
198		} else if (mem.eql(u8, arg, "--name")) {
199		out_name_arg = args[arg_i];
200		} else if (mem.eql(u8, arg, "--libc-lib-dir")) {
201		libc_lib_dir_arg = args[arg_i];
202		} else if (mem.eql(u8, arg, "--libc-static-lib-dir")) {
203		libc_static_lib_dir_arg = args[arg_i];
204		} else if (mem.eql(u8, arg, "--libc-include-dir")) {
205		libc_include_dir_arg = args[arg_i];
206		} else if (mem.eql(u8, arg, "--msvc-lib-dir")) {
207		msvc_lib_dir_arg = args[arg_i];
208		} else if (mem.eql(u8, arg, "--kernel32-lib-dir")) {
209		kernel32_lib_dir_arg = args[arg_i];
210		} else if (mem.eql(u8, arg, "--zig-install-prefix")) {
211		zig_install_prefix = args[arg_i];
212		} else if (mem.eql(u8, arg, "--dynamic-linker")) {
213		dynamic_linker_arg = args[arg_i];
214		} else if (mem.eql(u8, arg, "-isystem")) {
215		try clang_argv.append("-isystem");
216		try clang_argv.append(args[arg_i]);
217		} else if (mem.eql(u8, arg, "-dirafter")) {
218		try clang_argv.append("-dirafter");
219		try clang_argv.append(args[arg_i]);
220		} else if (mem.eql(u8, arg, "-mllvm")) {
221		try clang_argv.append("-mllvm");
222		try clang_argv.append(args[arg_i]);
223
224		try llvm_argv.append(args[arg_i]);
225		} else if (mem.eql(u8, arg, "--library-path") or mem.eql(u8, arg, "-L")) {
226		try lib_dirs.append(args[arg_i]);
227		} else if (mem.eql(u8, arg, "--library")) {
228		try link_libs.append(args[arg_i]);
229		} else if (mem.eql(u8, arg, "--object")) {
230		try objects.append(args[arg_i]);
231		} else if (mem.eql(u8, arg, "--assembly")) {
232		try asm_files.append(args[arg_i]);
233		} else if (mem.eql(u8, arg, "--cache-dir")) {
234		cache_dir_arg = args[arg_i];
235		} else if (mem.eql(u8, arg, "--target-arch")) {
236		target_arch = args[arg_i];
237		} else if (mem.eql(u8, arg, "--target-os")) {
238		target_os = args[arg_i];
239		} else if (mem.eql(u8, arg, "--target-environ")) {
240		target_environ = args[arg_i];
241		} else if (mem.eql(u8, arg, "-mmacosx-version-min")) {
242		mmacosx_version_min = args[arg_i];
243		} else if (mem.eql(u8, arg, "-mios-version-min")) {
244		mios_version_min = args[arg_i];
245		} else if (mem.eql(u8, arg, "-framework")) {
246		try frameworks.append(args[arg_i]);
247		} else if (mem.eql(u8, arg, "--linker-script")) {
248		linker_script_arg = args[arg_i];
249		} else if (mem.eql(u8, arg, "-rpath")) {
250		try rpath_list.append(args[arg_i]);
251		} else if (mem.eql(u8, arg, "--test-filter")) {
252		try test_filters.append(args[arg_i]);
253		} else if (mem.eql(u8, arg, "--test-name-prefix")) {
254		test_name_prefix_arg = args[arg_i];
255		} else if (mem.eql(u8, arg, "--ver-major")) {
256		ver_major = try std.fmt.parseUnsigned(u32, args[arg_i], 10);
257		} else if (mem.eql(u8, arg, "--ver-minor")) {
258		ver_minor = try std.fmt.parseUnsigned(u32, args[arg_i], 10);
259		} else if (mem.eql(u8, arg, "--ver-patch")) {
260		ver_patch = try std.fmt.parseUnsigned(u32, args[arg_i], 10);
261		} else if (mem.eql(u8, arg, "--test-cmd")) {
262		@panic("TODO --test-cmd");
263		} else {
264		badArgs("invalid argument: {}", arg);
265		}
266		}
267		} else if (cmd == Cmd.None) {
268		if (mem.eql(u8, arg, "build-obj")) {
269		cmd = Cmd.Build;
270		build_kind = Module.Kind.Obj;
271		} else if (mem.eql(u8, arg, "build-exe")) {
272		cmd = Cmd.Build;
273		build_kind = Module.Kind.Exe;
274		} else if (mem.eql(u8, arg, "build-lib")) {
275		cmd = Cmd.Build;
276		build_kind = Module.Kind.Lib;
277		} else if (mem.eql(u8, arg, "version")) {
278		cmd = Cmd.Version;
279		} else if (mem.eql(u8, arg, "zen")) {
280		cmd = Cmd.Zen;
281		} else if (mem.eql(u8, arg, "translate-c")) {
282		cmd = Cmd.TranslateC;
283		} else if (mem.eql(u8, arg, "test")) {
284		cmd = Cmd.Test;
285		build_kind = Module.Kind.Exe;
286		} else {
287		badArgs("unrecognized command: {}", arg);
288		}
289		} else switch (cmd) {
290		Cmd.Build, Cmd.TranslateC, Cmd.Test => {
291		if (in_file_arg == null) {
292		in_file_arg = arg;
293		} else {
294		badArgs("unexpected extra parameter: {}", arg);
295		}
296		},
297		Cmd.Version, Cmd.Zen, Cmd.Targets => {
298		badArgs("unexpected extra parameter: {}", arg);
299		},
300		Cmd.None => unreachable,
301		}
	61	if (args.len <= 1) {
	62	try stderr.write(usage);
	63	os.exit(1);
302	64	}
303	65
304		target.initializeAll();
305
306		// TODO
307		// ZigTarget alloc_target;
308		// ZigTarget *target;
309		// if (!target_arch && !target_os && !target_environ) {
310		// target = nullptr;
311		// } else {
312		// target = &alloc_target;
313		// get_unknown_target(target);
314		// if (target_arch) {
315		// if (parse_target_arch(target_arch, &target->arch)) {
316		// fprintf(stderr, "invalid --target-arch argument\n");
317		// return usage(arg0);
318		// }
319		// }
320		// if (target_os) {
321		// if (parse_target_os(target_os, &target->os)) {
322		// fprintf(stderr, "invalid --target-os argument\n");
323		// return usage(arg0);
324		// }
325		// }
326		// if (target_environ) {
327		// if (parse_target_environ(target_environ, &target->env_type)) {
328		// fprintf(stderr, "invalid --target-environ argument\n");
329		// return usage(arg0);
330		// }
331		// }
332		// }
333
334		switch (cmd) {
335		Cmd.None => badArgs("expected command"),
336		Cmd.Zen => return printZen(),
337		Cmd.Build, Cmd.Test, Cmd.TranslateC => {
338		if (cmd == Cmd.Build and in_file_arg == null and objects.len == 0 and asm_files.len == 0) {
339		badArgs("expected source file argument or at least one --object or --assembly argument");
340		} else if ((cmd == Cmd.TranslateC or cmd == Cmd.Test) and in_file_arg == null) {
341		badArgs("expected source file argument");
342		} else if (cmd == Cmd.Build and build_kind == Module.Kind.Obj and objects.len != 0) {
343		badArgs("When building an object file, --object arguments are invalid");
344		}
345
346		const root_name = switch (cmd) {
347		Cmd.Build, Cmd.TranslateC => x: {
348		if (out_name_arg) \|out_name\| {
349		break :x out_name;
350		} else if (in_file_arg) \|in_file_path\| {
351		const basename = os.path.basename(in_file_path);
352		var it = mem.split(basename, ".");
353		break :x it.next() ?? badArgs("file name cannot be empty");
354		} else {
355		badArgs("--name [name] not provided and unable to infer");
356		}
357		},
358		Cmd.Test => "test",
359		else => unreachable,
360		};
361
362		const zig_root_source_file = if (cmd == Cmd.TranslateC) null else in_file_arg;
363
364		const chosen_cache_dir = cache_dir_arg ?? default_zig_cache_name;
365		const full_cache_dir = try os.path.resolve(allocator, ".", chosen_cache_dir);
366		defer allocator.free(full_cache_dir);
367
368		const zig_lib_dir = try resolveZigLibDir(allocator, zig_install_prefix);
369		errdefer allocator.free(zig_lib_dir);
370
371		const module = try Module.create(allocator, root_name, zig_root_source_file,
372		Target.Native, build_kind, build_mode, zig_lib_dir, full_cache_dir);
373		defer module.destroy();
374
375		module.version_major = ver_major;
376		module.version_minor = ver_minor;
377		module.version_patch = ver_patch;
378
379		module.is_test = cmd == Cmd.Test;
380		if (linker_script_arg) \|linker_script\| {
381		module.linker_script = linker_script;
382		}
383		module.each_lib_rpath = each_lib_rpath;
384		module.clang_argv = clang_argv.toSliceConst();
385		module.llvm_argv = llvm_argv.toSliceConst();
386		module.strip = strip;
387		module.is_static = is_static;
388
389		if (libc_lib_dir_arg) \|libc_lib_dir\| {
390		module.libc_lib_dir = libc_lib_dir;
391		}
392		if (libc_static_lib_dir_arg) \|libc_static_lib_dir\| {
393		module.libc_static_lib_dir = libc_static_lib_dir;
394		}
395		if (libc_include_dir_arg) \|libc_include_dir\| {
396		module.libc_include_dir = libc_include_dir;
397		}
398		if (msvc_lib_dir_arg) \|msvc_lib_dir\| {
399		module.msvc_lib_dir = msvc_lib_dir;
400		}
401		if (kernel32_lib_dir_arg) \|kernel32_lib_dir\| {
402		module.kernel32_lib_dir = kernel32_lib_dir;
403		}
404		if (dynamic_linker_arg) \|dynamic_linker\| {
405		module.dynamic_linker = dynamic_linker;
406		}
407		module.verbose_tokenize = verbose_tokenize;
408		module.verbose_ast_tree = verbose_ast_tree;
409		module.verbose_ast_fmt = verbose_ast_fmt;
410		module.verbose_link = verbose_link;
411		module.verbose_ir = verbose_ir;
412		module.verbose_llvm_ir = verbose_llvm_ir;
413		module.verbose_cimport = verbose_cimport;
414
415		module.err_color = color;
416
417		module.lib_dirs = lib_dirs.toSliceConst();
418		module.darwin_frameworks = frameworks.toSliceConst();
419		module.rpath_list = rpath_list.toSliceConst();
420
421		for (link_libs.toSliceConst()) \|name\| {
422		_ = try module.addLinkLib(name, true);
423		}
424
425		module.windows_subsystem_windows = mwindows;
426		module.windows_subsystem_console = mconsole;
427		module.linker_rdynamic = rdynamic;
428
429		if (mmacosx_version_min != null and mios_version_min != null) {
430		badArgs("-mmacosx-version-min and -mios-version-min options not allowed together");
431		}
432
433		if (mmacosx_version_min) \|ver\| {
434		module.darwin_version_min = Module.DarwinVersionMin { .MacOS = ver };
435		} else if (mios_version_min) \|ver\| {
436		module.darwin_version_min = Module.DarwinVersionMin { .Ios = ver };
437		}
438
439		module.test_filters = test_filters.toSliceConst();
440		module.test_name_prefix = test_name_prefix_arg;
441		module.out_h_path = out_file_h;
442
443		// TODO
444		//add_package(g, cur_pkg, g->root_package);
445
446		switch (cmd) {
447		Cmd.Build => {
448		module.emit_file_type = emit_file_type;
449
450		module.link_objects = objects.toSliceConst();
451		module.assembly_files = asm_files.toSliceConst();
452
453		try module.build();
454		try module.link(out_file);
455		},
456		Cmd.TranslateC => @panic("TODO translate-c"),
457		Cmd.Test => @panic("TODO test cmd"),
458		else => unreachable,
459		}
460		},
461		Cmd.Version => {
462		var stdout_file = try io.getStdErr();
463		try stdout_file.write(std.cstr.toSliceConst(c.ZIG_VERSION_STRING));
464		try stdout_file.write("\n");
465		},
466		Cmd.Targets => @panic("TODO zig targets"),
	66	const commands = []Command {
	67	Command { .name = "build", .exec = cmdBuild },
	68	Command { .name = "build-exe", .exec = cmdBuildExe },
	69	Command { .name = "build-lib", .exec = cmdBuildLib },
	70	Command { .name = "build-obj", .exec = cmdBuildObj },
	71	Command { .name = "fmt", .exec = cmdFmt },
	72	Command { .name = "run", .exec = cmdRun },
	73	Command { .name = "targets", .exec = cmdTargets },
	74	Command { .name = "test", .exec = cmdTest },
	75	Command { .name = "translate-c", .exec = cmdTranslateC },
	76	Command { .name = "version", .exec = cmdVersion },
	77	Command { .name = "zen", .exec = cmdZen },
	78
	79	// undocumented commands
	80	Command { .name = "help", .exec = cmdHelp },
	81	Command { .name = "internal", .exec = cmdInternal },
	82	};
	83
	84	for (commands) \|command\| {
	85	if (mem.eql(u8, command.name, args[1])) {
	86	try command.exec(allocator, args[2..]);
	87	return;
	88	}
467	89	}
468		}
469	90
470		fn printUsage(stream: var) !void {
471		try stream.write(
472		\\Usage: zig [command] [options]
473		\\
474		\\Commands:
475		\\ build build project from build.zig
476		\\ build-exe [source] create executable from source or object files
477		\\ build-lib [source] create library from source or object files
478		\\ build-obj [source] create object from source or assembly
479		\\ fmt [file] parse file and render in canonical zig format
480		\\ translate-c [source] convert c code to zig code
481		\\ targets list available compilation targets
482		\\ test [source] create and run a test build
483		\\ version print version number and exit
484		\\ zen print zen of zig and exit
485		\\Compile Options:
486		\\ --assembly [source] add assembly file to build
487		\\ --cache-dir [path] override the cache directory
488		\\ --color [auto\|off\|on] enable or disable colored error messages
489		\\ --emit [filetype] emit a specific file format as compilation output
490		\\ --enable-timing-info print timing diagnostics
491		\\ --libc-include-dir [path] directory where libc stdlib.h resides
492		\\ --name [name] override output name
493		\\ --output [file] override destination path
494		\\ --output-h [file] override generated header file path
495		\\ --pkg-begin [name] [path] make package available to import and push current pkg
496		\\ --pkg-end pop current pkg
497		\\ --release-fast build with optimizations on and safety off
498		\\ --release-safe build with optimizations on and safety on
499		\\ --static output will be statically linked
500		\\ --strip exclude debug symbols
501		\\ --target-arch [name] specify target architecture
502		\\ --target-environ [name] specify target environment
503		\\ --target-os [name] specify target operating system
504		\\ --verbose-tokenize enable compiler debug info: tokenization
505		\\ --verbose-ast-tree enable compiler debug info: parsing into an AST (treeview)
506		\\ --verbose-ast-fmt enable compiler debug info: parsing into an AST (render source)
507		\\ --verbose-cimport enable compiler debug info: C imports
508		\\ --verbose-ir enable compiler debug info: Zig IR
509		\\ --verbose-llvm-ir enable compiler debug info: LLVM IR
510		\\ --verbose-link enable compiler debug info: linking
511		\\ --zig-install-prefix [path] override directory where zig thinks it is installed
512		\\ -dirafter [dir] same as -isystem but do it last
513		\\ -isystem [dir] add additional search path for other .h files
514		\\ -mllvm [arg] additional arguments to forward to LLVM's option processing
515		\\Link Options:
516		\\ --ar-path [path] set the path to ar
517		\\ --dynamic-linker [path] set the path to ld.so
518		\\ --each-lib-rpath add rpath for each used dynamic library
519		\\ --libc-lib-dir [path] directory where libc crt1.o resides
520		\\ --libc-static-lib-dir [path] directory where libc crtbegin.o resides
521		\\ --msvc-lib-dir [path] (windows) directory where vcruntime.lib resides
522		\\ --kernel32-lib-dir [path] (windows) directory where kernel32.lib resides
523		\\ --library [lib] link against lib
524		\\ --library-path [dir] add a directory to the library search path
525		\\ --linker-script [path] use a custom linker script
526		\\ --object [obj] add object file to build
527		\\ -L[dir] alias for --library-path
528		\\ -rdynamic add all symbols to the dynamic symbol table
529		\\ -rpath [path] add directory to the runtime library search path
530		\\ -mconsole (windows) --subsystem console to the linker
531		\\ -mwindows (windows) --subsystem windows to the linker
532		\\ -framework [name] (darwin) link against framework
533		\\ -mios-version-min [ver] (darwin) set iOS deployment target
534		\\ -mmacosx-version-min [ver] (darwin) set Mac OS X deployment target
535		\\ --ver-major [ver] dynamic library semver major version
536		\\ --ver-minor [ver] dynamic library semver minor version
537		\\ --ver-patch [ver] dynamic library semver patch version
538		\\Test Options:
539		\\ --test-filter [text] skip tests that do not match filter
540		\\ --test-name-prefix [text] add prefix to all tests
541		\\ --test-cmd [arg] specify test execution command one arg at a time
542		\\ --test-cmd-bin appends test binary path to test cmd args
543		\\
544		);
545		}
546
547		fn printZen() !void {
548		var stdout_file = try io.getStdErr();
549		try stdout_file.write(
550		\\
551		\\ * Communicate intent precisely.
552		\\ * Edge cases matter.
553		\\ * Favor reading code over writing code.
554		\\ * Only one obvious way to do things.
555		\\ * Runtime crashes are better than bugs.
556		\\ * Compile errors are better than runtime crashes.
557		\\ * Incremental improvements.
558		\\ * Avoid local maximums.
559		\\ * Reduce the amount one must remember.
560		\\ * Minimize energy spent on coding style.
561		\\ * Together we serve end users.
562		\\
563		\\
564		);
	91	try stderr.print("unknown command: {}\n\n", args[1]);
	92	try stderr.write(usage);
565	93	}
566	94
567		fn buildMain(allocator: &mem.Allocator, argv: []const []const u8) !void {
568		var build_file: [] const u8 = "build.zig";
569		var cache_dir: ?[] const u8 = null;
570		var zig_install_prefix: ?[] const u8 = null;
571		var asked_for_help = false;
572		var asked_for_init = false;
573
574		var args = ArrayList([] const u8).init(allocator);
575		defer args.deinit();
576
577		var zig_exe_path = try os.selfExePath(allocator);
578		defer allocator.free(zig_exe_path);
579
580		try args.append(""); // Placeholder for zig-cache/build
581		try args.append(""); // Placeholder for zig_exe_path
582		try args.append(""); // Placeholder for build_file_dirname
583		try args.append(""); // Placeholder for full_cache_dir
	95	// cmd:build ///////////////////////////////////////////////////////////////////////////////////////
	96
	97	const usage_build =
	98	\\usage: zig build <options>
	99	\\
	100	\\General Options:
	101	\\ --help Print this help and exit
	102	\\ --init Generate a build.zig template
	103	\\ --build-file [file] Override path to build.zig
	104	\\ --cache-dir [path] Override path to cache directory
	105	\\ --verbose Print commands before executing them
	106	\\ --prefix [path] Override default install prefix
	107	\\
	108	\\Project-Specific Options:
	109	\\
	110	\\ Project-specific options become available when the build file is found.
	111	\\
	112	\\Advanced Options:
	113	\\ --build-file [file] Override path to build.zig
	114	\\ --cache-dir [path] Override path to cache directory
	115	\\ --verbose-tokenize Enable compiler debug output for tokenization
	116	\\ --verbose-ast Enable compiler debug output for parsing into an AST
	117	\\ --verbose-link Enable compiler debug output for linking
	118	\\ --verbose-ir Enable compiler debug output for Zig IR
	119	\\ --verbose-llvm-ir Enable compiler debug output for LLVM IR
	120	\\ --verbose-cimport Enable compiler debug output for C imports
	121	\\
	122	\\
	123	;
	124
	125	const args_build_spec = []Flag {
	126	Flag.Bool("--help"),
	127	Flag.Bool("--init"),
	128	Flag.Arg1("--build-file"),
	129	Flag.Arg1("--cache-dir"),
	130	Flag.Bool("--verbose"),
	131	Flag.Arg1("--prefix"),
	132
	133	Flag.Arg1("--build-file"),
	134	Flag.Arg1("--cache-dir"),
	135	Flag.Bool("--verbose-tokenize"),
	136	Flag.Bool("--verbose-ast"),
	137	Flag.Bool("--verbose-link"),
	138	Flag.Bool("--verbose-ir"),
	139	Flag.Bool("--verbose-llvm-ir"),
	140	Flag.Bool("--verbose-cimport"),
	141	};
584	142
585		var i: usize = 0;
586		while (i < argv.len) : (i += 1) {
587		var arg = argv[i];
588		if (mem.eql(u8, arg, "--help")) {
589		asked_for_help = true;
590		try args.append(argv[i]);
591		} else if (mem.eql(u8, arg, "--init")) {
592		asked_for_init = true;
593		try args.append(argv[i]);
594		} else if (i + 1 < argv.len and mem.eql(u8, arg, "--build-file")) {
595		build_file = argv[i + 1];
596		i += 1;
597		} else if (i + 1 < argv.len and mem.eql(u8, arg, "--cache-dir")) {
598		cache_dir = argv[i + 1];
599		i += 1;
600		} else if (i + 1 < argv.len and mem.eql(u8, arg, "--zig-install-prefix")) {
601		try args.append(arg);
602		i += 1;
603		zig_install_prefix = argv[i];
604		try args.append(argv[i]);
605		} else {
606		try args.append(arg);
607		}
	143	const missing_build_file =
	144	\\No 'build.zig' file found.
	145	\\
	146	\\Initialize a 'build.zig' template file with `zig build --init`,
	147	\\or build an executable directly with `zig build-exe $FILENAME.zig`.
	148	\\
	149	\\See: `zig build --help` or `zig help` for more options.
	150	\\
	151	;
	152
	153	fn cmdBuild(allocator: &Allocator, args: []const []const u8) !void {
	154	var flags = try Args.parse(allocator, args_build_spec, args);
	155	defer flags.deinit();
	156
	157	if (flags.present("help")) {
	158	try stderr.write(usage_build);
	159	os.exit(0);
608	160	}
609	161
610		const zig_lib_dir = try resolveZigLibDir(allocator, zig_install_prefix);
	162	const zig_lib_dir = try introspect.resolveZigLibDir(allocator);
611	163	defer allocator.free(zig_lib_dir);
612	164
613	165	const zig_std_dir = try os.path.join(allocator, zig_lib_dir, "std");
...	...	@@ -619,186 +171,828 @@ fn buildMain(allocator: &mem.Allocator, argv: []const []const u8) !void {
619	171	const build_runner_path = try os.path.join(allocator, special_dir, "build_runner.zig");
620	172	defer allocator.free(build_runner_path);
621	173
622		// g = codegen_create(build_runner_path, ...)
623		// codegen_set_out_name(g, "build")
624
	174	const build_file = flags.single("build-file") ?? "build.zig";
625	175	const build_file_abs = try os.path.resolve(allocator, ".", build_file);
626	176	defer allocator.free(build_file_abs);
627	177
628		const build_file_basename = os.path.basename(build_file_abs);
629		const build_file_dirname = os.path.dirname(build_file_abs);
	178	const build_file_exists = os.File.access(allocator, build_file_abs, os.default_file_mode) catch false;
630	179
631		var full_cache_dir: []u8 = undefined;
632		if (cache_dir == null) {
633		full_cache_dir = try os.path.join(allocator, build_file_dirname, "zig-cache");
634		} else {
635		full_cache_dir = try os.path.resolve(allocator, ".", ??cache_dir, full_cache_dir);
636		}
637		defer allocator.free(full_cache_dir);
	180	if (flags.present("init")) {
	181	if (build_file_exists) {
	182	try stderr.print("build.zig already exists\n");
	183	os.exit(1);
	184	}
638	185
639		const path_to_build_exe = try os.path.join(allocator, full_cache_dir, "build");
640		defer allocator.free(path_to_build_exe);
641		// codegen_set_cache_dir(g, full_cache_dir)
	186	// need a new scope for proper defer scope finalization on exit
	187	{
	188	const build_template_path = try os.path.join(allocator, special_dir, "build_file_template.zig");
	189	defer allocator.free(build_template_path);
642	190
643		args.items[0] = path_to_build_exe;
644		args.items[1] = zig_exe_path;
645		args.items[2] = build_file_dirname;
646		args.items[3] = full_cache_dir;
	191	try os.copyFile(allocator, build_template_path, build_file_abs);
	192	try stderr.print("wrote build.zig template\n");
	193	}
647	194
648		var build_file_exists: bool = undefined;
649		if (os.File.openRead(allocator, build_file_abs)) \|*file\| {
650		file.close();
651		build_file_exists = true;
652		} else \|_\| {
653		build_file_exists = false;
	195	os.exit(0);
654	196	}
655	197
656		if (!build_file_exists and asked_for_help) {
657		// TODO(bnoordhuis) Print help message from std/special/build_runner.zig
658		return;
	198	if (!build_file_exists) {
	199	try stderr.write(missing_build_file);
	200	os.exit(1);
659	201	}
660	202
661		if (!build_file_exists and asked_for_init) {
662		const build_template_path = try os.path.join(allocator, special_dir, "build_file_template.zig");
663		defer allocator.free(build_template_path);
664
665		var srcfile = try os.File.openRead(allocator, build_template_path);
666		defer srcfile.close();
	203	// TODO: Invoke build.zig entrypoint directly?
	204	var zig_exe_path = try os.selfExePath(allocator);
	205	defer allocator.free(zig_exe_path);
667	206
668		var dstfile = try os.File.openWrite(allocator, build_file_abs);
669		defer dstfile.close();
	207	var build_args = ArrayList([]const u8).init(allocator);
	208	defer build_args.deinit();
670	209
671		while (true) {
672		var buffer: [4096]u8 = undefined;
673		const n = try srcfile.read(buffer[0..]);
674		if (n == 0) break;
675		try dstfile.write(buffer[0..n]);
676		}
	210	const build_file_basename = os.path.basename(build_file_abs);
	211	const build_file_dirname = os.path.dirname(build_file_abs);
677	212
678		return;
	213	var full_cache_dir: []u8 = undefined;
	214	if (flags.single("cache-dir")) \|cache_dir\| {
	215	full_cache_dir = try os.path.resolve(allocator, ".", cache_dir, full_cache_dir);
	216	} else {
	217	full_cache_dir = try os.path.join(allocator, build_file_dirname, "zig-cache");
679	218	}
	219	defer allocator.free(full_cache_dir);
680	220
681		if (!build_file_exists) {
682		warn(
683		\\No 'build.zig' file found.
684		\\Initialize a 'build.zig' template file with `zig build --init`,
685		\\or build an executable directly with `zig build-exe $FILENAME.zig`.
686		\\See: `zig build --help` or `zig help` for more options.
687		\\
688		);
689		os.exit(1);
690		}
	221	const path_to_build_exe = try os.path.join(allocator, full_cache_dir, "build");
	222	defer allocator.free(path_to_build_exe);
691	223
692		// codegen_build(g)
693		// codegen_link(g, path_to_build_exe)
694		// codegen_destroy(g)
	224	try build_args.append(path_to_build_exe);
	225	try build_args.append(zig_exe_path);
	226	try build_args.append(build_file_dirname);
	227	try build_args.append(full_cache_dir);
695	228
696		var proc = try os.ChildProcess.init(args.toSliceConst(), allocator);
	229	var proc = try os.ChildProcess.init(build_args.toSliceConst(), allocator);
697	230	defer proc.deinit();
698	231
699	232	var term = try proc.spawnAndWait();
700	233	switch (term) {
701	234	os.ChildProcess.Term.Exited => \|status\| {
702	235	if (status != 0) {
703		warn("{} exited with status {}\n", args.at(0), status);
	236	try stderr.print("{} exited with status {}\n", build_args.at(0), status);
704	237	os.exit(1);
705	238	}
706	239	},
707	240	os.ChildProcess.Term.Signal => \|signal\| {
708		warn("{} killed by signal {}\n", args.at(0), signal);
	241	try stderr.print("{} killed by signal {}\n", build_args.at(0), signal);
709	242	os.exit(1);
710	243	},
711	244	os.ChildProcess.Term.Stopped => \|signal\| {
712		warn("{} stopped by signal {}\n", args.at(0), signal);
	245	try stderr.print("{} stopped by signal {}\n", build_args.at(0), signal);
713	246	os.exit(1);
714	247	},
715	248	os.ChildProcess.Term.Unknown => \|status\| {
716		warn("{} encountered unknown failure {}\n", args.at(0), status);
	249	try stderr.print("{} encountered unknown failure {}\n", build_args.at(0), status);
	250	os.exit(1);
	251	},
	252	}
	253	}
	254
	255	// cmd:build-exe ///////////////////////////////////////////////////////////////////////////////////
	256
	257	const usage_build_generic =
	258	\\usage: zig build-exe <options> [file]
	259	\\ zig build-lib <options> [file]
	260	\\ zig build-obj <options> [file]
	261	\\
	262	\\General Options:
	263	\\ --help Print this help and exit
	264	\\ --color [auto\|off\|on] Enable or disable colored error messages
	265	\\
	266	\\Compile Options:
	267	\\ --assembly [source] Add assembly file to build
	268	\\ --cache-dir [path] Override the cache directory
	269	\\ --emit [filetype] Emit a specific file format as compilation output
	270	\\ --enable-timing-info Print timing diagnostics
	271	\\ --libc-include-dir [path] Directory where libc stdlib.h resides
	272	\\ --name [name] Override output name
	273	\\ --output [file] Override destination path
	274	\\ --output-h [file] Override generated header file path
	275	\\ --pkg-begin [name] [path] Make package available to import and push current pkg
	276	\\ --pkg-end Pop current pkg
	277	\\ --release-fast Build with optimizations on and safety off
	278	\\ --release-safe Build with optimizations on and safety on
	279	\\ --static Output will be statically linked
	280	\\ --strip Exclude debug symbols
	281	\\ --target-arch [name] Specify target architecture
	282	\\ --target-environ [name] Specify target environment
	283	\\ --target-os [name] Specify target operating system
	284	\\ --verbose-tokenize Turn on compiler debug output for tokenization
	285	\\ --verbose-ast-tree Turn on compiler debug output for parsing into an AST (tree view)
	286	\\ --verbose-ast-fmt Turn on compiler debug output for parsing into an AST (render source)
	287	\\ --verbose-link Turn on compiler debug output for linking
	288	\\ --verbose-ir Turn on compiler debug output for Zig IR
	289	\\ --verbose-llvm-ir Turn on compiler debug output for LLVM IR
	290	\\ --verbose-cimport Turn on compiler debug output for C imports
	291	\\ -dirafter [dir] Same as -isystem but do it last
	292	\\ -isystem [dir] Add additional search path for other .h files
	293	\\ -mllvm [arg] Additional arguments to forward to LLVM's option processing
	294	\\
	295	\\Link Options:
	296	\\ --ar-path [path] Set the path to ar
	297	\\ --dynamic-linker [path] Set the path to ld.so
	298	\\ --each-lib-rpath Add rpath for each used dynamic library
	299	\\ --libc-lib-dir [path] Directory where libc crt1.o resides
	300	\\ --libc-static-lib-dir [path] Directory where libc crtbegin.o resides
	301	\\ --msvc-lib-dir [path] (windows) directory where vcruntime.lib resides
	302	\\ --kernel32-lib-dir [path] (windows) directory where kernel32.lib resides
	303	\\ --library [lib] Link against lib
	304	\\ --forbid-library [lib] Make it an error to link against lib
	305	\\ --library-path [dir] Add a directory to the library search path
	306	\\ --linker-script [path] Use a custom linker script
	307	\\ --object [obj] Add object file to build
	308	\\ -rdynamic Add all symbols to the dynamic symbol table
	309	\\ -rpath [path] Add directory to the runtime library search path
	310	\\ -mconsole (windows) --subsystem console to the linker
	311	\\ -mwindows (windows) --subsystem windows to the linker
	312	\\ -framework [name] (darwin) link against framework
	313	\\ -mios-version-min [ver] (darwin) set iOS deployment target
	314	\\ -mmacosx-version-min [ver] (darwin) set Mac OS X deployment target
	315	\\ --ver-major [ver] Dynamic library semver major version
	316	\\ --ver-minor [ver] Dynamic library semver minor version
	317	\\ --ver-patch [ver] Dynamic library semver patch version
	318	\\
	319	\\
	320	;
	321
	322	const args_build_generic = []Flag {
	323	Flag.Bool("--help"),
	324	Flag.Option("--color", []const []const u8 { "auto", "off", "on" }),
	325
	326	Flag.ArgMergeN("--assembly", 1),
	327	Flag.Arg1("--cache-dir"),
	328	Flag.Option("--emit", []const []const u8 { "asm", "bin", "llvm-ir" }),
	329	Flag.Bool("--enable-timing-info"),
	330	Flag.Arg1("--libc-include-dir"),
	331	Flag.Arg1("--name"),
	332	Flag.Arg1("--output"),
	333	Flag.Arg1("--output-h"),
	334	// NOTE: Parsed manually after initial check
	335	Flag.ArgN("--pkg-begin", 2),
	336	Flag.Bool("--pkg-end"),
	337	Flag.Bool("--release-fast"),
	338	Flag.Bool("--release-safe"),
	339	Flag.Bool("--static"),
	340	Flag.Bool("--strip"),
	341	Flag.Arg1("--target-arch"),
	342	Flag.Arg1("--target-environ"),
	343	Flag.Arg1("--target-os"),
	344	Flag.Bool("--verbose-tokenize"),
	345	Flag.Bool("--verbose-ast-tree"),
	346	Flag.Bool("--verbose-ast-fmt"),
	347	Flag.Bool("--verbose-link"),
	348	Flag.Bool("--verbose-ir"),
	349	Flag.Bool("--verbose-llvm-ir"),
	350	Flag.Bool("--verbose-cimport"),
	351	Flag.Arg1("-dirafter"),
	352	Flag.ArgMergeN("-isystem", 1),
	353	Flag.Arg1("-mllvm"),
	354
	355	Flag.Arg1("--ar-path"),
	356	Flag.Arg1("--dynamic-linker"),
	357	Flag.Bool("--each-lib-rpath"),
	358	Flag.Arg1("--libc-lib-dir"),
	359	Flag.Arg1("--libc-static-lib-dir"),
	360	Flag.Arg1("--msvc-lib-dir"),
	361	Flag.Arg1("--kernel32-lib-dir"),
	362	Flag.ArgMergeN("--library", 1),
	363	Flag.ArgMergeN("--forbid-library", 1),
	364	Flag.ArgMergeN("--library-path", 1),
	365	Flag.Arg1("--linker-script"),
	366	Flag.ArgMergeN("--object", 1),
	367	// NOTE: Removed -L since it would need to be special-cased and we have an alias in library-path
	368	Flag.Bool("-rdynamic"),
	369	Flag.Arg1("-rpath"),
	370	Flag.Bool("-mconsole"),
	371	Flag.Bool("-mwindows"),
	372	Flag.ArgMergeN("-framework", 1),
	373	Flag.Arg1("-mios-version-min"),
	374	Flag.Arg1("-mmacosx-version-min"),
	375	Flag.Arg1("--ver-major"),
	376	Flag.Arg1("--ver-minor"),
	377	Flag.Arg1("--ver-patch"),
	378	};
	379
	380	fn buildOutputType(allocator: &Allocator, args: []const []const u8, out_type: Module.Kind) !void {
	381	var flags = try Args.parse(allocator, args_build_generic, args);
	382	defer flags.deinit();
	383
	384	if (flags.present("help")) {
	385	try stderr.write(usage_build_generic);
	386	os.exit(0);
	387	}
	388
	389	var build_mode = builtin.Mode.Debug;
	390	if (flags.present("release-fast")) {
	391	build_mode = builtin.Mode.ReleaseFast;
	392	} else if (flags.present("release-safe")) {
	393	build_mode = builtin.Mode.ReleaseSafe;
	394	}
	395
	396	var color = Module.ErrColor.Auto;
	397	if (flags.single("color")) \|color_flag\| {
	398	if (mem.eql(u8, color_flag, "auto")) {
	399	color = Module.ErrColor.Auto;
	400	} else if (mem.eql(u8, color_flag, "on")) {
	401	color = Module.ErrColor.On;
	402	} else if (mem.eql(u8, color_flag, "off")) {
	403	color = Module.ErrColor.Off;
	404	} else {
	405	unreachable;
	406	}
	407	}
	408
	409	var emit_type = Module.Emit.Binary;
	410	if (flags.single("emit")) \|emit_flag\| {
	411	if (mem.eql(u8, emit_flag, "asm")) {
	412	emit_type = Module.Emit.Assembly;
	413	} else if (mem.eql(u8, emit_flag, "bin")) {
	414	emit_type = Module.Emit.Binary;
	415	} else if (mem.eql(u8, emit_flag, "llvm-ir")) {
	416	emit_type = Module.Emit.LlvmIr;
	417	} else {
	418	unreachable;
	419	}
	420	}
	421
	422	var cur_pkg = try Module.CliPkg.init(allocator, "", "", null); // TODO: Need a path, name?
	423	defer cur_pkg.deinit();
	424
	425	var i: usize = 0;
	426	while (i < args.len) : (i += 1) {
	427	const arg_name = args[i];
	428	if (mem.eql(u8, "--pkg-begin", arg_name)) {
	429	// following two arguments guaranteed to exist due to arg parsing
	430	i += 1;
	431	const new_pkg_name = args[i];
	432	i += 1;
	433	const new_pkg_path = args[i];
	434
	435	var new_cur_pkg = try Module.CliPkg.init(allocator, new_pkg_name, new_pkg_path, cur_pkg);
	436	try cur_pkg.children.append(new_cur_pkg);
	437	cur_pkg = new_cur_pkg;
	438	} else if (mem.eql(u8, "--pkg-end", arg_name)) {
	439	if (cur_pkg.parent == null) {
	440	try stderr.print("encountered --pkg-end with no matching --pkg-begin\n");
	441	os.exit(1);
	442	}
	443	cur_pkg = ??cur_pkg.parent;
	444	}
	445	}
	446
	447	if (cur_pkg.parent != null) {
	448	try stderr.print("unmatched --pkg-begin\n");
	449	os.exit(1);
	450	}
	451
	452	var in_file: ?[]const u8 = undefined;
	453	switch (flags.positionals.len) {
	454	0 => {
	455	try stderr.write("--name [name] not provided and unable to infer\n");
717	456	os.exit(1);
718	457	},
	458	1 => {
	459	in_file = flags.positionals.at(0);
	460	},
	461	else => {
	462	try stderr.write("only one zig input file is accepted during build\n");
	463	os.exit(1);
	464	},
	465	}
	466
	467	const basename = os.path.basename(??in_file);
	468	var it = mem.split(basename, ".");
	469	const root_name = it.next() ?? {
	470	try stderr.write("file name cannot be empty\n");
	471	os.exit(1);
	472	};
	473
	474	const asm_a= flags.many("assembly");
	475	const obj_a = flags.many("object");
	476	if (in_file == null and (obj_a == null or (??obj_a).len == 0) and (asm_a == null or (??asm_a).len == 0)) {
	477	try stderr.write("Expected source file argument or at least one --object or --assembly argument\n");
	478	os.exit(1);
	479	}
	480
	481	if (out_type == Module.Kind.Obj and (obj_a != null and (??obj_a).len != 0)) {
	482	try stderr.write("When building an object file, --object arguments are invalid\n");
	483	os.exit(1);
	484	}
	485
	486	const zig_root_source_file = in_file;
	487
	488	const full_cache_dir = os.path.resolve(allocator, ".", flags.single("cache-dir") ?? "zig-cache"[0..]) catch {
	489	os.exit(1);
	490	};
	491	defer allocator.free(full_cache_dir);
	492
	493	const zig_lib_dir = introspect.resolveZigLibDir(allocator) catch os.exit(1);
	494	defer allocator.free(zig_lib_dir);
	495
	496	var module =
	497	try Module.create(
	498	allocator,
	499	root_name,
	500	zig_root_source_file,
	501	Target.Native,
	502	out_type,
	503	build_mode,
	504	zig_lib_dir,
	505	full_cache_dir
	506	);
	507	defer module.destroy();
	508
	509	module.version_major = try std.fmt.parseUnsigned(u32, flags.single("ver-major") ?? "0", 10);
	510	module.version_minor = try std.fmt.parseUnsigned(u32, flags.single("ver-minor") ?? "0", 10);
	511	module.version_patch = try std.fmt.parseUnsigned(u32, flags.single("ver-patch") ?? "0", 10);
	512
	513	module.is_test = false;
	514
	515	if (flags.single("linker-script")) \|linker_script\| {
	516	module.linker_script = linker_script;
	517	}
	518
	519	module.each_lib_rpath = flags.present("each-lib-rpath");
	520
	521	var clang_argv_buf = ArrayList([]const u8).init(allocator);
	522	defer clang_argv_buf.deinit();
	523	if (flags.many("mllvm")) \|mllvm_flags\| {
	524	for (mllvm_flags) \|mllvm\| {
	525	try clang_argv_buf.append("-mllvm");
	526	try clang_argv_buf.append(mllvm);
	527	}
	528
	529	module.llvm_argv = mllvm_flags;
	530	module.clang_argv = clang_argv_buf.toSliceConst();
	531	}
	532
	533	module.strip = flags.present("strip");
	534	module.is_static = flags.present("static");
	535
	536	if (flags.single("libc-lib-dir")) \|libc_lib_dir\| {
	537	module.libc_lib_dir = libc_lib_dir;
	538	}
	539	if (flags.single("libc-static-lib-dir")) \|libc_static_lib_dir\| {
	540	module.libc_static_lib_dir = libc_static_lib_dir;
	541	}
	542	if (flags.single("libc-include-dir")) \|libc_include_dir\| {
	543	module.libc_include_dir = libc_include_dir;
719	544	}
	545	if (flags.single("msvc-lib-dir")) \|msvc_lib_dir\| {
	546	module.msvc_lib_dir = msvc_lib_dir;
	547	}
	548	if (flags.single("kernel32-lib-dir")) \|kernel32_lib_dir\| {
	549	module.kernel32_lib_dir = kernel32_lib_dir;
	550	}
	551	if (flags.single("dynamic-linker")) \|dynamic_linker\| {
	552	module.dynamic_linker = dynamic_linker;
	553	}
	554
	555	module.verbose_tokenize = flags.present("verbose-tokenize");
	556	module.verbose_ast_tree = flags.present("verbose-ast-tree");
	557	module.verbose_ast_fmt = flags.present("verbose-ast-fmt");
	558	module.verbose_link = flags.present("verbose-link");
	559	module.verbose_ir = flags.present("verbose-ir");
	560	module.verbose_llvm_ir = flags.present("verbose-llvm-ir");
	561	module.verbose_cimport = flags.present("verbose-cimport");
	562
	563	module.err_color = color;
	564
	565	if (flags.many("library-path")) \|lib_dirs\| {
	566	module.lib_dirs = lib_dirs;
	567	}
	568
	569	if (flags.many("framework")) \|frameworks\| {
	570	module.darwin_frameworks = frameworks;
	571	}
	572
	573	if (flags.many("rpath")) \|rpath_list\| {
	574	module.rpath_list = rpath_list;
	575	}
	576
	577	if (flags.single("output-h")) \|output_h\| {
	578	module.out_h_path = output_h;
	579	}
	580
	581	module.windows_subsystem_windows = flags.present("mwindows");
	582	module.windows_subsystem_console = flags.present("mconsole");
	583	module.linker_rdynamic = flags.present("rdynamic");
	584
	585	if (flags.single("mmacosx-version-min") != null and flags.single("mios-version-min") != null) {
	586	try stderr.write("-mmacosx-version-min and -mios-version-min options not allowed together\n");
	587	os.exit(1);
	588	}
	589
	590	if (flags.single("mmacosx-version-min")) \|ver\| {
	591	module.darwin_version_min = Module.DarwinVersionMin { .MacOS = ver };
	592	}
	593	if (flags.single("mios-version-min")) \|ver\| {
	594	module.darwin_version_min = Module.DarwinVersionMin { .Ios = ver };
	595	}
	596
	597	module.emit_file_type = emit_type;
	598	if (flags.many("object")) \|objects\| {
	599	module.link_objects = objects;
	600	}
	601	if (flags.many("assembly")) \|assembly_files\| {
	602	module.assembly_files = assembly_files;
	603	}
	604
	605	try module.build();
	606	try module.link(flags.single("out-file") ?? null);
	607
	608	if (flags.present("print-timing-info")) {
	609	// codegen_print_timing_info(g, stderr);
	610	}
	611
	612	try stderr.print("building {}: {}\n", @tagName(out_type), in_file);
720	613	}
721	614
722		fn fmtMain(allocator: &mem.Allocator, file_paths: []const []const u8) !void {
723		for (file_paths) \|file_path\| {
	615	fn cmdBuildExe(allocator: &Allocator, args: []const []const u8) !void {
	616	try buildOutputType(allocator, args, Module.Kind.Exe);
	617	}
	618
	619	// cmd:build-lib ///////////////////////////////////////////////////////////////////////////////////
	620
	621	fn cmdBuildLib(allocator: &Allocator, args: []const []const u8) !void {
	622	try buildOutputType(allocator, args, Module.Kind.Lib);
	623	}
	624
	625	// cmd:build-obj ///////////////////////////////////////////////////////////////////////////////////
	626
	627	fn cmdBuildObj(allocator: &Allocator, args: []const []const u8) !void {
	628	try buildOutputType(allocator, args, Module.Kind.Obj);
	629	}
	630
	631	// cmd:fmt /////////////////////////////////////////////////////////////////////////////////////////
	632
	633	const usage_fmt =
	634	\\usage: zig fmt [file]...
	635	\\
	636	\\ Formats the input files and modifies them in-place.
	637	\\
	638	\\Options:
	639	\\ --help Print this help and exit
	640	\\ --keep-backups Retain backup entries for every file
	641	\\
	642	\\
	643	;
	644
	645	const args_fmt_spec = []Flag {
	646	Flag.Bool("--help"),
	647	Flag.Bool("--keep-backups"),
	648	};
	649
	650	fn cmdFmt(allocator: &Allocator, args: []const []const u8) !void {
	651	var flags = try Args.parse(allocator, args_fmt_spec, args);
	652	defer flags.deinit();
	653
	654	if (flags.present("help")) {
	655	try stderr.write(usage_fmt);
	656	os.exit(0);
	657	}
	658
	659	if (flags.positionals.len == 0) {
	660	try stderr.write("expected at least one source file argument\n");
	661	os.exit(1);
	662	}
	663
	664	for (flags.positionals.toSliceConst()) \|file_path\| {
724	665	var file = try os.File.openRead(allocator, file_path);
725	666	defer file.close();
726	667
727	668	const source_code = io.readFileAlloc(allocator, file_path) catch \|err\| {
728		warn("unable to open '{}': {}", file_path, err);
	669	try stderr.print("unable to open '{}': {}", file_path, err);
729	670	continue;
730	671	};
731	672	defer allocator.free(source_code);
732	673
733		var tokenizer = std.zig.Tokenizer.init(source_code);
734		var parser = std.zig.Parser.init(&tokenizer, allocator, file_path);
735		defer parser.deinit();
736
737		var tree = try parser.parse();
	674	var tree = std.zig.parse(allocator, source_code) catch \|err\| {
	675	try stderr.print("error parsing file '{}': {}\n", file_path, err);
	676	continue;
	677	};
738	678	defer tree.deinit();
739	679
	680
	681	var error_it = tree.errors.iterator(0);
	682	while (error_it.next()) \|parse_error\| {
	683	const token = tree.tokens.at(parse_error.loc());
	684	const loc = tree.tokenLocation(0, parse_error.loc());
	685	try stderr.print("{}:{}:{}: error: ", file_path, loc.line + 1, loc.column + 1);
	686	try tree.renderError(parse_error, stderr);
	687	try stderr.print("\n{}\n", source_code[loc.line_start..loc.line_end]);
	688	{
	689	var i: usize = 0;
	690	while (i < loc.column) : (i += 1) {
	691	try stderr.write(" ");
	692	}
	693	}
	694	{
	695	const caret_count = token.end - token.start;
	696	var i: usize = 0;
	697	while (i < caret_count) : (i += 1) {
	698	try stderr.write("~");
	699	}
	700	}
	701	try stderr.write("\n");
	702	}
	703	if (tree.errors.len != 0) {
	704	continue;
	705	}
	706
	707	try stderr.print("{}\n", file_path);
	708
740	709	const baf = try io.BufferedAtomicFile.create(allocator, file_path);
741	710	defer baf.destroy();
742	711
743		try parser.renderSource(baf.stream(), tree.root_node);
	712	try std.zig.render(allocator, baf.stream(), &tree);
	713	try baf.finish();
744	714	}
745	715	}
746	716
747		/// Caller must free result
748		fn resolveZigLibDir(allocator: &mem.Allocator, zig_install_prefix_arg: ?[]const u8) ![]u8 {
749		if (zig_install_prefix_arg) \|zig_install_prefix\| {
750		return testZigInstallPrefix(allocator, zig_install_prefix) catch \|err\| {
751		warn("No Zig installation found at prefix {}: {}\n", zig_install_prefix_arg, @errorName(err));
752		return error.ZigInstallationNotFound;
753		};
754		} else {
755		return findZigLibDir(allocator) catch \|err\| {
756		warn("Unable to find zig lib directory: {}.\nReinstall Zig or use --zig-install-prefix.\n",
757		@errorName(err));
758		return error.ZigLibDirNotFound;
759		};
	717	// cmd:targets /////////////////////////////////////////////////////////////////////////////////////
	718
	719	fn cmdTargets(allocator: &Allocator, args: []const []const u8) !void {
	720	try stdout.write("Architectures:\n");
	721	{
	722	comptime var i: usize = 0;
	723	inline while (i < @memberCount(builtin.Arch)) : (i += 1) {
	724	comptime const arch_tag = @memberName(builtin.Arch, i);
	725	// NOTE: Cannot use empty string, see #918.
	726	comptime const native_str =
	727	if (comptime mem.eql(u8, arch_tag, @tagName(builtin.arch))) " (native)\n" else "\n";
	728
	729	try stdout.print(" {}{}", arch_tag, native_str);
	730	}
	731	}
	732	try stdout.write("\n");
	733
	734	try stdout.write("Operating Systems:\n");
	735	{
	736	comptime var i: usize = 0;
	737	inline while (i < @memberCount(builtin.Os)) : (i += 1) {
	738	comptime const os_tag = @memberName(builtin.Os, i);
	739	// NOTE: Cannot use empty string, see #918.
	740	comptime const native_str =
	741	if (comptime mem.eql(u8, os_tag, @tagName(builtin.os))) " (native)\n" else "\n";
	742
	743	try stdout.print(" {}{}", os_tag, native_str);
	744	}
	745	}
	746	try stdout.write("\n");
	747
	748	try stdout.write("Environments:\n");
	749	{
	750	comptime var i: usize = 0;
	751	inline while (i < @memberCount(builtin.Environ)) : (i += 1) {
	752	comptime const environ_tag = @memberName(builtin.Environ, i);
	753	// NOTE: Cannot use empty string, see #918.
	754	comptime const native_str =
	755	if (comptime mem.eql(u8, environ_tag, @tagName(builtin.environ))) " (native)\n" else "\n";
	756
	757	try stdout.print(" {}{}", environ_tag, native_str);
	758	}
760	759	}
761	760	}
762	761
763		/// Caller must free result
764		fn testZigInstallPrefix(allocator: &mem.Allocator, test_path: []const u8) ![]u8 {
765		const test_zig_dir = try os.path.join(allocator, test_path, "lib", "zig");
766		errdefer allocator.free(test_zig_dir);
	762	// cmd:version /////////////////////////////////////////////////////////////////////////////////////
	763
	764	fn cmdVersion(allocator: &Allocator, args: []const []const u8) !void {
	765	try stdout.print("{}\n", std.cstr.toSliceConst(c.ZIG_VERSION_STRING));
	766	}
	767
	768	// cmd:test ////////////////////////////////////////////////////////////////////////////////////////
	769
	770	const usage_test =
	771	\\usage: zig test [file]...
	772	\\
	773	\\Options:
	774	\\ --help Print this help and exit
	775	\\
	776	\\
	777	;
	778
	779	const args_test_spec = []Flag {
	780	Flag.Bool("--help"),
	781	};
	782
	783
	784	fn cmdTest(allocator: &Allocator, args: []const []const u8) !void {
	785	var flags = try Args.parse(allocator, args_build_spec, args);
	786	defer flags.deinit();
767	787
768		const test_index_file = try os.path.join(allocator, test_zig_dir, "std", "index.zig");
769		defer allocator.free(test_index_file);
	788	if (flags.present("help")) {
	789	try stderr.write(usage_test);
	790	os.exit(0);
	791	}
770	792
771		var file = try os.File.openRead(allocator, test_index_file);
772		file.close();
	793	if (flags.positionals.len != 1) {
	794	try stderr.write("expected exactly one zig source file\n");
	795	os.exit(1);
	796	}
773	797
774		return test_zig_dir;
	798	// compile the test program into the cache and run
	799
	800	// NOTE: May be overlap with buildOutput, take the shared part out.
	801	try stderr.print("testing file {}\n", flags.positionals.at(0));
775	802	}
776	803
777		/// Caller must free result
778		fn findZigLibDir(allocator: &mem.Allocator) ![]u8 {
779		const self_exe_path = try os.selfExeDirPath(allocator);
780		defer allocator.free(self_exe_path);
	804	// cmd:run /////////////////////////////////////////////////////////////////////////////////////////
	805
	806	// Run should be simple and not expose the full set of arguments provided by build-exe. If specific
	807	// build requirements are need, the user should `build-exe` then `run` manually.
	808	const usage_run =
	809	\\usage: zig run [file] -- <runtime args>
	810	\\
	811	\\Options:
	812	\\ --help Print this help and exit
	813	\\
	814	\\
	815	;
	816
	817	const args_run_spec = []Flag {
	818	Flag.Bool("--help"),
	819	};
	820
781	821
782		var cur_path: []const u8 = self_exe_path;
783		while (true) {
784		const test_dir = os.path.dirname(cur_path);
	822	fn cmdRun(allocator: &Allocator, args: []const []const u8) !void {
	823	var compile_args = args;
	824	var runtime_args: []const []const u8 = []const []const u8 {};
785	825
786		if (mem.eql(u8, test_dir, cur_path)) {
	826	for (args) \|argv, i\| {
	827	if (mem.eql(u8, argv, "--")) {
	828	compile_args = args[0..i];
	829	runtime_args = args[i+1..];
787	830	break;
788	831	}
	832	}
	833	var flags = try Args.parse(allocator, args_run_spec, compile_args);
	834	defer flags.deinit();
789	835
790		return testZigInstallPrefix(allocator, test_dir) catch \|err\| {
791		cur_path = test_dir;
792		continue;
793		};
	836	if (flags.present("help")) {
	837	try stderr.write(usage_run);
	838	os.exit(0);
	839	}
	840
	841	if (flags.positionals.len != 1) {
	842	try stderr.write("expected exactly one zig source file\n");
	843	os.exit(1);
	844	}
	845
	846	try stderr.print("runtime args:\n");
	847	for (runtime_args) \|cargs\| {
	848	try stderr.print("{}\n", cargs);
	849	}
	850	}
	851
	852	// cmd:translate-c /////////////////////////////////////////////////////////////////////////////////
	853
	854	const usage_translate_c =
	855	\\usage: zig translate-c [file]
	856	\\
	857	\\Options:
	858	\\ --help Print this help and exit
	859	\\ --enable-timing-info Print timing diagnostics
	860	\\ --output [path] Output file to write generated zig file (default: stdout)
	861	\\
	862	\\
	863	;
	864
	865	const args_translate_c_spec = []Flag {
	866	Flag.Bool("--help"),
	867	Flag.Bool("--enable-timing-info"),
	868	Flag.Arg1("--libc-include-dir"),
	869	Flag.Arg1("--output"),
	870	};
	871
	872	fn cmdTranslateC(allocator: &Allocator, args: []const []const u8) !void {
	873	var flags = try Args.parse(allocator, args_translate_c_spec, args);
	874	defer flags.deinit();
	875
	876	if (flags.present("help")) {
	877	try stderr.write(usage_translate_c);
	878	os.exit(0);
	879	}
	880
	881	if (flags.positionals.len != 1) {
	882	try stderr.write("expected exactly one c source file\n");
	883	os.exit(1);
	884	}
	885
	886	// set up codegen
	887
	888	const zig_root_source_file = null;
	889
	890	// NOTE: translate-c shouldn't require setting up the full codegen instance as it does in
	891	// the C++ compiler.
	892
	893	// codegen_create(g);
	894	// codegen_set_out_name(g, null);
	895	// codegen_translate_c(g, flags.positional.at(0))
	896
	897	var output_stream = stdout;
	898	if (flags.single("output")) \|output_file\| {
	899	var file = try os.File.openWrite(allocator, output_file);
	900	defer file.close();
	901
	902	var file_stream = io.FileOutStream.init(&file);
	903	// TODO: Not being set correctly, still stdout
	904	output_stream = &file_stream.stream;
	905	}
	906
	907	// ast_render(g, output_stream, g->root_import->root, 4);
	908	try output_stream.write("pub const example = 10;\n");
	909
	910	if (flags.present("enable-timing-info")) {
	911	// codegen_print_timing_info(g, stdout);
	912	try stderr.write("printing timing info for translate-c\n");
794	913	}
	914	}
	915
	916	// cmd:help ////////////////////////////////////////////////////////////////////////////////////////
	917
	918	fn cmdHelp(allocator: &Allocator, args: []const []const u8) !void {
	919	try stderr.write(usage);
	920	}
	921
	922	// cmd:zen /////////////////////////////////////////////////////////////////////////////////////////
	923
	924	const info_zen =
	925	\\
	926	\\ * Communicate intent precisely.
	927	\\ * Edge cases matter.
	928	\\ * Favor reading code over writing code.
	929	\\ * Only one obvious way to do things.
	930	\\ * Runtime crashes are better than bugs.
	931	\\ * Compile errors are better than runtime crashes.
	932	\\ * Incremental improvements.
	933	\\ * Avoid local maximums.
	934	\\ * Reduce the amount one must remember.
	935	\\ * Minimize energy spent on coding style.
	936	\\ * Together we serve end users.
	937	\\
	938	\\
	939	;
	940
	941	fn cmdZen(allocator: &Allocator, args: []const []const u8) !void {
	942	try stdout.write(info_zen);
	943	}
	944
	945	// cmd:internal ////////////////////////////////////////////////////////////////////////////////////
	946
	947	const usage_internal =
	948	\\usage: zig internal [subcommand]
	949	\\
	950	\\Sub-Commands:
	951	\\ build-info Print static compiler build-info
	952	\\
	953	\\
	954	;
	955
	956	fn cmdInternal(allocator: &Allocator, args: []const []const u8) !void {
	957	if (args.len == 0) {
	958	try stderr.write(usage_internal);
	959	os.exit(1);
	960	}
	961
	962	const sub_commands = []Command {
	963	Command { .name = "build-info", .exec = cmdInternalBuildInfo },
	964	};
795	965
796		// TODO look in hard coded installation path from configuration
797		//if (ZIG_INSTALL_PREFIX != nullptr) {
798		// if (test_zig_install_prefix(buf_create_from_str(ZIG_INSTALL_PREFIX), out_path)) {
799		// return 0;
800		// }
801		//}
	966	for (sub_commands) \|sub_command\| {
	967	if (mem.eql(u8, sub_command.name, args[0])) {
	968	try sub_command.exec(allocator, args[1..]);
	969	return;
	970	}
	971	}
802	972
803		return error.FileNotFound;
	973	try stderr.print("unknown sub command: {}\n\n", args[0]);
	974	try stderr.write(usage_internal);
	975	}
	976
	977	fn cmdInternalBuildInfo(allocator: &Allocator, args: []const []const u8) !void {
	978	try stdout.print(
	979	\\ZIG_CMAKE_BINARY_DIR {}
	980	\\ZIG_CXX_COMPILER {}
	981	\\ZIG_LLVM_CONFIG_EXE {}
	982	\\ZIG_LLD_INCLUDE_PATH {}
	983	\\ZIG_LLD_LIBRARIES {}
	984	\\ZIG_STD_FILES {}
	985	\\ZIG_C_HEADER_FILES {}
	986	\\ZIG_DIA_GUIDS_LIB {}
	987	\\
	988	,
	989	std.cstr.toSliceConst(c.ZIG_CMAKE_BINARY_DIR),
	990	std.cstr.toSliceConst(c.ZIG_CXX_COMPILER),
	991	std.cstr.toSliceConst(c.ZIG_LLVM_CONFIG_EXE),
	992	std.cstr.toSliceConst(c.ZIG_LLD_INCLUDE_PATH),
	993	std.cstr.toSliceConst(c.ZIG_LLD_LIBRARIES),
	994	std.cstr.toSliceConst(c.ZIG_STD_FILES),
	995	std.cstr.toSliceConst(c.ZIG_C_HEADER_FILES),
	996	std.cstr.toSliceConst(c.ZIG_DIA_GUIDS_LIB),
	997	);
804	998	}

src-self-hosted/module.zig+25-21

...	...	@@ -8,9 +8,7 @@ const c = @import("c.zig");
8	8	const builtin = @import("builtin");
9	9	const Target = @import("target.zig").Target;
10	10	const warn = std.debug.warn;
11		const Tokenizer = std.zig.Tokenizer;
12	11	const Token = std.zig.Token;
13		const Parser = std.zig.Parser;
14	12	const ArrayList = std.ArrayList;
15	13
16	14	pub const Module = struct {
...	...	@@ -109,6 +107,29 @@ pub const Module = struct {
109	107	LlvmIr,
110	108	};
111	109
	110	pub const CliPkg = struct {
	111	name: []const u8,
	112	path: []const u8,
	113	children: ArrayList(&CliPkg),
	114	parent: ?&CliPkg,
	115
	116	pub fn init(allocator: &mem.Allocator, name: []const u8, path: []const u8, parent: ?&CliPkg) !&CliPkg {
	117	var pkg = try allocator.create(CliPkg);
	118	pkg.name = name;
	119	pkg.path = path;
	120	pkg.children = ArrayList(&CliPkg).init(allocator);
	121	pkg.parent = parent;
	122	return pkg;
	123	}
	124
	125	pub fn deinit(self: &CliPkg) void {
	126	for (self.children.toSliceConst()) \|child\| {
	127	child.deinit();
	128	}
	129	self.children.deinit();
	130	}
	131	};
	132
112	133	pub fn create(allocator: &mem.Allocator, name: []const u8, root_src_path: ?[]const u8, target: &const Target,
113	134	kind: Kind, build_mode: builtin.Mode, zig_lib_dir: []const u8, cache_dir: []const u8) !&Module
114	135	{
...	...	@@ -223,34 +244,17 @@ pub const Module = struct {
223	244
224	245	warn("{}", source_code);
225	246
226		warn("====tokenization:====\n");
227		{
228		var tokenizer = Tokenizer.init(source_code);
229		while (true) {
230		const token = tokenizer.next();
231		tokenizer.dump(token);
232		if (token.id == Token.Id.Eof) {
233		break;
234		}
235		}
236		}
237
238	247	warn("====parse:====\n");
239	248
240		var tokenizer = Tokenizer.init(source_code);
241		var parser = Parser.init(&tokenizer, self.allocator, root_src_real_path);
242		defer parser.deinit();
243
244		var tree = try parser.parse();
	249	var tree = try std.zig.parse(self.allocator, source_code);
245	250	defer tree.deinit();
246	251
247	252	var stderr_file = try std.io.getStdErr();
248	253	var stderr_file_out_stream = std.io.FileOutStream.init(&stderr_file);
249	254	const out_stream = &stderr_file_out_stream.stream;
250		try parser.renderAst(out_stream, tree.root_node);
251	255
252	256	warn("====fmt:====\n");
253		try parser.renderSource(out_stream, tree.root_node);
	257	try std.zig.render(self.allocator, out_stream, &tree);
254	258
255	259	warn("====ir:====\n");
256	260	warn("TODO\n\n");

src/all_types.hpp+90-15

...	...	@@ -359,7 +359,6 @@ enum NodeType {
359	359	NodeTypeRoot,
360	360	NodeTypeFnProto,
361	361	NodeTypeFnDef,
362		NodeTypeFnDecl,
363	362	NodeTypeParamDecl,
364	363	NodeTypeBlock,
365	364	NodeTypeGroupedExpr,
...	...	@@ -453,10 +452,6 @@ struct AstNodeFnDef {
453	452	AstNode *body;
454	453	};
455	454
456		struct AstNodeFnDecl {
457		AstNode *fn_proto;
458		};
459
460	455	struct AstNodeParamDecl {
461	456	Buf *name;
462	457	AstNode *type;
...	...	@@ -713,10 +708,6 @@ struct AstNodeSwitchRange {
713	708	AstNode *end;
714	709	};
715	710
716		struct AstNodeLabel {
717		Buf *name;
718		};
719
720	711	struct AstNodeCompTime {
721	712	AstNode *expr;
722	713	};
...	...	@@ -876,6 +867,7 @@ struct AstNodeAwaitExpr {
876	867	};
877	868
878	869	struct AstNodeSuspend {
	870	Buf *name;
879	871	AstNode *block;
880	872	AstNode *promise_symbol;
881	873	};
...	...	@@ -892,7 +884,6 @@ struct AstNode {
892	884	union {
893	885	AstNodeRoot root;
894	886	AstNodeFnDef fn_def;
895		AstNodeFnDecl fn_decl;
896	887	AstNodeFnProto fn_proto;
897	888	AstNodeParamDecl param_decl;
898	889	AstNodeBlock block;
...	...	@@ -917,7 +908,6 @@ struct AstNode {
917	908	AstNodeSwitchExpr switch_expr;
918	909	AstNodeSwitchProng switch_prong;
919	910	AstNodeSwitchRange switch_range;
920		AstNodeLabel label;
921	911	AstNodeCompTime comptime_expr;
922	912	AstNodeAsmExpr asm_expr;
923	913	AstNodeFieldAccessExpr field_access_expr;
...	...	@@ -1302,6 +1292,8 @@ enum BuiltinFnId {
1302	1292	BuiltinFnIdMemberCount,
1303	1293	BuiltinFnIdMemberType,
1304	1294	BuiltinFnIdMemberName,
	1295	BuiltinFnIdField,
	1296	BuiltinFnIdTypeInfo,
1305	1297	BuiltinFnIdTypeof,
1306	1298	BuiltinFnIdAddWithOverflow,
1307	1299	BuiltinFnIdSubWithOverflow,
...	...	@@ -1321,13 +1313,15 @@ enum BuiltinFnId {
1321	1313	BuiltinFnIdReturnAddress,
1322	1314	BuiltinFnIdFrameAddress,
1323	1315	BuiltinFnIdEmbedFile,
1324		BuiltinFnIdCmpExchange,
	1316	BuiltinFnIdCmpxchgWeak,
	1317	BuiltinFnIdCmpxchgStrong,
1325	1318	BuiltinFnIdFence,
1326	1319	BuiltinFnIdDivExact,
1327	1320	BuiltinFnIdDivTrunc,
1328	1321	BuiltinFnIdDivFloor,
1329	1322	BuiltinFnIdRem,
1330	1323	BuiltinFnIdMod,
	1324	BuiltinFnIdSqrt,
1331	1325	BuiltinFnIdTruncate,
1332	1326	BuiltinFnIdIntType,
1333	1327	BuiltinFnIdSetCold,
...	...	@@ -1357,6 +1351,7 @@ enum BuiltinFnId {
1357	1351	BuiltinFnIdExport,
1358	1352	BuiltinFnIdErrorReturnTrace,
1359	1353	BuiltinFnIdAtomicRmw,
	1354	BuiltinFnIdAtomicLoad,
1360	1355	};
1361	1356
1362	1357	struct BuiltinFnEntry {
...	...	@@ -1424,6 +1419,7 @@ enum ZigLLVMFnId {
1424	1419	ZigLLVMFnIdOverflowArithmetic,
1425	1420	ZigLLVMFnIdFloor,
1426	1421	ZigLLVMFnIdCeil,
	1422	ZigLLVMFnIdSqrt,
1427	1423	};
1428	1424
1429	1425	enum AddSubMul {
...	...	@@ -1444,7 +1440,7 @@ struct ZigLLVMFnKey {
1444	1440	} clz;
1445	1441	struct {
1446	1442	uint32_t bit_count;
1447		} floor_ceil;
	1443	} floating;
1448	1444	struct {
1449	1445	AddSubMul add_sub_mul;
1450	1446	uint32_t bit_count;
...	...	@@ -1465,6 +1461,7 @@ enum BuildMode {
1465	1461	BuildModeDebug,
1466	1462	BuildModeFastRelease,
1467	1463	BuildModeSafeRelease,
	1464	BuildModeSmallRelease,
1468	1465	};
1469	1466
1470	1467	enum EmitFileType {
...	...	@@ -1510,6 +1507,7 @@ struct CodeGen {
1510	1507	HashMap<Buf , AstNode , buf_hash, buf_eql_buf> exported_symbol_names;
1511	1508	HashMap<Buf , Tld , buf_hash, buf_eql_buf> external_prototypes;
1512	1509	HashMap<Buf , ConstExprValue , buf_hash, buf_eql_buf> string_literals_table;
	1510	HashMap<const TypeTableEntry , ConstExprValue , type_ptr_hash, type_ptr_eql> type_info_cache;
1513	1511
1514	1512
1515	1513	ZigList<ImportTableEntry *> import_queue;
...	...	@@ -1656,6 +1654,8 @@ struct CodeGen {
1656	1654	LLVMValueRef coro_save_fn_val;
1657	1655	LLVMValueRef coro_promise_fn_val;
1658	1656	LLVMValueRef coro_alloc_helper_fn_val;
	1657	LLVMValueRef merge_err_ret_traces_fn_val;
	1658	LLVMValueRef add_error_return_trace_addr_fn_val;
1659	1659	bool error_during_imports;
1660	1660
1661	1661	const char **clang_argv;
...	...	@@ -1709,6 +1709,8 @@ struct CodeGen {
1709	1709	ZigList<ZigLLVMDIType **> error_di_types;
1710	1710
1711	1711	ZigList<Buf *> forbidden_libs;
	1712
	1713	bool no_rosegment_workaround;
1712	1714	};
1713	1715
1714	1716	enum VarLinkage {
...	...	@@ -1759,6 +1761,7 @@ enum ScopeId {
1759	1761	ScopeIdVarDecl,
1760	1762	ScopeIdCImport,
1761	1763	ScopeIdLoop,
	1764	ScopeIdSuspend,
1762	1765	ScopeIdFnDef,
1763	1766	ScopeIdCompTime,
1764	1767	ScopeIdCoroPrelude,
...	...	@@ -1854,6 +1857,17 @@ struct ScopeLoop {
1854	1857	ZigList<IrBasicBlock > incoming_blocks;
1855	1858	};
1856	1859
	1860	// This scope is created for a suspend block in order to have labeled
	1861	// suspend for breaking out of a suspend and for detecting if a suspend
	1862	// block is inside a suspend block.
	1863	struct ScopeSuspend {
	1864	Scope base;
	1865
	1866	Buf *name;
	1867	IrBasicBlock *resume_block;
	1868	bool reported_err;
	1869	};
	1870
1857	1871	// This scope is created for a comptime expression.
1858	1872	// NodeTypeCompTime, NodeTypeSwitchExpr
1859	1873	struct ScopeCompTime {
...	...	@@ -2025,6 +2039,7 @@ enum IrInstructionId {
2025	2039	IrInstructionIdTagType,
2026	2040	IrInstructionIdFieldParentPtr,
2027	2041	IrInstructionIdOffsetOf,
	2042	IrInstructionIdTypeInfo,
2028	2043	IrInstructionIdTypeId,
2029	2044	IrInstructionIdSetEvalBranchQuota,
2030	2045	IrInstructionIdPtrTypeOf,
...	...	@@ -2050,10 +2065,14 @@ enum IrInstructionId {
2050	2065	IrInstructionIdCoroPromise,
2051	2066	IrInstructionIdCoroAllocHelper,
2052	2067	IrInstructionIdAtomicRmw,
	2068	IrInstructionIdAtomicLoad,
2053	2069	IrInstructionIdPromiseResultType,
2054	2070	IrInstructionIdAwaitBookkeeping,
2055	2071	IrInstructionIdSaveErrRetAddr,
2056	2072	IrInstructionIdAddImplicitReturnType,
	2073	IrInstructionIdMergeErrRetTraces,
	2074	IrInstructionIdMarkErrRetTracePtr,
	2075	IrInstructionIdSqrt,
2057	2076	};
2058	2077
2059	2078	struct IrInstruction {
...	...	@@ -2210,7 +2229,8 @@ struct IrInstructionFieldPtr {
2210	2229	IrInstruction base;
2211	2230
2212	2231	IrInstruction *container_ptr;
2213		Buf *field_name;
	2232	Buf *field_name_buffer;
	2233	IrInstruction *field_name_expr;
2214	2234	bool is_const;
2215	2235	};
2216	2236
...	...	@@ -2529,6 +2549,7 @@ struct IrInstructionEmbedFile {
2529	2549	struct IrInstructionCmpxchg {
2530	2550	IrInstruction base;
2531	2551
	2552	IrInstruction *type_value;
2532	2553	IrInstruction *ptr;
2533	2554	IrInstruction *cmp_value;
2534	2555	IrInstruction *new_value;
...	...	@@ -2536,8 +2557,13 @@ struct IrInstructionCmpxchg {
2536	2557	IrInstruction *failure_order_value;
2537	2558
2538	2559	// if this instruction gets to runtime then we know these values:
	2560	TypeTableEntry *type;
2539	2561	AtomicOrder success_order;
2540	2562	AtomicOrder failure_order;
	2563
	2564	bool is_weak;
	2565
	2566	LLVMValueRef tmp_ptr;
2541	2567	};
2542	2568
2543	2569	struct IrInstructionFence {
...	...	@@ -2835,6 +2861,12 @@ struct IrInstructionOffsetOf {
2835	2861	IrInstruction *field_name;
2836	2862	};
2837	2863
	2864	struct IrInstructionTypeInfo {
	2865	IrInstruction base;
	2866
	2867	IrInstruction *type_value;
	2868	};
	2869
2838	2870	struct IrInstructionTypeId {
2839	2871	IrInstruction base;
2840	2872
...	...	@@ -2892,6 +2924,11 @@ struct IrInstructionExport {
2892	2924
2893	2925	struct IrInstructionErrorReturnTrace {
2894	2926	IrInstruction base;
	2927
	2928	enum Nullable {
	2929	Null,
	2930	NonNull,
	2931	} nullable;
2895	2932	};
2896	2933
2897	2934	struct IrInstructionErrorUnion {
...	...	@@ -3002,6 +3039,15 @@ struct IrInstructionAtomicRmw {
3002	3039	AtomicOrder resolved_ordering;
3003	3040	};
3004	3041
	3042	struct IrInstructionAtomicLoad {
	3043	IrInstruction base;
	3044
	3045	IrInstruction *operand_type;
	3046	IrInstruction *ptr;
	3047	IrInstruction *ordering;
	3048	AtomicOrder resolved_ordering;
	3049	};
	3050
3005	3051	struct IrInstructionPromiseResultType {
3006	3052	IrInstruction base;
3007	3053
...	...	@@ -3024,6 +3070,27 @@ struct IrInstructionAddImplicitReturnType {
3024	3070	IrInstruction *value;
3025	3071	};
3026	3072
	3073	struct IrInstructionMergeErrRetTraces {
	3074	IrInstruction base;
	3075
	3076	IrInstruction *coro_promise_ptr;
	3077	IrInstruction *src_err_ret_trace_ptr;
	3078	IrInstruction *dest_err_ret_trace_ptr;
	3079	};
	3080
	3081	struct IrInstructionMarkErrRetTracePtr {
	3082	IrInstruction base;
	3083
	3084	IrInstruction *err_ret_trace_ptr;
	3085	};
	3086
	3087	struct IrInstructionSqrt {
	3088	IrInstruction base;
	3089
	3090	IrInstruction *type;
	3091	IrInstruction *op;
	3092	};
	3093
3027	3094	static const size_t slice_ptr_index = 0;
3028	3095	static const size_t slice_len_index = 1;
3029	3096
...	...	@@ -3033,10 +3100,18 @@ static const size_t maybe_null_index = 1;
3033	3100	static const size_t err_union_err_index = 0;
3034	3101	static const size_t err_union_payload_index = 1;
3035	3102
	3103	// TODO call graph analysis to find out what this number needs to be for every function
	3104	static const size_t stack_trace_ptr_count = 30;
	3105
	3106	// these belong to the async function
	3107	#define RETURN_ADDRESSES_FIELD_NAME "return_addresses"
	3108	#define ERR_RET_TRACE_FIELD_NAME "err_ret_trace"
	3109	#define RESULT_FIELD_NAME "result"
3036	3110	#define ASYNC_ALLOC_FIELD_NAME "allocFn"
3037	3111	#define ASYNC_FREE_FIELD_NAME "freeFn"
3038	3112	#define AWAITER_HANDLE_FIELD_NAME "awaiter_handle"
3039		#define RESULT_FIELD_NAME "result"
	3113	// these point to data belonging to the awaiter
	3114	#define ERR_RET_TRACE_PTR_FIELD_NAME "err_ret_trace_ptr"
3040	3115	#define RESULT_PTR_FIELD_NAME "result_ptr"
3041	3116
3042	3117

src/analyze.cpp+75-26

...	...	@@ -156,6 +156,14 @@ ScopeLoop create_loop_scope(AstNode node, Scope *parent) {
156	156	return scope;
157	157	}
158	158
	159	ScopeSuspend create_suspend_scope(AstNode node, Scope *parent) {
	160	assert(node->type == NodeTypeSuspend);
	161	ScopeSuspend *scope = allocate<ScopeSuspend>(1);
	162	init_scope(&scope->base, ScopeIdSuspend, node, parent);
	163	scope->name = node->data.suspend.name;
	164	return scope;
	165	}
	166
159	167	ScopeFnDef create_fndef_scope(AstNode node, Scope parent, FnTableEntry fn_entry) {
160	168	ScopeFnDef *scope = allocate<ScopeFnDef>(1);
161	169	init_scope(&scope->base, ScopeIdFnDef, node, parent);
...	...	@@ -468,10 +476,30 @@ TypeTableEntry get_promise_frame_type(CodeGen g, TypeTableEntry *return_type)
468	476
469	477	TypeTableEntry *awaiter_handle_type = get_maybe_type(g, g->builtin_types.entry_promise);
470	478	TypeTableEntry *result_ptr_type = get_pointer_to_type(g, return_type, false);
471		const char *field_names[] = {AWAITER_HANDLE_FIELD_NAME, RESULT_FIELD_NAME, RESULT_PTR_FIELD_NAME};
472		TypeTableEntry *field_types[] = {awaiter_handle_type, return_type, result_ptr_type};
	479
	480	ZigList<const char *> field_names = {};
	481	field_names.append(AWAITER_HANDLE_FIELD_NAME);
	482	field_names.append(RESULT_FIELD_NAME);
	483	field_names.append(RESULT_PTR_FIELD_NAME);
	484	if (g->have_err_ret_tracing) {
	485	field_names.append(ERR_RET_TRACE_PTR_FIELD_NAME);
	486	field_names.append(ERR_RET_TRACE_FIELD_NAME);
	487	field_names.append(RETURN_ADDRESSES_FIELD_NAME);
	488	}
	489
	490	ZigList<TypeTableEntry *> field_types = {};
	491	field_types.append(awaiter_handle_type);
	492	field_types.append(return_type);
	493	field_types.append(result_ptr_type);
	494	if (g->have_err_ret_tracing) {
	495	field_types.append(get_ptr_to_stack_trace_type(g));
	496	field_types.append(g->stack_trace_type);
	497	field_types.append(get_array_type(g, g->builtin_types.entry_usize, stack_trace_ptr_count));
	498	}
	499
	500	assert(field_names.length == field_types.length);
473	501	Buf *name = buf_sprintf("AsyncFramePromise(%s)", buf_ptr(&return_type->name));
474		TypeTableEntry *entry = get_struct_type(g, buf_ptr(name), field_names, field_types, 3);
	502	TypeTableEntry *entry = get_struct_type(g, buf_ptr(name), field_names.items, field_types.items, field_names.length);
475	503
476	504	return_type->promise_frame_parent = entry;
477	505	return entry;
...	...	@@ -1230,7 +1258,7 @@ void init_fn_type_id(FnTypeId fn_type_id, AstNode proto_node, size_t param_cou
1230	1258	}
1231	1259
1232	1260	fn_type_id->param_count = fn_proto->params.length;
1233		fn_type_id->param_info = allocate_nonzero<FnTypeParamInfo>(param_count_alloc);
	1261	fn_type_id->param_info = allocate<FnTypeParamInfo>(param_count_alloc);
1234	1262	fn_type_id->next_param_index = 0;
1235	1263	fn_type_id->is_var_args = fn_proto->is_var_args;
1236	1264	}
...	...	@@ -2297,8 +2325,14 @@ static void resolve_enum_zero_bits(CodeGen g, TypeTableEntry enum_type) {
2297	2325	HashMap<BigInt, AstNode *, bigint_hash, bigint_eql> occupied_tag_values = {};
2298	2326	occupied_tag_values.init(field_count);
2299	2327
2300		TypeTableEntry *tag_int_type = get_smallest_unsigned_int_type(g, field_count - 1);
	2328	TypeTableEntry *tag_int_type;
	2329	if (enum_type->data.enumeration.layout == ContainerLayoutExtern) {
	2330	tag_int_type = get_c_int_type(g, CIntTypeInt);
	2331	} else {
	2332	tag_int_type = get_smallest_unsigned_int_type(g, field_count - 1);
	2333	}
2301	2334
	2335	// TODO: Are extern enums allowed to have an init_arg_expr?
2302	2336	if (decl_node->data.container_decl.init_arg_expr != nullptr) {
2303	2337	TypeTableEntry *wanted_tag_int_type = analyze_type_expr(g, scope, decl_node->data.container_decl.init_arg_expr);
2304	2338	if (type_is_invalid(wanted_tag_int_type)) {
...	...	@@ -3216,7 +3250,6 @@ void scan_decls(CodeGen g, ScopeDecls decls_scope, AstNode *node) {
3216	3250	break;
3217	3251	case NodeTypeContainerDecl:
3218	3252	case NodeTypeParamDecl:
3219		case NodeTypeFnDecl:
3220	3253	case NodeTypeReturnExpr:
3221	3254	case NodeTypeDefer:
3222	3255	case NodeTypeBlock:
...	...	@@ -3597,6 +3630,7 @@ FnTableEntry scope_get_fn_if_root(Scope scope) {
3597	3630	case ScopeIdVarDecl:
3598	3631	case ScopeIdCImport:
3599	3632	case ScopeIdLoop:
	3633	case ScopeIdSuspend:
3600	3634	case ScopeIdCompTime:
3601	3635	case ScopeIdCoroPrelude:
3602	3636	scope = scope->parent;
...	...	@@ -4278,7 +4312,8 @@ bool handle_is_ptr(TypeTableEntry *type_entry) {
4278	4312	static ZigWindowsSDK get_windows_sdk(CodeGen g) {
4279	4313	if (g->win_sdk == nullptr) {
4280	4314	if (os_find_windows_sdk(&g->win_sdk)) {
4281		zig_panic("Unable to determine Windows SDK path.");
	4315	fprintf(stderr, "unable to determine windows sdk path\n");
	4316	exit(1);
4282	4317	}
4283	4318	}
4284	4319	assert(g->win_sdk != nullptr);
...	...	@@ -4380,7 +4415,8 @@ void find_libc_include_path(CodeGen *g) {
4380	4415	ZigWindowsSDK *sdk = get_windows_sdk(g);
4381	4416	g->libc_include_dir = buf_alloc();
4382	4417	if (os_get_win32_ucrt_include_path(sdk, g->libc_include_dir)) {
4383		zig_panic("Unable to determine libc include path.");
	4418	fprintf(stderr, "Unable to determine libc include path. --libc-include-dir");
	4419	exit(1);
4384	4420	}
4385	4421	} else if (g->zig_target.os == OsLinux) {
4386	4422	g->libc_include_dir = get_linux_libc_include_path();
...	...	@@ -4402,24 +4438,33 @@ void find_libc_lib_path(CodeGen *g) {
4402	4438	if (g->zig_target.os == OsWindows) {
4403	4439	ZigWindowsSDK *sdk = get_windows_sdk(g);
4404	4440
4405		Buf* vc_lib_dir = buf_alloc();
4406		if (os_get_win32_vcruntime_path(vc_lib_dir, g->zig_target.arch.arch)) {
4407		zig_panic("Unable to determine vcruntime path.");
	4441	if (g->msvc_lib_dir == nullptr) {
	4442	Buf* vc_lib_dir = buf_alloc();
	4443	if (os_get_win32_vcruntime_path(vc_lib_dir, g->zig_target.arch.arch)) {
	4444	fprintf(stderr, "Unable to determine vcruntime path. --msvc-lib-dir");
	4445	exit(1);
	4446	}
	4447	g->msvc_lib_dir = vc_lib_dir;
4408	4448	}
4409	4449
4410		Buf* ucrt_lib_path = buf_alloc();
4411		if (os_get_win32_ucrt_lib_path(sdk, ucrt_lib_path, g->zig_target.arch.arch)) {
4412		zig_panic("Unable to determine ucrt path.");
	4450	if (g->libc_lib_dir == nullptr) {
	4451	Buf* ucrt_lib_path = buf_alloc();
	4452	if (os_get_win32_ucrt_lib_path(sdk, ucrt_lib_path, g->zig_target.arch.arch)) {
	4453	fprintf(stderr, "Unable to determine ucrt path. --libc-lib-dir");
	4454	exit(1);
	4455	}
	4456	g->libc_lib_dir = ucrt_lib_path;
4413	4457	}
4414	4458
4415		Buf* kern_lib_path = buf_alloc();
4416		if (os_get_win32_kern32_path(sdk, kern_lib_path, g->zig_target.arch.arch)) {
4417		zig_panic("Unable to determine kernel32 path.");
	4459	if (g->kernel32_lib_dir == nullptr) {
	4460	Buf* kern_lib_path = buf_alloc();
	4461	if (os_get_win32_kern32_path(sdk, kern_lib_path, g->zig_target.arch.arch)) {
	4462	fprintf(stderr, "Unable to determine kernel32 path. --kernel32-lib-dir");
	4463	exit(1);
	4464	}
	4465	g->kernel32_lib_dir = kern_lib_path;
4418	4466	}
4419	4467
4420		g->msvc_lib_dir = vc_lib_dir;
4421		g->libc_lib_dir = ucrt_lib_path;
4422		g->kernel32_lib_dir = kern_lib_path;
4423	4468	} else if (g->zig_target.os == OsLinux) {
4424	4469	g->libc_lib_dir = get_linux_libc_lib_path("crt1.o");
4425	4470	} else {
...	...	@@ -5782,9 +5827,11 @@ uint32_t zig_llvm_fn_key_hash(ZigLLVMFnKey x) {
5782	5827	case ZigLLVMFnIdClz:
5783	5828	return (uint32_t)(x.data.clz.bit_count) * (uint32_t)2428952817;
5784	5829	case ZigLLVMFnIdFloor:
5785		return (uint32_t)(x.data.floor_ceil.bit_count) * (uint32_t)1899859168;
	5830	return (uint32_t)(x.data.floating.bit_count) * (uint32_t)1899859168;
5786	5831	case ZigLLVMFnIdCeil:
5787		return (uint32_t)(x.data.floor_ceil.bit_count) * (uint32_t)1953839089;
	5832	return (uint32_t)(x.data.floating.bit_count) * (uint32_t)1953839089;
	5833	case ZigLLVMFnIdSqrt:
	5834	return (uint32_t)(x.data.floating.bit_count) * (uint32_t)2225366385;
5788	5835	case ZigLLVMFnIdOverflowArithmetic:
5789	5836	return ((uint32_t)(x.data.overflow_arithmetic.bit_count) * 87135777) +
5790	5837	((uint32_t)(x.data.overflow_arithmetic.add_sub_mul) * 31640542) +
...	...	@@ -5803,7 +5850,8 @@ bool zig_llvm_fn_key_eql(ZigLLVMFnKey a, ZigLLVMFnKey b) {
5803	5850	return a.data.clz.bit_count == b.data.clz.bit_count;
5804	5851	case ZigLLVMFnIdFloor:
5805	5852	case ZigLLVMFnIdCeil:
5806		return a.data.floor_ceil.bit_count == b.data.floor_ceil.bit_count;
	5853	case ZigLLVMFnIdSqrt:
	5854	return a.data.floating.bit_count == b.data.floating.bit_count;
5807	5855	case ZigLLVMFnIdOverflowArithmetic:
5808	5856	return (a.data.overflow_arithmetic.bit_count == b.data.overflow_arithmetic.bit_count) &&
5809	5857	(a.data.overflow_arithmetic.add_sub_mul == b.data.overflow_arithmetic.add_sub_mul) &&
...	...	@@ -5883,8 +5931,8 @@ size_t type_id_len() {
5883	5931	return array_length(all_type_ids);
5884	5932	}
5885	5933
5886		size_t type_id_index(TypeTableEntryId id) {
5887		switch (id) {
	5934	size_t type_id_index(TypeTableEntry *entry) {
	5935	switch (entry->id) {
5888	5936	case TypeTableEntryIdInvalid:
5889	5937	zig_unreachable();
5890	5938	case TypeTableEntryIdMetaType:
...	...	@@ -5904,6 +5952,8 @@ size_t type_id_index(TypeTableEntryId id) {
5904	5952	case TypeTableEntryIdArray:
5905	5953	return 7;
5906	5954	case TypeTableEntryIdStruct:
	5955	if (entry->data.structure.is_slice)
	5956	return 25;
5907	5957	return 8;
5908	5958	case TypeTableEntryIdNumLitFloat:
5909	5959	return 9;
...	...	@@ -6089,4 +6139,3 @@ bool type_can_fail(TypeTableEntry *type_entry) {
6089	6139	bool fn_type_can_fail(FnTypeId *fn_type_id) {
6090	6140	return type_can_fail(fn_type_id->return_type) \|\| fn_type_id->cc == CallingConventionAsync;
6091	6141	}
6092

src/analyze.hpp+2-1

...	...	@@ -104,6 +104,7 @@ ScopeDeferExpr create_defer_expr_scope(AstNode node, Scope *parent);
104	104	Scope create_var_scope(AstNode node, Scope parent, VariableTableEntry var);
105	105	ScopeCImport create_cimport_scope(AstNode node, Scope *parent);
106	106	ScopeLoop create_loop_scope(AstNode node, Scope *parent);
	107	ScopeSuspend create_suspend_scope(AstNode node, Scope *parent);
107	108	ScopeFnDef create_fndef_scope(AstNode node, Scope parent, FnTableEntry fn_entry);
108	109	ScopeDecls create_decls_scope(AstNode node, Scope parent, TypeTableEntry container_type, ImportTableEntry *import);
109	110	Scope create_comptime_scope(AstNode node, Scope *parent);
...	...	@@ -173,7 +174,7 @@ void update_compile_var(CodeGen g, Buf name, ConstExprValue *value);
173	174	const char *type_id_name(TypeTableEntryId id);
174	175	TypeTableEntryId type_id_at_index(size_t index);
175	176	size_t type_id_len();
176		size_t type_id_index(TypeTableEntryId id);
	177	size_t type_id_index(TypeTableEntry *entry);
177	178	TypeTableEntry get_generic_fn_type(CodeGen g, FnTypeId *fn_type_id);
178	179	bool type_is_copyable(CodeGen g, TypeTableEntry type_entry);
179	180	LinkLib create_link_lib(Buf name);

src/ast_render.cpp+1-4

...	...	@@ -148,8 +148,6 @@ static const char *node_type_str(NodeType node_type) {
148	148	return "Root";
149	149	case NodeTypeFnDef:
150	150	return "FnDef";
151		case NodeTypeFnDecl:
152		return "FnDecl";
153	151	case NodeTypeFnProto:
154	152	return "FnProto";
155	153	case NodeTypeParamDecl:
...	...	@@ -730,7 +728,7 @@ static void render_node_extra(AstRender ar, AstNode node, bool grouped) {
730	728	render_node_grouped(ar, field_node->data.struct_field.type);
731	729	}
732	730	if (field_node->data.struct_field.value != nullptr) {
733		fprintf(ar->f, "= ");
	731	fprintf(ar->f, " = ");
734	732	render_node_grouped(ar, field_node->data.struct_field.value);
735	733	}
736	734	fprintf(ar->f, ",\n");
...	...	@@ -1098,7 +1096,6 @@ static void render_node_extra(AstRender ar, AstNode node, bool grouped) {
1098	1096	}
1099	1097	break;
1100	1098	}
1101		case NodeTypeFnDecl:
1102	1099	case NodeTypeParamDecl:
1103	1100	case NodeTypeTestDecl:
1104	1101	case NodeTypeStructField:

src/bigfloat.cpp+4

...	...	@@ -181,3 +181,7 @@ bool bigfloat_has_fraction(const BigFloat *bigfloat) {
181	181	f128M_roundToInt(&bigfloat->value, softfloat_round_minMag, false, &floored);
182	182	return !f128M_eq(&floored, &bigfloat->value);
183	183	}
	184
	185	void bigfloat_sqrt(BigFloat dest, const BigFloat op) {
	186	f128M_sqrt(&op->value, &dest->value);
	187	}

src/bigfloat.hpp+1

...	...	@@ -42,6 +42,7 @@ void bigfloat_div_trunc(BigFloat dest, const BigFloat op1, const BigFloat *op2
42	42	void bigfloat_div_floor(BigFloat dest, const BigFloat op1, const BigFloat *op2);
43	43	void bigfloat_rem(BigFloat dest, const BigFloat op1, const BigFloat *op2);
44	44	void bigfloat_mod(BigFloat dest, const BigFloat op1, const BigFloat *op2);
	45	void bigfloat_sqrt(BigFloat dest, const BigFloat op);
45	46	void bigfloat_append_buf(Buf buf, const BigFloat op);
46	47	Cmp bigfloat_cmp(const BigFloat op1, const BigFloat op2);
47	48

src/bigint.cpp+9-6

...	...	@@ -86,6 +86,11 @@ static void to_twos_complement(BigInt dest, const BigInt op, size_t bit_count)
86	86	size_t digits_to_copy = bit_count / 64;
87	87	size_t leftover_bits = bit_count % 64;
88	88	dest->digit_count = digits_to_copy + ((leftover_bits == 0) ? 0 : 1);
	89	if (dest->digit_count == 1 && leftover_bits == 0) {
	90	dest->data.digit = op_digits[0];
	91	if (dest->data.digit == 0) dest->digit_count = 0;
	92	return;
	93	}
89	94	dest->data.digits = allocate_nonzero<uint64_t>(dest->digit_count);
90	95	for (size_t i = 0; i < digits_to_copy; i += 1) {
91	96	uint64_t digit = (i < op->digit_count) ? op_digits[i] : 0;
...	...	@@ -1254,12 +1259,11 @@ void bigint_and(BigInt dest, const BigInt op1, const BigInt *op2) {
1254	1259	bigint_normalize(dest);
1255	1260	return;
1256	1261	}
1257		// TODO this code path is untested
1258		uint64_t first_digit = dest->data.digit;
	1262
1259	1263	dest->digit_count = max(op1->digit_count, op2->digit_count);
1260	1264	dest->data.digits = allocate_nonzero<uint64_t>(dest->digit_count);
1261		dest->data.digits[0] = first_digit;
1262		size_t i = 1;
	1265
	1266	size_t i = 0;
1263	1267	for (; i < op1->digit_count && i < op2->digit_count; i += 1) {
1264	1268	dest->data.digits[i] = op1_digits[i] & op2_digits[i];
1265	1269	}
...	...	@@ -1407,7 +1411,6 @@ void bigint_shr(BigInt dest, const BigInt op1, const BigInt *op2) {
1407	1411	return;
1408	1412	}
1409	1413
1410		// TODO this code path is untested
1411	1414	size_t digit_shift_count = shift_amt / 64;
1412	1415	size_t leftover_shift_count = shift_amt % 64;
1413	1416
...	...	@@ -1422,7 +1425,7 @@ void bigint_shr(BigInt dest, const BigInt op1, const BigInt *op2) {
1422	1425	uint64_t digit = op1_digits[op_digit_index];
1423	1426	size_t dest_digit_index = op_digit_index - digit_shift_count;
1424	1427	dest->data.digits[dest_digit_index] = carry \| (digit >> leftover_shift_count);
1425		carry = (0xffffffffffffffffULL << leftover_shift_count) & digit;
	1428	carry = digit << (64 - leftover_shift_count);
1426	1429
1427	1430	if (dest_digit_index == 0) { break; }
1428	1431	op_digit_index -= 1;

src/codegen.cpp+523-65

...	...	@@ -88,6 +88,7 @@ CodeGen codegen_create(Buf root_src_path, const ZigTarget *target, OutType out
88	88	g->exported_symbol_names.init(8);
89	89	g->external_prototypes.init(8);
90	90	g->string_literals_table.init(16);
	91	g->type_info_cache.init(32);
91	92	g->is_test_build = false;
92	93	g->want_h_file = (out_type == OutTypeObj \|\| out_type == OutTypeLib);
93	94	buf_resize(&g->global_asm, 0);
...	...	@@ -408,6 +409,9 @@ static uint32_t get_err_ret_trace_arg_index(CodeGen g, FnTableEntry fn_table_e
408	409	if (!g->have_err_ret_tracing) {
409	410	return UINT32_MAX;
410	411	}
	412	if (fn_table_entry->type_entry->data.fn.fn_type_id.cc == CallingConventionAsync) {
	413	return 0;
	414	}
411	415	TypeTableEntry *fn_type = fn_table_entry->type_entry;
412	416	if (!fn_type_can_fail(&fn_type->data.fn.fn_type_id)) {
413	417	return UINT32_MAX;
...	...	@@ -464,7 +468,7 @@ static LLVMValueRef fn_llvm_value(CodeGen g, FnTableEntry fn_table_entry) {
464	468	fn_table_entry->llvm_value, buf_ptr(&fn_export->name));
465	469	}
466	470	}
467		fn_table_entry->llvm_name = LLVMGetValueName(fn_table_entry->llvm_value);
	471	fn_table_entry->llvm_name = strdup(LLVMGetValueName(fn_table_entry->llvm_value));
468	472
469	473	switch (fn_table_entry->fn_inline) {
470	474	case FnInlineAlways:
...	...	@@ -509,7 +513,9 @@ static LLVMValueRef fn_llvm_value(CodeGen g, FnTableEntry fn_table_entry) {
509	513	}
510	514
511	515	if (fn_table_entry->body_node != nullptr) {
512		bool want_fn_safety = g->build_mode != BuildModeFastRelease && !fn_table_entry->def_scope->safety_off;
	516	bool want_fn_safety = g->build_mode != BuildModeFastRelease &&
	517	g->build_mode != BuildModeSmallRelease &&
	518	!fn_table_entry->def_scope->safety_off;
513	519	if (want_fn_safety) {
514	520	if (g->libc_link_lib != nullptr) {
515	521	addLLVMFnAttr(fn_table_entry->llvm_value, "sspstrong");
...	...	@@ -649,6 +655,7 @@ static ZigLLVMDIScope get_di_scope(CodeGen g, Scope *scope) {
649	655	}
650	656	case ScopeIdDeferExpr:
651	657	case ScopeIdLoop:
	658	case ScopeIdSuspend:
652	659	case ScopeIdCompTime:
653	660	case ScopeIdCoroPrelude:
654	661	return get_di_scope(g, scope->parent);
...	...	@@ -714,12 +721,12 @@ static LLVMValueRef get_int_overflow_fn(CodeGen g, TypeTableEntry type_entry,
714	721	return fn_val;
715	722	}
716	723
717		static LLVMValueRef get_floor_ceil_fn(CodeGen g, TypeTableEntry type_entry, ZigLLVMFnId fn_id) {
	724	static LLVMValueRef get_float_fn(CodeGen g, TypeTableEntry type_entry, ZigLLVMFnId fn_id) {
718	725	assert(type_entry->id == TypeTableEntryIdFloat);
719	726
720	727	ZigLLVMFnKey key = {};
721	728	key.id = fn_id;
722		key.data.floor_ceil.bit_count = (uint32_t)type_entry->data.floating.bit_count;
	729	key.data.floating.bit_count = (uint32_t)type_entry->data.floating.bit_count;
723	730
724	731	auto existing_entry = g->llvm_fn_table.maybe_get(key);
725	732	if (existing_entry)
...	...	@@ -730,6 +737,8 @@ static LLVMValueRef get_floor_ceil_fn(CodeGen g, TypeTableEntry type_entry, Zi
730	737	name = "floor";
731	738	} else if (fn_id == ZigLLVMFnIdCeil) {
732	739	name = "ceil";
	740	} else if (fn_id == ZigLLVMFnIdSqrt) {
	741	name = "sqrt";
733	742	} else {
734	743	zig_unreachable();
735	744	}
...	...	@@ -812,7 +821,7 @@ static bool ir_want_fast_math(CodeGen g, IrInstruction instruction) {
812	821	}
813	822
814	823	static bool ir_want_runtime_safety(CodeGen g, IrInstruction instruction) {
815		if (g->build_mode == BuildModeFastRelease)
	824	if (g->build_mode == BuildModeFastRelease \|\| g->build_mode == BuildModeSmallRelease)
816	825	return false;
817	826
818	827	// TODO memoize
...	...	@@ -1114,22 +1123,19 @@ static LLVMValueRef get_return_address_fn_val(CodeGen *g) {
1114	1123	return g->return_address_fn_val;
1115	1124	}
1116	1125
1117		static LLVMValueRef get_return_err_fn(CodeGen *g) {
1118		if (g->return_err_fn != nullptr)
1119		return g->return_err_fn;
1120
1121		assert(g->err_tag_type != nullptr);
	1126	static LLVMValueRef get_add_error_return_trace_addr_fn(CodeGen *g) {
	1127	if (g->add_error_return_trace_addr_fn_val != nullptr)
	1128	return g->add_error_return_trace_addr_fn_val;
1122	1129
1123	1130	LLVMTypeRef arg_types[] = {
1124		// error return trace pointer
1125	1131	get_ptr_to_stack_trace_type(g)->type_ref,
	1132	g->builtin_types.entry_usize->type_ref,
1126	1133	};
1127		LLVMTypeRef fn_type_ref = LLVMFunctionType(LLVMVoidType(), arg_types, 1, false);
	1134	LLVMTypeRef fn_type_ref = LLVMFunctionType(LLVMVoidType(), arg_types, 2, false);
1128	1135
1129		Buf *fn_name = get_mangled_name(g, buf_create_from_str("__zig_return_error"), false);
	1136	Buf *fn_name = get_mangled_name(g, buf_create_from_str("__zig_add_err_ret_trace_addr"), false);
1130	1137	LLVMValueRef fn_val = LLVMAddFunction(g->module, buf_ptr(fn_name), fn_type_ref);
1131		addLLVMFnAttr(fn_val, "noinline"); // so that we can look at return address
1132		addLLVMFnAttr(fn_val, "cold");
	1138	addLLVMFnAttr(fn_val, "alwaysinline");
1133	1139	LLVMSetLinkage(fn_val, LLVMInternalLinkage);
1134	1140	LLVMSetFunctionCallConv(fn_val, get_llvm_cc(g, CallingConventionUnspecified));
1135	1141	addLLVMFnAttr(fn_val, "nounwind");
...	...	@@ -1151,6 +1157,8 @@ static LLVMValueRef get_return_err_fn(CodeGen *g) {
1151	1157	// stack_trace.instruction_addresses[stack_trace.index % stack_trace.instruction_addresses.len] = return_address;
1152	1158
1153	1159	LLVMValueRef err_ret_trace_ptr = LLVMGetParam(fn_val, 0);
	1160	LLVMValueRef address_value = LLVMGetParam(fn_val, 1);
	1161
1154	1162	size_t index_field_index = g->stack_trace_type->data.structure.fields[0].gen_index;
1155	1163	LLVMValueRef index_field_ptr = LLVMBuildStructGEP(g->builder, err_ret_trace_ptr, (unsigned)index_field_index, "");
1156	1164	size_t addresses_field_index = g->stack_trace_type->data.structure.fields[1].gen_index;
...	...	@@ -1172,15 +1180,10 @@ static LLVMValueRef get_return_err_fn(CodeGen *g) {
1172	1180	LLVMValueRef ptr_value = gen_load_untyped(g, ptr_field_ptr, 0, false, "");
1173	1181	LLVMValueRef address_slot = LLVMBuildInBoundsGEP(g->builder, ptr_value, address_indices, 1, "");
1174	1182
1175		LLVMValueRef zero = LLVMConstNull(g->builtin_types.entry_i32->type_ref);
1176		LLVMValueRef return_address_ptr = LLVMBuildCall(g->builder, get_return_address_fn_val(g), &zero, 1, "");
1177		LLVMValueRef return_address = LLVMBuildPtrToInt(g->builder, return_address_ptr, usize_type_ref, "");
1178
1179		LLVMValueRef address_value = LLVMBuildPtrToInt(g->builder, return_address, usize_type_ref, "");
1180	1183	gen_store_untyped(g, address_value, address_slot, 0, false);
1181	1184
1182	1185	// stack_trace.index += 1;
1183		LLVMValueRef index_plus_one_val = LLVMBuildAdd(g->builder, index_val, LLVMConstInt(usize_type_ref, 1, false), "");
	1186	LLVMValueRef index_plus_one_val = LLVMBuildNUWAdd(g->builder, index_val, LLVMConstInt(usize_type_ref, 1, false), "");
1184	1187	gen_store_untyped(g, index_plus_one_val, index_field_ptr, 0, false);
1185	1188
1186	1189	// return;
...	...	@@ -1189,6 +1192,187 @@ static LLVMValueRef get_return_err_fn(CodeGen *g) {
1189	1192	LLVMPositionBuilderAtEnd(g->builder, prev_block);
1190	1193	LLVMSetCurrentDebugLocation(g->builder, prev_debug_location);
1191	1194
	1195	g->add_error_return_trace_addr_fn_val = fn_val;
	1196	return fn_val;
	1197	}
	1198
	1199	static LLVMValueRef get_merge_err_ret_traces_fn_val(CodeGen *g) {
	1200	if (g->merge_err_ret_traces_fn_val)
	1201	return g->merge_err_ret_traces_fn_val;
	1202
	1203	assert(g->stack_trace_type != nullptr);
	1204
	1205	LLVMTypeRef param_types[] = {
	1206	get_ptr_to_stack_trace_type(g)->type_ref,
	1207	get_ptr_to_stack_trace_type(g)->type_ref,
	1208	};
	1209	LLVMTypeRef fn_type_ref = LLVMFunctionType(LLVMVoidType(), param_types, 2, false);
	1210
	1211	Buf *fn_name = get_mangled_name(g, buf_create_from_str("__zig_merge_error_return_traces"), false);
	1212	LLVMValueRef fn_val = LLVMAddFunction(g->module, buf_ptr(fn_name), fn_type_ref);
	1213	LLVMSetLinkage(fn_val, LLVMInternalLinkage);
	1214	LLVMSetFunctionCallConv(fn_val, get_llvm_cc(g, CallingConventionUnspecified));
	1215	addLLVMFnAttr(fn_val, "nounwind");
	1216	add_uwtable_attr(g, fn_val);
	1217	addLLVMArgAttr(fn_val, (unsigned)0, "nonnull");
	1218	addLLVMArgAttr(fn_val, (unsigned)0, "noalias");
	1219	addLLVMArgAttr(fn_val, (unsigned)0, "writeonly");
	1220	addLLVMArgAttr(fn_val, (unsigned)1, "nonnull");
	1221	addLLVMArgAttr(fn_val, (unsigned)1, "noalias");
	1222	addLLVMArgAttr(fn_val, (unsigned)1, "readonly");
	1223	if (g->build_mode == BuildModeDebug) {
	1224	ZigLLVMAddFunctionAttr(fn_val, "no-frame-pointer-elim", "true");
	1225	ZigLLVMAddFunctionAttr(fn_val, "no-frame-pointer-elim-non-leaf", nullptr);
	1226	}
	1227
	1228	// this is above the ZigLLVMClearCurrentDebugLocation
	1229	LLVMValueRef add_error_return_trace_addr_fn_val = get_add_error_return_trace_addr_fn(g);
	1230
	1231	LLVMBasicBlockRef entry_block = LLVMAppendBasicBlock(fn_val, "Entry");
	1232	LLVMBasicBlockRef prev_block = LLVMGetInsertBlock(g->builder);
	1233	LLVMValueRef prev_debug_location = LLVMGetCurrentDebugLocation(g->builder);
	1234	LLVMPositionBuilderAtEnd(g->builder, entry_block);
	1235	ZigLLVMClearCurrentDebugLocation(g->builder);
	1236
	1237	// var frame_index: usize = undefined;
	1238	// var frames_left: usize = undefined;
	1239	// if (src_stack_trace.index < src_stack_trace.instruction_addresses.len) {
	1240	// frame_index = 0;
	1241	// frames_left = src_stack_trace.index;
	1242	// if (frames_left == 0) return;
	1243	// } else {
	1244	// frame_index = (src_stack_trace.index + 1) % src_stack_trace.instruction_addresses.len;
	1245	// frames_left = src_stack_trace.instruction_addresses.len;
	1246	// }
	1247	// while (true) {
	1248	// __zig_add_err_ret_trace_addr(dest_stack_trace, src_stack_trace.instruction_addresses[frame_index]);
	1249	// frames_left -= 1;
	1250	// if (frames_left == 0) return;
	1251	// frame_index = (frame_index + 1) % src_stack_trace.instruction_addresses.len;
	1252	// }
	1253	LLVMBasicBlockRef return_block = LLVMAppendBasicBlock(fn_val, "Return");
	1254
	1255	LLVMValueRef frame_index_ptr = LLVMBuildAlloca(g->builder, g->builtin_types.entry_usize->type_ref, "frame_index");
	1256	LLVMValueRef frames_left_ptr = LLVMBuildAlloca(g->builder, g->builtin_types.entry_usize->type_ref, "frames_left");
	1257
	1258	LLVMValueRef dest_stack_trace_ptr = LLVMGetParam(fn_val, 0);
	1259	LLVMValueRef src_stack_trace_ptr = LLVMGetParam(fn_val, 1);
	1260
	1261	size_t src_index_field_index = g->stack_trace_type->data.structure.fields[0].gen_index;
	1262	size_t src_addresses_field_index = g->stack_trace_type->data.structure.fields[1].gen_index;
	1263	LLVMValueRef src_index_field_ptr = LLVMBuildStructGEP(g->builder, src_stack_trace_ptr,
	1264	(unsigned)src_index_field_index, "");
	1265	LLVMValueRef src_addresses_field_ptr = LLVMBuildStructGEP(g->builder, src_stack_trace_ptr,
	1266	(unsigned)src_addresses_field_index, "");
	1267	TypeTableEntry *slice_type = g->stack_trace_type->data.structure.fields[1].type_entry;
	1268	size_t ptr_field_index = slice_type->data.structure.fields[slice_ptr_index].gen_index;
	1269	LLVMValueRef src_ptr_field_ptr = LLVMBuildStructGEP(g->builder, src_addresses_field_ptr, (unsigned)ptr_field_index, "");
	1270	size_t len_field_index = slice_type->data.structure.fields[slice_len_index].gen_index;
	1271	LLVMValueRef src_len_field_ptr = LLVMBuildStructGEP(g->builder, src_addresses_field_ptr, (unsigned)len_field_index, "");
	1272	LLVMValueRef src_index_val = LLVMBuildLoad(g->builder, src_index_field_ptr, "");
	1273	LLVMValueRef src_ptr_val = LLVMBuildLoad(g->builder, src_ptr_field_ptr, "");
	1274	LLVMValueRef src_len_val = LLVMBuildLoad(g->builder, src_len_field_ptr, "");
	1275	LLVMValueRef no_wrap_bit = LLVMBuildICmp(g->builder, LLVMIntULT, src_index_val, src_len_val, "");
	1276	LLVMBasicBlockRef no_wrap_block = LLVMAppendBasicBlock(fn_val, "NoWrap");
	1277	LLVMBasicBlockRef yes_wrap_block = LLVMAppendBasicBlock(fn_val, "YesWrap");
	1278	LLVMBasicBlockRef loop_block = LLVMAppendBasicBlock(fn_val, "Loop");
	1279	LLVMBuildCondBr(g->builder, no_wrap_bit, no_wrap_block, yes_wrap_block);
	1280
	1281	LLVMPositionBuilderAtEnd(g->builder, no_wrap_block);
	1282	LLVMValueRef usize_zero = LLVMConstNull(g->builtin_types.entry_usize->type_ref);
	1283	LLVMBuildStore(g->builder, usize_zero, frame_index_ptr);
	1284	LLVMBuildStore(g->builder, src_index_val, frames_left_ptr);
	1285	LLVMValueRef frames_left_eq_zero_bit = LLVMBuildICmp(g->builder, LLVMIntEQ, src_index_val, usize_zero, "");
	1286	LLVMBuildCondBr(g->builder, frames_left_eq_zero_bit, return_block, loop_block);
	1287
	1288	LLVMPositionBuilderAtEnd(g->builder, yes_wrap_block);
	1289	LLVMValueRef usize_one = LLVMConstInt(g->builtin_types.entry_usize->type_ref, 1, false);
	1290	LLVMValueRef plus_one = LLVMBuildNUWAdd(g->builder, src_index_val, usize_one, "");
	1291	LLVMValueRef mod_len = LLVMBuildURem(g->builder, plus_one, src_len_val, "");
	1292	LLVMBuildStore(g->builder, mod_len, frame_index_ptr);
	1293	LLVMBuildStore(g->builder, src_len_val, frames_left_ptr);
	1294	LLVMBuildBr(g->builder, loop_block);
	1295
	1296	LLVMPositionBuilderAtEnd(g->builder, loop_block);
	1297	LLVMValueRef ptr_index = LLVMBuildLoad(g->builder, frame_index_ptr, "");
	1298	LLVMValueRef addr_ptr = LLVMBuildInBoundsGEP(g->builder, src_ptr_val, &ptr_index, 1, "");
	1299	LLVMValueRef this_addr_val = LLVMBuildLoad(g->builder, addr_ptr, "");
	1300	LLVMValueRef args[] = {dest_stack_trace_ptr, this_addr_val};
	1301	ZigLLVMBuildCall(g->builder, add_error_return_trace_addr_fn_val, args, 2, get_llvm_cc(g, CallingConventionUnspecified), ZigLLVM_FnInlineAlways, "");
	1302	LLVMValueRef prev_frames_left = LLVMBuildLoad(g->builder, frames_left_ptr, "");
	1303	LLVMValueRef new_frames_left = LLVMBuildNUWSub(g->builder, prev_frames_left, usize_one, "");
	1304	LLVMValueRef done_bit = LLVMBuildICmp(g->builder, LLVMIntEQ, new_frames_left, usize_zero, "");
	1305	LLVMBasicBlockRef continue_block = LLVMAppendBasicBlock(fn_val, "Continue");
	1306	LLVMBuildCondBr(g->builder, done_bit, return_block, continue_block);
	1307
	1308	LLVMPositionBuilderAtEnd(g->builder, return_block);
	1309	LLVMBuildRetVoid(g->builder);
	1310
	1311	LLVMPositionBuilderAtEnd(g->builder, continue_block);
	1312	LLVMBuildStore(g->builder, new_frames_left, frames_left_ptr);
	1313	LLVMValueRef prev_index = LLVMBuildLoad(g->builder, frame_index_ptr, "");
	1314	LLVMValueRef index_plus_one = LLVMBuildNUWAdd(g->builder, prev_index, usize_one, "");
	1315	LLVMValueRef index_mod_len = LLVMBuildURem(g->builder, index_plus_one, src_len_val, "");
	1316	LLVMBuildStore(g->builder, index_mod_len, frame_index_ptr);
	1317	LLVMBuildBr(g->builder, loop_block);
	1318
	1319	LLVMPositionBuilderAtEnd(g->builder, prev_block);
	1320	LLVMSetCurrentDebugLocation(g->builder, prev_debug_location);
	1321
	1322	g->merge_err_ret_traces_fn_val = fn_val;
	1323	return fn_val;
	1324
	1325	}
	1326
	1327	static LLVMValueRef get_return_err_fn(CodeGen *g) {
	1328	if (g->return_err_fn != nullptr)
	1329	return g->return_err_fn;
	1330
	1331	assert(g->err_tag_type != nullptr);
	1332
	1333	LLVMTypeRef arg_types[] = {
	1334	// error return trace pointer
	1335	get_ptr_to_stack_trace_type(g)->type_ref,
	1336	};
	1337	LLVMTypeRef fn_type_ref = LLVMFunctionType(LLVMVoidType(), arg_types, 1, false);
	1338
	1339	Buf *fn_name = get_mangled_name(g, buf_create_from_str("__zig_return_error"), false);
	1340	LLVMValueRef fn_val = LLVMAddFunction(g->module, buf_ptr(fn_name), fn_type_ref);
	1341	addLLVMFnAttr(fn_val, "noinline"); // so that we can look at return address
	1342	addLLVMFnAttr(fn_val, "cold");
	1343	LLVMSetLinkage(fn_val, LLVMInternalLinkage);
	1344	LLVMSetFunctionCallConv(fn_val, get_llvm_cc(g, CallingConventionUnspecified));
	1345	addLLVMFnAttr(fn_val, "nounwind");
	1346	add_uwtable_attr(g, fn_val);
	1347	addLLVMArgAttr(fn_val, (unsigned)0, "nonnull");
	1348	if (g->build_mode == BuildModeDebug) {
	1349	ZigLLVMAddFunctionAttr(fn_val, "no-frame-pointer-elim", "true");
	1350	ZigLLVMAddFunctionAttr(fn_val, "no-frame-pointer-elim-non-leaf", nullptr);
	1351	}
	1352
	1353	// this is above the ZigLLVMClearCurrentDebugLocation
	1354	LLVMValueRef add_error_return_trace_addr_fn_val = get_add_error_return_trace_addr_fn(g);
	1355
	1356	LLVMBasicBlockRef entry_block = LLVMAppendBasicBlock(fn_val, "Entry");
	1357	LLVMBasicBlockRef prev_block = LLVMGetInsertBlock(g->builder);
	1358	LLVMValueRef prev_debug_location = LLVMGetCurrentDebugLocation(g->builder);
	1359	LLVMPositionBuilderAtEnd(g->builder, entry_block);
	1360	ZigLLVMClearCurrentDebugLocation(g->builder);
	1361
	1362	LLVMValueRef err_ret_trace_ptr = LLVMGetParam(fn_val, 0);
	1363
	1364	LLVMTypeRef usize_type_ref = g->builtin_types.entry_usize->type_ref;
	1365	LLVMValueRef zero = LLVMConstNull(g->builtin_types.entry_i32->type_ref);
	1366	LLVMValueRef return_address_ptr = LLVMBuildCall(g->builder, get_return_address_fn_val(g), &zero, 1, "");
	1367	LLVMValueRef return_address = LLVMBuildPtrToInt(g->builder, return_address_ptr, usize_type_ref, "");
	1368
	1369	LLVMValueRef args[] = { err_ret_trace_ptr, return_address };
	1370	ZigLLVMBuildCall(g->builder, add_error_return_trace_addr_fn_val, args, 2, get_llvm_cc(g, CallingConventionUnspecified), ZigLLVM_FnInlineAlways, "");
	1371	LLVMBuildRetVoid(g->builder);
	1372
	1373	LLVMPositionBuilderAtEnd(g->builder, prev_block);
	1374	LLVMSetCurrentDebugLocation(g->builder, prev_debug_location);
	1375
1192	1376	g->return_err_fn = fn_val;
1193	1377	return fn_val;
1194	1378	}
...	...	@@ -1641,7 +1825,6 @@ static LLVMValueRef ir_render_save_err_ret_addr(CodeGen g, IrExecutable execut
1641	1825	};
1642	1826	LLVMValueRef call_instruction = ZigLLVMBuildCall(g->builder, return_err_fn, args, 1,
1643	1827	get_llvm_cc(g, CallingConventionUnspecified), ZigLLVM_FnInlineAuto, "");
1644		LLVMSetTailCall(call_instruction, true);
1645	1828	return call_instruction;
1646	1829	}
1647	1830
...	...	@@ -1723,7 +1906,7 @@ static LLVMValueRef gen_floor(CodeGen g, LLVMValueRef val, TypeTableEntry type
1723	1906	if (type_entry->id == TypeTableEntryIdInt)
1724	1907	return val;
1725	1908
1726		LLVMValueRef floor_fn = get_floor_ceil_fn(g, type_entry, ZigLLVMFnIdFloor);
	1909	LLVMValueRef floor_fn = get_float_fn(g, type_entry, ZigLLVMFnIdFloor);
1727	1910	return LLVMBuildCall(g->builder, floor_fn, &val, 1, "");
1728	1911	}
1729	1912
...	...	@@ -1731,7 +1914,7 @@ static LLVMValueRef gen_ceil(CodeGen g, LLVMValueRef val, TypeTableEntry type_
1731	1914	if (type_entry->id == TypeTableEntryIdInt)
1732	1915	return val;
1733	1916
1734		LLVMValueRef ceil_fn = get_floor_ceil_fn(g, type_entry, ZigLLVMFnIdCeil);
	1917	LLVMValueRef ceil_fn = get_float_fn(g, type_entry, ZigLLVMFnIdCeil);
1735	1918	return LLVMBuildCall(g->builder, ceil_fn, &val, 1, "");
1736	1919	}
1737	1920
...	...	@@ -3070,10 +3253,12 @@ static LLVMValueRef get_int_builtin_fn(CodeGen g, TypeTableEntry int_type, Bui
3070	3253	fn_name = "cttz";
3071	3254	key.id = ZigLLVMFnIdCtz;
3072	3255	key.data.ctz.bit_count = (uint32_t)int_type->data.integral.bit_count;
3073		} else {
	3256	} else if (fn_id == BuiltinFnIdClz) {
3074	3257	fn_name = "ctlz";
3075	3258	key.id = ZigLLVMFnIdClz;
3076	3259	key.data.clz.bit_count = (uint32_t)int_type->data.integral.bit_count;
	3260	} else {
	3261	zig_unreachable();
3077	3262	}
3078	3263
3079	3264	auto existing_entry = g->llvm_fn_table.maybe_get(key);
...	...	@@ -3375,9 +3560,30 @@ static LLVMValueRef ir_render_cmpxchg(CodeGen g, IrExecutable executable, IrIn
3375	3560	LLVMAtomicOrdering failure_order = to_LLVMAtomicOrdering(instruction->failure_order);
3376	3561
3377	3562	LLVMValueRef result_val = ZigLLVMBuildCmpXchg(g->builder, ptr_val, cmp_val, new_val,
3378		success_order, failure_order);
	3563	success_order, failure_order, instruction->is_weak);
	3564
	3565	TypeTableEntry *maybe_type = instruction->base.value.type;
	3566	assert(maybe_type->id == TypeTableEntryIdMaybe);
	3567	TypeTableEntry *child_type = maybe_type->data.maybe.child_type;
	3568
	3569	if (type_is_codegen_pointer(child_type)) {
	3570	LLVMValueRef payload_val = LLVMBuildExtractValue(g->builder, result_val, 0, "");
	3571	LLVMValueRef success_bit = LLVMBuildExtractValue(g->builder, result_val, 1, "");
	3572	return LLVMBuildSelect(g->builder, success_bit, LLVMConstNull(child_type->type_ref), payload_val, "");
	3573	}
	3574
	3575	assert(instruction->tmp_ptr != nullptr);
	3576	assert(type_has_bits(instruction->type));
	3577
	3578	LLVMValueRef payload_val = LLVMBuildExtractValue(g->builder, result_val, 0, "");
	3579	LLVMValueRef val_ptr = LLVMBuildStructGEP(g->builder, instruction->tmp_ptr, maybe_child_index, "");
	3580	gen_assign_raw(g, val_ptr, get_pointer_to_type(g, instruction->type, false), payload_val);
3379	3581
3380		return LLVMBuildExtractValue(g->builder, result_val, 1, "");
	3582	LLVMValueRef success_bit = LLVMBuildExtractValue(g->builder, result_val, 1, "");
	3583	LLVMValueRef nonnull_bit = LLVMBuildNot(g->builder, success_bit, "");
	3584	LLVMValueRef maybe_ptr = LLVMBuildStructGEP(g->builder, instruction->tmp_ptr, maybe_null_index, "");
	3585	gen_store_untyped(g, nonnull_bit, maybe_ptr, 0, false);
	3586	return instruction->tmp_ptr;
3381	3587	}
3382	3588
3383	3589	static LLVMValueRef ir_render_fence(CodeGen g, IrExecutable executable, IrInstructionFence *instruction) {
...	...	@@ -4204,6 +4410,44 @@ static LLVMValueRef ir_render_atomic_rmw(CodeGen g, IrExecutable executable,
4204	4410	return LLVMBuildIntToPtr(g->builder, uncasted_result, operand_type->type_ref, "");
4205	4411	}
4206	4412
	4413	static LLVMValueRef ir_render_atomic_load(CodeGen g, IrExecutable executable,
	4414	IrInstructionAtomicLoad *instruction)
	4415	{
	4416	LLVMAtomicOrdering ordering = to_LLVMAtomicOrdering(instruction->resolved_ordering);
	4417	LLVMValueRef ptr = ir_llvm_value(g, instruction->ptr);
	4418	LLVMValueRef load_inst = gen_load(g, ptr, instruction->ptr->value.type, "");
	4419	LLVMSetOrdering(load_inst, ordering);
	4420	return load_inst;
	4421	}
	4422
	4423	static LLVMValueRef ir_render_merge_err_ret_traces(CodeGen g, IrExecutable executable,
	4424	IrInstructionMergeErrRetTraces *instruction)
	4425	{
	4426	assert(g->have_err_ret_tracing);
	4427
	4428	LLVMValueRef src_trace_ptr = ir_llvm_value(g, instruction->src_err_ret_trace_ptr);
	4429	LLVMValueRef dest_trace_ptr = ir_llvm_value(g, instruction->dest_err_ret_trace_ptr);
	4430
	4431	LLVMValueRef args[] = { dest_trace_ptr, src_trace_ptr };
	4432	ZigLLVMBuildCall(g->builder, get_merge_err_ret_traces_fn_val(g), args, 2, get_llvm_cc(g, CallingConventionUnspecified), ZigLLVM_FnInlineAuto, "");
	4433	return nullptr;
	4434	}
	4435
	4436	static LLVMValueRef ir_render_mark_err_ret_trace_ptr(CodeGen g, IrExecutable executable,
	4437	IrInstructionMarkErrRetTracePtr *instruction)
	4438	{
	4439	assert(g->have_err_ret_tracing);
	4440	g->cur_err_ret_trace_val_stack = ir_llvm_value(g, instruction->err_ret_trace_ptr);
	4441	return nullptr;
	4442	}
	4443
	4444	static LLVMValueRef ir_render_sqrt(CodeGen g, IrExecutable executable, IrInstructionSqrt *instruction) {
	4445	LLVMValueRef op = ir_llvm_value(g, instruction->op);
	4446	assert(instruction->base.value.type->id == TypeTableEntryIdFloat);
	4447	LLVMValueRef fn_val = get_float_fn(g, instruction->base.value.type, ZigLLVMFnIdSqrt);
	4448	return LLVMBuildCall(g->builder, fn_val, &op, 1, "");
	4449	}
	4450
4207	4451	static void set_debug_location(CodeGen g, IrInstruction instruction) {
4208	4452	AstNode *source_node = instruction->source_node;
4209	4453	Scope *scope = instruction->scope;
...	...	@@ -4259,6 +4503,7 @@ static LLVMValueRef ir_render_instruction(CodeGen g, IrExecutable executable,
4259	4503	case IrInstructionIdDeclRef:
4260	4504	case IrInstructionIdSwitchVar:
4261	4505	case IrInstructionIdOffsetOf:
	4506	case IrInstructionIdTypeInfo:
4262	4507	case IrInstructionIdTypeId:
4263	4508	case IrInstructionIdSetEvalBranchQuota:
4264	4509	case IrInstructionIdPtrTypeOf:
...	...	@@ -4419,8 +4664,16 @@ static LLVMValueRef ir_render_instruction(CodeGen g, IrExecutable executable,
4419	4664	return ir_render_coro_alloc_helper(g, executable, (IrInstructionCoroAllocHelper *)instruction);
4420	4665	case IrInstructionIdAtomicRmw:
4421	4666	return ir_render_atomic_rmw(g, executable, (IrInstructionAtomicRmw *)instruction);
	4667	case IrInstructionIdAtomicLoad:
	4668	return ir_render_atomic_load(g, executable, (IrInstructionAtomicLoad *)instruction);
4422	4669	case IrInstructionIdSaveErrRetAddr:
4423	4670	return ir_render_save_err_ret_addr(g, executable, (IrInstructionSaveErrRetAddr *)instruction);
	4671	case IrInstructionIdMergeErrRetTraces:
	4672	return ir_render_merge_err_ret_traces(g, executable, (IrInstructionMergeErrRetTraces *)instruction);
	4673	case IrInstructionIdMarkErrRetTracePtr:
	4674	return ir_render_mark_err_ret_trace_ptr(g, executable, (IrInstructionMarkErrRetTracePtr *)instruction);
	4675	case IrInstructionIdSqrt:
	4676	return ir_render_sqrt(g, executable, (IrInstructionSqrt *)instruction);
4424	4677	}
4425	4678	zig_unreachable();
4426	4679	}
...	...	@@ -5310,38 +5563,14 @@ static void do_code_gen(CodeGen *g) {
5310	5563	g->cur_err_ret_trace_val_arg = nullptr;
5311	5564	}
5312	5565
	5566	// error return tracing setup
5313	5567	bool is_async = fn_table_entry->type_entry->data.fn.fn_type_id.cc == CallingConventionAsync;
5314		bool have_err_ret_trace_stack = g->have_err_ret_tracing && fn_table_entry->calls_or_awaits_errorable_fn &&
5315		(is_async \|\| !have_err_ret_trace_arg);
	5568	bool have_err_ret_trace_stack = g->have_err_ret_tracing && fn_table_entry->calls_or_awaits_errorable_fn && !is_async && !have_err_ret_trace_arg;
	5569	LLVMValueRef err_ret_array_val = nullptr;
5316	5570	if (have_err_ret_trace_stack) {
5317		// TODO call graph analysis to find out what this number needs to be for every function
5318		static const size_t stack_trace_ptr_count = 30;
5319
5320		TypeTableEntry *usize = g->builtin_types.entry_usize;
5321		TypeTableEntry *array_type = get_array_type(g, usize, stack_trace_ptr_count);
5322		LLVMValueRef err_ret_array_val = build_alloca(g, array_type, "error_return_trace_addresses",
5323		get_abi_alignment(g, array_type));
	5571	TypeTableEntry *array_type = get_array_type(g, g->builtin_types.entry_usize, stack_trace_ptr_count);
	5572	err_ret_array_val = build_alloca(g, array_type, "error_return_trace_addresses", get_abi_alignment(g, array_type));
5324	5573	g->cur_err_ret_trace_val_stack = build_alloca(g, g->stack_trace_type, "error_return_trace", get_abi_alignment(g, g->stack_trace_type));
5325		size_t index_field_index = g->stack_trace_type->data.structure.fields[0].gen_index;
5326		LLVMValueRef index_field_ptr = LLVMBuildStructGEP(g->builder, g->cur_err_ret_trace_val_stack, (unsigned)index_field_index, "");
5327		gen_store_untyped(g, LLVMConstNull(usize->type_ref), index_field_ptr, 0, false);
5328
5329		size_t addresses_field_index = g->stack_trace_type->data.structure.fields[1].gen_index;
5330		LLVMValueRef addresses_field_ptr = LLVMBuildStructGEP(g->builder, g->cur_err_ret_trace_val_stack, (unsigned)addresses_field_index, "");
5331
5332		TypeTableEntry *slice_type = g->stack_trace_type->data.structure.fields[1].type_entry;
5333		size_t ptr_field_index = slice_type->data.structure.fields[slice_ptr_index].gen_index;
5334		LLVMValueRef ptr_field_ptr = LLVMBuildStructGEP(g->builder, addresses_field_ptr, (unsigned)ptr_field_index, "");
5335		LLVMValueRef zero = LLVMConstNull(usize->type_ref);
5336		LLVMValueRef indices[] = {zero, zero};
5337		LLVMValueRef err_ret_array_val_elem0_ptr = LLVMBuildInBoundsGEP(g->builder, err_ret_array_val,
5338		indices, 2, "");
5339		gen_store(g, err_ret_array_val_elem0_ptr, ptr_field_ptr,
5340		get_pointer_to_type(g, get_pointer_to_type(g, usize, false), false));
5341
5342		size_t len_field_index = slice_type->data.structure.fields[slice_len_index].gen_index;
5343		LLVMValueRef len_field_ptr = LLVMBuildStructGEP(g->builder, addresses_field_ptr, (unsigned)len_field_index, "");
5344		gen_store(g, LLVMConstInt(usize->type_ref, stack_trace_ptr_count, false), len_field_ptr, get_pointer_to_type(g, usize, false));
5345	5574	} else {
5346	5575	g->cur_err_ret_trace_val_stack = nullptr;
5347	5576	}
...	...	@@ -5383,6 +5612,9 @@ static void do_code_gen(CodeGen *g) {
5383	5612	} else if (instruction->id == IrInstructionIdErrWrapCode) {
5384	5613	IrInstructionErrWrapCode err_wrap_code_instruction = (IrInstructionErrWrapCode )instruction;
5385	5614	slot = &err_wrap_code_instruction->tmp_ptr;
	5615	} else if (instruction->id == IrInstructionIdCmpxchg) {
	5616	IrInstructionCmpxchg cmpxchg_instruction = (IrInstructionCmpxchg )instruction;
	5617	slot = &cmpxchg_instruction->tmp_ptr;
5386	5618	} else {
5387	5619	zig_unreachable();
5388	5620	}
...	...	@@ -5436,6 +5668,31 @@ static void do_code_gen(CodeGen *g) {
5436	5668	}
5437	5669	}
5438	5670
	5671	// finishing error return trace setup. we have to do this after all the allocas.
	5672	if (have_err_ret_trace_stack) {
	5673	TypeTableEntry *usize = g->builtin_types.entry_usize;
	5674	size_t index_field_index = g->stack_trace_type->data.structure.fields[0].gen_index;
	5675	LLVMValueRef index_field_ptr = LLVMBuildStructGEP(g->builder, g->cur_err_ret_trace_val_stack, (unsigned)index_field_index, "");
	5676	gen_store_untyped(g, LLVMConstNull(usize->type_ref), index_field_ptr, 0, false);
	5677
	5678	size_t addresses_field_index = g->stack_trace_type->data.structure.fields[1].gen_index;
	5679	LLVMValueRef addresses_field_ptr = LLVMBuildStructGEP(g->builder, g->cur_err_ret_trace_val_stack, (unsigned)addresses_field_index, "");
	5680
	5681	TypeTableEntry *slice_type = g->stack_trace_type->data.structure.fields[1].type_entry;
	5682	size_t ptr_field_index = slice_type->data.structure.fields[slice_ptr_index].gen_index;
	5683	LLVMValueRef ptr_field_ptr = LLVMBuildStructGEP(g->builder, addresses_field_ptr, (unsigned)ptr_field_index, "");
	5684	LLVMValueRef zero = LLVMConstNull(usize->type_ref);
	5685	LLVMValueRef indices[] = {zero, zero};
	5686	LLVMValueRef err_ret_array_val_elem0_ptr = LLVMBuildInBoundsGEP(g->builder, err_ret_array_val,
	5687	indices, 2, "");
	5688	TypeTableEntry *ptr_ptr_usize_type = get_pointer_to_type(g, get_pointer_to_type(g, usize, false), false);
	5689	gen_store(g, err_ret_array_val_elem0_ptr, ptr_field_ptr, ptr_ptr_usize_type);
	5690
	5691	size_t len_field_index = slice_type->data.structure.fields[slice_len_index].gen_index;
	5692	LLVMValueRef len_field_ptr = LLVMBuildStructGEP(g->builder, addresses_field_ptr, (unsigned)len_field_index, "");
	5693	gen_store(g, LLVMConstInt(usize->type_ref, stack_trace_ptr_count, false), len_field_ptr, get_pointer_to_type(g, usize, false));
	5694	}
	5695
5439	5696	FnTypeId *fn_type_id = &fn_table_entry->type_entry->data.fn.fn_type_id;
5440	5697
5441	5698	// create debug variable declarations for parameters
...	...	@@ -5519,10 +5776,12 @@ static void do_code_gen(CodeGen *g) {
5519	5776	os_path_join(g->cache_dir, o_basename, output_path);
5520	5777	ensure_cache_dir(g);
5521	5778
	5779	bool is_small = g->build_mode == BuildModeSmallRelease;
	5780
5522	5781	switch (g->emit_file_type) {
5523	5782	case EmitFileTypeBinary:
5524	5783	if (ZigLLVMTargetMachineEmitToFile(g->target_machine, g->module, buf_ptr(output_path),
5525		ZigLLVM_EmitBinary, &err_msg, g->build_mode == BuildModeDebug))
	5784	ZigLLVM_EmitBinary, &err_msg, g->build_mode == BuildModeDebug, is_small))
5526	5785	{
5527	5786	zig_panic("unable to write object file %s: %s", buf_ptr(output_path), err_msg);
5528	5787	}
...	...	@@ -5532,7 +5791,7 @@ static void do_code_gen(CodeGen *g) {
5532	5791
5533	5792	case EmitFileTypeAssembly:
5534	5793	if (ZigLLVMTargetMachineEmitToFile(g->target_machine, g->module, buf_ptr(output_path),
5535		ZigLLVM_EmitAssembly, &err_msg, g->build_mode == BuildModeDebug))
	5794	ZigLLVM_EmitAssembly, &err_msg, g->build_mode == BuildModeDebug, is_small))
5536	5795	{
5537	5796	zig_panic("unable to write assembly file %s: %s", buf_ptr(output_path), err_msg);
5538	5797	}
...	...	@@ -5541,7 +5800,7 @@ static void do_code_gen(CodeGen *g) {
5541	5800
5542	5801	case EmitFileTypeLLVMIr:
5543	5802	if (ZigLLVMTargetMachineEmitToFile(g->target_machine, g->module, buf_ptr(output_path),
5544		ZigLLVM_EmitLLVMIr, &err_msg, g->build_mode == BuildModeDebug))
	5803	ZigLLVM_EmitLLVMIr, &err_msg, g->build_mode == BuildModeDebug, is_small))
5545	5804	{
5546	5805	zig_panic("unable to write llvm-ir file %s: %s", buf_ptr(output_path), err_msg);
5547	5806	}
...	...	@@ -5867,6 +6126,8 @@ static void define_builtin_fns(CodeGen *g) {
5867	6126	create_builtin_fn(g, BuiltinFnIdMemberCount, "memberCount", 1);
5868	6127	create_builtin_fn(g, BuiltinFnIdMemberType, "memberType", 2);
5869	6128	create_builtin_fn(g, BuiltinFnIdMemberName, "memberName", 2);
	6129	create_builtin_fn(g, BuiltinFnIdField, "field", 2);
	6130	create_builtin_fn(g, BuiltinFnIdTypeInfo, "typeInfo", 1);
5870	6131	create_builtin_fn(g, BuiltinFnIdTypeof, "typeOf", 1); // TODO rename to TypeOf
5871	6132	create_builtin_fn(g, BuiltinFnIdAddWithOverflow, "addWithOverflow", 4);
5872	6133	create_builtin_fn(g, BuiltinFnIdSubWithOverflow, "subWithOverflow", 4);
...	...	@@ -5883,7 +6144,8 @@ static void define_builtin_fns(CodeGen *g) {
5883	6144	create_builtin_fn(g, BuiltinFnIdTypeName, "typeName", 1);
5884	6145	create_builtin_fn(g, BuiltinFnIdCanImplicitCast, "canImplicitCast", 2);
5885	6146	create_builtin_fn(g, BuiltinFnIdEmbedFile, "embedFile", 1);
5886		create_builtin_fn(g, BuiltinFnIdCmpExchange, "cmpxchg", 5);
	6147	create_builtin_fn(g, BuiltinFnIdCmpxchgWeak, "cmpxchgWeak", 6);
	6148	create_builtin_fn(g, BuiltinFnIdCmpxchgStrong, "cmpxchgStrong", 6);
5887	6149	create_builtin_fn(g, BuiltinFnIdFence, "fence", 1);
5888	6150	create_builtin_fn(g, BuiltinFnIdTruncate, "truncate", 2);
5889	6151	create_builtin_fn(g, BuiltinFnIdCompileErr, "compileError", 1);
...	...	@@ -5906,6 +6168,7 @@ static void define_builtin_fns(CodeGen *g) {
5906	6168	create_builtin_fn(g, BuiltinFnIdDivFloor, "divFloor", 2);
5907	6169	create_builtin_fn(g, BuiltinFnIdRem, "rem", 2);
5908	6170	create_builtin_fn(g, BuiltinFnIdMod, "mod", 2);
	6171	create_builtin_fn(g, BuiltinFnIdSqrt, "sqrt", 2);
5909	6172	create_builtin_fn(g, BuiltinFnIdInlineCall, "inlineCall", SIZE_MAX);
5910	6173	create_builtin_fn(g, BuiltinFnIdNoInlineCall, "noInlineCall", SIZE_MAX);
5911	6174	create_builtin_fn(g, BuiltinFnIdTypeId, "typeId", 1);
...	...	@@ -5919,6 +6182,7 @@ static void define_builtin_fns(CodeGen *g) {
5919	6182	create_builtin_fn(g, BuiltinFnIdExport, "export", 3);
5920	6183	create_builtin_fn(g, BuiltinFnIdErrorReturnTrace, "errorReturnTrace", 0);
5921	6184	create_builtin_fn(g, BuiltinFnIdAtomicRmw, "atomicRmw", 5);
	6185	create_builtin_fn(g, BuiltinFnIdAtomicLoad, "atomicLoad", 3);
5922	6186	}
5923	6187
5924	6188	static const char *bool_to_str(bool b) {
...	...	@@ -5930,6 +6194,7 @@ static const char *build_mode_to_str(BuildMode build_mode) {
5930	6194	case BuildModeDebug: return "Mode.Debug";
5931	6195	case BuildModeSafeRelease: return "Mode.ReleaseSafe";
5932	6196	case BuildModeFastRelease: return "Mode.ReleaseFast";
	6197	case BuildModeSmallRelease: return "Mode.ReleaseSmall";
5933	6198	}
5934	6199	zig_unreachable();
5935	6200	}
...	...	@@ -5943,6 +6208,8 @@ static void define_builtin_compile_vars(CodeGen *g) {
5943	6208	os_path_join(g->cache_dir, buf_create_from_str(builtin_zig_basename), builtin_zig_path);
5944	6209	Buf *contents = buf_alloc();
5945	6210
	6211	// Modifications to this struct must be coordinated with code that does anything with
	6212	// g->stack_trace_type. There are hard-coded references to the field indexes.
5946	6213	buf_append_str(contents,
5947	6214	"pub const StackTrace = struct {\n"
5948	6215	" index: usize,\n"
...	...	@@ -6068,6 +6335,7 @@ static void define_builtin_compile_vars(CodeGen *g) {
6068	6335	" Debug,\n"
6069	6336	" ReleaseSafe,\n"
6070	6337	" ReleaseFast,\n"
	6338	" ReleaseSmall,\n"
6071	6339	"};\n\n");
6072	6340	}
6073	6341	{
...	...	@@ -6077,8 +6345,196 @@ static void define_builtin_compile_vars(CodeGen *g) {
6077	6345	const TypeTableEntryId id = type_id_at_index(i);
6078	6346	buf_appendf(contents, " %s,\n", type_id_name(id));
6079	6347	}
	6348	buf_appendf(contents, " Slice,\n");
6080	6349	buf_appendf(contents, "};\n\n");
6081	6350	}
	6351	{
	6352	buf_appendf(contents,
	6353	"pub const TypeInfo = union(TypeId) {\n"
	6354	" Type: void,\n"
	6355	" Void: void,\n"
	6356	" Bool: void,\n"
	6357	" NoReturn: void,\n"
	6358	" Int: Int,\n"
	6359	" Float: Float,\n"
	6360	" Pointer: Pointer,\n"
	6361	" Slice: Slice,\n"
	6362	" Array: Array,\n"
	6363	" Struct: Struct,\n"
	6364	" FloatLiteral: void,\n"
	6365	" IntLiteral: void,\n"
	6366	" UndefinedLiteral: void,\n"
	6367	" NullLiteral: void,\n"
	6368	" Nullable: Nullable,\n"
	6369	" ErrorUnion: ErrorUnion,\n"
	6370	" ErrorSet: ErrorSet,\n"
	6371	" Enum: Enum,\n"
	6372	" Union: Union,\n"
	6373	" Fn: Fn,\n"
	6374	" Namespace: void,\n"
	6375	" Block: void,\n"
	6376	" BoundFn: Fn,\n"
	6377	" ArgTuple: void,\n"
	6378	" Opaque: void,\n"
	6379	" Promise: Promise,\n"
	6380	"\n\n"
	6381	" pub const Int = struct {\n"
	6382	" is_signed: bool,\n"
	6383	" bits: u8,\n"
	6384	" };\n"
	6385	"\n"
	6386	" pub const Float = struct {\n"
	6387	" bits: u8,\n"
	6388	" };\n"
	6389	"\n"
	6390	" pub const Pointer = struct {\n"
	6391	" is_const: bool,\n"
	6392	" is_volatile: bool,\n"
	6393	" alignment: u32,\n"
	6394	" child: type,\n"
	6395	" };\n"
	6396	"\n"
	6397	" pub const Slice = Pointer;\n"
	6398	"\n"
	6399	" pub const Array = struct {\n"
	6400	" len: usize,\n"
	6401	" child: type,\n"
	6402	" };\n"
	6403	"\n"
	6404	" pub const ContainerLayout = enum {\n"
	6405	" Auto,\n"
	6406	" Extern,\n"
	6407	" Packed,\n"
	6408	" };\n"
	6409	"\n"
	6410	" pub const StructField = struct {\n"
	6411	" name: []const u8,\n"
	6412	" offset: ?usize,\n"
	6413	" field_type: type,\n"
	6414	" };\n"
	6415	"\n"
	6416	" pub const Struct = struct {\n"
	6417	" layout: ContainerLayout,\n"
	6418	" fields: []StructField,\n"
	6419	" defs: []Definition,\n"
	6420	" };\n"
	6421	"\n"
	6422	" pub const Nullable = struct {\n"
	6423	" child: type,\n"
	6424	" };\n"
	6425	"\n"
	6426	" pub const ErrorUnion = struct {\n"
	6427	" error_set: type,\n"
	6428	" payload: type,\n"
	6429	" };\n"
	6430	"\n"
	6431	" pub const Error = struct {\n"
	6432	" name: []const u8,\n"
	6433	" value: usize,\n"
	6434	" };\n"
	6435	"\n"
	6436	" pub const ErrorSet = struct {\n"
	6437	" errors: []Error,\n"
	6438	" };\n"
	6439	"\n"
	6440	" pub const EnumField = struct {\n"
	6441	" name: []const u8,\n"
	6442	" value: usize,\n"
	6443	" };\n"
	6444	"\n"
	6445	" pub const Enum = struct {\n"
	6446	" layout: ContainerLayout,\n"
	6447	" tag_type: type,\n"
	6448	" fields: []EnumField,\n"
	6449	" defs: []Definition,\n"
	6450	" };\n"
	6451	"\n"
	6452	" pub const UnionField = struct {\n"
	6453	" name: []const u8,\n"
	6454	" enum_field: ?EnumField,\n"
	6455	" field_type: type,\n"
	6456	" };\n"
	6457	"\n"
	6458	" pub const Union = struct {\n"
	6459	" layout: ContainerLayout,\n"
	6460	" tag_type: type,\n"
	6461	" fields: []UnionField,\n"
	6462	" defs: []Definition,\n"
	6463	" };\n"
	6464	"\n"
	6465	" pub const CallingConvention = enum {\n"
	6466	" Unspecified,\n"
	6467	" C,\n"
	6468	" Cold,\n"
	6469	" Naked,\n"
	6470	" Stdcall,\n"
	6471	" Async,\n"
	6472	" };\n"
	6473	"\n"
	6474	" pub const FnArg = struct {\n"
	6475	" is_generic: bool,\n"
	6476	" is_noalias: bool,\n"
	6477	" arg_type: type,\n"
	6478	" };\n"
	6479	"\n"
	6480	" pub const Fn = struct {\n"
	6481	" calling_convention: CallingConvention,\n"
	6482	" is_generic: bool,\n"
	6483	" is_var_args: bool,\n"
	6484	" return_type: type,\n"
	6485	" async_allocator_type: type,\n"
	6486	" args: []FnArg,\n"
	6487	" };\n"
	6488	"\n"
	6489	" pub const Promise = struct {\n"
	6490	" child: type,\n"
	6491	" };\n"
	6492	"\n"
	6493	" pub const Definition = struct {\n"
	6494	" name: []const u8,\n"
	6495	" is_pub: bool,\n"
	6496	" data: Data,\n"
	6497	"\n"
	6498	" pub const Data = union(enum) {\n"
	6499	" Type: type,\n"
	6500	" Var: type,\n"
	6501	" Fn: FnDef,\n"
	6502	"\n"
	6503	" pub const FnDef = struct {\n"
	6504	" fn_type: type,\n"
	6505	" inline_type: Inline,\n"
	6506	" calling_convention: CallingConvention,\n"
	6507	" is_var_args: bool,\n"
	6508	" is_extern: bool,\n"
	6509	" is_export: bool,\n"
	6510	" lib_name: ?[]const u8,\n"
	6511	" return_type: type,\n"
	6512	" arg_names: [][] const u8,\n"
	6513	"\n"
	6514	" pub const Inline = enum {\n"
	6515	" Auto,\n"
	6516	" Always,\n"
	6517	" Never,\n"
	6518	" };\n"
	6519	" };\n"
	6520	" };\n"
	6521	" };\n"
	6522	"};\n\n");
	6523	assert(ContainerLayoutAuto == 0);
	6524	assert(ContainerLayoutExtern == 1);
	6525	assert(ContainerLayoutPacked == 2);
	6526
	6527	assert(CallingConventionUnspecified == 0);
	6528	assert(CallingConventionC == 1);
	6529	assert(CallingConventionCold == 2);
	6530	assert(CallingConventionNaked == 3);
	6531	assert(CallingConventionStdcall == 4);
	6532	assert(CallingConventionAsync == 5);
	6533
	6534	assert(FnInlineAuto == 0);
	6535	assert(FnInlineAlways == 1);
	6536	assert(FnInlineNever == 2);
	6537	}
6082	6538	{
6083	6539	buf_appendf(contents,
6084	6540	"pub const FloatMode = enum {\n"
...	...	@@ -6118,7 +6574,8 @@ static void define_builtin_compile_vars(CodeGen *g) {
6118	6574	int err;
6119	6575	Buf *abs_full_path = buf_alloc();
6120	6576	if ((err = os_path_real(builtin_zig_path, abs_full_path))) {
6121		zig_panic("unable to open '%s': %s", buf_ptr(builtin_zig_path), err_str(err));
	6577	fprintf(stderr, "unable to open '%s': %s", buf_ptr(builtin_zig_path), err_str(err));
	6578	exit(1);
6122	6579	}
6123	6580
6124	6581	assert(g->root_package);
...	...	@@ -6238,7 +6695,7 @@ static void init(CodeGen *g) {
6238	6695	}
6239	6696	}
6240	6697
6241		g->have_err_ret_tracing = g->build_mode != BuildModeFastRelease;
	6698	g->have_err_ret_tracing = g->build_mode != BuildModeFastRelease && g->build_mode != BuildModeSmallRelease;
6242	6699
6243	6700	define_builtin_fns(g);
6244	6701	define_builtin_compile_vars(g);
...	...	@@ -6372,12 +6829,14 @@ static void gen_root_source(CodeGen *g) {
6372	6829	Buf *abs_full_path = buf_alloc();
6373	6830	int err;
6374	6831	if ((err = os_path_real(rel_full_path, abs_full_path))) {
6375		zig_panic("unable to open '%s': %s", buf_ptr(rel_full_path), err_str(err));
	6832	fprintf(stderr, "unable to open '%s': %s", buf_ptr(rel_full_path), err_str(err));
	6833	exit(1);
6376	6834	}
6377	6835
6378	6836	Buf *source_code = buf_alloc();
6379	6837	if ((err = os_fetch_file_path(rel_full_path, source_code, true))) {
6380		zig_panic("unable to open '%s': %s", buf_ptr(rel_full_path), err_str(err));
	6838	fprintf(stderr, "unable to open '%s': %s", buf_ptr(rel_full_path), err_str(err));
	6839	exit(1);
6381	6840	}
6382	6841
6383	6842	g->root_import = add_source_file(g, g->root_package, abs_full_path, source_code);
...	...	@@ -6930,4 +7389,3 @@ PackageTableEntry codegen_create_package(CodeGen g, const char *root_src_dir,
6930	7389	}
6931	7390	return pkg;
6932	7391	}
6933

src/ir.cpp+1745-272

...	...	@@ -110,6 +110,8 @@ static IrInstruction ir_analyze_container_field_ptr(IrAnalyze ira, Buf *field_
110	110	IrInstruction source_instr, IrInstruction container_ptr, TypeTableEntry *container_type);
111	111	static IrInstruction ir_get_var_ptr(IrAnalyze ira, IrInstruction *instruction,
112	112	VariableTableEntry *var, bool is_const_ptr, bool is_volatile_ptr);
	113	static TypeTableEntry ir_resolve_atomic_operand_type(IrAnalyze ira, IrInstruction *op);
	114	static IrInstruction ir_lval_wrap(IrBuilder irb, Scope scope, IrInstruction value, LVal lval);
113	115
114	116	ConstExprValue const_ptr_pointee(CodeGen g, ConstExprValue *const_val) {
115	117	assert(const_val->type->id == TypeTableEntryIdPointer);
...	...	@@ -143,6 +145,8 @@ static bool ir_should_inline(IrExecutable exec, Scope scope) {
143	145	while (scope != nullptr) {
144	146	if (scope->id == ScopeIdCompTime)
145	147	return true;
	148	if (scope->id == ScopeIdFnDef)
	149	break;
146	150	scope = scope->parent;
147	151	}
148	152	return false;
...	...	@@ -613,6 +617,10 @@ static constexpr IrInstructionId ir_instruction_id(IrInstructionOffsetOf *) {
613	617	return IrInstructionIdOffsetOf;
614	618	}
615	619
	620	static constexpr IrInstructionId ir_instruction_id(IrInstructionTypeInfo *) {
	621	return IrInstructionIdTypeInfo;
	622	}
	623
616	624	static constexpr IrInstructionId ir_instruction_id(IrInstructionTypeId *) {
617	625	return IrInstructionIdTypeId;
618	626	}
...	...	@@ -709,6 +717,10 @@ static constexpr IrInstructionId ir_instruction_id(IrInstructionAtomicRmw *) {
709	717	return IrInstructionIdAtomicRmw;
710	718	}
711	719
	720	static constexpr IrInstructionId ir_instruction_id(IrInstructionAtomicLoad *) {
	721	return IrInstructionIdAtomicLoad;
	722	}
	723
712	724	static constexpr IrInstructionId ir_instruction_id(IrInstructionPromiseResultType *) {
713	725	return IrInstructionIdPromiseResultType;
714	726	}
...	...	@@ -725,6 +737,18 @@ static constexpr IrInstructionId ir_instruction_id(IrInstructionAddImplicitRetur
725	737	return IrInstructionIdAddImplicitReturnType;
726	738	}
727	739
	740	static constexpr IrInstructionId ir_instruction_id(IrInstructionMergeErrRetTraces *) {
	741	return IrInstructionIdMergeErrRetTraces;
	742	}
	743
	744	static constexpr IrInstructionId ir_instruction_id(IrInstructionMarkErrRetTracePtr *) {
	745	return IrInstructionIdMarkErrRetTracePtr;
	746	}
	747
	748	static constexpr IrInstructionId ir_instruction_id(IrInstructionSqrt *) {
	749	return IrInstructionIdSqrt;
	750	}
	751
728	752	template<typename T>
729	753	static T ir_create_instruction(IrBuilder irb, Scope scope, AstNode source_node) {
730	754	T *special_instruction = allocate<T>(1);
...	...	@@ -956,25 +980,6 @@ static IrInstruction ir_build_const_c_str_lit(IrBuilder irb, Scope *scope, Ast
956	980	return &const_instruction->base;
957	981	}
958	982
959		static IrInstruction ir_build_const_promise_init(IrBuilder irb, Scope scope, AstNode source_node,
960		TypeTableEntry *return_type)
961		{
962		TypeTableEntry *struct_type = get_promise_frame_type(irb->codegen, return_type);
963
964		IrInstructionConst *const_instruction = ir_build_instruction<IrInstructionConst>(irb, scope, source_node);
965		const_instruction->base.value.type = struct_type;
966		const_instruction->base.value.special = ConstValSpecialStatic;
967		const_instruction->base.value.data.x_struct.fields = allocate<ConstExprValue>(struct_type->data.structure.src_field_count);
968		const_instruction->base.value.data.x_struct.fields[0].type = struct_type->data.structure.fields[0].type_entry;
969		const_instruction->base.value.data.x_struct.fields[0].special = ConstValSpecialStatic;
970		const_instruction->base.value.data.x_struct.fields[0].data.x_maybe = nullptr;
971		const_instruction->base.value.data.x_struct.fields[1].type = return_type;
972		const_instruction->base.value.data.x_struct.fields[1].special = ConstValSpecialUndef;
973		const_instruction->base.value.data.x_struct.fields[2].type = struct_type->data.structure.fields[2].type_entry;
974		const_instruction->base.value.data.x_struct.fields[2].special = ConstValSpecialUndef;
975		return &const_instruction->base;
976		}
977
978	983	static IrInstruction ir_build_bin_op(IrBuilder irb, Scope scope, AstNode source_node, IrBinOp op_id,
979	984	IrInstruction op1, IrInstruction op2, bool safety_check_on)
980	985	{
...	...	@@ -1035,12 +1040,27 @@ static IrInstruction ir_build_elem_ptr_from(IrBuilder irb, IrInstruction *old_
1035	1040	return new_instruction;
1036	1041	}
1037	1042
	1043	static IrInstruction ir_build_field_ptr_instruction(IrBuilder irb, Scope scope, AstNode source_node,
	1044	IrInstruction container_ptr, IrInstruction field_name_expr)
	1045	{
	1046	IrInstructionFieldPtr *instruction = ir_build_instruction<IrInstructionFieldPtr>(irb, scope, source_node);
	1047	instruction->container_ptr = container_ptr;
	1048	instruction->field_name_buffer = nullptr;
	1049	instruction->field_name_expr = field_name_expr;
	1050
	1051	ir_ref_instruction(container_ptr, irb->current_basic_block);
	1052	ir_ref_instruction(field_name_expr, irb->current_basic_block);
	1053
	1054	return &instruction->base;
	1055	}
	1056
1038	1057	static IrInstruction ir_build_field_ptr(IrBuilder irb, Scope scope, AstNode source_node,
1039	1058	IrInstruction container_ptr, Buf field_name)
1040	1059	{
1041	1060	IrInstructionFieldPtr *instruction = ir_build_instruction<IrInstructionFieldPtr>(irb, scope, source_node);
1042	1061	instruction->container_ptr = container_ptr;
1043		instruction->field_name = field_name;
	1062	instruction->field_name_buffer = field_name;
	1063	instruction->field_name_expr = nullptr;
1044	1064
1045	1065	ir_ref_instruction(container_ptr, irb->current_basic_block);
1046	1066
...	...	@@ -1835,38 +1855,34 @@ static IrInstruction ir_build_embed_file(IrBuilder irb, Scope *scope, AstNode
1835	1855	return &instruction->base;
1836	1856	}
1837	1857
1838		static IrInstruction ir_build_cmpxchg(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *ptr,
1839		IrInstruction cmp_value, IrInstruction new_value, IrInstruction success_order_value, IrInstruction failure_order_value,
1840		AtomicOrder success_order, AtomicOrder failure_order)
	1858	static IrInstruction ir_build_cmpxchg(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *type_value,
	1859	IrInstruction ptr, IrInstruction cmp_value, IrInstruction *new_value,
	1860	IrInstruction success_order_value, IrInstruction failure_order_value,
	1861	bool is_weak,
	1862	TypeTableEntry *type, AtomicOrder success_order, AtomicOrder failure_order)
1841	1863	{
1842	1864	IrInstructionCmpxchg *instruction = ir_build_instruction<IrInstructionCmpxchg>(irb, scope, source_node);
	1865	instruction->type_value = type_value;
1843	1866	instruction->ptr = ptr;
1844	1867	instruction->cmp_value = cmp_value;
1845	1868	instruction->new_value = new_value;
1846	1869	instruction->success_order_value = success_order_value;
1847	1870	instruction->failure_order_value = failure_order_value;
	1871	instruction->is_weak = is_weak;
	1872	instruction->type = type;
1848	1873	instruction->success_order = success_order;
1849	1874	instruction->failure_order = failure_order;
1850	1875
	1876	if (type_value != nullptr) ir_ref_instruction(type_value, irb->current_basic_block);
1851	1877	ir_ref_instruction(ptr, irb->current_basic_block);
1852	1878	ir_ref_instruction(cmp_value, irb->current_basic_block);
1853	1879	ir_ref_instruction(new_value, irb->current_basic_block);
1854		ir_ref_instruction(success_order_value, irb->current_basic_block);
1855		ir_ref_instruction(failure_order_value, irb->current_basic_block);
	1880	if (type_value != nullptr) ir_ref_instruction(success_order_value, irb->current_basic_block);
	1881	if (type_value != nullptr) ir_ref_instruction(failure_order_value, irb->current_basic_block);
1856	1882
1857	1883	return &instruction->base;
1858	1884	}
1859	1885
1860		static IrInstruction ir_build_cmpxchg_from(IrBuilder irb, IrInstruction old_instruction, IrInstruction ptr,
1861		IrInstruction cmp_value, IrInstruction new_value, IrInstruction success_order_value, IrInstruction failure_order_value,
1862		AtomicOrder success_order, AtomicOrder failure_order)
1863		{
1864		IrInstruction *new_instruction = ir_build_cmpxchg(irb, old_instruction->scope, old_instruction->source_node,
1865		ptr, cmp_value, new_value, success_order_value, failure_order_value, success_order, failure_order);
1866		ir_link_new_instruction(new_instruction, old_instruction);
1867		return new_instruction;
1868		}
1869
1870	1886	static IrInstruction ir_build_fence(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *order_value, AtomicOrder order) {
1871	1887	IrInstructionFence *instruction = ir_build_instruction<IrInstructionFence>(irb, scope, source_node);
1872	1888	instruction->order_value = order_value;
...	...	@@ -2430,6 +2446,16 @@ static IrInstruction ir_build_offset_of(IrBuilder irb, Scope scope, AstNode
2430	2446	return &instruction->base;
2431	2447	}
2432	2448
	2449	static IrInstruction ir_build_type_info(IrBuilder irb, Scope scope, AstNode source_node,
	2450	IrInstruction *type_value) {
	2451	IrInstructionTypeInfo *instruction = ir_build_instruction<IrInstructionTypeInfo>(irb, scope, source_node);
	2452	instruction->type_value = type_value;
	2453
	2454	ir_ref_instruction(type_value, irb->current_basic_block);
	2455
	2456	return &instruction->base;
	2457	}
	2458
2433	2459	static IrInstruction ir_build_type_id(IrBuilder irb, Scope scope, AstNode source_node,
2434	2460	IrInstruction *type_value)
2435	2461	{
...	...	@@ -2495,8 +2521,9 @@ static IrInstruction ir_build_arg_type(IrBuilder irb, Scope scope, AstNode s
2495	2521	return &instruction->base;
2496	2522	}
2497	2523
2498		static IrInstruction ir_build_error_return_trace(IrBuilder irb, Scope scope, AstNode source_node) {
	2524	static IrInstruction ir_build_error_return_trace(IrBuilder irb, Scope scope, AstNode source_node, IrInstructionErrorReturnTrace::Nullable nullable) {
2499	2525	IrInstructionErrorReturnTrace *instruction = ir_build_instruction<IrInstructionErrorReturnTrace>(irb, scope, source_node);
	2526	instruction->nullable = nullable;
2500	2527
2501	2528	return &instruction->base;
2502	2529	}
...	...	@@ -2679,6 +2706,23 @@ static IrInstruction ir_build_atomic_rmw(IrBuilder irb, Scope *scope, AstNode
2679	2706	return &instruction->base;
2680	2707	}
2681	2708
	2709	static IrInstruction ir_build_atomic_load(IrBuilder irb, Scope scope, AstNode source_node,
	2710	IrInstruction operand_type, IrInstruction ptr,
	2711	IrInstruction *ordering, AtomicOrder resolved_ordering)
	2712	{
	2713	IrInstructionAtomicLoad *instruction = ir_build_instruction<IrInstructionAtomicLoad>(irb, scope, source_node);
	2714	instruction->operand_type = operand_type;
	2715	instruction->ptr = ptr;
	2716	instruction->ordering = ordering;
	2717	instruction->resolved_ordering = resolved_ordering;
	2718
	2719	if (operand_type != nullptr) ir_ref_instruction(operand_type, irb->current_basic_block);
	2720	ir_ref_instruction(ptr, irb->current_basic_block);
	2721	if (ordering != nullptr) ir_ref_instruction(ordering, irb->current_basic_block);
	2722
	2723	return &instruction->base;
	2724	}
	2725
2682	2726	static IrInstruction ir_build_promise_result_type(IrBuilder irb, Scope scope, AstNode source_node,
2683	2727	IrInstruction *promise_type)
2684	2728	{
...	...	@@ -2717,6 +2761,41 @@ static IrInstruction ir_build_add_implicit_return_type(IrBuilder irb, Scope *s
2717	2761	return &instruction->base;
2718	2762	}
2719	2763
	2764	static IrInstruction ir_build_merge_err_ret_traces(IrBuilder irb, Scope scope, AstNode source_node,
	2765	IrInstruction coro_promise_ptr, IrInstruction src_err_ret_trace_ptr, IrInstruction *dest_err_ret_trace_ptr)
	2766	{
	2767	IrInstructionMergeErrRetTraces *instruction = ir_build_instruction<IrInstructionMergeErrRetTraces>(irb, scope, source_node);
	2768	instruction->coro_promise_ptr = coro_promise_ptr;
	2769	instruction->src_err_ret_trace_ptr = src_err_ret_trace_ptr;
	2770	instruction->dest_err_ret_trace_ptr = dest_err_ret_trace_ptr;
	2771
	2772	ir_ref_instruction(coro_promise_ptr, irb->current_basic_block);
	2773	ir_ref_instruction(src_err_ret_trace_ptr, irb->current_basic_block);
	2774	ir_ref_instruction(dest_err_ret_trace_ptr, irb->current_basic_block);
	2775
	2776	return &instruction->base;
	2777	}
	2778
	2779	static IrInstruction ir_build_mark_err_ret_trace_ptr(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction *err_ret_trace_ptr) {
	2780	IrInstructionMarkErrRetTracePtr *instruction = ir_build_instruction<IrInstructionMarkErrRetTracePtr>(irb, scope, source_node);
	2781	instruction->err_ret_trace_ptr = err_ret_trace_ptr;
	2782
	2783	ir_ref_instruction(err_ret_trace_ptr, irb->current_basic_block);
	2784
	2785	return &instruction->base;
	2786	}
	2787
	2788	static IrInstruction ir_build_sqrt(IrBuilder irb, Scope scope, AstNode source_node, IrInstruction type, IrInstruction op) {
	2789	IrInstructionSqrt *instruction = ir_build_instruction<IrInstructionSqrt>(irb, scope, source_node);
	2790	instruction->type = type;
	2791	instruction->op = op;
	2792
	2793	if (type != nullptr) ir_ref_instruction(type, irb->current_basic_block);
	2794	ir_ref_instruction(op, irb->current_basic_block);
	2795
	2796	return &instruction->base;
	2797	}
	2798
2720	2799	static void ir_count_defers(IrBuilder irb, Scope inner_scope, Scope outer_scope, size_t results) {
2721	2800	results[ReturnKindUnconditional] = 0;
2722	2801	results[ReturnKindError] = 0;
...	...	@@ -2741,9 +2820,10 @@ static IrInstruction ir_mark_gen(IrInstruction instruction) {
2741	2820
2742	2821	static bool ir_gen_defers_for_block(IrBuilder irb, Scope inner_scope, Scope *outer_scope, bool gen_error_defers) {
2743	2822	Scope *scope = inner_scope;
	2823	bool is_noreturn = false;
2744	2824	while (scope != outer_scope) {
2745	2825	if (!scope)
2746		return false;
	2826	return is_noreturn;
2747	2827
2748	2828	if (scope->id == ScopeIdDefer) {
2749	2829	AstNode *defer_node = scope->source_node;
...	...	@@ -2756,14 +2836,18 @@ static bool ir_gen_defers_for_block(IrBuilder irb, Scope inner_scope, Scope *o
2756	2836	Scope *defer_expr_scope = defer_node->data.defer.expr_scope;
2757	2837	IrInstruction *defer_expr_value = ir_gen_node(irb, defer_expr_node, defer_expr_scope);
2758	2838	if (defer_expr_value != irb->codegen->invalid_instruction) {
2759		ir_mark_gen(ir_build_check_statement_is_void(irb, defer_expr_scope, defer_expr_node, defer_expr_value));
	2839	if (defer_expr_value->value.type != nullptr && defer_expr_value->value.type->id == TypeTableEntryIdUnreachable) {
	2840	is_noreturn = true;
	2841	} else {
	2842	ir_mark_gen(ir_build_check_statement_is_void(irb, defer_expr_scope, defer_expr_node, defer_expr_value));
	2843	}
2760	2844	}
2761	2845	}
2762	2846
2763	2847	}
2764	2848	scope = scope->parent;
2765	2849	}
2766		return true;
	2850	return is_noreturn;
2767	2851	}
2768	2852
2769	2853	static void ir_set_cursor_at_end(IrBuilder irb, IrBasicBlock basic_block) {
...	...	@@ -2777,6 +2861,18 @@ static void ir_set_cursor_at_end_and_append_block(IrBuilder irb, IrBasicBlock
2777	2861	ir_set_cursor_at_end(irb, basic_block);
2778	2862	}
2779	2863
	2864	static ScopeSuspend get_scope_suspend(Scope scope) {
	2865	while (scope) {
	2866	if (scope->id == ScopeIdSuspend)
	2867	return (ScopeSuspend *)scope;
	2868	if (scope->id == ScopeIdFnDef)
	2869	return nullptr;
	2870
	2871	scope = scope->parent;
	2872	}
	2873	return nullptr;
	2874	}
	2875
2780	2876	static ScopeDeferExpr get_scope_defer_expr(Scope scope) {
2781	2877	while (scope) {
2782	2878	if (scope->id == ScopeIdDeferExpr)
...	...	@@ -2822,34 +2918,6 @@ static IrInstruction ir_gen_async_return(IrBuilder irb, Scope *scope, AstNode
2822	2918	// the above blocks are rendered by ir_gen after the rest of codegen
2823	2919	}
2824	2920
2825		static bool exec_have_err_ret_trace(CodeGen g, IrExecutable exec) {
2826		if (!g->have_err_ret_tracing)
2827		return false;
2828		FnTableEntry *fn_entry = exec_fn_entry(exec);
2829		if (fn_entry == nullptr)
2830		return false;
2831		if (exec->is_inline)
2832		return false;
2833		return type_can_fail(fn_entry->type_entry->data.fn.fn_type_id.return_type);
2834		}
2835
2836		static void ir_gen_save_err_ret_addr(IrBuilder irb, Scope scope, AstNode *node) {
2837		if (!exec_have_err_ret_trace(irb->codegen, irb->exec))
2838		return;
2839
2840		bool is_async = exec_is_async(irb->exec);
2841
2842		if (is_async) {
2843		//IrInstruction *err_ret_addr_ptr = ir_build_load_ptr(irb, scope, node, irb->exec->coro_err_ret_addr_ptr);
2844		//IrInstruction *return_address_ptr = ir_build_instr_addr(irb, scope, node);
2845		//IrInstruction *return_address_usize = ir_build_ptr_to_int(irb, scope, node, return_address_ptr);
2846		//ir_build_store_ptr(irb, scope, node, err_ret_addr_ptr, return_address_usize);
2847		return;
2848		}
2849
2850		ir_build_save_err_ret_addr(irb, scope, node);
2851		}
2852
2853	2921	static IrInstruction ir_gen_return(IrBuilder irb, Scope scope, AstNode node, LVal lval) {
2854	2922	assert(node->type == NodeTypeReturnExpr);
2855	2923
...	...	@@ -2895,8 +2963,9 @@ static IrInstruction ir_gen_return(IrBuilder irb, Scope scope, AstNode node,
2895	2963
2896	2964	IrInstruction *is_err = ir_build_test_err(irb, scope, node, return_value);
2897	2965
	2966	bool should_inline = ir_should_inline(irb->exec, scope);
2898	2967	IrInstruction *is_comptime;
2899		if (ir_should_inline(irb->exec, scope)) {
	2968	if (should_inline) {
2900	2969	is_comptime = ir_build_const_bool(irb, scope, node, true);
2901	2970	} else {
2902	2971	is_comptime = ir_build_test_comptime(irb, scope, node, is_err);
...	...	@@ -2909,7 +2978,9 @@ static IrInstruction ir_gen_return(IrBuilder irb, Scope scope, AstNode node,
2909	2978	if (have_err_defers) {
2910	2979	ir_gen_defers_for_block(irb, scope, outer_scope, true);
2911	2980	}
2912		ir_gen_save_err_ret_addr(irb, scope, node);
	2981	if (irb->codegen->have_err_ret_tracing && !should_inline) {
	2982	ir_build_save_err_ret_addr(irb, scope, node);
	2983	}
2913	2984	ir_build_br(irb, scope, node, ret_stmt_block, is_comptime);
2914	2985
2915	2986	ir_set_cursor_at_end_and_append_block(irb, ok_block);
...	...	@@ -2938,7 +3009,8 @@ static IrInstruction ir_gen_return(IrBuilder irb, Scope scope, AstNode node,
2938	3009	IrBasicBlock *return_block = ir_create_basic_block(irb, scope, "ErrRetReturn");
2939	3010	IrBasicBlock *continue_block = ir_create_basic_block(irb, scope, "ErrRetContinue");
2940	3011	IrInstruction *is_comptime;
2941		if (ir_should_inline(irb->exec, scope)) {
	3012	bool should_inline = ir_should_inline(irb->exec, scope);
	3013	if (should_inline) {
2942	3014	is_comptime = ir_build_const_bool(irb, scope, node, true);
2943	3015	} else {
2944	3016	is_comptime = ir_build_test_comptime(irb, scope, node, is_err_val);
...	...	@@ -2946,10 +3018,13 @@ static IrInstruction ir_gen_return(IrBuilder irb, Scope scope, AstNode node,
2946	3018	ir_mark_gen(ir_build_cond_br(irb, scope, node, is_err_val, return_block, continue_block, is_comptime));
2947	3019
2948	3020	ir_set_cursor_at_end_and_append_block(irb, return_block);
2949		ir_gen_defers_for_block(irb, scope, outer_scope, true);
2950		IrInstruction *err_val = ir_build_unwrap_err_code(irb, scope, node, err_union_ptr);
2951		ir_gen_save_err_ret_addr(irb, scope, node);
2952		ir_gen_async_return(irb, scope, node, err_val, false);
	3021	if (!ir_gen_defers_for_block(irb, scope, outer_scope, true)) {
	3022	IrInstruction *err_val = ir_build_unwrap_err_code(irb, scope, node, err_union_ptr);
	3023	if (irb->codegen->have_err_ret_tracing && !should_inline) {
	3024	ir_build_save_err_ret_addr(irb, scope, node);
	3025	}
	3026	ir_gen_async_return(irb, scope, node, err_val, false);
	3027	}
2953	3028
2954	3029	ir_set_cursor_at_end_and_append_block(irb, continue_block);
2955	3030	IrInstruction *unwrapped_ptr = ir_build_unwrap_err_payload(irb, scope, node, err_union_ptr, false);
...	...	@@ -3088,6 +3163,9 @@ static IrInstruction ir_gen_block(IrBuilder irb, Scope *parent_scope, AstNode
3088	3163	if (block_node->data.block.name == nullptr \|\| incoming_blocks.length == 0) {
3089	3164	return noreturn_return_value;
3090	3165	}
	3166
	3167	ir_set_cursor_at_end_and_append_block(irb, scope_block->end_block);
	3168	return ir_build_phi(irb, parent_scope, block_node, incoming_blocks.length, incoming_blocks.items, incoming_values.items);
3091	3169	} else {
3092	3170	incoming_blocks.append(irb->current_basic_block);
3093	3171	incoming_values.append(ir_mark_gen(ir_build_const_void(irb, parent_scope, block_node)));
...	...	@@ -3481,7 +3559,7 @@ static IrInstruction ir_gen_array_access(IrBuilder irb, Scope *scope, AstNode
3481	3559	return ir_build_load_ptr(irb, scope, node, ptr_instruction);
3482	3560	}
3483	3561
3484		static IrInstruction ir_gen_field_access(IrBuilder irb, Scope scope, AstNode node, LVal lval) {
	3562	static IrInstruction ir_gen_field_access(IrBuilder irb, Scope scope, AstNode node) {
3485	3563	assert(node->type == NodeTypeFieldAccessExpr);
3486	3564
3487	3565	AstNode *container_ref_node = node->data.field_access_expr.struct_expr;
...	...	@@ -3491,11 +3569,7 @@ static IrInstruction ir_gen_field_access(IrBuilder irb, Scope *scope, AstNode
3491	3569	if (container_ref_instruction == irb->codegen->invalid_instruction)
3492	3570	return container_ref_instruction;
3493	3571
3494		IrInstruction *ptr_instruction = ir_build_field_ptr(irb, scope, node, container_ref_instruction, field_name);
3495		if (lval.is_ptr)
3496		return ptr_instruction;
3497
3498		return ir_build_load_ptr(irb, scope, node, ptr_instruction);
	3572	return ir_build_field_ptr(irb, scope, node, container_ref_instruction, field_name);
3499	3573	}
3500	3574
3501	3575	static IrInstruction ir_gen_overflow_op(IrBuilder irb, Scope scope, AstNode node, IrOverflowOp op) {
...	...	@@ -3526,7 +3600,7 @@ static IrInstruction ir_gen_overflow_op(IrBuilder irb, Scope scope, AstNode
3526	3600	return ir_build_overflow_op(irb, scope, node, op, type_value, op1, op2, result_ptr, nullptr);
3527	3601	}
3528	3602
3529		static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope scope, AstNode node) {
	3603	static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope scope, AstNode node, LVal lval) {
3530	3604	assert(node->type == NodeTypeFnCallExpr);
3531	3605
3532	3606	AstNode *fn_ref_expr = node->data.fn_call_expr.fn_ref_expr;
...	...	@@ -3558,7 +3632,9 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
3558	3632	IrInstruction *arg = ir_gen_node(irb, arg_node, scope);
3559	3633	if (arg == irb->codegen->invalid_instruction)
3560	3634	return arg;
3561		return ir_build_typeof(irb, scope, node, arg);
	3635
	3636	IrInstruction *type_of = ir_build_typeof(irb, scope, node, arg);
	3637	return ir_lval_wrap(irb, scope, type_of, lval);
3562	3638	}
3563	3639	case BuiltinFnIdSetCold:
3564	3640	{
...	...	@@ -3567,7 +3643,8 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
3567	3643	if (arg0_value == irb->codegen->invalid_instruction)
3568	3644	return arg0_value;
3569	3645
3570		return ir_build_set_cold(irb, scope, node, arg0_value);
	3646	IrInstruction *set_cold = ir_build_set_cold(irb, scope, node, arg0_value);
	3647	return ir_lval_wrap(irb, scope, set_cold, lval);
3571	3648	}
3572	3649	case BuiltinFnIdSetRuntimeSafety:
3573	3650	{
...	...	@@ -3576,7 +3653,8 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
3576	3653	if (arg0_value == irb->codegen->invalid_instruction)
3577	3654	return arg0_value;
3578	3655
3579		return ir_build_set_runtime_safety(irb, scope, node, arg0_value);
	3656	IrInstruction *set_safety = ir_build_set_runtime_safety(irb, scope, node, arg0_value);
	3657	return ir_lval_wrap(irb, scope, set_safety, lval);
3580	3658	}
3581	3659	case BuiltinFnIdSetFloatMode:
3582	3660	{
...	...	@@ -3590,7 +3668,8 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
3590	3668	if (arg1_value == irb->codegen->invalid_instruction)
3591	3669	return arg1_value;
3592	3670
3593		return ir_build_set_float_mode(irb, scope, node, arg0_value, arg1_value);
	3671	IrInstruction *set_float_mode = ir_build_set_float_mode(irb, scope, node, arg0_value, arg1_value);
	3672	return ir_lval_wrap(irb, scope, set_float_mode, lval);
3594	3673	}
3595	3674	case BuiltinFnIdSizeof:
3596	3675	{
...	...	@@ -3599,7 +3678,8 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
3599	3678	if (arg0_value == irb->codegen->invalid_instruction)
3600	3679	return arg0_value;
3601	3680
3602		return ir_build_size_of(irb, scope, node, arg0_value);
	3681	IrInstruction *size_of = ir_build_size_of(irb, scope, node, arg0_value);
	3682	return ir_lval_wrap(irb, scope, size_of, lval);
3603	3683	}
3604	3684	case BuiltinFnIdCtz:
3605	3685	{
...	...	@@ -3608,7 +3688,8 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
3608	3688	if (arg0_value == irb->codegen->invalid_instruction)
3609	3689	return arg0_value;
3610	3690
3611		return ir_build_ctz(irb, scope, node, arg0_value);
	3691	IrInstruction *ctz = ir_build_ctz(irb, scope, node, arg0_value);
	3692	return ir_lval_wrap(irb, scope, ctz, lval);
3612	3693	}
3613	3694	case BuiltinFnIdClz:
3614	3695	{
...	...	@@ -3617,7 +3698,8 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
3617	3698	if (arg0_value == irb->codegen->invalid_instruction)
3618	3699	return arg0_value;
3619	3700
3620		return ir_build_clz(irb, scope, node, arg0_value);
	3701	IrInstruction *clz = ir_build_clz(irb, scope, node, arg0_value);
	3702	return ir_lval_wrap(irb, scope, clz, lval);
3621	3703	}
3622	3704	case BuiltinFnIdImport:
3623	3705	{
...	...	@@ -3626,11 +3708,13 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
3626	3708	if (arg0_value == irb->codegen->invalid_instruction)
3627	3709	return arg0_value;
3628	3710
3629		return ir_build_import(irb, scope, node, arg0_value);
	3711	IrInstruction *import = ir_build_import(irb, scope, node, arg0_value);
	3712	return ir_lval_wrap(irb, scope, import, lval);
3630	3713	}
3631	3714	case BuiltinFnIdCImport:
3632	3715	{
3633		return ir_build_c_import(irb, scope, node);
	3716	IrInstruction *c_import = ir_build_c_import(irb, scope, node);
	3717	return ir_lval_wrap(irb, scope, c_import, lval);
3634	3718	}
3635	3719	case BuiltinFnIdCInclude:
3636	3720	{
...	...	@@ -3644,7 +3728,8 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
3644	3728	return irb->codegen->invalid_instruction;
3645	3729	}
3646	3730
3647		return ir_build_c_include(irb, scope, node, arg0_value);
	3731	IrInstruction *c_include = ir_build_c_include(irb, scope, node, arg0_value);
	3732	return ir_lval_wrap(irb, scope, c_include, lval);
3648	3733	}
3649	3734	case BuiltinFnIdCDefine:
3650	3735	{
...	...	@@ -3663,7 +3748,8 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
3663	3748	return irb->codegen->invalid_instruction;
3664	3749	}
3665	3750
3666		return ir_build_c_define(irb, scope, node, arg0_value, arg1_value);
	3751	IrInstruction *c_define = ir_build_c_define(irb, scope, node, arg0_value, arg1_value);
	3752	return ir_lval_wrap(irb, scope, c_define, lval);
3667	3753	}
3668	3754	case BuiltinFnIdCUndef:
3669	3755	{
...	...	@@ -3677,7 +3763,8 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
3677	3763	return irb->codegen->invalid_instruction;
3678	3764	}
3679	3765
3680		return ir_build_c_undef(irb, scope, node, arg0_value);
	3766	IrInstruction *c_undef = ir_build_c_undef(irb, scope, node, arg0_value);
	3767	return ir_lval_wrap(irb, scope, c_undef, lval);
3681	3768	}
3682	3769	case BuiltinFnIdMaxValue:
3683	3770	{
...	...	@@ -3686,7 +3773,8 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
3686	3773	if (arg0_value == irb->codegen->invalid_instruction)
3687	3774	return arg0_value;
3688	3775
3689		return ir_build_max_value(irb, scope, node, arg0_value);
	3776	IrInstruction *max_value = ir_build_max_value(irb, scope, node, arg0_value);
	3777	return ir_lval_wrap(irb, scope, max_value, lval);
3690	3778	}
3691	3779	case BuiltinFnIdMinValue:
3692	3780	{
...	...	@@ -3695,7 +3783,8 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
3695	3783	if (arg0_value == irb->codegen->invalid_instruction)
3696	3784	return arg0_value;
3697	3785
3698		return ir_build_min_value(irb, scope, node, arg0_value);
	3786	IrInstruction *min_value = ir_build_min_value(irb, scope, node, arg0_value);
	3787	return ir_lval_wrap(irb, scope, min_value, lval);
3699	3788	}
3700	3789	case BuiltinFnIdCompileErr:
3701	3790	{
...	...	@@ -3704,7 +3793,8 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
3704	3793	if (arg0_value == irb->codegen->invalid_instruction)
3705	3794	return arg0_value;
3706	3795
3707		return ir_build_compile_err(irb, scope, node, arg0_value);
	3796	IrInstruction *compile_err = ir_build_compile_err(irb, scope, node, arg0_value);
	3797	return ir_lval_wrap(irb, scope, compile_err, lval);
3708	3798	}
3709	3799	case BuiltinFnIdCompileLog:
3710	3800	{
...	...	@@ -3717,7 +3807,8 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
3717	3807	return irb->codegen->invalid_instruction;
3718	3808	}
3719	3809
3720		return ir_build_compile_log(irb, scope, node, actual_param_count, args);
	3810	IrInstruction *compile_log = ir_build_compile_log(irb, scope, node, actual_param_count, args);
	3811	return ir_lval_wrap(irb, scope, compile_log, lval);
3721	3812	}
3722	3813	case BuiltinFnIdErrName:
3723	3814	{
...	...	@@ -3726,7 +3817,8 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
3726	3817	if (arg0_value == irb->codegen->invalid_instruction)
3727	3818	return arg0_value;
3728	3819
3729		return ir_build_err_name(irb, scope, node, arg0_value);
	3820	IrInstruction *err_name = ir_build_err_name(irb, scope, node, arg0_value);
	3821	return ir_lval_wrap(irb, scope, err_name, lval);
3730	3822	}
3731	3823	case BuiltinFnIdEmbedFile:
3732	3824	{
...	...	@@ -3735,9 +3827,11 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
3735	3827	if (arg0_value == irb->codegen->invalid_instruction)
3736	3828	return arg0_value;
3737	3829
3738		return ir_build_embed_file(irb, scope, node, arg0_value);
	3830	IrInstruction *embed_file = ir_build_embed_file(irb, scope, node, arg0_value);
	3831	return ir_lval_wrap(irb, scope, embed_file, lval);
3739	3832	}
3740		case BuiltinFnIdCmpExchange:
	3833	case BuiltinFnIdCmpxchgWeak:
	3834	case BuiltinFnIdCmpxchgStrong:
3741	3835	{
3742	3836	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
3743	3837	IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
...	...	@@ -3764,9 +3858,15 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
3764	3858	if (arg4_value == irb->codegen->invalid_instruction)
3765	3859	return arg4_value;
3766	3860
3767		return ir_build_cmpxchg(irb, scope, node, arg0_value, arg1_value,
3768		arg2_value, arg3_value, arg4_value,
3769		AtomicOrderUnordered, AtomicOrderUnordered);
	3861	AstNode *arg5_node = node->data.fn_call_expr.params.at(5);
	3862	IrInstruction *arg5_value = ir_gen_node(irb, arg5_node, scope);
	3863	if (arg5_value == irb->codegen->invalid_instruction)
	3864	return arg5_value;
	3865
	3866	IrInstruction *cmpxchg = ir_build_cmpxchg(irb, scope, node, arg0_value, arg1_value,
	3867	arg2_value, arg3_value, arg4_value, arg5_value, (builtin_fn->id == BuiltinFnIdCmpxchgWeak),
	3868	nullptr, AtomicOrderUnordered, AtomicOrderUnordered);
	3869	return ir_lval_wrap(irb, scope, cmpxchg, lval);
3770	3870	}
3771	3871	case BuiltinFnIdFence:
3772	3872	{
...	...	@@ -3775,7 +3875,8 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
3775	3875	if (arg0_value == irb->codegen->invalid_instruction)
3776	3876	return arg0_value;
3777	3877
3778		return ir_build_fence(irb, scope, node, arg0_value, AtomicOrderUnordered);
	3878	IrInstruction *fence = ir_build_fence(irb, scope, node, arg0_value, AtomicOrderUnordered);
	3879	return ir_lval_wrap(irb, scope, fence, lval);
3779	3880	}
3780	3881	case BuiltinFnIdDivExact:
3781	3882	{
...	...	@@ -3789,7 +3890,8 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
3789	3890	if (arg1_value == irb->codegen->invalid_instruction)
3790	3891	return arg1_value;
3791	3892
3792		return ir_build_bin_op(irb, scope, node, IrBinOpDivExact, arg0_value, arg1_value, true);
	3893	IrInstruction *bin_op = ir_build_bin_op(irb, scope, node, IrBinOpDivExact, arg0_value, arg1_value, true);
	3894	return ir_lval_wrap(irb, scope, bin_op, lval);
3793	3895	}
3794	3896	case BuiltinFnIdDivTrunc:
3795	3897	{
...	...	@@ -3803,7 +3905,8 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
3803	3905	if (arg1_value == irb->codegen->invalid_instruction)
3804	3906	return arg1_value;
3805	3907
3806		return ir_build_bin_op(irb, scope, node, IrBinOpDivTrunc, arg0_value, arg1_value, true);
	3908	IrInstruction *bin_op = ir_build_bin_op(irb, scope, node, IrBinOpDivTrunc, arg0_value, arg1_value, true);
	3909	return ir_lval_wrap(irb, scope, bin_op, lval);
3807	3910	}
3808	3911	case BuiltinFnIdDivFloor:
3809	3912	{
...	...	@@ -3817,7 +3920,8 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
3817	3920	if (arg1_value == irb->codegen->invalid_instruction)
3818	3921	return arg1_value;
3819	3922
3820		return ir_build_bin_op(irb, scope, node, IrBinOpDivFloor, arg0_value, arg1_value, true);
	3923	IrInstruction *bin_op = ir_build_bin_op(irb, scope, node, IrBinOpDivFloor, arg0_value, arg1_value, true);
	3924	return ir_lval_wrap(irb, scope, bin_op, lval);
3821	3925	}
3822	3926	case BuiltinFnIdRem:
3823	3927	{
...	...	@@ -3831,7 +3935,8 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
3831	3935	if (arg1_value == irb->codegen->invalid_instruction)
3832	3936	return arg1_value;
3833	3937
3834		return ir_build_bin_op(irb, scope, node, IrBinOpRemRem, arg0_value, arg1_value, true);
	3938	IrInstruction *bin_op = ir_build_bin_op(irb, scope, node, IrBinOpRemRem, arg0_value, arg1_value, true);
	3939	return ir_lval_wrap(irb, scope, bin_op, lval);
3835	3940	}
3836	3941	case BuiltinFnIdMod:
3837	3942	{
...	...	@@ -3845,7 +3950,23 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
3845	3950	if (arg1_value == irb->codegen->invalid_instruction)
3846	3951	return arg1_value;
3847	3952
3848		return ir_build_bin_op(irb, scope, node, IrBinOpRemMod, arg0_value, arg1_value, true);
	3953	IrInstruction *bin_op = ir_build_bin_op(irb, scope, node, IrBinOpRemMod, arg0_value, arg1_value, true);
	3954	return ir_lval_wrap(irb, scope, bin_op, lval);
	3955	}
	3956	case BuiltinFnIdSqrt:
	3957	{
	3958	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
	3959	IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
	3960	if (arg0_value == irb->codegen->invalid_instruction)
	3961	return arg0_value;
	3962
	3963	AstNode *arg1_node = node->data.fn_call_expr.params.at(1);
	3964	IrInstruction *arg1_value = ir_gen_node(irb, arg1_node, scope);
	3965	if (arg1_value == irb->codegen->invalid_instruction)
	3966	return arg1_value;
	3967
	3968	IrInstruction *ir_sqrt = ir_build_sqrt(irb, scope, node, arg0_value, arg1_value);
	3969	return ir_lval_wrap(irb, scope, ir_sqrt, lval);
3849	3970	}
3850	3971	case BuiltinFnIdTruncate:
3851	3972	{
...	...	@@ -3859,7 +3980,8 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
3859	3980	if (arg1_value == irb->codegen->invalid_instruction)
3860	3981	return arg1_value;
3861	3982
3862		return ir_build_truncate(irb, scope, node, arg0_value, arg1_value);
	3983	IrInstruction *truncate = ir_build_truncate(irb, scope, node, arg0_value, arg1_value);
	3984	return ir_lval_wrap(irb, scope, truncate, lval);
3863	3985	}
3864	3986	case BuiltinFnIdIntType:
3865	3987	{
...	...	@@ -3873,7 +3995,8 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
3873	3995	if (arg1_value == irb->codegen->invalid_instruction)
3874	3996	return arg1_value;
3875	3997
3876		return ir_build_int_type(irb, scope, node, arg0_value, arg1_value);
	3998	IrInstruction *int_type = ir_build_int_type(irb, scope, node, arg0_value, arg1_value);
	3999	return ir_lval_wrap(irb, scope, int_type, lval);
3877	4000	}
3878	4001	case BuiltinFnIdMemcpy:
3879	4002	{
...	...	@@ -3892,7 +4015,8 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
3892	4015	if (arg2_value == irb->codegen->invalid_instruction)
3893	4016	return arg2_value;
3894	4017
3895		return ir_build_memcpy(irb, scope, node, arg0_value, arg1_value, arg2_value);
	4018	IrInstruction *ir_memcpy = ir_build_memcpy(irb, scope, node, arg0_value, arg1_value, arg2_value);
	4019	return ir_lval_wrap(irb, scope, ir_memcpy, lval);
3896	4020	}
3897	4021	case BuiltinFnIdMemset:
3898	4022	{
...	...	@@ -3911,7 +4035,8 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
3911	4035	if (arg2_value == irb->codegen->invalid_instruction)
3912	4036	return arg2_value;
3913	4037
3914		return ir_build_memset(irb, scope, node, arg0_value, arg1_value, arg2_value);
	4038	IrInstruction *ir_memset = ir_build_memset(irb, scope, node, arg0_value, arg1_value, arg2_value);
	4039	return ir_lval_wrap(irb, scope, ir_memset, lval);
3915	4040	}
3916	4041	case BuiltinFnIdMemberCount:
3917	4042	{
...	...	@@ -3920,7 +4045,8 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
3920	4045	if (arg0_value == irb->codegen->invalid_instruction)
3921	4046	return arg0_value;
3922	4047
3923		return ir_build_member_count(irb, scope, node, arg0_value);
	4048	IrInstruction *member_count = ir_build_member_count(irb, scope, node, arg0_value);
	4049	return ir_lval_wrap(irb, scope, member_count, lval);
3924	4050	}
3925	4051	case BuiltinFnIdMemberType:
3926	4052	{
...	...	@@ -3935,7 +4061,8 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
3935	4061	return arg1_value;
3936	4062
3937	4063
3938		return ir_build_member_type(irb, scope, node, arg0_value, arg1_value);
	4064	IrInstruction *member_type = ir_build_member_type(irb, scope, node, arg0_value, arg1_value);
	4065	return ir_lval_wrap(irb, scope, member_type, lval);
3939	4066	}
3940	4067	case BuiltinFnIdMemberName:
3941	4068	{
...	...	@@ -3950,14 +4077,44 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
3950	4077	return arg1_value;
3951	4078
3952	4079
3953		return ir_build_member_name(irb, scope, node, arg0_value, arg1_value);
	4080	IrInstruction *member_name = ir_build_member_name(irb, scope, node, arg0_value, arg1_value);
	4081	return ir_lval_wrap(irb, scope, member_name, lval);
	4082	}
	4083	case BuiltinFnIdField:
	4084	{
	4085	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
	4086	IrInstruction *arg0_value = ir_gen_node_extra(irb, arg0_node, scope, LVAL_PTR);
	4087	if (arg0_value == irb->codegen->invalid_instruction)
	4088	return arg0_value;
	4089
	4090	AstNode *arg1_node = node->data.fn_call_expr.params.at(1);
	4091	IrInstruction *arg1_value = ir_gen_node(irb, arg1_node, scope);
	4092	if (arg1_value == irb->codegen->invalid_instruction)
	4093	return arg1_value;
	4094
	4095	IrInstruction *ptr_instruction = ir_build_field_ptr_instruction(irb, scope, node, arg0_value, arg1_value);
	4096
	4097	if (lval.is_ptr)
	4098	return ptr_instruction;
	4099
	4100	return ir_build_load_ptr(irb, scope, node, ptr_instruction);
	4101	}
	4102	case BuiltinFnIdTypeInfo:
	4103	{
	4104	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
	4105	IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
	4106	if (arg0_value == irb->codegen->invalid_instruction)
	4107	return arg0_value;
	4108
	4109	IrInstruction *type_info = ir_build_type_info(irb, scope, node, arg0_value);
	4110	return ir_lval_wrap(irb, scope, type_info, lval);
3954	4111	}
3955	4112	case BuiltinFnIdBreakpoint:
3956		return ir_build_breakpoint(irb, scope, node);
	4113	return ir_lval_wrap(irb, scope, ir_build_breakpoint(irb, scope, node), lval);
3957	4114	case BuiltinFnIdReturnAddress:
3958		return ir_build_return_address(irb, scope, node);
	4115	return ir_lval_wrap(irb, scope, ir_build_return_address(irb, scope, node), lval);
3959	4116	case BuiltinFnIdFrameAddress:
3960		return ir_build_frame_address(irb, scope, node);
	4117	return ir_lval_wrap(irb, scope, ir_build_frame_address(irb, scope, node), lval);
3961	4118	case BuiltinFnIdAlignOf:
3962	4119	{
3963	4120	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
...	...	@@ -3965,16 +4122,17 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
3965	4122	if (arg0_value == irb->codegen->invalid_instruction)
3966	4123	return arg0_value;
3967	4124
3968		return ir_build_align_of(irb, scope, node, arg0_value);
	4125	IrInstruction *align_of = ir_build_align_of(irb, scope, node, arg0_value);
	4126	return ir_lval_wrap(irb, scope, align_of, lval);
3969	4127	}
3970	4128	case BuiltinFnIdAddWithOverflow:
3971		return ir_gen_overflow_op(irb, scope, node, IrOverflowOpAdd);
	4129	return ir_lval_wrap(irb, scope, ir_gen_overflow_op(irb, scope, node, IrOverflowOpAdd), lval);
3972	4130	case BuiltinFnIdSubWithOverflow:
3973		return ir_gen_overflow_op(irb, scope, node, IrOverflowOpSub);
	4131	return ir_lval_wrap(irb, scope, ir_gen_overflow_op(irb, scope, node, IrOverflowOpSub), lval);
3974	4132	case BuiltinFnIdMulWithOverflow:
3975		return ir_gen_overflow_op(irb, scope, node, IrOverflowOpMul);
	4133	return ir_lval_wrap(irb, scope, ir_gen_overflow_op(irb, scope, node, IrOverflowOpMul), lval);
3976	4134	case BuiltinFnIdShlWithOverflow:
3977		return ir_gen_overflow_op(irb, scope, node, IrOverflowOpShl);
	4135	return ir_lval_wrap(irb, scope, ir_gen_overflow_op(irb, scope, node, IrOverflowOpShl), lval);
3978	4136	case BuiltinFnIdTypeName:
3979	4137	{
3980	4138	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
...	...	@@ -3982,7 +4140,8 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
3982	4140	if (arg0_value == irb->codegen->invalid_instruction)
3983	4141	return arg0_value;
3984	4142
3985		return ir_build_type_name(irb, scope, node, arg0_value);
	4143	IrInstruction *type_name = ir_build_type_name(irb, scope, node, arg0_value);
	4144	return ir_lval_wrap(irb, scope, type_name, lval);
3986	4145	}
3987	4146	case BuiltinFnIdCanImplicitCast:
3988	4147	{
...	...	@@ -3996,7 +4155,8 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
3996	4155	if (arg1_value == irb->codegen->invalid_instruction)
3997	4156	return arg1_value;
3998	4157
3999		return ir_build_can_implicit_cast(irb, scope, node, arg0_value, arg1_value);
	4158	IrInstruction *can_implicit_cast = ir_build_can_implicit_cast(irb, scope, node, arg0_value, arg1_value);
	4159	return ir_lval_wrap(irb, scope, can_implicit_cast, lval);
4000	4160	}
4001	4161	case BuiltinFnIdPanic:
4002	4162	{
...	...	@@ -4005,7 +4165,8 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
4005	4165	if (arg0_value == irb->codegen->invalid_instruction)
4006	4166	return arg0_value;
4007	4167
4008		return ir_build_panic(irb, scope, node, arg0_value);
	4168	IrInstruction *panic = ir_build_panic(irb, scope, node, arg0_value);
	4169	return ir_lval_wrap(irb, scope, panic, lval);
4009	4170	}
4010	4171	case BuiltinFnIdPtrCast:
4011	4172	{
...	...	@@ -4019,7 +4180,8 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
4019	4180	if (arg1_value == irb->codegen->invalid_instruction)
4020	4181	return arg1_value;
4021	4182
4022		return ir_build_ptr_cast(irb, scope, node, arg0_value, arg1_value);
	4183	IrInstruction *ptr_cast = ir_build_ptr_cast(irb, scope, node, arg0_value, arg1_value);
	4184	return ir_lval_wrap(irb, scope, ptr_cast, lval);
4023	4185	}
4024	4186	case BuiltinFnIdBitCast:
4025	4187	{
...	...	@@ -4033,7 +4195,8 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
4033	4195	if (arg1_value == irb->codegen->invalid_instruction)
4034	4196	return arg1_value;
4035	4197
4036		return ir_build_bit_cast(irb, scope, node, arg0_value, arg1_value);
	4198	IrInstruction *bit_cast = ir_build_bit_cast(irb, scope, node, arg0_value, arg1_value);
	4199	return ir_lval_wrap(irb, scope, bit_cast, lval);
4037	4200	}
4038	4201	case BuiltinFnIdIntToPtr:
4039	4202	{
...	...	@@ -4047,7 +4210,8 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
4047	4210	if (arg1_value == irb->codegen->invalid_instruction)
4048	4211	return arg1_value;
4049	4212
4050		return ir_build_int_to_ptr(irb, scope, node, arg0_value, arg1_value);
	4213	IrInstruction *int_to_ptr = ir_build_int_to_ptr(irb, scope, node, arg0_value, arg1_value);
	4214	return ir_lval_wrap(irb, scope, int_to_ptr, lval);
4051	4215	}
4052	4216	case BuiltinFnIdPtrToInt:
4053	4217	{
...	...	@@ -4056,7 +4220,8 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
4056	4220	if (arg0_value == irb->codegen->invalid_instruction)
4057	4221	return arg0_value;
4058	4222
4059		return ir_build_ptr_to_int(irb, scope, node, arg0_value);
	4223	IrInstruction *ptr_to_int = ir_build_ptr_to_int(irb, scope, node, arg0_value);
	4224	return ir_lval_wrap(irb, scope, ptr_to_int, lval);
4060	4225	}
4061	4226	case BuiltinFnIdTagName:
4062	4227	{
...	...	@@ -4066,7 +4231,8 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
4066	4231	return arg0_value;
4067	4232
4068	4233	IrInstruction *actual_tag = ir_build_union_tag(irb, scope, node, arg0_value);
4069		return ir_build_tag_name(irb, scope, node, actual_tag);
	4234	IrInstruction *tag_name = ir_build_tag_name(irb, scope, node, actual_tag);
	4235	return ir_lval_wrap(irb, scope, tag_name, lval);
4070	4236	}
4071	4237	case BuiltinFnIdTagType:
4072	4238	{
...	...	@@ -4075,7 +4241,8 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
4075	4241	if (arg0_value == irb->codegen->invalid_instruction)
4076	4242	return arg0_value;
4077	4243
4078		return ir_build_tag_type(irb, scope, node, arg0_value);
	4244	IrInstruction *tag_type = ir_build_tag_type(irb, scope, node, arg0_value);
	4245	return ir_lval_wrap(irb, scope, tag_type, lval);
4079	4246	}
4080	4247	case BuiltinFnIdFieldParentPtr:
4081	4248	{
...	...	@@ -4094,7 +4261,8 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
4094	4261	if (arg2_value == irb->codegen->invalid_instruction)
4095	4262	return arg2_value;
4096	4263
4097		return ir_build_field_parent_ptr(irb, scope, node, arg0_value, arg1_value, arg2_value, nullptr);
	4264	IrInstruction *field_parent_ptr = ir_build_field_parent_ptr(irb, scope, node, arg0_value, arg1_value, arg2_value, nullptr);
	4265	return ir_lval_wrap(irb, scope, field_parent_ptr, lval);
4098	4266	}
4099	4267	case BuiltinFnIdOffsetOf:
4100	4268	{
...	...	@@ -4108,7 +4276,8 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
4108	4276	if (arg1_value == irb->codegen->invalid_instruction)
4109	4277	return arg1_value;
4110	4278
4111		return ir_build_offset_of(irb, scope, node, arg0_value, arg1_value);
	4279	IrInstruction *offset_of = ir_build_offset_of(irb, scope, node, arg0_value, arg1_value);
	4280	return ir_lval_wrap(irb, scope, offset_of, lval);
4112	4281	}
4113	4282	case BuiltinFnIdInlineCall:
4114	4283	case BuiltinFnIdNoInlineCall:
...	...	@@ -4134,7 +4303,8 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
4134	4303	}
4135	4304	FnInline fn_inline = (builtin_fn->id == BuiltinFnIdInlineCall) ? FnInlineAlways : FnInlineNever;
4136	4305
4137		return ir_build_call(irb, scope, node, nullptr, fn_ref, arg_count, args, false, fn_inline, false, nullptr);
	4306	IrInstruction *call = ir_build_call(irb, scope, node, nullptr, fn_ref, arg_count, args, false, fn_inline, false, nullptr);
	4307	return ir_lval_wrap(irb, scope, call, lval);
4138	4308	}
4139	4309	case BuiltinFnIdTypeId:
4140	4310	{
...	...	@@ -4143,7 +4313,8 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
4143	4313	if (arg0_value == irb->codegen->invalid_instruction)
4144	4314	return arg0_value;
4145	4315
4146		return ir_build_type_id(irb, scope, node, arg0_value);
	4316	IrInstruction *type_id = ir_build_type_id(irb, scope, node, arg0_value);
	4317	return ir_lval_wrap(irb, scope, type_id, lval);
4147	4318	}
4148	4319	case BuiltinFnIdShlExact:
4149	4320	{
...	...	@@ -4157,7 +4328,8 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
4157	4328	if (arg1_value == irb->codegen->invalid_instruction)
4158	4329	return arg1_value;
4159	4330
4160		return ir_build_bin_op(irb, scope, node, IrBinOpBitShiftLeftExact, arg0_value, arg1_value, true);
	4331	IrInstruction *bin_op = ir_build_bin_op(irb, scope, node, IrBinOpBitShiftLeftExact, arg0_value, arg1_value, true);
	4332	return ir_lval_wrap(irb, scope, bin_op, lval);
4161	4333	}
4162	4334	case BuiltinFnIdShrExact:
4163	4335	{
...	...	@@ -4171,7 +4343,8 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
4171	4343	if (arg1_value == irb->codegen->invalid_instruction)
4172	4344	return arg1_value;
4173	4345
4174		return ir_build_bin_op(irb, scope, node, IrBinOpBitShiftRightExact, arg0_value, arg1_value, true);
	4346	IrInstruction *bin_op = ir_build_bin_op(irb, scope, node, IrBinOpBitShiftRightExact, arg0_value, arg1_value, true);
	4347	return ir_lval_wrap(irb, scope, bin_op, lval);
4175	4348	}
4176	4349	case BuiltinFnIdSetEvalBranchQuota:
4177	4350	{
...	...	@@ -4180,7 +4353,8 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
4180	4353	if (arg0_value == irb->codegen->invalid_instruction)
4181	4354	return arg0_value;
4182	4355
4183		return ir_build_set_eval_branch_quota(irb, scope, node, arg0_value);
	4356	IrInstruction *set_eval_branch_quota = ir_build_set_eval_branch_quota(irb, scope, node, arg0_value);
	4357	return ir_lval_wrap(irb, scope, set_eval_branch_quota, lval);
4184	4358	}
4185	4359	case BuiltinFnIdAlignCast:
4186	4360	{
...	...	@@ -4194,10 +4368,14 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
4194	4368	if (arg1_value == irb->codegen->invalid_instruction)
4195	4369	return arg1_value;
4196	4370
4197		return ir_build_align_cast(irb, scope, node, arg0_value, arg1_value);
	4371	IrInstruction *align_cast = ir_build_align_cast(irb, scope, node, arg0_value, arg1_value);
	4372	return ir_lval_wrap(irb, scope, align_cast, lval);
4198	4373	}
4199	4374	case BuiltinFnIdOpaqueType:
4200		return ir_build_opaque_type(irb, scope, node);
	4375	{
	4376	IrInstruction *opaque_type = ir_build_opaque_type(irb, scope, node);
	4377	return ir_lval_wrap(irb, scope, opaque_type, lval);
	4378	}
4201	4379	case BuiltinFnIdSetAlignStack:
4202	4380	{
4203	4381	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
...	...	@@ -4205,7 +4383,8 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
4205	4383	if (arg0_value == irb->codegen->invalid_instruction)
4206	4384	return arg0_value;
4207	4385
4208		return ir_build_set_align_stack(irb, scope, node, arg0_value);
	4386	IrInstruction *set_align_stack = ir_build_set_align_stack(irb, scope, node, arg0_value);
	4387	return ir_lval_wrap(irb, scope, set_align_stack, lval);
4209	4388	}
4210	4389	case BuiltinFnIdArgType:
4211	4390	{
...	...	@@ -4219,7 +4398,8 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
4219	4398	if (arg1_value == irb->codegen->invalid_instruction)
4220	4399	return arg1_value;
4221	4400
4222		return ir_build_arg_type(irb, scope, node, arg0_value, arg1_value);
	4401	IrInstruction *arg_type = ir_build_arg_type(irb, scope, node, arg0_value, arg1_value);
	4402	return ir_lval_wrap(irb, scope, arg_type, lval);
4223	4403	}
4224	4404	case BuiltinFnIdExport:
4225	4405	{
...	...	@@ -4238,11 +4418,13 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
4238	4418	if (arg2_value == irb->codegen->invalid_instruction)
4239	4419	return arg2_value;
4240	4420
4241		return ir_build_export(irb, scope, node, arg0_value, arg1_value, arg2_value);
	4421	IrInstruction *ir_export = ir_build_export(irb, scope, node, arg0_value, arg1_value, arg2_value);
	4422	return ir_lval_wrap(irb, scope, ir_export, lval);
4242	4423	}
4243	4424	case BuiltinFnIdErrorReturnTrace:
4244	4425	{
4245		return ir_build_error_return_trace(irb, scope, node);
	4426	IrInstruction *error_return_trace = ir_build_error_return_trace(irb, scope, node, IrInstructionErrorReturnTrace::Null);
	4427	return ir_lval_wrap(irb, scope, error_return_trace, lval);
4246	4428	}
4247	4429	case BuiltinFnIdAtomicRmw:
4248	4430	{
...	...	@@ -4276,15 +4458,36 @@ static IrInstruction ir_gen_builtin_fn_call(IrBuilder irb, Scope *scope, AstNo
4276	4458	// these 2 values don't mean anything since we passed non-null values for other args
4277	4459	AtomicRmwOp_xchg, AtomicOrderMonotonic);
4278	4460	}
	4461	case BuiltinFnIdAtomicLoad:
	4462	{
	4463	AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
	4464	IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
	4465	if (arg0_value == irb->codegen->invalid_instruction)
	4466	return arg0_value;
	4467
	4468	AstNode *arg1_node = node->data.fn_call_expr.params.at(1);
	4469	IrInstruction *arg1_value = ir_gen_node(irb, arg1_node, scope);
	4470	if (arg1_value == irb->codegen->invalid_instruction)
	4471	return arg1_value;
	4472
	4473	AstNode *arg2_node = node->data.fn_call_expr.params.at(2);
	4474	IrInstruction *arg2_value = ir_gen_node(irb, arg2_node, scope);
	4475	if (arg2_value == irb->codegen->invalid_instruction)
	4476	return arg2_value;
	4477
	4478	return ir_build_atomic_load(irb, scope, node, arg0_value, arg1_value, arg2_value,
	4479	// this value does not mean anything since we passed non-null values for other arg
	4480	AtomicOrderMonotonic);
	4481	}
4279	4482	}
4280	4483	zig_unreachable();
4281	4484	}
4282	4485
4283		static IrInstruction ir_gen_fn_call(IrBuilder irb, Scope scope, AstNode node) {
	4486	static IrInstruction ir_gen_fn_call(IrBuilder irb, Scope scope, AstNode node, LVal lval) {
4284	4487	assert(node->type == NodeTypeFnCallExpr);
4285	4488
4286	4489	if (node->data.fn_call_expr.is_builtin)
4287		return ir_gen_builtin_fn_call(irb, scope, node);
	4490	return ir_gen_builtin_fn_call(irb, scope, node, lval);
4288	4491
4289	4492	AstNode *fn_ref_node = node->data.fn_call_expr.fn_ref_expr;
4290	4493	IrInstruction *fn_ref = ir_gen_node(irb, fn_ref_node, scope);
...	...	@@ -4310,7 +4513,8 @@ static IrInstruction ir_gen_fn_call(IrBuilder irb, Scope scope, AstNode node
4310	4513	}
4311	4514	}
4312	4515
4313		return ir_build_call(irb, scope, node, nullptr, fn_ref, arg_count, args, false, FnInlineAuto, is_async, async_allocator);
	4516	IrInstruction *fn_call = ir_build_call(irb, scope, node, nullptr, fn_ref, arg_count, args, false, FnInlineAuto, is_async, async_allocator);
	4517	return ir_lval_wrap(irb, scope, fn_call, lval);
4314	4518	}
4315	4519
4316	4520	static IrInstruction ir_gen_if_bool_expr(IrBuilder irb, Scope scope, AstNode node) {
...	...	@@ -5593,6 +5797,15 @@ static IrInstruction ir_gen_return_from_block(IrBuilder irb, Scope *break_scop
5593	5797	return ir_build_br(irb, break_scope, node, dest_block, is_comptime);
5594	5798	}
5595	5799
	5800	static IrInstruction ir_gen_break_from_suspend(IrBuilder irb, Scope break_scope, AstNode node, ScopeSuspend *suspend_scope) {
	5801	IrInstruction *is_comptime = ir_build_const_bool(irb, break_scope, node, false);
	5802
	5803	IrBasicBlock *dest_block = suspend_scope->resume_block;
	5804	ir_gen_defers_for_block(irb, break_scope, dest_block->scope, false);
	5805
	5806	return ir_build_br(irb, break_scope, node, dest_block, is_comptime);
	5807	}
	5808
5596	5809	static IrInstruction ir_gen_break(IrBuilder irb, Scope break_scope, AstNode node) {
5597	5810	assert(node->type == NodeTypeBreak);
5598	5811
...	...	@@ -5632,6 +5845,13 @@ static IrInstruction ir_gen_break(IrBuilder irb, Scope break_scope, AstNode
5632	5845	assert(this_block_scope->end_block != nullptr);
5633	5846	return ir_gen_return_from_block(irb, break_scope, node, this_block_scope);
5634	5847	}
	5848	} else if (search_scope->id == ScopeIdSuspend) {
	5849	ScopeSuspend this_suspend_scope = (ScopeSuspend )search_scope;
	5850	if (node->data.break_expr.name != nullptr &&
	5851	(this_suspend_scope->name != nullptr && buf_eql_buf(node->data.break_expr.name, this_suspend_scope->name)))
	5852	{
	5853	return ir_gen_break_from_suspend(irb, break_scope, node, this_suspend_scope);
	5854	}
5635	5855	}
5636	5856	search_scope = search_scope->parent;
5637	5857	}
...	...	@@ -5703,7 +5923,7 @@ static IrInstruction ir_gen_continue(IrBuilder irb, Scope *continue_scope, Ast
5703	5923
5704	5924	IrBasicBlock *dest_block = loop_scope->continue_block;
5705	5925	ir_gen_defers_for_block(irb, continue_scope, dest_block->scope, false);
5706		return ir_build_br(irb, continue_scope, node, dest_block, is_comptime);
	5926	return ir_mark_gen(ir_build_br(irb, continue_scope, node, dest_block, is_comptime));
5707	5927	}
5708	5928
5709	5929	static IrInstruction ir_gen_error_type(IrBuilder irb, Scope scope, AstNode node) {
...	...	@@ -5972,16 +6192,10 @@ static IrInstruction ir_gen_err_set_decl(IrBuilder irb, Scope *parent_scope, A
5972	6192	buf_init_from_buf(&err_set_type->name, type_name);
5973	6193	err_set_type->is_copyable = true;
5974	6194	err_set_type->data.error_set.err_count = err_count;
5975
5976		if (err_count == 0) {
5977		err_set_type->zero_bits = true;
5978		err_set_type->di_type = irb->codegen->builtin_types.entry_void->di_type;
5979		} else {
5980		err_set_type->type_ref = irb->codegen->builtin_types.entry_global_error_set->type_ref;
5981		err_set_type->di_type = irb->codegen->builtin_types.entry_global_error_set->di_type;
5982		irb->codegen->error_di_types.append(&err_set_type->di_type);
5983		err_set_type->data.error_set.errors = allocate<ErrorTableEntry *>(err_count);
5984		}
	6195	err_set_type->type_ref = irb->codegen->builtin_types.entry_global_error_set->type_ref;
	6196	err_set_type->di_type = irb->codegen->builtin_types.entry_global_error_set->di_type;
	6197	irb->codegen->error_di_types.append(&err_set_type->di_type);
	6198	err_set_type->data.error_set.errors = allocate<ErrorTableEntry *>(err_count);
5985	6199
5986	6200	ErrorTableEntry *errors = allocate<ErrorTableEntry >(irb->codegen->errors_by_index.length + err_count);
5987	6201
...	...	@@ -6125,6 +6339,13 @@ static IrInstruction ir_gen_await_expr(IrBuilder irb, Scope *parent_scope, Ast
6125	6339	Buf *result_ptr_field_name = buf_create_from_str(RESULT_PTR_FIELD_NAME);
6126	6340	IrInstruction *result_ptr_field_ptr = ir_build_field_ptr(irb, parent_scope, node, coro_promise_ptr, result_ptr_field_name);
6127	6341
	6342	if (irb->codegen->have_err_ret_tracing) {
	6343	IrInstruction *err_ret_trace_ptr = ir_build_error_return_trace(irb, parent_scope, node, IrInstructionErrorReturnTrace::NonNull);
	6344	Buf *err_ret_trace_ptr_field_name = buf_create_from_str(ERR_RET_TRACE_PTR_FIELD_NAME);
	6345	IrInstruction *err_ret_trace_ptr_field_ptr = ir_build_field_ptr(irb, parent_scope, node, coro_promise_ptr, err_ret_trace_ptr_field_name);
	6346	ir_build_store_ptr(irb, parent_scope, node, err_ret_trace_ptr_field_ptr, err_ret_trace_ptr);
	6347	}
	6348
6128	6349	Buf *awaiter_handle_field_name = buf_create_from_str(AWAITER_HANDLE_FIELD_NAME);
6129	6350	IrInstruction *awaiter_field_ptr = ir_build_field_ptr(irb, parent_scope, node, coro_promise_ptr,
6130	6351	awaiter_handle_field_name);
...	...	@@ -6148,10 +6369,16 @@ static IrInstruction ir_gen_await_expr(IrBuilder irb, Scope *parent_scope, Ast
6148	6369	IrInstruction *is_non_null = ir_build_test_nonnull(irb, parent_scope, node, maybe_await_handle);
6149	6370	IrBasicBlock *yes_suspend_block = ir_create_basic_block(irb, parent_scope, "YesSuspend");
6150	6371	IrBasicBlock *no_suspend_block = ir_create_basic_block(irb, parent_scope, "NoSuspend");
6151		IrBasicBlock *merge_block = ir_create_basic_block(irb, parent_scope, "Merge");
	6372	IrBasicBlock *merge_block = ir_create_basic_block(irb, parent_scope, "MergeSuspend");
6152	6373	ir_build_cond_br(irb, parent_scope, node, is_non_null, no_suspend_block, yes_suspend_block, const_bool_false);
6153	6374
6154	6375	ir_set_cursor_at_end_and_append_block(irb, no_suspend_block);
	6376	if (irb->codegen->have_err_ret_tracing) {
	6377	Buf *err_ret_trace_field_name = buf_create_from_str(ERR_RET_TRACE_FIELD_NAME);
	6378	IrInstruction *src_err_ret_trace_ptr = ir_build_field_ptr(irb, parent_scope, node, coro_promise_ptr, err_ret_trace_field_name);
	6379	IrInstruction *dest_err_ret_trace_ptr = ir_build_error_return_trace(irb, parent_scope, node, IrInstructionErrorReturnTrace::NonNull);
	6380	ir_build_merge_err_ret_traces(irb, parent_scope, node, coro_promise_ptr, src_err_ret_trace_ptr, dest_err_ret_trace_ptr);
	6381	}
6155	6382	Buf *result_field_name = buf_create_from_str(RESULT_FIELD_NAME);
6156	6383	IrInstruction *promise_result_ptr = ir_build_field_ptr(irb, parent_scope, node, coro_promise_ptr, result_field_name);
6157	6384	IrInstruction *no_suspend_result = ir_build_load_ptr(irb, parent_scope, node, promise_result_ptr);
...	...	@@ -6173,7 +6400,7 @@ static IrInstruction ir_gen_await_expr(IrBuilder irb, Scope *parent_scope, Ast
6173	6400
6174	6401	ir_set_cursor_at_end_and_append_block(irb, cleanup_block);
6175	6402	ir_gen_defers_for_block(irb, parent_scope, outer_scope, true);
6176		ir_build_br(irb, parent_scope, node, irb->exec->coro_final_cleanup_block, const_bool_false);
	6403	ir_mark_gen(ir_build_br(irb, parent_scope, node, irb->exec->coro_final_cleanup_block, const_bool_false));
6177	6404
6178	6405	ir_set_cursor_at_end_and_append_block(irb, resume_block);
6179	6406	IrInstruction *yes_suspend_result = ir_build_load_ptr(irb, parent_scope, node, my_result_var_ptr);
...	...	@@ -6205,14 +6432,26 @@ static IrInstruction ir_gen_suspend(IrBuilder irb, Scope *parent_scope, AstNod
6205	6432	ScopeDeferExpr *scope_defer_expr = get_scope_defer_expr(parent_scope);
6206	6433	if (scope_defer_expr) {
6207	6434	if (!scope_defer_expr->reported_err) {
6208		add_node_error(irb->codegen, node, buf_sprintf("cannot suspend inside defer expression"));
	6435	ErrorMsg *msg = add_node_error(irb->codegen, node, buf_sprintf("cannot suspend inside defer expression"));
	6436	add_error_note(irb->codegen, msg, scope_defer_expr->base.source_node, buf_sprintf("defer here"));
6209	6437	scope_defer_expr->reported_err = true;
6210	6438	}
6211	6439	return irb->codegen->invalid_instruction;
6212	6440	}
	6441	ScopeSuspend *existing_suspend_scope = get_scope_suspend(parent_scope);
	6442	if (existing_suspend_scope) {
	6443	if (!existing_suspend_scope->reported_err) {
	6444	ErrorMsg *msg = add_node_error(irb->codegen, node, buf_sprintf("cannot suspend inside suspend block"));
	6445	add_error_note(irb->codegen, msg, existing_suspend_scope->base.source_node, buf_sprintf("other suspend block here"));
	6446	existing_suspend_scope->reported_err = true;
	6447	}
	6448	return irb->codegen->invalid_instruction;
	6449	}
6213	6450
6214	6451	Scope *outer_scope = irb->exec->begin_scope;
6215	6452
	6453	IrBasicBlock *cleanup_block = ir_create_basic_block(irb, parent_scope, "SuspendCleanup");
	6454	IrBasicBlock *resume_block = ir_create_basic_block(irb, parent_scope, "SuspendResume");
6216	6455
6217	6456	IrInstruction *suspend_code;
6218	6457	IrInstruction *const_bool_false = ir_build_const_bool(irb, parent_scope, node, false);
...	...	@@ -6231,28 +6470,28 @@ static IrInstruction ir_gen_suspend(IrBuilder irb, Scope *parent_scope, AstNod
6231	6470	} else {
6232	6471	child_scope = parent_scope;
6233	6472	}
	6473	ScopeSuspend *suspend_scope = create_suspend_scope(node, child_scope);
	6474	suspend_scope->resume_block = resume_block;
	6475	child_scope = &suspend_scope->base;
6234	6476	IrInstruction *save_token = ir_build_coro_save(irb, child_scope, node, irb->exec->coro_handle);
6235	6477	ir_gen_node(irb, node->data.suspend.block, child_scope);
6236		suspend_code = ir_build_coro_suspend(irb, parent_scope, node, save_token, const_bool_false);
	6478	suspend_code = ir_mark_gen(ir_build_coro_suspend(irb, parent_scope, node, save_token, const_bool_false));
6237	6479	}
6238	6480
6239		IrBasicBlock *cleanup_block = ir_create_basic_block(irb, parent_scope, "SuspendCleanup");
6240		IrBasicBlock *resume_block = ir_create_basic_block(irb, parent_scope, "SuspendResume");
6241
6242	6481	IrInstructionSwitchBrCase *cases = allocate<IrInstructionSwitchBrCase>(2);
6243		cases[0].value = ir_build_const_u8(irb, parent_scope, node, 0);
	6482	cases[0].value = ir_mark_gen(ir_build_const_u8(irb, parent_scope, node, 0));
6244	6483	cases[0].block = resume_block;
6245		cases[1].value = ir_build_const_u8(irb, parent_scope, node, 1);
	6484	cases[1].value = ir_mark_gen(ir_build_const_u8(irb, parent_scope, node, 1));
6246	6485	cases[1].block = cleanup_block;
6247		ir_build_switch_br(irb, parent_scope, node, suspend_code, irb->exec->coro_suspend_block,
6248		2, cases, const_bool_false);
	6486	ir_mark_gen(ir_build_switch_br(irb, parent_scope, node, suspend_code, irb->exec->coro_suspend_block,
	6487	2, cases, const_bool_false));
6249	6488
6250	6489	ir_set_cursor_at_end_and_append_block(irb, cleanup_block);
6251	6490	ir_gen_defers_for_block(irb, parent_scope, outer_scope, true);
6252		ir_build_br(irb, parent_scope, node, irb->exec->coro_final_cleanup_block, const_bool_false);
	6491	ir_mark_gen(ir_build_br(irb, parent_scope, node, irb->exec->coro_final_cleanup_block, const_bool_false));
6253	6492
6254	6493	ir_set_cursor_at_end_and_append_block(irb, resume_block);
6255		return ir_build_const_void(irb, parent_scope, node);
	6494	return ir_mark_gen(ir_build_const_void(irb, parent_scope, node));
6256	6495	}
6257	6496
6258	6497	static IrInstruction ir_gen_node_raw(IrBuilder irb, AstNode node, Scope scope,
...	...	@@ -6268,7 +6507,6 @@ static IrInstruction ir_gen_node_raw(IrBuilder irb, AstNode node, Scope scop
6268	6507	case NodeTypeSwitchRange:
6269	6508	case NodeTypeStructField:
6270	6509	case NodeTypeFnDef:
6271		case NodeTypeFnDecl:
6272	6510	case NodeTypeTestDecl:
6273	6511	zig_unreachable();
6274	6512	case NodeTypeBlock:
...	...	@@ -6286,7 +6524,7 @@ static IrInstruction ir_gen_node_raw(IrBuilder irb, AstNode node, Scope scop
6286	6524	case NodeTypeSymbol:
6287	6525	return ir_gen_symbol(irb, scope, node, lval);
6288	6526	case NodeTypeFnCallExpr:
6289		return ir_lval_wrap(irb, scope, ir_gen_fn_call(irb, scope, node), lval);
	6527	return ir_gen_fn_call(irb, scope, node, lval);
6290	6528	case NodeTypeIfBoolExpr:
6291	6529	return ir_lval_wrap(irb, scope, ir_gen_if_bool_expr(irb, scope, node), lval);
6292	6530	case NodeTypePrefixOpExpr:
...	...	@@ -6306,7 +6544,15 @@ static IrInstruction ir_gen_node_raw(IrBuilder irb, AstNode node, Scope scop
6306	6544	case NodeTypeReturnExpr:
6307	6545	return ir_gen_return(irb, scope, node, lval);
6308	6546	case NodeTypeFieldAccessExpr:
6309		return ir_gen_field_access(irb, scope, node, lval);
	6547	{
	6548	IrInstruction *ptr_instruction = ir_gen_field_access(irb, scope, node);
	6549	if (ptr_instruction == irb->codegen->invalid_instruction)
	6550	return ptr_instruction;
	6551	if (lval.is_ptr)
	6552	return ptr_instruction;
	6553
	6554	return ir_build_load_ptr(irb, scope, node, ptr_instruction);
	6555	}
6310	6556	case NodeTypeThisLiteral:
6311	6557	return ir_lval_wrap(irb, scope, ir_gen_this_literal(irb, scope, node), lval);
6312	6558	case NodeTypeBoolLiteral:
...	...	@@ -6407,6 +6653,8 @@ bool ir_gen(CodeGen codegen, AstNode node, Scope scope, IrExecutable ir_exec
6407	6653	IrInstruction *coro_id;
6408	6654	IrInstruction *u8_ptr_type;
6409	6655	IrInstruction *const_bool_false;
	6656	IrInstruction *coro_promise_ptr;
	6657	IrInstruction *err_ret_trace_ptr;
6410	6658	TypeTableEntry *return_type;
6411	6659	Buf *result_ptr_field_name;
6412	6660	VariableTableEntry *coro_size_var;
...	...	@@ -6417,9 +6665,12 @@ bool ir_gen(CodeGen codegen, AstNode node, Scope scope, IrExecutable ir_exec
6417	6665	VariableTableEntry *promise_var = ir_create_var(irb, node, coro_scope, nullptr, false, false, true, const_bool_false);
6418	6666
6419	6667	return_type = fn_entry->type_entry->data.fn.fn_type_id.return_type;
6420		IrInstruction *promise_init = ir_build_const_promise_init(irb, coro_scope, node, return_type);
6421		ir_build_var_decl(irb, coro_scope, node, promise_var, nullptr, nullptr, promise_init);
6422		IrInstruction *coro_promise_ptr = ir_build_var_ptr(irb, coro_scope, node, promise_var, false, false);
	6668	IrInstruction *undef = ir_build_const_undefined(irb, coro_scope, node);
	6669	TypeTableEntry *coro_frame_type = get_promise_frame_type(irb->codegen, return_type);
	6670	IrInstruction *coro_frame_type_value = ir_build_const_type(irb, coro_scope, node, coro_frame_type);
	6671	// TODO mark this var decl as "no safety" e.g. disable initializing the undef value to 0xaa
	6672	ir_build_var_decl(irb, coro_scope, node, promise_var, coro_frame_type_value, nullptr, undef);
	6673	coro_promise_ptr = ir_build_var_ptr(irb, coro_scope, node, promise_var, false, false);
6423	6674
6424	6675	VariableTableEntry *await_handle_var = ir_create_var(irb, node, coro_scope, nullptr, false, false, true, const_bool_false);
6425	6676	IrInstruction *null_value = ir_build_const_null(irb, coro_scope, node);
...	...	@@ -6452,7 +6703,6 @@ bool ir_gen(CodeGen codegen, AstNode node, Scope scope, IrExecutable ir_exec
6452	6703	ir_set_cursor_at_end_and_append_block(irb, alloc_err_block);
6453	6704	// we can return undefined here, because the caller passes a pointer to the error struct field
6454	6705	// in the error union result, and we populate it in case of allocation failure.
6455		IrInstruction *undef = ir_build_const_undefined(irb, coro_scope, node);
6456	6706	ir_build_return(irb, coro_scope, node, undef);
6457	6707
6458	6708	ir_set_cursor_at_end_and_append_block(irb, alloc_ok_block);
...	...	@@ -6460,13 +6710,35 @@ bool ir_gen(CodeGen codegen, AstNode node, Scope scope, IrExecutable ir_exec
6460	6710	irb->exec->coro_handle = ir_build_coro_begin(irb, coro_scope, node, coro_id, coro_mem_ptr);
6461	6711
6462	6712	Buf *awaiter_handle_field_name = buf_create_from_str(AWAITER_HANDLE_FIELD_NAME);
6463		irb->exec->coro_awaiter_field_ptr = ir_build_field_ptr(irb, coro_scope, node, coro_promise_ptr,
	6713	irb->exec->coro_awaiter_field_ptr = ir_build_field_ptr(irb, scope, node, coro_promise_ptr,
6464	6714	awaiter_handle_field_name);
	6715	ir_build_store_ptr(irb, scope, node, irb->exec->coro_awaiter_field_ptr, null_value);
6465	6716	Buf *result_field_name = buf_create_from_str(RESULT_FIELD_NAME);
6466		irb->exec->coro_result_field_ptr = ir_build_field_ptr(irb, coro_scope, node, coro_promise_ptr, result_field_name);
	6717	irb->exec->coro_result_field_ptr = ir_build_field_ptr(irb, scope, node, coro_promise_ptr, result_field_name);
6467	6718	result_ptr_field_name = buf_create_from_str(RESULT_PTR_FIELD_NAME);
6468		irb->exec->coro_result_ptr_field_ptr = ir_build_field_ptr(irb, coro_scope, node, coro_promise_ptr, result_ptr_field_name);
6469		ir_build_store_ptr(irb, coro_scope, node, irb->exec->coro_result_ptr_field_ptr, irb->exec->coro_result_field_ptr);
	6719	irb->exec->coro_result_ptr_field_ptr = ir_build_field_ptr(irb, scope, node, coro_promise_ptr, result_ptr_field_name);
	6720	ir_build_store_ptr(irb, scope, node, irb->exec->coro_result_ptr_field_ptr, irb->exec->coro_result_field_ptr);
	6721	if (irb->codegen->have_err_ret_tracing) {
	6722	// initialize the error return trace
	6723	Buf *return_addresses_field_name = buf_create_from_str(RETURN_ADDRESSES_FIELD_NAME);
	6724	IrInstruction *return_addresses_ptr = ir_build_field_ptr(irb, scope, node, coro_promise_ptr, return_addresses_field_name);
	6725
	6726	Buf *err_ret_trace_field_name = buf_create_from_str(ERR_RET_TRACE_FIELD_NAME);
	6727	err_ret_trace_ptr = ir_build_field_ptr(irb, scope, node, coro_promise_ptr, err_ret_trace_field_name);
	6728	ir_build_mark_err_ret_trace_ptr(irb, scope, node, err_ret_trace_ptr);
	6729
	6730	// coordinate with builtin.zig
	6731	Buf *index_name = buf_create_from_str("index");
	6732	IrInstruction *index_ptr = ir_build_field_ptr(irb, scope, node, err_ret_trace_ptr, index_name);
	6733	IrInstruction *zero = ir_build_const_usize(irb, scope, node, 0);
	6734	ir_build_store_ptr(irb, scope, node, index_ptr, zero);
	6735
	6736	Buf *instruction_addresses_name = buf_create_from_str("instruction_addresses");
	6737	IrInstruction *addrs_slice_ptr = ir_build_field_ptr(irb, scope, node, err_ret_trace_ptr, instruction_addresses_name);
	6738
	6739	IrInstruction *slice_value = ir_build_slice(irb, scope, node, return_addresses_ptr, zero, nullptr, false);
	6740	ir_build_store_ptr(irb, scope, node, addrs_slice_ptr, slice_value);
	6741	}
6470	6742
6471	6743
6472	6744	irb->exec->coro_early_final = ir_create_basic_block(irb, scope, "CoroEarlyFinal");
...	...	@@ -6517,6 +6789,12 @@ bool ir_gen(CodeGen codegen, AstNode node, Scope scope, IrExecutable ir_exec
6517	6789	IrInstruction *size_of_ret_val = ir_build_size_of(irb, scope, node, return_type_inst);
6518	6790	ir_build_memcpy(irb, scope, node, result_ptr_as_u8_ptr, return_value_ptr_as_u8_ptr, size_of_ret_val);
6519	6791	}
	6792	if (irb->codegen->have_err_ret_tracing) {
	6793	Buf *err_ret_trace_ptr_field_name = buf_create_from_str(ERR_RET_TRACE_PTR_FIELD_NAME);
	6794	IrInstruction *err_ret_trace_ptr_field_ptr = ir_build_field_ptr(irb, scope, node, coro_promise_ptr, err_ret_trace_ptr_field_name);
	6795	IrInstruction *dest_err_ret_trace_ptr = ir_build_load_ptr(irb, scope, node, err_ret_trace_ptr_field_ptr);
	6796	ir_build_merge_err_ret_traces(irb, scope, node, coro_promise_ptr, err_ret_trace_ptr, dest_err_ret_trace_ptr);
	6797	}
6520	6798	ir_build_br(irb, scope, node, check_free_block, const_bool_false);
6521	6799
6522	6800	ir_set_cursor_at_end_and_append_block(irb, irb->exec->coro_final_cleanup_block);
...	...	@@ -7859,7 +8137,7 @@ static void update_errors_helper(CodeGen g, ErrorTableEntry *errors, size_t
7859	8137	errors = reallocate(errors, old_errors_count, *errors_count);
7860	8138	}
7861	8139
7862		static TypeTableEntry ir_resolve_peer_types(IrAnalyze ira, AstNode source_node, IrInstruction *instructions, size_t instruction_count) {
	8140	static TypeTableEntry ir_resolve_peer_types(IrAnalyze ira, AstNode source_node, TypeTableEntry expected_type, IrInstruction **instructions, size_t instruction_count) {
7863	8141	assert(instruction_count >= 1);
7864	8142	IrInstruction *prev_inst = instructions[0];
7865	8143	if (type_is_invalid(prev_inst->value.type)) {
...	...	@@ -7906,16 +8184,6 @@ static TypeTableEntry ir_resolve_peer_types(IrAnalyze ira, AstNode *source_nod
7906	8184	continue;
7907	8185	}
7908	8186
7909		if (prev_type->id == TypeTableEntryIdNullLit) {
7910		prev_inst = cur_inst;
7911		continue;
7912		}
7913
7914		if (cur_type->id == TypeTableEntryIdNullLit) {
7915		any_are_null = true;
7916		continue;
7917		}
7918
7919	8187	if (prev_type->id == TypeTableEntryIdErrorSet) {
7920	8188	assert(err_set_type != nullptr);
7921	8189	if (cur_type->id == TypeTableEntryIdErrorSet) {
...	...	@@ -8175,6 +8443,16 @@ static TypeTableEntry ir_resolve_peer_types(IrAnalyze ira, AstNode *source_nod
8175	8443	}
8176	8444	}
8177	8445
	8446	if (prev_type->id == TypeTableEntryIdNullLit) {
	8447	prev_inst = cur_inst;
	8448	continue;
	8449	}
	8450
	8451	if (cur_type->id == TypeTableEntryIdNullLit) {
	8452	any_are_null = true;
	8453	continue;
	8454	}
	8455
8178	8456	if (types_match_const_cast_only(ira, prev_type, cur_type, source_node).id == ConstCastResultIdOk) {
8179	8457	continue;
8180	8458	}
...	...	@@ -8358,6 +8636,10 @@ static TypeTableEntry ir_resolve_peer_types(IrAnalyze ira, AstNode *source_nod
8358	8636	} else if (err_set_type != nullptr) {
8359	8637	if (prev_inst->value.type->id == TypeTableEntryIdErrorSet) {
8360	8638	return err_set_type;
	8639	} else if (prev_inst->value.type->id == TypeTableEntryIdErrorUnion) {
	8640	return get_error_union_type(ira->codegen, err_set_type, prev_inst->value.type->data.error_union.payload_type);
	8641	} else if (expected_type != nullptr && expected_type->id == TypeTableEntryIdErrorUnion) {
	8642	return get_error_union_type(ira->codegen, err_set_type, expected_type->data.error_union.payload_type);
8361	8643	} else {
8362	8644	if (prev_inst->value.type->id == TypeTableEntryIdNumLitInt \|\|
8363	8645	prev_inst->value.type->id == TypeTableEntryIdNumLitFloat)
...	...	@@ -8369,8 +8651,6 @@ static TypeTableEntry ir_resolve_peer_types(IrAnalyze ira, AstNode *source_nod
8369	8651	ir_add_error_node(ira, source_node,
8370	8652	buf_sprintf("unable to make error union out of null literal"));
8371	8653	return ira->codegen->builtin_types.entry_invalid;
8372		} else if (prev_inst->value.type->id == TypeTableEntryIdErrorUnion) {
8373		return get_error_union_type(ira->codegen, err_set_type, prev_inst->value.type->data.error_union.payload_type);
8374	8654	} else {
8375	8655	return get_error_union_type(ira->codegen, err_set_type, prev_inst->value.type);
8376	8656	}
...	...	@@ -10393,7 +10673,7 @@ static TypeTableEntry ir_analyze_bin_op_cmp(IrAnalyze ira, IrInstructionBinOp
10393	10673	}
10394	10674
10395	10675	IrInstruction *instructions[] = {op1, op2};
10396		TypeTableEntry *resolved_type = ir_resolve_peer_types(ira, source_node, instructions, 2);
	10676	TypeTableEntry *resolved_type = ir_resolve_peer_types(ira, source_node, nullptr, instructions, 2);
10397	10677	if (type_is_invalid(resolved_type))
10398	10678	return resolved_type;
10399	10679	type_ensure_zero_bits_known(ira->codegen, resolved_type);
...	...	@@ -10783,7 +11063,7 @@ static TypeTableEntry ir_analyze_bin_op_math(IrAnalyze ira, IrInstructionBinOp
10783	11063	IrInstruction *op1 = bin_op_instruction->op1->other;
10784	11064	IrInstruction *op2 = bin_op_instruction->op2->other;
10785	11065	IrInstruction *instructions[] = {op1, op2};
10786		TypeTableEntry *resolved_type = ir_resolve_peer_types(ira, bin_op_instruction->base.source_node, instructions, 2);
	11066	TypeTableEntry *resolved_type = ir_resolve_peer_types(ira, bin_op_instruction->base.source_node, nullptr, instructions, 2);
10787	11067	if (type_is_invalid(resolved_type))
10788	11068	return resolved_type;
10789	11069	IrBinOp op_id = bin_op_instruction->op_id;
...	...	@@ -11353,7 +11633,19 @@ static TypeTableEntry ir_analyze_instruction_decl_var(IrAnalyze ira, IrInstruc
11353	11633	}
11354	11634	break;
11355	11635	case VarClassRequiredAny:
11356		// OK
	11636	if (casted_init_value->value.special == ConstValSpecialStatic &&
	11637	casted_init_value->value.type->id == TypeTableEntryIdFn &&
	11638	casted_init_value->value.data.x_ptr.data.fn.fn_entry->fn_inline == FnInlineAlways)
	11639	{
	11640	var_class_requires_const = true;
	11641	if (!var->src_is_const && !is_comptime_var) {
	11642	ErrorMsg *msg = ir_add_error_node(ira, source_node,
	11643	buf_sprintf("functions marked inline must be stored in const or comptime var"));
	11644	AstNode *proto_node = casted_init_value->value.data.x_ptr.data.fn.fn_entry->proto_node;
	11645	add_error_note(ira->codegen, msg, proto_node, buf_sprintf("declared here"));
	11646	result_type = ira->codegen->builtin_types.entry_invalid;
	11647	}
	11648	}
11357	11649	break;
11358	11650	}
11359	11651	}
...	...	@@ -11579,18 +11871,25 @@ static bool exec_has_err_ret_trace(CodeGen g, IrExecutable exec) {
11579	11871	static TypeTableEntry ir_analyze_instruction_error_return_trace(IrAnalyze ira,
11580	11872	IrInstructionErrorReturnTrace *instruction)
11581	11873	{
11582		TypeTableEntry *ptr_to_stack_trace_type = get_ptr_to_stack_trace_type(ira->codegen);
11583		TypeTableEntry *nullable_type = get_maybe_type(ira->codegen, ptr_to_stack_trace_type);
11584		if (!exec_has_err_ret_trace(ira->codegen, ira->new_irb.exec)) {
11585		ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
11586		out_val->data.x_maybe = nullptr;
	11874	if (instruction->nullable == IrInstructionErrorReturnTrace::Null) {
	11875	TypeTableEntry *ptr_to_stack_trace_type = get_ptr_to_stack_trace_type(ira->codegen);
	11876	TypeTableEntry *nullable_type = get_maybe_type(ira->codegen, ptr_to_stack_trace_type);
	11877	if (!exec_has_err_ret_trace(ira->codegen, ira->new_irb.exec)) {
	11878	ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
	11879	out_val->data.x_maybe = nullptr;
	11880	return nullable_type;
	11881	}
	11882	IrInstruction *new_instruction = ir_build_error_return_trace(&ira->new_irb, instruction->base.scope,
	11883	instruction->base.source_node, instruction->nullable);
	11884	ir_link_new_instruction(new_instruction, &instruction->base);
11587	11885	return nullable_type;
	11886	} else {
	11887	assert(ira->codegen->have_err_ret_tracing);
	11888	IrInstruction *new_instruction = ir_build_error_return_trace(&ira->new_irb, instruction->base.scope,
	11889	instruction->base.source_node, instruction->nullable);
	11890	ir_link_new_instruction(new_instruction, &instruction->base);
	11891	return get_ptr_to_stack_trace_type(ira->codegen);
11588	11892	}
11589
11590		IrInstruction *new_instruction = ir_build_error_return_trace(&ira->new_irb, instruction->base.scope,
11591		instruction->base.source_node);
11592		ir_link_new_instruction(new_instruction, &instruction->base);
11593		return nullable_type;
11594	11893	}
11595	11894
11596	11895	static TypeTableEntry ir_analyze_instruction_error_union(IrAnalyze ira,
...	...	@@ -11755,7 +12054,8 @@ static bool ir_analyze_fn_call_generic_arg(IrAnalyze ira, AstNode fn_proto_nod
11755	12054	}
11756	12055	}
11757	12056
11758		bool comptime_arg = param_decl_node->data.param_decl.is_inline;
	12057	bool comptime_arg = param_decl_node->data.param_decl.is_inline \|\|
	12058	casted_arg->value.type->id == TypeTableEntryIdNumLitInt \|\| casted_arg->value.type->id == TypeTableEntryIdNumLitFloat;
11759	12059
11760	12060	ConstExprValue *arg_val;
11761	12061
...	...	@@ -11780,6 +12080,12 @@ static bool ir_analyze_fn_call_generic_arg(IrAnalyze ira, AstNode fn_proto_nod
11780	12080	var->shadowable = !comptime_arg;
11781	12081
11782	12082	*next_proto_i += 1;
	12083	} else if (casted_arg->value.type->id == TypeTableEntryIdNumLitInt \|\|
	12084	casted_arg->value.type->id == TypeTableEntryIdNumLitFloat)
	12085	{
	12086	ir_add_error(ira, casted_arg,
	12087	buf_sprintf("compiler bug: integer and float literals in var args function must be casted. https://github.com/zig-lang/zig/issues/557"));
	12088	return false;
11783	12089	}
11784	12090
11785	12091	if (!comptime_arg) {
...	...	@@ -12726,7 +13032,7 @@ static TypeTableEntry ir_analyze_instruction_phi(IrAnalyze ira, IrInstructionP
12726	13032	return first_value->value.type;
12727	13033	}
12728	13034
12729		TypeTableEntry *resolved_type = ir_resolve_peer_types(ira, phi_instruction->base.source_node,
	13035	TypeTableEntry *resolved_type = ir_resolve_peer_types(ira, phi_instruction->base.source_node, nullptr,
12730	13036	new_incoming_values.items, new_incoming_values.length);
12731	13037	if (type_is_invalid(resolved_type))
12732	13038	return resolved_type;
...	...	@@ -13072,6 +13378,7 @@ static IrInstruction ir_analyze_container_member_access_inner(IrAnalyze ira,
13072	13378	{
13073	13379	if (!is_slice(bare_struct_type)) {
13074	13380	ScopeDecls *container_scope = get_container_scope(bare_struct_type);
	13381	assert(container_scope != nullptr);
13075	13382	auto entry = container_scope->decl_table.maybe_get(field_name);
13076	13383	Tld *tld = entry ? entry->value : nullptr;
13077	13384	if (tld && tld->id == TldIdFn) {
...	...	@@ -13105,7 +13412,6 @@ static IrInstruction ir_analyze_container_member_access_inner(IrAnalyze ira,
13105	13412	return ira->codegen->invalid_instruction;
13106	13413	}
13107	13414
13108
13109	13415	static IrInstruction ir_analyze_container_field_ptr(IrAnalyze ira, Buf *field_name,
13110	13416	IrInstruction source_instr, IrInstruction container_ptr, TypeTableEntry *container_type)
13111	13417	{
...	...	@@ -13167,21 +13473,66 @@ static IrInstruction ir_analyze_container_field_ptr(IrAnalyze ira, Buf *field_
13167	13473	} else if (bare_type->id == TypeTableEntryIdUnion) {
13168	13474	TypeUnionField *field = find_union_type_field(bare_type, field_name);
13169	13475	if (field) {
13170		IrInstruction *result = ir_build_union_field_ptr(&ira->new_irb, source_instr->scope, source_instr->source_node, container_ptr, field);
13171		result->value.type = get_pointer_to_type_extra(ira->codegen, field->type_entry, is_const, is_volatile,
13172		get_abi_alignment(ira->codegen, field->type_entry), 0, 0);
13173		return result;
13174		} else {
13175		return ir_analyze_container_member_access_inner(ira, bare_type, field_name,
13176		source_instr, container_ptr, container_type);
13177		}
13178		} else {
13179		zig_unreachable();
13180		}
13181		}
	13476	if (instr_is_comptime(container_ptr)) {
	13477	ConstExprValue *ptr_val = ir_resolve_const(ira, container_ptr, UndefBad);
	13478	if (!ptr_val)
	13479	return ira->codegen->invalid_instruction;
13182	13480
13183		static void add_link_lib_symbol(IrAnalyze ira, Buf lib_name, Buf symbol_name, AstNode source_node) {
13184		LinkLib *link_lib = add_link_lib(ira->codegen, lib_name);
	13481	if (ptr_val->data.x_ptr.special != ConstPtrSpecialHardCodedAddr) {
	13482	ConstExprValue *union_val = const_ptr_pointee(ira->codegen, ptr_val);
	13483	if (type_is_invalid(union_val->type))
	13484	return ira->codegen->invalid_instruction;
	13485
	13486	TypeUnionField *actual_field = find_union_field_by_tag(bare_type, &union_val->data.x_union.tag);
	13487	if (actual_field == nullptr)
	13488	zig_unreachable();
	13489
	13490	if (field != actual_field) {
	13491	ir_add_error_node(ira, source_instr->source_node,
	13492	buf_sprintf("accessing union field '%s' while field '%s' is set", buf_ptr(field_name),
	13493	buf_ptr(actual_field->name)));
	13494	return ira->codegen->invalid_instruction;
	13495	}
	13496
	13497	ConstExprValue *payload_val = union_val->data.x_union.payload;
	13498
	13499	TypeTableEntry *field_type = field->type_entry;
	13500	if (field_type->id == TypeTableEntryIdVoid)
	13501	{
	13502	assert(payload_val == nullptr);
	13503	payload_val = create_const_vals(1);
	13504	payload_val->special = ConstValSpecialStatic;
	13505	payload_val->type = field_type;
	13506	}
	13507
	13508	TypeTableEntry *ptr_type = get_pointer_to_type_extra(ira->codegen, field_type, is_const, is_volatile,
	13509	get_abi_alignment(ira->codegen, field_type), 0, 0);
	13510
	13511	IrInstruction *result = ir_get_const(ira, source_instr);
	13512	ConstExprValue *const_val = &result->value;
	13513	const_val->data.x_ptr.special = ConstPtrSpecialRef;
	13514	const_val->data.x_ptr.mut = container_ptr->value.data.x_ptr.mut;
	13515	const_val->data.x_ptr.data.ref.pointee = payload_val;
	13516	const_val->type = ptr_type;
	13517	return result;
	13518	}
	13519	}
	13520
	13521	IrInstruction *result = ir_build_union_field_ptr(&ira->new_irb, source_instr->scope, source_instr->source_node, container_ptr, field);
	13522	result->value.type = get_pointer_to_type_extra(ira->codegen, field->type_entry, is_const, is_volatile,
	13523	get_abi_alignment(ira->codegen, field->type_entry), 0, 0);
	13524	return result;
	13525	} else {
	13526	return ir_analyze_container_member_access_inner(ira, bare_type, field_name,
	13527	source_instr, container_ptr, container_type);
	13528	}
	13529	} else {
	13530	zig_unreachable();
	13531	}
	13532	}
	13533
	13534	static void add_link_lib_symbol(IrAnalyze ira, Buf lib_name, Buf symbol_name, AstNode source_node) {
	13535	LinkLib *link_lib = add_link_lib(ira->codegen, lib_name);
13185	13536	for (size_t i = 0; i < link_lib->symbols.length; i += 1) {
13186	13537	Buf *existing_symbol_name = link_lib->symbols.at(i);
13187	13538	if (buf_eql_buf(existing_symbol_name, symbol_name)) {
...	...	@@ -13275,7 +13626,15 @@ static TypeTableEntry ir_analyze_instruction_field_ptr(IrAnalyze ira, IrInstru
13275	13626	zig_unreachable();
13276	13627	}
13277	13628
13278		Buf *field_name = field_ptr_instruction->field_name;
	13629	Buf *field_name = field_ptr_instruction->field_name_buffer;
	13630	if (!field_name) {
	13631	IrInstruction *field_name_expr = field_ptr_instruction->field_name_expr->other;
	13632	field_name = ir_resolve_str(ira, field_name_expr);
	13633	if (!field_name)
	13634	return ira->codegen->builtin_types.entry_invalid;
	13635	}
	13636
	13637
13279	13638	AstNode *source_node = field_ptr_instruction->base.source_node;
13280	13639
13281	13640	if (type_is_invalid(container_type)) {
...	...	@@ -13377,7 +13736,16 @@ static TypeTableEntry ir_analyze_instruction_field_ptr(IrAnalyze ira, IrInstru
13377	13736	create_const_enum(child_type, &field->value), child_type,
13378	13737	ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile);
13379	13738	}
13380		} else if (child_type->id == TypeTableEntryIdUnion &&
	13739	}
	13740	ScopeDecls *container_scope = get_container_scope(child_type);
	13741	if (container_scope != nullptr) {
	13742	auto entry = container_scope->decl_table.maybe_get(field_name);
	13743	Tld *tld = entry ? entry->value : nullptr;
	13744	if (tld) {
	13745	return ir_analyze_decl_ref(ira, &field_ptr_instruction->base, tld);
	13746	}
	13747	}
	13748	if (child_type->id == TypeTableEntryIdUnion &&
13381	13749	(child_type->data.unionation.decl_node->data.container_decl.init_arg_expr != nullptr \|\|
13382	13750	child_type->data.unionation.decl_node->data.container_decl.auto_enum))
13383	13751	{
...	...	@@ -13394,14 +13762,6 @@ static TypeTableEntry ir_analyze_instruction_field_ptr(IrAnalyze ira, IrInstru
13394	13762	ConstPtrMutComptimeConst, ptr_is_const, ptr_is_volatile);
13395	13763	}
13396	13764	}
13397		ScopeDecls *container_scope = get_container_scope(child_type);
13398		if (container_scope != nullptr) {
13399		auto entry = container_scope->decl_table.maybe_get(field_name);
13400		Tld *tld = entry ? entry->value : nullptr;
13401		if (tld) {
13402		return ir_analyze_decl_ref(ira, &field_ptr_instruction->base, tld);
13403		}
13404		}
13405	13765	ir_add_error(ira, &field_ptr_instruction->base,
13406	13766	buf_sprintf("container '%s' has no member called '%s'",
13407	13767	buf_ptr(&child_type->name), buf_ptr(field_name)));
...	...	@@ -13570,6 +13930,15 @@ static TypeTableEntry ir_analyze_instruction_field_ptr(IrAnalyze ira, IrInstru
13570	13930	}
13571	13931	} else if (child_type->id == TypeTableEntryIdFn) {
13572	13932	if (buf_eql_str(field_name, "ReturnType")) {
	13933	if (child_type->data.fn.fn_type_id.return_type == nullptr) {
	13934	// Return type can only ever be null, if the function is generic
	13935	assert(child_type->data.fn.is_generic);
	13936
	13937	ir_add_error(ira, &field_ptr_instruction->base,
	13938	buf_sprintf("ReturnType has not been resolved because '%s' is generic", buf_ptr(&child_type->name)));
	13939	return ira->codegen->builtin_types.entry_invalid;
	13940	}
	13941
13573	13942	bool ptr_is_const = true;
13574	13943	bool ptr_is_volatile = false;
13575	13944	return ir_analyze_const_ptr(ira, &field_ptr_instruction->base,
...	...	@@ -14340,7 +14709,7 @@ static IrInstruction ir_analyze_union_tag(IrAnalyze ira, IrInstruction *source
14340	14709	}
14341	14710
14342	14711	if (value->value.type->id != TypeTableEntryIdUnion) {
14343		ir_add_error(ira, source_instr,
	14712	ir_add_error(ira, value,
14344	14713	buf_sprintf("expected enum or union type, found '%s'", buf_ptr(&value->value.type->name)));
14345	14714	return ira->codegen->invalid_instruction;
14346	14715	}
...	...	@@ -14492,7 +14861,10 @@ static TypeTableEntry ir_analyze_instruction_switch_target(IrAnalyze ira,
14492	14861	return out_val->type;
14493	14862	}
14494	14863
14495		assert(target_value_ptr->value.type->id == TypeTableEntryIdPointer);
	14864	if (target_value_ptr->value.type->id != TypeTableEntryIdPointer) {
	14865	ir_add_error(ira, target_value_ptr, buf_sprintf("invalid deref on switch target"));
	14866	return ira->codegen->builtin_types.entry_invalid;
	14867	}
14496	14868
14497	14869	TypeTableEntry *target_type = target_value_ptr->value.type->data.pointer.child_type;
14498	14870	ConstExprValue *pointee_val = nullptr;
...	...	@@ -15268,6 +15640,8 @@ static TypeTableEntry ir_analyze_instruction_field_parent_ptr(IrAnalyze ira,
15268	15640	}
15269	15641
15270	15642	ensure_complete_type(ira->codegen, container_type);
	15643	if (type_is_invalid(container_type))
	15644	return ira->codegen->builtin_types.entry_invalid;
15271	15645
15272	15646	TypeStructField *field = find_struct_type_field(container_type, field_name);
15273	15647	if (field == nullptr) {
...	...	@@ -15374,6 +15748,910 @@ static TypeTableEntry ir_analyze_instruction_offset_of(IrAnalyze ira,
15374	15748	return ira->codegen->builtin_types.entry_num_lit_int;
15375	15749	}
15376	15750
	15751	static void ensure_field_index(TypeTableEntry type, const char field_name, size_t index)
	15752	{
	15753	Buf *field_name_buf;
	15754
	15755	assert(type != nullptr && !type_is_invalid(type));
	15756	// Check for our field by creating a buffer in place then using the comma operator to free it so that we don't
	15757	// leak memory in debug mode.
	15758	assert(find_struct_type_field(type, field_name_buf = buf_create_from_str(field_name))->src_index == index &&
	15759	(buf_deinit(field_name_buf), true));
	15760	}
	15761
	15762	static TypeTableEntry ir_type_info_get_type(IrAnalyze ira, const char type_name, TypeTableEntry root = nullptr)
	15763	{
	15764	static ConstExprValue *type_info_var = nullptr;
	15765	static TypeTableEntry *type_info_type = nullptr;
	15766	if (type_info_var == nullptr)
	15767	{
	15768	type_info_var = get_builtin_value(ira->codegen, "TypeInfo");
	15769	assert(type_info_var->type->id == TypeTableEntryIdMetaType);
	15770
	15771	ensure_complete_type(ira->codegen, type_info_var->data.x_type);
	15772	type_info_type = type_info_var->data.x_type;
	15773	assert(type_info_type->id == TypeTableEntryIdUnion);
	15774	}
	15775
	15776	if (type_name == nullptr && root == nullptr)
	15777	return type_info_type;
	15778	else if (type_name == nullptr)
	15779	return root;
	15780
	15781	TypeTableEntry *root_type = (root == nullptr) ? type_info_type : root;
	15782
	15783	ScopeDecls *type_info_scope = get_container_scope(root_type);
	15784	assert(type_info_scope != nullptr);
	15785
	15786	Buf field_name = BUF_INIT;
	15787	buf_init_from_str(&field_name, type_name);
	15788	auto entry = type_info_scope->decl_table.get(&field_name);
	15789	buf_deinit(&field_name);
	15790
	15791	TldVar tld = (TldVar )entry;
	15792	assert(tld->base.id == TldIdVar);
	15793
	15794	VariableTableEntry *var = tld->var;
	15795
	15796	ensure_complete_type(ira->codegen, var->value->type);
	15797	assert(var->value->type->id == TypeTableEntryIdMetaType);
	15798	return var->value->data.x_type;
	15799	}
	15800
	15801	static void ir_make_type_info_defs(IrAnalyze ira, ConstExprValue out_val, ScopeDecls *decls_scope)
	15802	{
	15803	TypeTableEntry *type_info_definition_type = ir_type_info_get_type(ira, "Definition");
	15804	ensure_complete_type(ira->codegen, type_info_definition_type);
	15805	ensure_field_index(type_info_definition_type, "name", 0);
	15806	ensure_field_index(type_info_definition_type, "is_pub", 1);
	15807	ensure_field_index(type_info_definition_type, "data", 2);
	15808
	15809	TypeTableEntry *type_info_definition_data_type = ir_type_info_get_type(ira, "Data", type_info_definition_type);
	15810	ensure_complete_type(ira->codegen, type_info_definition_data_type);
	15811
	15812	TypeTableEntry *type_info_fn_def_type = ir_type_info_get_type(ira, "FnDef", type_info_definition_data_type);
	15813	ensure_complete_type(ira->codegen, type_info_fn_def_type);
	15814
	15815	TypeTableEntry *type_info_fn_def_inline_type = ir_type_info_get_type(ira, "Inline", type_info_fn_def_type);
	15816	ensure_complete_type(ira->codegen, type_info_fn_def_inline_type);
	15817
	15818	// Loop through our definitions once to figure out how many definitions we will generate info for.
	15819	auto decl_it = decls_scope->decl_table.entry_iterator();
	15820	decltype(decls_scope->decl_table)::Entry *curr_entry = nullptr;
	15821	int definition_count = 0;
	15822
	15823	while ((curr_entry = decl_it.next()) != nullptr)
	15824	{
	15825	// If the definition is unresolved, force it to be resolved again.
	15826	if (curr_entry->value->resolution == TldResolutionUnresolved)
	15827	{
	15828	resolve_top_level_decl(ira->codegen, curr_entry->value, false, curr_entry->value->source_node);
	15829	if (curr_entry->value->resolution != TldResolutionOk)
	15830	{
	15831	return;
	15832	}
	15833	}
	15834
	15835	// Skip comptime blocks and test functions.
	15836	if (curr_entry->value->id != TldIdCompTime)
	15837	{
	15838	if (curr_entry->value->id == TldIdFn)
	15839	{
	15840	FnTableEntry fn_entry = ((TldFn )curr_entry->value)->fn_entry;
	15841	if (fn_entry->is_test)
	15842	continue;
	15843	}
	15844
	15845	definition_count += 1;
	15846	}
	15847	}
	15848
	15849	ConstExprValue *definition_array = create_const_vals(1);
	15850	definition_array->special = ConstValSpecialStatic;
	15851	definition_array->type = get_array_type(ira->codegen, type_info_definition_type, definition_count);
	15852	definition_array->data.x_array.special = ConstArraySpecialNone;
	15853	definition_array->data.x_array.s_none.parent.id = ConstParentIdNone;
	15854	definition_array->data.x_array.s_none.elements = create_const_vals(definition_count);
	15855	init_const_slice(ira->codegen, out_val, definition_array, 0, definition_count, false);
	15856
	15857	// Loop through the definitions and generate info.
	15858	decl_it = decls_scope->decl_table.entry_iterator();
	15859	curr_entry = nullptr;
	15860	int definition_index = 0;
	15861	while ((curr_entry = decl_it.next()) != nullptr)
	15862	{
	15863	// Skip comptime blocks and test functions.
	15864	if (curr_entry->value->id == TldIdCompTime)
	15865	continue;
	15866	else if (curr_entry->value->id == TldIdFn)
	15867	{
	15868	FnTableEntry fn_entry = ((TldFn )curr_entry->value)->fn_entry;
	15869	if (fn_entry->is_test)
	15870	continue;
	15871	}
	15872
	15873	ConstExprValue *definition_val = &definition_array->data.x_array.s_none.elements[definition_index];
	15874
	15875	definition_val->special = ConstValSpecialStatic;
	15876	definition_val->type = type_info_definition_type;
	15877
	15878	ConstExprValue *inner_fields = create_const_vals(3);
	15879	ConstExprValue *name = create_const_str_lit(ira->codegen, curr_entry->key);
	15880	init_const_slice(ira->codegen, &inner_fields[0], name, 0, buf_len(curr_entry->key), true);
	15881	inner_fields[1].special = ConstValSpecialStatic;
	15882	inner_fields[1].type = ira->codegen->builtin_types.entry_bool;
	15883	inner_fields[1].data.x_bool = curr_entry->value->visib_mod == VisibModPub;
	15884	inner_fields[2].special = ConstValSpecialStatic;
	15885	inner_fields[2].type = type_info_definition_data_type;
	15886	inner_fields[2].data.x_union.parent.id = ConstParentIdStruct;
	15887	inner_fields[2].data.x_union.parent.data.p_struct.struct_val = definition_val;
	15888	inner_fields[2].data.x_union.parent.data.p_struct.field_index = 1;
	15889
	15890	switch (curr_entry->value->id)
	15891	{
	15892	case TldIdVar:
	15893	{
	15894	VariableTableEntry var = ((TldVar )curr_entry->value)->var;
	15895	ensure_complete_type(ira->codegen, var->value->type);
	15896	if (var->value->type->id == TypeTableEntryIdMetaType)
	15897	{
	15898	// We have a variable of type 'type', so it's actually a type definition.
	15899	// 0: Data.Type: type
	15900	bigint_init_unsigned(&inner_fields[2].data.x_union.tag, 0);
	15901	inner_fields[2].data.x_union.payload = var->value;
	15902	}
	15903	else
	15904	{
	15905	// We have a variable of another type, so we store the type of the variable.
	15906	// 1: Data.Var: type
	15907	bigint_init_unsigned(&inner_fields[2].data.x_union.tag, 1);
	15908
	15909	ConstExprValue *payload = create_const_vals(1);
	15910	payload->type = ira->codegen->builtin_types.entry_type;
	15911	payload->data.x_type = var->value->type;
	15912
	15913	inner_fields[2].data.x_union.payload = payload;
	15914	}
	15915
	15916	break;
	15917	}
	15918	case TldIdFn:
	15919	{
	15920	// 2: Data.Fn: Data.FnDef
	15921	bigint_init_unsigned(&inner_fields[2].data.x_union.tag, 2);
	15922
	15923	FnTableEntry fn_entry = ((TldFn )curr_entry->value)->fn_entry;
	15924	assert(!fn_entry->is_test);
	15925
	15926	analyze_fn_body(ira->codegen, fn_entry);
	15927	if (fn_entry->anal_state == FnAnalStateInvalid)
	15928	return;
	15929
	15930	AstNodeFnProto fn_node = (AstNodeFnProto )(fn_entry->proto_node);
	15931
	15932	ConstExprValue *fn_def_val = create_const_vals(1);
	15933	fn_def_val->special = ConstValSpecialStatic;
	15934	fn_def_val->type = type_info_fn_def_type;
	15935	fn_def_val->data.x_struct.parent.id = ConstParentIdUnion;
	15936	fn_def_val->data.x_struct.parent.data.p_union.union_val = &inner_fields[2];
	15937
	15938	ConstExprValue *fn_def_fields = create_const_vals(9);
	15939	fn_def_val->data.x_struct.fields = fn_def_fields;
	15940
	15941	// fn_type: type
	15942	ensure_field_index(fn_def_val->type, "fn_type", 0);
	15943	fn_def_fields[0].special = ConstValSpecialStatic;
	15944	fn_def_fields[0].type = ira->codegen->builtin_types.entry_type;
	15945	fn_def_fields[0].data.x_type = fn_entry->type_entry;
	15946	// inline_type: Data.FnDef.Inline
	15947	ensure_field_index(fn_def_val->type, "inline_type", 1);
	15948	fn_def_fields[1].special = ConstValSpecialStatic;
	15949	fn_def_fields[1].type = type_info_fn_def_inline_type;
	15950	bigint_init_unsigned(&fn_def_fields[1].data.x_enum_tag, fn_entry->fn_inline);
	15951	// calling_convention: TypeInfo.CallingConvention
	15952	ensure_field_index(fn_def_val->type, "calling_convention", 2);
	15953	fn_def_fields[2].special = ConstValSpecialStatic;
	15954	fn_def_fields[2].type = ir_type_info_get_type(ira, "CallingConvention");
	15955	bigint_init_unsigned(&fn_def_fields[2].data.x_enum_tag, fn_node->cc);
	15956	// is_var_args: bool
	15957	ensure_field_index(fn_def_val->type, "is_var_args", 3);
	15958	bool is_varargs = fn_node->is_var_args;
	15959	fn_def_fields[3].special = ConstValSpecialStatic;
	15960	fn_def_fields[3].type = ira->codegen->builtin_types.entry_bool;
	15961	fn_def_fields[3].data.x_bool = is_varargs;
	15962	// is_extern: bool
	15963	ensure_field_index(fn_def_val->type, "is_extern", 4);
	15964	fn_def_fields[4].special = ConstValSpecialStatic;
	15965	fn_def_fields[4].type = ira->codegen->builtin_types.entry_bool;
	15966	fn_def_fields[4].data.x_bool = fn_node->is_extern;
	15967	// is_export: bool
	15968	ensure_field_index(fn_def_val->type, "is_export", 5);
	15969	fn_def_fields[5].special = ConstValSpecialStatic;
	15970	fn_def_fields[5].type = ira->codegen->builtin_types.entry_bool;
	15971	fn_def_fields[5].data.x_bool = fn_node->is_export;
	15972	// lib_name: ?[]const u8
	15973	ensure_field_index(fn_def_val->type, "lib_name", 6);
	15974	fn_def_fields[6].special = ConstValSpecialStatic;
	15975	fn_def_fields[6].type = get_maybe_type(ira->codegen,
	15976	get_slice_type(ira->codegen, get_pointer_to_type(ira->codegen,
	15977	ira->codegen->builtin_types.entry_u8, true)));
	15978	if (fn_node->is_extern && buf_len(fn_node->lib_name) > 0)
	15979	{
	15980	fn_def_fields[6].data.x_maybe = create_const_vals(1);
	15981	ConstExprValue *lib_name = create_const_str_lit(ira->codegen, fn_node->lib_name);
	15982	init_const_slice(ira->codegen, fn_def_fields[6].data.x_maybe, lib_name, 0, buf_len(fn_node->lib_name), true);
	15983	}
	15984	else
	15985	fn_def_fields[6].data.x_maybe = nullptr;
	15986	// return_type: type
	15987	ensure_field_index(fn_def_val->type, "return_type", 7);
	15988	fn_def_fields[7].special = ConstValSpecialStatic;
	15989	fn_def_fields[7].type = ira->codegen->builtin_types.entry_type;
	15990	if (fn_entry->src_implicit_return_type != nullptr)
	15991	fn_def_fields[7].data.x_type = fn_entry->src_implicit_return_type;
	15992	else if (fn_entry->type_entry->data.fn.gen_return_type != nullptr)
	15993	fn_def_fields[7].data.x_type = fn_entry->type_entry->data.fn.gen_return_type;
	15994	else
	15995	fn_def_fields[7].data.x_type = fn_entry->type_entry->data.fn.fn_type_id.return_type;
	15996	// arg_names: [][] const u8
	15997	ensure_field_index(fn_def_val->type, "arg_names", 8);
	15998	size_t fn_arg_count = fn_entry->variable_list.length;
	15999	ConstExprValue *fn_arg_name_array = create_const_vals(1);
	16000	fn_arg_name_array->special = ConstValSpecialStatic;
	16001	fn_arg_name_array->type = get_array_type(ira->codegen, get_slice_type(ira->codegen,
	16002	get_pointer_to_type(ira->codegen, ira->codegen->builtin_types.entry_u8, true)), fn_arg_count);
	16003	fn_arg_name_array->data.x_array.special = ConstArraySpecialNone;
	16004	fn_arg_name_array->data.x_array.s_none.parent.id = ConstParentIdNone;
	16005	fn_arg_name_array->data.x_array.s_none.elements = create_const_vals(fn_arg_count);
	16006
	16007	init_const_slice(ira->codegen, &fn_def_fields[8], fn_arg_name_array, 0, fn_arg_count, false);
	16008
	16009	for (size_t fn_arg_index = 0; fn_arg_index < fn_arg_count; fn_arg_index++)
	16010	{
	16011	VariableTableEntry *arg_var = fn_entry->variable_list.at(fn_arg_index);
	16012	ConstExprValue *fn_arg_name_val = &fn_arg_name_array->data.x_array.s_none.elements[fn_arg_index];
	16013	ConstExprValue *arg_name = create_const_str_lit(ira->codegen, &arg_var->name);
	16014	init_const_slice(ira->codegen, fn_arg_name_val, arg_name, 0, buf_len(&arg_var->name), true);
	16015	fn_arg_name_val->data.x_struct.parent.id = ConstParentIdArray;
	16016	fn_arg_name_val->data.x_struct.parent.data.p_array.array_val = fn_arg_name_array;
	16017	fn_arg_name_val->data.x_struct.parent.data.p_array.elem_index = fn_arg_index;
	16018	}
	16019
	16020	inner_fields[2].data.x_union.payload = fn_def_val;
	16021	break;
	16022	}
	16023	case TldIdContainer:
	16024	{
	16025	TypeTableEntry type_entry = ((TldContainer )curr_entry->value)->type_entry;
	16026	ensure_complete_type(ira->codegen, type_entry);
	16027	// This is a type.
	16028	bigint_init_unsigned(&inner_fields[2].data.x_union.tag, 0);
	16029
	16030	ConstExprValue *payload = create_const_vals(1);
	16031	payload->type = ira->codegen->builtin_types.entry_type;
	16032	payload->data.x_type = type_entry;
	16033
	16034	inner_fields[2].data.x_union.payload = payload;
	16035
	16036	break;
	16037	}
	16038	default:
	16039	zig_unreachable();
	16040	}
	16041
	16042	definition_val->data.x_struct.fields = inner_fields;
	16043	definition_index++;
	16044	}
	16045
	16046	assert(definition_index == definition_count);
	16047	}
	16048
	16049	static ConstExprValue ir_make_type_info_value(IrAnalyze ira, TypeTableEntry *type_entry)
	16050	{
	16051	assert(type_entry != nullptr);
	16052	assert(!type_is_invalid(type_entry));
	16053
	16054	ensure_complete_type(ira->codegen, type_entry);
	16055
	16056	const auto make_enum_field_val = [ira](ConstExprValue enum_field_val, TypeEnumField enum_field,
	16057	TypeTableEntry *type_info_enum_field_type) {
	16058	enum_field_val->special = ConstValSpecialStatic;
	16059	enum_field_val->type = type_info_enum_field_type;
	16060
	16061	ConstExprValue *inner_fields = create_const_vals(2);
	16062	inner_fields[1].special = ConstValSpecialStatic;
	16063	inner_fields[1].type = ira->codegen->builtin_types.entry_usize;
	16064
	16065	ConstExprValue *name = create_const_str_lit(ira->codegen, enum_field->name);
	16066	init_const_slice(ira->codegen, &inner_fields[0], name, 0, buf_len(enum_field->name), true);
	16067
	16068	bigint_init_bigint(&inner_fields[1].data.x_bigint, &enum_field->value);
	16069
	16070	enum_field_val->data.x_struct.fields = inner_fields;
	16071	};
	16072
	16073	const auto create_ptr_like_type_info = [ira](const char name, TypeTableEntry ptr_type_entry) {
	16074	ConstExprValue *result = create_const_vals(1);
	16075	result->special = ConstValSpecialStatic;
	16076	result->type = ir_type_info_get_type(ira, name);
	16077
	16078	ConstExprValue *fields = create_const_vals(4);
	16079	result->data.x_struct.fields = fields;
	16080
	16081	// is_const: bool
	16082	ensure_field_index(result->type, "is_const", 0);
	16083	fields[0].special = ConstValSpecialStatic;
	16084	fields[0].type = ira->codegen->builtin_types.entry_bool;
	16085	fields[0].data.x_bool = ptr_type_entry->data.pointer.is_const;
	16086	// is_volatile: bool
	16087	ensure_field_index(result->type, "is_volatile", 1);
	16088	fields[1].special = ConstValSpecialStatic;
	16089	fields[1].type = ira->codegen->builtin_types.entry_bool;
	16090	fields[1].data.x_bool = ptr_type_entry->data.pointer.is_volatile;
	16091	// alignment: u32
	16092	ensure_field_index(result->type, "alignment", 2);
	16093	fields[2].special = ConstValSpecialStatic;
	16094	fields[2].type = ira->codegen->builtin_types.entry_u32;
	16095	bigint_init_unsigned(&fields[2].data.x_bigint, ptr_type_entry->data.pointer.alignment);
	16096	// child: type
	16097	ensure_field_index(result->type, "child", 3);
	16098	fields[3].special = ConstValSpecialStatic;
	16099	fields[3].type = ira->codegen->builtin_types.entry_type;
	16100	fields[3].data.x_type = ptr_type_entry->data.pointer.child_type;
	16101
	16102	return result;
	16103	};
	16104
	16105	ConstExprValue *result = nullptr;
	16106	switch (type_entry->id)
	16107	{
	16108	case TypeTableEntryIdInvalid:
	16109	zig_unreachable();
	16110	case TypeTableEntryIdMetaType:
	16111	case TypeTableEntryIdVoid:
	16112	case TypeTableEntryIdBool:
	16113	case TypeTableEntryIdUnreachable:
	16114	case TypeTableEntryIdNumLitFloat:
	16115	case TypeTableEntryIdNumLitInt:
	16116	case TypeTableEntryIdUndefLit:
	16117	case TypeTableEntryIdNullLit:
	16118	case TypeTableEntryIdNamespace:
	16119	case TypeTableEntryIdBlock:
	16120	case TypeTableEntryIdArgTuple:
	16121	case TypeTableEntryIdOpaque:
	16122	return nullptr;
	16123	default:
	16124	{
	16125	// Lookup an available value in our cache.
	16126	auto entry = ira->codegen->type_info_cache.maybe_get(type_entry);
	16127	if (entry != nullptr)
	16128	return entry->value;
	16129
	16130	// Fallthrough if we don't find one.
	16131	}
	16132	case TypeTableEntryIdInt:
	16133	{
	16134	result = create_const_vals(1);
	16135	result->special = ConstValSpecialStatic;
	16136	result->type = ir_type_info_get_type(ira, "Int");
	16137
	16138	ConstExprValue *fields = create_const_vals(2);
	16139	result->data.x_struct.fields = fields;
	16140
	16141	// is_signed: bool
	16142	ensure_field_index(result->type, "is_signed", 0);
	16143	fields[0].special = ConstValSpecialStatic;
	16144	fields[0].type = ira->codegen->builtin_types.entry_bool;
	16145	fields[0].data.x_bool = type_entry->data.integral.is_signed;
	16146	// bits: u8
	16147	ensure_field_index(result->type, "bits", 1);
	16148	fields[1].special = ConstValSpecialStatic;
	16149	fields[1].type = ira->codegen->builtin_types.entry_u8;
	16150	bigint_init_unsigned(&fields[1].data.x_bigint, type_entry->data.integral.bit_count);
	16151
	16152	break;
	16153	}
	16154	case TypeTableEntryIdFloat:
	16155	{
	16156	result = create_const_vals(1);
	16157	result->special = ConstValSpecialStatic;
	16158	result->type = ir_type_info_get_type(ira, "Float");
	16159
	16160	ConstExprValue *fields = create_const_vals(1);
	16161	result->data.x_struct.fields = fields;
	16162
	16163	// bits: u8
	16164	ensure_field_index(result->type, "bits", 0);
	16165	fields[0].special = ConstValSpecialStatic;
	16166	fields[0].type = ira->codegen->builtin_types.entry_u8;
	16167	bigint_init_unsigned(&fields->data.x_bigint, type_entry->data.floating.bit_count);
	16168
	16169	break;
	16170	}
	16171	case TypeTableEntryIdPointer:
	16172	{
	16173	result = create_ptr_like_type_info("Pointer", type_entry);
	16174	break;
	16175	}
	16176	case TypeTableEntryIdArray:
	16177	{
	16178	result = create_const_vals(1);
	16179	result->special = ConstValSpecialStatic;
	16180	result->type = ir_type_info_get_type(ira, "Array");
	16181
	16182	ConstExprValue *fields = create_const_vals(2);
	16183	result->data.x_struct.fields = fields;
	16184
	16185	// len: usize
	16186	ensure_field_index(result->type, "len", 0);
	16187	fields[0].special = ConstValSpecialStatic;
	16188	fields[0].type = ira->codegen->builtin_types.entry_usize;
	16189	bigint_init_unsigned(&fields[0].data.x_bigint, type_entry->data.array.len);
	16190	// child: type
	16191	ensure_field_index(result->type, "child", 1);
	16192	fields[1].special = ConstValSpecialStatic;
	16193	fields[1].type = ira->codegen->builtin_types.entry_type;
	16194	fields[1].data.x_type = type_entry->data.array.child_type;
	16195
	16196	break;
	16197	}
	16198	case TypeTableEntryIdMaybe:
	16199	{
	16200	result = create_const_vals(1);
	16201	result->special = ConstValSpecialStatic;
	16202	result->type = ir_type_info_get_type(ira, "Nullable");
	16203
	16204	ConstExprValue *fields = create_const_vals(1);
	16205	result->data.x_struct.fields = fields;
	16206
	16207	// child: type
	16208	ensure_field_index(result->type, "child", 0);
	16209	fields[0].special = ConstValSpecialStatic;
	16210	fields[0].type = ira->codegen->builtin_types.entry_type;
	16211	fields[0].data.x_type = type_entry->data.maybe.child_type;
	16212
	16213	break;
	16214	}
	16215	case TypeTableEntryIdPromise:
	16216	{
	16217	result = create_const_vals(1);
	16218	result->special = ConstValSpecialStatic;
	16219	result->type = ir_type_info_get_type(ira, "Promise");
	16220
	16221	ConstExprValue *fields = create_const_vals(1);
	16222	result->data.x_struct.fields = fields;
	16223
	16224	// @TODO ?type instead of using @typeOf(undefined) when we have no type.
	16225	// child: type
	16226	ensure_field_index(result->type, "child", 0);
	16227	fields[0].special = ConstValSpecialStatic;
	16228	fields[0].type = ira->codegen->builtin_types.entry_type;
	16229
	16230	if (type_entry->data.promise.result_type == nullptr)
	16231	fields[0].data.x_type = ira->codegen->builtin_types.entry_undef;
	16232	else
	16233	fields[0].data.x_type = type_entry->data.promise.result_type;
	16234
	16235	break;
	16236	}
	16237	case TypeTableEntryIdEnum:
	16238	{
	16239	result = create_const_vals(1);
	16240	result->special = ConstValSpecialStatic;
	16241	result->type = ir_type_info_get_type(ira, "Enum");
	16242
	16243	ConstExprValue *fields = create_const_vals(4);
	16244	result->data.x_struct.fields = fields;
	16245
	16246	// layout: ContainerLayout
	16247	ensure_field_index(result->type, "layout", 0);
	16248	fields[0].special = ConstValSpecialStatic;
	16249	fields[0].type = ir_type_info_get_type(ira, "ContainerLayout");
	16250	bigint_init_unsigned(&fields[0].data.x_enum_tag, type_entry->data.enumeration.layout);
	16251	// tag_type: type
	16252	ensure_field_index(result->type, "tag_type", 1);
	16253	fields[1].special = ConstValSpecialStatic;
	16254	fields[1].type = ira->codegen->builtin_types.entry_type;
	16255	fields[1].data.x_type = type_entry->data.enumeration.tag_int_type;
	16256	// fields: []TypeInfo.EnumField
	16257	ensure_field_index(result->type, "fields", 2);
	16258
	16259	TypeTableEntry *type_info_enum_field_type = ir_type_info_get_type(ira, "EnumField");
	16260	uint32_t enum_field_count = type_entry->data.enumeration.src_field_count;
	16261
	16262	ConstExprValue *enum_field_array = create_const_vals(1);
	16263	enum_field_array->special = ConstValSpecialStatic;
	16264	enum_field_array->type = get_array_type(ira->codegen, type_info_enum_field_type, enum_field_count);
	16265	enum_field_array->data.x_array.special = ConstArraySpecialNone;
	16266	enum_field_array->data.x_array.s_none.parent.id = ConstParentIdNone;
	16267	enum_field_array->data.x_array.s_none.elements = create_const_vals(enum_field_count);
	16268
	16269	init_const_slice(ira->codegen, &fields[2], enum_field_array, 0, enum_field_count, false);
	16270
	16271	for (uint32_t enum_field_index = 0; enum_field_index < enum_field_count; enum_field_index++)
	16272	{
	16273	TypeEnumField *enum_field = &type_entry->data.enumeration.fields[enum_field_index];
	16274	ConstExprValue *enum_field_val = &enum_field_array->data.x_array.s_none.elements[enum_field_index];
	16275	make_enum_field_val(enum_field_val, enum_field, type_info_enum_field_type);
	16276	enum_field_val->data.x_struct.parent.id = ConstParentIdArray;
	16277	enum_field_val->data.x_struct.parent.data.p_array.array_val = enum_field_array;
	16278	enum_field_val->data.x_struct.parent.data.p_array.elem_index = enum_field_index;
	16279	}
	16280	// defs: []TypeInfo.Definition
	16281	ensure_field_index(result->type, "defs", 3);
	16282	ir_make_type_info_defs(ira, &fields[3], type_entry->data.enumeration.decls_scope);
	16283
	16284	break;
	16285	}
	16286	case TypeTableEntryIdErrorSet:
	16287	{
	16288	result = create_const_vals(1);
	16289	result->special = ConstValSpecialStatic;
	16290	result->type = ir_type_info_get_type(ira, "ErrorSet");
	16291
	16292	ConstExprValue *fields = create_const_vals(1);
	16293	result->data.x_struct.fields = fields;
	16294
	16295	// errors: []TypeInfo.Error
	16296	ensure_field_index(result->type, "errors", 0);
	16297
	16298	TypeTableEntry *type_info_error_type = ir_type_info_get_type(ira, "Error");
	16299	uint32_t error_count = type_entry->data.error_set.err_count;
	16300	ConstExprValue *error_array = create_const_vals(1);
	16301	error_array->special = ConstValSpecialStatic;
	16302	error_array->type = get_array_type(ira->codegen, type_info_error_type, error_count);
	16303	error_array->data.x_array.special = ConstArraySpecialNone;
	16304	error_array->data.x_array.s_none.parent.id = ConstParentIdNone;
	16305	error_array->data.x_array.s_none.elements = create_const_vals(error_count);
	16306
	16307	init_const_slice(ira->codegen, &fields[0], error_array, 0, error_count, false);
	16308	for (uint32_t error_index = 0; error_index < error_count; error_index++)
	16309	{
	16310	ErrorTableEntry *error = type_entry->data.error_set.errors[error_index];
	16311	ConstExprValue *error_val = &error_array->data.x_array.s_none.elements[error_index];
	16312
	16313	error_val->special = ConstValSpecialStatic;
	16314	error_val->type = type_info_error_type;
	16315
	16316	ConstExprValue *inner_fields = create_const_vals(2);
	16317	inner_fields[1].special = ConstValSpecialStatic;
	16318	inner_fields[1].type = ira->codegen->builtin_types.entry_usize;
	16319
	16320	ConstExprValue *name = nullptr;
	16321	if (error->cached_error_name_val != nullptr)
	16322	name = error->cached_error_name_val;
	16323	if (name == nullptr)
	16324	name = create_const_str_lit(ira->codegen, &error->name);
	16325	init_const_slice(ira->codegen, &inner_fields[0], name, 0, buf_len(&error->name), true);
	16326	bigint_init_unsigned(&inner_fields[1].data.x_bigint, error->value);
	16327
	16328	error_val->data.x_struct.fields = inner_fields;
	16329	error_val->data.x_struct.parent.id = ConstParentIdArray;
	16330	error_val->data.x_struct.parent.data.p_array.array_val = error_array;
	16331	error_val->data.x_struct.parent.data.p_array.elem_index = error_index;
	16332	}
	16333
	16334	break;
	16335	}
	16336	case TypeTableEntryIdErrorUnion:
	16337	{
	16338	result = create_const_vals(1);
	16339	result->special = ConstValSpecialStatic;
	16340	result->type = ir_type_info_get_type(ira, "ErrorUnion");
	16341
	16342	ConstExprValue *fields = create_const_vals(2);
	16343	result->data.x_struct.fields = fields;
	16344
	16345	// error_set: type
	16346	ensure_field_index(result->type, "error_set", 0);
	16347	fields[0].special = ConstValSpecialStatic;
	16348	fields[0].type = ira->codegen->builtin_types.entry_type;
	16349	fields[0].data.x_type = type_entry->data.error_union.err_set_type;
	16350
	16351	// payload: type
	16352	ensure_field_index(result->type, "payload", 1);
	16353	fields[1].special = ConstValSpecialStatic;
	16354	fields[1].type = ira->codegen->builtin_types.entry_type;
	16355	fields[1].data.x_type = type_entry->data.error_union.payload_type;
	16356
	16357	break;
	16358	}
	16359	case TypeTableEntryIdUnion:
	16360	{
	16361	result = create_const_vals(1);
	16362	result->special = ConstValSpecialStatic;
	16363	result->type = ir_type_info_get_type(ira, "Union");
	16364
	16365	ConstExprValue *fields = create_const_vals(4);
	16366	result->data.x_struct.fields = fields;
	16367
	16368	// layout: ContainerLayout
	16369	ensure_field_index(result->type, "layout", 0);
	16370	fields[0].special = ConstValSpecialStatic;
	16371	fields[0].type = ir_type_info_get_type(ira, "ContainerLayout");
	16372	bigint_init_unsigned(&fields[0].data.x_enum_tag, type_entry->data.unionation.layout);
	16373	// tag_type: type
	16374	ensure_field_index(result->type, "tag_type", 1);
	16375	fields[1].special = ConstValSpecialStatic;
	16376	fields[1].type = ira->codegen->builtin_types.entry_type;
	16377	// @TODO ?type instead of using @typeOf(undefined) when we have no type.
	16378	AstNode *union_decl_node = type_entry->data.unionation.decl_node;
	16379	if (union_decl_node->data.container_decl.auto_enum \|\|
	16380	union_decl_node->data.container_decl.init_arg_expr != nullptr)
	16381	{
	16382	fields[1].data.x_type = type_entry->data.unionation.tag_type;
	16383	}
	16384	else
	16385	fields[1].data.x_type = ira->codegen->builtin_types.entry_undef;
	16386	// fields: []TypeInfo.UnionField
	16387	ensure_field_index(result->type, "fields", 2);
	16388
	16389	TypeTableEntry *type_info_union_field_type = ir_type_info_get_type(ira, "UnionField");
	16390	uint32_t union_field_count = type_entry->data.unionation.src_field_count;
	16391
	16392	ConstExprValue *union_field_array = create_const_vals(1);
	16393	union_field_array->special = ConstValSpecialStatic;
	16394	union_field_array->type = get_array_type(ira->codegen, type_info_union_field_type, union_field_count);
	16395	union_field_array->data.x_array.special = ConstArraySpecialNone;
	16396	union_field_array->data.x_array.s_none.parent.id = ConstParentIdNone;
	16397	union_field_array->data.x_array.s_none.elements = create_const_vals(union_field_count);
	16398
	16399	init_const_slice(ira->codegen, &fields[2], union_field_array, 0, union_field_count, false);
	16400
	16401	TypeTableEntry *type_info_enum_field_type = ir_type_info_get_type(ira, "EnumField");
	16402
	16403	for (uint32_t union_field_index = 0; union_field_index < union_field_count; union_field_index++)
	16404	{
	16405	TypeUnionField *union_field = &type_entry->data.unionation.fields[union_field_index];
	16406	ConstExprValue *union_field_val = &union_field_array->data.x_array.s_none.elements[union_field_index];
	16407
	16408	union_field_val->special = ConstValSpecialStatic;
	16409	union_field_val->type = type_info_union_field_type;
	16410
	16411	ConstExprValue *inner_fields = create_const_vals(3);
	16412	inner_fields[1].special = ConstValSpecialStatic;
	16413	inner_fields[1].type = get_maybe_type(ira->codegen, type_info_enum_field_type);
	16414
	16415	if (fields[1].data.x_type == ira->codegen->builtin_types.entry_undef)
	16416	inner_fields[1].data.x_maybe = nullptr;
	16417	else
	16418	{
	16419	inner_fields[1].data.x_maybe = create_const_vals(1);
	16420	make_enum_field_val(inner_fields[1].data.x_maybe, union_field->enum_field, type_info_enum_field_type);
	16421	}
	16422
	16423	inner_fields[2].special = ConstValSpecialStatic;
	16424	inner_fields[2].type = ira->codegen->builtin_types.entry_type;
	16425	inner_fields[2].data.x_type = union_field->type_entry;
	16426
	16427	ConstExprValue *name = create_const_str_lit(ira->codegen, union_field->name);
	16428	init_const_slice(ira->codegen, &inner_fields[0], name, 0, buf_len(union_field->name), true);
	16429
	16430	union_field_val->data.x_struct.fields = inner_fields;
	16431	union_field_val->data.x_struct.parent.id = ConstParentIdArray;
	16432	union_field_val->data.x_struct.parent.data.p_array.array_val = union_field_array;
	16433	union_field_val->data.x_struct.parent.data.p_array.elem_index = union_field_index;
	16434	}
	16435	// defs: []TypeInfo.Definition
	16436	ensure_field_index(result->type, "defs", 3);
	16437	ir_make_type_info_defs(ira, &fields[3], type_entry->data.unionation.decls_scope);
	16438
	16439	break;
	16440	}
	16441	case TypeTableEntryIdStruct:
	16442	{
	16443	if (type_entry->data.structure.is_slice) {
	16444	Buf ptr_field_name = BUF_INIT;
	16445	buf_init_from_str(&ptr_field_name, "ptr");
	16446	TypeTableEntry *ptr_type = type_entry->data.structure.fields_by_name.get(&ptr_field_name)->type_entry;
	16447	ensure_complete_type(ira->codegen, ptr_type);
	16448	buf_deinit(&ptr_field_name);
	16449
	16450	result = create_ptr_like_type_info("Slice", ptr_type);
	16451	break;
	16452	}
	16453
	16454	result = create_const_vals(1);
	16455	result->special = ConstValSpecialStatic;
	16456	result->type = ir_type_info_get_type(ira, "Struct");
	16457
	16458	ConstExprValue *fields = create_const_vals(3);
	16459	result->data.x_struct.fields = fields;
	16460
	16461	// layout: ContainerLayout
	16462	ensure_field_index(result->type, "layout", 0);
	16463	fields[0].special = ConstValSpecialStatic;
	16464	fields[0].type = ir_type_info_get_type(ira, "ContainerLayout");
	16465	bigint_init_unsigned(&fields[0].data.x_enum_tag, type_entry->data.structure.layout);
	16466	// fields: []TypeInfo.StructField
	16467	ensure_field_index(result->type, "fields", 1);
	16468
	16469	TypeTableEntry *type_info_struct_field_type = ir_type_info_get_type(ira, "StructField");
	16470	uint32_t struct_field_count = type_entry->data.structure.src_field_count;
	16471
	16472	ConstExprValue *struct_field_array = create_const_vals(1);
	16473	struct_field_array->special = ConstValSpecialStatic;
	16474	struct_field_array->type = get_array_type(ira->codegen, type_info_struct_field_type, struct_field_count);
	16475	struct_field_array->data.x_array.special = ConstArraySpecialNone;
	16476	struct_field_array->data.x_array.s_none.parent.id = ConstParentIdNone;
	16477	struct_field_array->data.x_array.s_none.elements = create_const_vals(struct_field_count);
	16478
	16479	init_const_slice(ira->codegen, &fields[1], struct_field_array, 0, struct_field_count, false);
	16480
	16481	for (uint32_t struct_field_index = 0; struct_field_index < struct_field_count; struct_field_index++)
	16482	{
	16483	TypeStructField *struct_field = &type_entry->data.structure.fields[struct_field_index];
	16484	ConstExprValue *struct_field_val = &struct_field_array->data.x_array.s_none.elements[struct_field_index];
	16485
	16486	struct_field_val->special = ConstValSpecialStatic;
	16487	struct_field_val->type = type_info_struct_field_type;
	16488
	16489	ConstExprValue *inner_fields = create_const_vals(3);
	16490	inner_fields[1].special = ConstValSpecialStatic;
	16491	inner_fields[1].type = get_maybe_type(ira->codegen, ira->codegen->builtin_types.entry_usize);
	16492
	16493	if (!type_has_bits(struct_field->type_entry))
	16494	inner_fields[1].data.x_maybe = nullptr;
	16495	else
	16496	{
	16497	size_t byte_offset = LLVMOffsetOfElement(ira->codegen->target_data_ref, type_entry->type_ref, struct_field->gen_index);
	16498	inner_fields[1].data.x_maybe = create_const_vals(1);
	16499	inner_fields[1].data.x_maybe->type = ira->codegen->builtin_types.entry_usize;
	16500	bigint_init_unsigned(&inner_fields[1].data.x_maybe->data.x_bigint, byte_offset);
	16501	}
	16502
	16503	inner_fields[2].special = ConstValSpecialStatic;
	16504	inner_fields[2].type = ira->codegen->builtin_types.entry_type;
	16505	inner_fields[2].data.x_type = struct_field->type_entry;
	16506
	16507	ConstExprValue *name = create_const_str_lit(ira->codegen, struct_field->name);
	16508	init_const_slice(ira->codegen, &inner_fields[0], name, 0, buf_len(struct_field->name), true);
	16509
	16510	struct_field_val->data.x_struct.fields = inner_fields;
	16511	struct_field_val->data.x_struct.parent.id = ConstParentIdArray;
	16512	struct_field_val->data.x_struct.parent.data.p_array.array_val = struct_field_array;
	16513	struct_field_val->data.x_struct.parent.data.p_array.elem_index = struct_field_index;
	16514	}
	16515	// defs: []TypeInfo.Definition
	16516	ensure_field_index(result->type, "defs", 2);
	16517	ir_make_type_info_defs(ira, &fields[2], type_entry->data.structure.decls_scope);
	16518
	16519	break;
	16520	}
	16521	case TypeTableEntryIdFn:
	16522	{
	16523	result = create_const_vals(1);
	16524	result->special = ConstValSpecialStatic;
	16525	result->type = ir_type_info_get_type(ira, "Fn");
	16526
	16527	ConstExprValue *fields = create_const_vals(6);
	16528	result->data.x_struct.fields = fields;
	16529
	16530	// @TODO Fix type = undefined with ?type
	16531
	16532	// calling_convention: TypeInfo.CallingConvention
	16533	ensure_field_index(result->type, "calling_convention", 0);
	16534	fields[0].special = ConstValSpecialStatic;
	16535	fields[0].type = ir_type_info_get_type(ira, "CallingConvention");
	16536	bigint_init_unsigned(&fields[0].data.x_enum_tag, type_entry->data.fn.fn_type_id.cc);
	16537	// is_generic: bool
	16538	ensure_field_index(result->type, "is_generic", 1);
	16539	bool is_generic = type_entry->data.fn.is_generic;
	16540	fields[1].special = ConstValSpecialStatic;
	16541	fields[1].type = ira->codegen->builtin_types.entry_bool;
	16542	fields[1].data.x_bool = is_generic;
	16543	// is_varargs: bool
	16544	ensure_field_index(result->type, "is_var_args", 2);
	16545	bool is_varargs = type_entry->data.fn.fn_type_id.is_var_args;
	16546	fields[2].special = ConstValSpecialStatic;
	16547	fields[2].type = ira->codegen->builtin_types.entry_bool;
	16548	fields[2].data.x_bool = type_entry->data.fn.fn_type_id.is_var_args;
	16549	// return_type: type
	16550	ensure_field_index(result->type, "return_type", 3);
	16551	fields[3].special = ConstValSpecialStatic;
	16552	fields[3].type = ira->codegen->builtin_types.entry_type;
	16553	if (type_entry->data.fn.fn_type_id.return_type == nullptr)
	16554	fields[3].data.x_type = ira->codegen->builtin_types.entry_undef;
	16555	else
	16556	fields[3].data.x_type = type_entry->data.fn.fn_type_id.return_type;
	16557	// async_allocator_type: type
	16558	ensure_field_index(result->type, "async_allocator_type", 4);
	16559	fields[4].special = ConstValSpecialStatic;
	16560	fields[4].type = ira->codegen->builtin_types.entry_type;
	16561	if (type_entry->data.fn.fn_type_id.async_allocator_type == nullptr)
	16562	fields[4].data.x_type = ira->codegen->builtin_types.entry_undef;
	16563	else
	16564	fields[4].data.x_type = type_entry->data.fn.fn_type_id.async_allocator_type;
	16565	// args: []TypeInfo.FnArg
	16566	TypeTableEntry *type_info_fn_arg_type = ir_type_info_get_type(ira, "FnArg");
	16567	size_t fn_arg_count = type_entry->data.fn.fn_type_id.param_count -
	16568	(is_varargs && type_entry->data.fn.fn_type_id.cc != CallingConventionC);
	16569
	16570	ConstExprValue *fn_arg_array = create_const_vals(1);
	16571	fn_arg_array->special = ConstValSpecialStatic;
	16572	fn_arg_array->type = get_array_type(ira->codegen, type_info_fn_arg_type, fn_arg_count);
	16573	fn_arg_array->data.x_array.special = ConstArraySpecialNone;
	16574	fn_arg_array->data.x_array.s_none.parent.id = ConstParentIdNone;
	16575	fn_arg_array->data.x_array.s_none.elements = create_const_vals(fn_arg_count);
	16576
	16577	init_const_slice(ira->codegen, &fields[5], fn_arg_array, 0, fn_arg_count, false);
	16578
	16579	for (size_t fn_arg_index = 0; fn_arg_index < fn_arg_count; fn_arg_index++)
	16580	{
	16581	FnTypeParamInfo *fn_param_info = &type_entry->data.fn.fn_type_id.param_info[fn_arg_index];
	16582	ConstExprValue *fn_arg_val = &fn_arg_array->data.x_array.s_none.elements[fn_arg_index];
	16583
	16584	fn_arg_val->special = ConstValSpecialStatic;
	16585	fn_arg_val->type = type_info_fn_arg_type;
	16586
	16587	bool arg_is_generic = fn_param_info->type == nullptr;
	16588	if (arg_is_generic) assert(is_generic);
	16589
	16590	ConstExprValue *inner_fields = create_const_vals(3);
	16591	inner_fields[0].special = ConstValSpecialStatic;
	16592	inner_fields[0].type = ira->codegen->builtin_types.entry_bool;
	16593	inner_fields[0].data.x_bool = arg_is_generic;
	16594	inner_fields[1].special = ConstValSpecialStatic;
	16595	inner_fields[1].type = ira->codegen->builtin_types.entry_bool;
	16596	inner_fields[1].data.x_bool = fn_param_info->is_noalias;
	16597	inner_fields[2].special = ConstValSpecialStatic;
	16598	inner_fields[2].type = ira->codegen->builtin_types.entry_type;
	16599
	16600	if (arg_is_generic)
	16601	inner_fields[2].data.x_type = ira->codegen->builtin_types.entry_undef;
	16602	else
	16603	inner_fields[2].data.x_type = fn_param_info->type;
	16604
	16605	fn_arg_val->data.x_struct.fields = inner_fields;
	16606	fn_arg_val->data.x_struct.parent.id = ConstParentIdArray;
	16607	fn_arg_val->data.x_struct.parent.data.p_array.array_val = fn_arg_array;
	16608	fn_arg_val->data.x_struct.parent.data.p_array.elem_index = fn_arg_index;
	16609	}
	16610
	16611	break;
	16612	}
	16613	case TypeTableEntryIdBoundFn:
	16614	{
	16615	TypeTableEntry *fn_type = type_entry->data.bound_fn.fn_type;
	16616	assert(fn_type->id == TypeTableEntryIdFn);
	16617	result = ir_make_type_info_value(ira, fn_type);
	16618
	16619	break;
	16620	}
	16621	}
	16622
	16623	assert(result != nullptr);
	16624	ira->codegen->type_info_cache.put(type_entry, result);
	16625	return result;
	16626	}
	16627
	16628	static TypeTableEntry ir_analyze_instruction_type_info(IrAnalyze ira,
	16629	IrInstructionTypeInfo *instruction)
	16630	{
	16631	IrInstruction *type_value = instruction->type_value->other;
	16632	TypeTableEntry *type_entry = ir_resolve_type(ira, type_value);
	16633	if (type_is_invalid(type_entry))
	16634	return ira->codegen->builtin_types.entry_invalid;
	16635
	16636	TypeTableEntry *result_type = ir_type_info_get_type(ira, nullptr);
	16637
	16638	ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
	16639	out_val->type = result_type;
	16640	bigint_init_unsigned(&out_val->data.x_union.tag, type_id_index(type_entry));
	16641
	16642	ConstExprValue *payload = ir_make_type_info_value(ira, type_entry);
	16643	out_val->data.x_union.payload = payload;
	16644
	16645	if (payload != nullptr)
	16646	{
	16647	assert(payload->type->id == TypeTableEntryIdStruct);
	16648	payload->data.x_struct.parent.id = ConstParentIdUnion;
	16649	payload->data.x_struct.parent.data.p_union.union_val = out_val;
	16650	}
	16651
	16652	return result_type;
	16653	}
	16654
15377	16655	static TypeTableEntry ir_analyze_instruction_type_id(IrAnalyze ira,
15378	16656	IrInstructionTypeId *instruction)
15379	16657	{
...	...	@@ -15387,7 +16665,7 @@ static TypeTableEntry ir_analyze_instruction_type_id(IrAnalyze ira,
15387	16665	TypeTableEntry *result_type = var_value->data.x_type;
15388	16666
15389	16667	ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
15390		bigint_init_unsigned(&out_val->data.x_enum_tag, type_id_index(type_entry->id));
	16668	bigint_init_unsigned(&out_val->data.x_enum_tag, type_id_index(type_entry));
15391	16669	return result_type;
15392	16670	}
15393	16671
...	...	@@ -15590,10 +16868,20 @@ static TypeTableEntry ir_analyze_instruction_embed_file(IrAnalyze ira, IrInstr
15590	16868	}
15591	16869
15592	16870	static TypeTableEntry ir_analyze_instruction_cmpxchg(IrAnalyze ira, IrInstructionCmpxchg *instruction) {
	16871	TypeTableEntry *operand_type = ir_resolve_atomic_operand_type(ira, instruction->type_value->other);
	16872	if (type_is_invalid(operand_type))
	16873	return ira->codegen->builtin_types.entry_invalid;
	16874
15593	16875	IrInstruction *ptr = instruction->ptr->other;
15594	16876	if (type_is_invalid(ptr->value.type))
15595	16877	return ira->codegen->builtin_types.entry_invalid;
15596	16878
	16879	// TODO let this be volatile
	16880	TypeTableEntry *ptr_type = get_pointer_to_type(ira->codegen, operand_type, false);
	16881	IrInstruction *casted_ptr = ir_implicit_cast(ira, ptr, ptr_type);
	16882	if (type_is_invalid(casted_ptr->value.type))
	16883	return ira->codegen->builtin_types.entry_invalid;
	16884
15597	16885	IrInstruction *cmp_value = instruction->cmp_value->other;
15598	16886	if (type_is_invalid(cmp_value->value.type))
15599	16887	return ira->codegen->builtin_types.entry_invalid;
...	...	@@ -15618,28 +16906,11 @@ static TypeTableEntry ir_analyze_instruction_cmpxchg(IrAnalyze ira, IrInstruct
15618	16906	if (!ir_resolve_atomic_order(ira, failure_order_value, &failure_order))
15619	16907	return ira->codegen->builtin_types.entry_invalid;
15620	16908
15621		if (ptr->value.type->id != TypeTableEntryIdPointer) {
15622		ir_add_error(ira, instruction->ptr,
15623		buf_sprintf("expected pointer argument, found '%s'", buf_ptr(&ptr->value.type->name)));
15624		return ira->codegen->builtin_types.entry_invalid;
15625		}
15626
15627		TypeTableEntry *child_type = ptr->value.type->data.pointer.child_type;
15628
15629		uint32_t align_bytes = ptr->value.type->data.pointer.alignment;
15630		uint64_t size_bytes = type_size(ira->codegen, child_type);
15631		if (align_bytes < size_bytes) {
15632		ir_add_error(ira, instruction->ptr,
15633		buf_sprintf("expected pointer alignment of at least %" ZIG_PRI_u64 ", found %" PRIu32,
15634		size_bytes, align_bytes));
15635		return ira->codegen->builtin_types.entry_invalid;
15636		}
15637
15638		IrInstruction *casted_cmp_value = ir_implicit_cast(ira, cmp_value, child_type);
	16909	IrInstruction *casted_cmp_value = ir_implicit_cast(ira, cmp_value, operand_type);
15639	16910	if (type_is_invalid(casted_cmp_value->value.type))
15640	16911	return ira->codegen->builtin_types.entry_invalid;
15641	16912
15642		IrInstruction *casted_new_value = ir_implicit_cast(ira, new_value, child_type);
	16913	IrInstruction *casted_new_value = ir_implicit_cast(ira, new_value, operand_type);
15643	16914	if (type_is_invalid(casted_new_value->value.type))
15644	16915	return ira->codegen->builtin_types.entry_invalid;
15645	16916
...	...	@@ -15664,9 +16935,17 @@ static TypeTableEntry ir_analyze_instruction_cmpxchg(IrAnalyze ira, IrInstruct
15664	16935	return ira->codegen->builtin_types.entry_invalid;
15665	16936	}
15666	16937
15667		ir_build_cmpxchg_from(&ira->new_irb, &instruction->base, ptr, casted_cmp_value, casted_new_value,
15668		success_order_value, failure_order_value, success_order, failure_order);
15669		return ira->codegen->builtin_types.entry_bool;
	16938	if (instr_is_comptime(casted_ptr) && instr_is_comptime(casted_cmp_value) && instr_is_comptime(casted_new_value)) {
	16939	zig_panic("TODO compile-time execution of cmpxchg");
	16940	}
	16941
	16942	IrInstruction *result = ir_build_cmpxchg(&ira->new_irb, instruction->base.scope, instruction->base.source_node,
	16943	nullptr, casted_ptr, casted_cmp_value, casted_new_value, nullptr, nullptr, instruction->is_weak,
	16944	operand_type, success_order, failure_order);
	16945	result->value.type = get_maybe_type(ira->codegen, operand_type);
	16946	ir_link_new_instruction(result, &instruction->base);
	16947	ir_add_alloca(ira, result, result->value.type);
	16948	return result->value.type;
15670	16949	}
15671	16950
15672	16951	static TypeTableEntry ir_analyze_instruction_fence(IrAnalyze ira, IrInstructionFence *instruction) {
...	...	@@ -16702,6 +17981,11 @@ static TypeTableEntry ir_analyze_instruction_fn_proto(IrAnalyze ira, IrInstruc
16702	17981	return ira->codegen->builtin_types.entry_invalid;
16703	17982
16704	17983	if (fn_type_id.cc == CallingConventionAsync) {
	17984	if (instruction->async_allocator_type_value == nullptr) {
	17985	ir_add_error(ira, &instruction->base,
	17986	buf_sprintf("async fn proto missing allocator type"));
	17987	return ira->codegen->builtin_types.entry_invalid;
	17988	}
16705	17989	IrInstruction *async_allocator_type_value = instruction->async_allocator_type_value->other;
16706	17990	fn_type_id.async_allocator_type = ir_resolve_type(ira, async_allocator_type_value);
16707	17991	if (type_is_invalid(fn_type_id.async_allocator_type))
...	...	@@ -17560,6 +18844,16 @@ static TypeTableEntry ir_analyze_instruction_arg_type(IrAnalyze ira, IrInstruc
17560	18844
17561	18845	ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
17562	18846	out_val->data.x_type = fn_type_id->param_info[arg_index].type;
	18847	if (out_val->data.x_type == nullptr) {
	18848	// Args are only unresolved if our function is generic.
	18849	assert(fn_type->data.fn.is_generic);
	18850
	18851	ir_add_error(ira, arg_index_inst,
	18852	buf_sprintf("@ArgType could not resolve the type of arg %" ZIG_PRI_u64 " because '%s' is generic",
	18853	arg_index, buf_ptr(&fn_type->name)));
	18854	return ira->codegen->builtin_types.entry_invalid;
	18855	}
	18856
17563	18857	return ira->codegen->builtin_types.entry_type;
17564	18858	}
17565	18859
...	...	@@ -17795,39 +19089,48 @@ static TypeTableEntry ir_analyze_instruction_coro_alloc_helper(IrAnalyze ira,
17795	19089	return result->value.type;
17796	19090	}
17797	19091
17798		static TypeTableEntry ir_analyze_instruction_atomic_rmw(IrAnalyze ira, IrInstructionAtomicRmw *instruction) {
17799		TypeTableEntry *operand_type = ir_resolve_type(ira, instruction->operand_type->other);
17800		if (type_is_invalid(operand_type)) {
	19092	static TypeTableEntry ir_resolve_atomic_operand_type(IrAnalyze ira, IrInstruction *op) {
	19093	TypeTableEntry *operand_type = ir_resolve_type(ira, op);
	19094	if (type_is_invalid(operand_type))
17801	19095	return ira->codegen->builtin_types.entry_invalid;
17802		}
	19096
17803	19097	if (operand_type->id == TypeTableEntryIdInt) {
17804	19098	if (operand_type->data.integral.bit_count < 8) {
17805		ir_add_error(ira, &instruction->base,
	19099	ir_add_error(ira, op,
17806	19100	buf_sprintf("expected integer type 8 bits or larger, found %" PRIu32 "-bit integer type",
17807	19101	operand_type->data.integral.bit_count));
17808	19102	return ira->codegen->builtin_types.entry_invalid;
17809	19103	}
17810	19104	if (operand_type->data.integral.bit_count > ira->codegen->pointer_size_bytes * 8) {
17811		ir_add_error(ira, &instruction->base,
	19105	ir_add_error(ira, op,
17812	19106	buf_sprintf("expected integer type pointer size or smaller, found %" PRIu32 "-bit integer type",
17813	19107	operand_type->data.integral.bit_count));
17814	19108	return ira->codegen->builtin_types.entry_invalid;
17815	19109	}
17816	19110	if (!is_power_of_2(operand_type->data.integral.bit_count)) {
17817		ir_add_error(ira, &instruction->base,
	19111	ir_add_error(ira, op,
17818	19112	buf_sprintf("%" PRIu32 "-bit integer type is not a power of 2", operand_type->data.integral.bit_count));
17819	19113	return ira->codegen->builtin_types.entry_invalid;
17820	19114	}
17821	19115	} else if (get_codegen_ptr_type(operand_type) == nullptr) {
17822		ir_add_error(ira, &instruction->base,
	19116	ir_add_error(ira, op,
17823	19117	buf_sprintf("expected integer or pointer type, found '%s'", buf_ptr(&operand_type->name)));
17824	19118	return ira->codegen->builtin_types.entry_invalid;
17825	19119	}
17826	19120
	19121	return operand_type;
	19122	}
	19123
	19124	static TypeTableEntry ir_analyze_instruction_atomic_rmw(IrAnalyze ira, IrInstructionAtomicRmw *instruction) {
	19125	TypeTableEntry *operand_type = ir_resolve_atomic_operand_type(ira, instruction->operand_type->other);
	19126	if (type_is_invalid(operand_type))
	19127	return ira->codegen->builtin_types.entry_invalid;
	19128
17827	19129	IrInstruction *ptr_inst = instruction->ptr->other;
17828	19130	if (type_is_invalid(ptr_inst->value.type))
17829	19131	return ira->codegen->builtin_types.entry_invalid;
17830	19132
	19133	// TODO let this be volatile
17831	19134	TypeTableEntry *ptr_type = get_pointer_to_type(ira->codegen, operand_type, false);
17832	19135	IrInstruction *casted_ptr = ir_implicit_cast(ira, ptr_inst, ptr_type);
17833	19136	if (type_is_invalid(casted_ptr->value.type))
...	...	@@ -17856,6 +19159,11 @@ static TypeTableEntry ir_analyze_instruction_atomic_rmw(IrAnalyze ira, IrInstr
17856	19159	} else {
17857	19160	if (!ir_resolve_atomic_order(ira, instruction->ordering->other, &ordering))
17858	19161	return ira->codegen->builtin_types.entry_invalid;
	19162	if (ordering == AtomicOrderUnordered) {
	19163	ir_add_error(ira, instruction->ordering,
	19164	buf_sprintf("@atomicRmw atomic ordering must not be Unordered"));
	19165	return ira->codegen->builtin_types.entry_invalid;
	19166	}
17859	19167	}
17860	19168
17861	19169	if (instr_is_comptime(casted_operand) && instr_is_comptime(casted_ptr) && casted_ptr->value.data.x_ptr.mut == ConstPtrMutComptimeVar)
...	...	@@ -17871,6 +19179,49 @@ static TypeTableEntry ir_analyze_instruction_atomic_rmw(IrAnalyze ira, IrInstr
17871	19179	return result->value.type;
17872	19180	}
17873	19181
	19182	static TypeTableEntry ir_analyze_instruction_atomic_load(IrAnalyze ira, IrInstructionAtomicLoad *instruction) {
	19183	TypeTableEntry *operand_type = ir_resolve_atomic_operand_type(ira, instruction->operand_type->other);
	19184	if (type_is_invalid(operand_type))
	19185	return ira->codegen->builtin_types.entry_invalid;
	19186
	19187	IrInstruction *ptr_inst = instruction->ptr->other;
	19188	if (type_is_invalid(ptr_inst->value.type))
	19189	return ira->codegen->builtin_types.entry_invalid;
	19190
	19191	TypeTableEntry *ptr_type = get_pointer_to_type(ira->codegen, operand_type, true);
	19192	IrInstruction *casted_ptr = ir_implicit_cast(ira, ptr_inst, ptr_type);
	19193	if (type_is_invalid(casted_ptr->value.type))
	19194	return ira->codegen->builtin_types.entry_invalid;
	19195
	19196	AtomicOrder ordering;
	19197	if (instruction->ordering == nullptr) {
	19198	ordering = instruction->resolved_ordering;
	19199	} else {
	19200	if (!ir_resolve_atomic_order(ira, instruction->ordering->other, &ordering))
	19201	return ira->codegen->builtin_types.entry_invalid;
	19202	}
	19203
	19204	if (ordering == AtomicOrderRelease \|\| ordering == AtomicOrderAcqRel) {
	19205	assert(instruction->ordering != nullptr);
	19206	ir_add_error(ira, instruction->ordering,
	19207	buf_sprintf("@atomicLoad atomic ordering must not be Release or AcqRel"));
	19208	return ira->codegen->builtin_types.entry_invalid;
	19209	}
	19210
	19211	if (instr_is_comptime(casted_ptr)) {
	19212	IrInstruction *result = ir_get_deref(ira, &instruction->base, casted_ptr);
	19213	ir_link_new_instruction(result, &instruction->base);
	19214	assert(result->value.type != nullptr);
	19215	return result->value.type;
	19216	}
	19217
	19218	IrInstruction *result = ir_build_atomic_load(&ira->new_irb, instruction->base.scope,
	19219	instruction->base.source_node, nullptr, casted_ptr, nullptr, ordering);
	19220	ir_link_new_instruction(result, &instruction->base);
	19221	result->value.type = operand_type;
	19222	return result->value.type;
	19223	}
	19224
17874	19225	static TypeTableEntry ir_analyze_instruction_promise_result_type(IrAnalyze ira, IrInstructionPromiseResultType *instruction) {
17875	19226	TypeTableEntry *promise_type = ir_resolve_type(ira, instruction->promise_type->other);
17876	19227	if (type_is_invalid(promise_type))
...	...	@@ -17904,6 +19255,39 @@ static TypeTableEntry ir_analyze_instruction_await_bookkeeping(IrAnalyze ira,
17904	19255	return out_val->type;
17905	19256	}
17906	19257
	19258	static TypeTableEntry ir_analyze_instruction_merge_err_ret_traces(IrAnalyze ira,
	19259	IrInstructionMergeErrRetTraces *instruction)
	19260	{
	19261	IrInstruction *coro_promise_ptr = instruction->coro_promise_ptr->other;
	19262	if (type_is_invalid(coro_promise_ptr->value.type))
	19263	return ira->codegen->builtin_types.entry_invalid;
	19264
	19265	assert(coro_promise_ptr->value.type->id == TypeTableEntryIdPointer);
	19266	TypeTableEntry *promise_frame_type = coro_promise_ptr->value.type->data.pointer.child_type;
	19267	assert(promise_frame_type->id == TypeTableEntryIdStruct);
	19268	TypeTableEntry *promise_result_type = promise_frame_type->data.structure.fields[1].type_entry;
	19269
	19270	if (!type_can_fail(promise_result_type)) {
	19271	ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
	19272	out_val->type = ira->codegen->builtin_types.entry_void;
	19273	return out_val->type;
	19274	}
	19275
	19276	IrInstruction *src_err_ret_trace_ptr = instruction->src_err_ret_trace_ptr->other;
	19277	if (type_is_invalid(src_err_ret_trace_ptr->value.type))
	19278	return ira->codegen->builtin_types.entry_invalid;
	19279
	19280	IrInstruction *dest_err_ret_trace_ptr = instruction->dest_err_ret_trace_ptr->other;
	19281	if (type_is_invalid(dest_err_ret_trace_ptr->value.type))
	19282	return ira->codegen->builtin_types.entry_invalid;
	19283
	19284	IrInstruction *result = ir_build_merge_err_ret_traces(&ira->new_irb, instruction->base.scope,
	19285	instruction->base.source_node, coro_promise_ptr, src_err_ret_trace_ptr, dest_err_ret_trace_ptr);
	19286	ir_link_new_instruction(result, &instruction->base);
	19287	result->value.type = ira->codegen->builtin_types.entry_void;
	19288	return result->value.type;
	19289	}
	19290
17907	19291	static TypeTableEntry ir_analyze_instruction_save_err_ret_addr(IrAnalyze ira, IrInstructionSaveErrRetAddr *instruction) {
17908	19292	IrInstruction *result = ir_build_save_err_ret_addr(&ira->new_irb, instruction->base.scope,
17909	19293	instruction->base.source_node);
...	...	@@ -17912,6 +19296,80 @@ static TypeTableEntry ir_analyze_instruction_save_err_ret_addr(IrAnalyze ira,
17912	19296	return result->value.type;
17913	19297	}
17914	19298
	19299	static TypeTableEntry ir_analyze_instruction_mark_err_ret_trace_ptr(IrAnalyze ira, IrInstructionMarkErrRetTracePtr *instruction) {
	19300	IrInstruction *err_ret_trace_ptr = instruction->err_ret_trace_ptr->other;
	19301	if (type_is_invalid(err_ret_trace_ptr->value.type))
	19302	return ira->codegen->builtin_types.entry_invalid;
	19303
	19304	IrInstruction *result = ir_build_mark_err_ret_trace_ptr(&ira->new_irb, instruction->base.scope,
	19305	instruction->base.source_node, err_ret_trace_ptr);
	19306	ir_link_new_instruction(result, &instruction->base);
	19307	result->value.type = ira->codegen->builtin_types.entry_void;
	19308	return result->value.type;
	19309	}
	19310
	19311	static TypeTableEntry ir_analyze_instruction_sqrt(IrAnalyze ira, IrInstructionSqrt *instruction) {
	19312	TypeTableEntry *float_type = ir_resolve_type(ira, instruction->type->other);
	19313	if (type_is_invalid(float_type))
	19314	return ira->codegen->builtin_types.entry_invalid;
	19315
	19316	IrInstruction *op = instruction->op->other;
	19317	if (type_is_invalid(op->value.type))
	19318	return ira->codegen->builtin_types.entry_invalid;
	19319
	19320	bool ok_type = float_type->id == TypeTableEntryIdNumLitFloat \|\| float_type->id == TypeTableEntryIdFloat;
	19321	if (!ok_type) {
	19322	ir_add_error(ira, instruction->type, buf_sprintf("@sqrt does not support type '%s'", buf_ptr(&float_type->name)));
	19323	return ira->codegen->builtin_types.entry_invalid;
	19324	}
	19325
	19326	IrInstruction *casted_op = ir_implicit_cast(ira, op, float_type);
	19327	if (type_is_invalid(casted_op->value.type))
	19328	return ira->codegen->builtin_types.entry_invalid;
	19329
	19330	if (instr_is_comptime(casted_op)) {
	19331	ConstExprValue *val = ir_resolve_const(ira, casted_op, UndefBad);
	19332	if (!val)
	19333	return ira->codegen->builtin_types.entry_invalid;
	19334
	19335	ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
	19336
	19337	if (float_type->id == TypeTableEntryIdNumLitFloat) {
	19338	bigfloat_sqrt(&out_val->data.x_bigfloat, &val->data.x_bigfloat);
	19339	} else if (float_type->id == TypeTableEntryIdFloat) {
	19340	switch (float_type->data.floating.bit_count) {
	19341	case 32:
	19342	out_val->data.x_f32 = sqrtf(val->data.x_f32);
	19343	break;
	19344	case 64:
	19345	out_val->data.x_f64 = sqrt(val->data.x_f64);
	19346	break;
	19347	case 128:
	19348	f128M_sqrt(&val->data.x_f128, &out_val->data.x_f128);
	19349	break;
	19350	default:
	19351	zig_unreachable();
	19352	}
	19353	} else {
	19354	zig_unreachable();
	19355	}
	19356
	19357	return float_type;
	19358	}
	19359
	19360	assert(float_type->id == TypeTableEntryIdFloat);
	19361	if (float_type->data.floating.bit_count != 32 && float_type->data.floating.bit_count != 64) {
	19362	ir_add_error(ira, instruction->type, buf_sprintf("compiler TODO: add implementation of sqrt for '%s'", buf_ptr(&float_type->name)));
	19363	return ira->codegen->builtin_types.entry_invalid;
	19364	}
	19365
	19366	IrInstruction *result = ir_build_sqrt(&ira->new_irb, instruction->base.scope,
	19367	instruction->base.source_node, nullptr, casted_op);
	19368	ir_link_new_instruction(result, &instruction->base);
	19369	result->value.type = float_type;
	19370	return result->value.type;
	19371	}
	19372
17915	19373	static TypeTableEntry ir_analyze_instruction_nocast(IrAnalyze ira, IrInstruction *instruction) {
17916	19374	switch (instruction->id) {
17917	19375	case IrInstructionIdInvalid:
...	...	@@ -18095,6 +19553,8 @@ static TypeTableEntry ir_analyze_instruction_nocast(IrAnalyze ira, IrInstructi
18095	19553	return ir_analyze_instruction_field_parent_ptr(ira, (IrInstructionFieldParentPtr *)instruction);
18096	19554	case IrInstructionIdOffsetOf:
18097	19555	return ir_analyze_instruction_offset_of(ira, (IrInstructionOffsetOf *)instruction);
	19556	case IrInstructionIdTypeInfo:
	19557	return ir_analyze_instruction_type_info(ira, (IrInstructionTypeInfo *) instruction);
18098	19558	case IrInstructionIdTypeId:
18099	19559	return ir_analyze_instruction_type_id(ira, (IrInstructionTypeId *)instruction);
18100	19560	case IrInstructionIdSetEvalBranchQuota:
...	...	@@ -18147,6 +19607,8 @@ static TypeTableEntry ir_analyze_instruction_nocast(IrAnalyze ira, IrInstructi
18147	19607	return ir_analyze_instruction_coro_alloc_helper(ira, (IrInstructionCoroAllocHelper *)instruction);
18148	19608	case IrInstructionIdAtomicRmw:
18149	19609	return ir_analyze_instruction_atomic_rmw(ira, (IrInstructionAtomicRmw *)instruction);
	19610	case IrInstructionIdAtomicLoad:
	19611	return ir_analyze_instruction_atomic_load(ira, (IrInstructionAtomicLoad *)instruction);
18150	19612	case IrInstructionIdPromiseResultType:
18151	19613	return ir_analyze_instruction_promise_result_type(ira, (IrInstructionPromiseResultType *)instruction);
18152	19614	case IrInstructionIdAwaitBookkeeping:
...	...	@@ -18155,6 +19617,12 @@ static TypeTableEntry ir_analyze_instruction_nocast(IrAnalyze ira, IrInstructi
18155	19617	return ir_analyze_instruction_save_err_ret_addr(ira, (IrInstructionSaveErrRetAddr *)instruction);
18156	19618	case IrInstructionIdAddImplicitReturnType:
18157	19619	return ir_analyze_instruction_add_implicit_return_type(ira, (IrInstructionAddImplicitReturnType *)instruction);
	19620	case IrInstructionIdMergeErrRetTraces:
	19621	return ir_analyze_instruction_merge_err_ret_traces(ira, (IrInstructionMergeErrRetTraces *)instruction);
	19622	case IrInstructionIdMarkErrRetTracePtr:
	19623	return ir_analyze_instruction_mark_err_ret_trace_ptr(ira, (IrInstructionMarkErrRetTracePtr *)instruction);
	19624	case IrInstructionIdSqrt:
	19625	return ir_analyze_instruction_sqrt(ira, (IrInstructionSqrt *)instruction);
18158	19626	}
18159	19627	zig_unreachable();
18160	19628	}
...	...	@@ -18231,7 +19699,7 @@ TypeTableEntry ir_analyze(CodeGen codegen, IrExecutable *old_exec, IrExecutabl
18231	19699	} else if (ira->src_implicit_return_type_list.length == 0) {
18232	19700	return codegen->builtin_types.entry_unreachable;
18233	19701	} else {
18234		return ir_resolve_peer_types(ira, expected_type_source_node, ira->src_implicit_return_type_list.items,
	19702	return ir_resolve_peer_types(ira, expected_type_source_node, expected_type, ira->src_implicit_return_type_list.items,
18235	19703	ira->src_implicit_return_type_list.length);
18236	19704	}
18237	19705	}
...	...	@@ -18282,6 +19750,9 @@ bool ir_has_side_effects(IrInstruction *instruction) {
18282	19750	case IrInstructionIdAwaitBookkeeping:
18283	19751	case IrInstructionIdSaveErrRetAddr:
18284	19752	case IrInstructionIdAddImplicitReturnType:
	19753	case IrInstructionIdMergeErrRetTraces:
	19754	case IrInstructionIdMarkErrRetTracePtr:
	19755	case IrInstructionIdAtomicRmw:
18285	19756	return true;
18286	19757
18287	19758	case IrInstructionIdPhi:
...	...	@@ -18350,6 +19821,7 @@ bool ir_has_side_effects(IrInstruction *instruction) {
18350	19821	case IrInstructionIdTagName:
18351	19822	case IrInstructionIdFieldParentPtr:
18352	19823	case IrInstructionIdOffsetOf:
	19824	case IrInstructionIdTypeInfo:
18353	19825	case IrInstructionIdTypeId:
18354	19826	case IrInstructionIdAlignCast:
18355	19827	case IrInstructionIdOpaqueType:
...	...	@@ -18362,9 +19834,10 @@ bool ir_has_side_effects(IrInstruction *instruction) {
18362	19834	case IrInstructionIdCoroSize:
18363	19835	case IrInstructionIdCoroSuspend:
18364	19836	case IrInstructionIdCoroFree:
18365		case IrInstructionIdAtomicRmw:
18366	19837	case IrInstructionIdCoroPromise:
18367	19838	case IrInstructionIdPromiseResultType:
	19839	case IrInstructionIdSqrt:
	19840	case IrInstructionIdAtomicLoad:
18368	19841	return false;
18369	19842
18370	19843	case IrInstructionIdAsm:

src/ir_print.cpp+89-4

...	...	@@ -358,9 +358,18 @@ static void ir_print_ptr_type_child(IrPrint irp, IrInstructionPtrTypeChild ins
358	358	}
359	359
360	360	static void ir_print_field_ptr(IrPrint irp, IrInstructionFieldPtr instruction) {
361		fprintf(irp->f, "fieldptr ");
362		ir_print_other_instruction(irp, instruction->container_ptr);
363		fprintf(irp->f, ".%s", buf_ptr(instruction->field_name));
	361	if (instruction->field_name_buffer) {
	362	fprintf(irp->f, "fieldptr ");
	363	ir_print_other_instruction(irp, instruction->container_ptr);
	364	fprintf(irp->f, ".%s", buf_ptr(instruction->field_name_buffer));
	365	} else {
	366	assert(instruction->field_name_expr);
	367	fprintf(irp->f, "@field(");
	368	ir_print_other_instruction(irp, instruction->container_ptr);
	369	fprintf(irp->f, ", ");
	370	ir_print_other_instruction(irp, instruction->field_name_expr);
	371	fprintf(irp->f, ")");
	372	}
364	373	}
365	374
366	375	static void ir_print_struct_field_ptr(IrPrint irp, IrInstructionStructFieldPtr instruction) {
...	...	@@ -957,6 +966,12 @@ static void ir_print_offset_of(IrPrint irp, IrInstructionOffsetOf instruction)
957	966	fprintf(irp->f, ")");
958	967	}
959	968
	969	static void ir_print_type_info(IrPrint irp, IrInstructionTypeInfo instruction) {
	970	fprintf(irp->f, "@typeInfo(");
	971	ir_print_other_instruction(irp, instruction->type_value);
	972	fprintf(irp->f, ")");
	973	}
	974
960	975	static void ir_print_type_id(IrPrint irp, IrInstructionTypeId instruction) {
961	976	fprintf(irp->f, "@typeId(");
962	977	ir_print_other_instruction(irp, instruction->type_value);
...	...	@@ -1024,7 +1039,16 @@ static void ir_print_export(IrPrint irp, IrInstructionExport instruction) {
1024	1039	}
1025	1040
1026	1041	static void ir_print_error_return_trace(IrPrint irp, IrInstructionErrorReturnTrace instruction) {
1027		fprintf(irp->f, "@errorReturnTrace()");
	1042	fprintf(irp->f, "@errorReturnTrace(");
	1043	switch (instruction->nullable) {
	1044	case IrInstructionErrorReturnTrace::Null:
	1045	fprintf(irp->f, "Null");
	1046	break;
	1047	case IrInstructionErrorReturnTrace::NonNull:
	1048	fprintf(irp->f, "NonNull");
	1049	break;
	1050	}
	1051	fprintf(irp->f, ")");
1028	1052	}
1029	1053
1030	1054	static void ir_print_error_union(IrPrint irp, IrInstructionErrorUnion instruction) {
...	...	@@ -1163,6 +1187,24 @@ static void ir_print_atomic_rmw(IrPrint irp, IrInstructionAtomicRmw instructio
1163	1187	fprintf(irp->f, ")");
1164	1188	}
1165	1189
	1190	static void ir_print_atomic_load(IrPrint irp, IrInstructionAtomicLoad instruction) {
	1191	fprintf(irp->f, "@atomicLoad(");
	1192	if (instruction->operand_type != nullptr) {
	1193	ir_print_other_instruction(irp, instruction->operand_type);
	1194	} else {
	1195	fprintf(irp->f, "[TODO print]");
	1196	}
	1197	fprintf(irp->f, ",");
	1198	ir_print_other_instruction(irp, instruction->ptr);
	1199	fprintf(irp->f, ",");
	1200	if (instruction->ordering != nullptr) {
	1201	ir_print_other_instruction(irp, instruction->ordering);
	1202	} else {
	1203	fprintf(irp->f, "[TODO print]");
	1204	}
	1205	fprintf(irp->f, ")");
	1206	}
	1207
1166	1208	static void ir_print_await_bookkeeping(IrPrint irp, IrInstructionAwaitBookkeeping instruction) {
1167	1209	fprintf(irp->f, "@awaitBookkeeping(");
1168	1210	ir_print_other_instruction(irp, instruction->promise_result_type);
...	...	@@ -1179,6 +1221,34 @@ static void ir_print_add_implicit_return_type(IrPrint *irp, IrInstructionAddImpl
1179	1221	fprintf(irp->f, ")");
1180	1222	}
1181	1223
	1224	static void ir_print_merge_err_ret_traces(IrPrint irp, IrInstructionMergeErrRetTraces instruction) {
	1225	fprintf(irp->f, "@mergeErrRetTraces(");
	1226	ir_print_other_instruction(irp, instruction->coro_promise_ptr);
	1227	fprintf(irp->f, ",");
	1228	ir_print_other_instruction(irp, instruction->src_err_ret_trace_ptr);
	1229	fprintf(irp->f, ",");
	1230	ir_print_other_instruction(irp, instruction->dest_err_ret_trace_ptr);
	1231	fprintf(irp->f, ")");
	1232	}
	1233
	1234	static void ir_print_mark_err_ret_trace_ptr(IrPrint irp, IrInstructionMarkErrRetTracePtr instruction) {
	1235	fprintf(irp->f, "@markErrRetTracePtr(");
	1236	ir_print_other_instruction(irp, instruction->err_ret_trace_ptr);
	1237	fprintf(irp->f, ")");
	1238	}
	1239
	1240	static void ir_print_sqrt(IrPrint irp, IrInstructionSqrt instruction) {
	1241	fprintf(irp->f, "@sqrt(");
	1242	if (instruction->type != nullptr) {
	1243	ir_print_other_instruction(irp, instruction->type);
	1244	} else {
	1245	fprintf(irp->f, "null");
	1246	}
	1247	fprintf(irp->f, ",");
	1248	ir_print_other_instruction(irp, instruction->op);
	1249	fprintf(irp->f, ")");
	1250	}
	1251
1182	1252	static void ir_print_instruction(IrPrint irp, IrInstruction instruction) {
1183	1253	ir_print_prefix(irp, instruction);
1184	1254	switch (instruction->id) {
...	...	@@ -1472,6 +1542,9 @@ static void ir_print_instruction(IrPrint irp, IrInstruction instruction) {
1472	1542	case IrInstructionIdOffsetOf:
1473	1543	ir_print_offset_of(irp, (IrInstructionOffsetOf *)instruction);
1474	1544	break;
	1545	case IrInstructionIdTypeInfo:
	1546	ir_print_type_info(irp, (IrInstructionTypeInfo *)instruction);
	1547	break;
1475	1548	case IrInstructionIdTypeId:
1476	1549	ir_print_type_id(irp, (IrInstructionTypeId *)instruction);
1477	1550	break;
...	...	@@ -1559,6 +1632,18 @@ static void ir_print_instruction(IrPrint irp, IrInstruction instruction) {
1559	1632	case IrInstructionIdAddImplicitReturnType:
1560	1633	ir_print_add_implicit_return_type(irp, (IrInstructionAddImplicitReturnType *)instruction);
1561	1634	break;
	1635	case IrInstructionIdMergeErrRetTraces:
	1636	ir_print_merge_err_ret_traces(irp, (IrInstructionMergeErrRetTraces *)instruction);
	1637	break;
	1638	case IrInstructionIdMarkErrRetTracePtr:
	1639	ir_print_mark_err_ret_trace_ptr(irp, (IrInstructionMarkErrRetTracePtr *)instruction);
	1640	break;
	1641	case IrInstructionIdSqrt:
	1642	ir_print_sqrt(irp, (IrInstructionSqrt *)instruction);
	1643	break;
	1644	case IrInstructionIdAtomicLoad:
	1645	ir_print_atomic_load(irp, (IrInstructionAtomicLoad *)instruction);
	1646	break;
1562	1647	}
1563	1648	fprintf(irp->f, "\n");
1564	1649	}

src/link.cpp+3

...	...	@@ -217,6 +217,9 @@ static void construct_linker_job_elf(LinkJob *lj) {
217	217	lj->args.append(g->linker_script);
218	218	}
219	219
	220	if (g->no_rosegment_workaround) {
	221	lj->args.append("--no-rosegment");
	222	}
220	223	lj->args.append("--gc-sections");
221	224
222	225	lj->args.append("-m");

src/main.cpp+16-25

...	...	@@ -43,6 +43,7 @@ static int usage(const char *arg0) {
43	43	" --pkg-end pop current pkg\n"
44	44	" --release-fast build with optimizations on and safety off\n"
45	45	" --release-safe build with optimizations on and safety on\n"
	46	" --release-small build with size optimizations on and safety off\n"
46	47	" --static output will be statically linked\n"
47	48	" --strip exclude debug symbols\n"
48	49	" --target-arch [name] specify target architecture\n"
...	...	@@ -54,7 +55,6 @@ static int usage(const char *arg0) {
54	55	" --verbose-ir turn on compiler debug output for Zig IR\n"
55	56	" --verbose-llvm-ir turn on compiler debug output for LLVM IR\n"
56	57	" --verbose-cimport turn on compiler debug output for C imports\n"
57		" --zig-install-prefix [path] override directory where zig thinks it is installed\n"
58	58	" -dirafter [dir] same as -isystem but do it last\n"
59	59	" -isystem [dir] add additional search path for other .h files\n"
60	60	" -mllvm [arg] additional arguments to forward to LLVM's option processing\n"
...	...	@@ -74,6 +74,7 @@ static int usage(const char *arg0) {
74	74	" -L[dir] alias for --library-path\n"
75	75	" -rdynamic add all symbols to the dynamic symbol table\n"
76	76	" -rpath [path] add directory to the runtime library search path\n"
	77	" --no-rosegment compromise security to workaround valgrind bug\n"
77	78	" -mconsole (windows) --subsystem console to the linker\n"
78	79	" -mwindows (windows) --subsystem windows to the linker\n"
79	80	" -framework [name] (darwin) link against framework\n"
...	...	@@ -177,6 +178,7 @@ static int find_zig_lib_dir(Buf *out_path) {
177	178	int err;
178	179
179	180	Buf self_exe_path = BUF_INIT;
	181	buf_resize(&self_exe_path, 0);
180	182	if (!(err = os_self_exe_path(&self_exe_path))) {
181	183	Buf *cur_path = &self_exe_path;
182	184
...	...	@@ -199,23 +201,14 @@ static int find_zig_lib_dir(Buf *out_path) {
199	201	return ErrorFileNotFound;
200	202	}
201	203
202		static Buf resolve_zig_lib_dir(const char zig_install_prefix_arg) {
	204	static Buf *resolve_zig_lib_dir(void) {
203	205	int err;
204	206	Buf *result = buf_alloc();
205		if (zig_install_prefix_arg == nullptr) {
206		if ((err = find_zig_lib_dir(result))) {
207		fprintf(stderr, "Unable to find zig lib directory. Reinstall Zig or use --zig-install-prefix.\n");
208		exit(EXIT_FAILURE);
209		}
210		return result;
211		}
212		Buf *zig_lib_dir_buf = buf_create_from_str(zig_install_prefix_arg);
213		if (test_zig_install_prefix(zig_lib_dir_buf, result)) {
214		return result;
	207	if ((err = find_zig_lib_dir(result))) {
	208	fprintf(stderr, "Unable to find zig lib directory\n");
	209	exit(EXIT_FAILURE);
215	210	}
216
217		fprintf(stderr, "No Zig installation found at prefix: %s\n", zig_install_prefix_arg);
218		exit(EXIT_FAILURE);
	211	return result;
219	212	}
220	213
221	214	enum Cmd {
...	...	@@ -299,7 +292,6 @@ int main(int argc, char **argv) {
299	292	const char *libc_include_dir = nullptr;
300	293	const char *msvc_lib_dir = nullptr;
301	294	const char *kernel32_lib_dir = nullptr;
302		const char *zig_install_prefix = nullptr;
303	295	const char *dynamic_linker = nullptr;
304	296	ZigList<const char *> clang_argv = {0};
305	297	ZigList<const char *> llvm_argv = {0};
...	...	@@ -333,6 +325,7 @@ int main(int argc, char **argv) {
333	325	ZigList<const char *> test_exec_args = {0};
334	326	int comptime_args_end = 0;
335	327	int runtime_args_start = argc;
	328	bool no_rosegment_workaround = false;
336	329
337	330	if (argc >= 2 && strcmp(argv[1], "build") == 0) {
338	331	const char *zig_exe_path = arg0;
...	...	@@ -359,17 +352,12 @@ int main(int argc, char **argv) {
359	352	} else if (i + 1 < argc && strcmp(argv[i], "--cache-dir") == 0) {
360	353	cache_dir = argv[i + 1];
361	354	i += 1;
362		} else if (i + 1 < argc && strcmp(argv[i], "--zig-install-prefix") == 0) {
363		args.append(argv[i]);
364		i += 1;
365		zig_install_prefix = argv[i];
366		args.append(zig_install_prefix);
367	355	} else {
368	356	args.append(argv[i]);
369	357	}
370	358	}
371	359
372		Buf *zig_lib_dir_buf = resolve_zig_lib_dir(zig_install_prefix);
	360	Buf *zig_lib_dir_buf = resolve_zig_lib_dir();
373	361
374	362	Buf *zig_std_dir = buf_alloc();
375	363	os_path_join(zig_lib_dir_buf, buf_create_from_str("std"), zig_std_dir);
...	...	@@ -497,6 +485,8 @@ int main(int argc, char **argv) {
497	485	build_mode = BuildModeFastRelease;
498	486	} else if (strcmp(arg, "--release-safe") == 0) {
499	487	build_mode = BuildModeSafeRelease;
	488	} else if (strcmp(arg, "--release-small") == 0) {
	489	build_mode = BuildModeSmallRelease;
500	490	} else if (strcmp(arg, "--strip") == 0) {
501	491	strip = true;
502	492	} else if (strcmp(arg, "--static") == 0) {
...	...	@@ -519,6 +509,8 @@ int main(int argc, char **argv) {
519	509	mconsole = true;
520	510	} else if (strcmp(arg, "-rdynamic") == 0) {
521	511	rdynamic = true;
	512	} else if (strcmp(arg, "--no-rosegment") == 0) {
	513	no_rosegment_workaround = true;
522	514	} else if (strcmp(arg, "--each-lib-rpath") == 0) {
523	515	each_lib_rpath = true;
524	516	} else if (strcmp(arg, "--enable-timing-info") == 0) {
...	...	@@ -590,8 +582,6 @@ int main(int argc, char **argv) {
590	582	msvc_lib_dir = argv[i];
591	583	} else if (strcmp(arg, "--kernel32-lib-dir") == 0) {
592	584	kernel32_lib_dir = argv[i];
593		} else if (strcmp(arg, "--zig-install-prefix") == 0) {
594		zig_install_prefix = argv[i];
595	585	} else if (strcmp(arg, "--dynamic-linker") == 0) {
596	586	dynamic_linker = argv[i];
597	587	} else if (strcmp(arg, "-isystem") == 0) {
...	...	@@ -803,7 +793,7 @@ int main(int argc, char **argv) {
803	793	full_cache_dir);
804	794	}
805	795
806		Buf *zig_lib_dir_buf = resolve_zig_lib_dir(zig_install_prefix);
	796	Buf *zig_lib_dir_buf = resolve_zig_lib_dir();
807	797
808	798	CodeGen *g = codegen_create(zig_root_source_file, target, out_type, build_mode, zig_lib_dir_buf);
809	799	codegen_set_out_name(g, buf_out_name);
...	...	@@ -858,6 +848,7 @@ int main(int argc, char **argv) {
858	848
859	849	codegen_set_windows_subsystem(g, mwindows, mconsole);
860	850	codegen_set_rdynamic(g, rdynamic);
	851	g->no_rosegment_workaround = no_rosegment_workaround;
861	852	if (mmacosx_version_min && mios_version_min) {
862	853	fprintf(stderr, "-mmacosx-version-min and -mios-version-min options not allowed together\n");
863	854	return EXIT_FAILURE;

src/os.cpp+1

...	...	@@ -1007,6 +1007,7 @@ int os_self_exe_path(Buf *out_path) {
1007	1007	buf_resize(out_path, buf_len(out_path) * 2);
1008	1008	continue;
1009	1009	}
	1010	buf_resize(out_path, amt);
1010	1011	return 0;
1011	1012	}
1012	1013	#endif

src/parser.cpp+23-5

...	...	@@ -648,12 +648,30 @@ static AstNode ast_parse_asm_expr(ParseContext pc, size_t *token_index, bool m
648	648	}
649	649
650	650	/*
651		SuspendExpression(body) = "suspend" "\|" Symbol "\|" body
	651	SuspendExpression(body) = option(Symbol ":") "suspend" option(("\|" Symbol "\|" body))
652	652	*/
653	653	static AstNode ast_parse_suspend_block(ParseContext pc, size_t *token_index, bool mandatory) {
654	654	size_t orig_token_index = *token_index;
655	655
656		Token suspend_token = &pc->tokens->at(token_index);
	656	Token *name_token = nullptr;
	657	Token token = &pc->tokens->at(token_index);
	658	if (token->id == TokenIdSymbol) {
	659	*token_index += 1;
	660	Token colon_token = &pc->tokens->at(token_index);
	661	if (colon_token->id == TokenIdColon) {
	662	*token_index += 1;
	663	name_token = token;
	664	token = &pc->tokens->at(*token_index);
	665	} else if (mandatory) {
	666	ast_expect_token(pc, colon_token, TokenIdColon);
	667	zig_unreachable();
	668	} else {
	669	*token_index = orig_token_index;
	670	return nullptr;
	671	}
	672	}
	673
	674	Token *suspend_token = token;
657	675	if (suspend_token->id == TokenIdKeywordSuspend) {
658	676	*token_index += 1;
659	677	} else if (mandatory) {
...	...	@@ -675,6 +693,9 @@ static AstNode ast_parse_suspend_block(ParseContext pc, size_t *token_index, b
675	693	}
676	694
677	695	AstNode *node = ast_create_node(pc, NodeTypeSuspend, suspend_token);
	696	if (name_token != nullptr) {
	697	node->data.suspend.name = token_buf(name_token);
	698	}
678	699	node->data.suspend.promise_symbol = ast_parse_symbol(pc, token_index);
679	700	ast_eat_token(pc, token_index, TokenIdBinOr);
680	701	node->data.suspend.block = ast_parse_block(pc, token_index, true);
...	...	@@ -2923,9 +2944,6 @@ void ast_visit_node_children(AstNode node, void (visit)(AstNode *, void cont
2923	2944	visit_field(&node->data.fn_def.fn_proto, visit, context);
2924	2945	visit_field(&node->data.fn_def.body, visit, context);
2925	2946	break;
2926		case NodeTypeFnDecl:
2927		visit_field(&node->data.fn_decl.fn_proto, visit, context);
2928		break;
2929	2947	case NodeTypeParamDecl:
2930	2948	visit_field(&node->data.param_decl.type, visit, context);
2931	2949	break;

src/translate_c.cpp+45-71

...	...	@@ -3667,6 +3667,7 @@ static AstNode resolve_typedef_decl(Context c, const TypedefNameDecl *typedef_
3667	3667	if (existing_entry) {
3668	3668	return existing_entry->value;
3669	3669	}
	3670
3670	3671	QualType child_qt = typedef_decl->getUnderlyingType();
3671	3672	Buf *type_name = buf_create_from_str(decl_name(typedef_decl));
3672	3673
...	...	@@ -3700,16 +3701,19 @@ static AstNode resolve_typedef_decl(Context c, const TypedefNameDecl *typedef_
3700	3701	// use the name of this typedef
3701	3702	// TODO
3702	3703
	3704	// trans_qual_type here might cause us to look at this typedef again so we put the item in the map first
	3705	AstNode *symbol_node = trans_create_node_symbol(c, type_name);
	3706	c->decl_table.put(typedef_decl->getCanonicalDecl(), symbol_node);
	3707
3703	3708	AstNode *type_node = trans_qual_type(c, child_qt, typedef_decl->getLocation());
3704	3709	if (type_node == nullptr) {
3705	3710	emit_warning(c, typedef_decl->getLocation(), "typedef %s - unresolved child type", buf_ptr(type_name));
3706	3711	c->decl_table.put(typedef_decl, nullptr);
	3712	// TODO add global var with type_name equal to @compileError("unable to resolve C type")
3707	3713	return nullptr;
3708	3714	}
3709	3715	add_global_var(c, type_name, type_node);
3710	3716
3711		AstNode *symbol_node = trans_create_node_symbol(c, type_name);
3712		c->decl_table.put(typedef_decl->getCanonicalDecl(), symbol_node);
3713	3717	return symbol_node;
3714	3718	}
3715	3719
...	...	@@ -3744,6 +3748,7 @@ static AstNode resolve_enum_decl(Context c, const EnumDecl *enum_decl) {
3744	3748	return demote_enum_to_opaque(c, enum_decl, full_type_name, bare_name);
3745	3749	}
3746	3750
	3751
3747	3752	bool pure_enum = true;
3748	3753	uint32_t field_count = 0;
3749	3754	for (auto it = enum_def->enumerator_begin(),
...	...	@@ -3755,84 +3760,53 @@ static AstNode resolve_enum_decl(Context c, const EnumDecl *enum_decl) {
3755	3760	pure_enum = false;
3756	3761	}
3757	3762	}
3758
3759	3763	AstNode *tag_int_type = trans_qual_type(c, enum_decl->getIntegerType(), enum_decl->getLocation());
3760	3764	assert(tag_int_type);
3761	3765
3762		if (pure_enum) {
3763		AstNode *enum_node = trans_create_node(c, NodeTypeContainerDecl);
3764		enum_node->data.container_decl.kind = ContainerKindEnum;
3765		enum_node->data.container_decl.layout = ContainerLayoutExtern;
3766		// TODO only emit this tag type if the enum tag type is not the default.
3767		// I don't know what the default is, need to figure out how clang is deciding.
3768		// it appears to at least be different across gcc/msvc
3769		if (!c_is_builtin_type(c, enum_decl->getIntegerType(), BuiltinType::UInt) &&
3770		!c_is_builtin_type(c, enum_decl->getIntegerType(), BuiltinType::Int))
3771		{
3772		enum_node->data.container_decl.init_arg_expr = tag_int_type;
3773		}
3774
3775		enum_node->data.container_decl.fields.resize(field_count);
3776		uint32_t i = 0;
3777		for (auto it = enum_def->enumerator_begin(),
3778		it_end = enum_def->enumerator_end();
3779		it != it_end; ++it, i += 1)
3780		{
3781		const EnumConstantDecl enum_const = it;
3782
3783		Buf *enum_val_name = buf_create_from_str(decl_name(enum_const));
3784		Buf *field_name;
3785		if (bare_name != nullptr && buf_starts_with_buf(enum_val_name, bare_name)) {
3786		field_name = buf_slice(enum_val_name, buf_len(bare_name), buf_len(enum_val_name));
3787		} else {
3788		field_name = enum_val_name;
3789		}
3790
3791		AstNode *field_node = trans_create_node(c, NodeTypeStructField);
3792		field_node->data.struct_field.name = field_name;
3793		field_node->data.struct_field.type = nullptr;
3794		enum_node->data.container_decl.fields.items[i] = field_node;
3795
3796		// in C each enum value is in the global namespace. so we put them there too.
3797		// at this point we can rely on the enum emitting successfully
3798		if (is_anonymous) {
3799		AstNode *lit_node = trans_create_node_unsigned(c, i);
3800		add_global_var(c, enum_val_name, lit_node);
3801		} else {
3802		AstNode *field_access_node = trans_create_node_field_access(c,
3803		trans_create_node_symbol(c, full_type_name), field_name);
3804		add_global_var(c, enum_val_name, field_access_node);
3805		}
3806		}
3807
3808		if (is_anonymous) {
3809		c->decl_table.put(enum_decl->getCanonicalDecl(), enum_node);
3810		return enum_node;
3811		} else {
3812		AstNode *symbol_node = trans_create_node_symbol(c, full_type_name);
3813		add_global_weak_alias(c, bare_name, full_type_name);
3814		add_global_var(c, full_type_name, enum_node);
3815		c->decl_table.put(enum_decl->getCanonicalDecl(), symbol_node);
3816		return enum_node;
3817		}
	3766	AstNode *enum_node = trans_create_node(c, NodeTypeContainerDecl);
	3767	enum_node->data.container_decl.kind = ContainerKindEnum;
	3768	enum_node->data.container_decl.layout = ContainerLayoutExtern;
	3769	// TODO only emit this tag type if the enum tag type is not the default.
	3770	// I don't know what the default is, need to figure out how clang is deciding.
	3771	// it appears to at least be different across gcc/msvc
	3772	if (!c_is_builtin_type(c, enum_decl->getIntegerType(), BuiltinType::UInt) &&
	3773	!c_is_builtin_type(c, enum_decl->getIntegerType(), BuiltinType::Int))
	3774	{
	3775	enum_node->data.container_decl.init_arg_expr = tag_int_type;
3818	3776	}
3819
3820		// TODO after issue #305 is solved, make this be an enum with tag_int_type
3821		// as the integer type and set the custom enum values
3822		AstNode *enum_node = tag_int_type;
3823
3824
3825		// add variables for all the values with enum_node
	3777	enum_node->data.container_decl.fields.resize(field_count);
	3778	uint32_t i = 0;
3826	3779	for (auto it = enum_def->enumerator_begin(),
3827	3780	it_end = enum_def->enumerator_end();
3828		it != it_end; ++it)
	3781	it != it_end; ++it, i += 1)
3829	3782	{
3830	3783	const EnumConstantDecl enum_const = it;
3831	3784
3832	3785	Buf *enum_val_name = buf_create_from_str(decl_name(enum_const));
3833		AstNode *int_node = trans_create_node_apint(c, enum_const->getInitVal());
3834		AstNode *var_node = add_global_var(c, enum_val_name, int_node);
3835		var_node->data.variable_declaration.type = tag_int_type;
	3786	Buf *field_name;
	3787	if (bare_name != nullptr && buf_starts_with_buf(enum_val_name, bare_name)) {
	3788	field_name = buf_slice(enum_val_name, buf_len(bare_name), buf_len(enum_val_name));
	3789	} else {
	3790	field_name = enum_val_name;
	3791	}
	3792
	3793	AstNode *int_node = pure_enum && !is_anonymous ? nullptr : trans_create_node_apint(c, enum_const->getInitVal());
	3794	AstNode *field_node = trans_create_node(c, NodeTypeStructField);
	3795	field_node->data.struct_field.name = field_name;
	3796	field_node->data.struct_field.type = nullptr;
	3797	field_node->data.struct_field.value = int_node;
	3798	enum_node->data.container_decl.fields.items[i] = field_node;
	3799
	3800	// in C each enum value is in the global namespace. so we put them there too.
	3801	// at this point we can rely on the enum emitting successfully
	3802	if (is_anonymous) {
	3803	Buf *enum_val_name = buf_create_from_str(decl_name(enum_const));
	3804	add_global_var(c, enum_val_name, int_node);
	3805	} else {
	3806	AstNode *field_access_node = trans_create_node_field_access(c,
	3807	trans_create_node_symbol(c, full_type_name), field_name);
	3808	add_global_var(c, enum_val_name, field_access_node);
	3809	}
3836	3810	}
3837	3811
3838	3812	if (is_anonymous) {
...	...	@@ -3843,7 +3817,7 @@ static AstNode resolve_enum_decl(Context c, const EnumDecl *enum_decl) {
3843	3817	add_global_weak_alias(c, bare_name, full_type_name);
3844	3818	add_global_var(c, full_type_name, enum_node);
3845	3819	c->decl_table.put(enum_decl->getCanonicalDecl(), symbol_node);
3846		return symbol_node;
	3820	return enum_node;
3847	3821	}
3848	3822	}
3849	3823

src/zig_llvm.cpp+7-5

...	...	@@ -81,7 +81,7 @@ static const bool assertions_on = false;
81	81	#endif
82	82
83	83	bool ZigLLVMTargetMachineEmitToFile(LLVMTargetMachineRef targ_machine_ref, LLVMModuleRef module_ref,
84		const char filename, ZigLLVM_EmitOutputType output_type, char *error_message, bool is_debug)
	84	const char filename, ZigLLVM_EmitOutputType output_type, char *error_message, bool is_debug, bool is_small)
85	85	{
86	86	std::error_code EC;
87	87	raw_fd_ostream dest(filename, EC, sys::fs::F_None);
...	...	@@ -100,7 +100,7 @@ bool ZigLLVMTargetMachineEmitToFile(LLVMTargetMachineRef targ_machine_ref, LLVMM
100	100	return true;
101	101	}
102	102	PMBuilder->OptLevel = target_machine->getOptLevel();
103		PMBuilder->SizeLevel = 0;
	103	PMBuilder->SizeLevel = is_small ? 2 : 0;
104	104
105	105	PMBuilder->DisableTailCalls = is_debug;
106	106	PMBuilder->DisableUnitAtATime = is_debug;
...	...	@@ -765,10 +765,12 @@ static AtomicOrdering mapFromLLVMOrdering(LLVMAtomicOrdering Ordering) {
765	765
766	766	LLVMValueRef ZigLLVMBuildCmpXchg(LLVMBuilderRef builder, LLVMValueRef ptr, LLVMValueRef cmp,
767	767	LLVMValueRef new_val, LLVMAtomicOrdering success_ordering,
768		LLVMAtomicOrdering failure_ordering)
	768	LLVMAtomicOrdering failure_ordering, bool is_weak)
769	769	{
770		return wrap(unwrap(builder)->CreateAtomicCmpXchg(unwrap(ptr), unwrap(cmp), unwrap(new_val),
771		mapFromLLVMOrdering(success_ordering), mapFromLLVMOrdering(failure_ordering)));
	770	AtomicCmpXchgInst *inst = unwrap(builder)->CreateAtomicCmpXchg(unwrap(ptr), unwrap(cmp),
	771	unwrap(new_val), mapFromLLVMOrdering(success_ordering), mapFromLLVMOrdering(failure_ordering));
	772	inst->setWeak(is_weak);
	773	return wrap(inst);
772	774	}
773	775
774	776	LLVMValueRef ZigLLVMBuildNSWShl(LLVMBuilderRef builder, LLVMValueRef LHS, LLVMValueRef RHS,

src/zig_llvm.h+2-2

...	...	@@ -52,7 +52,7 @@ enum ZigLLVM_EmitOutputType {
52	52	};
53	53
54	54	ZIG_EXTERN_C bool ZigLLVMTargetMachineEmitToFile(LLVMTargetMachineRef targ_machine_ref, LLVMModuleRef module_ref,
55		const char filename, enum ZigLLVM_EmitOutputType output_type, char *error_message, bool is_debug);
	55	const char filename, enum ZigLLVM_EmitOutputType output_type, char *error_message, bool is_debug, bool is_small);
56	56
57	57	ZIG_EXTERN_C LLVMTypeRef ZigLLVMTokenTypeInContext(LLVMContextRef context_ref);
58	58
...	...	@@ -66,7 +66,7 @@ ZIG_EXTERN_C LLVMValueRef ZigLLVMBuildCall(LLVMBuilderRef B, LLVMValueRef Fn, LL
66	66
67	67	ZIG_EXTERN_C LLVMValueRef ZigLLVMBuildCmpXchg(LLVMBuilderRef builder, LLVMValueRef ptr, LLVMValueRef cmp,
68	68	LLVMValueRef new_val, LLVMAtomicOrdering success_ordering,
69		LLVMAtomicOrdering failure_ordering);
	69	LLVMAtomicOrdering failure_ordering, bool is_weak);
70	70
71	71	ZIG_EXTERN_C LLVMValueRef ZigLLVMBuildNSWShl(LLVMBuilderRef builder, LLVMValueRef LHS, LLVMValueRef RHS,
72	72	const char *name);

std/array_list.zig+64-2

...	...	@@ -28,11 +28,11 @@ pub fn AlignedArrayList(comptime T: type, comptime A: u29) type{
28	28	};
29	29	}
30	30
31		pub fn deinit(l: &Self) void {
	31	pub fn deinit(l: &const Self) void {
32	32	l.allocator.free(l.items);
33	33	}
34	34
35		pub fn toSlice(l: &Self) []align(A) T {
	35	pub fn toSlice(l: &const Self) []align(A) T {
36	36	return l.items[0..l.len];
37	37	}
38	38
...	...	@@ -44,6 +44,10 @@ pub fn AlignedArrayList(comptime T: type, comptime A: u29) type{
44	44	return l.toSliceConst()[n];
45	45	}
46	46
	47	pub fn count(self: &const Self) usize {
	48	return self.len;
	49	}
	50
47	51	/// ArrayList takes ownership of the passed in slice. The slice must have been
48	52	/// allocated with `allocator`.
49	53	/// Deinitialize with `deinit` or use `toOwnedSlice`.
...	...	@@ -128,6 +132,27 @@ pub fn AlignedArrayList(comptime T: type, comptime A: u29) type{
128	132	return null;
129	133	return self.pop();
130	134	}
	135
	136	pub const Iterator = struct {
	137	list: &const Self,
	138	// how many items have we returned
	139	count: usize,
	140
	141	pub fn next(it: &Iterator) ?T {
	142	if (it.count >= it.list.len) return null;
	143	const val = it.list.at(it.count);
	144	it.count += 1;
	145	return val;
	146	}
	147
	148	pub fn reset(it: &Iterator) void {
	149	it.count = 0;
	150	}
	151	};
	152
	153	pub fn iterator(self: &const Self) Iterator {
	154	return Iterator { .list = self, .count = 0 };
	155	}
131	156	};
132	157	}
133	158
...	...	@@ -143,6 +168,14 @@ test "basic ArrayList test" {
143	168	assert(list.items[i] == i32(i + 1));
144	169	}}
145	170
	171	for (list.toSlice()) \|v, i\| {
	172	assert(v == i32(i + 1));
	173	}
	174
	175	for (list.toSliceConst()) \|v, i\| {
	176	assert(v == i32(i + 1));
	177	}
	178
146	179	assert(list.pop() == 10);
147	180	assert(list.len == 9);
148	181
...	...	@@ -157,6 +190,35 @@ test "basic ArrayList test" {
157	190	assert(list.len == 9);
158	191	}
159	192
	193	test "iterator ArrayList test" {
	194	var list = ArrayList(i32).init(debug.global_allocator);
	195	defer list.deinit();
	196
	197	try list.append(1);
	198	try list.append(2);
	199	try list.append(3);
	200
	201	var count : i32 = 0;
	202	var it = list.iterator();
	203	while (it.next()) \|next\| {
	204	assert(next == count + 1);
	205	count += 1;
	206	}
	207
	208	assert(count == 3);
	209	assert(it.next() == null);
	210	it.reset();
	211	count = 0;
	212	while (it.next()) \|next\| {
	213	assert(next == count + 1);
	214	count += 1;
	215	if (count == 2) break;
	216	}
	217
	218	it.reset();
	219	assert(?? it.next() == 1);
	220	}
	221
160	222	test "insert ArrayList test" {
161	223	var list = ArrayList(i32).init(debug.global_allocator);
162	224	defer list.deinit();

std/atomic/index.zig created+7

...	...	@@ -0,0 +1,7 @@
	1	pub const Stack = @import("stack.zig").Stack;
	2	pub const Queue = @import("queue.zig").Queue;
	3
	4	test "std.atomic" {
	5	_ = @import("stack.zig").Stack;
	6	_ = @import("queue.zig").Queue;
	7	}

std/atomic/queue.zig created+126

...	...	@@ -0,0 +1,126 @@
	1	const builtin = @import("builtin");
	2	const AtomicOrder = builtin.AtomicOrder;
	3	const AtomicRmwOp = builtin.AtomicRmwOp;
	4
	5	/// Many reader, many writer, non-allocating, thread-safe, lock-free
	6	pub fn Queue(comptime T: type) type {
	7	return struct {
	8	head: &Node,
	9	tail: &Node,
	10	root: Node,
	11
	12	pub const Self = this;
	13
	14	pub const Node = struct {
	15	next: ?&Node,
	16	data: T,
	17	};
	18
	19	// TODO: well defined copy elision: https://github.com/zig-lang/zig/issues/287
	20	pub fn init(self: &Self) void {
	21	self.root.next = null;
	22	self.head = &self.root;
	23	self.tail = &self.root;
	24	}
	25
	26	pub fn put(self: &Self, node: &Node) void {
	27	node.next = null;
	28
	29	const tail = @atomicRmw(&Node, &self.tail, AtomicRmwOp.Xchg, node, AtomicOrder.SeqCst);
	30	_ = @atomicRmw(?&Node, &tail.next, AtomicRmwOp.Xchg, node, AtomicOrder.SeqCst);
	31	}
	32
	33	pub fn get(self: &Self) ?&Node {
	34	var head = @atomicLoad(&Node, &self.head, AtomicOrder.SeqCst);
	35	while (true) {
	36	const node = head.next ?? return null;
	37	head = @cmpxchgWeak(&Node, &self.head, head, node, AtomicOrder.SeqCst, AtomicOrder.SeqCst) ?? return node;
	38	}
	39	}
	40	};
	41	}
	42
	43	const std = @import("std");
	44	const Context = struct {
	45	allocator: &std.mem.Allocator,
	46	queue: &Queue(i32),
	47	put_sum: isize,
	48	get_sum: isize,
	49	get_count: usize,
	50	puts_done: u8, // TODO make this a bool
	51	};
	52
	53	// TODO add lazy evaluated build options and then put puts_per_thread behind
	54	// some option such as: "AggressiveMultithreadedFuzzTest". In the AppVeyor
	55	// CI we would use a less aggressive setting since at 1 core, while we still
	56	// want this test to pass, we need a smaller value since there is so much thrashing
	57	// we would also use a less aggressive setting when running in valgrind
	58	const puts_per_thread = 500;
	59	const put_thread_count = 3;
	60
	61	test "std.atomic.queue" {
	62	var direct_allocator = std.heap.DirectAllocator.init();
	63	defer direct_allocator.deinit();
	64
	65	var plenty_of_memory = try direct_allocator.allocator.alloc(u8, 300 * 1024);
	66	defer direct_allocator.allocator.free(plenty_of_memory);
	67
	68	var fixed_buffer_allocator = std.heap.ThreadSafeFixedBufferAllocator.init(plenty_of_memory);
	69	var a = &fixed_buffer_allocator.allocator;
	70
	71	var queue: Queue(i32) = undefined;
	72	queue.init();
	73	var context = Context {
	74	.allocator = a,
	75	.queue = &queue,
	76	.put_sum = 0,
	77	.get_sum = 0,
	78	.puts_done = 0,
	79	.get_count = 0,
	80	};
	81
	82	var putters: [put_thread_count]&std.os.Thread = undefined;
	83	for (putters) \|*t\| {
	84	*t = try std.os.spawnThread(&context, startPuts);
	85	}
	86	var getters: [put_thread_count]&std.os.Thread = undefined;
	87	for (getters) \|*t\| {
	88	*t = try std.os.spawnThread(&context, startGets);
	89	}
	90
	91	for (putters) \|t\| t.wait();
	92	_ = @atomicRmw(u8, &context.puts_done, builtin.AtomicRmwOp.Xchg, 1, AtomicOrder.SeqCst);
	93	for (getters) \|t\| t.wait();
	94
	95	std.debug.assert(context.put_sum == context.get_sum);
	96	std.debug.assert(context.get_count == puts_per_thread * put_thread_count);
	97	}
	98
	99	fn startPuts(ctx: &Context) u8 {
	100	var put_count: usize = puts_per_thread;
	101	var r = std.rand.DefaultPrng.init(0xdeadbeef);
	102	while (put_count != 0) : (put_count -= 1) {
	103	std.os.time.sleep(0, 1); // let the os scheduler be our fuzz
	104	const x = @bitCast(i32, r.random.scalar(u32));
	105	const node = ctx.allocator.create(Queue(i32).Node) catch unreachable;
	106	node.data = x;
	107	ctx.queue.put(node);
	108	_ = @atomicRmw(isize, &ctx.put_sum, builtin.AtomicRmwOp.Add, x, AtomicOrder.SeqCst);
	109	}
	110	return 0;
	111	}
	112
	113	fn startGets(ctx: &Context) u8 {
	114	while (true) {
	115	while (ctx.queue.get()) \|node\| {
	116	std.os.time.sleep(0, 1); // let the os scheduler be our fuzz
	117	_ = @atomicRmw(isize, &ctx.get_sum, builtin.AtomicRmwOp.Add, node.data, builtin.AtomicOrder.SeqCst);
	118	_ = @atomicRmw(usize, &ctx.get_count, builtin.AtomicRmwOp.Add, 1, builtin.AtomicOrder.SeqCst);
	119	}
	120
	121	if (@atomicLoad(u8, &ctx.puts_done, builtin.AtomicOrder.SeqCst) == 1) {
	122	break;
	123	}
	124	}
	125	return 0;
	126	}

std/atomic/stack.zig created+131

...	...	@@ -0,0 +1,131 @@
	1	const builtin = @import("builtin");
	2	const AtomicOrder = builtin.AtomicOrder;
	3
	4	/// Many reader, many writer, non-allocating, thread-safe, lock-free
	5	pub fn Stack(comptime T: type) type {
	6	return struct {
	7	root: ?&Node,
	8
	9	pub const Self = this;
	10
	11	pub const Node = struct {
	12	next: ?&Node,
	13	data: T,
	14	};
	15
	16	pub fn init() Self {
	17	return Self {
	18	.root = null,
	19	};
	20	}
	21
	22	/// push operation, but only if you are the first item in the stack. if you did not succeed in
	23	/// being the first item in the stack, returns the other item that was there.
	24	pub fn pushFirst(self: &Self, node: &Node) ?&Node {
	25	node.next = null;
	26	return @cmpxchgStrong(?&Node, &self.root, null, node, AtomicOrder.SeqCst, AtomicOrder.SeqCst);
	27	}
	28
	29	pub fn push(self: &Self, node: &Node) void {
	30	var root = @atomicLoad(?&Node, &self.root, AtomicOrder.SeqCst);
	31	while (true) {
	32	node.next = root;
	33	root = @cmpxchgWeak(?&Node, &self.root, root, node, AtomicOrder.SeqCst, AtomicOrder.SeqCst) ?? break;
	34	}
	35	}
	36
	37	pub fn pop(self: &Self) ?&Node {
	38	var root = @atomicLoad(?&Node, &self.root, AtomicOrder.SeqCst);
	39	while (true) {
	40	root = @cmpxchgWeak(?&Node, &self.root, root, (root ?? return null).next, AtomicOrder.SeqCst, AtomicOrder.SeqCst) ?? return root;
	41	}
	42	}
	43
	44	pub fn isEmpty(self: &Self) bool {
	45	return @atomicLoad(?&Node, &self.root, AtomicOrder.SeqCst) == null;
	46	}
	47	};
	48	}
	49
	50	const std = @import("std");
	51	const Context = struct {
	52	allocator: &std.mem.Allocator,
	53	stack: &Stack(i32),
	54	put_sum: isize,
	55	get_sum: isize,
	56	get_count: usize,
	57	puts_done: u8, // TODO make this a bool
	58	};
	59	// TODO add lazy evaluated build options and then put puts_per_thread behind
	60	// some option such as: "AggressiveMultithreadedFuzzTest". In the AppVeyor
	61	// CI we would use a less aggressive setting since at 1 core, while we still
	62	// want this test to pass, we need a smaller value since there is so much thrashing
	63	// we would also use a less aggressive setting when running in valgrind
	64	const puts_per_thread = 500;
	65	const put_thread_count = 3;
	66
	67	test "std.atomic.stack" {
	68	var direct_allocator = std.heap.DirectAllocator.init();
	69	defer direct_allocator.deinit();
	70
	71	var plenty_of_memory = try direct_allocator.allocator.alloc(u8, 300 * 1024);
	72	defer direct_allocator.allocator.free(plenty_of_memory);
	73
	74	var fixed_buffer_allocator = std.heap.ThreadSafeFixedBufferAllocator.init(plenty_of_memory);
	75	var a = &fixed_buffer_allocator.allocator;
	76
	77	var stack = Stack(i32).init();
	78	var context = Context {
	79	.allocator = a,
	80	.stack = &stack,
	81	.put_sum = 0,
	82	.get_sum = 0,
	83	.puts_done = 0,
	84	.get_count = 0,
	85	};
	86
	87	var putters: [put_thread_count]&std.os.Thread = undefined;
	88	for (putters) \|*t\| {
	89	*t = try std.os.spawnThread(&context, startPuts);
	90	}
	91	var getters: [put_thread_count]&std.os.Thread = undefined;
	92	for (getters) \|*t\| {
	93	*t = try std.os.spawnThread(&context, startGets);
	94	}
	95
	96	for (putters) \|t\| t.wait();
	97	_ = @atomicRmw(u8, &context.puts_done, builtin.AtomicRmwOp.Xchg, 1, AtomicOrder.SeqCst);
	98	for (getters) \|t\| t.wait();
	99
	100	std.debug.assert(context.put_sum == context.get_sum);
	101	std.debug.assert(context.get_count == puts_per_thread * put_thread_count);
	102	}
	103
	104	fn startPuts(ctx: &Context) u8 {
	105	var put_count: usize = puts_per_thread;
	106	var r = std.rand.DefaultPrng.init(0xdeadbeef);
	107	while (put_count != 0) : (put_count -= 1) {
	108	std.os.time.sleep(0, 1); // let the os scheduler be our fuzz
	109	const x = @bitCast(i32, r.random.scalar(u32));
	110	const node = ctx.allocator.create(Stack(i32).Node) catch unreachable;
	111	node.data = x;
	112	ctx.stack.push(node);
	113	_ = @atomicRmw(isize, &ctx.put_sum, builtin.AtomicRmwOp.Add, x, AtomicOrder.SeqCst);
	114	}
	115	return 0;
	116	}
	117
	118	fn startGets(ctx: &Context) u8 {
	119	while (true) {
	120	while (ctx.stack.pop()) \|node\| {
	121	std.os.time.sleep(0, 1); // let the os scheduler be our fuzz
	122	_ = @atomicRmw(isize, &ctx.get_sum, builtin.AtomicRmwOp.Add, node.data, builtin.AtomicOrder.SeqCst);
	123	_ = @atomicRmw(usize, &ctx.get_count, builtin.AtomicRmwOp.Add, 1, builtin.AtomicOrder.SeqCst);
	124	}
	125
	126	if (@atomicLoad(u8, &ctx.puts_done, builtin.AtomicOrder.SeqCst) == 1) {
	127	break;
	128	}
	129	}
	130	return 0;
	131	}

std/buf_map.zig+40-23

...	...	@@ -1,6 +1,8 @@
1		const HashMap = @import("hash_map.zig").HashMap;
2		const mem = @import("mem.zig");
	1	const std = @import("index.zig");
	2	const HashMap = std.HashMap;
	3	const mem = std.mem;
3	4	const Allocator = mem.Allocator;
	5	const assert = std.debug.assert;
4	6
5	7	/// BufMap copies keys and values before they go into the map, and
6	8	/// frees them when they get removed.
...	...	@@ -16,10 +18,10 @@ pub const BufMap = struct {
16	18	return self;
17	19	}
18	20
19		pub fn deinit(self: &BufMap) void {
	21	pub fn deinit(self: &const BufMap) void {
20	22	var it = self.hash_map.iterator();
21	23	while (true) {
22		const entry = it.next() ?? break;
	24	const entry = it.next() ?? break;
23	25	self.free(entry.key);
24	26	self.free(entry.value);
25	27	}
...	...	@@ -28,21 +30,15 @@ pub const BufMap = struct {
28	30	}
29	31
30	32	pub fn set(self: &BufMap, key: []const u8, value: []const u8) !void {
31		if (self.hash_map.get(key)) \|entry\| {
32		const value_copy = try self.copy(value);
33		errdefer self.free(value_copy);
34		_ = try self.hash_map.put(key, value_copy);
35		self.free(entry.value);
36		} else {
37		const key_copy = try self.copy(key);
38		errdefer self.free(key_copy);
39		const value_copy = try self.copy(value);
40		errdefer self.free(value_copy);
41		_ = try self.hash_map.put(key_copy, value_copy);
42		}
	33	self.delete(key);
	34	const key_copy = try self.copy(key);
	35	errdefer self.free(key_copy);
	36	const value_copy = try self.copy(value);
	37	errdefer self.free(value_copy);
	38	_ = try self.hash_map.put(key_copy, value_copy);
43	39	}
44	40
45		pub fn get(self: &BufMap, key: []const u8) ?[]const u8 {
	41	pub fn get(self: &const BufMap, key: []const u8) ?[]const u8 {
46	42	const entry = self.hash_map.get(key) ?? return null;
47	43	return entry.value;
48	44	}
...	...	@@ -54,20 +50,41 @@ pub const BufMap = struct {
54	50	}
55	51
56	52	pub fn count(self: &const BufMap) usize {
57		return self.hash_map.size;
	53	return self.hash_map.count();
58	54	}
59	55
60	56	pub fn iterator(self: &const BufMap) BufMapHashMap.Iterator {
61	57	return self.hash_map.iterator();
62	58	}
63	59
64		fn free(self: &BufMap, value: []const u8) void {
	60	fn free(self: &const BufMap, value: []const u8) void {
65	61	self.hash_map.allocator.free(value);
66	62	}
67	63
68		fn copy(self: &BufMap, value: []const u8) ![]const u8 {
69		const result = try self.hash_map.allocator.alloc(u8, value.len);
70		mem.copy(u8, result, value);
71		return result;
	64	fn copy(self: &const BufMap, value: []const u8) ![]const u8 {
	65	return mem.dupe(self.hash_map.allocator, u8, value);
72	66	}
73	67	};
	68
	69	test "BufMap" {
	70	var direct_allocator = std.heap.DirectAllocator.init();
	71	defer direct_allocator.deinit();
	72
	73	var bufmap = BufMap.init(&direct_allocator.allocator);
	74	defer bufmap.deinit();
	75
	76	try bufmap.set("x", "1");
	77	assert(mem.eql(u8, ??bufmap.get("x"), "1"));
	78	assert(1 == bufmap.count());
	79
	80	try bufmap.set("x", "2");
	81	assert(mem.eql(u8, ??bufmap.get("x"), "2"));
	82	assert(1 == bufmap.count());
	83
	84	try bufmap.set("x", "3");
	85	assert(mem.eql(u8, ??bufmap.get("x"), "3"));
	86	assert(1 == bufmap.count());
	87
	88	bufmap.delete("x");
	89	assert(0 == bufmap.count());
	90	}

std/buf_set.zig+23-5

...	...	@@ -1,6 +1,8 @@
	1	const std = @import("index.zig");
1	2	const HashMap = @import("hash_map.zig").HashMap;
2	3	const mem = @import("mem.zig");
3	4	const Allocator = mem.Allocator;
	5	const assert = std.debug.assert;
4	6
5	7	pub const BufSet = struct {
6	8	hash_map: BufSetHashMap,
...	...	@@ -14,10 +16,10 @@ pub const BufSet = struct {
14	16	return self;
15	17	}
16	18
17		pub fn deinit(self: &BufSet) void {
	19	pub fn deinit(self: &const BufSet) void {
18	20	var it = self.hash_map.iterator();
19	21	while (true) {
20		const entry = it.next() ?? break;
	22	const entry = it.next() ?? break;
21	23	self.free(entry.key);
22	24	}
23	25
...	...	@@ -38,7 +40,7 @@ pub const BufSet = struct {
38	40	}
39	41
40	42	pub fn count(self: &const BufSet) usize {
41		return self.hash_map.size;
	43	return self.hash_map.count();
42	44	}
43	45
44	46	pub fn iterator(self: &const BufSet) BufSetHashMap.Iterator {
...	...	@@ -49,14 +51,30 @@ pub const BufSet = struct {
49	51	return self.hash_map.allocator;
50	52	}
51	53
52		fn free(self: &BufSet, value: []const u8) void {
	54	fn free(self: &const BufSet, value: []const u8) void {
53	55	self.hash_map.allocator.free(value);
54	56	}
55	57
56		fn copy(self: &BufSet, value: []const u8) ![]const u8 {
	58	fn copy(self: &const BufSet, value: []const u8) ![]const u8 {
57	59	const result = try self.hash_map.allocator.alloc(u8, value.len);
58	60	mem.copy(u8, result, value);
59	61	return result;
60	62	}
61	63	};
62	64
	65	test "BufSet" {
	66	var direct_allocator = std.heap.DirectAllocator.init();
	67	defer direct_allocator.deinit();
	68
	69	var bufset = BufSet.init(&direct_allocator.allocator);
	70	defer bufset.deinit();
	71
	72	try bufset.put("x");
	73	assert(bufset.count() == 1);
	74	bufset.delete("x");
	75	assert(bufset.count() == 0);
	76
	77	try bufset.put("x");
	78	try bufset.put("y");
	79	try bufset.put("z");
	80	}

std/buffer.zig+6-22

...	...	@@ -66,7 +66,7 @@ pub const Buffer = struct {
66	66	self.list.deinit();
67	67	}
68	68
69		pub fn toSlice(self: &Buffer) []u8 {
	69	pub fn toSlice(self: &const Buffer) []u8 {
70	70	return self.list.toSlice()[0..self.len()];
71	71	}
72	72
...	...	@@ -99,26 +99,10 @@ pub const Buffer = struct {
99	99	mem.copy(u8, self.list.toSlice()[old_len..], m);
100	100	}
101	101
102		// TODO: remove, use OutStream for this
103		pub fn appendFormat(self: &Buffer, comptime format: []const u8, args: ...) !void {
104		return fmt.format(self, append, format, args);
105		}
106
107		// TODO: remove, use OutStream for this
108	102	pub fn appendByte(self: &Buffer, byte: u8) !void {
109		return self.appendByteNTimes(byte, 1);
110		}
111
112		// TODO: remove, use OutStream for this
113		pub fn appendByteNTimes(self: &Buffer, byte: u8, count: usize) !void {
114		var prev_size: usize = self.len();
115		const new_size = prev_size + count;
116		try self.resize(new_size);
117
118		var i: usize = prev_size;
119		while (i < new_size) : (i += 1) {
120		self.list.items[i] = byte;
121		}
	103	const old_len = self.len();
	104	try self.resize(old_len + 1);
	105	self.list.toSlice()[old_len] = byte;
122	106	}
123	107
124	108	pub fn eql(self: &const Buffer, m: []const u8) bool {
...	...	@@ -154,7 +138,7 @@ test "simple Buffer" {
154	138	var buf = try Buffer.init(debug.global_allocator, "");
155	139	assert(buf.len() == 0);
156	140	try buf.append("hello");
157		try buf.appendByte(' ');
	141	try buf.append(" ");
158	142	try buf.append("world");
159	143	assert(buf.eql("hello world"));
160	144	assert(mem.eql(u8, cstr.toSliceConst(buf.toSliceConst().ptr), buf.toSliceConst()));
...	...	@@ -166,5 +150,5 @@ test "simple Buffer" {
166	150	assert(buf.endsWith("orld"));
167	151
168	152	try buf2.resize(4);
169		assert(buf.startsWith(buf2.toSliceConst()));
	153	assert(buf.startsWith(buf2.toSlice()));
170	154	}

std/build.zig+10-5

...	...	@@ -426,15 +426,18 @@ pub const Builder = struct {
426	426
427	427	const release_safe = self.option(bool, "release-safe", "optimizations on and safety on") ?? false;
428	428	const release_fast = self.option(bool, "release-fast", "optimizations on and safety off") ?? false;
	429	const release_small = self.option(bool, "release-small", "size optimizations on and safety off") ?? false;
429	430
430		const mode = if (release_safe and !release_fast)
	431	const mode = if (release_safe and !release_fast and !release_small)
431	432	builtin.Mode.ReleaseSafe
432		else if (release_fast and !release_safe)
	433	else if (release_fast and !release_safe and !release_small)
433	434	builtin.Mode.ReleaseFast
434		else if (!release_fast and !release_safe)
	435	else if (release_small and !release_fast and !release_safe)
	436	builtin.Mode.ReleaseSmall
	437	else if (!release_fast and !release_safe and !release_small)
435	438	builtin.Mode.Debug
436	439	else x: {
437		warn("Both -Drelease-safe and -Drelease-fast specified");
	440	warn("Multiple release modes (of -Drelease-safe, -Drelease-fast and -Drelease-small)");
438	441	self.markInvalidUserInput();
439	442	break :x builtin.Mode.Debug;
440	443	};
...	...	@@ -1229,6 +1232,7 @@ pub const LibExeObjStep = struct {
1229	1232	builtin.Mode.Debug => {},
1230	1233	builtin.Mode.ReleaseSafe => zig_args.append("--release-safe") catch unreachable,
1231	1234	builtin.Mode.ReleaseFast => zig_args.append("--release-fast") catch unreachable,
	1235	builtin.Mode.ReleaseSmall => zig_args.append("--release-small") catch unreachable,
1232	1236	}
1233	1237
1234	1238	zig_args.append("--cache-dir") catch unreachable;
...	...	@@ -1369,7 +1373,7 @@ pub const LibExeObjStep = struct {
1369	1373	args.append("ssp-buffer-size=4") catch unreachable;
1370	1374	}
1371	1375	},
1372		builtin.Mode.ReleaseFast => {
	1376	builtin.Mode.ReleaseFast, builtin.Mode.ReleaseSmall => {
1373	1377	args.append("-O2") catch unreachable;
1374	1378	args.append("-fno-stack-protector") catch unreachable;
1375	1379	},
...	...	@@ -1706,6 +1710,7 @@ pub const TestStep = struct {
1706	1710	builtin.Mode.Debug => {},
1707	1711	builtin.Mode.ReleaseSafe => try zig_args.append("--release-safe"),
1708	1712	builtin.Mode.ReleaseFast => try zig_args.append("--release-fast"),
	1713	builtin.Mode.ReleaseSmall => try zig_args.append("--release-small"),
1709	1714	}
1710	1715
1711	1716	switch (self.target) {

std/c/darwin.zig+31

...	...	@@ -3,10 +3,28 @@ pub extern "c" fn _NSGetExecutablePath(buf: &u8, bufsize: &u32) c_int;
3	3
4	4	pub extern "c" fn __getdirentries64(fd: c_int, buf_ptr: &u8, buf_len: usize, basep: &i64) usize;
5	5
	6	pub extern "c" fn mach_absolute_time() u64;
	7	pub extern "c" fn mach_timebase_info(tinfo: ?&mach_timebase_info_data) void;
	8
6	9	pub use @import("../os/darwin_errno.zig");
7	10
8	11	pub const _errno = __error;
9	12
	13	pub const timeval = extern struct {
	14	tv_sec: isize,
	15	tv_usec: isize,
	16	};
	17
	18	pub const timezone = extern struct {
	19	tz_minuteswest: i32,
	20	tz_dsttime: i32,
	21	};
	22
	23	pub const mach_timebase_info_data = struct {
	24	numer: u32,
	25	denom: u32,
	26	};
	27
10	28	/// Renamed to Stat to not conflict with the stat function.
11	29	pub const Stat = extern struct {
12	30	dev: i32,
...	...	@@ -55,3 +73,16 @@ pub const dirent = extern struct {
55	73	d_type: u8,
56	74	d_name: u8, // field address is address of first byte of name
57	75	};
	76
	77	pub const sockaddr = extern struct {
	78	sa_len: u8,
	79	sa_family: sa_family_t,
	80	sa_data: [14]u8,
	81	};
	82
	83	pub const sa_family_t = u8;
	84
	85	pub const pthread_attr_t = extern struct {
	86	__sig: c_long,
	87	__opaque: [56]u8,
	88	};

std/c/index.zig+12

...	...	@@ -28,6 +28,7 @@ pub extern "c" fn unlink(path: &const u8) c_int;
28	28	pub extern "c" fn getcwd(buf: &u8, size: usize) ?&u8;
29	29	pub extern "c" fn waitpid(pid: c_int, stat_loc: &c_int, options: c_int) c_int;
30	30	pub extern "c" fn fork() c_int;
	31	pub extern "c" fn access(path: &const u8, mode: c_uint) c_int;
31	32	pub extern "c" fn pipe(fds: &c_int) c_int;
32	33	pub extern "c" fn mkdir(path: &const u8, mode: c_uint) c_int;
33	34	pub extern "c" fn symlink(existing: &const u8, new: &const u8) c_int;
...	...	@@ -40,6 +41,7 @@ pub extern "c" fn dup2(old_fd: c_int, new_fd: c_int) c_int;
40	41	pub extern "c" fn readlink(noalias path: &const u8, noalias buf: &u8, bufsize: usize) isize;
41	42	pub extern "c" fn realpath(noalias file_name: &const u8, noalias resolved_name: &u8) ?&u8;
42	43	pub extern "c" fn sigprocmask(how: c_int, noalias set: &const sigset_t, noalias oset: ?&sigset_t) c_int;
	44	pub extern "c" fn gettimeofday(tv: ?&timeval, tz: ?&timezone) c_int;
43	45	pub extern "c" fn sigaction(sig: c_int, noalias act: &const Sigaction, noalias oact: ?&Sigaction) c_int;
44	46	pub extern "c" fn nanosleep(rqtp: &const timespec, rmtp: ?&timespec) c_int;
45	47	pub extern "c" fn setreuid(ruid: c_uint, euid: c_uint) c_int;
...	...	@@ -51,3 +53,13 @@ pub extern "c" fn malloc(usize) ?&c_void;
51	53	pub extern "c" fn realloc(&c_void, usize) ?&c_void;
52	54	pub extern "c" fn free(&c_void) void;
53	55	pub extern "c" fn posix_memalign(memptr: &&c_void, alignment: usize, size: usize) c_int;
	56
	57	pub extern "pthread" fn pthread_create(noalias newthread: &pthread_t,
	58	noalias attr: ?&const pthread_attr_t, start_routine: extern fn(?&c_void) ?&c_void,
	59	noalias arg: ?&c_void) c_int;
	60	pub extern "pthread" fn pthread_attr_init(attr: &pthread_attr_t) c_int;
	61	pub extern "pthread" fn pthread_attr_setstack(attr: &pthread_attr_t, stackaddr: &c_void, stacksize: usize) c_int;
	62	pub extern "pthread" fn pthread_attr_destroy(attr: &pthread_attr_t) c_int;
	63	pub extern "pthread" fn pthread_join(thread: pthread_t, arg_return: ?&?&c_void) c_int;
	64
	65	pub const pthread_t = &@OpaqueType();

std/c/linux.zig+5

...	...	@@ -3,3 +3,8 @@ pub use @import("../os/linux/errno.zig");
3	3	pub extern "c" fn getrandom(buf_ptr: &u8, buf_len: usize, flags: c_uint) c_int;
4	4	extern "c" fn __errno_location() &c_int;
5	5	pub const _errno = __errno_location;
	6
	7	pub const pthread_attr_t = extern struct {
	8	__size: [56]u8,
	9	__align: c_long,
	10	};

std/crypto/throughput_test.zig+11-16

...	...	@@ -1,22 +1,17 @@
1	1	// Modify the HashFunction variable to the one wanted to test.
2	2	//
3		// NOTE: The throughput measurement may be slightly lower than other measurements since we run
4		// through our block alignment functions as well. Be aware when comparing against other tests.
5		//
6	3	// ```
7		// zig build-exe --release-fast --library c throughput_test.zig
	4	// zig build-exe --release-fast throughput_test.zig
8	5	// ./throughput_test
9	6	// ```
10		const HashFunction = @import("md5.zig").Md5;
11		const BytesToHash = 1024 * Mb;
12	7
13	8	const std = @import("std");
	9	const time = std.os.time;
	10	const Timer = time.Timer;
	11	const HashFunction = @import("md5.zig").Md5;
14	12
15		const c = @cImport({
16		@cInclude("time.h");
17		});
18
19		const Mb = 1024 * 1024;
	13	const MiB = 1024 * 1024;
	14	const BytesToHash = 1024 * MiB;
20	15
21	16	pub fn main() !void {
22	17	var stdout_file = try std.io.getStdOut();
...	...	@@ -29,15 +24,15 @@ pub fn main() !void {
29	24	var h = HashFunction.init();
30	25	var offset: usize = 0;
31	26
32		const start = c.clock();
	27	var timer = try Timer.start();
	28	const start = timer.lap();
33	29	while (offset < BytesToHash) : (offset += block.len) {
34	30	h.update(block[0..]);
35	31	}
36		const end = c.clock();
	32	const end = timer.read();
37	33
38		const elapsed_s = f64((end - start) * c.CLOCKS_PER_SEC) / 1000000;
	34	const elapsed_s = f64(end - start) / time.ns_per_s;
39	35	const throughput = u64(BytesToHash / elapsed_s);
40	36
41		try stdout.print("{}: ", @typeName(HashFunction));
42		try stdout.print("{} Mb/s\n", throughput);
	37	try stdout.print("{}: {} MiB/s\n", @typeName(HashFunction), throughput / (1 * MiB));
43	38	}

std/debug/index.zig+20-5

...	...	@@ -38,7 +38,7 @@ pub fn getSelfDebugInfo() !&ElfStackTrace {
38	38	if (self_debug_info) \|info\| {
39	39	return info;
40	40	} else {
41		const info = try openSelfDebugInfo(global_allocator);
	41	const info = try openSelfDebugInfo(getDebugInfoAllocator());
42	42	self_debug_info = info;
43	43	return info;
44	44	}
...	...	@@ -51,7 +51,7 @@ pub fn dumpCurrentStackTrace(start_addr: ?usize) void {
51	51	stderr.print("Unable to dump stack trace: Unable to open debug info: {}\n", @errorName(err)) catch return;
52	52	return;
53	53	};
54		writeCurrentStackTrace(stderr, global_allocator, debug_info, stderr_file.isTty(), start_addr) catch \|err\| {
	54	writeCurrentStackTrace(stderr, getDebugInfoAllocator(), debug_info, stderr_file.isTty(), start_addr) catch \|err\| {
55	55	stderr.print("Unable to dump stack trace: {}\n", @errorName(err)) catch return;
56	56	return;
57	57	};
...	...	@@ -64,7 +64,7 @@ pub fn dumpStackTrace(stack_trace: &const builtin.StackTrace) void {
64	64	stderr.print("Unable to dump stack trace: Unable to open debug info: {}\n", @errorName(err)) catch return;
65	65	return;
66	66	};
67		writeStackTrace(stack_trace, stderr, global_allocator, debug_info, stderr_file.isTty()) catch \|err\| {
	67	writeStackTrace(stack_trace, stderr, getDebugInfoAllocator(), debug_info, stderr_file.isTty()) catch \|err\| {
68	68	stderr.print("Unable to dump stack trace: {}\n", @errorName(err)) catch return;
69	69	return;
70	70	};
...	...	@@ -592,8 +592,8 @@ fn getString(st: &ElfStackTrace, offset: u64) ![]u8 {
592	592	}
593	593
594	594	fn readAllocBytes(allocator: &mem.Allocator, in_stream: var, size: usize) ![]u8 {
595		const buf = try global_allocator.alloc(u8, size);
596		errdefer global_allocator.free(buf);
	595	const buf = try allocator.alloc(u8, size);
	596	errdefer allocator.free(buf);
597	597	if ((try in_stream.read(buf)) < size) return error.EndOfFile;
598	598	return buf;
599	599	}
...	...	@@ -1126,6 +1126,21 @@ fn readILeb128(in_stream: var) !i64 {
1126	1126	}
1127	1127	}
1128	1128
	1129	/// This should only be used in temporary test programs.
1129	1130	pub const global_allocator = &global_fixed_allocator.allocator;
1130	1131	var global_fixed_allocator = std.heap.FixedBufferAllocator.init(global_allocator_mem[0..]);
1131	1132	var global_allocator_mem: [100 * 1024]u8 = undefined;
	1133
	1134
	1135	// TODO make thread safe
	1136	var debug_info_allocator: ?&mem.Allocator = null;
	1137	var debug_info_direct_allocator: std.heap.DirectAllocator = undefined;
	1138	var debug_info_arena_allocator: std.heap.ArenaAllocator = undefined;
	1139	fn getDebugInfoAllocator() &mem.Allocator {
	1140	if (debug_info_allocator) \|a\| return a;
	1141
	1142	debug_info_direct_allocator = std.heap.DirectAllocator.init();
	1143	debug_info_arena_allocator = std.heap.ArenaAllocator.init(&debug_info_direct_allocator.allocator);
	1144	debug_info_allocator = &debug_info_arena_allocator.allocator;
	1145	return &debug_info_arena_allocator.allocator;
	1146	}

std/elf.zig+611

...	...	@@ -7,6 +7,246 @@ const mem = std.mem;
7	7	const debug = std.debug;
8	8	const InStream = std.stream.InStream;
9	9
	10	pub const AT_NULL = 0;
	11	pub const AT_IGNORE = 1;
	12	pub const AT_EXECFD = 2;
	13	pub const AT_PHDR = 3;
	14	pub const AT_PHENT = 4;
	15	pub const AT_PHNUM = 5;
	16	pub const AT_PAGESZ = 6;
	17	pub const AT_BASE = 7;
	18	pub const AT_FLAGS = 8;
	19	pub const AT_ENTRY = 9;
	20	pub const AT_NOTELF = 10;
	21	pub const AT_UID = 11;
	22	pub const AT_EUID = 12;
	23	pub const AT_GID = 13;
	24	pub const AT_EGID = 14;
	25	pub const AT_CLKTCK = 17;
	26	pub const AT_PLATFORM = 15;
	27	pub const AT_HWCAP = 16;
	28	pub const AT_FPUCW = 18;
	29	pub const AT_DCACHEBSIZE = 19;
	30	pub const AT_ICACHEBSIZE = 20;
	31	pub const AT_UCACHEBSIZE = 21;
	32	pub const AT_IGNOREPPC = 22;
	33	pub const AT_SECURE = 23;
	34	pub const AT_BASE_PLATFORM = 24;
	35	pub const AT_RANDOM = 25;
	36	pub const AT_HWCAP2 = 26;
	37	pub const AT_EXECFN = 31;
	38	pub const AT_SYSINFO = 32;
	39	pub const AT_SYSINFO_EHDR = 33;
	40	pub const AT_L1I_CACHESHAPE = 34;
	41	pub const AT_L1D_CACHESHAPE = 35;
	42	pub const AT_L2_CACHESHAPE = 36;
	43	pub const AT_L3_CACHESHAPE = 37;
	44	pub const AT_L1I_CACHESIZE = 40;
	45	pub const AT_L1I_CACHEGEOMETRY = 41;
	46	pub const AT_L1D_CACHESIZE = 42;
	47	pub const AT_L1D_CACHEGEOMETRY = 43;
	48	pub const AT_L2_CACHESIZE = 44;
	49	pub const AT_L2_CACHEGEOMETRY = 45;
	50	pub const AT_L3_CACHESIZE = 46;
	51	pub const AT_L3_CACHEGEOMETRY = 47;
	52
	53	pub const DT_NULL = 0;
	54	pub const DT_NEEDED = 1;
	55	pub const DT_PLTRELSZ = 2;
	56	pub const DT_PLTGOT = 3;
	57	pub const DT_HASH = 4;
	58	pub const DT_STRTAB = 5;
	59	pub const DT_SYMTAB = 6;
	60	pub const DT_RELA = 7;
	61	pub const DT_RELASZ = 8;
	62	pub const DT_RELAENT = 9;
	63	pub const DT_STRSZ = 10;
	64	pub const DT_SYMENT = 11;
	65	pub const DT_INIT = 12;
	66	pub const DT_FINI = 13;
	67	pub const DT_SONAME = 14;
	68	pub const DT_RPATH = 15;
	69	pub const DT_SYMBOLIC = 16;
	70	pub const DT_REL = 17;
	71	pub const DT_RELSZ = 18;
	72	pub const DT_RELENT = 19;
	73	pub const DT_PLTREL = 20;
	74	pub const DT_DEBUG = 21;
	75	pub const DT_TEXTREL = 22;
	76	pub const DT_JMPREL = 23;
	77	pub const DT_BIND_NOW = 24;
	78	pub const DT_INIT_ARRAY = 25;
	79	pub const DT_FINI_ARRAY = 26;
	80	pub const DT_INIT_ARRAYSZ = 27;
	81	pub const DT_FINI_ARRAYSZ = 28;
	82	pub const DT_RUNPATH = 29;
	83	pub const DT_FLAGS = 30;
	84	pub const DT_ENCODING = 32;
	85	pub const DT_PREINIT_ARRAY = 32;
	86	pub const DT_PREINIT_ARRAYSZ = 33;
	87	pub const DT_SYMTAB_SHNDX = 34;
	88	pub const DT_NUM = 35;
	89	pub const DT_LOOS = 0x6000000d;
	90	pub const DT_HIOS = 0x6ffff000;
	91	pub const DT_LOPROC = 0x70000000;
	92	pub const DT_HIPROC = 0x7fffffff;
	93	pub const DT_PROCNUM = DT_MIPS_NUM;
	94
	95	pub const DT_VALRNGLO = 0x6ffffd00;
	96	pub const DT_GNU_PRELINKED = 0x6ffffdf5;
	97	pub const DT_GNU_CONFLICTSZ = 0x6ffffdf6;
	98	pub const DT_GNU_LIBLISTSZ = 0x6ffffdf7;
	99	pub const DT_CHECKSUM = 0x6ffffdf8;
	100	pub const DT_PLTPADSZ = 0x6ffffdf9;
	101	pub const DT_MOVEENT = 0x6ffffdfa;
	102	pub const DT_MOVESZ = 0x6ffffdfb;
	103	pub const DT_FEATURE_1 = 0x6ffffdfc;
	104	pub const DT_POSFLAG_1 = 0x6ffffdfd;
	105
	106	pub const DT_SYMINSZ = 0x6ffffdfe;
	107	pub const DT_SYMINENT = 0x6ffffdff;
	108	pub const DT_VALRNGHI = 0x6ffffdff;
	109	pub const DT_VALNUM = 12;
	110
	111	pub const DT_ADDRRNGLO = 0x6ffffe00;
	112	pub const DT_GNU_HASH = 0x6ffffef5;
	113	pub const DT_TLSDESC_PLT = 0x6ffffef6;
	114	pub const DT_TLSDESC_GOT = 0x6ffffef7;
	115	pub const DT_GNU_CONFLICT = 0x6ffffef8;
	116	pub const DT_GNU_LIBLIST = 0x6ffffef9;
	117	pub const DT_CONFIG = 0x6ffffefa;
	118	pub const DT_DEPAUDIT = 0x6ffffefb;
	119	pub const DT_AUDIT = 0x6ffffefc;
	120	pub const DT_PLTPAD = 0x6ffffefd;
	121	pub const DT_MOVETAB = 0x6ffffefe;
	122	pub const DT_SYMINFO = 0x6ffffeff;
	123	pub const DT_ADDRRNGHI = 0x6ffffeff;
	124	pub const DT_ADDRNUM = 11;
	125
	126
	127	pub const DT_VERSYM = 0x6ffffff0;
	128
	129	pub const DT_RELACOUNT = 0x6ffffff9;
	130	pub const DT_RELCOUNT = 0x6ffffffa;
	131
	132
	133	pub const DT_FLAGS_1 = 0x6ffffffb;
	134	pub const DT_VERDEF = 0x6ffffffc;
	135
	136	pub const DT_VERDEFNUM = 0x6ffffffd;
	137	pub const DT_VERNEED = 0x6ffffffe;
	138
	139	pub const DT_VERNEEDNUM = 0x6fffffff;
	140	pub const DT_VERSIONTAGNUM = 16;
	141
	142
	143
	144	pub const DT_AUXILIARY = 0x7ffffffd;
	145	pub const DT_FILTER = 0x7fffffff;
	146	pub const DT_EXTRANUM = 3;
	147
	148
	149	pub const DT_SPARC_REGISTER = 0x70000001;
	150	pub const DT_SPARC_NUM = 2;
	151
	152	pub const DT_MIPS_RLD_VERSION = 0x70000001;
	153	pub const DT_MIPS_TIME_STAMP = 0x70000002;
	154	pub const DT_MIPS_ICHECKSUM = 0x70000003;
	155	pub const DT_MIPS_IVERSION = 0x70000004;
	156	pub const DT_MIPS_FLAGS = 0x70000005;
	157	pub const DT_MIPS_BASE_ADDRESS = 0x70000006;
	158	pub const DT_MIPS_MSYM = 0x70000007;
	159	pub const DT_MIPS_CONFLICT = 0x70000008;
	160	pub const DT_MIPS_LIBLIST = 0x70000009;
	161	pub const DT_MIPS_LOCAL_GOTNO = 0x7000000a;
	162	pub const DT_MIPS_CONFLICTNO = 0x7000000b;
	163	pub const DT_MIPS_LIBLISTNO = 0x70000010;
	164	pub const DT_MIPS_SYMTABNO = 0x70000011;
	165	pub const DT_MIPS_UNREFEXTNO = 0x70000012;
	166	pub const DT_MIPS_GOTSYM = 0x70000013;
	167	pub const DT_MIPS_HIPAGENO = 0x70000014;
	168	pub const DT_MIPS_RLD_MAP = 0x70000016;
	169	pub const DT_MIPS_DELTA_CLASS = 0x70000017;
	170	pub const DT_MIPS_DELTA_CLASS_NO = 0x70000018;
	171
	172	pub const DT_MIPS_DELTA_INSTANCE = 0x70000019;
	173	pub const DT_MIPS_DELTA_INSTANCE_NO = 0x7000001a;
	174
	175	pub const DT_MIPS_DELTA_RELOC = 0x7000001b;
	176	pub const DT_MIPS_DELTA_RELOC_NO = 0x7000001c;
	177
	178	pub const DT_MIPS_DELTA_SYM = 0x7000001d;
	179
	180	pub const DT_MIPS_DELTA_SYM_NO = 0x7000001e;
	181
	182	pub const DT_MIPS_DELTA_CLASSSYM = 0x70000020;
	183
	184	pub const DT_MIPS_DELTA_CLASSSYM_NO = 0x70000021;
	185
	186	pub const DT_MIPS_CXX_FLAGS = 0x70000022;
	187	pub const DT_MIPS_PIXIE_INIT = 0x70000023;
	188	pub const DT_MIPS_SYMBOL_LIB = 0x70000024;
	189	pub const DT_MIPS_LOCALPAGE_GOTIDX = 0x70000025;
	190	pub const DT_MIPS_LOCAL_GOTIDX = 0x70000026;
	191	pub const DT_MIPS_HIDDEN_GOTIDX = 0x70000027;
	192	pub const DT_MIPS_PROTECTED_GOTIDX = 0x70000028;
	193	pub const DT_MIPS_OPTIONS = 0x70000029;
	194	pub const DT_MIPS_INTERFACE = 0x7000002a;
	195	pub const DT_MIPS_DYNSTR_ALIGN = 0x7000002b;
	196	pub const DT_MIPS_INTERFACE_SIZE = 0x7000002c;
	197	pub const DT_MIPS_RLD_TEXT_RESOLVE_ADDR = 0x7000002d;
	198
	199	pub const DT_MIPS_PERF_SUFFIX = 0x7000002e;
	200
	201	pub const DT_MIPS_COMPACT_SIZE = 0x7000002f;
	202	pub const DT_MIPS_GP_VALUE = 0x70000030;
	203	pub const DT_MIPS_AUX_DYNAMIC = 0x70000031;
	204
	205	pub const DT_MIPS_PLTGOT = 0x70000032;
	206
	207	pub const DT_MIPS_RWPLT = 0x70000034;
	208	pub const DT_MIPS_RLD_MAP_REL = 0x70000035;
	209	pub const DT_MIPS_NUM = 0x36;
	210
	211	pub const DT_ALPHA_PLTRO = (DT_LOPROC + 0);
	212	pub const DT_ALPHA_NUM = 1;
	213
	214	pub const DT_PPC_GOT = (DT_LOPROC + 0);
	215	pub const DT_PPC_OPT = (DT_LOPROC + 1);
	216	pub const DT_PPC_NUM = 2;
	217
	218	pub const DT_PPC64_GLINK = (DT_LOPROC + 0);
	219	pub const DT_PPC64_OPD = (DT_LOPROC + 1);
	220	pub const DT_PPC64_OPDSZ = (DT_LOPROC + 2);
	221	pub const DT_PPC64_OPT = (DT_LOPROC + 3);
	222	pub const DT_PPC64_NUM = 4;
	223
	224	pub const DT_IA_64_PLT_RESERVE = (DT_LOPROC + 0);
	225	pub const DT_IA_64_NUM = 1;
	226
	227	pub const DT_NIOS2_GP = 0x70000002;
	228
	229	pub const PT_NULL = 0;
	230	pub const PT_LOAD = 1;
	231	pub const PT_DYNAMIC = 2;
	232	pub const PT_INTERP = 3;
	233	pub const PT_NOTE = 4;
	234	pub const PT_SHLIB = 5;
	235	pub const PT_PHDR = 6;
	236	pub const PT_TLS = 7;
	237	pub const PT_NUM = 8;
	238	pub const PT_LOOS = 0x60000000;
	239	pub const PT_GNU_EH_FRAME = 0x6474e550;
	240	pub const PT_GNU_STACK = 0x6474e551;
	241	pub const PT_GNU_RELRO = 0x6474e552;
	242	pub const PT_LOSUNW = 0x6ffffffa;
	243	pub const PT_SUNWBSS = 0x6ffffffa;
	244	pub const PT_SUNWSTACK = 0x6ffffffb;
	245	pub const PT_HISUNW = 0x6fffffff;
	246	pub const PT_HIOS = 0x6fffffff;
	247	pub const PT_LOPROC = 0x70000000;
	248	pub const PT_HIPROC = 0x7fffffff;
	249
10	250	pub const SHT_NULL = 0;
11	251	pub const SHT_PROGBITS = 1;
12	252	pub const SHT_SYMTAB = 2;
...	...	@@ -31,6 +271,45 @@ pub const SHT_HIPROC = 0x7fffffff;
31	271	pub const SHT_LOUSER = 0x80000000;
32	272	pub const SHT_HIUSER = 0xffffffff;
33	273
	274	pub const STB_LOCAL = 0;
	275	pub const STB_GLOBAL = 1;
	276	pub const STB_WEAK = 2;
	277	pub const STB_NUM = 3;
	278	pub const STB_LOOS = 10;
	279	pub const STB_GNU_UNIQUE = 10;
	280	pub const STB_HIOS = 12;
	281	pub const STB_LOPROC = 13;
	282	pub const STB_HIPROC = 15;
	283
	284	pub const STB_MIPS_SPLIT_COMMON = 13;
	285
	286	pub const STT_NOTYPE = 0;
	287	pub const STT_OBJECT = 1;
	288	pub const STT_FUNC = 2;
	289	pub const STT_SECTION = 3;
	290	pub const STT_FILE = 4;
	291	pub const STT_COMMON = 5;
	292	pub const STT_TLS = 6;
	293	pub const STT_NUM = 7;
	294	pub const STT_LOOS = 10;
	295	pub const STT_GNU_IFUNC = 10;
	296	pub const STT_HIOS = 12;
	297	pub const STT_LOPROC = 13;
	298	pub const STT_HIPROC = 15;
	299
	300	pub const STT_SPARC_REGISTER = 13;
	301
	302	pub const STT_PARISC_MILLICODE = 13;
	303
	304	pub const STT_HP_OPAQUE = (STT_LOOS + 0x1);
	305	pub const STT_HP_STUB = (STT_LOOS + 0x2);
	306
	307	pub const STT_ARM_TFUNC = STT_LOPROC;
	308	pub const STT_ARM_16BIT = STT_HIPROC;
	309
	310	pub const VER_FLG_BASE = 0x1;
	311	pub const VER_FLG_WEAK = 0x2;
	312
34	313	pub const FileType = enum {
35	314	Relocatable,
36	315	Executable,
...	...	@@ -266,3 +545,335 @@ pub const Elf = struct {
266	545	try elf.in_file.seekTo(elf_section.offset);
267	546	}
268	547	};
	548
	549	pub const EI_NIDENT = 16;
	550	pub const Elf32_Half = u16;
	551	pub const Elf64_Half = u16;
	552	pub const Elf32_Word = u32;
	553	pub const Elf32_Sword = i32;
	554	pub const Elf64_Word = u32;
	555	pub const Elf64_Sword = i32;
	556	pub const Elf32_Xword = u64;
	557	pub const Elf32_Sxword = i64;
	558	pub const Elf64_Xword = u64;
	559	pub const Elf64_Sxword = i64;
	560	pub const Elf32_Addr = u32;
	561	pub const Elf64_Addr = u64;
	562	pub const Elf32_Off = u32;
	563	pub const Elf64_Off = u64;
	564	pub const Elf32_Section = u16;
	565	pub const Elf64_Section = u16;
	566	pub const Elf32_Versym = Elf32_Half;
	567	pub const Elf64_Versym = Elf64_Half;
	568	pub const Elf32_Ehdr = extern struct {
	569	e_ident: [EI_NIDENT]u8,
	570	e_type: Elf32_Half,
	571	e_machine: Elf32_Half,
	572	e_version: Elf32_Word,
	573	e_entry: Elf32_Addr,
	574	e_phoff: Elf32_Off,
	575	e_shoff: Elf32_Off,
	576	e_flags: Elf32_Word,
	577	e_ehsize: Elf32_Half,
	578	e_phentsize: Elf32_Half,
	579	e_phnum: Elf32_Half,
	580	e_shentsize: Elf32_Half,
	581	e_shnum: Elf32_Half,
	582	e_shstrndx: Elf32_Half,
	583	};
	584	pub const Elf64_Ehdr = extern struct {
	585	e_ident: [EI_NIDENT]u8,
	586	e_type: Elf64_Half,
	587	e_machine: Elf64_Half,
	588	e_version: Elf64_Word,
	589	e_entry: Elf64_Addr,
	590	e_phoff: Elf64_Off,
	591	e_shoff: Elf64_Off,
	592	e_flags: Elf64_Word,
	593	e_ehsize: Elf64_Half,
	594	e_phentsize: Elf64_Half,
	595	e_phnum: Elf64_Half,
	596	e_shentsize: Elf64_Half,
	597	e_shnum: Elf64_Half,
	598	e_shstrndx: Elf64_Half,
	599	};
	600	pub const Elf32_Shdr = extern struct {
	601	sh_name: Elf32_Word,
	602	sh_type: Elf32_Word,
	603	sh_flags: Elf32_Word,
	604	sh_addr: Elf32_Addr,
	605	sh_offset: Elf32_Off,
	606	sh_size: Elf32_Word,
	607	sh_link: Elf32_Word,
	608	sh_info: Elf32_Word,
	609	sh_addralign: Elf32_Word,
	610	sh_entsize: Elf32_Word,
	611	};
	612	pub const Elf64_Shdr = extern struct {
	613	sh_name: Elf64_Word,
	614	sh_type: Elf64_Word,
	615	sh_flags: Elf64_Xword,
	616	sh_addr: Elf64_Addr,
	617	sh_offset: Elf64_Off,
	618	sh_size: Elf64_Xword,
	619	sh_link: Elf64_Word,
	620	sh_info: Elf64_Word,
	621	sh_addralign: Elf64_Xword,
	622	sh_entsize: Elf64_Xword,
	623	};
	624	pub const Elf32_Chdr = extern struct {
	625	ch_type: Elf32_Word,
	626	ch_size: Elf32_Word,
	627	ch_addralign: Elf32_Word,
	628	};
	629	pub const Elf64_Chdr = extern struct {
	630	ch_type: Elf64_Word,
	631	ch_reserved: Elf64_Word,
	632	ch_size: Elf64_Xword,
	633	ch_addralign: Elf64_Xword,
	634	};
	635	pub const Elf32_Sym = extern struct {
	636	st_name: Elf32_Word,
	637	st_value: Elf32_Addr,
	638	st_size: Elf32_Word,
	639	st_info: u8,
	640	st_other: u8,
	641	st_shndx: Elf32_Section,
	642	};
	643	pub const Elf64_Sym = extern struct {
	644	st_name: Elf64_Word,
	645	st_info: u8,
	646	st_other: u8,
	647	st_shndx: Elf64_Section,
	648	st_value: Elf64_Addr,
	649	st_size: Elf64_Xword,
	650	};
	651	pub const Elf32_Syminfo = extern struct {
	652	si_boundto: Elf32_Half,
	653	si_flags: Elf32_Half,
	654	};
	655	pub const Elf64_Syminfo = extern struct {
	656	si_boundto: Elf64_Half,
	657	si_flags: Elf64_Half,
	658	};
	659	pub const Elf32_Rel = extern struct {
	660	r_offset: Elf32_Addr,
	661	r_info: Elf32_Word,
	662	};
	663	pub const Elf64_Rel = extern struct {
	664	r_offset: Elf64_Addr,
	665	r_info: Elf64_Xword,
	666	};
	667	pub const Elf32_Rela = extern struct {
	668	r_offset: Elf32_Addr,
	669	r_info: Elf32_Word,
	670	r_addend: Elf32_Sword,
	671	};
	672	pub const Elf64_Rela = extern struct {
	673	r_offset: Elf64_Addr,
	674	r_info: Elf64_Xword,
	675	r_addend: Elf64_Sxword,
	676	};
	677	pub const Elf32_Phdr = extern struct {
	678	p_type: Elf32_Word,
	679	p_offset: Elf32_Off,
	680	p_vaddr: Elf32_Addr,
	681	p_paddr: Elf32_Addr,
	682	p_filesz: Elf32_Word,
	683	p_memsz: Elf32_Word,
	684	p_flags: Elf32_Word,
	685	p_align: Elf32_Word,
	686	};
	687	pub const Elf64_Phdr = extern struct {
	688	p_type: Elf64_Word,
	689	p_flags: Elf64_Word,
	690	p_offset: Elf64_Off,
	691	p_vaddr: Elf64_Addr,
	692	p_paddr: Elf64_Addr,
	693	p_filesz: Elf64_Xword,
	694	p_memsz: Elf64_Xword,
	695	p_align: Elf64_Xword,
	696	};
	697	pub const Elf32_Dyn = extern struct {
	698	d_tag: Elf32_Sword,
	699	d_un: extern union {
	700	d_val: Elf32_Word,
	701	d_ptr: Elf32_Addr,
	702	},
	703	};
	704	pub const Elf64_Dyn = extern struct {
	705	d_tag: Elf64_Sxword,
	706	d_un: extern union {
	707	d_val: Elf64_Xword,
	708	d_ptr: Elf64_Addr,
	709	},
	710	};
	711	pub const Elf32_Verdef = extern struct {
	712	vd_version: Elf32_Half,
	713	vd_flags: Elf32_Half,
	714	vd_ndx: Elf32_Half,
	715	vd_cnt: Elf32_Half,
	716	vd_hash: Elf32_Word,
	717	vd_aux: Elf32_Word,
	718	vd_next: Elf32_Word,
	719	};
	720	pub const Elf64_Verdef = extern struct {
	721	vd_version: Elf64_Half,
	722	vd_flags: Elf64_Half,
	723	vd_ndx: Elf64_Half,
	724	vd_cnt: Elf64_Half,
	725	vd_hash: Elf64_Word,
	726	vd_aux: Elf64_Word,
	727	vd_next: Elf64_Word,
	728	};
	729	pub const Elf32_Verdaux = extern struct {
	730	vda_name: Elf32_Word,
	731	vda_next: Elf32_Word,
	732	};
	733	pub const Elf64_Verdaux = extern struct {
	734	vda_name: Elf64_Word,
	735	vda_next: Elf64_Word,
	736	};
	737	pub const Elf32_Verneed = extern struct {
	738	vn_version: Elf32_Half,
	739	vn_cnt: Elf32_Half,
	740	vn_file: Elf32_Word,
	741	vn_aux: Elf32_Word,
	742	vn_next: Elf32_Word,
	743	};
	744	pub const Elf64_Verneed = extern struct {
	745	vn_version: Elf64_Half,
	746	vn_cnt: Elf64_Half,
	747	vn_file: Elf64_Word,
	748	vn_aux: Elf64_Word,
	749	vn_next: Elf64_Word,
	750	};
	751	pub const Elf32_Vernaux = extern struct {
	752	vna_hash: Elf32_Word,
	753	vna_flags: Elf32_Half,
	754	vna_other: Elf32_Half,
	755	vna_name: Elf32_Word,
	756	vna_next: Elf32_Word,
	757	};
	758	pub const Elf64_Vernaux = extern struct {
	759	vna_hash: Elf64_Word,
	760	vna_flags: Elf64_Half,
	761	vna_other: Elf64_Half,
	762	vna_name: Elf64_Word,
	763	vna_next: Elf64_Word,
	764	};
	765	pub const Elf32_auxv_t = extern struct {
	766	a_type: u32,
	767	a_un: extern union {
	768	a_val: u32,
	769	},
	770	};
	771	pub const Elf64_auxv_t = extern struct {
	772	a_type: u64,
	773	a_un: extern union {
	774	a_val: u64,
	775	},
	776	};
	777	pub const Elf32_Nhdr = extern struct {
	778	n_namesz: Elf32_Word,
	779	n_descsz: Elf32_Word,
	780	n_type: Elf32_Word,
	781	};
	782	pub const Elf64_Nhdr = extern struct {
	783	n_namesz: Elf64_Word,
	784	n_descsz: Elf64_Word,
	785	n_type: Elf64_Word,
	786	};
	787	pub const Elf32_Move = extern struct {
	788	m_value: Elf32_Xword,
	789	m_info: Elf32_Word,
	790	m_poffset: Elf32_Word,
	791	m_repeat: Elf32_Half,
	792	m_stride: Elf32_Half,
	793	};
	794	pub const Elf64_Move = extern struct {
	795	m_value: Elf64_Xword,
	796	m_info: Elf64_Xword,
	797	m_poffset: Elf64_Xword,
	798	m_repeat: Elf64_Half,
	799	m_stride: Elf64_Half,
	800	};
	801	pub const Elf32_gptab = extern union {
	802	gt_header: extern struct {
	803	gt_current_g_value: Elf32_Word,
	804	gt_unused: Elf32_Word,
	805	},
	806	gt_entry: extern struct {
	807	gt_g_value: Elf32_Word,
	808	gt_bytes: Elf32_Word,
	809	},
	810	};
	811	pub const Elf32_RegInfo = extern struct {
	812	ri_gprmask: Elf32_Word,
	813	ri_cprmask: [4]Elf32_Word,
	814	ri_gp_value: Elf32_Sword,
	815	};
	816	pub const Elf_Options = extern struct {
	817	kind: u8,
	818	size: u8,
	819	@"section": Elf32_Section,
	820	info: Elf32_Word,
	821	};
	822	pub const Elf_Options_Hw = extern struct {
	823	hwp_flags1: Elf32_Word,
	824	hwp_flags2: Elf32_Word,
	825	};
	826	pub const Elf32_Lib = extern struct {
	827	l_name: Elf32_Word,
	828	l_time_stamp: Elf32_Word,
	829	l_checksum: Elf32_Word,
	830	l_version: Elf32_Word,
	831	l_flags: Elf32_Word,
	832	};
	833	pub const Elf64_Lib = extern struct {
	834	l_name: Elf64_Word,
	835	l_time_stamp: Elf64_Word,
	836	l_checksum: Elf64_Word,
	837	l_version: Elf64_Word,
	838	l_flags: Elf64_Word,
	839	};
	840	pub const Elf32_Conflict = Elf32_Addr;
	841	pub const Elf_MIPS_ABIFlags_v0 = extern struct {
	842	version: Elf32_Half,
	843	isa_level: u8,
	844	isa_rev: u8,
	845	gpr_size: u8,
	846	cpr1_size: u8,
	847	cpr2_size: u8,
	848	fp_abi: u8,
	849	isa_ext: Elf32_Word,
	850	ases: Elf32_Word,
	851	flags1: Elf32_Word,
	852	flags2: Elf32_Word,
	853	};
	854
	855	pub const Ehdr = switch(@sizeOf(usize)) {
	856	4 => Elf32_Ehdr,
	857	8 => Elf64_Ehdr,
	858	else => @compileError("expected pointer size of 32 or 64"),
	859	};
	860	pub const Phdr = switch(@sizeOf(usize)) {
	861	4 => Elf32_Phdr,
	862	8 => Elf64_Phdr,
	863	else => @compileError("expected pointer size of 32 or 64"),
	864	};
	865	pub const Sym = switch(@sizeOf(usize)) {
	866	4 => Elf32_Sym,
	867	8 => Elf64_Sym,
	868	else => @compileError("expected pointer size of 32 or 64"),
	869	};
	870	pub const Verdef = switch(@sizeOf(usize)) {
	871	4 => Elf32_Verdef,
	872	8 => Elf64_Verdef,
	873	else => @compileError("expected pointer size of 32 or 64"),
	874	};
	875	pub const Verdaux = switch(@sizeOf(usize)) {
	876	4 => Elf32_Verdaux,
	877	8 => Elf64_Verdaux,
	878	else => @compileError("expected pointer size of 32 or 64"),
	879	};

std/endian.zig deleted-25

...	...	@@ -1,25 +0,0 @@
1		const mem = @import("mem.zig");
2		const builtin = @import("builtin");
3
4		pub fn swapIfLe(comptime T: type, x: T) T {
5		return swapIf(builtin.Endian.Little, T, x);
6		}
7
8		pub fn swapIfBe(comptime T: type, x: T) T {
9		return swapIf(builtin.Endian.Big, T, x);
10		}
11
12		pub fn swapIf(endian: builtin.Endian, comptime T: type, x: T) T {
13		return if (builtin.endian == endian) swap(T, x) else x;
14		}
15
16		pub fn swap(comptime T: type, x: T) T {
17		var buf: [@sizeOf(T)]u8 = undefined;
18		mem.writeInt(buf[0..], x, builtin.Endian.Little);
19		return mem.readInt(buf, T, builtin.Endian.Big);
20		}
21
22		test "swap" {
23		const debug = @import("debug/index.zig");
24		debug.assert(swap(u32, 0xDEADBEEF) == 0xEFBEADDE);
25		}

std/event.zig created+235

...	...	@@ -0,0 +1,235 @@
	1	const std = @import("index.zig");
	2	const builtin = @import("builtin");
	3	const assert = std.debug.assert;
	4	const event = this;
	5	const mem = std.mem;
	6	const posix = std.os.posix;
	7
	8	pub const TcpServer = struct {
	9	handleRequestFn: async<&mem.Allocator> fn (&TcpServer, &const std.net.Address, &const std.os.File) void,
	10
	11	loop: &Loop,
	12	sockfd: i32,
	13	accept_coro: ?promise,
	14	listen_address: std.net.Address,
	15
	16	waiting_for_emfile_node: PromiseNode,
	17
	18	const PromiseNode = std.LinkedList(promise).Node;
	19
	20	pub fn init(loop: &Loop) !TcpServer {
	21	const sockfd = try std.os.posixSocket(posix.AF_INET,
	22	posix.SOCK_STREAM\|posix.SOCK_CLOEXEC\|posix.SOCK_NONBLOCK,
	23	posix.PROTO_tcp);
	24	errdefer std.os.close(sockfd);
	25
	26	// TODO can't initialize handler coroutine here because we need well defined copy elision
	27	return TcpServer {
	28	.loop = loop,
	29	.sockfd = sockfd,
	30	.accept_coro = null,
	31	.handleRequestFn = undefined,
	32	.waiting_for_emfile_node = undefined,
	33	.listen_address = undefined,
	34	};
	35	}
	36
	37	pub fn listen(self: &TcpServer, address: &const std.net.Address,
	38	handleRequestFn: async<&mem.Allocator> fn (&TcpServer, &const std.net.Address, &const std.os.File)void) !void
	39	{
	40	self.handleRequestFn = handleRequestFn;
	41
	42	try std.os.posixBind(self.sockfd, &address.os_addr);
	43	try std.os.posixListen(self.sockfd, posix.SOMAXCONN);
	44	self.listen_address = std.net.Address.initPosix(try std.os.posixGetSockName(self.sockfd));
	45
	46	self.accept_coro = try async<self.loop.allocator> TcpServer.handler(self);
	47	errdefer cancel ??self.accept_coro;
	48
	49	try self.loop.addFd(self.sockfd, ??self.accept_coro);
	50	errdefer self.loop.removeFd(self.sockfd);
	51
	52	}
	53
	54	pub fn deinit(self: &TcpServer) void {
	55	self.loop.removeFd(self.sockfd);
	56	if (self.accept_coro) \|accept_coro\| cancel accept_coro;
	57	std.os.close(self.sockfd);
	58	}
	59
	60	pub async fn handler(self: &TcpServer) void {
	61	while (true) {
	62	var accepted_addr: std.net.Address = undefined;
	63	if (std.os.posixAccept(self.sockfd, &accepted_addr.os_addr,
	64	posix.SOCK_NONBLOCK \| posix.SOCK_CLOEXEC)) \|accepted_fd\|
	65	{
	66	var socket = std.os.File.openHandle(accepted_fd);
	67	_ = async<self.loop.allocator> self.handleRequestFn(self, accepted_addr, socket) catch \|err\| switch (err) {
	68	error.OutOfMemory => {
	69	socket.close();
	70	continue;
	71	},
	72	};
	73	} else \|err\| switch (err) {
	74	error.WouldBlock => {
	75	suspend; // we will get resumed by epoll_wait in the event loop
	76	continue;
	77	},
	78	error.ProcessFdQuotaExceeded => {
	79	errdefer std.os.emfile_promise_queue.remove(&self.waiting_for_emfile_node);
	80	suspend \|p\| {
	81	self.waiting_for_emfile_node = PromiseNode.init(p);
	82	std.os.emfile_promise_queue.append(&self.waiting_for_emfile_node);
	83	}
	84	continue;
	85	},
	86	error.ConnectionAborted,
	87	error.FileDescriptorClosed => continue,
	88
	89	error.PageFault => unreachable,
	90	error.InvalidSyscall => unreachable,
	91	error.FileDescriptorNotASocket => unreachable,
	92	error.OperationNotSupported => unreachable,
	93
	94	error.SystemFdQuotaExceeded,
	95	error.SystemResources,
	96	error.ProtocolFailure,
	97	error.BlockedByFirewall,
	98	error.Unexpected => {
	99	@panic("TODO handle this error");
	100	},
	101	}
	102	}
	103	}
	104	};
	105
	106	pub const Loop = struct {
	107	allocator: &mem.Allocator,
	108	epollfd: i32,
	109	keep_running: bool,
	110
	111	fn init(allocator: &mem.Allocator) !Loop {
	112	const epollfd = try std.os.linuxEpollCreate(std.os.linux.EPOLL_CLOEXEC);
	113	return Loop {
	114	.keep_running = true,
	115	.allocator = allocator,
	116	.epollfd = epollfd,
	117	};
	118	}
	119
	120	pub fn addFd(self: &Loop, fd: i32, prom: promise) !void {
	121	var ev = std.os.linux.epoll_event {
	122	.events = std.os.linux.EPOLLIN\|std.os.linux.EPOLLOUT\|std.os.linux.EPOLLET,
	123	.data = std.os.linux.epoll_data {
	124	.ptr = @ptrToInt(prom),
	125	},
	126	};
	127	try std.os.linuxEpollCtl(self.epollfd, std.os.linux.EPOLL_CTL_ADD, fd, &ev);
	128	}
	129
	130	pub fn removeFd(self: &Loop, fd: i32) void {
	131	std.os.linuxEpollCtl(self.epollfd, std.os.linux.EPOLL_CTL_DEL, fd, undefined) catch {};
	132	}
	133
	134	async fn waitFd(self: &Loop, fd: i32) !void {
	135	defer self.removeFd(fd);
	136	suspend \|p\| {
	137	try self.addFd(fd, p);
	138	}
	139	}
	140
	141	pub fn stop(self: &Loop) void {
	142	// TODO make atomic
	143	self.keep_running = false;
	144	// TODO activate an fd in the epoll set
	145	}
	146
	147	pub fn run(self: &Loop) void {
	148	while (self.keep_running) {
	149	var events: [16]std.os.linux.epoll_event = undefined;
	150	const count = std.os.linuxEpollWait(self.epollfd, events[0..], -1);
	151	for (events[0..count]) \|ev\| {
	152	const p = @intToPtr(promise, ev.data.ptr);
	153	resume p;
	154	}
	155	}
	156	}
	157	};
	158
	159	pub async fn connect(loop: &Loop, _address: &const std.net.Address) !std.os.File {
	160	var address = *_address; // TODO https://github.com/zig-lang/zig/issues/733
	161
	162	const sockfd = try std.os.posixSocket(posix.AF_INET, posix.SOCK_STREAM\|posix.SOCK_CLOEXEC\|posix.SOCK_NONBLOCK, posix.PROTO_tcp);
	163	errdefer std.os.close(sockfd);
	164
	165	try std.os.posixConnectAsync(sockfd, &address.os_addr);
	166	try await try async loop.waitFd(sockfd);
	167	try std.os.posixGetSockOptConnectError(sockfd);
	168
	169	return std.os.File.openHandle(sockfd);
	170	}
	171
	172	test "listen on a port, send bytes, receive bytes" {
	173	if (builtin.os != builtin.Os.linux) {
	174	// TODO build abstractions for other operating systems
	175	return;
	176	}
	177	const MyServer = struct {
	178	tcp_server: TcpServer,
	179
	180	const Self = this;
	181
	182	async<&mem.Allocator> fn handler(tcp_server: &TcpServer, _addr: &const std.net.Address,
	183	_socket: &const std.os.File) void
	184	{
	185	const self = @fieldParentPtr(Self, "tcp_server", tcp_server);
	186	var socket = *_socket; // TODO https://github.com/zig-lang/zig/issues/733
	187	defer socket.close();
	188	const next_handler = async errorableHandler(self, _addr, socket) catch \|err\| switch (err) {
	189	error.OutOfMemory => @panic("unable to handle connection: out of memory"),
	190	};
	191	(await next_handler) catch \|err\| {
	192	std.debug.panic("unable to handle connection: {}\n", err);
	193	};
	194	suspend \|p\| { cancel p; }
	195	}
	196
	197	async fn errorableHandler(self: &Self, _addr: &const std.net.Address,
	198	_socket: &const std.os.File) !void
	199	{
	200	const addr = *_addr; // TODO https://github.com/zig-lang/zig/issues/733
	201	var socket = *_socket; // TODO https://github.com/zig-lang/zig/issues/733
	202
	203	var adapter = std.io.FileOutStream.init(&socket);
	204	var stream = &adapter.stream;
	205	try stream.print("hello from server\n");
	206	}
	207	};
	208
	209	const ip4addr = std.net.parseIp4("127.0.0.1") catch unreachable;
	210	const addr = std.net.Address.initIp4(ip4addr, 0);
	211
	212	var loop = try Loop.init(std.debug.global_allocator);
	213	var server = MyServer {
	214	.tcp_server = try TcpServer.init(&loop),
	215	};
	216	defer server.tcp_server.deinit();
	217	try server.tcp_server.listen(addr, MyServer.handler);
	218
	219	const p = try async<std.debug.global_allocator> doAsyncTest(&loop, server.tcp_server.listen_address);
	220	defer cancel p;
	221	loop.run();
	222	}
	223
	224	async fn doAsyncTest(loop: &Loop, address: &const std.net.Address) void {
	225	errdefer @panic("test failure");
	226
	227	var socket_file = try await try async event.connect(loop, address);
	228	defer socket_file.close();
	229
	230	var buf: [512]u8 = undefined;
	231	const amt_read = try socket_file.read(buf[0..]);
	232	const msg = buf[0..amt_read];
	233	assert(mem.eql(u8, msg, "hello from server\n"));
	234	loop.stop();
	235	}

std/fmt/errol/index.zig+76-3

...	...	@@ -12,13 +12,79 @@ pub const FloatDecimal = struct {
12	12	exp: i32,
13	13	};
14	14
	15	pub const RoundMode = enum {
	16	// Round only the fractional portion (e.g. 1234.23 has precision 2)
	17	Decimal,
	18	// Round the entire whole/fractional portion (e.g. 1.23423e3 has precision 5)
	19	Scientific,
	20	};
	21
	22	/// Round a FloatDecimal as returned by errol3 to the specified fractional precision.
	23	/// All digits after the specified precision should be considered invalid.
	24	pub fn roundToPrecision(float_decimal: &FloatDecimal, precision: usize, mode: RoundMode) void {
	25	// The round digit refers to the index which we should look at to determine
	26	// whether we need to round to match the specified precision.
	27	var round_digit: usize = 0;
	28
	29	switch (mode) {
	30	RoundMode.Decimal => {
	31	if (float_decimal.exp >= 0) {
	32	round_digit = precision + usize(float_decimal.exp);
	33	} else {
	34	// if a small negative exp, then adjust we need to offset by the number
	35	// of leading zeros that will occur.
	36	const min_exp_required = usize(-float_decimal.exp);
	37	if (precision > min_exp_required) {
	38	round_digit = precision - min_exp_required;
	39	}
	40	}
	41	},
	42	RoundMode.Scientific => {
	43	round_digit = 1 + precision;
	44	},
	45	}
	46
	47	// It suffices to look at just this digit. We don't round and propagate say 0.04999 to 0.05
	48	// first, and then to 0.1 in the case of a {.1} single precision.
	49
	50	// Find the digit which will signify the round point and start rounding backwards.
	51	if (round_digit < float_decimal.digits.len and float_decimal.digits[round_digit] - '0' >= 5) {
	52	assert(round_digit >= 0);
	53
	54	var i = round_digit;
	55	while (true) {
	56	if (i == 0) {
	57	// Rounded all the way past the start. This was of the form 9.999...
	58	// Slot the new digit in place and increase the exponent.
	59	float_decimal.exp += 1;
	60
	61	// Re-size the buffer to use the reserved leading byte.
	62	const one_before = @intToPtr(&u8, @ptrToInt(&float_decimal.digits[0]) - 1);
	63	float_decimal.digits = one_before[0..float_decimal.digits.len + 1];
	64	float_decimal.digits[0] = '1';
	65	return;
	66	}
	67
	68	i -= 1;
	69
	70	const new_value = (float_decimal.digits[i] - '0' + 1) % 10;
	71	float_decimal.digits[i] = new_value + '0';
	72
	73	// must continue rounding until non-9
	74	if (new_value != 0) {
	75	return;
	76	}
	77	}
	78	}
	79	}
	80
15	81	/// Corrected Errol3 double to ASCII conversion.
16	82	pub fn errol3(value: f64, buffer: []u8) FloatDecimal {
17	83	const bits = @bitCast(u64, value);
18	84	const i = tableLowerBound(bits);
19	85	if (i < enum3.len and enum3[i] == bits) {
20	86	const data = enum3_data[i];
21		const digits = buffer[0..data.str.len];
	87	const digits = buffer[1..data.str.len + 1];
22	88	mem.copy(u8, digits, data.str);
23	89	return FloatDecimal {
24	90	.digits = digits,
...	...	@@ -98,7 +164,11 @@ fn errol3u(val: f64, buffer: []u8) FloatDecimal {
98	164	}
99	165
100	166	// digit generation
101		var buf_index: usize = 0;
	167
	168	// We generate digits starting at index 1. If rounding a buffer later then it may be
	169	// required to generate a preceeding digit in some cases (9.999) in which case we use
	170	// the 0-index for this extra digit.
	171	var buf_index: usize = 1;
102	172	while (true) {
103	173	var hdig = u8(math.floor(high.val));
104	174	if ((high.val == f64(hdig)) and (high.off < 0))
...	...	@@ -128,7 +198,7 @@ fn errol3u(val: f64, buffer: []u8) FloatDecimal {
128	198	buf_index += 1;
129	199
130	200	return FloatDecimal {
131		.digits = buffer[0..buf_index],
	201	.digits = buffer[1..buf_index],
132	202	.exp = exp,
133	203	};
134	204	}
...	...	@@ -189,6 +259,9 @@ fn gethi(in: f64) f64 {
189	259	/// Normalize the number by factoring in the error.
190	260	/// @hp: The float pair.
191	261	fn hpNormalize(hp: &HP) void {
	262	// Required to avoid segfaults causing buffer overrun during errol3 digit output termination.
	263	@setFloatMode(this, @import("builtin").FloatMode.Strict);
	264
192	265	const val = hp.val;
193	266
194	267	hp.val += hp.off;

std/fmt/index.zig+448-122

...	...	@@ -4,29 +4,31 @@ const debug = std.debug;
4	4	const assert = debug.assert;
5	5	const mem = std.mem;
6	6	const builtin = @import("builtin");
7		const errol3 = @import("errol/index.zig").errol3;
	7	const errol = @import("errol/index.zig");
8	8
9	9	const max_int_digits = 65;
10	10
11		const State = enum { // TODO put inside format function and make sure the name and debug info is correct
12		Start,
13		OpenBrace,
14		CloseBrace,
15		Integer,
16		IntegerWidth,
17		Float,
18		FloatWidth,
19		Character,
20		Buf,
21		BufWidth,
22		};
23
24	11	/// Renders fmt string with args, calling output with slices of bytes.
25	12	/// If `output` returns an error, the error is returned from `format` and
26	13	/// `output` is not called again.
27	14	pub fn format(context: var, comptime Errors: type, output: fn(@typeOf(context), []const u8) Errors!void,
28	15	comptime fmt: []const u8, args: ...) Errors!void
29	16	{
	17	const State = enum {
	18	Start,
	19	OpenBrace,
	20	CloseBrace,
	21	Integer,
	22	IntegerWidth,
	23	Float,
	24	FloatWidth,
	25	FloatScientific,
	26	FloatScientificWidth,
	27	Character,
	28	Buf,
	29	BufWidth,
	30	};
	31
30	32	comptime var start_index = 0;
31	33	comptime var state = State.Start;
32	34	comptime var next_arg = 0;
...	...	@@ -86,7 +88,11 @@ pub fn format(context: var, comptime Errors: type, output: fn(@typeOf(context),
86	88	},
87	89	's' => {
88	90	state = State.Buf;
89		},'.' => {
	91	},
	92	'e' => {
	93	state = State.FloatScientific;
	94	},
	95	'.' => {
90	96	state = State.Float;
91	97	},
92	98	else => @compileError("Unknown format character: " ++ []u8{c}),
...	...	@@ -132,9 +138,33 @@ pub fn format(context: var, comptime Errors: type, output: fn(@typeOf(context),
132	138	'0' ... '9' => {},
133	139	else => @compileError("Unexpected character in format string: " ++ []u8{c}),
134	140	},
	141	State.FloatScientific => switch (c) {
	142	'}' => {
	143	try formatFloatScientific(args[next_arg], null, context, Errors, output);
	144	next_arg += 1;
	145	state = State.Start;
	146	start_index = i + 1;
	147	},
	148	'0' ... '9' => {
	149	width_start = i;
	150	state = State.FloatScientificWidth;
	151	},
	152	else => @compileError("Unexpected character in format string: " ++ []u8{c}),
	153	},
	154	State.FloatScientificWidth => switch (c) {
	155	'}' => {
	156	width = comptime (parseUnsigned(usize, fmt[width_start..i], 10) catch unreachable);
	157	try formatFloatScientific(args[next_arg], width, context, Errors, output);
	158	next_arg += 1;
	159	state = State.Start;
	160	start_index = i + 1;
	161	},
	162	'0' ... '9' => {},
	163	else => @compileError("Unexpected character in format string: " ++ []u8{c}),
	164	},
135	165	State.Float => switch (c) {
136	166	'}' => {
137		try formatFloatDecimal(args[next_arg], 0, context, Errors, output);
	167	try formatFloatDecimal(args[next_arg], null, context, Errors, output);
138	168	next_arg += 1;
139	169	state = State.Start;
140	170	start_index = i + 1;
...	...	@@ -198,7 +228,7 @@ pub fn formatValue(value: var, context: var, comptime Errors: type, output: fn(@
198	228	return formatInt(value, 10, false, 0, context, Errors, output);
199	229	},
200	230	builtin.TypeId.Float => {
201		return formatFloat(value, context, Errors, output);
	231	return formatFloatScientific(value, null, context, Errors, output);
202	232	},
203	233	builtin.TypeId.Void => {
204	234	return output(context, "void");
...	...	@@ -256,81 +286,237 @@ pub fn formatBuf(buf: []const u8, width: usize,
256	286	}
257	287	}
258	288
259		pub fn formatFloat(value: var, context: var, comptime Errors: type, output: fn(@typeOf(context), []const u8)Errors!void) Errors!void {
	289	// Print a float in scientific notation to the specified precision. Null uses full precision.
	290	// It should be the case that every full precision, printed value can be re-parsed back to the
	291	// same type unambiguously.
	292	pub fn formatFloatScientific(value: var, maybe_precision: ?usize, context: var, comptime Errors: type, output: fn(@typeOf(context), []const u8)Errors!void) Errors!void {
260	293	var x = f64(value);
261	294
262	295	// Errol doesn't handle these special cases.
263		if (math.isNan(x)) {
264		return output(context, "NaN");
265		}
266	296	if (math.signbit(x)) {
267	297	try output(context, "-");
268	298	x = -x;
269	299	}
	300
	301	if (math.isNan(x)) {
	302	return output(context, "nan");
	303	}
270	304	if (math.isPositiveInf(x)) {
271		return output(context, "Infinity");
	305	return output(context, "inf");
272	306	}
273	307	if (x == 0.0) {
274		return output(context, "0.0");
	308	try output(context, "0");
	309
	310	if (maybe_precision) \|precision\| {
	311	if (precision != 0) {
	312	try output(context, ".");
	313	var i: usize = 0;
	314	while (i < precision) : (i += 1) {
	315	try output(context, "0");
	316	}
	317	}
	318	} else {
	319	try output(context, ".0");
	320	}
	321
	322	try output(context, "e+00");
	323	return;
275	324	}
276	325
277	326	var buffer: [32]u8 = undefined;
278		const float_decimal = errol3(x, buffer[0..]);
279		try output(context, float_decimal.digits[0..1]);
280		try output(context, ".");
281		if (float_decimal.digits.len > 1) {
282		const num_digits = if (@typeOf(value) == f32)
283		math.min(usize(9), float_decimal.digits.len)
284		else
285		float_decimal.digits.len;
286		try output(context, float_decimal.digits[1 .. num_digits]);
	327	var float_decimal = errol.errol3(x, buffer[0..]);
	328
	329	if (maybe_precision) \|precision\| {
	330	errol.roundToPrecision(&float_decimal, precision, errol.RoundMode.Scientific);
	331
	332	try output(context, float_decimal.digits[0..1]);
	333
	334	// {e0} case prints no `.`
	335	if (precision != 0) {
	336	try output(context, ".");
	337
	338	var printed: usize = 0;
	339	if (float_decimal.digits.len > 1) {
	340	const num_digits = math.min(float_decimal.digits.len, precision + 1);
	341	try output(context, float_decimal.digits[1 .. num_digits]);
	342	printed += num_digits - 1;
	343	}
	344
	345	while (printed < precision) : (printed += 1) {
	346	try output(context, "0");
	347	}
	348	}
287	349	} else {
288		try output(context, "0");
	350	try output(context, float_decimal.digits[0..1]);
	351	try output(context, ".");
	352	if (float_decimal.digits.len > 1) {
	353	const num_digits = if (@typeOf(value) == f32)
	354	math.min(usize(9), float_decimal.digits.len)
	355	else
	356	float_decimal.digits.len;
	357
	358	try output(context, float_decimal.digits[1 .. num_digits]);
	359	} else {
	360	try output(context, "0");
	361	}
289	362	}
290	363
291		if (float_decimal.exp != 1) {
292		try output(context, "e");
293		try formatInt(float_decimal.exp - 1, 10, false, 0, context, Errors, output);
	364	try output(context, "e");
	365	const exp = float_decimal.exp - 1;
	366
	367	if (exp >= 0) {
	368	try output(context, "+");
	369	if (exp > -10 and exp < 10) {
	370	try output(context, "0");
	371	}
	372	try formatInt(exp, 10, false, 0, context, Errors, output);
	373	} else {
	374	try output(context, "-");
	375	if (exp > -10 and exp < 10) {
	376	try output(context, "0");
	377	}
	378	try formatInt(-exp, 10, false, 0, context, Errors, output);
294	379	}
295	380	}
296	381
297		pub fn formatFloatDecimal(value: var, precision: usize, context: var, comptime Errors: type, output: fn(@typeOf(context), []const u8)Errors!void) Errors!void {
	382	// Print a float of the format x.yyyyy where the number of y is specified by the precision argument.
	383	// By default floats are printed at full precision (no rounding).
	384	pub fn formatFloatDecimal(value: var, maybe_precision: ?usize, context: var, comptime Errors: type, output: fn(@typeOf(context), []const u8)Errors!void) Errors!void {
298	385	var x = f64(value);
299	386
300	387	// Errol doesn't handle these special cases.
301		if (math.isNan(x)) {
302		return output(context, "NaN");
303		}
304	388	if (math.signbit(x)) {
305	389	try output(context, "-");
306	390	x = -x;
307	391	}
	392
	393	if (math.isNan(x)) {
	394	return output(context, "nan");
	395	}
308	396	if (math.isPositiveInf(x)) {
309		return output(context, "Infinity");
	397	return output(context, "inf");
310	398	}
311	399	if (x == 0.0) {
312		return output(context, "0.0");
	400	try output(context, "0");
	401
	402	if (maybe_precision) \|precision\| {
	403	if (precision != 0) {
	404	try output(context, ".");
	405	var i: usize = 0;
	406	while (i < precision) : (i += 1) {
	407	try output(context, "0");
	408	}
	409	} else {
	410	try output(context, ".0");
	411	}
	412	} else {
	413	try output(context, "0");
	414	}
	415
	416	return;
313	417	}
314	418
	419	// non-special case, use errol3
315	420	var buffer: [32]u8 = undefined;
316		const float_decimal = errol3(x, buffer[0..]);
317
318		const num_left_digits = if (float_decimal.exp > 0) usize(float_decimal.exp) else 1;
319
320		try output(context, float_decimal.digits[0 .. num_left_digits]);
321		try output(context, ".");
322		if (float_decimal.digits.len > 1) {
323		const num_valid_digtis = if (@typeOf(value) == f32) math.min(usize(7), float_decimal.digits.len)
324		else
325		float_decimal.digits.len;
326
327		const num_right_digits = if (precision != 0)
328		math.min(precision, (num_valid_digtis-num_left_digits))
329		else
330		num_valid_digtis - num_left_digits;
331		try output(context, float_decimal.digits[num_left_digits .. (num_left_digits + num_right_digits)]);
	421	var float_decimal = errol.errol3(x, buffer[0..]);
	422
	423	if (maybe_precision) \|precision\| {
	424	errol.roundToPrecision(&float_decimal, precision, errol.RoundMode.Decimal);
	425
	426	// exp < 0 means the leading is always 0 as errol result is normalized.
	427	var num_digits_whole = if (float_decimal.exp > 0) usize(float_decimal.exp) else 0;
	428
	429	// the actual slice into the buffer, we may need to zero-pad between num_digits_whole and this.
	430	var num_digits_whole_no_pad = math.min(num_digits_whole, float_decimal.digits.len);
	431
	432	if (num_digits_whole > 0) {
	433	// We may have to zero pad, for instance 1e4 requires zero padding.
	434	try output(context, float_decimal.digits[0 .. num_digits_whole_no_pad]);
	435
	436	var i = num_digits_whole_no_pad;
	437	while (i < num_digits_whole) : (i += 1) {
	438	try output(context, "0");
	439	}
	440	} else {
	441	try output(context , "0");
	442	}
	443
	444	// {.0} special case doesn't want a trailing '.'
	445	if (precision == 0) {
	446	return;
	447	}
	448
	449	try output(context, ".");
	450
	451	// Keep track of fractional count printed for case where we pre-pad then post-pad with 0's.
	452	var printed: usize = 0;
	453
	454	// Zero-fill until we reach significant digits or run out of precision.
	455	if (float_decimal.exp <= 0) {
	456	const zero_digit_count = usize(-float_decimal.exp);
	457	const zeros_to_print = math.min(zero_digit_count, precision);
	458
	459	var i: usize = 0;
	460	while (i < zeros_to_print) : (i += 1) {
	461	try output(context, "0");
	462	printed += 1;
	463	}
	464
	465	if (printed >= precision) {
	466	return;
	467	}
	468	}
	469
	470	// Remaining fractional portion, zero-padding if insufficient.
	471	debug.assert(precision >= printed);
	472	if (num_digits_whole_no_pad + precision - printed < float_decimal.digits.len) {
	473	try output(context, float_decimal.digits[num_digits_whole_no_pad .. num_digits_whole_no_pad + precision - printed]);
	474	return;
	475	} else {
	476	try output(context, float_decimal.digits[num_digits_whole_no_pad ..]);
	477	printed += float_decimal.digits.len - num_digits_whole_no_pad;
	478
	479	while (printed < precision) : (printed += 1) {
	480	try output(context, "0");
	481	}
	482	}
332	483	} else {
333		try output(context, "0");
	484	// exp < 0 means the leading is always 0 as errol result is normalized.
	485	var num_digits_whole = if (float_decimal.exp > 0) usize(float_decimal.exp) else 0;
	486
	487	// the actual slice into the buffer, we may need to zero-pad between num_digits_whole and this.
	488	var num_digits_whole_no_pad = math.min(num_digits_whole, float_decimal.digits.len);
	489
	490	if (num_digits_whole > 0) {
	491	// We may have to zero pad, for instance 1e4 requires zero padding.
	492	try output(context, float_decimal.digits[0 .. num_digits_whole_no_pad]);
	493
	494	var i = num_digits_whole_no_pad;
	495	while (i < num_digits_whole) : (i += 1) {
	496	try output(context, "0");
	497	}
	498	} else {
	499	try output(context , "0");
	500	}
	501
	502	// Omit `.` if no fractional portion
	503	if (float_decimal.exp >= 0 and num_digits_whole_no_pad == float_decimal.digits.len) {
	504	return;
	505	}
	506
	507	try output(context, ".");
	508
	509	// Zero-fill until we reach significant digits or run out of precision.
	510	if (float_decimal.exp < 0) {
	511	const zero_digit_count = usize(-float_decimal.exp);
	512
	513	var i: usize = 0;
	514	while (i < zero_digit_count) : (i += 1) {
	515	try output(context, "0");
	516	}
	517	}
	518
	519	try output(context, float_decimal.digits[num_digits_whole_no_pad ..]);
334	520	}
335	521	}
336	522
...	...	@@ -465,7 +651,7 @@ pub fn parseUnsigned(comptime T: type, buf: []const u8, radix: u8) ParseUnsigned
465	651	return x;
466	652	}
467	653
468		fn charToDigit(c: u8, radix: u8) (error{InvalidCharacter}!u8) {
	654	pub fn charToDigit(c: u8, radix: u8) (error{InvalidCharacter}!u8) {
469	655	const value = switch (c) {
470	656	'0' ... '9' => c - '0',
471	657	'A' ... 'Z' => c - 'A' + 10,
...	...	@@ -593,70 +779,210 @@ test "fmt.format" {
593	779	const result = try bufPrint(buf1[0..], "pointer: {}\n", &value);
594	780	assert(mem.startsWith(u8, result, "pointer: Struct@"));
595	781	}
596
597		// TODO get these tests passing in release modes
598		// https://github.com/zig-lang/zig/issues/564
599		if (builtin.mode == builtin.Mode.Debug) {
600		{
601		var buf1: [32]u8 = undefined;
602		const value: f32 = 12.34;
603		const result = try bufPrint(buf1[0..], "f32: {}\n", value);
604		assert(mem.eql(u8, result, "f32: 1.23400001e1\n"));
605		}
606		{
607		var buf1: [32]u8 = undefined;
608		const value: f64 = -12.34e10;
609		const result = try bufPrint(buf1[0..], "f64: {}\n", value);
610		assert(mem.eql(u8, result, "f64: -1.234e11\n"));
611		}
612		{
613		var buf1: [32]u8 = undefined;
614		const result = try bufPrint(buf1[0..], "f64: {}\n", math.nan_f64);
615		assert(mem.eql(u8, result, "f64: NaN\n"));
616		}
617		{
618		var buf1: [32]u8 = undefined;
619		const result = try bufPrint(buf1[0..], "f64: {}\n", math.inf_f64);
620		assert(mem.eql(u8, result, "f64: Infinity\n"));
621		}
622		{
623		var buf1: [32]u8 = undefined;
624		const result = try bufPrint(buf1[0..], "f64: {}\n", -math.inf_f64);
625		assert(mem.eql(u8, result, "f64: -Infinity\n"));
626		}
627		{
628		var buf1: [32]u8 = undefined;
629		const value: f32 = 1.1234;
630		const result = try bufPrint(buf1[0..], "f32: {.1}\n", value);
631		assert(mem.eql(u8, result, "f32: 1.1\n"));
632		}
633		{
634		var buf1: [32]u8 = undefined;
635		const value: f32 = 1234.567;
636		const result = try bufPrint(buf1[0..], "f32: {.2}\n", value);
637		assert(mem.eql(u8, result, "f32: 1234.56\n"));
638		}
639		{
640		var buf1: [32]u8 = undefined;
641		const value: f32 = -11.1234;
642		const result = try bufPrint(buf1[0..], "f32: {.4}\n", value);
643		// -11.1234 is converted to f64 -11.12339... internally (errol3() function takes f64).
644		// -11.12339... is truncated to -11.1233
645		assert(mem.eql(u8, result, "f32: -11.1233\n"));
646		}
647		{
648		var buf1: [32]u8 = undefined;
649		const value: f32 = 91.12345;
650		const result = try bufPrint(buf1[0..], "f32: {.}\n", value);
651		assert(mem.eql(u8, result, "f32: 91.12345\n"));
652		}
653		{
	782	{
	783	var buf1: [32]u8 = undefined;
	784	const value: f32 = 1.34;
	785	const result = try bufPrint(buf1[0..], "f32: {e}\n", value);
	786	assert(mem.eql(u8, result, "f32: 1.34000003e+00\n"));
	787	}
	788	{
	789	var buf1: [32]u8 = undefined;
	790	const value: f32 = 12.34;
	791	const result = try bufPrint(buf1[0..], "f32: {e}\n", value);
	792	assert(mem.eql(u8, result, "f32: 1.23400001e+01\n"));
	793	}
	794	{
	795	var buf1: [32]u8 = undefined;
	796	const value: f64 = -12.34e10;
	797	const result = try bufPrint(buf1[0..], "f64: {e}\n", value);
	798	assert(mem.eql(u8, result, "f64: -1.234e+11\n"));
	799	}
	800	{
	801	// This fails on release due to a minor rounding difference.
	802	// --release-fast outputs 9.999960000000001e-40 vs. the expected.
	803	if (builtin.mode == builtin.Mode.Debug) {
654	804	var buf1: [32]u8 = undefined;
655		const value: f64 = 91.12345678901235;
656		const result = try bufPrint(buf1[0..], "f64: {.10}\n", value);
657		assert(mem.eql(u8, result, "f64: 91.1234567890\n"));
	805	const value: f64 = 9.999960e-40;
	806	const result = try bufPrint(buf1[0..], "f64: {e}\n", value);
	807	assert(mem.eql(u8, result, "f64: 9.99996e-40\n"));
658	808	}
659
	809	}
	810	{
	811	var buf1: [32]u8 = undefined;
	812	const value: f64 = 1.409706e-42;
	813	const result = try bufPrint(buf1[0..], "f64: {e5}\n", value);
	814	assert(mem.eql(u8, result, "f64: 1.40971e-42\n"));
	815	}
	816	{
	817	var buf1: [32]u8 = undefined;
	818	const value: f64 = @bitCast(f32, u32(814313563));
	819	const result = try bufPrint(buf1[0..], "f64: {e5}\n", value);
	820	assert(mem.eql(u8, result, "f64: 1.00000e-09\n"));
	821	}
	822	{
	823	var buf1: [32]u8 = undefined;
	824	const value: f64 = @bitCast(f32, u32(1006632960));
	825	const result = try bufPrint(buf1[0..], "f64: {e5}\n", value);
	826	assert(mem.eql(u8, result, "f64: 7.81250e-03\n"));
	827	}
	828	{
	829	// libc rounds 1.000005e+05 to 1.00000e+05 but zig does 1.00001e+05.
	830	// In fact, libc doesn't round a lot of 5 cases up when one past the precision point.
	831	var buf1: [32]u8 = undefined;
	832	const value: f64 = @bitCast(f32, u32(1203982400));
	833	const result = try bufPrint(buf1[0..], "f64: {e5}\n", value);
	834	assert(mem.eql(u8, result, "f64: 1.00001e+05\n"));
	835	}
	836	{
	837	var buf1: [32]u8 = undefined;
	838	const result = try bufPrint(buf1[0..], "f64: {}\n", math.nan_f64);
	839	assert(mem.eql(u8, result, "f64: nan\n"));
	840	}
	841	{
	842	var buf1: [32]u8 = undefined;
	843	const result = try bufPrint(buf1[0..], "f64: {}\n", -math.nan_f64);
	844	assert(mem.eql(u8, result, "f64: -nan\n"));
	845	}
	846	{
	847	var buf1: [32]u8 = undefined;
	848	const result = try bufPrint(buf1[0..], "f64: {}\n", math.inf_f64);
	849	assert(mem.eql(u8, result, "f64: inf\n"));
	850	}
	851	{
	852	var buf1: [32]u8 = undefined;
	853	const result = try bufPrint(buf1[0..], "f64: {}\n", -math.inf_f64);
	854	assert(mem.eql(u8, result, "f64: -inf\n"));
	855	}
	856	{
	857	var buf1: [64]u8 = undefined;
	858	const value: f64 = 1.52314e+29;
	859	const result = try bufPrint(buf1[0..], "f64: {.}\n", value);
	860	assert(mem.eql(u8, result, "f64: 152314000000000000000000000000\n"));
	861	}
	862	{
	863	var buf1: [32]u8 = undefined;
	864	const value: f32 = 1.1234;
	865	const result = try bufPrint(buf1[0..], "f32: {.1}\n", value);
	866	assert(mem.eql(u8, result, "f32: 1.1\n"));
	867	}
	868	{
	869	var buf1: [32]u8 = undefined;
	870	const value: f32 = 1234.567;
	871	const result = try bufPrint(buf1[0..], "f32: {.2}\n", value);
	872	assert(mem.eql(u8, result, "f32: 1234.57\n"));
	873	}
	874	{
	875	var buf1: [32]u8 = undefined;
	876	const value: f32 = -11.1234;
	877	const result = try bufPrint(buf1[0..], "f32: {.4}\n", value);
	878	// -11.1234 is converted to f64 -11.12339... internally (errol3() function takes f64).
	879	// -11.12339... is rounded back up to -11.1234
	880	assert(mem.eql(u8, result, "f32: -11.1234\n"));
	881	}
	882	{
	883	var buf1: [32]u8 = undefined;
	884	const value: f32 = 91.12345;
	885	const result = try bufPrint(buf1[0..], "f32: {.5}\n", value);
	886	assert(mem.eql(u8, result, "f32: 91.12345\n"));
	887	}
	888	{
	889	var buf1: [32]u8 = undefined;
	890	const value: f64 = 91.12345678901235;
	891	const result = try bufPrint(buf1[0..], "f64: {.10}\n", value);
	892	assert(mem.eql(u8, result, "f64: 91.1234567890\n"));
	893	}
	894	{
	895	var buf1: [32]u8 = undefined;
	896	const value: f64 = 0.0;
	897	const result = try bufPrint(buf1[0..], "f64: {.5}\n", value);
	898	assert(mem.eql(u8, result, "f64: 0.00000\n"));
	899	}
	900	{
	901	var buf1: [32]u8 = undefined;
	902	const value: f64 = 5.700;
	903	const result = try bufPrint(buf1[0..], "f64: {.0}\n", value);
	904	assert(mem.eql(u8, result, "f64: 6\n"));
	905	}
	906	{
	907	var buf1: [32]u8 = undefined;
	908	const value: f64 = 9.999;
	909	const result = try bufPrint(buf1[0..], "f64: {.1}\n", value);
	910	assert(mem.eql(u8, result, "f64: 10.0\n"));
	911	}
	912	{
	913	var buf1: [32]u8 = undefined;
	914	const value: f64 = 1.0;
	915	const result = try bufPrint(buf1[0..], "f64: {.3}\n", value);
	916	assert(mem.eql(u8, result, "f64: 1.000\n"));
	917	}
	918	{
	919	var buf1: [32]u8 = undefined;
	920	const value: f64 = 0.0003;
	921	const result = try bufPrint(buf1[0..], "f64: {.8}\n", value);
	922	assert(mem.eql(u8, result, "f64: 0.00030000\n"));
	923	}
	924	{
	925	var buf1: [32]u8 = undefined;
	926	const value: f64 = 1.40130e-45;
	927	const result = try bufPrint(buf1[0..], "f64: {.5}\n", value);
	928	assert(mem.eql(u8, result, "f64: 0.00000\n"));
	929	}
	930	{
	931	var buf1: [32]u8 = undefined;
	932	const value: f64 = 9.999960e-40;
	933	const result = try bufPrint(buf1[0..], "f64: {.5}\n", value);
	934	assert(mem.eql(u8, result, "f64: 0.00000\n"));
	935	}
	936	// libc checks
	937	{
	938	var buf1: [32]u8 = undefined;
	939	const value: f64 = f64(@bitCast(f32, u32(916964781)));
	940	const result = try bufPrint(buf1[0..], "f64: {.5}\n", value);
	941	assert(mem.eql(u8, result, "f64: 0.00001\n"));
	942	}
	943	{
	944	var buf1: [32]u8 = undefined;
	945	const value: f64 = f64(@bitCast(f32, u32(925353389)));
	946	const result = try bufPrint(buf1[0..], "f64: {.5}\n", value);
	947	assert(mem.eql(u8, result, "f64: 0.00001\n"));
	948	}
	949	{
	950	var buf1: [32]u8 = undefined;
	951	const value: f64 = f64(@bitCast(f32, u32(1036831278)));
	952	const result = try bufPrint(buf1[0..], "f64: {.5}\n", value);
	953	assert(mem.eql(u8, result, "f64: 0.10000\n"));
	954	}
	955	{
	956	var buf1: [32]u8 = undefined;
	957	const value: f64 = f64(@bitCast(f32, u32(1065353133)));
	958	const result = try bufPrint(buf1[0..], "f64: {.5}\n", value);
	959	assert(mem.eql(u8, result, "f64: 1.00000\n"));
	960	}
	961	{
	962	var buf1: [32]u8 = undefined;
	963	const value: f64 = f64(@bitCast(f32, u32(1092616192)));
	964	const result = try bufPrint(buf1[0..], "f64: {.5}\n", value);
	965	assert(mem.eql(u8, result, "f64: 10.00000\n"));
	966	}
	967	// libc differences
	968	{
	969	var buf1: [32]u8 = undefined;
	970	// This is 0.015625 exactly according to gdb. We thus round down,
	971	// however glibc rounds up for some reason. This occurs for all
	972	// floats of the form x.yyyy25 on a precision point.
	973	const value: f64 = f64(@bitCast(f32, u32(1015021568)));
	974	const result = try bufPrint(buf1[0..], "f64: {.5}\n", value);
	975	assert(mem.eql(u8, result, "f64: 0.01563\n"));
	976	}
	977	// std-windows-x86_64-Debug-bare test case fails
	978	{
	979	// errol3 rounds to ... 630 but libc rounds to ...632. Grisu3
	980	// also rounds to 630 so I'm inclined to believe libc is not
	981	// optimal here.
	982	var buf1: [32]u8 = undefined;
	983	const value: f64 = f64(@bitCast(f32, u32(1518338049)));
	984	const result = try bufPrint(buf1[0..], "f64: {.5}\n", value);
	985	assert(mem.eql(u8, result, "f64: 18014400656965630.00000\n"));
660	986	}
661	987	}
662	988

std/hash_map.zig+62-6

...	...	@@ -54,6 +54,14 @@ pub fn HashMap(comptime K: type, comptime V: type,
54	54	}
55	55	unreachable; // no next item
56	56	}
	57
	58	// Reset the iterator to the initial index
	59	pub fn reset(it: &Iterator) void {
	60	it.count = 0;
	61	it.index = 0;
	62	// Resetting the modification count too
	63	it.initial_modification_count = it.hm.modification_count;
	64	}
57	65	};
58	66
59	67	pub fn init(allocator: &Allocator) Self {
...	...	@@ -66,7 +74,7 @@ pub fn HashMap(comptime K: type, comptime V: type,
66	74	};
67	75	}
68	76
69		pub fn deinit(hm: &Self) void {
	77	pub fn deinit(hm: &const Self) void {
70	78	hm.allocator.free(hm.entries);
71	79	}
72	80
...	...	@@ -79,6 +87,10 @@ pub fn HashMap(comptime K: type, comptime V: type,
79	87	hm.incrementModificationCount();
80	88	}
81	89
	90	pub fn count(hm: &const Self) usize {
	91	return hm.size;
	92	}
	93
82	94	/// Returns the value that was already there.
83	95	pub fn put(hm: &Self, key: K, value: &const V) !?V {
84	96	if (hm.entries.len == 0) {
...	...	@@ -102,18 +114,19 @@ pub fn HashMap(comptime K: type, comptime V: type,
102	114	return hm.internalPut(key, value);
103	115	}
104	116
105		pub fn get(hm: &Self, key: K) ?&Entry {
	117	pub fn get(hm: &const Self, key: K) ?&Entry {
106	118	if (hm.entries.len == 0) {
107	119	return null;
108	120	}
109	121	return hm.internalGet(key);
110	122	}
111	123
112		pub fn contains(hm: &Self, key: K) bool {
	124	pub fn contains(hm: &const Self, key: K) bool {
113	125	return hm.get(key) != null;
114	126	}
115	127
116	128	pub fn remove(hm: &Self, key: K) ?&Entry {
	129	if (hm.entries.len == 0) return null;
117	130	hm.incrementModificationCount();
118	131	const start_index = hm.keyToIndex(key);
119	132	{var roll_over: usize = 0; while (roll_over <= hm.max_distance_from_start_index) : (roll_over += 1) {
...	...	@@ -217,7 +230,7 @@ pub fn HashMap(comptime K: type, comptime V: type,
217	230	unreachable; // put into a full map
218	231	}
219	232
220		fn internalGet(hm: &Self, key: K) ?&Entry {
	233	fn internalGet(hm: &const Self, key: K) ?&Entry {
221	234	const start_index = hm.keyToIndex(key);
222	235	{var roll_over: usize = 0; while (roll_over <= hm.max_distance_from_start_index) : (roll_over += 1) {
223	236	const index = (start_index + roll_over) % hm.entries.len;
...	...	@@ -229,14 +242,17 @@ pub fn HashMap(comptime K: type, comptime V: type,
229	242	return null;
230	243	}
231	244
232		fn keyToIndex(hm: &Self, key: K) usize {
	245	fn keyToIndex(hm: &const Self, key: K) usize {
233	246	return usize(hash(key)) % hm.entries.len;
234	247	}
235	248	};
236	249	}
237	250
238	251	test "basic hash map usage" {
239		var map = HashMap(i32, i32, hash_i32, eql_i32).init(debug.global_allocator);
	252	var direct_allocator = std.heap.DirectAllocator.init();
	253	defer direct_allocator.deinit();
	254
	255	var map = HashMap(i32, i32, hash_i32, eql_i32).init(&direct_allocator.allocator);
240	256	defer map.deinit();
241	257
242	258	assert((map.put(1, 11) catch unreachable) == null);
...	...	@@ -248,12 +264,52 @@ test "basic hash map usage" {
248	264	assert(??(map.put(5, 66) catch unreachable) == 55);
249	265	assert(??(map.put(5, 55) catch unreachable) == 66);
250	266
	267	assert(map.contains(2));
251	268	assert((??map.get(2)).value == 22);
252	269	_ = map.remove(2);
253	270	assert(map.remove(2) == null);
254	271	assert(map.get(2) == null);
255	272	}
256	273
	274	test "iterator hash map" {
	275	var direct_allocator = std.heap.DirectAllocator.init();
	276	defer direct_allocator.deinit();
	277
	278	var reset_map = HashMap(i32, i32, hash_i32, eql_i32).init(&direct_allocator.allocator);
	279	defer reset_map.deinit();
	280
	281	assert((reset_map.put(1, 11) catch unreachable) == null);
	282	assert((reset_map.put(2, 22) catch unreachable) == null);
	283	assert((reset_map.put(3, 33) catch unreachable) == null);
	284
	285	var keys = []i32 { 1, 2, 3 };
	286	var values = []i32 { 11, 22, 33 };
	287
	288	var it = reset_map.iterator();
	289	var count : usize = 0;
	290	while (it.next()) \|next\| {
	291	assert(next.key == keys[count]);
	292	assert(next.value == values[count]);
	293	count += 1;
	294	}
	295
	296	assert(count == 3);
	297	assert(it.next() == null);
	298	it.reset();
	299	count = 0;
	300	while (it.next()) \|next\| {
	301	assert(next.key == keys[count]);
	302	assert(next.value == values[count]);
	303	count += 1;
	304	if (count == 2) break;
	305	}
	306
	307	it.reset();
	308	var entry = ?? it.next();
	309	assert(entry.key == keys[0]);
	310	assert(entry.value == values[0]);
	311	}
	312
257	313	fn hash_i32(x: i32) u32 {
258	314	return @bitCast(u32, x);
259	315	}

std/heap.zig+117-18

...	...	@@ -47,13 +47,6 @@ pub const DirectAllocator = struct {
47	47
48	48	const HeapHandle = if (builtin.os == Os.windows) os.windows.HANDLE else void;
49	49
50		//pub const canary_bytes = []u8 {48, 239, 128, 46, 18, 49, 147, 9, 195, 59, 203, 3, 245, 54, 9, 122};
51		//pub const want_safety = switch (builtin.mode) {
52		// builtin.Mode.Debug => true,
53		// builtin.Mode.ReleaseSafe => true,
54		// else => false,
55		//};
56
57	50	pub fn init() DirectAllocator {
58	51	return DirectAllocator {
59	52	.allocator = Allocator {
...	...	@@ -79,19 +72,38 @@ pub const DirectAllocator = struct {
79	72
80	73	switch (builtin.os) {
81	74	Os.linux, Os.macosx, Os.ios => {
82		assert(alignment <= os.page_size);
83	75	const p = os.posix;
84		const addr = p.mmap(null, n, p.PROT_READ\|p.PROT_WRITE,
85		p.MAP_PRIVATE\|p.MAP_ANONYMOUS, -1, 0);
86		if (addr == p.MAP_FAILED) {
87		return error.OutOfMemory;
88		}
89		return @intToPtr(&u8, addr)[0..n];
	76	const alloc_size = if(alignment <= os.page_size) n else n + alignment;
	77	const addr = p.mmap(null, alloc_size, p.PROT_READ\|p.PROT_WRITE,
	78	p.MAP_PRIVATE\|p.MAP_ANONYMOUS, -1, 0);
	79	if(addr == p.MAP_FAILED) return error.OutOfMemory;
	80
	81	if(alloc_size == n) return @intToPtr(&u8, addr)[0..n];
	82
	83	var aligned_addr = addr & ~usize(alignment - 1);
	84	aligned_addr += alignment;
	85
	86	//We can unmap the unused portions of our mmap, but we must only
	87	// pass munmap bytes that exist outside our allocated pages or it
	88	// will happily eat us too
	89
	90	//Since alignment > page_size, we are by definition on a page boundry
	91	const unused_start = addr;
	92	const unused_len = aligned_addr - 1 - unused_start;
	93
	94	var err = p.munmap(unused_start, unused_len);
	95	debug.assert(p.getErrno(err) == 0);
	96
	97	//It is impossible that there is an unoccupied page at the top of our
	98	// mmap.
	99
	100	return @intToPtr(&u8, aligned_addr)[0..n];
90	101	},
91	102	Os.windows => {
92	103	const amt = n + alignment + @sizeOf(usize);
93	104	const heap_handle = self.heap_handle ?? blk: {
94		const hh = os.windows.HeapCreate(os.windows.HEAP_NO_SERIALIZE, amt, 0) ?? return error.OutOfMemory;
	105	const hh = os.windows.HeapCreate(os.windows.HEAP_NO_SERIALIZE, amt, 0)
	106	?? return error.OutOfMemory;
95	107	self.heap_handle = hh;
96	108	break :blk hh;
97	109	};
...	...	@@ -120,7 +132,7 @@ pub const DirectAllocator = struct {
120	132	const rem = @rem(new_addr_end, os.page_size);
121	133	const new_addr_end_rounded = new_addr_end + if (rem == 0) 0 else (os.page_size - rem);
122	134	if (old_addr_end > new_addr_end_rounded) {
123		_ = os.posix.munmap(@intToPtr(&u8, new_addr_end_rounded), old_addr_end - new_addr_end_rounded);
	135	_ = os.posix.munmap(new_addr_end_rounded, old_addr_end - new_addr_end_rounded);
124	136	}
125	137	return old_mem[0..new_size];
126	138	}
...	...	@@ -158,7 +170,7 @@ pub const DirectAllocator = struct {
158	170
159	171	switch (builtin.os) {
160	172	Os.linux, Os.macosx, Os.ios => {
161		_ = os.posix.munmap(bytes.ptr, bytes.len);
	173	_ = os.posix.munmap(@ptrToInt(bytes.ptr), bytes.len);
162	174	},
163	175	Os.windows => {
164	176	const record_addr = @ptrToInt(bytes.ptr) + bytes.len;
...	...	@@ -279,7 +291,7 @@ pub const FixedBufferAllocator = struct {
279	291
280	292	fn alloc(allocator: &Allocator, n: usize, alignment: u29) ![]u8 {
281	293	const self = @fieldParentPtr(FixedBufferAllocator, "allocator", allocator);
282		const addr = @ptrToInt(&self.buffer[self.end_index]);
	294	const addr = @ptrToInt(self.buffer.ptr) + self.end_index;
283	295	const rem = @rem(addr, alignment);
284	296	const march_forward_bytes = if (rem == 0) 0 else (alignment - rem);
285	297	const adjusted_index = self.end_index + march_forward_bytes;
...	...	@@ -306,6 +318,54 @@ pub const FixedBufferAllocator = struct {
306	318	fn free(allocator: &Allocator, bytes: []u8) void { }
307	319	};
308	320
	321	/// lock free
	322	pub const ThreadSafeFixedBufferAllocator = struct {
	323	allocator: Allocator,
	324	end_index: usize,
	325	buffer: []u8,
	326
	327	pub fn init(buffer: []u8) ThreadSafeFixedBufferAllocator {
	328	return ThreadSafeFixedBufferAllocator {
	329	.allocator = Allocator {
	330	.allocFn = alloc,
	331	.reallocFn = realloc,
	332	.freeFn = free,
	333	},
	334	.buffer = buffer,
	335	.end_index = 0,
	336	};
	337	}
	338
	339	fn alloc(allocator: &Allocator, n: usize, alignment: u29) ![]u8 {
	340	const self = @fieldParentPtr(ThreadSafeFixedBufferAllocator, "allocator", allocator);
	341	var end_index = @atomicLoad(usize, &self.end_index, builtin.AtomicOrder.SeqCst);
	342	while (true) {
	343	const addr = @ptrToInt(self.buffer.ptr) + end_index;
	344	const rem = @rem(addr, alignment);
	345	const march_forward_bytes = if (rem == 0) 0 else (alignment - rem);
	346	const adjusted_index = end_index + march_forward_bytes;
	347	const new_end_index = adjusted_index + n;
	348	if (new_end_index > self.buffer.len) {
	349	return error.OutOfMemory;
	350	}
	351	end_index = @cmpxchgWeak(usize, &self.end_index, end_index, new_end_index,
	352	builtin.AtomicOrder.SeqCst, builtin.AtomicOrder.SeqCst) ?? return self.buffer[adjusted_index .. new_end_index];
	353	}
	354	}
	355
	356	fn realloc(allocator: &Allocator, old_mem: []u8, new_size: usize, alignment: u29) ![]u8 {
	357	if (new_size <= old_mem.len) {
	358	return old_mem[0..new_size];
	359	} else {
	360	const result = try alloc(allocator, new_size, alignment);
	361	mem.copy(u8, result, old_mem);
	362	return result;
	363	}
	364	}
	365
	366	fn free(allocator: &Allocator, bytes: []u8) void { }
	367	};
	368
309	369
310	370
311	371	test "c_allocator" {
...	...	@@ -322,6 +382,7 @@ test "DirectAllocator" {
322	382
323	383	const allocator = &direct_allocator.allocator;
324	384	try testAllocator(allocator);
	385	try testAllocatorLargeAlignment(allocator);
325	386	}
326	387
327	388	test "ArenaAllocator" {
...	...	@@ -332,6 +393,7 @@ test "ArenaAllocator" {
332	393	defer arena_allocator.deinit();
333	394
334	395	try testAllocator(&arena_allocator.allocator);
	396	try testAllocatorLargeAlignment(&arena_allocator.allocator);
335	397	}
336	398
337	399	var test_fixed_buffer_allocator_memory: [30000 * @sizeOf(usize)]u8 = undefined;
...	...	@@ -339,6 +401,14 @@ test "FixedBufferAllocator" {
339	401	var fixed_buffer_allocator = FixedBufferAllocator.init(test_fixed_buffer_allocator_memory[0..]);
340	402
341	403	try testAllocator(&fixed_buffer_allocator.allocator);
	404	try testAllocatorLargeAlignment(&fixed_buffer_allocator.allocator);
	405	}
	406
	407	test "ThreadSafeFixedBufferAllocator" {
	408	var fixed_buffer_allocator = ThreadSafeFixedBufferAllocator.init(test_fixed_buffer_allocator_memory[0..]);
	409
	410	try testAllocator(&fixed_buffer_allocator.allocator);
	411	try testAllocatorLargeAlignment(&fixed_buffer_allocator.allocator);
342	412	}
343	413
344	414	fn testAllocator(allocator: &mem.Allocator) !void {
...	...	@@ -360,3 +430,32 @@ fn testAllocator(allocator: &mem.Allocator) !void {
360	430
361	431	allocator.free(slice);
362	432	}
	433
	434	fn testAllocatorLargeAlignment(allocator: &mem.Allocator) mem.Allocator.Error!void {
	435	//Maybe a platform's page_size is actually the same as or
	436	// very near usize?
	437	if(os.page_size << 2 > @maxValue(usize)) return;
	438
	439	const USizeShift = @IntType(false, std.math.log2(usize.bit_count));
	440	const large_align = u29(os.page_size << 2);
	441
	442	var align_mask: usize = undefined;
	443	_ = @shlWithOverflow(usize, ~usize(0), USizeShift(@ctz(large_align)), &align_mask);
	444
	445	var slice = try allocator.allocFn(allocator, 500, large_align);
	446	debug.assert(@ptrToInt(slice.ptr) & align_mask == @ptrToInt(slice.ptr));
	447
	448	slice = try allocator.reallocFn(allocator, slice, 100, large_align);
	449	debug.assert(@ptrToInt(slice.ptr) & align_mask == @ptrToInt(slice.ptr));
	450
	451	slice = try allocator.reallocFn(allocator, slice, 5000, large_align);
	452	debug.assert(@ptrToInt(slice.ptr) & align_mask == @ptrToInt(slice.ptr));
	453
	454	slice = try allocator.reallocFn(allocator, slice, 10, large_align);
	455	debug.assert(@ptrToInt(slice.ptr) & align_mask == @ptrToInt(slice.ptr));
	456
	457	slice = try allocator.reallocFn(allocator, slice, 20000, large_align);
	458	debug.assert(@ptrToInt(slice.ptr) & align_mask == @ptrToInt(slice.ptr));
	459
	460	allocator.free(slice);
	461	}

std/index.zig+9-3

...	...	@@ -7,7 +7,9 @@ pub const BufferOutStream = @import("buffer.zig").BufferOutStream;
7	7	pub const HashMap = @import("hash_map.zig").HashMap;
8	8	pub const LinkedList = @import("linked_list.zig").LinkedList;
9	9	pub const IntrusiveLinkedList = @import("linked_list.zig").IntrusiveLinkedList;
	10	pub const SegmentedList = @import("segmented_list.zig").SegmentedList;
10	11
	12	pub const atomic = @import("atomic/index.zig");
11	13	pub const base64 = @import("base64.zig");
12	14	pub const build = @import("build.zig");
13	15	pub const c = @import("c/index.zig");
...	...	@@ -17,11 +19,12 @@ pub const debug = @import("debug/index.zig");
17	19	pub const dwarf = @import("dwarf.zig");
18	20	pub const elf = @import("elf.zig");
19	21	pub const empty_import = @import("empty.zig");
20		pub const endian = @import("endian.zig");
	22	pub const event = @import("event.zig");
21	23	pub const fmt = @import("fmt/index.zig");
22	24	pub const hash = @import("hash/index.zig");
23	25	pub const heap = @import("heap.zig");
24	26	pub const io = @import("io.zig");
	27	pub const json = @import("json.zig");
25	28	pub const macho = @import("macho.zig");
26	29	pub const math = @import("math/index.zig");
27	30	pub const mem = @import("mem.zig");
...	...	@@ -34,12 +37,14 @@ pub const zig = @import("zig/index.zig");
34	37
35	38	test "std" {
36	39	// run tests from these
	40	_ = @import("atomic/index.zig");
37	41	_ = @import("array_list.zig");
38	42	_ = @import("buf_map.zig");
39	43	_ = @import("buf_set.zig");
40	44	_ = @import("buffer.zig");
41	45	_ = @import("hash_map.zig");
42	46	_ = @import("linked_list.zig");
	47	_ = @import("segmented_list.zig");
43	48
44	49	_ = @import("base64.zig");
45	50	_ = @import("build.zig");
...	...	@@ -50,15 +55,16 @@ test "std" {
50	55	_ = @import("dwarf.zig");
51	56	_ = @import("elf.zig");
52	57	_ = @import("empty.zig");
53		_ = @import("endian.zig");
	58	_ = @import("event.zig");
54	59	_ = @import("fmt/index.zig");
55	60	_ = @import("hash/index.zig");
56	61	_ = @import("io.zig");
	62	_ = @import("json.zig");
57	63	_ = @import("macho.zig");
58	64	_ = @import("math/index.zig");
59	65	_ = @import("mem.zig");
60		_ = @import("heap.zig");
61	66	_ = @import("net.zig");
	67	_ = @import("heap.zig");
62	68	_ = @import("os/index.zig");
63	69	_ = @import("rand/index.zig");
64	70	_ = @import("sort.zig");

std/io.zig+5

...	...	@@ -486,6 +486,11 @@ pub fn readLine(buf: []u8) !usize {
486	486	while (true) {
487	487	const byte = stream.readByte() catch return error.EndOfFile;
488	488	switch (byte) {
	489	'\r' => {
	490	// trash the following \n
	491	_ = stream.readByte() catch return error.EndOfFile;
	492	return index;
	493	},
489	494	'\n' => return index,
490	495	else => {
491	496	if (index == buf.len) return error.InputTooLong;

std/io_test.zig+17-1

...	...	@@ -1,6 +1,5 @@
1	1	const std = @import("index.zig");
2	2	const io = std.io;
3		const allocator = std.debug.global_allocator;
4	3	const DefaultPrng = std.rand.DefaultPrng;
5	4	const assert = std.debug.assert;
6	5	const mem = std.mem;
...	...	@@ -8,6 +7,9 @@ const os = std.os;
8	7	const builtin = @import("builtin");
9	8
10	9	test "write a file, read it, then delete it" {
	10	var raw_bytes: [200 * 1024]u8 = undefined;
	11	var allocator = &std.heap.FixedBufferAllocator.init(raw_bytes[0..]).allocator;
	12
11	13	var data: [1024]u8 = undefined;
12	14	var prng = DefaultPrng.init(1234);
13	15	prng.random.bytes(data[0..]);
...	...	@@ -44,3 +46,17 @@ test "write a file, read it, then delete it" {
44	46	}
45	47	try os.deleteFile(allocator, tmp_file_name);
46	48	}
	49
	50	test "BufferOutStream" {
	51	var bytes: [100]u8 = undefined;
	52	var allocator = &std.heap.FixedBufferAllocator.init(bytes[0..]).allocator;
	53
	54	var buffer = try std.Buffer.initSize(allocator, 0);
	55	var buf_stream = &std.io.BufferOutStream.init(&buffer).stream;
	56
	57	const x: i32 = 42;
	58	const y: i32 = 1234;
	59	try buf_stream.print("x: {}\ny: {}\n", x, y);
	60
	61	assert(mem.eql(u8, buffer.toSlice(), "x: 42\ny: 1234\n"));
	62	}

std/json.zig created+1304

...	...	@@ -0,0 +1,1304 @@
	1	// JSON parser conforming to RFC8259.
	2	//
	3	// https://tools.ietf.org/html/rfc8259
	4
	5	const std = @import("index.zig");
	6	const mem = std.mem;
	7
	8	const u1 = @IntType(false, 1);
	9	const u256 = @IntType(false, 256);
	10
	11	// A single token slice into the parent string.
	12	//
	13	// Use `token.slice()` on the inptu at the current position to get the current slice.
	14	pub const Token = struct {
	15	id: Id,
	16	// How many bytes do we skip before counting
	17	offset: u1,
	18	// Whether string contains a \uXXXX sequence and cannot be zero-copied
	19	string_has_escape: bool,
	20	// Whether number is simple and can be represented by an integer (i.e. no `.` or `e`)
	21	number_is_integer: bool,
	22	// How many bytes from the current position behind the start of this token is.
	23	count: usize,
	24
	25	pub const Id = enum {
	26	ObjectBegin,
	27	ObjectEnd,
	28	ArrayBegin,
	29	ArrayEnd,
	30	String,
	31	Number,
	32	True,
	33	False,
	34	Null,
	35	};
	36
	37	pub fn init(id: Id, count: usize, offset: u1) Token {
	38	return Token {
	39	.id = id,
	40	.offset = offset,
	41	.string_has_escape = false,
	42	.number_is_integer = true,
	43	.count = count,
	44	};
	45	}
	46
	47	pub fn initString(count: usize, has_unicode_escape: bool) Token {
	48	return Token {
	49	.id = Id.String,
	50	.offset = 0,
	51	.string_has_escape = has_unicode_escape,
	52	.number_is_integer = true,
	53	.count = count,
	54	};
	55	}
	56
	57	pub fn initNumber(count: usize, number_is_integer: bool) Token {
	58	return Token {
	59	.id = Id.Number,
	60	.offset = 0,
	61	.string_has_escape = false,
	62	.number_is_integer = number_is_integer,
	63	.count = count,
	64	};
	65	}
	66
	67	// A marker token is a zero-length
	68	pub fn initMarker(id: Id) Token {
	69	return Token {
	70	.id = id,
	71	.offset = 0,
	72	.string_has_escape = false,
	73	.number_is_integer = true,
	74	.count = 0,
	75	};
	76	}
	77
	78	// Slice into the underlying input string.
	79	pub fn slice(self: &const Token, input: []const u8, i: usize) []const u8 {
	80	return input[i + self.offset - self.count .. i + self.offset];
	81	}
	82	};
	83
	84	// A small streaming JSON parser. This accepts input one byte at a time and returns tokens as
	85	// they are encountered. No copies or allocations are performed during parsing and the entire
	86	// parsing state requires ~40-50 bytes of stack space.
	87	//
	88	// Conforms strictly to RFC8529.
	89	const StreamingJsonParser = struct {
	90	// Current state
	91	state: State,
	92	// How many bytes we have counted for the current token
	93	count: usize,
	94	// What state to follow after parsing a string (either property or value string)
	95	after_string_state: State,
	96	// What state to follow after parsing a value (either top-level or value end)
	97	after_value_state: State,
	98	// If we stopped now, would the complete parsed string to now be a valid json string
	99	complete: bool,
	100	// Current token flags to pass through to the next generated, see Token.
	101	string_has_escape: bool,
	102	number_is_integer: bool,
	103
	104	// Bit-stack for nested object/map literals (max 255 nestings).
	105	stack: u256,
	106	stack_used: u8,
	107
	108	const object_bit = 0;
	109	const array_bit = 1;
	110	const max_stack_size = @maxValue(u8);
	111
	112	pub fn init() StreamingJsonParser {
	113	var p: StreamingJsonParser = undefined;
	114	p.reset();
	115	return p;
	116	}
	117
	118	pub fn reset(p: &StreamingJsonParser) void {
	119	p.state = State.TopLevelBegin;
	120	p.count = 0;
	121	// Set before ever read in main transition function
	122	p.after_string_state = undefined;
	123	p.after_value_state = State.ValueEnd; // handle end of values normally
	124	p.stack = 0;
	125	p.stack_used = 0;
	126	p.complete = false;
	127	p.string_has_escape = false;
	128	p.number_is_integer = true;
	129	}
	130
	131	pub const State = enum {
	132	// These must be first with these explicit values as we rely on them for indexing the
	133	// bit-stack directly and avoiding a branch.
	134	ObjectSeparator = 0,
	135	ValueEnd = 1,
	136
	137	TopLevelBegin,
	138	TopLevelEnd,
	139
	140	ValueBegin,
	141	ValueBeginNoClosing,
	142
	143	String,
	144	StringUtf8Byte3,
	145	StringUtf8Byte2,
	146	StringUtf8Byte1,
	147	StringEscapeCharacter,
	148	StringEscapeHexUnicode4,
	149	StringEscapeHexUnicode3,
	150	StringEscapeHexUnicode2,
	151	StringEscapeHexUnicode1,
	152
	153	Number,
	154	NumberMaybeDotOrExponent,
	155	NumberMaybeDigitOrDotOrExponent,
	156	NumberFractionalRequired,
	157	NumberFractional,
	158	NumberMaybeExponent,
	159	NumberExponent,
	160	NumberExponentDigitsRequired,
	161	NumberExponentDigits,
	162
	163	TrueLiteral1,
	164	TrueLiteral2,
	165	TrueLiteral3,
	166
	167	FalseLiteral1,
	168	FalseLiteral2,
	169	FalseLiteral3,
	170	FalseLiteral4,
	171
	172	NullLiteral1,
	173	NullLiteral2,
	174	NullLiteral3,
	175
	176	// Only call this function to generate array/object final state.
	177	pub fn fromInt(x: var) State {
	178	std.debug.assert(x == 0 or x == 1);
	179	const T = @TagType(State);
	180	return State(T(x));
	181	}
	182	};
	183
	184	pub const Error = error {
	185	InvalidTopLevel,
	186	TooManyNestedItems,
	187	TooManyClosingItems,
	188	InvalidValueBegin,
	189	InvalidValueEnd,
	190	UnbalancedBrackets,
	191	UnbalancedBraces,
	192	UnexpectedClosingBracket,
	193	UnexpectedClosingBrace,
	194	InvalidNumber,
	195	InvalidSeparator,
	196	InvalidLiteral,
	197	InvalidEscapeCharacter,
	198	InvalidUnicodeHexSymbol,
	199	InvalidUtf8Byte,
	200	InvalidTopLevelTrailing,
	201	InvalidControlCharacter,
	202	};
	203
	204	// Give another byte to the parser and obtain any new tokens. This may (rarely) return two
	205	// tokens. token2 is always null if token1 is null.
	206	//
	207	// There is currently no error recovery on a bad stream.
	208	pub fn feed(p: &StreamingJsonParser, c: u8, token1: &?Token, token2: &?Token) Error!void {
	209	*token1 = null;
	210	*token2 = null;
	211	p.count += 1;
	212
	213	// unlikely
	214	if (try p.transition(c, token1)) {
	215	_ = try p.transition(c, token2);
	216	}
	217	}
	218
	219	// Perform a single transition on the state machine and return any possible token.
	220	fn transition(p: &StreamingJsonParser, c: u8, token: &?Token) Error!bool {
	221	switch (p.state) {
	222	State.TopLevelBegin => switch (c) {
	223	'{' => {
	224	p.stack <<= 1;
	225	p.stack \|= object_bit;
	226	p.stack_used += 1;
	227
	228	p.state = State.ValueBegin;
	229	p.after_string_state = State.ObjectSeparator;
	230
	231	*token = Token.initMarker(Token.Id.ObjectBegin);
	232	},
	233	'[' => {
	234	p.stack <<= 1;
	235	p.stack \|= array_bit;
	236	p.stack_used += 1;
	237
	238	p.state = State.ValueBegin;
	239	p.after_string_state = State.ValueEnd;
	240
	241	*token = Token.initMarker(Token.Id.ArrayBegin);
	242	},
	243	'-' => {
	244	p.number_is_integer = true;
	245	p.state = State.Number;
	246	p.after_value_state = State.TopLevelEnd;
	247	p.count = 0;
	248	},
	249	'0' => {
	250	p.number_is_integer = true;
	251	p.state = State.NumberMaybeDotOrExponent;
	252	p.after_value_state = State.TopLevelEnd;
	253	p.count = 0;
	254	},
	255	'1' ... '9' => {
	256	p.number_is_integer = true;
	257	p.state = State.NumberMaybeDigitOrDotOrExponent;
	258	p.after_value_state = State.TopLevelEnd;
	259	p.count = 0;
	260	},
	261	'"' => {
	262	p.state = State.String;
	263	p.after_value_state = State.TopLevelEnd;
	264	// We don't actually need the following since after_value_state should override.
	265	p.after_string_state = State.ValueEnd;
	266	p.string_has_escape = false;
	267	p.count = 0;
	268	},
	269	't' => {
	270	p.state = State.TrueLiteral1;
	271	p.after_value_state = State.TopLevelEnd;
	272	p.count = 0;
	273	},
	274	'f' => {
	275	p.state = State.FalseLiteral1;
	276	p.after_value_state = State.TopLevelEnd;
	277	p.count = 0;
	278	},
	279	'n' => {
	280	p.state = State.NullLiteral1;
	281	p.after_value_state = State.TopLevelEnd;
	282	p.count = 0;
	283	},
	284	0x09, 0x0A, 0x0D, 0x20 => {
	285	// whitespace
	286	},
	287	else => {
	288	return error.InvalidTopLevel;
	289	},
	290	},
	291
	292	State.TopLevelEnd => switch (c) {
	293	0x09, 0x0A, 0x0D, 0x20 => {
	294	// whitespace
	295	},
	296	else => {
	297	return error.InvalidTopLevelTrailing;
	298	},
	299	},
	300
	301	State.ValueBegin => switch (c) {
	302	// NOTE: These are shared in ValueEnd as well, think we can reorder states to
	303	// be a bit clearer and avoid this duplication.
	304	'}' => {
	305	// unlikely
	306	if (p.stack & 1 != object_bit) {
	307	return error.UnexpectedClosingBracket;
	308	}
	309	if (p.stack_used == 0) {
	310	return error.TooManyClosingItems;
	311	}
	312
	313	p.state = State.ValueBegin;
	314	p.after_string_state = State.fromInt(p.stack & 1);
	315
	316	p.stack >>= 1;
	317	p.stack_used -= 1;
	318
	319	switch (p.stack_used) {
	320	0 => {
	321	p.complete = true;
	322	p.state = State.TopLevelEnd;
	323	},
	324	else => {},
	325	}
	326
	327	*token = Token.initMarker(Token.Id.ObjectEnd);
	328	},
	329	']' => {
	330	if (p.stack & 1 != array_bit) {
	331	return error.UnexpectedClosingBrace;
	332	}
	333	if (p.stack_used == 0) {
	334	return error.TooManyClosingItems;
	335	}
	336
	337	p.state = State.ValueBegin;
	338	p.after_string_state = State.fromInt(p.stack & 1);
	339
	340	p.stack >>= 1;
	341	p.stack_used -= 1;
	342
	343	switch (p.stack_used) {
	344	0 => {
	345	p.complete = true;
	346	p.state = State.TopLevelEnd;
	347	},
	348	else => {},
	349	}
	350
	351	*token = Token.initMarker(Token.Id.ArrayEnd);
	352	},
	353	'{' => {
	354	if (p.stack_used == max_stack_size) {
	355	return error.TooManyNestedItems;
	356	}
	357
	358	p.stack <<= 1;
	359	p.stack \|= object_bit;
	360	p.stack_used += 1;
	361
	362	p.state = State.ValueBegin;
	363	p.after_string_state = State.ObjectSeparator;
	364
	365	*token = Token.initMarker(Token.Id.ObjectBegin);
	366	},
	367	'[' => {
	368	if (p.stack_used == max_stack_size) {
	369	return error.TooManyNestedItems;
	370	}
	371
	372	p.stack <<= 1;
	373	p.stack \|= array_bit;
	374	p.stack_used += 1;
	375
	376	p.state = State.ValueBegin;
	377	p.after_string_state = State.ValueEnd;
	378
	379	*token = Token.initMarker(Token.Id.ArrayBegin);
	380	},
	381	'-' => {
	382	p.state = State.Number;
	383	p.count = 0;
	384	},
	385	'0' => {
	386	p.state = State.NumberMaybeDotOrExponent;
	387	p.count = 0;
	388	},
	389	'1' ... '9' => {
	390	p.state = State.NumberMaybeDigitOrDotOrExponent;
	391	p.count = 0;
	392	},
	393	'"' => {
	394	p.state = State.String;
	395	p.count = 0;
	396	},
	397	't' => {
	398	p.state = State.TrueLiteral1;
	399	p.count = 0;
	400	},
	401	'f' => {
	402	p.state = State.FalseLiteral1;
	403	p.count = 0;
	404	},
	405	'n' => {
	406	p.state = State.NullLiteral1;
	407	p.count = 0;
	408	},
	409	0x09, 0x0A, 0x0D, 0x20 => {
	410	// whitespace
	411	},
	412	else => {
	413	return error.InvalidValueBegin;
	414	},
	415	},
	416
	417	// TODO: A bit of duplication here and in the following state, redo.
	418	State.ValueBeginNoClosing => switch (c) {
	419	'{' => {
	420	if (p.stack_used == max_stack_size) {
	421	return error.TooManyNestedItems;
	422	}
	423
	424	p.stack <<= 1;
	425	p.stack \|= object_bit;
	426	p.stack_used += 1;
	427
	428	p.state = State.ValueBegin;
	429	p.after_string_state = State.ObjectSeparator;
	430
	431	*token = Token.initMarker(Token.Id.ObjectBegin);
	432	},
	433	'[' => {
	434	if (p.stack_used == max_stack_size) {
	435	return error.TooManyNestedItems;
	436	}
	437
	438	p.stack <<= 1;
	439	p.stack \|= array_bit;
	440	p.stack_used += 1;
	441
	442	p.state = State.ValueBegin;
	443	p.after_string_state = State.ValueEnd;
	444
	445	*token = Token.initMarker(Token.Id.ArrayBegin);
	446	},
	447	'-' => {
	448	p.state = State.Number;
	449	p.count = 0;
	450	},
	451	'0' => {
	452	p.state = State.NumberMaybeDotOrExponent;
	453	p.count = 0;
	454	},
	455	'1' ... '9' => {
	456	p.state = State.NumberMaybeDigitOrDotOrExponent;
	457	p.count = 0;
	458	},
	459	'"' => {
	460	p.state = State.String;
	461	p.count = 0;
	462	},
	463	't' => {
	464	p.state = State.TrueLiteral1;
	465	p.count = 0;
	466	},
	467	'f' => {
	468	p.state = State.FalseLiteral1;
	469	p.count = 0;
	470	},
	471	'n' => {
	472	p.state = State.NullLiteral1;
	473	p.count = 0;
	474	},
	475	0x09, 0x0A, 0x0D, 0x20 => {
	476	// whitespace
	477	},
	478	else => {
	479	return error.InvalidValueBegin;
	480	},
	481	},
	482
	483	State.ValueEnd => switch (c) {
	484	',' => {
	485	p.after_string_state = State.fromInt(p.stack & 1);
	486	p.state = State.ValueBeginNoClosing;
	487	},
	488	']' => {
	489	if (p.stack_used == 0) {
	490	return error.UnbalancedBrackets;
	491	}
	492
	493	p.state = State.ValueEnd;
	494	p.after_string_state = State.fromInt(p.stack & 1);
	495
	496	p.stack >>= 1;
	497	p.stack_used -= 1;
	498
	499	if (p.stack_used == 0) {
	500	p.complete = true;
	501	p.state = State.TopLevelEnd;
	502	}
	503
	504	*token = Token.initMarker(Token.Id.ArrayEnd);
	505	},
	506	'}' => {
	507	if (p.stack_used == 0) {
	508	return error.UnbalancedBraces;
	509	}
	510
	511	p.state = State.ValueEnd;
	512	p.after_string_state = State.fromInt(p.stack & 1);
	513
	514	p.stack >>= 1;
	515	p.stack_used -= 1;
	516
	517	if (p.stack_used == 0) {
	518	p.complete = true;
	519	p.state = State.TopLevelEnd;
	520	}
	521
	522	*token = Token.initMarker(Token.Id.ObjectEnd);
	523	},
	524	0x09, 0x0A, 0x0D, 0x20 => {
	525	// whitespace
	526	},
	527	else => {
	528	return error.InvalidValueEnd;
	529	},
	530	},
	531
	532	State.ObjectSeparator => switch (c) {
	533	':' => {
	534	p.state = State.ValueBegin;
	535	p.after_string_state = State.ValueEnd;
	536	},
	537	0x09, 0x0A, 0x0D, 0x20 => {
	538	// whitespace
	539	},
	540	else => {
	541	return error.InvalidSeparator;
	542	},
	543	},
	544
	545	State.String => switch (c) {
	546	0x00 ... 0x1F => {
	547	return error.InvalidControlCharacter;
	548	},
	549	'"' => {
	550	p.state = p.after_string_state;
	551	if (p.after_value_state == State.TopLevelEnd) {
	552	p.state = State.TopLevelEnd;
	553	p.complete = true;
	554	}
	555
	556	*token = Token.initString(p.count - 1, p.string_has_escape);
	557	},
	558	'\\' => {
	559	p.state = State.StringEscapeCharacter;
	560	},
	561	0x20, 0x21, 0x23 ... 0x5B, 0x5D ... 0x7F => {
	562	// non-control ascii
	563	},
	564	0xC0 ... 0xDF => {
	565	p.state = State.StringUtf8Byte1;
	566	},
	567	0xE0 ... 0xEF => {
	568	p.state = State.StringUtf8Byte2;
	569	},
	570	0xF0 ... 0xFF => {
	571	p.state = State.StringUtf8Byte3;
	572	},
	573	else => {
	574	return error.InvalidUtf8Byte;
	575	},
	576	},
	577
	578	State.StringUtf8Byte3 => switch (c >> 6) {
	579	0b10 => p.state = State.StringUtf8Byte2,
	580	else => return error.InvalidUtf8Byte,
	581	},
	582
	583	State.StringUtf8Byte2 => switch (c >> 6) {
	584	0b10 => p.state = State.StringUtf8Byte1,
	585	else => return error.InvalidUtf8Byte,
	586	},
	587
	588	State.StringUtf8Byte1 => switch (c >> 6) {
	589	0b10 => p.state = State.String,
	590	else => return error.InvalidUtf8Byte,
	591	},
	592
	593	State.StringEscapeCharacter => switch (c) {
	594	// NOTE: '/' is allowed as an escaped character but it also is allowed
	595	// as unescaped according to the RFC. There is a reported errata which suggests
	596	// removing the non-escaped variant but it makes more sense to simply disallow
	597	// it as an escape code here.
	598	//
	599	// The current JSONTestSuite tests rely on both of this behaviour being present
	600	// however, so we default to the status quo where both are accepted until this
	601	// is further clarified.
	602	'"', '\\', '/', 'b', 'f', 'n', 'r', 't' => {
	603	p.string_has_escape = true;
	604	p.state = State.String;
	605	},
	606	'u' => {
	607	p.string_has_escape = true;
	608	p.state = State.StringEscapeHexUnicode4;
	609	},
	610	else => {
	611	return error.InvalidEscapeCharacter;
	612	},
	613	},
	614
	615	State.StringEscapeHexUnicode4 => switch (c) {
	616	'0' ... '9', 'A' ... 'F', 'a' ... 'f' => {
	617	p.state = State.StringEscapeHexUnicode3;
	618	},
	619	else => return error.InvalidUnicodeHexSymbol,
	620	},
	621
	622	State.StringEscapeHexUnicode3 => switch (c) {
	623	'0' ... '9', 'A' ... 'F', 'a' ... 'f' => {
	624	p.state = State.StringEscapeHexUnicode2;
	625	},
	626	else => return error.InvalidUnicodeHexSymbol,
	627	},
	628
	629	State.StringEscapeHexUnicode2 => switch (c) {
	630	'0' ... '9', 'A' ... 'F', 'a' ... 'f' => {
	631	p.state = State.StringEscapeHexUnicode1;
	632	},
	633	else => return error.InvalidUnicodeHexSymbol,
	634	},
	635
	636	State.StringEscapeHexUnicode1 => switch (c) {
	637	'0' ... '9', 'A' ... 'F', 'a' ... 'f' => {
	638	p.state = State.String;
	639	},
	640	else => return error.InvalidUnicodeHexSymbol,
	641	},
	642
	643	State.Number => {
	644	p.complete = p.after_value_state == State.TopLevelEnd;
	645	switch (c) {
	646	'0' => {
	647	p.state = State.NumberMaybeDotOrExponent;
	648	},
	649	'1' ... '9' => {
	650	p.state = State.NumberMaybeDigitOrDotOrExponent;
	651	},
	652	else => {
	653	return error.InvalidNumber;
	654	},
	655	}
	656	},
	657
	658	State.NumberMaybeDotOrExponent => {
	659	p.complete = p.after_value_state == State.TopLevelEnd;
	660	switch (c) {
	661	'.' => {
	662	p.number_is_integer = false;
	663	p.state = State.NumberFractionalRequired;
	664	},
	665	'e', 'E' => {
	666	p.number_is_integer = false;
	667	p.state = State.NumberExponent;
	668	},
	669	else => {
	670	p.state = p.after_value_state;
	671	*token = Token.initNumber(p.count, p.number_is_integer);
	672	return true;
	673	},
	674	}
	675	},
	676
	677	State.NumberMaybeDigitOrDotOrExponent => {
	678	p.complete = p.after_value_state == State.TopLevelEnd;
	679	switch (c) {
	680	'.' => {
	681	p.number_is_integer = false;
	682	p.state = State.NumberFractionalRequired;
	683	},
	684	'e', 'E' => {
	685	p.number_is_integer = false;
	686	p.state = State.NumberExponent;
	687	},
	688	'0' ... '9' => {
	689	// another digit
	690	},
	691	else => {
	692	p.state = p.after_value_state;
	693	*token = Token.initNumber(p.count, p.number_is_integer);
	694	return true;
	695	},
	696	}
	697	},
	698
	699	State.NumberFractionalRequired => {
	700	p.complete = p.after_value_state == State.TopLevelEnd;
	701	switch (c) {
	702	'0' ... '9' => {
	703	p.state = State.NumberFractional;
	704	},
	705	else => {
	706	return error.InvalidNumber;
	707	},
	708	}
	709	},
	710
	711	State.NumberFractional => {
	712	p.complete = p.after_value_state == State.TopLevelEnd;
	713	switch (c) {
	714	'0' ... '9' => {
	715	// another digit
	716	},
	717	'e', 'E' => {
	718	p.number_is_integer = false;
	719	p.state = State.NumberExponent;
	720	},
	721	else => {
	722	p.state = p.after_value_state;
	723	*token = Token.initNumber(p.count, p.number_is_integer);
	724	return true;
	725	},
	726	}
	727	},
	728
	729	State.NumberMaybeExponent => {
	730	p.complete = p.after_value_state == State.TopLevelEnd;
	731	switch (c) {
	732	'e', 'E' => {
	733	p.number_is_integer = false;
	734	p.state = State.NumberExponent;
	735	},
	736	else => {
	737	p.state = p.after_value_state;
	738	*token = Token.initNumber(p.count, p.number_is_integer);
	739	return true;
	740	},
	741	}
	742	},
	743
	744	State.NumberExponent => switch (c) {
	745	'-', '+', => {
	746	p.complete = false;
	747	p.state = State.NumberExponentDigitsRequired;
	748	},
	749	'0' ... '9' => {
	750	p.complete = p.after_value_state == State.TopLevelEnd;
	751	p.state = State.NumberExponentDigits;
	752	},
	753	else => {
	754	return error.InvalidNumber;
	755	},
	756	},
	757
	758	State.NumberExponentDigitsRequired => switch (c) {
	759	'0' ... '9' => {
	760	p.complete = p.after_value_state == State.TopLevelEnd;
	761	p.state = State.NumberExponentDigits;
	762	},
	763	else => {
	764	return error.InvalidNumber;
	765	},
	766	},
	767
	768	State.NumberExponentDigits => {
	769	p.complete = p.after_value_state == State.TopLevelEnd;
	770	switch (c) {
	771	'0' ... '9' => {
	772	// another digit
	773	},
	774	else => {
	775	p.state = p.after_value_state;
	776	*token = Token.initNumber(p.count, p.number_is_integer);
	777	return true;
	778	},
	779	}
	780	},
	781
	782	State.TrueLiteral1 => switch (c) {
	783	'r' => p.state = State.TrueLiteral2,
	784	else => return error.InvalidLiteral,
	785	},
	786
	787	State.TrueLiteral2 => switch (c) {
	788	'u' => p.state = State.TrueLiteral3,
	789	else => return error.InvalidLiteral,
	790	},
	791
	792	State.TrueLiteral3 => switch (c) {
	793	'e' => {
	794	p.state = p.after_value_state;
	795	p.complete = p.state == State.TopLevelEnd;
	796	*token = Token.init(Token.Id.True, p.count + 1, 1);
	797	},
	798	else => {
	799	return error.InvalidLiteral;
	800	},
	801	},
	802
	803	State.FalseLiteral1 => switch (c) {
	804	'a' => p.state = State.FalseLiteral2,
	805	else => return error.InvalidLiteral,
	806	},
	807
	808	State.FalseLiteral2 => switch (c) {
	809	'l' => p.state = State.FalseLiteral3,
	810	else => return error.InvalidLiteral,
	811	},
	812
	813	State.FalseLiteral3 => switch (c) {
	814	's' => p.state = State.FalseLiteral4,
	815	else => return error.InvalidLiteral,
	816	},
	817
	818	State.FalseLiteral4 => switch (c) {
	819	'e' => {
	820	p.state = p.after_value_state;
	821	p.complete = p.state == State.TopLevelEnd;
	822	*token = Token.init(Token.Id.False, p.count + 1, 1);
	823	},
	824	else => {
	825	return error.InvalidLiteral;
	826	},
	827	},
	828
	829	State.NullLiteral1 => switch (c) {
	830	'u' => p.state = State.NullLiteral2,
	831	else => return error.InvalidLiteral,
	832	},
	833
	834	State.NullLiteral2 => switch (c) {
	835	'l' => p.state = State.NullLiteral3,
	836	else => return error.InvalidLiteral,
	837	},
	838
	839	State.NullLiteral3 => switch (c) {
	840	'l' => {
	841	p.state = p.after_value_state;
	842	p.complete = p.state == State.TopLevelEnd;
	843	*token = Token.init(Token.Id.Null, p.count + 1, 1);
	844	},
	845	else => {
	846	return error.InvalidLiteral;
	847	},
	848	},
	849	}
	850
	851	return false;
	852	}
	853	};
	854
	855	// Validate a JSON string. This does not limit number precision so a decoder may not necessarily
	856	// be able to decode the string even if this returns true.
	857	pub fn validate(s: []const u8) bool {
	858	var p = StreamingJsonParser.init();
	859
	860	for (s) \|c, i\| {
	861	var token1: ?Token = undefined;
	862	var token2: ?Token = undefined;
	863
	864	p.feed(c, &token1, &token2) catch \|err\| {
	865	return false;
	866	};
	867	}
	868
	869	return p.complete;
	870	}
	871
	872	const Allocator = std.mem.Allocator;
	873	const ArenaAllocator = std.heap.ArenaAllocator;
	874	const ArrayList = std.ArrayList;
	875	const HashMap = std.HashMap;
	876
	877	pub const ValueTree = struct {
	878	arena: ArenaAllocator,
	879	root: Value,
	880
	881	pub fn deinit(self: &ValueTree) void {
	882	self.arena.deinit();
	883	}
	884	};
	885
	886	pub const ObjectMap = HashMap([]const u8, Value, mem.hash_slice_u8, mem.eql_slice_u8);
	887
	888	pub const Value = union(enum) {
	889	Null,
	890	Bool: bool,
	891	Integer: i64,
	892	Float: f64,
	893	String: []const u8,
	894	Array: ArrayList(Value),
	895	Object: ObjectMap,
	896
	897	pub fn dump(self: &const Value) void {
	898	switch (*self) {
	899	Value.Null => {
	900	std.debug.warn("null");
	901	},
	902	Value.Bool => \|inner\| {
	903	std.debug.warn("{}", inner);
	904	},
	905	Value.Integer => \|inner\| {
	906	std.debug.warn("{}", inner);
	907	},
	908	Value.Float => \|inner\| {
	909	std.debug.warn("{.5}", inner);
	910	},
	911	Value.String => \|inner\| {
	912	std.debug.warn("\"{}\"", inner);
	913	},
	914	Value.Array => \|inner\| {
	915	var not_first = false;
	916	std.debug.warn("[");
	917	for (inner.toSliceConst()) \|value\| {
	918	if (not_first) {
	919	std.debug.warn(",");
	920	}
	921	not_first = true;
	922	value.dump();
	923	}
	924	std.debug.warn("]");
	925	},
	926	Value.Object => \|inner\| {
	927	var not_first = false;
	928	std.debug.warn("{{");
	929	var it = inner.iterator();
	930
	931	while (it.next()) \|entry\| {
	932	if (not_first) {
	933	std.debug.warn(",");
	934	}
	935	not_first = true;
	936	std.debug.warn("\"{}\":", entry.key);
	937	entry.value.dump();
	938	}
	939	std.debug.warn("}}");
	940	},
	941	}
	942	}
	943
	944	pub fn dumpIndent(self: &const Value, indent: usize) void {
	945	if (indent == 0) {
	946	self.dump();
	947	} else {
	948	self.dumpIndentLevel(indent, 0);
	949	}
	950	}
	951
	952	fn dumpIndentLevel(self: &const Value, indent: usize, level: usize) void {
	953	switch (*self) {
	954	Value.Null => {
	955	std.debug.warn("null");
	956	},
	957	Value.Bool => \|inner\| {
	958	std.debug.warn("{}", inner);
	959	},
	960	Value.Integer => \|inner\| {
	961	std.debug.warn("{}", inner);
	962	},
	963	Value.Float => \|inner\| {
	964	std.debug.warn("{.5}", inner);
	965	},
	966	Value.String => \|inner\| {
	967	std.debug.warn("\"{}\"", inner);
	968	},
	969	Value.Array => \|inner\| {
	970	var not_first = false;
	971	std.debug.warn("[\n");
	972
	973	for (inner.toSliceConst()) \|value\| {
	974	if (not_first) {
	975	std.debug.warn(",\n");
	976	}
	977	not_first = true;
	978	padSpace(level + indent);
	979	value.dumpIndentLevel(indent, level + indent);
	980	}
	981	std.debug.warn("\n");
	982	padSpace(level);
	983	std.debug.warn("]");
	984	},
	985	Value.Object => \|inner\| {
	986	var not_first = false;
	987	std.debug.warn("{{\n");
	988	var it = inner.iterator();
	989
	990	while (it.next()) \|entry\| {
	991	if (not_first) {
	992	std.debug.warn(",\n");
	993	}
	994	not_first = true;
	995	padSpace(level + indent);
	996	std.debug.warn("\"{}\": ", entry.key);
	997	entry.value.dumpIndentLevel(indent, level + indent);
	998	}
	999	std.debug.warn("\n");
	1000	padSpace(level);
	1001	std.debug.warn("}}");
	1002	},
	1003	}
	1004	}
	1005
	1006	fn padSpace(indent: usize) void {
	1007	var i: usize = 0;
	1008	while (i < indent) : (i += 1) {
	1009	std.debug.warn(" ");
	1010	}
	1011	}
	1012	};
	1013
	1014	// A non-stream JSON parser which constructs a tree of Value's.
	1015	const JsonParser = struct {
	1016	allocator: &Allocator,
	1017	state: State,
	1018	copy_strings: bool,
	1019	// Stores parent nodes and un-combined Values.
	1020	stack: ArrayList(Value),
	1021
	1022	const State = enum {
	1023	ObjectKey,
	1024	ObjectValue,
	1025	ArrayValue,
	1026	Simple,
	1027	};
	1028
	1029	pub fn init(allocator: &Allocator, copy_strings: bool) JsonParser {
	1030	return JsonParser {
	1031	.allocator = allocator,
	1032	.state = State.Simple,
	1033	.copy_strings = copy_strings,
	1034	.stack = ArrayList(Value).init(allocator),
	1035	};
	1036	}
	1037
	1038	pub fn deinit(p: &JsonParser) void {
	1039	p.stack.deinit();
	1040	}
	1041
	1042	pub fn reset(p: &JsonParser) void {
	1043	p.state = State.Simple;
	1044	p.stack.shrink(0);
	1045	}
	1046
	1047	pub fn parse(p: &JsonParser, input: []const u8) !ValueTree {
	1048	var mp = StreamingJsonParser.init();
	1049
	1050	var arena = ArenaAllocator.init(p.allocator);
	1051	errdefer arena.deinit();
	1052
	1053	for (input) \|c, i\| {
	1054	var mt1: ?Token = undefined;
	1055	var mt2: ?Token = undefined;
	1056
	1057	try mp.feed(c, &mt1, &mt2);
	1058	if (mt1) \|t1\| {
	1059	try p.transition(&arena.allocator, input, i, t1);
	1060
	1061	if (mt2) \|t2\| {
	1062	try p.transition(&arena.allocator, input, i, t2);
	1063	}
	1064	}
	1065	}
	1066
	1067	// Handle top-level lonely number values.
	1068	{
	1069	const i = input.len;
	1070	var mt1: ?Token = undefined;
	1071	var mt2: ?Token = undefined;
	1072
	1073	try mp.feed(' ', &mt1, &mt2);
	1074	if (mt1) \|t1\| {
	1075	try p.transition(&arena.allocator, input, i, t1);
	1076	}
	1077	}
	1078
	1079	if (!mp.complete) {
	1080	return error.IncompleteJsonInput;
	1081	}
	1082
	1083	std.debug.assert(p.stack.len == 1);
	1084
	1085	return ValueTree {
	1086	.arena = arena,
	1087	.root = p.stack.at(0),
	1088	};
	1089	}
	1090
	1091	// Even though p.allocator exists, we take an explicit allocator so that allocation state
	1092	// can be cleaned up on error correctly during a `parse` on call.
	1093	fn transition(p: &JsonParser, allocator: &Allocator, input: []const u8, i: usize, token: &const Token) !void {
	1094	switch (p.state) {
	1095	State.ObjectKey => switch (token.id) {
	1096	Token.Id.ObjectEnd => {
	1097	if (p.stack.len == 1) {
	1098	return;
	1099	}
	1100
	1101	var value = p.stack.pop();
	1102	try p.pushToParent(value);
	1103	},
	1104	Token.Id.String => {
	1105	try p.stack.append(try p.parseString(allocator, token, input, i));
	1106	p.state = State.ObjectValue;
	1107	},
	1108	else => {
	1109	unreachable;
	1110	},
	1111	},
	1112	State.ObjectValue => {
	1113	var object = &p.stack.items[p.stack.len - 2].Object;
	1114	var key = p.stack.items[p.stack.len - 1].String;
	1115
	1116	switch (token.id) {
	1117	Token.Id.ObjectBegin => {
	1118	try p.stack.append(Value { .Object = ObjectMap.init(allocator) });
	1119	p.state = State.ObjectKey;
	1120	},
	1121	Token.Id.ArrayBegin => {
	1122	try p.stack.append(Value { .Array = ArrayList(Value).init(allocator) });
	1123	p.state = State.ArrayValue;
	1124	},
	1125	Token.Id.String => {
	1126	_ = try object.put(key, try p.parseString(allocator, token, input, i));
	1127	_ = p.stack.pop();
	1128	p.state = State.ObjectKey;
	1129	},
	1130	Token.Id.Number => {
	1131	_ = try object.put(key, try p.parseNumber(token, input, i));
	1132	_ = p.stack.pop();
	1133	p.state = State.ObjectKey;
	1134	},
	1135	Token.Id.True => {
	1136	_ = try object.put(key, Value { .Bool = true });
	1137	_ = p.stack.pop();
	1138	p.state = State.ObjectKey;
	1139	},
	1140	Token.Id.False => {
	1141	_ = try object.put(key, Value { .Bool = false });
	1142	_ = p.stack.pop();
	1143	p.state = State.ObjectKey;
	1144	},
	1145	Token.Id.Null => {
	1146	_ = try object.put(key, Value.Null);
	1147	_ = p.stack.pop();
	1148	p.state = State.ObjectKey;
	1149	},
	1150	else => {
	1151	unreachable;
	1152	},
	1153	}
	1154	},
	1155	State.ArrayValue => {
	1156	var array = &p.stack.items[p.stack.len - 1].Array;
	1157
	1158	switch (token.id) {
	1159	Token.Id.ArrayEnd => {
	1160	if (p.stack.len == 1) {
	1161	return;
	1162	}
	1163
	1164	var value = p.stack.pop();
	1165	try p.pushToParent(value);
	1166	},
	1167	Token.Id.ObjectBegin => {
	1168	try p.stack.append(Value { .Object = ObjectMap.init(allocator) });
	1169	p.state = State.ObjectKey;
	1170	},
	1171	Token.Id.ArrayBegin => {
	1172	try p.stack.append(Value { .Array = ArrayList(Value).init(allocator) });
	1173	p.state = State.ArrayValue;
	1174	},
	1175	Token.Id.String => {
	1176	try array.append(try p.parseString(allocator, token, input, i));
	1177	},
	1178	Token.Id.Number => {
	1179	try array.append(try p.parseNumber(token, input, i));
	1180	},
	1181	Token.Id.True => {
	1182	try array.append(Value { .Bool = true });
	1183	},
	1184	Token.Id.False => {
	1185	try array.append(Value { .Bool = false });
	1186	},
	1187	Token.Id.Null => {
	1188	try array.append(Value.Null);
	1189	},
	1190	else => {
	1191	unreachable;
	1192	},
	1193	}
	1194	},
	1195	State.Simple => switch (token.id) {
	1196	Token.Id.ObjectBegin => {
	1197	try p.stack.append(Value { .Object = ObjectMap.init(allocator) });
	1198	p.state = State.ObjectKey;
	1199	},
	1200	Token.Id.ArrayBegin => {
	1201	try p.stack.append(Value { .Array = ArrayList(Value).init(allocator) });
	1202	p.state = State.ArrayValue;
	1203	},
	1204	Token.Id.String => {
	1205	try p.stack.append(try p.parseString(allocator, token, input, i));
	1206	},
	1207	Token.Id.Number => {
	1208	try p.stack.append(try p.parseNumber(token, input, i));
	1209	},
	1210	Token.Id.True => {
	1211	try p.stack.append(Value { .Bool = true });
	1212	},
	1213	Token.Id.False => {
	1214	try p.stack.append(Value { .Bool = false });
	1215	},
	1216	Token.Id.Null => {
	1217	try p.stack.append(Value.Null);
	1218	},
	1219	Token.Id.ObjectEnd, Token.Id.ArrayEnd => {
	1220	unreachable;
	1221	},
	1222	},
	1223	}
	1224	}
	1225
	1226	fn pushToParent(p: &JsonParser, value: &const Value) !void {
	1227	switch (p.stack.at(p.stack.len - 1)) {
	1228	// Object Parent -> [ ..., object, <key>, value ]
	1229	Value.String => \|key\| {
	1230	_ = p.stack.pop();
	1231
	1232	var object = &p.stack.items[p.stack.len - 1].Object;
	1233	_ = try object.put(key, value);
	1234	p.state = State.ObjectKey;
	1235	},
	1236	// Array Parent -> [ ..., <array>, value ]
	1237	Value.Array => \|*array\| {
	1238	try array.append(value);
	1239	p.state = State.ArrayValue;
	1240	},
	1241	else => {
	1242	unreachable;
	1243	},
	1244	}
	1245	}
	1246
	1247	fn parseString(p: &JsonParser, allocator: &Allocator, token: &const Token, input: []const u8, i: usize) !Value {
	1248	// TODO: We don't strictly have to copy values which do not contain any escape
	1249	// characters if flagged with the option.
	1250	const slice = token.slice(input, i);
	1251	return Value { .String = try mem.dupe(p.allocator, u8, slice) };
	1252	}
	1253
	1254	fn parseNumber(p: &JsonParser, token: &const Token, input: []const u8, i: usize) !Value {
	1255	return if (token.number_is_integer)
	1256	Value { .Integer = try std.fmt.parseInt(i64, token.slice(input, i), 10) }
	1257	else
	1258	@panic("TODO: fmt.parseFloat not yet implemented")
	1259	;
	1260	}
	1261	};
	1262
	1263	const debug = std.debug;
	1264
	1265	test "json parser dynamic" {
	1266	var p = JsonParser.init(std.debug.global_allocator, false);
	1267	defer p.deinit();
	1268
	1269	const s =
	1270	\\{
	1271	\\ "Image": {
	1272	\\ "Width": 800,
	1273	\\ "Height": 600,
	1274	\\ "Title": "View from 15th Floor",
	1275	\\ "Thumbnail": {
	1276	\\ "Url": "http://www.example.com/image/481989943",
	1277	\\ "Height": 125,
	1278	\\ "Width": 100
	1279	\\ },
	1280	\\ "Animated" : false,
	1281	\\ "IDs": [116, 943, 234, 38793]
	1282	\\ }
	1283	\\}
	1284	;
	1285
	1286	var tree = try p.parse(s);
	1287	defer tree.deinit();
	1288
	1289	var root = tree.root;
	1290
	1291	var image = (??root.Object.get("Image")).value;
	1292
	1293	const width = (??image.Object.get("Width")).value;
	1294	debug.assert(width.Integer == 800);
	1295
	1296	const height = (??image.Object.get("Height")).value;
	1297	debug.assert(height.Integer == 600);
	1298
	1299	const title = (??image.Object.get("Title")).value;
	1300	debug.assert(mem.eql(u8, title.String, "View from 15th Floor"));
	1301
	1302	const animated = (??image.Object.get("Animated")).value;
	1303	debug.assert(animated.Bool == false);
	1304	}

std/json_test.zig created+1942

...	...	@@ -0,0 +1,1942 @@
	1	// RFC 8529 conformance tests.
	2	//
	3	// Tests are taken from https://github.com/nst/JSONTestSuite
	4	// Read also http://seriot.ch/parsing_json.php for a good overview.
	5
	6	const std = @import("index.zig");
	7
	8	fn ok(comptime s: []const u8) void {
	9	std.debug.assert(std.json.validate(s));
	10	}
	11
	12	fn err(comptime s: []const u8) void {
	13	std.debug.assert(!std.json.validate(s));
	14	}
	15
	16	fn any(comptime s: []const u8) void {
	17	std.debug.assert(true);
	18	}
	19
	20	////////////////////////////////////////////////////////////////////////////////////////////////////
	21
	22	test "y_array_arraysWithSpaces" {
	23	ok(
	24	\\[[] ]
	25	);
	26	}
	27
	28	test "y_array_empty" {
	29	ok(
	30	\\[]
	31	);
	32	}
	33
	34	test "y_array_empty-string" {
	35	ok(
	36	\\[""]
	37	);
	38	}
	39
	40	test "y_array_ending_with_newline" {
	41	ok(
	42	\\["a"]
	43	);
	44	}
	45
	46	test "y_array_false" {
	47	ok(
	48	\\[false]
	49	);
	50	}
	51
	52	test "y_array_heterogeneous" {
	53	ok(
	54	\\[null, 1, "1", {}]
	55	);
	56	}
	57
	58	test "y_array_null" {
	59	ok(
	60	\\[null]
	61	);
	62	}
	63
	64	test "y_array_with_1_and_newline" {
	65	ok(
	66	\\[1
	67	\\]
	68	);
	69	}
	70
	71	test "y_array_with_leading_space" {
	72	ok(
	73	\\ [1]
	74	);
	75	}
	76
	77	test "y_array_with_several_null" {
	78	ok(
	79	\\[1,null,null,null,2]
	80	);
	81	}
	82
	83	test "y_array_with_trailing_space" {
	84	ok(
	85	"[2] "
	86	);
	87	}
	88
	89	test "y_number_0e+1" {
	90	ok(
	91	\\[0e+1]
	92	);
	93	}
	94
	95	test "y_number_0e1" {
	96	ok(
	97	\\[0e1]
	98	);
	99	}
	100
	101	test "y_number_after_space" {
	102	ok(
	103	\\[ 4]
	104	);
	105	}
	106
	107	test "y_number_double_close_to_zero" {
	108	ok(
	109	\\[-0.000000000000000000000000000000000000000000000000000000000000000000000000000001]
	110	);
	111	}
	112
	113	test "y_number_int_with_exp" {
	114	ok(
	115	\\[20e1]
	116	);
	117	}
	118
	119	test "y_number" {
	120	ok(
	121	\\[123e65]
	122	);
	123	}
	124
	125	test "y_number_minus_zero" {
	126	ok(
	127	\\[-0]
	128	);
	129	}
	130
	131	test "y_number_negative_int" {
	132	ok(
	133	\\[-123]
	134	);
	135	}
	136
	137	test "y_number_negative_one" {
	138	ok(
	139	\\[-1]
	140	);
	141	}
	142
	143	test "y_number_negative_zero" {
	144	ok(
	145	\\[-0]
	146	);
	147	}
	148
	149	test "y_number_real_capital_e" {
	150	ok(
	151	\\[1E22]
	152	);
	153	}
	154
	155	test "y_number_real_capital_e_neg_exp" {
	156	ok(
	157	\\[1E-2]
	158	);
	159	}
	160
	161	test "y_number_real_capital_e_pos_exp" {
	162	ok(
	163	\\[1E+2]
	164	);
	165	}
	166
	167	test "y_number_real_exponent" {
	168	ok(
	169	\\[123e45]
	170	);
	171	}
	172
	173	test "y_number_real_fraction_exponent" {
	174	ok(
	175	\\[123.456e78]
	176	);
	177	}
	178
	179	test "y_number_real_neg_exp" {
	180	ok(
	181	\\[1e-2]
	182	);
	183	}
	184
	185	test "y_number_real_pos_exponent" {
	186	ok(
	187	\\[1e+2]
	188	);
	189	}
	190
	191	test "y_number_simple_int" {
	192	ok(
	193	\\[123]
	194	);
	195	}
	196
	197	test "y_number_simple_real" {
	198	ok(
	199	\\[123.456789]
	200	);
	201	}
	202
	203	test "y_object_basic" {
	204	ok(
	205	\\{"asd":"sdf"}
	206	);
	207	}
	208
	209	test "y_object_duplicated_key_and_value" {
	210	ok(
	211	\\{"a":"b","a":"b"}
	212	);
	213	}
	214
	215	test "y_object_duplicated_key" {
	216	ok(
	217	\\{"a":"b","a":"c"}
	218	);
	219	}
	220
	221	test "y_object_empty" {
	222	ok(
	223	\\{}
	224	);
	225	}
	226
	227	test "y_object_empty_key" {
	228	ok(
	229	\\{"":0}
	230	);
	231	}
	232
	233	test "y_object_escaped_null_in_key" {
	234	ok(
	235	\\{"foo\u0000bar": 42}
	236	);
	237	}
	238
	239	test "y_object_extreme_numbers" {
	240	ok(
	241	\\{ "min": -1.0e+28, "max": 1.0e+28 }
	242	);
	243	}
	244
	245	test "y_object" {
	246	ok(
	247	\\{"asd":"sdf", "dfg":"fgh"}
	248	);
	249	}
	250
	251	test "y_object_long_strings" {
	252	ok(
	253	\\{"x":[{"id": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"}], "id": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"}
	254	);
	255	}
	256
	257	test "y_object_simple" {
	258	ok(
	259	\\{"a":[]}
	260	);
	261	}
	262
	263	test "y_object_string_unicode" {
	264	ok(
	265	\\{"title":"\u041f\u043e\u043b\u0442\u043e\u0440\u0430 \u0417\u0435\u043c\u043b\u0435\u043a\u043e\u043f\u0430" }
	266	);
	267	}
	268
	269	test "y_object_with_newlines" {
	270	ok(
	271	\\{
	272	\\"a": "b"
	273	\\}
	274	);
	275	}
	276
	277	test "y_string_1_2_3_bytes_UTF-8_sequences" {
	278	ok(
	279	\\["\u0060\u012a\u12AB"]
	280	);
	281	}
	282
	283	test "y_string_accepted_surrogate_pair" {
	284	ok(
	285	\\["\uD801\udc37"]
	286	);
	287	}
	288
	289	test "y_string_accepted_surrogate_pairs" {
	290	ok(
	291	\\["\ud83d\ude39\ud83d\udc8d"]
	292	);
	293	}
	294
	295	test "y_string_allowed_escapes" {
	296	ok(
	297	\\["\"\\\/\b\f\n\r\t"]
	298	);
	299	}
	300
	301	test "y_string_backslash_and_u_escaped_zero" {
	302	ok(
	303	\\["\\u0000"]
	304	);
	305	}
	306
	307	test "y_string_backslash_doublequotes" {
	308	ok(
	309	\\["\""]
	310	);
	311	}
	312
	313	test "y_string_comments" {
	314	ok(
	315	\\["a/b/c/*d//e"]
	316	);
	317	}
	318
	319	test "y_string_double_escape_a" {
	320	ok(
	321	\\["\\a"]
	322	);
	323	}
	324
	325	test "y_string_double_escape_n" {
	326	ok(
	327	\\["\\n"]
	328	);
	329	}
	330
	331	test "y_string_escaped_control_character" {
	332	ok(
	333	\\["\u0012"]
	334	);
	335	}
	336
	337	test "y_string_escaped_noncharacter" {
	338	ok(
	339	\\["\uFFFF"]
	340	);
	341	}
	342
	343	test "y_string_in_array" {
	344	ok(
	345	\\["asd"]
	346	);
	347	}
	348
	349	test "y_string_in_array_with_leading_space" {
	350	ok(
	351	\\[ "asd"]
	352	);
	353	}
	354
	355	test "y_string_last_surrogates_1_and_2" {
	356	ok(
	357	\\["\uDBFF\uDFFF"]
	358	);
	359	}
	360
	361	test "y_string_nbsp_uescaped" {
	362	ok(
	363	\\["new\u00A0line"]
	364	);
	365	}
	366
	367	test "y_string_nonCharacterInUTF-8_U+10FFFF" {
	368	ok(
	369	\\["􏿿"]
	370	);
	371	}
	372
	373	test "y_string_nonCharacterInUTF-8_U+FFFF" {
	374	ok(
	375	\\[""]
	376	);
	377	}
	378
	379	test "y_string_null_escape" {
	380	ok(
	381	\\["\u0000"]
	382	);
	383	}
	384
	385	test "y_string_one-byte-utf-8" {
	386	ok(
	387	\\["\u002c"]
	388	);
	389	}
	390
	391	test "y_string_pi" {
	392	ok(
	393	\\["π"]
	394	);
	395	}
	396
	397	test "y_string_reservedCharacterInUTF-8_U+1BFFF" {
	398	ok(
	399	\\["𛿿"]
	400	);
	401	}
	402
	403	test "y_string_simple_ascii" {
	404	ok(
	405	\\["asd "]
	406	);
	407	}
	408
	409	test "y_string_space" {
	410	ok(
	411	\\" "
	412	);
	413	}
	414
	415	test "y_string_surrogates_U+1D11E_MUSICAL_SYMBOL_G_CLEF" {
	416	ok(
	417	\\["\uD834\uDd1e"]
	418	);
	419	}
	420
	421	test "y_string_three-byte-utf-8" {
	422	ok(
	423	\\["\u0821"]
	424	);
	425	}
	426
	427	test "y_string_two-byte-utf-8" {
	428	ok(
	429	\\["\u0123"]
	430	);
	431	}
	432
	433	test "y_string_u+2028_line_sep" {
	434	ok(
	435	\\[" "]
	436	);
	437	}
	438
	439	test "y_string_u+2029_par_sep" {
	440	ok(
	441	\\[" "]
	442	);
	443	}
	444
	445	test "y_string_uescaped_newline" {
	446	ok(
	447	\\["new\u000Aline"]
	448	);
	449	}
	450
	451	test "y_string_uEscape" {
	452	ok(
	453	\\["\u0061\u30af\u30EA\u30b9"]
	454	);
	455	}
	456
	457	test "y_string_unescaped_char_delete" {
	458	ok(
	459	\\[""]
	460	);
	461	}
	462
	463	test "y_string_unicode_2" {
	464	ok(
	465	\\["⍂㈴⍂"]
	466	);
	467	}
	468
	469	test "y_string_unicodeEscapedBackslash" {
	470	ok(
	471	\\["\u005C"]
	472	);
	473	}
	474
	475	test "y_string_unicode_escaped_double_quote" {
	476	ok(
	477	\\["\u0022"]
	478	);
	479	}
	480
	481	test "y_string_unicode" {
	482	ok(
	483	\\["\uA66D"]
	484	);
	485	}
	486
	487	test "y_string_unicode_U+10FFFE_nonchar" {
	488	ok(
	489	\\["\uDBFF\uDFFE"]
	490	);
	491	}
	492
	493	test "y_string_unicode_U+1FFFE_nonchar" {
	494	ok(
	495	\\["\uD83F\uDFFE"]
	496	);
	497	}
	498
	499	test "y_string_unicode_U+200B_ZERO_WIDTH_SPACE" {
	500	ok(
	501	\\["\u200B"]
	502	);
	503	}
	504
	505	test "y_string_unicode_U+2064_invisible_plus" {
	506	ok(
	507	\\["\u2064"]
	508	);
	509	}
	510
	511	test "y_string_unicode_U+FDD0_nonchar" {
	512	ok(
	513	\\["\uFDD0"]
	514	);
	515	}
	516
	517	test "y_string_unicode_U+FFFE_nonchar" {
	518	ok(
	519	\\["\uFFFE"]
	520	);
	521	}
	522
	523	test "y_string_utf8" {
	524	ok(
	525	\\["€𝄞"]
	526	);
	527	}
	528
	529	test "y_string_with_del_character" {
	530	ok(
	531	\\["aa"]
	532	);
	533	}
	534
	535	test "y_structure_lonely_false" {
	536	ok(
	537	\\false
	538	);
	539	}
	540
	541	test "y_structure_lonely_int" {
	542	ok(
	543	\\42
	544	);
	545	}
	546
	547	test "y_structure_lonely_negative_real" {
	548	ok(
	549	\\-0.1
	550	);
	551	}
	552
	553	test "y_structure_lonely_null" {
	554	ok(
	555	\\null
	556	);
	557	}
	558
	559	test "y_structure_lonely_string" {
	560	ok(
	561	\\"asd"
	562	);
	563	}
	564
	565	test "y_structure_lonely_true" {
	566	ok(
	567	\\true
	568	);
	569	}
	570
	571	test "y_structure_string_empty" {
	572	ok(
	573	\\""
	574	);
	575	}
	576
	577	test "y_structure_trailing_newline" {
	578	ok(
	579	\\["a"]
	580	);
	581	}
	582
	583	test "y_structure_true_in_array" {
	584	ok(
	585	\\[true]
	586	);
	587	}
	588
	589	test "y_structure_whitespace_array" {
	590	ok(
	591	" [] "
	592	);
	593	}
	594
	595	////////////////////////////////////////////////////////////////////////////////////////////////////
	596
	597	test "n_array_1_true_without_comma" {
	598	err(
	599	\\[1 true]
	600	);
	601	}
	602
	603	test "n_array_a_invalid_utf8" {
	604	err(
	605	\\[aå]
	606	);
	607	}
	608
	609	test "n_array_colon_instead_of_comma" {
	610	err(
	611	\\["": 1]
	612	);
	613	}
	614
	615	test "n_array_comma_after_close" {
	616	//err(
	617	// \\[""],
	618	//);
	619	}
	620
	621	test "n_array_comma_and_number" {
	622	err(
	623	\\[,1]
	624	);
	625	}
	626
	627	test "n_array_double_comma" {
	628	err(
	629	\\[1,,2]
	630	);
	631	}
	632
	633	test "n_array_double_extra_comma" {
	634	err(
	635	\\["x",,]
	636	);
	637	}
	638
	639	test "n_array_extra_close" {
	640	err(
	641	\\["x"]]
	642	);
	643	}
	644
	645	test "n_array_extra_comma" {
	646	//err(
	647	// \\["",]
	648	//);
	649	}
	650
	651	test "n_array_incomplete_invalid_value" {
	652	err(
	653	\\[x
	654	);
	655	}
	656
	657	test "n_array_incomplete" {
	658	err(
	659	\\["x"
	660	);
	661	}
	662
	663	test "n_array_inner_array_no_comma" {
	664	err(
	665	\\[3[4]]
	666	);
	667	}
	668
	669	test "n_array_invalid_utf8" {
	670	err(
	671	\\[ÿ]
	672	);
	673	}
	674
	675	test "n_array_items_separated_by_semicolon" {
	676	err(
	677	\\[1:2]
	678	);
	679	}
	680
	681	test "n_array_just_comma" {
	682	err(
	683	\\[,]
	684	);
	685	}
	686
	687	test "n_array_just_minus" {
	688	err(
	689	\\[-]
	690	);
	691	}
	692
	693	test "n_array_missing_value" {
	694	err(
	695	\\[ , ""]
	696	);
	697	}
	698
	699	test "n_array_newlines_unclosed" {
	700	err(
	701	\\["a",
	702	\\4
	703	\\,1,
	704	);
	705	}
	706
	707
	708	test "n_array_number_and_comma" {
	709	err(
	710	\\[1,]
	711	);
	712	}
	713
	714	test "n_array_number_and_several_commas" {
	715	err(
	716	\\[1,,]
	717	);
	718	}
	719
	720	test "n_array_spaces_vertical_tab_formfeed" {
	721	err(
	722	\\["a"\f]
	723	);
	724	}
	725
	726	test "n_array_star_inside" {
	727	err(
	728	\\[*]
	729	);
	730	}
	731
	732	test "n_array_unclosed" {
	733	err(
	734	\\[""
	735	);
	736	}
	737
	738	test "n_array_unclosed_trailing_comma" {
	739	err(
	740	\\[1,
	741	);
	742	}
	743
	744	test "n_array_unclosed_with_new_lines" {
	745	err(
	746	\\[1,
	747	\\1
	748	\\,1
	749	);
	750	}
	751
	752	test "n_array_unclosed_with_object_inside" {
	753	err(
	754	\\[{}
	755	);
	756	}
	757
	758	test "n_incomplete_false" {
	759	err(
	760	\\[fals]
	761	);
	762	}
	763
	764	test "n_incomplete_null" {
	765	err(
	766	\\[nul]
	767	);
	768	}
	769
	770	test "n_incomplete_true" {
	771	err(
	772	\\[tru]
	773	);
	774	}
	775
	776	test "n_multidigit_number_then_00" {
	777	err(
	778	\\123
	779	);
	780	}
	781
	782	test "n_number_0.1.2" {
	783	err(
	784	\\[0.1.2]
	785	);
	786	}
	787
	788	test "n_number_-01" {
	789	err(
	790	\\[-01]
	791	);
	792	}
	793
	794	test "n_number_0.3e" {
	795	err(
	796	\\[0.3e]
	797	);
	798	}
	799
	800	test "n_number_0.3e+" {
	801	err(
	802	\\[0.3e+]
	803	);
	804	}
	805
	806	test "n_number_0_capital_E" {
	807	err(
	808	\\[0E]
	809	);
	810	}
	811
	812	test "n_number_0_capital_E+" {
	813	err(
	814	\\[0E+]
	815	);
	816	}
	817
	818	test "n_number_0.e1" {
	819	err(
	820	\\[0.e1]
	821	);
	822	}
	823
	824	test "n_number_0e" {
	825	err(
	826	\\[0e]
	827	);
	828	}
	829
	830	test "n_number_0e+" {
	831	err(
	832	\\[0e+]
	833	);
	834	}
	835
	836	test "n_number_1_000" {
	837	err(
	838	\\[1 000.0]
	839	);
	840	}
	841
	842	test "n_number_1.0e-" {
	843	err(
	844	\\[1.0e-]
	845	);
	846	}
	847
	848	test "n_number_1.0e" {
	849	err(
	850	\\[1.0e]
	851	);
	852	}
	853
	854	test "n_number_1.0e+" {
	855	err(
	856	\\[1.0e+]
	857	);
	858	}
	859
	860	test "n_number_-1.0." {
	861	err(
	862	\\[-1.0.]
	863	);
	864	}
	865
	866	test "n_number_1eE2" {
	867	err(
	868	\\[1eE2]
	869	);
	870	}
	871
	872	test "n_number_.-1" {
	873	err(
	874	\\[.-1]
	875	);
	876	}
	877
	878	test "n_number_+1" {
	879	err(
	880	\\[+1]
	881	);
	882	}
	883
	884	test "n_number_.2e-3" {
	885	err(
	886	\\[.2e-3]
	887	);
	888	}
	889
	890	test "n_number_2.e-3" {
	891	err(
	892	\\[2.e-3]
	893	);
	894	}
	895
	896	test "n_number_2.e+3" {
	897	err(
	898	\\[2.e+3]
	899	);
	900	}
	901
	902	test "n_number_2.e3" {
	903	err(
	904	\\[2.e3]
	905	);
	906	}
	907
	908	test "n_number_-2." {
	909	err(
	910	\\[-2.]
	911	);
	912	}
	913
	914	test "n_number_9.e+" {
	915	err(
	916	\\[9.e+]
	917	);
	918	}
	919
	920	test "n_number_expression" {
	921	err(
	922	\\[1+2]
	923	);
	924	}
	925
	926	test "n_number_hex_1_digit" {
	927	err(
	928	\\[0x1]
	929	);
	930	}
	931
	932	test "n_number_hex_2_digits" {
	933	err(
	934	\\[0x42]
	935	);
	936	}
	937
	938	test "n_number_infinity" {
	939	err(
	940	\\[Infinity]
	941	);
	942	}
	943
	944	test "n_number_+Inf" {
	945	err(
	946	\\[+Inf]
	947	);
	948	}
	949
	950	test "n_number_Inf" {
	951	err(
	952	\\[Inf]
	953	);
	954	}
	955
	956	test "n_number_invalid+-" {
	957	err(
	958	\\[0e+-1]
	959	);
	960	}
	961
	962	test "n_number_invalid-negative-real" {
	963	err(
	964	\\[-123.123foo]
	965	);
	966	}
	967
	968	test "n_number_invalid-utf-8-in-bigger-int" {
	969	err(
	970	\\[123å]
	971	);
	972	}
	973
	974	test "n_number_invalid-utf-8-in-exponent" {
	975	err(
	976	\\[1e1å]
	977	);
	978	}
	979
	980	test "n_number_invalid-utf-8-in-int" {
	981	err(
	982	\\[0å]
	983	);
	984	}
	985
	986
	987	test "n_number_++" {
	988	err(
	989	\\[++1234]
	990	);
	991	}
	992
	993	test "n_number_minus_infinity" {
	994	err(
	995	\\[-Infinity]
	996	);
	997	}
	998
	999	test "n_number_minus_sign_with_trailing_garbage" {
	1000	err(
	1001	\\[-foo]
	1002	);
	1003	}
	1004
	1005	test "n_number_minus_space_1" {
	1006	err(
	1007	\\[- 1]
	1008	);
	1009	}
	1010
	1011	test "n_number_-NaN" {
	1012	err(
	1013	\\[-NaN]
	1014	);
	1015	}
	1016
	1017	test "n_number_NaN" {
	1018	err(
	1019	\\[NaN]
	1020	);
	1021	}
	1022
	1023	test "n_number_neg_int_starting_with_zero" {
	1024	err(
	1025	\\[-012]
	1026	);
	1027	}
	1028
	1029	test "n_number_neg_real_without_int_part" {
	1030	err(
	1031	\\[-.123]
	1032	);
	1033	}
	1034
	1035	test "n_number_neg_with_garbage_at_end" {
	1036	err(
	1037	\\[-1x]
	1038	);
	1039	}
	1040
	1041	test "n_number_real_garbage_after_e" {
	1042	err(
	1043	\\[1ea]
	1044	);
	1045	}
	1046
	1047	test "n_number_real_with_invalid_utf8_after_e" {
	1048	err(
	1049	\\[1eå]
	1050	);
	1051	}
	1052
	1053	test "n_number_real_without_fractional_part" {
	1054	err(
	1055	\\[1.]
	1056	);
	1057	}
	1058
	1059	test "n_number_starting_with_dot" {
	1060	err(
	1061	\\[.123]
	1062	);
	1063	}
	1064
	1065	test "n_number_U+FF11_fullwidth_digit_one" {
	1066	err(
	1067	\\[ï¼]
	1068	);
	1069	}
	1070
	1071	test "n_number_with_alpha_char" {
	1072	err(
	1073	\\[1.8011670033376514H-308]
	1074	);
	1075	}
	1076
	1077	test "n_number_with_alpha" {
	1078	err(
	1079	\\[1.2a-3]
	1080	);
	1081	}
	1082
	1083	test "n_number_with_leading_zero" {
	1084	err(
	1085	\\[012]
	1086	);
	1087	}
	1088
	1089	test "n_object_bad_value" {
	1090	err(
	1091	\\["x", truth]
	1092	);
	1093	}
	1094
	1095	test "n_object_bracket_key" {
	1096	err(
	1097	\\{[: "x"}
	1098	);
	1099	}
	1100
	1101	test "n_object_comma_instead_of_colon" {
	1102	err(
	1103	\\{"x", null}
	1104	);
	1105	}
	1106
	1107	test "n_object_double_colon" {
	1108	err(
	1109	\\{"x"::"b"}
	1110	);
	1111	}
	1112
	1113	test "n_object_emoji" {
	1114	err(
	1115	\\{ð¨ð}
	1116	);
	1117	}
	1118
	1119	test "n_object_garbage_at_end" {
	1120	err(
	1121	\\{"a":"a" 123}
	1122	);
	1123	}
	1124
	1125	test "n_object_key_with_single_quotes" {
	1126	err(
	1127	\\{key: 'value'}
	1128	);
	1129	}
	1130
	1131	test "n_object_lone_continuation_byte_in_key_and_trailing_comma" {
	1132	err(
	1133	\\{"¹":"0",}
	1134	);
	1135	}
	1136
	1137	test "n_object_missing_colon" {
	1138	err(
	1139	\\{"a" b}
	1140	);
	1141	}
	1142
	1143	test "n_object_missing_key" {
	1144	err(
	1145	\\{:"b"}
	1146	);
	1147	}
	1148
	1149	test "n_object_missing_semicolon" {
	1150	err(
	1151	\\{"a" "b"}
	1152	);
	1153	}
	1154
	1155	test "n_object_missing_value" {
	1156	err(
	1157	\\{"a":
	1158	);
	1159	}
	1160
	1161	test "n_object_no-colon" {
	1162	err(
	1163	\\{"a"
	1164	);
	1165	}
	1166
	1167	test "n_object_non_string_key_but_huge_number_instead" {
	1168	err(
	1169	\\{9999E9999:1}
	1170	);
	1171	}
	1172
	1173	test "n_object_non_string_key" {
	1174	err(
	1175	\\{1:1}
	1176	);
	1177	}
	1178
	1179	test "n_object_repeated_null_null" {
	1180	err(
	1181	\\{null:null,null:null}
	1182	);
	1183	}
	1184
	1185	test "n_object_several_trailing_commas" {
	1186	err(
	1187	\\{"id":0,,,,,}
	1188	);
	1189	}
	1190
	1191	test "n_object_single_quote" {
	1192	err(
	1193	\\{'a':0}
	1194	);
	1195	}
	1196
	1197	test "n_object_trailing_comma" {
	1198	err(
	1199	\\{"id":0,}
	1200	);
	1201	}
	1202
	1203	test "n_object_trailing_comment" {
	1204	err(
	1205	\\{"a":"b"}/**/
	1206	);
	1207	}
	1208
	1209	test "n_object_trailing_comment_open" {
	1210	err(
	1211	\\{"a":"b"}/**//
	1212	);
	1213	}
	1214
	1215	test "n_object_trailing_comment_slash_open_incomplete" {
	1216	err(
	1217	\\{"a":"b"}/
	1218	);
	1219	}
	1220
	1221	test "n_object_trailing_comment_slash_open" {
	1222	err(
	1223	\\{"a":"b"}//
	1224	);
	1225	}
	1226
	1227	test "n_object_two_commas_in_a_row" {
	1228	err(
	1229	\\{"a":"b",,"c":"d"}
	1230	);
	1231	}
	1232
	1233	test "n_object_unquoted_key" {
	1234	err(
	1235	\\{a: "b"}
	1236	);
	1237	}
	1238
	1239	test "n_object_unterminated-value" {
	1240	err(
	1241	\\{"a":"a
	1242	);
	1243	}
	1244
	1245	test "n_object_with_single_string" {
	1246	err(
	1247	\\{ "foo" : "bar", "a" }
	1248	);
	1249	}
	1250
	1251	test "n_object_with_trailing_garbage" {
	1252	err(
	1253	\\{"a":"b"}#
	1254	);
	1255	}
	1256
	1257	test "n_single_space" {
	1258	err(
	1259	" "
	1260	);
	1261	}
	1262
	1263	test "n_string_1_surrogate_then_escape" {
	1264	err(
	1265	\\["\uD800\"]
	1266	);
	1267	}
	1268
	1269	test "n_string_1_surrogate_then_escape_u1" {
	1270	err(
	1271	\\["\uD800\u1"]
	1272	);
	1273	}
	1274
	1275	test "n_string_1_surrogate_then_escape_u1x" {
	1276	err(
	1277	\\["\uD800\u1x"]
	1278	);
	1279	}
	1280
	1281	test "n_string_1_surrogate_then_escape_u" {
	1282	err(
	1283	\\["\uD800\u"]
	1284	);
	1285	}
	1286
	1287	test "n_string_accentuated_char_no_quotes" {
	1288	err(
	1289	\\[Ã©]
	1290	);
	1291	}
	1292
	1293	test "n_string_backslash_00" {
	1294	err(
	1295	\\["\"]
	1296	);
	1297	}
	1298
	1299	test "n_string_escaped_backslash_bad" {
	1300	err(
	1301	\\["\\\"]
	1302	);
	1303	}
	1304
	1305	test "n_string_escaped_ctrl_char_tab" {
	1306	err(
	1307	\\["\ "]
	1308	);
	1309	}
	1310
	1311	test "n_string_escaped_emoji" {
	1312	err(
	1313	\\["\ð"]
	1314	);
	1315	}
	1316
	1317	test "n_string_escape_x" {
	1318	err(
	1319	\\["\x00"]
	1320	);
	1321	}
	1322
	1323	test "n_string_incomplete_escaped_character" {
	1324	err(
	1325	\\["\u00A"]
	1326	);
	1327	}
	1328
	1329	test "n_string_incomplete_escape" {
	1330	err(
	1331	\\["\"]
	1332	);
	1333	}
	1334
	1335	test "n_string_incomplete_surrogate_escape_invalid" {
	1336	err(
	1337	\\["\uD800\uD800\x"]
	1338	);
	1339	}
	1340
	1341	test "n_string_incomplete_surrogate" {
	1342	err(
	1343	\\["\uD834\uDd"]
	1344	);
	1345	}
	1346
	1347	test "n_string_invalid_backslash_esc" {
	1348	err(
	1349	\\["\a"]
	1350	);
	1351	}
	1352
	1353	test "n_string_invalid_unicode_escape" {
	1354	err(
	1355	\\["\uqqqq"]
	1356	);
	1357	}
	1358
	1359	test "n_string_invalid_utf8_after_escape" {
	1360	err(
	1361	\\["\å"]
	1362	);
	1363	}
	1364
	1365	test "n_string_invalid-utf-8-in-escape" {
	1366	err(
	1367	\\["\uå"]
	1368	);
	1369	}
	1370
	1371	test "n_string_leading_uescaped_thinspace" {
	1372	err(
	1373	\\[\u0020"asd"]
	1374	);
	1375	}
	1376
	1377	test "n_string_no_quotes_with_bad_escape" {
	1378	err(
	1379	\\[\n]
	1380	);
	1381	}
	1382
	1383	test "n_string_single_doublequote" {
	1384	err(
	1385	\\"
	1386	);
	1387	}
	1388
	1389	test "n_string_single_quote" {
	1390	err(
	1391	\\['single quote']
	1392	);
	1393	}
	1394
	1395	test "n_string_single_string_no_double_quotes" {
	1396	err(
	1397	\\abc
	1398	);
	1399	}
	1400
	1401	test "n_string_start_escape_unclosed" {
	1402	err(
	1403	\\["\
	1404	);
	1405	}
	1406
	1407	test "n_string_unescaped_crtl_char" {
	1408	err(
	1409	\\["aa"]
	1410	);
	1411	}
	1412
	1413	test "n_string_unescaped_newline" {
	1414	err(
	1415	\\["new
	1416	\\line"]
	1417	);
	1418	}
	1419
	1420	test "n_string_unescaped_tab" {
	1421	err(
	1422	\\[" "]
	1423	);
	1424	}
	1425
	1426	test "n_string_unicode_CapitalU" {
	1427	err(
	1428	\\"\UA66D"
	1429	);
	1430	}
	1431
	1432	test "n_string_with_trailing_garbage" {
	1433	err(
	1434	\\""x
	1435	);
	1436	}
	1437
	1438	test "n_structure_100000_opening_arrays" {
	1439	err(
	1440	"[" ** 100000
	1441	);
	1442	}
	1443
	1444	test "n_structure_angle_bracket_." {
	1445	err(
	1446	\\<.>
	1447	);
	1448	}
	1449
	1450	test "n_structure_angle_bracket_null" {
	1451	err(
	1452	\\[<null>]
	1453	);
	1454	}
	1455
	1456	test "n_structure_array_trailing_garbage" {
	1457	err(
	1458	\\[1]x
	1459	);
	1460	}
	1461
	1462	test "n_structure_array_with_extra_array_close" {
	1463	err(
	1464	\\[1]]
	1465	);
	1466	}
	1467
	1468	test "n_structure_array_with_unclosed_string" {
	1469	err(
	1470	\\["asd]
	1471	);
	1472	}
	1473
	1474	test "n_structure_ascii-unicode-identifier" {
	1475	err(
	1476	\\aÃ¥
	1477	);
	1478	}
	1479
	1480	test "n_structure_capitalized_True" {
	1481	err(
	1482	\\[True]
	1483	);
	1484	}
	1485
	1486	test "n_structure_close_unopened_array" {
	1487	err(
	1488	\\1]
	1489	);
	1490	}
	1491
	1492	test "n_structure_comma_instead_of_closing_brace" {
	1493	err(
	1494	\\{"x": true,
	1495	);
	1496	}
	1497
	1498	test "n_structure_double_array" {
	1499	err(
	1500	\\[][]
	1501	);
	1502	}
	1503
	1504	test "n_structure_end_array" {
	1505	err(
	1506	\\]
	1507	);
	1508	}
	1509
	1510	test "n_structure_incomplete_UTF8_BOM" {
	1511	err(
	1512	\\ï»{}
	1513	);
	1514	}
	1515
	1516	test "n_structure_lone-invalid-utf-8" {
	1517	err(
	1518	\\å
	1519	);
	1520	}
	1521
	1522	test "n_structure_lone-open-bracket" {
	1523	err(
	1524	\\[
	1525	);
	1526	}
	1527
	1528	test "n_structure_no_data" {
	1529	err(
	1530	\\
	1531	);
	1532	}
	1533
	1534	test "n_structure_null-byte-outside-string" {
	1535	err(
	1536	\\[]
	1537	);
	1538	}
	1539
	1540	test "n_structure_number_with_trailing_garbage" {
	1541	err(
	1542	\\2@
	1543	);
	1544	}
	1545
	1546	test "n_structure_object_followed_by_closing_object" {
	1547	err(
	1548	\\{}}
	1549	);
	1550	}
	1551
	1552	test "n_structure_object_unclosed_no_value" {
	1553	err(
	1554	\\{"":
	1555	);
	1556	}
	1557
	1558	test "n_structure_object_with_comment" {
	1559	err(
	1560	\\{"a":/comment/"b"}
	1561	);
	1562	}
	1563
	1564	test "n_structure_object_with_trailing_garbage" {
	1565	err(
	1566	\\{"a": true} "x"
	1567	);
	1568	}
	1569
	1570	test "n_structure_open_array_apostrophe" {
	1571	err(
	1572	\\['
	1573	);
	1574	}
	1575
	1576	test "n_structure_open_array_comma" {
	1577	err(
	1578	\\[,
	1579	);
	1580	}
	1581
	1582	test "n_structure_open_array_object" {
	1583	err(
	1584	"[{\"\":" ** 50000
	1585	);
	1586	}
	1587
	1588	test "n_structure_open_array_open_object" {
	1589	err(
	1590	\\[{
	1591	);
	1592	}
	1593
	1594	test "n_structure_open_array_open_string" {
	1595	err(
	1596	\\["a
	1597	);
	1598	}
	1599
	1600	test "n_structure_open_array_string" {
	1601	err(
	1602	\\["a"
	1603	);
	1604	}
	1605
	1606	test "n_structure_open_object_close_array" {
	1607	err(
	1608	\\{]
	1609	);
	1610	}
	1611
	1612	test "n_structure_open_object_comma" {
	1613	err(
	1614	\\{,
	1615	);
	1616	}
	1617
	1618	test "n_structure_open_object" {
	1619	err(
	1620	\\{
	1621	);
	1622	}
	1623
	1624	test "n_structure_open_object_open_array" {
	1625	err(
	1626	\\{[
	1627	);
	1628	}
	1629
	1630	test "n_structure_open_object_open_string" {
	1631	err(
	1632	\\{"a
	1633	);
	1634	}
	1635
	1636	test "n_structure_open_object_string_with_apostrophes" {
	1637	err(
	1638	\\{'a'
	1639	);
	1640	}
	1641
	1642	test "n_structure_open_open" {
	1643	err(
	1644	\\["\{["\{["\{["\{
	1645	);
	1646	}
	1647
	1648	test "n_structure_single_eacute" {
	1649	err(
	1650	\\é
	1651	);
	1652	}
	1653
	1654	test "n_structure_single_star" {
	1655	err(
	1656	\\*
	1657	);
	1658	}
	1659
	1660	test "n_structure_trailing_#" {
	1661	err(
	1662	\\{"a":"b"}#{}
	1663	);
	1664	}
	1665
	1666	test "n_structure_U+2060_word_joined" {
	1667	err(
	1668	\\[â ]
	1669	);
	1670	}
	1671
	1672	test "n_structure_uescaped_LF_before_string" {
	1673	err(
	1674	\\[\u000A""]
	1675	);
	1676	}
	1677
	1678	test "n_structure_unclosed_array" {
	1679	err(
	1680	\\[1
	1681	);
	1682	}
	1683
	1684	test "n_structure_unclosed_array_partial_null" {
	1685	err(
	1686	\\[ false, nul
	1687	);
	1688	}
	1689
	1690	test "n_structure_unclosed_array_unfinished_false" {
	1691	err(
	1692	\\[ true, fals
	1693	);
	1694	}
	1695
	1696	test "n_structure_unclosed_array_unfinished_true" {
	1697	err(
	1698	\\[ false, tru
	1699	);
	1700	}
	1701
	1702	test "n_structure_unclosed_object" {
	1703	err(
	1704	\\{"asd":"asd"
	1705	);
	1706	}
	1707
	1708	test "n_structure_unicode-identifier" {
	1709	err(
	1710	\\Ã¥
	1711	);
	1712	}
	1713
	1714	test "n_structure_UTF8_BOM_no_data" {
	1715	err(
	1716	\\ï»¿
	1717	);
	1718	}
	1719
	1720	test "n_structure_whitespace_formfeed" {
	1721	err(
	1722	\\[]
	1723	);
	1724	}
	1725
	1726	test "n_structure_whitespace_U+2060_word_joiner" {
	1727	err(
	1728	\\[â ]
	1729	);
	1730	}
	1731
	1732	////////////////////////////////////////////////////////////////////////////////////////////////////
	1733
	1734	test "i_number_double_huge_neg_exp" {
	1735	any(
	1736	\\[123.456e-789]
	1737	);
	1738	}
	1739
	1740	test "i_number_huge_exp" {
	1741	any(
	1742	\\[0.4e00669999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999969999999006]
	1743	);
	1744	}
	1745
	1746	test "i_number_neg_int_huge_exp" {
	1747	any(
	1748	\\[-1e+9999]
	1749	);
	1750	}
	1751
	1752	test "i_number_pos_double_huge_exp" {
	1753	any(
	1754	\\[1.5e+9999]
	1755	);
	1756	}
	1757
	1758	test "i_number_real_neg_overflow" {
	1759	any(
	1760	\\[-123123e100000]
	1761	);
	1762	}
	1763
	1764	test "i_number_real_pos_overflow" {
	1765	any(
	1766	\\[123123e100000]
	1767	);
	1768	}
	1769
	1770	test "i_number_real_underflow" {
	1771	any(
	1772	\\[123e-10000000]
	1773	);
	1774	}
	1775
	1776	test "i_number_too_big_neg_int" {
	1777	any(
	1778	\\[-123123123123123123123123123123]
	1779	);
	1780	}
	1781
	1782	test "i_number_too_big_pos_int" {
	1783	any(
	1784	\\[100000000000000000000]
	1785	);
	1786	}
	1787
	1788	test "i_number_very_big_negative_int" {
	1789	any(
	1790	\\[-237462374673276894279832749832423479823246327846]
	1791	);
	1792	}
	1793
	1794	test "i_object_key_lone_2nd_surrogate" {
	1795	any(
	1796	\\{"\uDFAA":0}
	1797	);
	1798	}
	1799
	1800	test "i_string_1st_surrogate_but_2nd_missing" {
	1801	any(
	1802	\\["\uDADA"]
	1803	);
	1804	}
	1805
	1806	test "i_string_1st_valid_surrogate_2nd_invalid" {
	1807	any(
	1808	\\["\uD888\u1234"]
	1809	);
	1810	}
	1811
	1812	test "i_string_incomplete_surrogate_and_escape_valid" {
	1813	any(
	1814	\\["\uD800\n"]
	1815	);
	1816	}
	1817
	1818	test "i_string_incomplete_surrogate_pair" {
	1819	any(
	1820	\\["\uDd1ea"]
	1821	);
	1822	}
	1823
	1824	test "i_string_incomplete_surrogates_escape_valid" {
	1825	any(
	1826	\\["\uD800\uD800\n"]
	1827	);
	1828	}
	1829
	1830	test "i_string_invalid_lonely_surrogate" {
	1831	any(
	1832	\\["\ud800"]
	1833	);
	1834	}
	1835
	1836	test "i_string_invalid_surrogate" {
	1837	any(
	1838	\\["\ud800abc"]
	1839	);
	1840	}
	1841
	1842	test "i_string_invalid_utf-8" {
	1843	any(
	1844	\\["ÿ"]
	1845	);
	1846	}
	1847
	1848	test "i_string_inverted_surrogates_U+1D11E" {
	1849	any(
	1850	\\["\uDd1e\uD834"]
	1851	);
	1852	}
	1853
	1854	test "i_string_iso_latin_1" {
	1855	any(
	1856	\\["é"]
	1857	);
	1858	}
	1859
	1860	test "i_string_lone_second_surrogate" {
	1861	any(
	1862	\\["\uDFAA"]
	1863	);
	1864	}
	1865
	1866	test "i_string_lone_utf8_continuation_byte" {
	1867	any(
	1868	\\[""]
	1869	);
	1870	}
	1871
	1872	test "i_string_not_in_unicode_range" {
	1873	any(
	1874	\\["ô¿¿¿"]
	1875	);
	1876	}
	1877
	1878	test "i_string_overlong_sequence_2_bytes" {
	1879	any(
	1880	\\["À¯"]
	1881	);
	1882	}
	1883
	1884	test "i_string_overlong_sequence_6_bytes" {
	1885	any(
	1886	\\["ü¿¿¿¿"]
	1887	);
	1888	}
	1889
	1890	test "i_string_overlong_sequence_6_bytes_null" {
	1891	any(
	1892	\\["ü"]
	1893	);
	1894	}
	1895
	1896	test "i_string_truncated-utf-8" {
	1897	any(
	1898	\\["àÿ"]
	1899	);
	1900	}
	1901
	1902	test "i_string_utf16BE_no_BOM" {
	1903	any(
	1904	\\["é"]
	1905	);
	1906	}
	1907
	1908	test "i_string_utf16LE_no_BOM" {
	1909	any(
	1910	\\["é"]
	1911	);
	1912	}
	1913
	1914	test "i_string_UTF-16LE_with_BOM" {
	1915	any(
	1916	\\ÿþ["é"]
	1917	);
	1918	}
	1919
	1920	test "i_string_UTF-8_invalid_sequence" {
	1921	any(
	1922	\\["æ¥Ñú"]
	1923	);
	1924	}
	1925
	1926	test "i_string_UTF8_surrogate_U+D800" {
	1927	any(
	1928	\\["í "]
	1929	);
	1930	}
	1931
	1932	test "i_structure_500_nested_arrays" {
	1933	any(
	1934	("[" 500) ++ ("]" 500)
	1935	);
	1936	}
	1937
	1938	test "i_structure_UTF-8_BOM_empty_object" {
	1939	any(
	1940	\\ï»¿{}
	1941	);
	1942	}

std/linked_list.zig+1

...	...	@@ -161,6 +161,7 @@ fn BaseLinkedList(comptime T: type, comptime ParentType: type, comptime field_na
161	161	}
162	162
163	163	list.len -= 1;
	164	assert(list.len == 0 or (list.first != null and list.last != null));
164	165	}
165	166
166	167	/// Remove and return the last node in the list.

std/math/complex/abs.zig created+18

...	...	@@ -0,0 +1,18 @@
	1	const std = @import("../../index.zig");
	2	const debug = std.debug;
	3	const math = std.math;
	4	const cmath = math.complex;
	5	const Complex = cmath.Complex;
	6
	7	pub fn abs(z: var) @typeOf(z.re) {
	8	const T = @typeOf(z.re);
	9	return math.hypot(T, z.re, z.im);
	10	}
	11
	12	const epsilon = 0.0001;
	13
	14	test "complex.cabs" {
	15	const a = Complex(f32).new(5, 3);
	16	const c = abs(a);
	17	debug.assert(math.approxEq(f32, c, 5.83095, epsilon));
	18	}

std/math/complex/acos.zig created+21

...	...	@@ -0,0 +1,21 @@
	1	const std = @import("../../index.zig");
	2	const debug = std.debug;
	3	const math = std.math;
	4	const cmath = math.complex;
	5	const Complex = cmath.Complex;
	6
	7	pub fn acos(z: var) Complex(@typeOf(z.re)) {
	8	const T = @typeOf(z.re);
	9	const q = cmath.asin(z);
	10	return Complex(T).new(T(math.pi) / 2 - q.re, -q.im);
	11	}
	12
	13	const epsilon = 0.0001;
	14
	15	test "complex.cacos" {
	16	const a = Complex(f32).new(5, 3);
	17	const c = acos(a);
	18
	19	debug.assert(math.approxEq(f32, c.re, 0.546975, epsilon));
	20	debug.assert(math.approxEq(f32, c.im, -2.452914, epsilon));
	21	}

std/math/complex/acosh.zig created+21

...	...	@@ -0,0 +1,21 @@
	1	const std = @import("../../index.zig");
	2	const debug = std.debug;
	3	const math = std.math;
	4	const cmath = math.complex;
	5	const Complex = cmath.Complex;
	6
	7	pub fn acosh(z: var) Complex(@typeOf(z.re)) {
	8	const T = @typeOf(z.re);
	9	const q = cmath.acos(z);
	10	return Complex(T).new(-q.im, q.re);
	11	}
	12
	13	const epsilon = 0.0001;
	14
	15	test "complex.cacosh" {
	16	const a = Complex(f32).new(5, 3);
	17	const c = acosh(a);
	18
	19	debug.assert(math.approxEq(f32, c.re, 2.452914, epsilon));
	20	debug.assert(math.approxEq(f32, c.im, 0.546975, epsilon));
	21	}

std/math/complex/arg.zig created+18

...	...	@@ -0,0 +1,18 @@
	1	const std = @import("../../index.zig");
	2	const debug = std.debug;
	3	const math = std.math;
	4	const cmath = math.complex;
	5	const Complex = cmath.Complex;
	6
	7	pub fn arg(z: var) @typeOf(z.re) {
	8	const T = @typeOf(z.re);
	9	return math.atan2(T, z.im, z.re);
	10	}
	11
	12	const epsilon = 0.0001;
	13
	14	test "complex.carg" {
	15	const a = Complex(f32).new(5, 3);
	16	const c = arg(a);
	17	debug.assert(math.approxEq(f32, c, 0.540420, epsilon));
	18	}

std/math/complex/asin.zig created+27

...	...	@@ -0,0 +1,27 @@
	1	const std = @import("../../index.zig");
	2	const debug = std.debug;
	3	const math = std.math;
	4	const cmath = math.complex;
	5	const Complex = cmath.Complex;
	6
	7	pub fn asin(z: var) Complex(@typeOf(z.re)) {
	8	const T = @typeOf(z.re);
	9	const x = z.re;
	10	const y = z.im;
	11
	12	const p = Complex(T).new(1.0 - (x - y) * (x + y), -2.0 * x * y);
	13	const q = Complex(T).new(-y, x);
	14	const r = cmath.log(q.add(cmath.sqrt(p)));
	15
	16	return Complex(T).new(r.im, -r.re);
	17	}
	18
	19	const epsilon = 0.0001;
	20
	21	test "complex.casin" {
	22	const a = Complex(f32).new(5, 3);
	23	const c = asin(a);
	24
	25	debug.assert(math.approxEq(f32, c.re, 1.023822, epsilon));
	26	debug.assert(math.approxEq(f32, c.im, 2.452914, epsilon));
	27	}

std/math/complex/asinh.zig created+22

...	...	@@ -0,0 +1,22 @@
	1	const std = @import("../../index.zig");
	2	const debug = std.debug;
	3	const math = std.math;
	4	const cmath = math.complex;
	5	const Complex = cmath.Complex;
	6
	7	pub fn asinh(z: var) Complex(@typeOf(z.re)) {
	8	const T = @typeOf(z.re);
	9	const q = Complex(T).new(-z.im, z.re);
	10	const r = cmath.asin(q);
	11	return Complex(T).new(r.im, -r.re);
	12	}
	13
	14	const epsilon = 0.0001;
	15
	16	test "complex.casinh" {
	17	const a = Complex(f32).new(5, 3);
	18	const c = asinh(a);
	19
	20	debug.assert(math.approxEq(f32, c.re, 2.459831, epsilon));
	21	debug.assert(math.approxEq(f32, c.im, 0.533999, epsilon));
	22	}

std/math/complex/atan.zig created+130

...	...	@@ -0,0 +1,130 @@
	1	const std = @import("../../index.zig");
	2	const debug = std.debug;
	3	const math = std.math;
	4	const cmath = math.complex;
	5	const Complex = cmath.Complex;
	6
	7	pub fn atan(z: var) Complex(@typeOf(z.re)) {
	8	const T = @typeOf(z.re);
	9	return switch (T) {
	10	f32 => atan32(z),
	11	f64 => atan64(z),
	12	else => @compileError("atan not implemented for " ++ @typeName(z)),
	13	};
	14	}
	15
	16	fn redupif32(x: f32) f32 {
	17	const DP1 = 3.140625;
	18	const DP2 = 9.67502593994140625e-4;
	19	const DP3 = 1.509957990978376432e-7;
	20
	21	var t = x / math.pi;
	22	if (t >= 0.0) {
	23	t += 0.5;
	24	} else {
	25	t -= 0.5;
	26	}
	27
	28	const u = f32(i32(t));
	29	return ((x - u * DP1) - u * DP2) - t * DP3;
	30	}
	31
	32	fn atan32(z: &const Complex(f32)) Complex(f32) {
	33	const maxnum = 1.0e38;
	34
	35	const x = z.re;
	36	const y = z.im;
	37
	38	if ((x == 0.0) and (y > 1.0)) {
	39	// overflow
	40	return Complex(f32).new(maxnum, maxnum);
	41	}
	42
	43	const x2 = x * x;
	44	var a = 1.0 - x2 - (y * y);
	45	if (a == 0.0) {
	46	// overflow
	47	return Complex(f32).new(maxnum, maxnum);
	48	}
	49
	50	var t = 0.5 * math.atan2(f32, 2.0 * x, a);
	51	var w = redupif32(t);
	52
	53	t = y - 1.0;
	54	a = x2 + t * t;
	55	if (a == 0.0) {
	56	// overflow
	57	return Complex(f32).new(maxnum, maxnum);
	58	}
	59
	60	t = y + 1.0;
	61	a = (x2 + (t * t)) / a;
	62	return Complex(f32).new(w, 0.25 * math.ln(a));
	63	}
	64
	65	fn redupif64(x: f64) f64 {
	66	const DP1 = 3.14159265160560607910;
	67	const DP2 = 1.98418714791870343106e-9;
	68	const DP3 = 1.14423774522196636802e-17;
	69
	70	var t = x / math.pi;
	71	if (t >= 0.0) {
	72	t += 0.5;
	73	} else {
	74	t -= 0.5;
	75	}
	76
	77	const u = f64(i64(t));
	78	return ((x - u * DP1) - u * DP2) - t * DP3;
	79	}
	80
	81	fn atan64(z: &const Complex(f64)) Complex(f64) {
	82	const maxnum = 1.0e308;
	83
	84	const x = z.re;
	85	const y = z.im;
	86
	87	if ((x == 0.0) and (y > 1.0)) {
	88	// overflow
	89	return Complex(f64).new(maxnum, maxnum);
	90	}
	91
	92	const x2 = x * x;
	93	var a = 1.0 - x2 - (y * y);
	94	if (a == 0.0) {
	95	// overflow
	96	return Complex(f64).new(maxnum, maxnum);
	97	}
	98
	99	var t = 0.5 * math.atan2(f64, 2.0 * x, a);
	100	var w = redupif64(t);
	101
	102	t = y - 1.0;
	103	a = x2 + t * t;
	104	if (a == 0.0) {
	105	// overflow
	106	return Complex(f64).new(maxnum, maxnum);
	107	}
	108
	109	t = y + 1.0;
	110	a = (x2 + (t * t)) / a;
	111	return Complex(f64).new(w, 0.25 * math.ln(a));
	112	}
	113
	114	const epsilon = 0.0001;
	115
	116	test "complex.catan32" {
	117	const a = Complex(f32).new(5, 3);
	118	const c = atan(a);
	119
	120	debug.assert(math.approxEq(f32, c.re, 1.423679, epsilon));
	121	debug.assert(math.approxEq(f32, c.im, 0.086569, epsilon));
	122	}
	123
	124	test "complex.catan64" {
	125	const a = Complex(f64).new(5, 3);
	126	const c = atan(a);
	127
	128	debug.assert(math.approxEq(f64, c.re, 1.423679, epsilon));
	129	debug.assert(math.approxEq(f64, c.im, 0.086569, epsilon));
	130	}

std/math/complex/atanh.zig created+22

...	...	@@ -0,0 +1,22 @@
	1	const std = @import("../../index.zig");
	2	const debug = std.debug;
	3	const math = std.math;
	4	const cmath = math.complex;
	5	const Complex = cmath.Complex;
	6
	7	pub fn atanh(z: var) Complex(@typeOf(z.re)) {
	8	const T = @typeOf(z.re);
	9	const q = Complex(T).new(-z.im, z.re);
	10	const r = cmath.atan(q);
	11	return Complex(T).new(r.im, -r.re);
	12	}
	13
	14	const epsilon = 0.0001;
	15
	16	test "complex.catanh" {
	17	const a = Complex(f32).new(5, 3);
	18	const c = atanh(a);
	19
	20	debug.assert(math.approxEq(f32, c.re, 0.146947, epsilon));
	21	debug.assert(math.approxEq(f32, c.im, 1.480870, epsilon));
	22	}

std/math/complex/conj.zig created+17

...	...	@@ -0,0 +1,17 @@
	1	const std = @import("../../index.zig");
	2	const debug = std.debug;
	3	const math = std.math;
	4	const cmath = math.complex;
	5	const Complex = cmath.Complex;
	6
	7	pub fn conj(z: var) Complex(@typeOf(z.re)) {
	8	const T = @typeOf(z.re);
	9	return Complex(T).new(z.re, -z.im);
	10	}
	11
	12	test "complex.conj" {
	13	const a = Complex(f32).new(5, 3);
	14	const c = a.conjugate();
	15
	16	debug.assert(c.re == 5 and c.im == -3);
	17	}

std/math/complex/cos.zig created+21

...	...	@@ -0,0 +1,21 @@
	1	const std = @import("../../index.zig");
	2	const debug = std.debug;
	3	const math = std.math;
	4	const cmath = math.complex;
	5	const Complex = cmath.Complex;
	6
	7	pub fn cos(z: var) Complex(@typeOf(z.re)) {
	8	const T = @typeOf(z.re);
	9	const p = Complex(T).new(-z.im, z.re);
	10	return cmath.cosh(p);
	11	}
	12
	13	const epsilon = 0.0001;
	14
	15	test "complex.ccos" {
	16	const a = Complex(f32).new(5, 3);
	17	const c = cos(a);
	18
	19	debug.assert(math.approxEq(f32, c.re, 2.855815, epsilon));
	20	debug.assert(math.approxEq(f32, c.im, 9.606383, epsilon));
	21	}

std/math/complex/cosh.zig created+165

...	...	@@ -0,0 +1,165 @@
	1	const std = @import("../../index.zig");
	2	const debug = std.debug;
	3	const math = std.math;
	4	const cmath = math.complex;
	5	const Complex = cmath.Complex;
	6
	7	const ldexp_cexp = @import("ldexp.zig").ldexp_cexp;
	8
	9	pub fn cosh(z: var) Complex(@typeOf(z.re)) {
	10	const T = @typeOf(z.re);
	11	return switch (T) {
	12	f32 => cosh32(z),
	13	f64 => cosh64(z),
	14	else => @compileError("cosh not implemented for " ++ @typeName(z)),
	15	};
	16	}
	17
	18	fn cosh32(z: &const Complex(f32)) Complex(f32) {
	19	const x = z.re;
	20	const y = z.im;
	21
	22	const hx = @bitCast(u32, x);
	23	const ix = hx & 0x7fffffff;
	24
	25	const hy = @bitCast(u32, y);
	26	const iy = hy & 0x7fffffff;
	27
	28	if (ix < 0x7f800000 and iy < 0x7f800000) {
	29	if (iy == 0) {
	30	return Complex(f32).new(math.cosh(x), y);
	31	}
	32	// small x: normal case
	33	if (ix < 0x41100000) {
	34	return Complex(f32).new(math.cosh(x) * math.cos(y), math.sinh(x) * math.sin(y));
	35	}
	36
	37	// \|x\|>= 9, so cosh(x) ~= exp(\|x\|)
	38	if (ix < 0x42b17218) {
	39	// x < 88.7: exp(\|x\|) won't overflow
	40	const h = math.exp(math.fabs(x)) * 0.5;
	41	return Complex(f32).new(math.copysign(f32, h, x) * math.cos(y), h * math.sin(y));
	42	}
	43	// x < 192.7: scale to avoid overflow
	44	else if (ix < 0x4340b1e7) {
	45	const v = Complex(f32).new(math.fabs(x), y);
	46	const r = ldexp_cexp(v, -1);
	47	return Complex(f32).new(x, y * math.copysign(f32, 1, x));
	48	}
	49	// x >= 192.7: result always overflows
	50	else {
	51	const h = 0x1p127 * x;
	52	return Complex(f32).new(h * h * math.cos(y), h * math.sin(y));
	53	}
	54	}
	55
	56	if (ix == 0 and iy >= 0x7f800000) {
	57	return Complex(f32).new(y - y, math.copysign(f32, 0, x * (y - y)));
	58	}
	59
	60	if (iy == 0 and ix >= 0x7f800000) {
	61	if (hx & 0x7fffff == 0) {
	62	return Complex(f32).new(x * x, math.copysign(f32, 0, x) * y);
	63	}
	64	return Complex(f32).new(x, math.copysign(f32, 0, (x + x) * y));
	65	}
	66
	67	if (ix < 0x7f800000 and iy >= 0x7f800000) {
	68	return Complex(f32).new(y - y, x * (y - y));
	69	}
	70
	71	if (ix >= 0x7f800000 and (hx & 0x7fffff) == 0) {
	72	if (iy >= 0x7f800000) {
	73	return Complex(f32).new(x * x, x * (y - y));
	74	}
	75	return Complex(f32).new((x * x) * math.cos(y), x * math.sin(y));
	76	}
	77
	78	return Complex(f32).new((x * x) * (y - y), (x + x) * (y - y));
	79	}
	80
	81	fn cosh64(z: &const Complex(f64)) Complex(f64) {
	82	const x = z.re;
	83	const y = z.im;
	84
	85	const fx = @bitCast(u64, x);
	86	const hx = u32(fx >> 32);
	87	const lx = @truncate(u32, fx);
	88	const ix = hx & 0x7fffffff;
	89
	90	const fy = @bitCast(u64, y);
	91	const hy = u32(fy >> 32);
	92	const ly = @truncate(u32, fy);
	93	const iy = hy & 0x7fffffff;
	94
	95	// nearly non-exceptional case where x, y are finite
	96	if (ix < 0x7ff00000 and iy < 0x7ff00000) {
	97	if (iy \| ly == 0) {
	98	return Complex(f64).new(math.cosh(x), x * y);
	99	}
	100	// small x: normal case
	101	if (ix < 0x40360000) {
	102	return Complex(f64).new(math.cosh(x) * math.cos(y), math.sinh(x) * math.sin(y));
	103	}
	104
	105	// \|x\|>= 22, so cosh(x) ~= exp(\|x\|)
	106	if (ix < 0x40862e42) {
	107	// x < 710: exp(\|x\|) won't overflow
	108	const h = math.exp(math.fabs(x)) * 0.5;
	109	return Complex(f64).new(h * math.cos(y), math.copysign(f64, h, x) * math.sin(y));
	110	}
	111	// x < 1455: scale to avoid overflow
	112	else if (ix < 0x4096bbaa) {
	113	const v = Complex(f64).new(math.fabs(x), y);
	114	const r = ldexp_cexp(v, -1);
	115	return Complex(f64).new(x, y * math.copysign(f64, 1, x));
	116	}
	117	// x >= 1455: result always overflows
	118	else {
	119	const h = 0x1p1023;
	120	return Complex(f64).new(h * h * math.cos(y), h * math.sin(y));
	121	}
	122	}
	123
	124	if (ix \| lx == 0 and iy >= 0x7ff00000) {
	125	return Complex(f64).new(y - y, math.copysign(f64, 0, x * (y - y)));
	126	}
	127
	128	if (iy \| ly == 0 and ix >= 0x7ff00000) {
	129	if ((hx & 0xfffff) \| lx == 0) {
	130	return Complex(f64).new(x * x, math.copysign(f64, 0, x) * y);
	131	}
	132	return Complex(f64).new(x * x, math.copysign(f64, 0, (x + x) * y));
	133	}
	134
	135	if (ix < 0x7ff00000 and iy >= 0x7ff00000) {
	136	return Complex(f64).new(y - y, x * (y - y));
	137	}
	138
	139	if (ix >= 0x7ff00000 and (hx & 0xfffff) \| lx == 0) {
	140	if (iy >= 0x7ff00000) {
	141	return Complex(f64).new(x * x, x * (y - y));
	142	}
	143	return Complex(f64).new(x * x * math.cos(y), x * math.sin(y));
	144	}
	145
	146	return Complex(f64).new((x * x) * (y - y), (x + x) * (y - y));
	147	}
	148
	149	const epsilon = 0.0001;
	150
	151	test "complex.ccosh32" {
	152	const a = Complex(f32).new(5, 3);
	153	const c = cosh(a);
	154
	155	debug.assert(math.approxEq(f32, c.re, -73.467300, epsilon));
	156	debug.assert(math.approxEq(f32, c.im, 10.471557, epsilon));
	157	}
	158
	159	test "complex.ccosh64" {
	160	const a = Complex(f64).new(5, 3);
	161	const c = cosh(a);
	162
	163	debug.assert(math.approxEq(f64, c.re, -73.467300, epsilon));
	164	debug.assert(math.approxEq(f64, c.im, 10.471557, epsilon));
	165	}

std/math/complex/exp.zig created+140

...	...	@@ -0,0 +1,140 @@
	1	const std = @import("../../index.zig");
	2	const debug = std.debug;
	3	const math = std.math;
	4	const cmath = math.complex;
	5	const Complex = cmath.Complex;
	6
	7	const ldexp_cexp = @import("ldexp.zig").ldexp_cexp;
	8
	9	pub fn exp(z: var) Complex(@typeOf(z.re)) {
	10	const T = @typeOf(z.re);
	11
	12	return switch (T) {
	13	f32 => exp32(z),
	14	f64 => exp64(z),
	15	else => @compileError("exp not implemented for " ++ @typeName(z)),
	16	};
	17	}
	18
	19	fn exp32(z: &const Complex(f32)) Complex(f32) {
	20	@setFloatMode(this, @import("builtin").FloatMode.Strict);
	21
	22	const exp_overflow = 0x42b17218; // max_exp * ln2 ~= 88.72283955
	23	const cexp_overflow = 0x43400074; // (max_exp - min_denom_exp) * ln2
	24
	25	const x = z.re;
	26	const y = z.im;
	27
	28	const hy = @bitCast(u32, y) & 0x7fffffff;
	29	// cexp(x + i0) = exp(x) + i0
	30	if (hy == 0) {
	31	return Complex(f32).new(math.exp(x), y);
	32	}
	33
	34	const hx = @bitCast(u32, x);
	35	// cexp(0 + iy) = cos(y) + isin(y)
	36	if ((hx & 0x7fffffff) == 0) {
	37	return Complex(f32).new(math.cos(y), math.sin(y));
	38	}
	39
	40	if (hy >= 0x7f800000) {
	41	// cexp(finite\|nan +- i inf\|nan) = nan + i nan
	42	if ((hx & 0x7fffffff) != 0x7f800000) {
	43	return Complex(f32).new(y - y, y - y);
	44	}
	45	// cexp(-inf +- i inf\|nan) = 0 + i0
	46	else if (hx & 0x80000000 != 0) {
	47	return Complex(f32).new(0, 0);
	48	}
	49	// cexp(+inf +- i inf\|nan) = inf + i nan
	50	else {
	51	return Complex(f32).new(x, y - y);
	52	}
	53	}
	54
	55	// 88.7 <= x <= 192 so must scale
	56	if (hx >= exp_overflow and hx <= cexp_overflow) {
	57	return ldexp_cexp(z, 0);
	58	}
	59	// - x < exp_overflow => exp(x) won't overflow (common)
	60	// - x > cexp_overflow, so exp(x) * s overflows for s > 0
	61	// - x = +-inf
	62	// - x = nan
	63	else {
	64	const exp_x = math.exp(x);
	65	return Complex(f32).new(exp_x * math.cos(y), exp_x * math.sin(y));
	66	}
	67	}
	68
	69	fn exp64(z: &const Complex(f64)) Complex(f64) {
	70	const exp_overflow = 0x40862e42; // high bits of max_exp * ln2 ~= 710
	71	const cexp_overflow = 0x4096b8e4; // (max_exp - min_denorm_exp) * ln2
	72
	73	const x = z.re;
	74	const y = z.im;
	75
	76	const fy = @bitCast(u64, y);
	77	const hy = u32(fy >> 32) & 0x7fffffff;
	78	const ly = @truncate(u32, fy);
	79
	80	// cexp(x + i0) = exp(x) + i0
	81	if (hy \| ly == 0) {
	82	return Complex(f64).new(math.exp(x), y);
	83	}
	84
	85	const fx = @bitCast(u64, x);
	86	const hx = u32(fx >> 32);
	87	const lx = @truncate(u32, fx);
	88
	89	// cexp(0 + iy) = cos(y) + isin(y)
	90	if ((hx & 0x7fffffff) \| lx == 0) {
	91	return Complex(f64).new(math.cos(y), math.sin(y));
	92	}
	93
	94	if (hy >= 0x7ff00000) {
	95	// cexp(finite\|nan +- i inf\|nan) = nan + i nan
	96	if (lx != 0 or (hx & 0x7fffffff) != 0x7ff00000) {
	97	return Complex(f64).new(y - y, y - y);
	98	}
	99	// cexp(-inf +- i inf\|nan) = 0 + i0
	100	else if (hx & 0x80000000 != 0) {
	101	return Complex(f64).new(0, 0);
	102	}
	103	// cexp(+inf +- i inf\|nan) = inf + i nan
	104	else {
	105	return Complex(f64).new(x, y - y);
	106	}
	107	}
	108
	109	// 709.7 <= x <= 1454.3 so must scale
	110	if (hx >= exp_overflow and hx <= cexp_overflow) {
	111	const r = ldexp_cexp(z, 0);
	112	return *r;
	113	}
	114	// - x < exp_overflow => exp(x) won't overflow (common)
	115	// - x > cexp_overflow, so exp(x) * s overflows for s > 0
	116	// - x = +-inf
	117	// - x = nan
	118	else {
	119	const exp_x = math.exp(x);
	120	return Complex(f64).new(exp_x * math.cos(y), exp_x * math.sin(y));
	121	}
	122	}
	123
	124	const epsilon = 0.0001;
	125
	126	test "complex.cexp32" {
	127	const a = Complex(f32).new(5, 3);
	128	const c = exp(a);
	129
	130	debug.assert(math.approxEq(f32, c.re, -146.927917, epsilon));
	131	debug.assert(math.approxEq(f32, c.im, 20.944065, epsilon));
	132	}
	133
	134	test "complex.cexp64" {
	135	const a = Complex(f32).new(5, 3);
	136	const c = exp(a);
	137
	138	debug.assert(math.approxEq(f64, c.re, -146.927917, epsilon));
	139	debug.assert(math.approxEq(f64, c.im, 20.944065, epsilon));
	140	}

std/math/complex/index.zig created+171

...	...	@@ -0,0 +1,171 @@
	1	const std = @import("../../index.zig");
	2	const debug = std.debug;
	3	const math = std.math;
	4
	5	pub const abs = @import("abs.zig").abs;
	6	pub const acosh = @import("acosh.zig").acosh;
	7	pub const acos = @import("acos.zig").acos;
	8	pub const arg = @import("arg.zig").arg;
	9	pub const asinh = @import("asinh.zig").asinh;
	10	pub const asin = @import("asin.zig").asin;
	11	pub const atanh = @import("atanh.zig").atanh;
	12	pub const atan = @import("atan.zig").atan;
	13	pub const conj = @import("conj.zig").conj;
	14	pub const cosh = @import("cosh.zig").cosh;
	15	pub const cos = @import("cos.zig").cos;
	16	pub const exp = @import("exp.zig").exp;
	17	pub const log = @import("log.zig").log;
	18	pub const pow = @import("pow.zig").pow;
	19	pub const proj = @import("proj.zig").proj;
	20	pub const sinh = @import("sinh.zig").sinh;
	21	pub const sin = @import("sin.zig").sin;
	22	pub const sqrt = @import("sqrt.zig").sqrt;
	23	pub const tanh = @import("tanh.zig").tanh;
	24	pub const tan = @import("tan.zig").tan;
	25
	26	pub fn Complex(comptime T: type) type {
	27	return struct {
	28	const Self = this;
	29
	30	re: T,
	31	im: T,
	32
	33	pub fn new(re: T, im: T) Self {
	34	return Self {
	35	.re = re,
	36	.im = im,
	37	};
	38	}
	39
	40	pub fn add(self: &const Self, other: &const Self) Self {
	41	return Self {
	42	.re = self.re + other.re,
	43	.im = self.im + other.im,
	44	};
	45	}
	46
	47	pub fn sub(self: &const Self, other: &const Self) Self {
	48	return Self {
	49	.re = self.re - other.re,
	50	.im = self.im - other.im,
	51	};
	52	}
	53
	54	pub fn mul(self: &const Self, other: &const Self) Self {
	55	return Self {
	56	.re = self.re * other.re - self.im * other.im,
	57	.im = self.im * other.re + self.re * other.im,
	58	};
	59	}
	60
	61	pub fn div(self: &const Self, other: &const Self) Self {
	62	const re_num = self.re * other.re + self.im * other.im;
	63	const im_num = self.im * other.re - self.re * other.im;
	64	const den = other.re * other.re + other.im * other.im;
	65
	66	return Self {
	67	.re = re_num / den,
	68	.im = im_num / den,
	69	};
	70	}
	71
	72	pub fn conjugate(self: &const Self) Self {
	73	return Self {
	74	.re = self.re,
	75	.im = -self.im,
	76	};
	77	}
	78
	79	pub fn reciprocal(self: &const Self) Self {
	80	const m = self.re * self.re + self.im * self.im;
	81	return Self {
	82	.re = self.re / m,
	83	.im = -self.im / m,
	84	};
	85	}
	86
	87	pub fn magnitude(self: &const Self) T {
	88	return math.sqrt(self.re * self.re + self.im * self.im);
	89	}
	90	};
	91	}
	92
	93	const epsilon = 0.0001;
	94
	95	test "complex.add" {
	96	const a = Complex(f32).new(5, 3);
	97	const b = Complex(f32).new(2, 7);
	98	const c = a.add(b);
	99
	100	debug.assert(c.re == 7 and c.im == 10);
	101	}
	102
	103	test "complex.sub" {
	104	const a = Complex(f32).new(5, 3);
	105	const b = Complex(f32).new(2, 7);
	106	const c = a.sub(b);
	107
	108	debug.assert(c.re == 3 and c.im == -4);
	109	}
	110
	111	test "complex.mul" {
	112	const a = Complex(f32).new(5, 3);
	113	const b = Complex(f32).new(2, 7);
	114	const c = a.mul(b);
	115
	116	debug.assert(c.re == -11 and c.im == 41);
	117	}
	118
	119	test "complex.div" {
	120	const a = Complex(f32).new(5, 3);
	121	const b = Complex(f32).new(2, 7);
	122	const c = a.div(b);
	123
	124	debug.assert(math.approxEq(f32, c.re, f32(31)/53, epsilon) and
	125	math.approxEq(f32, c.im, f32(-29)/53, epsilon));
	126	}
	127
	128	test "complex.conjugate" {
	129	const a = Complex(f32).new(5, 3);
	130	const c = a.conjugate();
	131
	132	debug.assert(c.re == 5 and c.im == -3);
	133	}
	134
	135	test "complex.reciprocal" {
	136	const a = Complex(f32).new(5, 3);
	137	const c = a.reciprocal();
	138
	139	debug.assert(math.approxEq(f32, c.re, f32(5)/34, epsilon) and
	140	math.approxEq(f32, c.im, f32(-3)/34, epsilon));
	141	}
	142
	143	test "complex.magnitude" {
	144	const a = Complex(f32).new(5, 3);
	145	const c = a.magnitude();
	146
	147	debug.assert(math.approxEq(f32, c, 5.83095, epsilon));
	148	}
	149
	150	test "complex.cmath" {
	151	_ = @import("abs.zig");
	152	_ = @import("acosh.zig");
	153	_ = @import("acos.zig");
	154	_ = @import("arg.zig");
	155	_ = @import("asinh.zig");
	156	_ = @import("asin.zig");
	157	_ = @import("atanh.zig");
	158	_ = @import("atan.zig");
	159	_ = @import("conj.zig");
	160	_ = @import("cosh.zig");
	161	_ = @import("cos.zig");
	162	_ = @import("exp.zig");
	163	_ = @import("log.zig");
	164	_ = @import("pow.zig");
	165	_ = @import("proj.zig");
	166	_ = @import("sinh.zig");
	167	_ = @import("sin.zig");
	168	_ = @import("sqrt.zig");
	169	_ = @import("tanh.zig");
	170	_ = @import("tan.zig");
	171	}

std/math/complex/ldexp.zig created+75

...	...	@@ -0,0 +1,75 @@
	1	const std = @import("../../index.zig");
	2	const debug = std.debug;
	3	const math = std.math;
	4	const cmath = math.complex;
	5	const Complex = cmath.Complex;
	6
	7	pub fn ldexp_cexp(z: var, expt: i32) Complex(@typeOf(z.re)) {
	8	const T = @typeOf(z.re);
	9
	10	return switch (T) {
	11	f32 => ldexp_cexp32(z, expt),
	12	f64 => ldexp_cexp64(z, expt),
	13	else => unreachable,
	14	};
	15	}
	16
	17	fn frexp_exp32(x: f32, expt: &i32) f32 {
	18	const k = 235; // reduction constant
	19	const kln2 = 162.88958740; // k * ln2
	20
	21	const exp_x = math.exp(x - kln2);
	22	const hx = @bitCast(u32, exp_x);
	23	*expt = i32(hx >> 23) - (0x7f + 127) + k;
	24	return @bitCast(f32, (hx & 0x7fffff) \| ((0x7f + 127) << 23));
	25	}
	26
	27	fn ldexp_cexp32(z: &const Complex(f32), expt: i32) Complex(f32) {
	28	var ex_expt: i32 = undefined;
	29	const exp_x = frexp_exp32(z.re, &ex_expt);
	30	const exptf = expt + ex_expt;
	31
	32	const half_expt1 = @divTrunc(exptf, 2);
	33	const scale1 = @bitCast(f32, (0x7f + half_expt1) << 23);
	34
	35	const half_expt2 = exptf - half_expt1;
	36	const scale2 = @bitCast(f32, (0x7f + half_expt2) << 23);
	37
	38	return Complex(f32).new(
	39	math.cos(z.im) * exp_x * scale1 * scale2,
	40	math.sin(z.im) * exp_x * scale1 * scale2,
	41	);
	42	}
	43
	44	fn frexp_exp64(x: f64, expt: &i32) f64 {
	45	const k = 1799; // reduction constant
	46	const kln2 = 1246.97177782734161156; // k * ln2
	47
	48	const exp_x = math.exp(x - kln2);
	49
	50	const fx = @bitCast(u64, x);
	51	const hx = u32(fx >> 32);
	52	const lx = @truncate(u32, fx);
	53
	54	*expt = i32(hx >> 20) - (0x3ff + 1023) + k;
	55
	56	const high_word = (hx & 0xfffff) \| ((0x3ff + 1023) << 20);
	57	return @bitCast(f64, (u64(high_word) << 32) \| lx);
	58	}
	59
	60	fn ldexp_cexp64(z: &const Complex(f64), expt: i32) Complex(f64) {
	61	var ex_expt: i32 = undefined;
	62	const exp_x = frexp_exp64(z.re, &ex_expt);
	63	const exptf = i64(expt + ex_expt);
	64
	65	const half_expt1 = @divTrunc(exptf, 2);
	66	const scale1 = @bitCast(f64, (0x3ff + half_expt1) << 20);
	67
	68	const half_expt2 = exptf - half_expt1;
	69	const scale2 = @bitCast(f64, (0x3ff + half_expt2) << 20);
	70
	71	return Complex(f64).new(
	72	math.cos(z.im) * exp_x * scale1 * scale2,
	73	math.sin(z.im) * exp_x * scale1 * scale2,
	74	);
	75	}

std/math/complex/log.zig created+23

...	...	@@ -0,0 +1,23 @@
	1	const std = @import("../../index.zig");
	2	const debug = std.debug;
	3	const math = std.math;
	4	const cmath = math.complex;
	5	const Complex = cmath.Complex;
	6
	7	pub fn log(z: var) Complex(@typeOf(z.re)) {
	8	const T = @typeOf(z.re);
	9	const r = cmath.abs(z);
	10	const phi = cmath.arg(z);
	11
	12	return Complex(T).new(math.ln(r), phi);
	13	}
	14
	15	const epsilon = 0.0001;
	16
	17	test "complex.clog" {
	18	const a = Complex(f32).new(5, 3);
	19	const c = log(a);
	20
	21	debug.assert(math.approxEq(f32, c.re, 1.763180, epsilon));
	22	debug.assert(math.approxEq(f32, c.im, 0.540419, epsilon));
	23	}

std/math/complex/pow.zig created+22

...	...	@@ -0,0 +1,22 @@
	1	const std = @import("../../index.zig");
	2	const debug = std.debug;
	3	const math = std.math;
	4	const cmath = math.complex;
	5	const Complex = cmath.Complex;
	6
	7	pub fn pow(comptime T: type, z: &const T, c: &const T) T {
	8	const p = cmath.log(z);
	9	const q = c.mul(p);
	10	return cmath.exp(q);
	11	}
	12
	13	const epsilon = 0.0001;
	14
	15	test "complex.cpow" {
	16	const a = Complex(f32).new(5, 3);
	17	const b = Complex(f32).new(2.3, -1.3);
	18	const c = pow(Complex(f32), a, b);
	19
	20	debug.assert(math.approxEq(f32, c.re, 58.049110, epsilon));
	21	debug.assert(math.approxEq(f32, c.im, -101.003433, epsilon));
	22	}

std/math/complex/proj.zig created+24

...	...	@@ -0,0 +1,24 @@
	1	const std = @import("../../index.zig");
	2	const debug = std.debug;
	3	const math = std.math;
	4	const cmath = math.complex;
	5	const Complex = cmath.Complex;
	6
	7	pub fn proj(z: var) Complex(@typeOf(z.re)) {
	8	const T = @typeOf(z.re);
	9
	10	if (math.isInf(z.re) or math.isInf(z.im)) {
	11	return Complex(T).new(math.inf(T), math.copysign(T, 0, z.re));
	12	}
	13
	14	return Complex(T).new(z.re, z.im);
	15	}
	16
	17	const epsilon = 0.0001;
	18
	19	test "complex.cproj" {
	20	const a = Complex(f32).new(5, 3);
	21	const c = proj(a);
	22
	23	debug.assert(c.re == 5 and c.im == 3);
	24	}

std/math/complex/sin.zig created+22

...	...	@@ -0,0 +1,22 @@
	1	const std = @import("../../index.zig");
	2	const debug = std.debug;
	3	const math = std.math;
	4	const cmath = math.complex;
	5	const Complex = cmath.Complex;
	6
	7	pub fn sin(z: var) Complex(@typeOf(z.re)) {
	8	const T = @typeOf(z.re);
	9	const p = Complex(T).new(-z.im, z.re);
	10	const q = cmath.sinh(p);
	11	return Complex(T).new(q.im, -q.re);
	12	}
	13
	14	const epsilon = 0.0001;
	15
	16	test "complex.csin" {
	17	const a = Complex(f32).new(5, 3);
	18	const c = sin(a);
	19
	20	debug.assert(math.approxEq(f32, c.re, -9.654126, epsilon));
	21	debug.assert(math.approxEq(f32, c.im, 2.841692, epsilon));
	22	}

std/math/complex/sinh.zig created+164

...	...	@@ -0,0 +1,164 @@
	1	const std = @import("../../index.zig");
	2	const debug = std.debug;
	3	const math = std.math;
	4	const cmath = math.complex;
	5	const Complex = cmath.Complex;
	6
	7	const ldexp_cexp = @import("ldexp.zig").ldexp_cexp;
	8
	9	pub fn sinh(z: var) Complex(@typeOf(z.re)) {
	10	const T = @typeOf(z.re);
	11	return switch (T) {
	12	f32 => sinh32(z),
	13	f64 => sinh64(z),
	14	else => @compileError("tan not implemented for " ++ @typeName(z)),
	15	};
	16	}
	17
	18	fn sinh32(z: &const Complex(f32)) Complex(f32) {
	19	const x = z.re;
	20	const y = z.im;
	21
	22	const hx = @bitCast(u32, x);
	23	const ix = hx & 0x7fffffff;
	24
	25	const hy = @bitCast(u32, y);
	26	const iy = hy & 0x7fffffff;
	27
	28	if (ix < 0x7f800000 and iy < 0x7f800000) {
	29	if (iy == 0) {
	30	return Complex(f32).new(math.sinh(x), y);
	31	}
	32	// small x: normal case
	33	if (ix < 0x41100000) {
	34	return Complex(f32).new(math.sinh(x) * math.cos(y), math.cosh(x) * math.sin(y));
	35	}
	36
	37	// \|x\|>= 9, so cosh(x) ~= exp(\|x\|)
	38	if (ix < 0x42b17218) {
	39	// x < 88.7: exp(\|x\|) won't overflow
	40	const h = math.exp(math.fabs(x)) * 0.5;
	41	return Complex(f32).new(math.copysign(f32, h, x) * math.cos(y), h * math.sin(y));
	42	}
	43	// x < 192.7: scale to avoid overflow
	44	else if (ix < 0x4340b1e7) {
	45	const v = Complex(f32).new(math.fabs(x), y);
	46	const r = ldexp_cexp(v, -1);
	47	return Complex(f32).new(x * math.copysign(f32, 1, x), y);
	48	}
	49	// x >= 192.7: result always overflows
	50	else {
	51	const h = 0x1p127 * x;
	52	return Complex(f32).new(h * math.cos(y), h * h * math.sin(y));
	53	}
	54	}
	55
	56	if (ix == 0 and iy >= 0x7f800000) {
	57	return Complex(f32).new(math.copysign(f32, 0, x * (y - y)), y - y);
	58	}
	59
	60	if (iy == 0 and ix >= 0x7f800000) {
	61	if (hx & 0x7fffff == 0) {
	62	return Complex(f32).new(x, y);
	63	}
	64	return Complex(f32).new(x, math.copysign(f32, 0, y));
	65	}
	66
	67	if (ix < 0x7f800000 and iy >= 0x7f800000) {
	68	return Complex(f32).new(y - y, x * (y - y));
	69	}
	70
	71	if (ix >= 0x7f800000 and (hx & 0x7fffff) == 0) {
	72	if (iy >= 0x7f800000) {
	73	return Complex(f32).new(x * x, x * (y - y));
	74	}
	75	return Complex(f32).new(x * math.cos(y), math.inf_f32 * math.sin(y));
	76	}
	77
	78	return Complex(f32).new((x * x) * (y - y), (x + x) * (y - y));
	79	}
	80
	81	fn sinh64(z: &const Complex(f64)) Complex(f64) {
	82	const x = z.re;
	83	const y = z.im;
	84
	85	const fx = @bitCast(u64, x);
	86	const hx = u32(fx >> 32);
	87	const lx = @truncate(u32, fx);
	88	const ix = hx & 0x7fffffff;
	89
	90	const fy = @bitCast(u64, y);
	91	const hy = u32(fy >> 32);
	92	const ly = @truncate(u32, fy);
	93	const iy = hy & 0x7fffffff;
	94
	95	if (ix < 0x7ff00000 and iy < 0x7ff00000) {
	96	if (iy \| ly == 0) {
	97	return Complex(f64).new(math.sinh(x), y);
	98	}
	99	// small x: normal case
	100	if (ix < 0x40360000) {
	101	return Complex(f64).new(math.sinh(x) * math.cos(y), math.cosh(x) * math.sin(y));
	102	}
	103
	104	// \|x\|>= 22, so cosh(x) ~= exp(\|x\|)
	105	if (ix < 0x40862e42) {
	106	// x < 710: exp(\|x\|) won't overflow
	107	const h = math.exp(math.fabs(x)) * 0.5;
	108	return Complex(f64).new(math.copysign(f64, h, x) * math.cos(y), h * math.sin(y));
	109	}
	110	// x < 1455: scale to avoid overflow
	111	else if (ix < 0x4096bbaa) {
	112	const v = Complex(f64).new(math.fabs(x), y);
	113	const r = ldexp_cexp(v, -1);
	114	return Complex(f64).new(x * math.copysign(f64, 1, x), y);
	115	}
	116	// x >= 1455: result always overflows
	117	else {
	118	const h = 0x1p1023 * x;
	119	return Complex(f64).new(h * math.cos(y), h * h * math.sin(y));
	120	}
	121	}
	122
	123	if (ix \| lx == 0 and iy >= 0x7ff00000) {
	124	return Complex(f64).new(math.copysign(f64, 0, x * (y - y)), y - y);
	125	}
	126
	127	if (iy \| ly == 0 and ix >= 0x7ff00000) {
	128	if ((hx & 0xfffff) \| lx == 0) {
	129	return Complex(f64).new(x, y);
	130	}
	131	return Complex(f64).new(x, math.copysign(f64, 0, y));
	132	}
	133
	134	if (ix < 0x7ff00000 and iy >= 0x7ff00000) {
	135	return Complex(f64).new(y - y, x * (y - y));
	136	}
	137
	138	if (ix >= 0x7ff00000 and (hx & 0xfffff) \| lx == 0) {
	139	if (iy >= 0x7ff00000) {
	140	return Complex(f64).new(x * x, x * (y - y));
	141	}
	142	return Complex(f64).new(x * math.cos(y), math.inf_f64 * math.sin(y));
	143	}
	144
	145	return Complex(f64).new((x * x) * (y - y), (x + x) * (y - y));
	146	}
	147
	148	const epsilon = 0.0001;
	149
	150	test "complex.csinh32" {
	151	const a = Complex(f32).new(5, 3);
	152	const c = sinh(a);
	153
	154	debug.assert(math.approxEq(f32, c.re, -73.460617, epsilon));
	155	debug.assert(math.approxEq(f32, c.im, 10.472508, epsilon));
	156	}
	157
	158	test "complex.csinh64" {
	159	const a = Complex(f64).new(5, 3);
	160	const c = sinh(a);
	161
	162	debug.assert(math.approxEq(f64, c.re, -73.460617, epsilon));
	163	debug.assert(math.approxEq(f64, c.im, 10.472508, epsilon));
	164	}

std/math/complex/sqrt.zig created+133

...	...	@@ -0,0 +1,133 @@
	1	const std = @import("../../index.zig");
	2	const debug = std.debug;
	3	const math = std.math;
	4	const cmath = math.complex;
	5	const Complex = cmath.Complex;
	6
	7	// TODO when #733 is solved this can be @typeOf(z) instead of Complex(@typeOf(z.re))
	8	pub fn sqrt(z: var) Complex(@typeOf(z.re)) {
	9	const T = @typeOf(z.re);
	10
	11	return switch (T) {
	12	f32 => sqrt32(z),
	13	f64 => sqrt64(z),
	14	else => @compileError("sqrt not implemented for " ++ @typeName(z)),
	15	};
	16	}
	17
	18	fn sqrt32(z: &const Complex(f32)) Complex(f32) {
	19	const x = z.re;
	20	const y = z.im;
	21
	22	if (x == 0 and y == 0) {
	23	return Complex(f32).new(0, y);
	24	}
	25	if (math.isInf(y)) {
	26	return Complex(f32).new(math.inf(f32), y);
	27	}
	28	if (math.isNan(x)) {
	29	// raise invalid if y is not nan
	30	const t = (y - y) / (y - y);
	31	return Complex(f32).new(x, t);
	32	}
	33	if (math.isInf(x)) {
	34	// sqrt(inf + i nan) = inf + nan i
	35	// sqrt(inf + iy) = inf + i0
	36	// sqrt(-inf + i nan) = nan +- inf i
	37	// sqrt(-inf + iy) = 0 + inf i
	38	if (math.signbit(x)) {
	39	return Complex(f32).new(math.fabs(x - y), math.copysign(f32, x, y));
	40	} else {
	41	return Complex(f32).new(x, math.copysign(f32, y - y, y));
	42	}
	43	}
	44
	45	// y = nan special case is handled fine below
	46
	47	// double-precision avoids overflow with correct rounding.
	48	const dx = f64(x);
	49	const dy = f64(y);
	50
	51	if (dx >= 0) {
	52	const t = math.sqrt((dx + math.hypot(f64, dx, dy)) * 0.5);
	53	return Complex(f32).new(f32(t), f32(dy / (2.0 * t)));
	54	} else {
	55	const t = math.sqrt((-dx + math.hypot(f64, dx, dy)) * 0.5);
	56	return Complex(f32).new(f32(math.fabs(y) / (2.0 * t)), f32(math.copysign(f64, t, y)));
	57	}
	58	}
	59
	60	fn sqrt64(z: &const Complex(f64)) Complex(f64) {
	61	// may encounter overflow for im,re >= DBL_MAX / (1 + sqrt(2))
	62	const threshold = 0x1.a827999fcef32p+1022;
	63
	64	var x = z.re;
	65	var y = z.im;
	66
	67	if (x == 0 and y == 0) {
	68	return Complex(f64).new(0, y);
	69	}
	70	if (math.isInf(y)) {
	71	return Complex(f64).new(math.inf(f64), y);
	72	}
	73	if (math.isNan(x)) {
	74	// raise invalid if y is not nan
	75	const t = (y - y) / (y - y);
	76	return Complex(f64).new(x, t);
	77	}
	78	if (math.isInf(x)) {
	79	// sqrt(inf + i nan) = inf + nan i
	80	// sqrt(inf + iy) = inf + i0
	81	// sqrt(-inf + i nan) = nan +- inf i
	82	// sqrt(-inf + iy) = 0 + inf i
	83	if (math.signbit(x)) {
	84	return Complex(f64).new(math.fabs(x - y), math.copysign(f64, x, y));
	85	} else {
	86	return Complex(f64).new(x, math.copysign(f64, y - y, y));
	87	}
	88	}
	89
	90	// y = nan special case is handled fine below
	91
	92	// scale to avoid overflow
	93	var scale = false;
	94	if (math.fabs(x) >= threshold or math.fabs(y) >= threshold) {
	95	x *= 0.25;
	96	y *= 0.25;
	97	scale = true;
	98	}
	99
	100	var result: Complex(f64) = undefined;
	101	if (x >= 0) {
	102	const t = math.sqrt((x + math.hypot(f64, x, y)) * 0.5);
	103	result = Complex(f64).new(t, y / (2.0 * t));
	104	} else {
	105	const t = math.sqrt((-x + math.hypot(f64, x, y)) * 0.5);
	106	result = Complex(f64).new(math.fabs(y) / (2.0 * t), math.copysign(f64, t, y));
	107	}
	108
	109	if (scale) {
	110	result.re *= 2;
	111	result.im *= 2;
	112	}
	113
	114	return result;
	115	}
	116
	117	const epsilon = 0.0001;
	118
	119	test "complex.csqrt32" {
	120	const a = Complex(f32).new(5, 3);
	121	const c = sqrt(a);
	122
	123	debug.assert(math.approxEq(f32, c.re, 2.327117, epsilon));
	124	debug.assert(math.approxEq(f32, c.im, 0.644574, epsilon));
	125	}
	126
	127	test "complex.csqrt64" {
	128	const a = Complex(f64).new(5, 3);
	129	const c = sqrt(a);
	130
	131	debug.assert(math.approxEq(f64, c.re, 2.3271175190399496, epsilon));
	132	debug.assert(math.approxEq(f64, c.im, 0.6445742373246469, epsilon));
	133	}

std/math/complex/tan.zig created+22

...	...	@@ -0,0 +1,22 @@
	1	const std = @import("../../index.zig");
	2	const debug = std.debug;
	3	const math = std.math;
	4	const cmath = math.complex;
	5	const Complex = cmath.Complex;
	6
	7	pub fn tan(z: var) Complex(@typeOf(z.re)) {
	8	const T = @typeOf(z.re);
	9	const q = Complex(T).new(-z.im, z.re);
	10	const r = cmath.tanh(q);
	11	return Complex(T).new(r.im, -r.re);
	12	}
	13
	14	const epsilon = 0.0001;
	15
	16	test "complex.ctan" {
	17	const a = Complex(f32).new(5, 3);
	18	const c = tan(a);
	19
	20	debug.assert(math.approxEq(f32, c.re, -0.002708233, epsilon));
	21	debug.assert(math.approxEq(f32, c.im, 1.004165, epsilon));
	22	}

std/math/complex/tanh.zig created+111

...	...	@@ -0,0 +1,111 @@
	1	const std = @import("../../index.zig");
	2	const debug = std.debug;
	3	const math = std.math;
	4	const cmath = math.complex;
	5	const Complex = cmath.Complex;
	6
	7	pub fn tanh(z: var) Complex(@typeOf(z.re)) {
	8	const T = @typeOf(z.re);
	9	return switch (T) {
	10	f32 => tanh32(z),
	11	f64 => tanh64(z),
	12	else => @compileError("tan not implemented for " ++ @typeName(z)),
	13	};
	14	}
	15
	16	fn tanh32(z: &const Complex(f32)) Complex(f32) {
	17	const x = z.re;
	18	const y = z.im;
	19
	20	const hx = @bitCast(u32, x);
	21	const ix = hx & 0x7fffffff;
	22
	23	if (ix >= 0x7f800000) {
	24	if (ix & 0x7fffff != 0) {
	25	const r = if (y == 0) y else x * y;
	26	return Complex(f32).new(x, r);
	27	}
	28	const xx = @bitCast(f32, hx - 0x40000000);
	29	const r = if (math.isInf(y)) y else math.sin(y) * math.cos(y);
	30	return Complex(f32).new(xx, math.copysign(f32, 0, r));
	31	}
	32
	33	if (!math.isFinite(y)) {
	34	const r = if (ix != 0) y - y else x;
	35	return Complex(f32).new(r, y - y);
	36	}
	37
	38	// x >= 11
	39	if (ix >= 0x41300000) {
	40	const exp_mx = math.exp(-math.fabs(x));
	41	return Complex(f32).new(math.copysign(f32, 1, x), 4 * math.sin(y) * math.cos(y) * exp_mx * exp_mx);
	42	}
	43
	44	// Kahan's algorithm
	45	const t = math.tan(y);
	46	const beta = 1.0 + t * t;
	47	const s = math.sinh(x);
	48	const rho = math.sqrt(1 + s * s);
	49	const den = 1 + beta * s * s;
	50
	51	return Complex(f32).new((beta * rho * s) / den, t / den);
	52	}
	53
	54	fn tanh64(z: &const Complex(f64)) Complex(f64) {
	55	const x = z.re;
	56	const y = z.im;
	57
	58	const fx = @bitCast(u64, x);
	59	const hx = u32(fx >> 32);
	60	const lx = @truncate(u32, fx);
	61	const ix = hx & 0x7fffffff;
	62
	63	if (ix >= 0x7ff00000) {
	64	if ((ix & 0x7fffff) \| lx != 0) {
	65	const r = if (y == 0) y else x * y;
	66	return Complex(f64).new(x, r);
	67	}
	68
	69	const xx = @bitCast(f64, (u64(hx - 0x40000000) << 32) \| lx);
	70	const r = if (math.isInf(y)) y else math.sin(y) * math.cos(y);
	71	return Complex(f64).new(xx, math.copysign(f64, 0, r));
	72	}
	73
	74	if (!math.isFinite(y)) {
	75	const r = if (ix != 0) y - y else x;
	76	return Complex(f64).new(r, y - y);
	77	}
	78
	79	// x >= 22
	80	if (ix >= 0x40360000) {
	81	const exp_mx = math.exp(-math.fabs(x));
	82	return Complex(f64).new(math.copysign(f64, 1, x), 4 * math.sin(y) * math.cos(y) * exp_mx * exp_mx);
	83	}
	84
	85	// Kahan's algorithm
	86	const t = math.tan(y);
	87	const beta = 1.0 + t * t;
	88	const s = math.sinh(x);
	89	const rho = math.sqrt(1 + s * s);
	90	const den = 1 + beta * s * s;
	91
	92	return Complex(f64).new((beta * rho * s) / den, t / den);
	93	}
	94
	95	const epsilon = 0.0001;
	96
	97	test "complex.ctanh32" {
	98	const a = Complex(f32).new(5, 3);
	99	const c = tanh(a);
	100
	101	debug.assert(math.approxEq(f32, c.re, 0.999913, epsilon));
	102	debug.assert(math.approxEq(f32, c.im, -0.000025, epsilon));
	103	}
	104
	105	test "complex.ctanh64" {
	106	const a = Complex(f64).new(5, 3);
	107	const c = tanh(a);
	108
	109	debug.assert(math.approxEq(f64, c.re, 0.999913, epsilon));
	110	debug.assert(math.approxEq(f64, c.im, -0.000025, epsilon));
	111	}

std/math/exp.zig+5

...	...	@@ -6,6 +6,7 @@
6	6	const std = @import("../index.zig");
7	7	const math = std.math;
8	8	const assert = std.debug.assert;
	9	const builtin = @import("builtin");
9	10
10	11	pub fn exp(x: var) @typeOf(x) {
11	12	const T = @typeOf(x);
...	...	@@ -17,6 +18,8 @@ pub fn exp(x: var) @typeOf(x) {
17	18	}
18	19
19	20	fn exp32(x_: f32) f32 {
	21	@setFloatMode(this, builtin.FloatMode.Strict);
	22
20	23	const half = []f32 { 0.5, -0.5 };
21	24	const ln2hi = 6.9314575195e-1;
22	25	const ln2lo = 1.4286067653e-6;
...	...	@@ -94,6 +97,8 @@ fn exp32(x_: f32) f32 {
94	97	}
95	98
96	99	fn exp64(x_: f64) f64 {
	100	@setFloatMode(this, builtin.FloatMode.Strict);
	101
97	102	const half = []const f64 { 0.5, -0.5 };
98	103	const ln2hi: f64 = 6.93147180369123816490e-01;
99	104	const ln2lo: f64 = 1.90821492927058770002e-10;

std/math/index.zig+31

...	...	@@ -129,6 +129,9 @@ pub const cos = @import("cos.zig").cos;
129	129	pub const sin = @import("sin.zig").sin;
130	130	pub const tan = @import("tan.zig").tan;
131	131
	132	pub const complex = @import("complex/index.zig");
	133	pub const Complex = complex.Complex;
	134
132	135	test "math" {
133	136	_ = @import("nan.zig");
134	137	_ = @import("isnan.zig");
...	...	@@ -172,6 +175,8 @@ test "math" {
172	175	_ = @import("sin.zig");
173	176	_ = @import("cos.zig");
174	177	_ = @import("tan.zig");
	178
	179	_ = @import("complex/index.zig");
175	180	}
176	181
177	182
...	...	@@ -553,6 +558,32 @@ test "math.floorPowerOfTwo" {
553	558	comptime testFloorPowerOfTwo();
554	559	}
555	560
	561	pub fn log2_int(comptime T: type, x: T) Log2Int(T) {
	562	assert(x != 0);
	563	return Log2Int(T)(T.bit_count - 1 - @clz(x));
	564	}
	565
	566	pub fn log2_int_ceil(comptime T: type, x: T) Log2Int(T) {
	567	assert(x != 0);
	568	const log2_val = log2_int(T, x);
	569	if (T(1) << log2_val == x)
	570	return log2_val;
	571	return log2_val + 1;
	572	}
	573
	574	test "std.math.log2_int_ceil" {
	575	assert(log2_int_ceil(u32, 1) == 0);
	576	assert(log2_int_ceil(u32, 2) == 1);
	577	assert(log2_int_ceil(u32, 3) == 2);
	578	assert(log2_int_ceil(u32, 4) == 2);
	579	assert(log2_int_ceil(u32, 5) == 3);
	580	assert(log2_int_ceil(u32, 6) == 3);
	581	assert(log2_int_ceil(u32, 7) == 3);
	582	assert(log2_int_ceil(u32, 8) == 3);
	583	assert(log2_int_ceil(u32, 9) == 4);
	584	assert(log2_int_ceil(u32, 10) == 4);
	585	}
	586
556	587	fn testFloorPowerOfTwo() void {
557	588	assert(floorPowerOfTwo(u32, 63) == 32);
558	589	assert(floorPowerOfTwo(u32, 64) == 64);

std/math/ln.zig+2

...	...	@@ -89,6 +89,8 @@ pub fn ln_32(x_: f32) f32 {
89	89	}
90	90
91	91	pub fn ln_64(x_: f64) f64 {
	92	@setFloatMode(this, @import("builtin").FloatMode.Strict);
	93
92	94	const ln2_hi: f64 = 6.93147180369123816490e-01;
93	95	const ln2_lo: f64 = 1.90821492927058770002e-10;
94	96	const Lg1: f64 = 6.666666666666735130e-01;

std/math/log2.zig+1-6

...	...	@@ -31,17 +31,12 @@ pub fn log2(x: var) @typeOf(x) {
31	31	return result;
32	32	},
33	33	TypeId.Int => {
34		return log2_int(T, x);
	34	return math.log2_int(T, x);
35	35	},
36	36	else => @compileError("log2 not implemented for " ++ @typeName(T)),
37	37	}
38	38	}
39	39
40		pub fn log2_int(comptime T: type, x: T) T {
41		assert(x != 0);
42		return T.bit_count - 1 - T(@clz(x));
43		}
44
45	40	pub fn log2_32(x_: f32) f32 {
46	41	const ivln2hi: f32 = 1.4428710938e+00;
47	42	const ivln2lo: f32 = -1.7605285393e-04;

std/math/sqrt.zig+33-262

...	...	@@ -14,26 +14,8 @@ const TypeId = builtin.TypeId;
14	14	pub fn sqrt(x: var) (if (@typeId(@typeOf(x)) == TypeId.Int) @IntType(false, @typeOf(x).bit_count / 2) else @typeOf(x)) {
15	15	const T = @typeOf(x);
16	16	switch (@typeId(T)) {
17		TypeId.FloatLiteral => {
18		return T(sqrt64(x));
19		},
20		TypeId.Float => {
21		switch (T) {
22		f32 => {
23		switch (builtin.arch) {
24		builtin.Arch.x86_64 => return @import("x86_64/sqrt.zig").sqrt32(x),
25		else => return sqrt32(x),
26		}
27		},
28		f64 => {
29		switch (builtin.arch) {
30		builtin.Arch.x86_64 => return @import("x86_64/sqrt.zig").sqrt64(x),
31		else => return sqrt64(x),
32		}
33		},
34		else => @compileError("sqrt not implemented for " ++ @typeName(T)),
35		}
36		},
	17	TypeId.FloatLiteral => return T(@sqrt(f64, x)), // TODO upgrade to f128
	18	TypeId.Float => return @sqrt(T, x),
37	19	TypeId.IntLiteral => comptime {
38	20	if (x > @maxValue(u128)) {
39	21	@compileError("sqrt not implemented for comptime_int greater than 128 bits");
...	...	@@ -43,269 +25,58 @@ pub fn sqrt(x: var) (if (@typeId(@typeOf(x)) == TypeId.Int) @IntType(false, @typ
43	25	}
44	26	return T(sqrt_int(u128, x));
45	27	},
46		TypeId.Int => {
47		return sqrt_int(T, x);
48		},
	28	TypeId.Int => return sqrt_int(T, x),
49	29	else => @compileError("sqrt not implemented for " ++ @typeName(T)),
50	30	}
51	31	}
52	32
53		fn sqrt32(x: f32) f32 {
54		const tiny: f32 = 1.0e-30;
55		const sign: i32 = @bitCast(i32, u32(0x80000000));
56		var ix: i32 = @bitCast(i32, x);
57
58		if ((ix & 0x7F800000) == 0x7F800000) {
59		return x * x + x; // sqrt(nan) = nan, sqrt(+inf) = +inf, sqrt(-inf) = snan
60		}
61
62		// zero
63		if (ix <= 0) {
64		if (ix & ~sign == 0) {
65		return x; // sqrt (+-0) = +-0
66		}
67		if (ix < 0) {
68		return math.snan(f32);
69		}
70		}
71
72		// normalize
73		var m = ix >> 23;
74		if (m == 0) {
75		// subnormal
76		var i: i32 = 0;
77		while (ix & 0x00800000 == 0) : (i += 1) {
78		ix <<= 1;
79		}
80		m -= i - 1;
81		}
82
83		m -= 127; // unbias exponent
84		ix = (ix & 0x007FFFFF) \| 0x00800000;
85
86		if (m & 1 != 0) { // odd m, double x to even
87		ix += ix;
88		}
89
90		m >>= 1; // m = [m / 2]
91
92		// sqrt(x) bit by bit
93		ix += ix;
94		var q: i32 = 0; // q = sqrt(x)
95		var s: i32 = 0;
96		var r: i32 = 0x01000000; // r = moving bit right -> left
97
98		while (r != 0) {
99		const t = s + r;
100		if (t <= ix) {
101		s = t + r;
102		ix -= t;
103		q += r;
104		}
105		ix += ix;
106		r >>= 1;
107		}
108
109		// floating add to find rounding direction
110		if (ix != 0) {
111		var z = 1.0 - tiny; // inexact
112		if (z >= 1.0) {
113		z = 1.0 + tiny;
114		if (z > 1.0) {
115		q += 2;
116		} else {
117		if (q & 1 != 0) {
118		q += 1;
119		}
120		}
121		}
122		}
123
124		ix = (q >> 1) + 0x3f000000;
125		ix += m << 23;
126		return @bitCast(f32, ix);
127		}
128
129		// NOTE: The original code is full of implicit signed -> unsigned assumptions and u32 wraparound
130		// behaviour. Most intermediate i32 values are changed to u32 where appropriate but there are
131		// potentially some edge cases remaining that are not handled in the same way.
132		fn sqrt64(x: f64) f64 {
133		const tiny: f64 = 1.0e-300;
134		const sign: u32 = 0x80000000;
135		const u = @bitCast(u64, x);
136
137		var ix0 = u32(u >> 32);
138		var ix1 = u32(u & 0xFFFFFFFF);
139
140		// sqrt(nan) = nan, sqrt(+inf) = +inf, sqrt(-inf) = nan
141		if (ix0 & 0x7FF00000 == 0x7FF00000) {
142		return x * x + x;
143		}
144
145		// sqrt(+-0) = +-0
146		if (x == 0.0) {
147		return x;
148		}
149		// sqrt(-ve) = snan
150		if (ix0 & sign != 0) {
151		return math.snan(f64);
152		}
153
154		// normalize x
155		var m = i32(ix0 >> 20);
156		if (m == 0) {
157		// subnormal
158		while (ix0 == 0) {
159		m -= 21;
160		ix0 \|= ix1 >> 11;
161		ix1 <<= 21;
162		}
163
164		// subnormal
165		var i: u32 = 0;
166		while (ix0 & 0x00100000 == 0) : (i += 1) {
167		ix0 <<= 1;
168		}
169		m -= i32(i) - 1;
170		ix0 \|= ix1 >> u5(32 - i);
171		ix1 <<= u5(i);
172		}
173
174		// unbias exponent
175		m -= 1023;
176		ix0 = (ix0 & 0x000FFFFF) \| 0x00100000;
177		if (m & 1 != 0) {
178		ix0 += ix0 + (ix1 >> 31);
179		ix1 = ix1 +% ix1;
180		}
181		m >>= 1;
182
183		// sqrt(x) bit by bit
184		ix0 += ix0 + (ix1 >> 31);
185		ix1 = ix1 +% ix1;
186
187		var q: u32 = 0;
188		var q1: u32 = 0;
189		var s0: u32 = 0;
190		var s1: u32 = 0;
191		var r: u32 = 0x00200000;
192		var t: u32 = undefined;
193		var t1: u32 = undefined;
194
195		while (r != 0) {
196		t = s0 +% r;
197		if (t <= ix0) {
198		s0 = t + r;
199		ix0 -= t;
200		q += r;
201		}
202		ix0 = ix0 +% ix0 +% (ix1 >> 31);
203		ix1 = ix1 +% ix1;
204		r >>= 1;
205		}
206
207		r = sign;
208		while (r != 0) {
209		t = s1 +% r;
210		t = s0;
211		if (t < ix0 or (t == ix0 and t1 <= ix1)) {
212		s1 = t1 +% r;
213		if (t1 & sign == sign and s1 & sign == 0) {
214		s0 += 1;
215		}
216		ix0 -= t;
217		if (ix1 < t1) {
218		ix0 -= 1;
219		}
220		ix1 = ix1 -% t1;
221		q1 += r;
222		}
223		ix0 = ix0 +% ix0 +% (ix1 >> 31);
224		ix1 = ix1 +% ix1;
225		r >>= 1;
226		}
227
228		// rounding direction
229		if (ix0 \| ix1 != 0) {
230		var z = 1.0 - tiny; // raise inexact
231		if (z >= 1.0) {
232		z = 1.0 + tiny;
233		if (q1 == 0xFFFFFFFF) {
234		q1 = 0;
235		q += 1;
236		} else if (z > 1.0) {
237		if (q1 == 0xFFFFFFFE) {
238		q += 1;
239		}
240		q1 += 2;
241		} else {
242		q1 += q1 & 1;
243		}
244		}
245		}
246
247		ix0 = (q >> 1) + 0x3FE00000;
248		ix1 = q1 >> 1;
249		if (q & 1 != 0) {
250		ix1 \|= 0x80000000;
251		}
252
253		// NOTE: musl here appears to rely on signed twos-complement wraparound. +% has the same
254		// behaviour at least.
255		var iix0 = i32(ix0);
256		iix0 = iix0 +% (m << 20);
257
258		const uz = (u64(iix0) << 32) \| ix1;
259		return @bitCast(f64, uz);
260		}
261
262	33	test "math.sqrt" {
263		assert(sqrt(f32(0.0)) == sqrt32(0.0));
264		assert(sqrt(f64(0.0)) == sqrt64(0.0));
	34	assert(sqrt(f32(0.0)) == @sqrt(f32, 0.0));
	35	assert(sqrt(f64(0.0)) == @sqrt(f64, 0.0));
265	36	}
266	37
267	38	test "math.sqrt32" {
268	39	const epsilon = 0.000001;
269	40
270		assert(sqrt32(0.0) == 0.0);
271		assert(math.approxEq(f32, sqrt32(2.0), 1.414214, epsilon));
272		assert(math.approxEq(f32, sqrt32(3.6), 1.897367, epsilon));
273		assert(sqrt32(4.0) == 2.0);
274		assert(math.approxEq(f32, sqrt32(7.539840), 2.745877, epsilon));
275		assert(math.approxEq(f32, sqrt32(19.230934), 4.385309, epsilon));
276		assert(sqrt32(64.0) == 8.0);
277		assert(math.approxEq(f32, sqrt32(64.1), 8.006248, epsilon));
278		assert(math.approxEq(f32, sqrt32(8942.230469), 94.563370, epsilon));
	41	assert(@sqrt(f32, 0.0) == 0.0);
	42	assert(math.approxEq(f32, @sqrt(f32, 2.0), 1.414214, epsilon));
	43	assert(math.approxEq(f32, @sqrt(f32, 3.6), 1.897367, epsilon));
	44	assert(@sqrt(f32, 4.0) == 2.0);
	45	assert(math.approxEq(f32, @sqrt(f32, 7.539840), 2.745877, epsilon));
	46	assert(math.approxEq(f32, @sqrt(f32, 19.230934), 4.385309, epsilon));
	47	assert(@sqrt(f32, 64.0) == 8.0);
	48	assert(math.approxEq(f32, @sqrt(f32, 64.1), 8.006248, epsilon));
	49	assert(math.approxEq(f32, @sqrt(f32, 8942.230469), 94.563370, epsilon));
279	50	}
280	51
281	52	test "math.sqrt64" {
282	53	const epsilon = 0.000001;
283	54
284		assert(sqrt64(0.0) == 0.0);
285		assert(math.approxEq(f64, sqrt64(2.0), 1.414214, epsilon));
286		assert(math.approxEq(f64, sqrt64(3.6), 1.897367, epsilon));
287		assert(sqrt64(4.0) == 2.0);
288		assert(math.approxEq(f64, sqrt64(7.539840), 2.745877, epsilon));
289		assert(math.approxEq(f64, sqrt64(19.230934), 4.385309, epsilon));
290		assert(sqrt64(64.0) == 8.0);
291		assert(math.approxEq(f64, sqrt64(64.1), 8.006248, epsilon));
292		assert(math.approxEq(f64, sqrt64(8942.230469), 94.563367, epsilon));
	55	assert(@sqrt(f64, 0.0) == 0.0);
	56	assert(math.approxEq(f64, @sqrt(f64, 2.0), 1.414214, epsilon));
	57	assert(math.approxEq(f64, @sqrt(f64, 3.6), 1.897367, epsilon));
	58	assert(@sqrt(f64, 4.0) == 2.0);
	59	assert(math.approxEq(f64, @sqrt(f64, 7.539840), 2.745877, epsilon));
	60	assert(math.approxEq(f64, @sqrt(f64, 19.230934), 4.385309, epsilon));
	61	assert(@sqrt(f64, 64.0) == 8.0);
	62	assert(math.approxEq(f64, @sqrt(f64, 64.1), 8.006248, epsilon));
	63	assert(math.approxEq(f64, @sqrt(f64, 8942.230469), 94.563367, epsilon));
293	64	}
294	65
295	66	test "math.sqrt32.special" {
296		assert(math.isPositiveInf(sqrt32(math.inf(f32))));
297		assert(sqrt32(0.0) == 0.0);
298		assert(sqrt32(-0.0) == -0.0);
299		assert(math.isNan(sqrt32(-1.0)));
300		assert(math.isNan(sqrt32(math.nan(f32))));
	67	assert(math.isPositiveInf(@sqrt(f32, math.inf(f32))));
	68	assert(@sqrt(f32, 0.0) == 0.0);
	69	assert(@sqrt(f32, -0.0) == -0.0);
	70	assert(math.isNan(@sqrt(f32, -1.0)));
	71	assert(math.isNan(@sqrt(f32, math.nan(f32))));
301	72	}
302	73
303	74	test "math.sqrt64.special" {
304		assert(math.isPositiveInf(sqrt64(math.inf(f64))));
305		assert(sqrt64(0.0) == 0.0);
306		assert(sqrt64(-0.0) == -0.0);
307		assert(math.isNan(sqrt64(-1.0)));
308		assert(math.isNan(sqrt64(math.nan(f64))));
	75	assert(math.isPositiveInf(@sqrt(f64, math.inf(f64))));
	76	assert(@sqrt(f64, 0.0) == 0.0);
	77	assert(@sqrt(f64, -0.0) == -0.0);
	78	assert(math.isNan(@sqrt(f64, -1.0)));
	79	assert(math.isNan(@sqrt(f64, math.nan(f64))));
309	80	}
310	81
311	82	fn sqrt_int(comptime T: type, value: T) @IntType(false, T.bit_count / 2) {

std/math/x86_64/sqrt.zig deleted-15

...	...	@@ -1,15 +0,0 @@
1		pub fn sqrt32(x: f32) f32 {
2		return asm (
3		\\sqrtss %%xmm0, %%xmm0
4		: [ret] "={xmm0}" (-> f32)
5		: [x] "{xmm0}" (x)
6		);
7		}
8
9		pub fn sqrt64(x: f64) f64 {
10		return asm (
11		\\sqrtsd %%xmm0, %%xmm0
12		: [ret] "={xmm0}" (-> f64)
13		: [x] "{xmm0}" (x)
14		);
15		}

std/mem.zig+129-4

...	...	@@ -3,6 +3,7 @@ const debug = std.debug;
3	3	const assert = debug.assert;
4	4	const math = std.math;
5	5	const builtin = @import("builtin");
	6	const mem = this;
6	7
7	8	pub const Allocator = struct {
8	9	const Error = error {OutOfMemory};
...	...	@@ -10,6 +11,8 @@ pub const Allocator = struct {
10	11	/// Allocate byte_count bytes and return them in a slice, with the
11	12	/// slice's pointer aligned at least to alignment bytes.
12	13	/// The returned newly allocated memory is undefined.
	14	/// `alignment` is guaranteed to be >= 1
	15	/// `alignment` is guaranteed to be a power of 2
13	16	allocFn: fn (self: &Allocator, byte_count: usize, alignment: u29) Error![]u8,
14	17
15	18	/// If `new_byte_count > old_mem.len`:
...	...	@@ -17,20 +20,37 @@ pub const Allocator = struct {
17	20	/// * alignment >= alignment of old_mem.ptr
18	21	///
19	22	/// If `new_byte_count <= old_mem.len`:
20		/// * this function must return successfully.
	23	/// * this function must return successfully.
21	24	/// * alignment <= alignment of old_mem.ptr
22	25	///
23	26	/// The returned newly allocated memory is undefined.
	27	/// `alignment` is guaranteed to be >= 1
	28	/// `alignment` is guaranteed to be a power of 2
24	29	reallocFn: fn (self: &Allocator, old_mem: []u8, new_byte_count: usize, alignment: u29) Error![]u8,
25	30
26	31	/// Guaranteed: `old_mem.len` is the same as what was returned from `allocFn` or `reallocFn`
27	32	freeFn: fn (self: &Allocator, old_mem: []u8) void,
28	33
29	34	fn create(self: &Allocator, comptime T: type) !&T {
	35	if (@sizeOf(T) == 0) return &{};
30	36	const slice = try self.alloc(T, 1);
31	37	return &slice[0];
32	38	}
33	39
	40	// TODO once #733 is solved, this will replace create
	41	fn construct(self: &Allocator, init: var) t: {
	42	// TODO this is a workaround for type getting parsed as Error!&const T
	43	const T = @typeOf(init).Child;
	44	break :t Error!&T;
	45	} {
	46	const T = @typeOf(init).Child;
	47	if (@sizeOf(T) == 0) return &{};
	48	const slice = try self.alloc(T, 1);
	49	const ptr = &slice[0];
	50	ptr = init;
	51	return ptr;
	52	}
	53
34	54	fn destroy(self: &Allocator, ptr: var) void {
35	55	self.free(ptr[0..1]);
36	56	}
...	...	@@ -48,7 +68,7 @@ pub const Allocator = struct {
48	68	const byte_count = math.mul(usize, @sizeOf(T), n) catch return Error.OutOfMemory;
49	69	const byte_slice = try self.allocFn(self, byte_count, alignment);
50	70	assert(byte_slice.len == byte_count);
51		// This loop should get optimized out in ReleaseFast mode
	71	// This loop gets optimized out in ReleaseFast mode
52	72	for (byte_slice) \|*byte\| {
53	73	*byte = undefined;
54	74	}
...	...	@@ -75,7 +95,7 @@ pub const Allocator = struct {
75	95	const byte_slice = try self.reallocFn(self, old_byte_slice, byte_count, alignment);
76	96	assert(byte_slice.len == byte_count);
77	97	if (n > old_mem.len) {
78		// This loop should get optimized out in ReleaseFast mode
	98	// This loop gets optimized out in ReleaseFast mode
79	99	for (byte_slice[old_byte_slice.len..]) \|*byte\| {
80	100	*byte = undefined;
81	101	}
...	...	@@ -169,6 +189,20 @@ pub fn dupe(allocator: &Allocator, comptime T: type, m: []const T) ![]T {
169	189	return new_buf;
170	190	}
171	191
	192	/// Remove values from the beginning of a slice.
	193	pub fn trimLeft(comptime T: type, slice: []const T, values_to_strip: []const T) []const T {
	194	var begin: usize = 0;
	195	while (begin < slice.len and indexOfScalar(T, values_to_strip, slice[begin]) != null) : (begin += 1) {}
	196	return slice[begin..];
	197	}
	198
	199	/// Remove values from the end of a slice.
	200	pub fn trimRight(comptime T: type, slice: []const T, values_to_strip: []const T) []const T {
	201	var end: usize = slice.len;
	202	while (end > 0 and indexOfScalar(T, values_to_strip, slice[end - 1]) != null) : (end -= 1) {}
	203	return slice[0..end];
	204	}
	205
172	206	/// Remove values from the beginning and end of a slice.
173	207	pub fn trim(comptime T: type, slice: []const T, values_to_strip: []const T) []const T {
174	208	var begin: usize = 0;
...	...	@@ -179,6 +213,8 @@ pub fn trim(comptime T: type, slice: []const T, values_to_strip: []const T) []co
179	213	}
180	214
181	215	test "mem.trim" {
	216	assert(eql(u8, trimLeft(u8, " foo\n ", " \n"), "foo\n "));
	217	assert(eql(u8, trimRight(u8, " foo\n ", " \n"), " foo"));
182	218	assert(eql(u8, trim(u8, " foo\n ", " \n"), "foo"));
183	219	assert(eql(u8, trim(u8, "foo", " \n"), "foo"));
184	220	}
...	...	@@ -188,6 +224,17 @@ pub fn indexOfScalar(comptime T: type, slice: []const T, value: T) ?usize {
188	224	return indexOfScalarPos(T, slice, 0, value);
189	225	}
190	226
	227	/// Linear search for the last index of a scalar value inside a slice.
	228	pub fn lastIndexOfScalar(comptime T: type, slice: []const T, value: T) ?usize {
	229	var i: usize = slice.len;
	230	while (i != 0) {
	231	i -= 1;
	232	if (slice[i] == value)
	233	return i;
	234	}
	235	return null;
	236	}
	237
191	238	pub fn indexOfScalarPos(comptime T: type, slice: []const T, start_index: usize, value: T) ?usize {
192	239	var i: usize = start_index;
193	240	while (i < slice.len) : (i += 1) {
...	...	@@ -201,6 +248,18 @@ pub fn indexOfAny(comptime T: type, slice: []const T, values: []const T) ?usize
201	248	return indexOfAnyPos(T, slice, 0, values);
202	249	}
203	250
	251	pub fn lastIndexOfAny(comptime T: type, slice: []const T, values: []const T) ?usize {
	252	var i: usize = slice.len;
	253	while (i != 0) {
	254	i -= 1;
	255	for (values) \|value\| {
	256	if (slice[i] == value)
	257	return i;
	258	}
	259	}
	260	return null;
	261	}
	262
204	263	pub fn indexOfAnyPos(comptime T: type, slice: []const T, start_index: usize, values: []const T) ?usize {
205	264	var i: usize = start_index;
206	265	while (i < slice.len) : (i += 1) {
...	...	@@ -216,6 +275,22 @@ pub fn indexOf(comptime T: type, haystack: []const T, needle: []const T) ?usize
216	275	return indexOfPos(T, haystack, 0, needle);
217	276	}
218	277
	278	/// Find the index in a slice of a sub-slice, searching from the end backwards.
	279	/// To start looking at a different index, slice the haystack first.
	280	/// TODO is there even a better algorithm for this?
	281	pub fn lastIndexOf(comptime T: type, haystack: []const T, needle: []const T) ?usize {
	282	if (needle.len > haystack.len)
	283	return null;
	284
	285	var i: usize = haystack.len - needle.len;
	286	while (true) : (i -= 1) {
	287	if (mem.eql(T, haystack[i..i+needle.len], needle))
	288	return i;
	289	if (i == 0)
	290	return null;
	291	}
	292	}
	293
219	294	// TODO boyer-moore algorithm
220	295	pub fn indexOfPos(comptime T: type, haystack: []const T, start_index: usize, needle: []const T) ?usize {
221	296	if (needle.len > haystack.len)
...	...	@@ -232,9 +307,19 @@ pub fn indexOfPos(comptime T: type, haystack: []const T, start_index: usize, nee
232	307
233	308	test "mem.indexOf" {
234	309	assert(??indexOf(u8, "one two three four", "four") == 14);
	310	assert(??lastIndexOf(u8, "one two three two four", "two") == 14);
235	311	assert(indexOf(u8, "one two three four", "gour") == null);
	312	assert(lastIndexOf(u8, "one two three four", "gour") == null);
236	313	assert(??indexOf(u8, "foo", "foo") == 0);
	314	assert(??lastIndexOf(u8, "foo", "foo") == 0);
237	315	assert(indexOf(u8, "foo", "fool") == null);
	316	assert(lastIndexOf(u8, "foo", "lfoo") == null);
	317	assert(lastIndexOf(u8, "foo", "fool") == null);
	318
	319	assert(??indexOf(u8, "foo foo", "foo") == 0);
	320	assert(??lastIndexOf(u8, "foo foo", "foo") == 4);
	321	assert(??lastIndexOfAny(u8, "boo, cat", "abo") == 6);
	322	assert(??lastIndexOfScalar(u8, "boo", 'o') == 2);
238	323	}
239	324
240	325	/// Reads an integer from memory with size equal to bytes.len.
...	...	@@ -354,9 +439,24 @@ pub fn startsWith(comptime T: type, haystack: []const T, needle: []const T) bool
354	439	return if (needle.len > haystack.len) false else eql(T, haystack[0 .. needle.len], needle);
355	440	}
356	441
	442	test "mem.startsWith" {
	443	assert(startsWith(u8, "Bob", "Bo"));
	444	assert(!startsWith(u8, "Needle in haystack", "haystack"));
	445	}
	446
	447	pub fn endsWith(comptime T: type, haystack: []const T, needle: []const T) bool {
	448	return if (needle.len > haystack.len) false else eql(T, haystack[haystack.len - needle.len ..], needle);
	449	}
	450
	451
	452	test "mem.endsWith" {
	453	assert(endsWith(u8, "Needle in haystack", "haystack"));
	454	assert(!endsWith(u8, "Bob", "Bo"));
	455	}
	456
357	457	pub const SplitIterator = struct {
358	458	buffer: []const u8,
359		split_bytes: []const u8,
	459	split_bytes: []const u8,
360	460	index: usize,
361	461
362	462	pub fn next(self: &SplitIterator) ?[]const u8 {
...	...	@@ -550,3 +650,28 @@ test "std.mem.rotate" {
550	650
551	651	assert(eql(i32, arr, []i32{ 1, 2, 4, 5, 3 }));
552	652	}
	653
	654	// TODO: When https://github.com/zig-lang/zig/issues/649 is solved these can be done by
	655	// endian-casting the pointer and then dereferencing
	656
	657	pub fn endianSwapIfLe(comptime T: type, x: T) T {
	658	return endianSwapIf(builtin.Endian.Little, T, x);
	659	}
	660
	661	pub fn endianSwapIfBe(comptime T: type, x: T) T {
	662	return endianSwapIf(builtin.Endian.Big, T, x);
	663	}
	664
	665	pub fn endianSwapIf(endian: builtin.Endian, comptime T: type, x: T) T {
	666	return if (builtin.endian == endian) endianSwap(T, x) else x;
	667	}
	668
	669	pub fn endianSwap(comptime T: type, x: T) T {
	670	var buf: [@sizeOf(T)]u8 = undefined;
	671	mem.writeInt(buf[0..], x, builtin.Endian.Little);
	672	return mem.readInt(buf, T, builtin.Endian.Big);
	673	}
	674
	675	test "std.mem.endianSwap" {
	676	assert(endianSwap(u32, 0xDEADBEEF) == 0xEFBEADDE);
	677	}

std/net.zig+121-162

...	...	@@ -1,143 +1,120 @@
1	1	const std = @import("index.zig");
2		const linux = std.os.linux;
	2	const builtin = @import("builtin");
3	3	const assert = std.debug.assert;
4		const endian = std.endian;
	4	const net = this;
	5	const posix = std.os.posix;
	6	const mem = std.mem;
5	7
6		// TODO don't trust this file, it bit rotted. start over
7
8		const Connection = struct {
9		socket_fd: i32,
10
11		pub fn send(c: Connection, buf: []const u8) !usize {
12		const send_ret = linux.sendto(c.socket_fd, buf.ptr, buf.len, 0, null, 0);
13		const send_err = linux.getErrno(send_ret);
14		switch (send_err) {
15		0 => return send_ret,
16		linux.EINVAL => unreachable,
17		linux.EFAULT => unreachable,
18		linux.ECONNRESET => return error.ConnectionReset,
19		linux.EINTR => return error.SigInterrupt,
20		// TODO there are more possible errors
21		else => return error.Unexpected,
22		}
23		}
24
25		pub fn recv(c: Connection, buf: []u8) ![]u8 {
26		const recv_ret = linux.recvfrom(c.socket_fd, buf.ptr, buf.len, 0, null, null);
27		const recv_err = linux.getErrno(recv_ret);
28		switch (recv_err) {
29		0 => return buf[0..recv_ret],
30		linux.EINVAL => unreachable,
31		linux.EFAULT => unreachable,
32		linux.ENOTSOCK => return error.NotSocket,
33		linux.EINTR => return error.SigInterrupt,
34		linux.ENOMEM => return error.OutOfMemory,
35		linux.ECONNREFUSED => return error.ConnectionRefused,
36		linux.EBADF => return error.BadFd,
37		// TODO more error values
38		else => return error.Unexpected,
39		}
40		}
41
42		pub fn close(c: Connection) !void {
43		switch (linux.getErrno(linux.close(c.socket_fd))) {
44		0 => return,
45		linux.EBADF => unreachable,
46		linux.EINTR => return error.SigInterrupt,
47		linux.EIO => return error.Io,
48		else => return error.Unexpected,
49		}
50		}
	8	pub const TmpWinAddr = struct {
	9	family: u8,
	10	data: [14]u8,
51	11	};
52	12
53		const Address = struct {
54		family: u16,
55		scope_id: u32,
56		addr: [16]u8,
57		sort_key: i32,
	13	pub const OsAddress = switch (builtin.os) {
	14	builtin.Os.windows => TmpWinAddr,
	15	else => posix.sockaddr,
58	16	};
59	17
60		pub fn lookup(hostname: []const u8, out_addrs: []Address) ![]Address {
61		if (hostname.len == 0) {
62
63		unreachable; // TODO
	18	pub const Address = struct {
	19	os_addr: OsAddress,
	20
	21	pub fn initIp4(ip4: u32, port: u16) Address {
	22	return Address {
	23	.os_addr = posix.sockaddr {
	24	.in = posix.sockaddr_in {
	25	.family = posix.AF_INET,
	26	.port = std.mem.endianSwapIfLe(u16, port),
	27	.addr = ip4,
	28	.zero = []u8{0} ** 8,
	29	},
	30	},
	31	};
64	32	}
65	33
66		unreachable; // TODO
67		}
	34	pub fn initIp6(ip6: &const Ip6Addr, port: u16) Address {
	35	return Address {
	36	.family = posix.AF_INET6,
	37	.os_addr = posix.sockaddr {
	38	.in6 = posix.sockaddr_in6 {
	39	.family = posix.AF_INET6,
	40	.port = std.mem.endianSwapIfLe(u16, port),
	41	.flowinfo = 0,
	42	.addr = ip6.addr,
	43	.scope_id = ip6.scope_id,
	44	},
	45	},
	46	};
	47	}
68	48
69		pub fn connectAddr(addr: &Address, port: u16) !Connection {
70		const socket_ret = linux.socket(addr.family, linux.SOCK_STREAM, linux.PROTO_tcp);
71		const socket_err = linux.getErrno(socket_ret);
72		if (socket_err > 0) {
73		// TODO figure out possible errors from socket()
74		return error.Unexpected;
	49	pub fn initPosix(addr: &const posix.sockaddr) Address {
	50	return Address {
	51	.os_addr = *addr,
	52	};
75	53	}
76		const socket_fd = i32(socket_ret);
77	54
78		const connect_ret = if (addr.family == linux.AF_INET) x: {
79		var os_addr: linux.sockaddr_in = undefined;
80		os_addr.family = addr.family;
81		os_addr.port = endian.swapIfLe(u16, port);
82		@memcpy((&u8)(&os_addr.addr), &addr.addr[0], 4);
83		@memset(&os_addr.zero[0], 0, @sizeOf(@typeOf(os_addr.zero)));
84		break :x linux.connect(socket_fd, (&linux.sockaddr)(&os_addr), @sizeOf(linux.sockaddr_in));
85		} else if (addr.family == linux.AF_INET6) x: {
86		var os_addr: linux.sockaddr_in6 = undefined;
87		os_addr.family = addr.family;
88		os_addr.port = endian.swapIfLe(u16, port);
89		os_addr.flowinfo = 0;
90		os_addr.scope_id = addr.scope_id;
91		@memcpy(&os_addr.addr[0], &addr.addr[0], 16);
92		break :x linux.connect(socket_fd, (&linux.sockaddr)(&os_addr), @sizeOf(linux.sockaddr_in6));
93		} else {
94		unreachable;
95		};
96		const connect_err = linux.getErrno(connect_ret);
97		if (connect_err > 0) {
98		switch (connect_err) {
99		linux.ETIMEDOUT => return error.TimedOut,
100		else => {
101		// TODO figure out possible errors from connect()
102		return error.Unexpected;
	55	pub fn format(self: &const Address, out_stream: var) !void {
	56	switch (self.os_addr.in.family) {
	57	posix.AF_INET => {
	58	const native_endian_port = std.mem.endianSwapIfLe(u16, self.os_addr.in.port);
	59	const bytes = ([]const u8)((&self.os_addr.in.addr)[0..1]);
	60	try out_stream.print("{}.{}.{}.{}:{}", bytes[0], bytes[1], bytes[2], bytes[3], native_endian_port);
	61	},
	62	posix.AF_INET6 => {
	63	const native_endian_port = std.mem.endianSwapIfLe(u16, self.os_addr.in6.port);
	64	try out_stream.print("[TODO render ip6 address]:{}", native_endian_port);
103	65	},
	66	else => try out_stream.write("(unrecognized address family)"),
104	67	}
105	68	}
	69	};
106	70
107		return Connection {
108		.socket_fd = socket_fd,
109		};
110		}
111
112		pub fn connect(hostname: []const u8, port: u16) !Connection {
113		var addrs_buf: [1]Address = undefined;
114		const addrs_slice = try lookup(hostname, addrs_buf[0..]);
115		const main_addr = &addrs_slice[0];
116
117		return connectAddr(main_addr, port);
118		}
	71	pub fn parseIp4(buf: []const u8) !u32 {
	72	var result: u32 = undefined;
	73	const out_ptr = ([]u8)((&result)[0..1]);
119	74
120		pub fn parseIpLiteral(buf: []const u8) !Address {
	75	var x: u8 = 0;
	76	var index: u8 = 0;
	77	var saw_any_digits = false;
	78	for (buf) \|c\| {
	79	if (c == '.') {
	80	if (!saw_any_digits) {
	81	return error.InvalidCharacter;
	82	}
	83	if (index == 3) {
	84	return error.InvalidEnd;
	85	}
	86	out_ptr[index] = x;
	87	index += 1;
	88	x = 0;
	89	saw_any_digits = false;
	90	} else if (c >= '0' and c <= '9') {
	91	saw_any_digits = true;
	92	const digit = c - '0';
	93	if (@mulWithOverflow(u8, x, 10, &x)) {
	94	return error.Overflow;
	95	}
	96	if (@addWithOverflow(u8, x, digit, &x)) {
	97	return error.Overflow;
	98	}
	99	} else {
	100	return error.InvalidCharacter;
	101	}
	102	}
	103	if (index == 3 and saw_any_digits) {
	104	out_ptr[index] = x;
	105	return result;
	106	}
121	107
122		return error.InvalidIpLiteral;
	108	return error.Incomplete;
123	109	}
124	110
125		fn hexDigit(c: u8) u8 {
126		// TODO use switch with range
127		if ('0' <= c and c <= '9') {
128		return c - '0';
129		} else if ('A' <= c and c <= 'Z') {
130		return c - 'A' + 10;
131		} else if ('a' <= c and c <= 'z') {
132		return c - 'a' + 10;
133		} else {
134		return @maxValue(u8);
135		}
136		}
	111	pub const Ip6Addr = struct {
	112	scope_id: u32,
	113	addr: [16]u8,
	114	};
137	115
138		fn parseIp6(buf: []const u8) !Address {
139		var result: Address = undefined;
140		result.family = linux.AF_INET6;
	116	pub fn parseIp6(buf: []const u8) !Ip6Addr {
	117	var result: Ip6Addr = undefined;
141	118	result.scope_id = 0;
142	119	const ip_slice = result.addr[0..];
143	120
...	...	@@ -156,14 +133,14 @@ fn parseIp6(buf: []const u8) !Address {
156	133	return error.Overflow;
157	134	}
158	135	} else {
159		return error.InvalidChar;
	136	return error.InvalidCharacter;
160	137	}
161	138	} else if (c == ':') {
162	139	if (!saw_any_digits) {
163		return error.InvalidChar;
	140	return error.InvalidCharacter;
164	141	}
165	142	if (index == 14) {
166		return error.JunkAtEnd;
	143	return error.InvalidEnd;
167	144	}
168	145	ip_slice[index] = @truncate(u8, x >> 8);
169	146	index += 1;
...	...	@@ -174,7 +151,7 @@ fn parseIp6(buf: []const u8) !Address {
174	151	saw_any_digits = false;
175	152	} else if (c == '%') {
176	153	if (!saw_any_digits) {
177		return error.InvalidChar;
	154	return error.InvalidCharacter;
178	155	}
179	156	if (index == 14) {
180	157	ip_slice[index] = @truncate(u8, x >> 8);
...	...	@@ -185,10 +162,7 @@ fn parseIp6(buf: []const u8) !Address {
185	162	scope_id = true;
186	163	saw_any_digits = false;
187	164	} else {
188		const digit = hexDigit(c);
189		if (digit == @maxValue(u8)) {
190		return error.InvalidChar;
191		}
	165	const digit = try std.fmt.charToDigit(c, 16);
192	166	if (@mulWithOverflow(u16, x, 16, &x)) {
193	167	return error.Overflow;
194	168	}
...	...	@@ -216,42 +190,27 @@ fn parseIp6(buf: []const u8) !Address {
216	190	return error.Incomplete;
217	191	}
218	192
219		fn parseIp4(buf: []const u8) !u32 {
220		var result: u32 = undefined;
221		const out_ptr = ([]u8)((&result)[0..1]);
	193	test "std.net.parseIp4" {
	194	assert((try parseIp4("127.0.0.1")) == std.mem.endianSwapIfLe(u32, 0x7f000001));
222	195
223		var x: u8 = 0;
224		var index: u8 = 0;
225		var saw_any_digits = false;
226		for (buf) \|c\| {
227		if (c == '.') {
228		if (!saw_any_digits) {
229		return error.InvalidChar;
230		}
231		if (index == 3) {
232		return error.JunkAtEnd;
233		}
234		out_ptr[index] = x;
235		index += 1;
236		x = 0;
237		saw_any_digits = false;
238		} else if (c >= '0' and c <= '9') {
239		saw_any_digits = true;
240		const digit = c - '0';
241		if (@mulWithOverflow(u8, x, 10, &x)) {
242		return error.Overflow;
243		}
244		if (@addWithOverflow(u8, x, digit, &x)) {
245		return error.Overflow;
246		}
247		} else {
248		return error.InvalidChar;
249		}
250		}
251		if (index == 3 and saw_any_digits) {
252		out_ptr[index] = x;
253		return result;
	196	testParseIp4Fail("256.0.0.1", error.Overflow);
	197	testParseIp4Fail("x.0.0.1", error.InvalidCharacter);
	198	testParseIp4Fail("127.0.0.1.1", error.InvalidEnd);
	199	testParseIp4Fail("127.0.0.", error.Incomplete);
	200	testParseIp4Fail("100..0.1", error.InvalidCharacter);
	201	}
	202
	203	fn testParseIp4Fail(buf: []const u8, expected_err: error) void {
	204	if (parseIp4(buf)) \|_\| {
	205	@panic("expected error");
	206	} else \|e\| {
	207	assert(e == expected_err);
254	208	}
	209	}
255	210
256		return error.Incomplete;
	211	test "std.net.parseIp6" {
	212	const addr = try parseIp6("FF01:0:0:0:0:0:0:FB");
	213	assert(addr.addr[0] == 0xff);
	214	assert(addr.addr[1] == 0x01);
	215	assert(addr.addr[2] == 0x00);
257	216	}

std/os/darwin.zig+27-3

...	...	@@ -41,6 +41,11 @@ pub const SA_64REGSET = 0x0200; /// signal handler with SA_SIGINFO args with 64
41	41	pub const O_LARGEFILE = 0x0000;
42	42	pub const O_PATH = 0x0000;
43	43
	44	pub const F_OK = 0;
	45	pub const X_OK = 1;
	46	pub const W_OK = 2;
	47	pub const R_OK = 4;
	48
44	49	pub const O_RDONLY = 0x0000; /// open for reading only
45	50	pub const O_WRONLY = 0x0001; /// open for writing only
46	51	pub const O_RDWR = 0x0002; /// open for reading and writing
...	...	@@ -179,7 +184,7 @@ pub fn write(fd: i32, buf: &const u8, nbyte: usize) usize {
179	184	return errnoWrap(c.write(fd, @ptrCast(&const c_void, buf), nbyte));
180	185	}
181	186
182		pub fn mmap(address: ?&u8, length: usize, prot: usize, flags: usize, fd: i32,
	187	pub fn mmap(address: ?&u8, length: usize, prot: usize, flags: u32, fd: i32,
183	188	offset: isize) usize
184	189	{
185	190	const ptr_result = c.mmap(@ptrCast(&c_void, address), length,
...	...	@@ -188,8 +193,8 @@ pub fn mmap(address: ?&u8, length: usize, prot: usize, flags: usize, fd: i32,
188	193	return errnoWrap(isize_result);
189	194	}
190	195
191		pub fn munmap(address: &u8, length: usize) usize {
192		return errnoWrap(c.munmap(@ptrCast(&c_void, address), length));
	196	pub fn munmap(address: usize, length: usize) usize {
	197	return errnoWrap(c.munmap(@intToPtr(&c_void, address), length));
193	198	}
194	199
195	200	pub fn unlink(path: &const u8) usize {
...	...	@@ -209,6 +214,10 @@ pub fn fork() usize {
209	214	return errnoWrap(c.fork());
210	215	}
211	216
	217	pub fn access(path: &const u8, mode: u32) usize {
	218	return errnoWrap(c.access(path, mode));
	219	}
	220
212	221	pub fn pipe(fds: &[2]i32) usize {
213	222	comptime assert(i32.bit_count == c_int.bit_count);
214	223	return errnoWrap(c.pipe(@ptrCast(&c_int, fds)));
...	...	@@ -251,6 +260,10 @@ pub fn readlink(noalias path: &const u8, noalias buf_ptr: &u8, buf_len: usize) u
251	260	return errnoWrap(c.readlink(path, buf_ptr, buf_len));
252	261	}
253	262
	263	pub fn gettimeofday(tv: ?&timeval, tz: ?&timezone) usize {
	264	return errnoWrap(c.gettimeofday(tv, tz));
	265	}
	266
254	267	pub fn nanosleep(req: &const timespec, rem: ?&timespec) usize {
255	268	return errnoWrap(c.nanosleep(req, rem));
256	269	}
...	...	@@ -301,6 +314,9 @@ pub const timespec = c.timespec;
301	314	pub const Stat = c.Stat;
302	315	pub const dirent = c.dirent;
303	316
	317	pub const sa_family_t = c.sa_family_t;
	318	pub const sockaddr = c.sockaddr;
	319
304	320	/// Renamed from `sigaction` to `Sigaction` to avoid conflict with the syscall.
305	321	pub const Sigaction = struct {
306	322	handler: extern fn(i32)void,
...	...	@@ -318,3 +334,11 @@ pub fn sigaddset(set: &sigset_t, signo: u5) void {
318	334	fn errnoWrap(value: isize) usize {
319	335	return @bitCast(usize, if (value == -1) -isize(*c._errno()) else value);
320	336	}
	337
	338
	339	pub const timezone = c.timezone;
	340	pub const timeval = c.timeval;
	341	pub const mach_timebase_info_data = c.mach_timebase_info_data;
	342
	343	pub const mach_absolute_time = c.mach_absolute_time;
	344	pub const mach_timebase_info = c.mach_timebase_info;

std/os/epoch.zig created+26

...	...	@@ -0,0 +1,26 @@
	1	/// Epoch reference times in terms of their difference from
	2	/// posix epoch in seconds.
	3	pub const posix = 0; //Jan 01, 1970 AD
	4	pub const dos = 315532800; //Jan 01, 1980 AD
	5	pub const ios = 978307200; //Jan 01, 2001 AD
	6	pub const openvms = -3506716800; //Nov 17, 1858 AD
	7	pub const zos = -2208988800; //Jan 01, 1900 AD
	8	pub const windows = -11644473600; //Jan 01, 1601 AD
	9	pub const amiga = 252460800; //Jan 01, 1978 AD
	10	pub const pickos = -63244800; //Dec 31, 1967 AD
	11	pub const gps = 315964800; //Jan 06, 1980 AD
	12	pub const clr = -62135769600; //Jan 01, 0001 AD
	13
	14	pub const unix = posix;
	15	pub const android = posix;
	16	pub const os2 = dos;
	17	pub const bios = dos;
	18	pub const vfat = dos;
	19	pub const ntfs = windows;
	20	pub const ntp = zos;
	21	pub const jbase = pickos;
	22	pub const aros = amiga;
	23	pub const morphos = amiga;
	24	pub const brew = gps;
	25	pub const atsc = gps;
	26	pub const go = clr;
		\ No newline at end of file

std/os/file.zig+44-1

...	...	@@ -85,6 +85,47 @@ pub const File = struct {
85	85	};
86	86	}
87	87
	88	pub fn access(allocator: &mem.Allocator, path: []const u8, file_mode: os.FileMode) !bool {
	89	const path_with_null = try std.cstr.addNullByte(allocator, path);
	90	defer allocator.free(path_with_null);
	91
	92	if (is_posix) {
	93	// mode is ignored and is always F_OK for now
	94	const result = posix.access(path_with_null.ptr, posix.F_OK);
	95	const err = posix.getErrno(result);
	96	if (err > 0) {
	97	return switch (err) {
	98	posix.EACCES => error.PermissionDenied,
	99	posix.EROFS => error.PermissionDenied,
	100	posix.ELOOP => error.PermissionDenied,
	101	posix.ETXTBSY => error.PermissionDenied,
	102	posix.ENOTDIR => error.NotFound,
	103	posix.ENOENT => error.NotFound,
	104
	105	posix.ENAMETOOLONG => error.NameTooLong,
	106	posix.EINVAL => error.BadMode,
	107	posix.EFAULT => error.BadPathName,
	108	posix.EIO => error.Io,
	109	posix.ENOMEM => error.SystemResources,
	110	else => os.unexpectedErrorPosix(err),
	111	};
	112	}
	113	return true;
	114	} else if (is_windows) {
	115	if (os.windows.PathFileExists(path_with_null.ptr) == os.windows.TRUE) {
	116	return true;
	117	}
	118
	119	const err = windows.GetLastError();
	120	return switch (err) {
	121	windows.ERROR.FILE_NOT_FOUND => error.NotFound,
	122	windows.ERROR.ACCESS_DENIED => error.PermissionDenied,
	123	else => os.unexpectedErrorWindows(err),
	124	};
	125	} else {
	126	@compileError("TODO implement access for this OS");
	127	}
	128	}
88	129
89	130	/// Upon success, the stream is in an uninitialized state. To continue using it,
90	131	/// you must use the open() function.
...	...	@@ -245,7 +286,9 @@ pub const File = struct {
245	286	};
246	287	}
247	288
248		return stat.mode;
	289	// TODO: we should be able to cast u16 to ModeError!u32, making this
	290	// explicit cast not necessary
	291	return os.FileMode(stat.mode);
249	292	} else if (is_windows) {
250	293	return {};
251	294	} else {

std/os/index.zig+932-172

...	...	@@ -2,22 +2,42 @@ const std = @import("../index.zig");
2	2	const builtin = @import("builtin");
3	3	const Os = builtin.Os;
4	4	const is_windows = builtin.os == Os.windows;
	5	const is_posix = switch (builtin.os) {
	6	builtin.Os.linux,
	7	builtin.Os.macosx => true,
	8	else => false,
	9	};
5	10	const os = this;
6	11
	12	test "std.os" {
	13	_ = @import("child_process.zig");
	14	_ = @import("darwin.zig");
	15	_ = @import("darwin_errno.zig");
	16	_ = @import("get_user_id.zig");
	17	_ = @import("linux/index.zig");
	18	_ = @import("path.zig");
	19	_ = @import("test.zig");
	20	_ = @import("time.zig");
	21	_ = @import("windows/index.zig");
	22	}
	23
7	24	pub const windows = @import("windows/index.zig");
8	25	pub const darwin = @import("darwin.zig");
9	26	pub const linux = @import("linux/index.zig");
10	27	pub const zen = @import("zen.zig");
11		pub const posix = switch(builtin.os) {
	28	pub const posix = switch (builtin.os) {
12	29	Os.linux => linux,
13		Os.macosx, Os.ios => darwin,
	30	Os.macosx,
	31	Os.ios => darwin,
14	32	Os.zen => zen,
15	33	else => @compileError("Unsupported OS"),
16	34	};
	35	pub const net = @import("net.zig");
17	36
18	37	pub const ChildProcess = @import("child_process.zig").ChildProcess;
19	38	pub const path = @import("path.zig");
20	39	pub const File = @import("file.zig").File;
	40	pub const time = @import("time.zig");
21	41
22	42	pub const FileMode = switch (builtin.os) {
23	43	Os.windows => void,
...	...	@@ -40,7 +60,7 @@ pub const windowsWrite = windows_util.windowsWrite;
40	60	pub const windowsIsCygwinPty = windows_util.windowsIsCygwinPty;
41	61	pub const windowsOpen = windows_util.windowsOpen;
42	62	pub const windowsLoadDll = windows_util.windowsLoadDll;
43		pub const windowsUnloadDll = windows_util.windowsUnloadDll;
	63	pub const windowsUnloadDll = windows_util.windowsUnloadDll;
44	64	pub const createWindowsEnvBlock = windows_util.createWindowsEnvBlock;
45	65
46	66	pub const WindowsWaitError = windows_util.WaitError;
...	...	@@ -79,9 +99,9 @@ pub fn getRandomBytes(buf: []u8) !void {
79	99	switch (err) {
80	100	posix.EINVAL => unreachable,
81	101	posix.EFAULT => unreachable,
82		posix.EINTR => continue,
	102	posix.EINTR => continue,
83	103	posix.ENOSYS => {
84		const fd = try posixOpenC(c"/dev/urandom", posix.O_RDONLY\|posix.O_CLOEXEC, 0);
	104	const fd = try posixOpenC(c"/dev/urandom", posix.O_RDONLY \| posix.O_CLOEXEC, 0);
85	105	defer close(fd);
86	106
87	107	try posixRead(fd, buf);
...	...	@@ -92,8 +112,9 @@ pub fn getRandomBytes(buf: []u8) !void {
92	112	}
93	113	return;
94	114	},
95		Os.macosx, Os.ios => {
96		const fd = try posixOpenC(c"/dev/urandom", posix.O_RDONLY\|posix.O_CLOEXEC, 0);
	115	Os.macosx,
	116	Os.ios => {
	117	const fd = try posixOpenC(c"/dev/urandom", posix.O_RDONLY \| posix.O_CLOEXEC, 0);
97	118	defer close(fd);
98	119
99	120	try posixRead(fd, buf);
...	...	@@ -116,7 +137,20 @@ pub fn getRandomBytes(buf: []u8) !void {
116	137	}
117	138	},
118	139	Os.zen => {
119		const randomness = []u8 {42, 1, 7, 12, 22, 17, 99, 16, 26, 87, 41, 45};
	140	const randomness = []u8 {
	141	42,
	142	1,
	143	7,
	144	12,
	145	22,
	146	17,
	147	99,
	148	16,
	149	26,
	150	87,
	151	41,
	152	45,
	153	};
120	154	var i: usize = 0;
121	155	while (i < buf.len) : (i += 1) {
122	156	if (i > randomness.len) return error.Unknown;
...	...	@@ -141,7 +175,9 @@ pub fn abort() noreturn {
141	175	c.abort();
142	176	}
143	177	switch (builtin.os) {
144		Os.linux, Os.macosx, Os.ios => {
	178	Os.linux,
	179	Os.macosx,
	180	Os.ios => {
145	181	_ = posix.raise(posix.SIGABRT);
146	182	_ = posix.raise(posix.SIGKILL);
147	183	while (true) {}
...	...	@@ -163,7 +199,9 @@ pub fn exit(status: u8) noreturn {
163	199	c.exit(status);
164	200	}
165	201	switch (builtin.os) {
166		Os.linux, Os.macosx, Os.ios => {
	202	Os.linux,
	203	Os.macosx,
	204	Os.ios => {
167	205	posix.exit(status);
168	206	},
169	207	Os.windows => {
...	...	@@ -173,6 +211,13 @@ pub fn exit(status: u8) noreturn {
173	211	}
174	212	}
175	213
	214	/// When a file descriptor is closed on linux, it pops the first
	215	/// node from this queue and resumes it.
	216	/// Async functions which get the EMFILE error code can suspend,
	217	/// putting their coroutine handle into this list.
	218	/// TODO make this an atomic linked list
	219	pub var emfile_promise_queue = std.LinkedList(promise).init();
	220
176	221	/// Closes the file handle. Keeps trying if it gets interrupted by a signal.
177	222	pub fn close(handle: FileHandle) void {
178	223	if (is_windows) {
...	...	@@ -180,10 +225,12 @@ pub fn close(handle: FileHandle) void {
180	225	} else {
181	226	while (true) {
182	227	const err = posix.getErrno(posix.close(handle));
183		if (err == posix.EINTR) {
184		continue;
185		} else {
186		return;
	228	switch (err) {
	229	posix.EINTR => continue,
	230	else => {
	231	if (emfile_promise_queue.popFirst()) \|p\| resume p.data;
	232	return;
	233	},
187	234	}
188	235	}
189	236	}
...	...	@@ -203,12 +250,14 @@ pub fn posixRead(fd: i32, buf: []u8) !void {
203	250	if (err > 0) {
204	251	return switch (err) {
205	252	posix.EINTR => continue,
206		posix.EINVAL, posix.EFAULT => unreachable,
	253	posix.EINVAL,
	254	posix.EFAULT => unreachable,
207	255	posix.EAGAIN => error.WouldBlock,
208	256	posix.EBADF => error.FileClosed,
209	257	posix.EIO => error.InputOutput,
210	258	posix.EISDIR => error.IsDir,
211		posix.ENOBUFS, posix.ENOMEM => error.SystemResources,
	259	posix.ENOBUFS,
	260	posix.ENOMEM => error.SystemResources,
212	261	else => unexpectedErrorPosix(err),
213	262	};
214	263	}
...	...	@@ -242,18 +291,19 @@ pub fn posixWrite(fd: i32, bytes: []const u8) !void {
242	291	const write_err = posix.getErrno(rc);
243	292	if (write_err > 0) {
244	293	return switch (write_err) {
245		posix.EINTR => continue,
246		posix.EINVAL, posix.EFAULT => unreachable,
	294	posix.EINTR => continue,
	295	posix.EINVAL,
	296	posix.EFAULT => unreachable,
247	297	posix.EAGAIN => PosixWriteError.WouldBlock,
248	298	posix.EBADF => PosixWriteError.FileClosed,
249	299	posix.EDESTADDRREQ => PosixWriteError.DestinationAddressRequired,
250	300	posix.EDQUOT => PosixWriteError.DiskQuota,
251		posix.EFBIG => PosixWriteError.FileTooBig,
252		posix.EIO => PosixWriteError.InputOutput,
	301	posix.EFBIG => PosixWriteError.FileTooBig,
	302	posix.EIO => PosixWriteError.InputOutput,
253	303	posix.ENOSPC => PosixWriteError.NoSpaceLeft,
254		posix.EPERM => PosixWriteError.AccessDenied,
255		posix.EPIPE => PosixWriteError.BrokenPipe,
256		else => unexpectedErrorPosix(write_err),
	304	posix.EPERM => PosixWriteError.AccessDenied,
	305	posix.EPIPE => PosixWriteError.BrokenPipe,
	306	else => unexpectedErrorPosix(write_err),
257	307	};
258	308	}
259	309	index += rc;
...	...	@@ -299,7 +349,8 @@ pub fn posixOpenC(file_path: &const u8, flags: u32, perm: usize) !i32 {
299	349	posix.EFAULT => unreachable,
300	350	posix.EINVAL => unreachable,
301	351	posix.EACCES => return PosixOpenError.AccessDenied,
302		posix.EFBIG, posix.EOVERFLOW => return PosixOpenError.FileTooBig,
	352	posix.EFBIG,
	353	posix.EOVERFLOW => return PosixOpenError.FileTooBig,
303	354	posix.EISDIR => return PosixOpenError.IsDir,
304	355	posix.ELOOP => return PosixOpenError.SymLinkLoop,
305	356	posix.EMFILE => return PosixOpenError.ProcessFdQuotaExceeded,
...	...	@@ -324,7 +375,8 @@ pub fn posixDup2(old_fd: i32, new_fd: i32) !void {
324	375	const err = posix.getErrno(posix.dup2(old_fd, new_fd));
325	376	if (err > 0) {
326	377	return switch (err) {
327		posix.EBUSY, posix.EINTR => continue,
	378	posix.EBUSY,
	379	posix.EINTR => continue,
328	380	posix.EMFILE => error.ProcessFdQuotaExceeded,
329	381	posix.EINVAL => unreachable,
330	382	else => unexpectedErrorPosix(err),
...	...	@@ -359,7 +411,7 @@ pub fn createNullDelimitedEnvMap(allocator: &Allocator, env_map: &const BufMap)
359	411
360	412	pub fn freeNullDelimitedEnvMap(allocator: &Allocator, envp_buf: []?&u8) void {
361	413	for (envp_buf) \|env\| {
362		const env_buf = if (env) \|ptr\| ptr[0 .. cstr.len(ptr) + 1] else break;
	414	const env_buf = if (env) \|ptr\| ptr[0..cstr.len(ptr) + 1] else break;
363	415	allocator.free(env_buf);
364	416	}
365	417	allocator.free(envp_buf);
...	...	@@ -370,9 +422,7 @@ pub fn freeNullDelimitedEnvMap(allocator: &Allocator, envp_buf: []?&u8) void {
370	422	/// pointers after the args and after the environment variables.
371	423	/// `argv[0]` is the executable path.
372	424	/// This function also uses the PATH environment variable to get the full path to the executable.
373		pub fn posixExecve(argv: []const []const u8, env_map: &const BufMap,
374		allocator: &Allocator) !void
375		{
	425	pub fn posixExecve(argv: []const []const u8, env_map: &const BufMap, allocator: &Allocator) !void {
376	426	const argv_buf = try allocator.alloc(?&u8, argv.len + 1);
377	427	mem.set(?&u8, argv_buf, null);
378	428	defer {
...	...	@@ -411,7 +461,7 @@ pub fn posixExecve(argv: []const []const u8, env_map: &const BufMap,
411	461	while (it.next()) \|search_path\| {
412	462	mem.copy(u8, path_buf, search_path);
413	463	path_buf[search_path.len] = '/';
414		mem.copy(u8, path_buf[search_path.len + 1 ..], exe_path);
	464	mem.copy(u8, path_buf[search_path.len + 1..], exe_path);
415	465	path_buf[search_path.len + exe_path.len + 1] = 0;
416	466	err = posix.getErrno(posix.execve(path_buf.ptr, argv_buf.ptr, envp_buf.ptr));
417	467	assert(err > 0);
...	...	@@ -443,10 +493,17 @@ fn posixExecveErrnoToErr(err: usize) PosixExecveError {
443	493	assert(err > 0);
444	494	return switch (err) {
445	495	posix.EFAULT => unreachable,
446		posix.E2BIG, posix.EMFILE, posix.ENAMETOOLONG, posix.ENFILE, posix.ENOMEM => error.SystemResources,
447		posix.EACCES, posix.EPERM => error.AccessDenied,
448		posix.EINVAL, posix.ENOEXEC => error.InvalidExe,
449		posix.EIO, posix.ELOOP => error.FileSystem,
	496	posix.E2BIG,
	497	posix.EMFILE,
	498	posix.ENAMETOOLONG,
	499	posix.ENFILE,
	500	posix.ENOMEM => error.SystemResources,
	501	posix.EACCES,
	502	posix.EPERM => error.AccessDenied,
	503	posix.EINVAL,
	504	posix.ENOEXEC => error.InvalidExe,
	505	posix.EIO,
	506	posix.ELOOP => error.FileSystem,
450	507	posix.EISDIR => error.IsDir,
451	508	posix.ENOENT => error.FileNotFound,
452	509	posix.ENOTDIR => error.NotDir,
...	...	@@ -455,6 +512,7 @@ fn posixExecveErrnoToErr(err: usize) PosixExecveError {
455	512	};
456	513	}
457	514
	515	pub var linux_aux_raw = []usize {0} ** 38;
458	516	pub var posix_environ_raw: []&u8 = undefined;
459	517
460	518	/// Caller must free result when done.
...	...	@@ -468,8 +526,7 @@ pub fn getEnvMap(allocator: &Allocator) !BufMap {
468	526
469	527	var i: usize = 0;
470	528	while (true) {
471		if (ptr[i] == 0)
472		return result;
	529	if (ptr[i] == 0) return result;
473	530
474	531	const key_start = i;
475	532
...	...	@@ -507,8 +564,7 @@ pub fn getEnvPosix(key: []const u8) ?[]const u8 {
507	564	var line_i: usize = 0;
508	565	while (ptr[line_i] != 0 and ptr[line_i] != '=') : (line_i += 1) {}
509	566	const this_key = ptr[0..line_i];
510		if (!mem.eql(u8, key, this_key))
511		continue;
	567	if (!mem.eql(u8, key, this_key)) continue;
512	568
513	569	var end_i: usize = line_i;
514	570	while (ptr[end_i] != 0) : (end_i += 1) {}
...	...	@@ -661,8 +717,10 @@ pub fn symLinkPosix(allocator: &Allocator, existing_path: []const u8, new_path:
661	717	const err = posix.getErrno(posix.symlink(existing_buf.ptr, new_buf.ptr));
662	718	if (err > 0) {
663	719	return switch (err) {
664		posix.EFAULT, posix.EINVAL => unreachable,
665		posix.EACCES, posix.EPERM => error.AccessDenied,
	720	posix.EFAULT,
	721	posix.EINVAL => unreachable,
	722	posix.EACCES,
	723	posix.EPERM => error.AccessDenied,
666	724	posix.EDQUOT => error.DiskQuota,
667	725	posix.EEXIST => error.PathAlreadyExists,
668	726	posix.EIO => error.FileSystem,
...	...	@@ -679,9 +737,7 @@ pub fn symLinkPosix(allocator: &Allocator, existing_path: []const u8, new_path:
679	737	}
680	738
681	739	// here we replace the standard +/ with -_ so that it can be used in a file name
682		const b64_fs_encoder = base64.Base64Encoder.init(
683		"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_",
684		base64.standard_pad_char);
	740	const b64_fs_encoder = base64.Base64Encoder.init("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_", base64.standard_pad_char);
685	741
686	742	pub fn atomicSymLink(allocator: &Allocator, existing_path: []const u8, new_path: []const u8) !void {
687	743	if (symLink(allocator, existing_path, new_path)) {
...	...	@@ -700,7 +756,7 @@ pub fn atomicSymLink(allocator: &Allocator, existing_path: []const u8, new_path:
700	756	tmp_path[dirname.len] = os.path.sep;
701	757	while (true) {
702	758	try getRandomBytes(rand_buf[0..]);
703		b64_fs_encoder.encode(tmp_path[dirname.len + 1 ..], rand_buf);
	759	b64_fs_encoder.encode(tmp_path[dirname.len + 1..], rand_buf);
704	760
705	761	if (symLink(allocator, existing_path, tmp_path)) {
706	762	return rename(allocator, tmp_path, new_path);
...	...	@@ -709,7 +765,6 @@ pub fn atomicSymLink(allocator: &Allocator, existing_path: []const u8, new_path:
709	765	else => return err, // TODO zig should know this set does not include PathAlreadyExists
710	766	}
711	767	}
712
713	768	}
714	769
715	770	pub fn deleteFile(allocator: &Allocator, file_path: []const u8) !void {
...	...	@@ -732,7 +787,8 @@ pub fn deleteFileWindows(allocator: &Allocator, file_path: []const u8) !void {
732	787	return switch (err) {
733	788	windows.ERROR.FILE_NOT_FOUND => error.FileNotFound,
734	789	windows.ERROR.ACCESS_DENIED => error.AccessDenied,
735		windows.ERROR.FILENAME_EXCED_RANGE, windows.ERROR.INVALID_PARAMETER => error.NameTooLong,
	790	windows.ERROR.FILENAME_EXCED_RANGE,
	791	windows.ERROR.INVALID_PARAMETER => error.NameTooLong,
736	792	else => unexpectedErrorWindows(err),
737	793	};
738	794	}
...	...	@@ -748,9 +804,11 @@ pub fn deleteFilePosix(allocator: &Allocator, file_path: []const u8) !void {
748	804	const err = posix.getErrno(posix.unlink(buf.ptr));
749	805	if (err > 0) {
750	806	return switch (err) {
751		posix.EACCES, posix.EPERM => error.AccessDenied,
	807	posix.EACCES,
	808	posix.EPERM => error.AccessDenied,
752	809	posix.EBUSY => error.FileBusy,
753		posix.EFAULT, posix.EINVAL => unreachable,
	810	posix.EFAULT,
	811	posix.EINVAL => unreachable,
754	812	posix.EIO => error.FileSystem,
755	813	posix.EISDIR => error.IsDir,
756	814	posix.ELOOP => error.SymLinkLoop,
...	...	@@ -828,7 +886,7 @@ pub const AtomicFile = struct {
828	886
829	887	while (true) {
830	888	try getRandomBytes(rand_buf[0..]);
831		b64_fs_encoder.encode(tmp_path[dirname.len + 1 ..], rand_buf);
	889	b64_fs_encoder.encode(tmp_path[dirname.len + 1..], rand_buf);
832	890
833	891	const file = os.File.openWriteNoClobber(allocator, tmp_path, mode) catch \|err\| switch (err) {
834	892	error.PathAlreadyExists => continue,
...	...	@@ -879,7 +937,7 @@ pub fn rename(allocator: &Allocator, old_path: []const u8, new_path: []const u8)
879	937	new_buf[new_path.len] = 0;
880	938
881	939	if (is_windows) {
882		const flags = windows.MOVEFILE_REPLACE_EXISTING\|windows.MOVEFILE_WRITE_THROUGH;
	940	const flags = windows.MOVEFILE_REPLACE_EXISTING \| windows.MOVEFILE_WRITE_THROUGH;
883	941	if (windows.MoveFileExA(old_buf.ptr, new_buf.ptr, flags) == 0) {
884	942	const err = windows.GetLastError();
885	943	return switch (err) {
...	...	@@ -890,10 +948,12 @@ pub fn rename(allocator: &Allocator, old_path: []const u8, new_path: []const u8)
890	948	const err = posix.getErrno(posix.rename(old_buf.ptr, new_buf.ptr));
891	949	if (err > 0) {
892	950	return switch (err) {
893		posix.EACCES, posix.EPERM => error.AccessDenied,
	951	posix.EACCES,
	952	posix.EPERM => error.AccessDenied,
894	953	posix.EBUSY => error.FileBusy,
895	954	posix.EDQUOT => error.DiskQuota,
896		posix.EFAULT, posix.EINVAL => unreachable,
	955	posix.EFAULT,
	956	posix.EINVAL => unreachable,
897	957	posix.EISDIR => error.IsDir,
898	958	posix.ELOOP => error.SymLinkLoop,
899	959	posix.EMLINK => error.LinkQuotaExceeded,
...	...	@@ -902,7 +962,8 @@ pub fn rename(allocator: &Allocator, old_path: []const u8, new_path: []const u8)
902	962	posix.ENOTDIR => error.NotDir,
903	963	posix.ENOMEM => error.SystemResources,
904	964	posix.ENOSPC => error.NoSpaceLeft,
905		posix.EEXIST, posix.ENOTEMPTY => error.PathAlreadyExists,
	965	posix.EEXIST,
	966	posix.ENOTEMPTY => error.PathAlreadyExists,
906	967	posix.EROFS => error.ReadOnlyFileSystem,
907	968	posix.EXDEV => error.RenameAcrossMountPoints,
908	969	else => unexpectedErrorPosix(err),
...	...	@@ -940,7 +1001,8 @@ pub fn makeDirPosix(allocator: &Allocator, dir_path: []const u8) !void {
940	1001	const err = posix.getErrno(posix.mkdir(path_buf.ptr, 0o755));
941	1002	if (err > 0) {
942	1003	return switch (err) {
943		posix.EACCES, posix.EPERM => error.AccessDenied,
	1004	posix.EACCES,
	1005	posix.EPERM => error.AccessDenied,
944	1006	posix.EDQUOT => error.DiskQuota,
945	1007	posix.EEXIST => error.PathAlreadyExists,
946	1008	posix.EFAULT => unreachable,
...	...	@@ -970,27 +1032,23 @@ pub fn makePath(allocator: &Allocator, full_path: []const u8) !void {
970	1032	// TODO stat the file and return an error if it's not a directory
971	1033	// this is important because otherwise a dangling symlink
972	1034	// could cause an infinite loop
973		if (end_index == resolved_path.len)
974		return;
	1035	if (end_index == resolved_path.len) return;
975	1036	} else if (err == error.FileNotFound) {
976	1037	// march end_index backward until next path component
977	1038	while (true) {
978	1039	end_index -= 1;
979		if (os.path.isSep(resolved_path[end_index]))
980		break;
	1040	if (os.path.isSep(resolved_path[end_index])) break;
981	1041	}
982	1042	continue;
983	1043	} else {
984	1044	return err;
985	1045	}
986	1046	};
987		if (end_index == resolved_path.len)
988		return;
	1047	if (end_index == resolved_path.len) return;
989	1048	// march end_index forward until next path component
990	1049	while (true) {
991	1050	end_index += 1;
992		if (end_index == resolved_path.len or os.path.isSep(resolved_path[end_index]))
993		break;
	1051	if (end_index == resolved_path.len or os.path.isSep(resolved_path[end_index])) break;
994	1052	}
995	1053	}
996	1054	}
...	...	@@ -1007,15 +1065,18 @@ pub fn deleteDir(allocator: &Allocator, dir_path: []const u8) !void {
1007	1065	const err = posix.getErrno(posix.rmdir(path_buf.ptr));
1008	1066	if (err > 0) {
1009	1067	return switch (err) {
1010		posix.EACCES, posix.EPERM => error.AccessDenied,
	1068	posix.EACCES,
	1069	posix.EPERM => error.AccessDenied,
1011	1070	posix.EBUSY => error.FileBusy,
1012		posix.EFAULT, posix.EINVAL => unreachable,
	1071	posix.EFAULT,
	1072	posix.EINVAL => unreachable,
1013	1073	posix.ELOOP => error.SymLinkLoop,
1014	1074	posix.ENAMETOOLONG => error.NameTooLong,
1015	1075	posix.ENOENT => error.FileNotFound,
1016	1076	posix.ENOMEM => error.SystemResources,
1017	1077	posix.ENOTDIR => error.NotDir,
1018		posix.EEXIST, posix.ENOTEMPTY => error.DirNotEmpty,
	1078	posix.EEXIST,
	1079	posix.ENOTEMPTY => error.DirNotEmpty,
1019	1080	posix.EROFS => error.ReadOnlyFileSystem,
1020	1081	else => unexpectedErrorPosix(err),
1021	1082	};
...	...	@@ -1025,7 +1086,7 @@ pub fn deleteDir(allocator: &Allocator, dir_path: []const u8) !void {
1025	1086	/// Whether ::full_path describes a symlink, file, or directory, this function
1026	1087	/// removes it. If it cannot be removed because it is a non-empty directory,
1027	1088	/// this function recursively removes its entries and then tries again.
1028		// TODO non-recursive implementation
	1089	/// TODO non-recursive implementation
1029	1090	const DeleteTreeError = error {
1030	1091	OutOfMemory,
1031	1092	AccessDenied,
...	...	@@ -1067,8 +1128,7 @@ pub fn deleteTree(allocator: &Allocator, full_path: []const u8) DeleteTreeError!
1067	1128	error.NotDir,
1068	1129	error.FileSystem,
1069	1130	error.FileBusy,
1070		error.Unexpected
1071		=> return err,
	1131	error.Unexpected => return err,
1072	1132	}
1073	1133	{
1074	1134	var dir = Dir.open(allocator, full_path) catch \|err\| switch (err) {
...	...	@@ -1092,8 +1152,7 @@ pub fn deleteTree(allocator: &Allocator, full_path: []const u8) DeleteTreeError!
1092	1152	error.SystemResources,
1093	1153	error.NoSpaceLeft,
1094	1154	error.PathAlreadyExists,
1095		error.Unexpected
1096		=> return err,
	1155	error.Unexpected => return err,
1097	1156	};
1098	1157	defer dir.close();
1099	1158
...	...	@@ -1123,7 +1182,8 @@ pub const Dir = struct {
1123	1182	end_index: usize,
1124	1183
1125	1184	const darwin_seek_t = switch (builtin.os) {
1126		Os.macosx, Os.ios => i64,
	1185	Os.macosx,
	1186	Os.ios => i64,
1127	1187	else => void,
1128	1188	};
1129	1189
...	...	@@ -1147,12 +1207,14 @@ pub const Dir = struct {
1147	1207	pub fn open(allocator: &Allocator, dir_path: []const u8) !Dir {
1148	1208	const fd = switch (builtin.os) {
1149	1209	Os.windows => @compileError("TODO support Dir.open for windows"),
1150		Os.linux => try posixOpen(allocator, dir_path, posix.O_RDONLY\|posix.O_DIRECTORY\|posix.O_CLOEXEC, 0),
1151		Os.macosx, Os.ios => try posixOpen(allocator, dir_path, posix.O_RDONLY\|posix.O_NONBLOCK\|posix.O_DIRECTORY\|posix.O_CLOEXEC, 0),
	1210	Os.linux => try posixOpen(allocator, dir_path, posix.O_RDONLY \| posix.O_DIRECTORY \| posix.O_CLOEXEC, 0),
	1211	Os.macosx,
	1212	Os.ios => try posixOpen(allocator, dir_path, posix.O_RDONLY \| posix.O_NONBLOCK \| posix.O_DIRECTORY \| posix.O_CLOEXEC, 0),
1152	1213	else => @compileError("Dir.open is not supported for this platform"),
1153	1214	};
1154	1215	const darwin_seek_init = switch (builtin.os) {
1155		Os.macosx, Os.ios => 0,
	1216	Os.macosx,
	1217	Os.ios => 0,
1156	1218	else => {},
1157	1219	};
1158	1220	return Dir {
...	...	@@ -1175,7 +1237,8 @@ pub const Dir = struct {
1175	1237	pub fn next(self: &Dir) !?Entry {
1176	1238	switch (builtin.os) {
1177	1239	Os.linux => return self.nextLinux(),
1178		Os.macosx, Os.ios => return self.nextDarwin(),
	1240	Os.macosx,
	1241	Os.ios => return self.nextDarwin(),
1179	1242	Os.windows => return self.nextWindows(),
1180	1243	else => @compileError("Dir.next not supported on " ++ @tagName(builtin.os)),
1181	1244	}
...	...	@@ -1189,12 +1252,13 @@ pub const Dir = struct {
1189	1252	}
1190	1253
1191	1254	while (true) {
1192		const result = posix.getdirentries64(self.fd, self.buf.ptr, self.buf.len,
1193		&self.darwin_seek);
	1255	const result = posix.getdirentries64(self.fd, self.buf.ptr, self.buf.len, &self.darwin_seek);
1194	1256	const err = posix.getErrno(result);
1195	1257	if (err > 0) {
1196	1258	switch (err) {
1197		posix.EBADF, posix.EFAULT, posix.ENOTDIR => unreachable,
	1259	posix.EBADF,
	1260	posix.EFAULT,
	1261	posix.ENOTDIR => unreachable,
1198	1262	posix.EINVAL => {
1199	1263	self.buf = try self.allocator.realloc(u8, self.buf, self.buf.len * 2);
1200	1264	continue;
...	...	@@ -1202,14 +1266,13 @@ pub const Dir = struct {
1202	1266	else => return unexpectedErrorPosix(err),
1203	1267	}
1204	1268	}
1205		if (result == 0)
1206		return null;
	1269	if (result == 0) return null;
1207	1270	self.index = 0;
1208	1271	self.end_index = result;
1209	1272	break;
1210	1273	}
1211	1274	}
1212		const darwin_entry = @ptrCast(& align(1) posix.dirent, &self.buf[self.index]);
	1275	const darwin_entry = @ptrCast(&align(1) posix.dirent, &self.buf[self.index]);
1213	1276	const next_index = self.index + darwin_entry.d_reclen;
1214	1277	self.index = next_index;
1215	1278
...	...	@@ -1254,7 +1317,9 @@ pub const Dir = struct {
1254	1317	const err = posix.getErrno(result);
1255	1318	if (err > 0) {
1256	1319	switch (err) {
1257		posix.EBADF, posix.EFAULT, posix.ENOTDIR => unreachable,
	1320	posix.EBADF,
	1321	posix.EFAULT,
	1322	posix.ENOTDIR => unreachable,
1258	1323	posix.EINVAL => {
1259	1324	self.buf = try self.allocator.realloc(u8, self.buf, self.buf.len * 2);
1260	1325	continue;
...	...	@@ -1262,14 +1327,13 @@ pub const Dir = struct {
1262	1327	else => return unexpectedErrorPosix(err),
1263	1328	}
1264	1329	}
1265		if (result == 0)
1266		return null;
	1330	if (result == 0) return null;
1267	1331	self.index = 0;
1268	1332	self.end_index = result;
1269	1333	break;
1270	1334	}
1271	1335	}
1272		const linux_entry = @ptrCast(& align(1) posix.dirent, &self.buf[self.index]);
	1336	const linux_entry = @ptrCast(&align(1) posix.dirent, &self.buf[self.index]);
1273	1337	const next_index = self.index + linux_entry.d_reclen;
1274	1338	self.index = next_index;
1275	1339
...	...	@@ -1338,7 +1402,8 @@ pub fn readLink(allocator: &Allocator, pathname: []const u8) ![]u8 {
1338	1402	if (err > 0) {
1339	1403	return switch (err) {
1340	1404	posix.EACCES => error.AccessDenied,
1341		posix.EFAULT, posix.EINVAL => unreachable,
	1405	posix.EFAULT,
	1406	posix.EINVAL => unreachable,
1342	1407	posix.EIO => error.FileSystem,
1343	1408	posix.ELOOP => error.SymLinkLoop,
1344	1409	posix.ENAMETOOLONG => error.NameTooLong,
...	...	@@ -1356,50 +1421,6 @@ pub fn readLink(allocator: &Allocator, pathname: []const u8) ![]u8 {
1356	1421	}
1357	1422	}
1358	1423
1359		pub fn sleep(seconds: usize, nanoseconds: usize) void {
1360		switch(builtin.os) {
1361		Os.linux, Os.macosx, Os.ios => {
1362		posixSleep(u63(seconds), u63(nanoseconds));
1363		},
1364		Os.windows => {
1365		const milliseconds = seconds * 1000 + nanoseconds / 1000000;
1366		windows.Sleep(windows.DWORD(milliseconds));
1367		},
1368		else => @compileError("Unsupported OS"),
1369		}
1370		}
1371
1372		const u63 = @IntType(false, 63);
1373		pub fn posixSleep(seconds: u63, nanoseconds: u63) void {
1374		var req = posix.timespec {
1375		.tv_sec = seconds,
1376		.tv_nsec = nanoseconds,
1377		};
1378		var rem: posix.timespec = undefined;
1379		while (true) {
1380		const ret_val = posix.nanosleep(&req, &rem);
1381		const err = posix.getErrno(ret_val);
1382		if (err == 0) return;
1383		switch (err) {
1384		posix.EFAULT => unreachable,
1385		posix.EINVAL => {
1386		// Sometimes Darwin returns EINVAL for no reason.
1387		// We treat it as a spurious wakeup.
1388		return;
1389		},
1390		posix.EINTR => {
1391		req = rem;
1392		continue;
1393		},
1394		else => return,
1395		}
1396		}
1397		}
1398
1399		test "os.sleep" {
1400		sleep(0, 1);
1401		}
1402
1403	1424	pub fn posix_setuid(uid: u32) !void {
1404	1425	const err = posix.getErrno(posix.setuid(uid));
1405	1426	if (err == 0) return;
...	...	@@ -1475,8 +1496,7 @@ pub const ArgIteratorPosix = struct {
1475	1496	}
1476	1497
1477	1498	pub fn next(self: &ArgIteratorPosix) ?[]const u8 {
1478		if (self.index == self.count)
1479		return null;
	1499	if (self.index == self.count) return null;
1480	1500
1481	1501	const s = raw[self.index];
1482	1502	self.index += 1;
...	...	@@ -1484,8 +1504,7 @@ pub const ArgIteratorPosix = struct {
1484	1504	}
1485	1505
1486	1506	pub fn skip(self: &ArgIteratorPosix) bool {
1487		if (self.index == self.count)
1488		return false;
	1507	if (self.index == self.count) return false;
1489	1508
1490	1509	self.index += 1;
1491	1510	return true;
...	...	@@ -1503,7 +1522,9 @@ pub const ArgIteratorWindows = struct {
1503	1522	quote_count: usize,
1504	1523	seen_quote_count: usize,
1505	1524
1506		pub const NextError = error{OutOfMemory};
	1525	pub const NextError = error {
	1526	OutOfMemory,
	1527	};
1507	1528
1508	1529	pub fn init() ArgIteratorWindows {
1509	1530	return initWithCmdLine(windows.GetCommandLineA());
...	...	@@ -1526,7 +1547,8 @@ pub const ArgIteratorWindows = struct {
1526	1547	const byte = self.cmd_line[self.index];
1527	1548	switch (byte) {
1528	1549	0 => return null,
1529		' ', '\t' => continue,
	1550	' ',
	1551	'\t' => continue,
1530	1552	else => break,
1531	1553	}
1532	1554	}
...	...	@@ -1540,7 +1562,8 @@ pub const ArgIteratorWindows = struct {
1540	1562	const byte = self.cmd_line[self.index];
1541	1563	switch (byte) {
1542	1564	0 => return false,
1543		' ', '\t' => continue,
	1565	' ',
	1566	'\t' => continue,
1544	1567	else => break,
1545	1568	}
1546	1569	}
...	...	@@ -1559,7 +1582,8 @@ pub const ArgIteratorWindows = struct {
1559	1582	'\\' => {
1560	1583	backslash_count += 1;
1561	1584	},
1562		' ', '\t' => {
	1585	' ',
	1586	'\t' => {
1563	1587	if (self.seen_quote_count % 2 == 0 or self.seen_quote_count == self.quote_count) {
1564	1588	return true;
1565	1589	}
...	...	@@ -1599,7 +1623,8 @@ pub const ArgIteratorWindows = struct {
1599	1623	'\\' => {
1600	1624	backslash_count += 1;
1601	1625	},
1602		' ', '\t' => {
	1626	' ',
	1627	'\t' => {
1603	1628	try self.emitBackslashes(&buf, backslash_count);
1604	1629	backslash_count = 0;
1605	1630	if (self.seen_quote_count % 2 == 1 and self.seen_quote_count != self.quote_count) {
...	...	@@ -1643,7 +1668,6 @@ pub const ArgIteratorWindows = struct {
1643	1668	}
1644	1669	}
1645	1670	}
1646
1647	1671	};
1648	1672
1649	1673	pub const ArgIterator = struct {
...	...	@@ -1658,7 +1682,7 @@ pub const ArgIterator = struct {
1658	1682	}
1659	1683
1660	1684	pub const NextError = ArgIteratorWindows.NextError;
1661
	1685
1662	1686	/// You must free the returned memory when done.
1663	1687	pub fn next(self: &ArgIterator, allocator: &Allocator) ?(NextError![]u8) {
1664	1688	if (builtin.os == Os.windows) {
...	...	@@ -1733,15 +1757,47 @@ pub fn argsFree(allocator: &mem.Allocator, args_alloc: []const []u8) void {
1733	1757	}
1734	1758
1735	1759	test "windows arg parsing" {
1736		testWindowsCmdLine(c"a b\tc d", [][]const u8{"a", "b", "c", "d"});
1737		testWindowsCmdLine(c"\"abc\" d e", [][]const u8{"abc", "d", "e"});
1738		testWindowsCmdLine(c"a\\\\\\b d\"e f\"g h", [][]const u8{"a\\\\\\b", "de fg", "h"});
1739		testWindowsCmdLine(c"a\\\\\\\"b c d", [][]const u8{"a\\\"b", "c", "d"});
1740		testWindowsCmdLine(c"a\\\\\\\\\"b c\" d e", [][]const u8{"a\\\\b c", "d", "e"});
1741		testWindowsCmdLine(c"a b\tc \"d f", [][]const u8{"a", "b", "c", "\"d", "f"});
1742
1743		testWindowsCmdLine(c"\".\\..\\zig-cache\\build\" \"bin\\zig.exe\" \".\\..\" \".\\..\\zig-cache\" \"--help\"",
1744		[][]const u8{".\\..\\zig-cache\\build", "bin\\zig.exe", ".\\..", ".\\..\\zig-cache", "--help"});
	1760	testWindowsCmdLine(c"a b\tc d", [][]const u8 {
	1761	"a",
	1762	"b",
	1763	"c",
	1764	"d",
	1765	});
	1766	testWindowsCmdLine(c"\"abc\" d e", [][]const u8 {
	1767	"abc",
	1768	"d",
	1769	"e",
	1770	});
	1771	testWindowsCmdLine(c"a\\\\\\b d\"e f\"g h", [][]const u8 {
	1772	"a\\\\\\b",
	1773	"de fg",
	1774	"h",
	1775	});
	1776	testWindowsCmdLine(c"a\\\\\\\"b c d", [][]const u8 {
	1777	"a\\\"b",
	1778	"c",
	1779	"d",
	1780	});
	1781	testWindowsCmdLine(c"a\\\\\\\\\"b c\" d e", [][]const u8 {
	1782	"a\\\\b c",
	1783	"d",
	1784	"e",
	1785	});
	1786	testWindowsCmdLine(c"a b\tc \"d f", [][]const u8 {
	1787	"a",
	1788	"b",
	1789	"c",
	1790	"\"d",
	1791	"f",
	1792	});
	1793
	1794	testWindowsCmdLine(c"\".\\..\\zig-cache\\build\" \"bin\\zig.exe\" \".\\..\" \".\\..\\zig-cache\" \"--help\"", [][]const u8 {
	1795	".\\..\\zig-cache\\build",
	1796	"bin\\zig.exe",
	1797	".\\..",
	1798	".\\..\\zig-cache",
	1799	"--help",
	1800	});
1745	1801	}
1746	1802
1747	1803	fn testWindowsCmdLine(input_cmd_line: &const u8, expected_args: []const []const u8) void {
...	...	@@ -1753,27 +1809,16 @@ fn testWindowsCmdLine(input_cmd_line: &const u8, expected_args: []const []const
1753	1809	assert(it.next(debug.global_allocator) == null);
1754	1810	}
1755	1811
1756		test "std.os" {
1757		_ = @import("child_process.zig");
1758		_ = @import("darwin_errno.zig");
1759		_ = @import("darwin.zig");
1760		_ = @import("get_user_id.zig");
1761		_ = @import("linux/errno.zig");
1762		//_ = @import("linux_i386.zig");
1763		_ = @import("linux/x86_64.zig");
1764		_ = @import("linux/index.zig");
1765		_ = @import("path.zig");
1766		_ = @import("windows/index.zig");
1767		_ = @import("test.zig");
1768		}
1769
1770
1771	1812	// TODO make this a build variable that you can set
1772	1813	const unexpected_error_tracing = false;
	1814	const UnexpectedError = error {
	1815	/// The Operating System returned an undocumented error code.
	1816	Unexpected,
	1817	};
1773	1818
1774	1819	/// Call this when you made a syscall or something that sets errno
1775	1820	/// and you get an unexpected error.
1776		pub fn unexpectedErrorPosix(errno: usize) (error{Unexpected}) {
	1821	pub fn unexpectedErrorPosix(errno: usize) UnexpectedError {
1777	1822	if (unexpected_error_tracing) {
1778	1823	debug.warn("unexpected errno: {}\n", errno);
1779	1824	debug.dumpCurrentStackTrace(null);
...	...	@@ -1783,7 +1828,7 @@ pub fn unexpectedErrorPosix(errno: usize) (error{Unexpected}) {
1783	1828
1784	1829	/// Call this when you made a windows DLL call or something that does SetLastError
1785	1830	/// and you get an unexpected error.
1786		pub fn unexpectedErrorWindows(err: windows.DWORD) (error{Unexpected}) {
	1831	pub fn unexpectedErrorWindows(err: windows.DWORD) UnexpectedError {
1787	1832	if (unexpected_error_tracing) {
1788	1833	debug.warn("unexpected GetLastError(): {}\n", err);
1789	1834	debug.dumpCurrentStackTrace(null);
...	...	@@ -1799,7 +1844,8 @@ pub fn openSelfExe() !os.File {
1799	1844	var fixed_allocator = std.heap.FixedBufferAllocator.init(fixed_buffer_mem[0..]);
1800	1845	return os.File.openRead(&fixed_allocator.allocator, proc_file_path);
1801	1846	},
1802		Os.macosx, Os.ios => {
	1847	Os.macosx,
	1848	Os.ios => {
1803	1849	var fixed_buffer_mem: [darwin.PATH_MAX * 2]u8 = undefined;
1804	1850	var fixed_allocator = std.heap.FixedBufferAllocator.init(fixed_buffer_mem[0..]);
1805	1851	const self_exe_path = try selfExePath(&fixed_allocator.allocator);
...	...	@@ -1811,8 +1857,10 @@ pub fn openSelfExe() !os.File {
1811	1857
1812	1858	test "openSelfExe" {
1813	1859	switch (builtin.os) {
1814		Os.linux, Os.macosx, Os.ios => (try openSelfExe()).close(),
1815		else => return, // Unsupported OS.
	1860	Os.linux,
	1861	Os.macosx,
	1862	Os.ios => (try openSelfExe()).close(),
	1863	else => return, // Unsupported OS.
1816	1864	}
1817	1865	}
1818	1866
...	...	@@ -1849,7 +1897,8 @@ pub fn selfExePath(allocator: &mem.Allocator) ![]u8 {
1849	1897	try out_path.resize(new_len);
1850	1898	}
1851	1899	},
1852		Os.macosx, Os.ios => {
	1900	Os.macosx,
	1901	Os.ios => {
1853	1902	var u32_len: u32 = 0;
1854	1903	const ret1 = c._NSGetExecutablePath(undefined, &u32_len);
1855	1904	assert(ret1 != 0);
...	...	@@ -1877,7 +1926,9 @@ pub fn selfExeDirPath(allocator: &mem.Allocator) ![]u8 {
1877	1926	const dir = path.dirname(full_exe_path);
1878	1927	return allocator.shrink(u8, full_exe_path, dir.len);
1879	1928	},
1880		Os.windows, Os.macosx, Os.ios => {
	1929	Os.windows,
	1930	Os.macosx,
	1931	Os.ios => {
1881	1932	const self_exe_path = try selfExePath(allocator);
1882	1933	errdefer allocator.free(self_exe_path);
1883	1934	const dirname = os.path.dirname(self_exe_path);
...	...	@@ -1898,3 +1949,712 @@ pub fn isTty(handle: FileHandle) bool {
1898	1949	}
1899	1950	}
1900	1951	}
	1952
	1953	pub const PosixSocketError = error {
	1954	/// Permission to create a socket of the specified type and/or
	1955	/// pro‐tocol is denied.
	1956	PermissionDenied,
	1957
	1958	/// The implementation does not support the specified address family.
	1959	AddressFamilyNotSupported,
	1960
	1961	/// Unknown protocol, or protocol family not available.
	1962	ProtocolFamilyNotAvailable,
	1963
	1964	/// The per-process limit on the number of open file descriptors has been reached.
	1965	ProcessFdQuotaExceeded,
	1966
	1967	/// The system-wide limit on the total number of open files has been reached.
	1968	SystemFdQuotaExceeded,
	1969
	1970	/// Insufficient memory is available. The socket cannot be created until sufficient
	1971	/// resources are freed.
	1972	SystemResources,
	1973
	1974	/// The protocol type or the specified protocol is not supported within this domain.
	1975	ProtocolNotSupported,
	1976	};
	1977
	1978	pub fn posixSocket(domain: u32, socket_type: u32, protocol: u32) !i32 {
	1979	const rc = posix.socket(domain, socket_type, protocol);
	1980	const err = posix.getErrno(rc);
	1981	switch (err) {
	1982	0 => return i32(rc),
	1983	posix.EACCES => return PosixSocketError.PermissionDenied,
	1984	posix.EAFNOSUPPORT => return PosixSocketError.AddressFamilyNotSupported,
	1985	posix.EINVAL => return PosixSocketError.ProtocolFamilyNotAvailable,
	1986	posix.EMFILE => return PosixSocketError.ProcessFdQuotaExceeded,
	1987	posix.ENFILE => return PosixSocketError.SystemFdQuotaExceeded,
	1988	posix.ENOBUFS,
	1989	posix.ENOMEM => return PosixSocketError.SystemResources,
	1990	posix.EPROTONOSUPPORT => return PosixSocketError.ProtocolNotSupported,
	1991	else => return unexpectedErrorPosix(err),
	1992	}
	1993	}
	1994
	1995	pub const PosixBindError = error {
	1996	/// The address is protected, and the user is not the superuser.
	1997	/// For UNIX domain sockets: Search permission is denied on a component
	1998	/// of the path prefix.
	1999	AccessDenied,
	2000
	2001	/// The given address is already in use, or in the case of Internet domain sockets,
	2002	/// The port number was specified as zero in the socket
	2003	/// address structure, but, upon attempting to bind to an ephemeral port, it was
	2004	/// determined that all port numbers in the ephemeral port range are currently in
	2005	/// use. See the discussion of /proc/sys/net/ipv4/ip_local_port_range ip(7).
	2006	AddressInUse,
	2007
	2008	/// sockfd is not a valid file descriptor.
	2009	InvalidFileDescriptor,
	2010
	2011	/// The socket is already bound to an address, or addrlen is wrong, or addr is not
	2012	/// a valid address for this socket's domain.
	2013	InvalidSocketOrAddress,
	2014
	2015	/// The file descriptor sockfd does not refer to a socket.
	2016	FileDescriptorNotASocket,
	2017
	2018	/// A nonexistent interface was requested or the requested address was not local.
	2019	AddressNotAvailable,
	2020
	2021	/// addr points outside the user's accessible address space.
	2022	PageFault,
	2023
	2024	/// Too many symbolic links were encountered in resolving addr.
	2025	SymLinkLoop,
	2026
	2027	/// addr is too long.
	2028	NameTooLong,
	2029
	2030	/// A component in the directory prefix of the socket pathname does not exist.
	2031	FileNotFound,
	2032
	2033	/// Insufficient kernel memory was available.
	2034	SystemResources,
	2035
	2036	/// A component of the path prefix is not a directory.
	2037	NotDir,
	2038
	2039	/// The socket inode would reside on a read-only filesystem.
	2040	ReadOnlyFileSystem,
	2041
	2042	Unexpected,
	2043	};
	2044
	2045	/// addr is `&const T` where T is one of the sockaddr
	2046	pub fn posixBind(fd: i32, addr: &const posix.sockaddr) PosixBindError!void {
	2047	const rc = posix.bind(fd, addr, @sizeOf(posix.sockaddr));
	2048	const err = posix.getErrno(rc);
	2049	switch (err) {
	2050	0 => return,
	2051	posix.EACCES => return PosixBindError.AccessDenied,
	2052	posix.EADDRINUSE => return PosixBindError.AddressInUse,
	2053	posix.EBADF => return PosixBindError.InvalidFileDescriptor,
	2054	posix.EINVAL => return PosixBindError.InvalidSocketOrAddress,
	2055	posix.ENOTSOCK => return PosixBindError.FileDescriptorNotASocket,
	2056	posix.EADDRNOTAVAIL => return PosixBindError.AddressNotAvailable,
	2057	posix.EFAULT => return PosixBindError.PageFault,
	2058	posix.ELOOP => return PosixBindError.SymLinkLoop,
	2059	posix.ENAMETOOLONG => return PosixBindError.NameTooLong,
	2060	posix.ENOENT => return PosixBindError.FileNotFound,
	2061	posix.ENOMEM => return PosixBindError.SystemResources,
	2062	posix.ENOTDIR => return PosixBindError.NotDir,
	2063	posix.EROFS => return PosixBindError.ReadOnlyFileSystem,
	2064	else => return unexpectedErrorPosix(err),
	2065	}
	2066	}
	2067
	2068	const PosixListenError = error {
	2069	/// Another socket is already listening on the same port.
	2070	/// For Internet domain sockets, the socket referred to by sockfd had not previously
	2071	/// been bound to an address and, upon attempting to bind it to an ephemeral port, it
	2072	/// was determined that all port numbers in the ephemeral port range are currently in
	2073	/// use. See the discussion of /proc/sys/net/ipv4/ip_local_port_range in ip(7).
	2074	AddressInUse,
	2075
	2076	/// The argument sockfd is not a valid file descriptor.
	2077	InvalidFileDescriptor,
	2078
	2079	/// The file descriptor sockfd does not refer to a socket.
	2080	FileDescriptorNotASocket,
	2081
	2082	/// The socket is not of a type that supports the listen() operation.
	2083	OperationNotSupported,
	2084
	2085	Unexpected,
	2086	};
	2087
	2088	pub fn posixListen(sockfd: i32, backlog: u32) PosixListenError!void {
	2089	const rc = posix.listen(sockfd, backlog);
	2090	const err = posix.getErrno(rc);
	2091	switch (err) {
	2092	0 => return,
	2093	posix.EADDRINUSE => return PosixListenError.AddressInUse,
	2094	posix.EBADF => return PosixListenError.InvalidFileDescriptor,
	2095	posix.ENOTSOCK => return PosixListenError.FileDescriptorNotASocket,
	2096	posix.EOPNOTSUPP => return PosixListenError.OperationNotSupported,
	2097	else => return unexpectedErrorPosix(err),
	2098	}
	2099	}
	2100
	2101	pub const PosixAcceptError = error {
	2102	/// The socket is marked nonblocking and no connections are present to be accepted.
	2103	WouldBlock,
	2104
	2105	/// sockfd is not an open file descriptor.
	2106	FileDescriptorClosed,
	2107
	2108	ConnectionAborted,
	2109
	2110	/// The addr argument is not in a writable part of the user address space.
	2111	PageFault,
	2112
	2113	/// Socket is not listening for connections, or addrlen is invalid (e.g., is negative),
	2114	/// or invalid value in flags.
	2115	InvalidSyscall,
	2116
	2117	/// The per-process limit on the number of open file descriptors has been reached.
	2118	ProcessFdQuotaExceeded,
	2119
	2120	/// The system-wide limit on the total number of open files has been reached.
	2121	SystemFdQuotaExceeded,
	2122
	2123	/// Not enough free memory. This often means that the memory allocation is limited
	2124	/// by the socket buffer limits, not by the system memory.
	2125	SystemResources,
	2126
	2127	/// The file descriptor sockfd does not refer to a socket.
	2128	FileDescriptorNotASocket,
	2129
	2130	/// The referenced socket is not of type SOCK_STREAM.
	2131	OperationNotSupported,
	2132
	2133	ProtocolFailure,
	2134
	2135	/// Firewall rules forbid connection.
	2136	BlockedByFirewall,
	2137
	2138	Unexpected,
	2139	};
	2140
	2141	pub fn posixAccept(fd: i32, addr: &posix.sockaddr, flags: u32) PosixAcceptError!i32 {
	2142	while (true) {
	2143	var sockaddr_size = u32(@sizeOf(posix.sockaddr));
	2144	const rc = posix.accept4(fd, addr, &sockaddr_size, flags);
	2145	const err = posix.getErrno(rc);
	2146	switch (err) {
	2147	0 => return i32(rc),
	2148	posix.EINTR => continue,
	2149	else => return unexpectedErrorPosix(err),
	2150
	2151	posix.EAGAIN => return PosixAcceptError.WouldBlock,
	2152	posix.EBADF => return PosixAcceptError.FileDescriptorClosed,
	2153	posix.ECONNABORTED => return PosixAcceptError.ConnectionAborted,
	2154	posix.EFAULT => return PosixAcceptError.PageFault,
	2155	posix.EINVAL => return PosixAcceptError.InvalidSyscall,
	2156	posix.EMFILE => return PosixAcceptError.ProcessFdQuotaExceeded,
	2157	posix.ENFILE => return PosixAcceptError.SystemFdQuotaExceeded,
	2158	posix.ENOBUFS,
	2159	posix.ENOMEM => return PosixAcceptError.SystemResources,
	2160	posix.ENOTSOCK => return PosixAcceptError.FileDescriptorNotASocket,
	2161	posix.EOPNOTSUPP => return PosixAcceptError.OperationNotSupported,
	2162	posix.EPROTO => return PosixAcceptError.ProtocolFailure,
	2163	posix.EPERM => return PosixAcceptError.BlockedByFirewall,
	2164	}
	2165	}
	2166	}
	2167
	2168	pub const LinuxEpollCreateError = error {
	2169	/// Invalid value specified in flags.
	2170	InvalidSyscall,
	2171
	2172	/// The per-user limit on the number of epoll instances imposed by
	2173	/// /proc/sys/fs/epoll/max_user_instances was encountered. See epoll(7) for further
	2174	/// details.
	2175	/// Or, The per-process limit on the number of open file descriptors has been reached.
	2176	ProcessFdQuotaExceeded,
	2177
	2178	/// The system-wide limit on the total number of open files has been reached.
	2179	SystemFdQuotaExceeded,
	2180
	2181	/// There was insufficient memory to create the kernel object.
	2182	SystemResources,
	2183
	2184	Unexpected,
	2185	};
	2186
	2187	pub fn linuxEpollCreate(flags: u32) LinuxEpollCreateError!i32 {
	2188	const rc = posix.epoll_create1(flags);
	2189	const err = posix.getErrno(rc);
	2190	switch (err) {
	2191	0 => return i32(rc),
	2192	else => return unexpectedErrorPosix(err),
	2193
	2194	posix.EINVAL => return LinuxEpollCreateError.InvalidSyscall,
	2195	posix.EMFILE => return LinuxEpollCreateError.ProcessFdQuotaExceeded,
	2196	posix.ENFILE => return LinuxEpollCreateError.SystemFdQuotaExceeded,
	2197	posix.ENOMEM => return LinuxEpollCreateError.SystemResources,
	2198	}
	2199	}
	2200
	2201	pub const LinuxEpollCtlError = error {
	2202	/// epfd or fd is not a valid file descriptor.
	2203	InvalidFileDescriptor,
	2204
	2205	/// op was EPOLL_CTL_ADD, and the supplied file descriptor fd is already registered
	2206	/// with this epoll instance.
	2207	FileDescriptorAlreadyPresentInSet,
	2208
	2209	/// epfd is not an epoll file descriptor, or fd is the same as epfd, or the requested
	2210	/// operation op is not supported by this interface, or
	2211	/// An invalid event type was specified along with EPOLLEXCLUSIVE in events, or
	2212	/// op was EPOLL_CTL_MOD and events included EPOLLEXCLUSIVE, or
	2213	/// op was EPOLL_CTL_MOD and the EPOLLEXCLUSIVE flag has previously been applied to
	2214	/// this epfd, fd pair, or
	2215	/// EPOLLEXCLUSIVE was specified in event and fd refers to an epoll instance.
	2216	InvalidSyscall,
	2217
	2218	/// fd refers to an epoll instance and this EPOLL_CTL_ADD operation would result in a
	2219	/// circular loop of epoll instances monitoring one another.
	2220	OperationCausesCircularLoop,
	2221
	2222	/// op was EPOLL_CTL_MOD or EPOLL_CTL_DEL, and fd is not registered with this epoll
	2223	/// instance.
	2224	FileDescriptorNotRegistered,
	2225
	2226	/// There was insufficient memory to handle the requested op control operation.
	2227	SystemResources,
	2228
	2229	/// The limit imposed by /proc/sys/fs/epoll/max_user_watches was encountered while
	2230	/// trying to register (EPOLL_CTL_ADD) a new file descriptor on an epoll instance.
	2231	/// See epoll(7) for further details.
	2232	UserResourceLimitReached,
	2233
	2234	/// The target file fd does not support epoll. This error can occur if fd refers to,
	2235	/// for example, a regular file or a directory.
	2236	FileDescriptorIncompatibleWithEpoll,
	2237
	2238	Unexpected,
	2239	};
	2240
	2241	pub fn linuxEpollCtl(epfd: i32, op: u32, fd: i32, event: &linux.epoll_event) LinuxEpollCtlError!void {
	2242	const rc = posix.epoll_ctl(epfd, op, fd, event);
	2243	const err = posix.getErrno(rc);
	2244	switch (err) {
	2245	0 => return,
	2246	else => return unexpectedErrorPosix(err),
	2247
	2248	posix.EBADF => return LinuxEpollCtlError.InvalidFileDescriptor,
	2249	posix.EEXIST => return LinuxEpollCtlError.FileDescriptorAlreadyPresentInSet,
	2250	posix.EINVAL => return LinuxEpollCtlError.InvalidSyscall,
	2251	posix.ELOOP => return LinuxEpollCtlError.OperationCausesCircularLoop,
	2252	posix.ENOENT => return LinuxEpollCtlError.FileDescriptorNotRegistered,
	2253	posix.ENOMEM => return LinuxEpollCtlError.SystemResources,
	2254	posix.ENOSPC => return LinuxEpollCtlError.UserResourceLimitReached,
	2255	posix.EPERM => return LinuxEpollCtlError.FileDescriptorIncompatibleWithEpoll,
	2256	}
	2257	}
	2258
	2259	pub fn linuxEpollWait(epfd: i32, events: []linux.epoll_event, timeout: i32) usize {
	2260	while (true) {
	2261	const rc = posix.epoll_wait(epfd, events.ptr, u32(events.len), timeout);
	2262	const err = posix.getErrno(rc);
	2263	switch (err) {
	2264	0 => return rc,
	2265	posix.EINTR => continue,
	2266	posix.EBADF => unreachable,
	2267	posix.EFAULT => unreachable,
	2268	posix.EINVAL => unreachable,
	2269	else => unreachable,
	2270	}
	2271	}
	2272	}
	2273
	2274	pub const PosixGetSockNameError = error {
	2275	/// Insufficient resources were available in the system to perform the operation.
	2276	SystemResources,
	2277
	2278	Unexpected,
	2279	};
	2280
	2281	pub fn posixGetSockName(sockfd: i32) PosixGetSockNameError!posix.sockaddr {
	2282	var addr: posix.sockaddr = undefined;
	2283	var addrlen: posix.socklen_t = @sizeOf(posix.sockaddr);
	2284	const rc = posix.getsockname(sockfd, &addr, &addrlen);
	2285	const err = posix.getErrno(rc);
	2286	switch (err) {
	2287	0 => return addr,
	2288	else => return unexpectedErrorPosix(err),
	2289
	2290	posix.EBADF => unreachable,
	2291	posix.EFAULT => unreachable,
	2292	posix.EINVAL => unreachable,
	2293	posix.ENOTSOCK => unreachable,
	2294	posix.ENOBUFS => return PosixGetSockNameError.SystemResources,
	2295	}
	2296	}
	2297
	2298	pub const PosixConnectError = error {
	2299	/// For UNIX domain sockets, which are identified by pathname: Write permission is denied on the socket
	2300	/// file, or search permission is denied for one of the directories in the path prefix.
	2301	/// or
	2302	/// The user tried to connect to a broadcast address without having the socket broadcast flag enabled or
	2303	/// the connection request failed because of a local firewall rule.
	2304	PermissionDenied,
	2305
	2306	/// Local address is already in use.
	2307	AddressInUse,
	2308
	2309	/// (Internet domain sockets) The socket referred to by sockfd had not previously been bound to an
	2310	/// address and, upon attempting to bind it to an ephemeral port, it was determined that all port numbers
	2311	/// in the ephemeral port range are currently in use. See the discussion of
	2312	/// /proc/sys/net/ipv4/ip_local_port_range in ip(7).
	2313	AddressNotAvailable,
	2314
	2315	/// The passed address didn't have the correct address family in its sa_family field.
	2316	AddressFamilyNotSupported,
	2317
	2318	/// Insufficient entries in the routing cache.
	2319	SystemResources,
	2320
	2321	/// A connect() on a stream socket found no one listening on the remote address.
	2322	ConnectionRefused,
	2323
	2324	/// Network is unreachable.
	2325	NetworkUnreachable,
	2326
	2327	/// Timeout while attempting connection. The server may be too busy to accept new connections. Note
	2328	/// that for IP sockets the timeout may be very long when syncookies are enabled on the server.
	2329	ConnectionTimedOut,
	2330
	2331	Unexpected,
	2332	};
	2333
	2334	pub fn posixConnect(sockfd: i32, sockaddr: &const posix.sockaddr) PosixConnectError!void {
	2335	while (true) {
	2336	const rc = posix.connect(sockfd, sockaddr, @sizeOf(posix.sockaddr));
	2337	const err = posix.getErrno(rc);
	2338	switch (err) {
	2339	0 => return,
	2340	else => return unexpectedErrorPosix(err),
	2341
	2342	posix.EACCES => return PosixConnectError.PermissionDenied,
	2343	posix.EPERM => return PosixConnectError.PermissionDenied,
	2344	posix.EADDRINUSE => return PosixConnectError.AddressInUse,
	2345	posix.EADDRNOTAVAIL => return PosixConnectError.AddressNotAvailable,
	2346	posix.EAFNOSUPPORT => return PosixConnectError.AddressFamilyNotSupported,
	2347	posix.EAGAIN => return PosixConnectError.SystemResources,
	2348	posix.EALREADY => unreachable, // The socket is nonblocking and a previous connection attempt has not yet been completed.
	2349	posix.EBADF => unreachable, // sockfd is not a valid open file descriptor.
	2350	posix.ECONNREFUSED => return PosixConnectError.ConnectionRefused,
	2351	posix.EFAULT => unreachable, // The socket structure address is outside the user's address space.
	2352	posix.EINPROGRESS => unreachable, // The socket is nonblocking and the connection cannot be completed immediately.
	2353	posix.EINTR => continue,
	2354	posix.EISCONN => unreachable, // The socket is already connected.
	2355	posix.ENETUNREACH => return PosixConnectError.NetworkUnreachable,
	2356	posix.ENOTSOCK => unreachable, // The file descriptor sockfd does not refer to a socket.
	2357	posix.EPROTOTYPE => unreachable, // The socket type does not support the requested communications protocol.
	2358	posix.ETIMEDOUT => return PosixConnectError.ConnectionTimedOut,
	2359	}
	2360	}
	2361	}
	2362
	2363	/// Same as posixConnect except it is for blocking socket file descriptors.
	2364	/// It expects to receive EINPROGRESS.
	2365	pub fn posixConnectAsync(sockfd: i32, sockaddr: &const posix.sockaddr) PosixConnectError!void {
	2366	while (true) {
	2367	const rc = posix.connect(sockfd, sockaddr, @sizeOf(posix.sockaddr));
	2368	const err = posix.getErrno(rc);
	2369	switch (err) {
	2370	0,
	2371	posix.EINPROGRESS => return,
	2372	else => return unexpectedErrorPosix(err),
	2373
	2374	posix.EACCES => return PosixConnectError.PermissionDenied,
	2375	posix.EPERM => return PosixConnectError.PermissionDenied,
	2376	posix.EADDRINUSE => return PosixConnectError.AddressInUse,
	2377	posix.EADDRNOTAVAIL => return PosixConnectError.AddressNotAvailable,
	2378	posix.EAFNOSUPPORT => return PosixConnectError.AddressFamilyNotSupported,
	2379	posix.EAGAIN => return PosixConnectError.SystemResources,
	2380	posix.EALREADY => unreachable, // The socket is nonblocking and a previous connection attempt has not yet been completed.
	2381	posix.EBADF => unreachable, // sockfd is not a valid open file descriptor.
	2382	posix.ECONNREFUSED => return PosixConnectError.ConnectionRefused,
	2383	posix.EFAULT => unreachable, // The socket structure address is outside the user's address space.
	2384	posix.EINTR => continue,
	2385	posix.EISCONN => unreachable, // The socket is already connected.
	2386	posix.ENETUNREACH => return PosixConnectError.NetworkUnreachable,
	2387	posix.ENOTSOCK => unreachable, // The file descriptor sockfd does not refer to a socket.
	2388	posix.EPROTOTYPE => unreachable, // The socket type does not support the requested communications protocol.
	2389	posix.ETIMEDOUT => return PosixConnectError.ConnectionTimedOut,
	2390	}
	2391	}
	2392	}
	2393
	2394	pub fn posixGetSockOptConnectError(sockfd: i32) PosixConnectError!void {
	2395	var err_code: i32 = undefined;
	2396	var size: u32 = @sizeOf(i32);
	2397	const rc = posix.getsockopt(sockfd, posix.SOL_SOCKET, posix.SO_ERROR, @ptrCast(&u8, &err_code), &size);
	2398	assert(size == 4);
	2399	const err = posix.getErrno(rc);
	2400	switch (err) {
	2401	0 => switch (err_code) {
	2402	0 => return,
	2403	else => return unexpectedErrorPosix(err),
	2404
	2405	posix.EACCES => return PosixConnectError.PermissionDenied,
	2406	posix.EPERM => return PosixConnectError.PermissionDenied,
	2407	posix.EADDRINUSE => return PosixConnectError.AddressInUse,
	2408	posix.EADDRNOTAVAIL => return PosixConnectError.AddressNotAvailable,
	2409	posix.EAFNOSUPPORT => return PosixConnectError.AddressFamilyNotSupported,
	2410	posix.EAGAIN => return PosixConnectError.SystemResources,
	2411	posix.EALREADY => unreachable, // The socket is nonblocking and a previous connection attempt has not yet been completed.
	2412	posix.EBADF => unreachable, // sockfd is not a valid open file descriptor.
	2413	posix.ECONNREFUSED => return PosixConnectError.ConnectionRefused,
	2414	posix.EFAULT => unreachable, // The socket structure address is outside the user's address space.
	2415	posix.EISCONN => unreachable, // The socket is already connected.
	2416	posix.ENETUNREACH => return PosixConnectError.NetworkUnreachable,
	2417	posix.ENOTSOCK => unreachable, // The file descriptor sockfd does not refer to a socket.
	2418	posix.EPROTOTYPE => unreachable, // The socket type does not support the requested communications protocol.
	2419	posix.ETIMEDOUT => return PosixConnectError.ConnectionTimedOut,
	2420	},
	2421	else => return unexpectedErrorPosix(err),
	2422	posix.EBADF => unreachable, // The argument sockfd is not a valid file descriptor.
	2423	posix.EFAULT => unreachable, // The address pointed to by optval or optlen is not in a valid part of the process address space.
	2424	posix.EINVAL => unreachable,
	2425	posix.ENOPROTOOPT => unreachable, // The option is unknown at the level indicated.
	2426	posix.ENOTSOCK => unreachable, // The file descriptor sockfd does not refer to a socket.
	2427	}
	2428	}
	2429
	2430	pub const Thread = struct {
	2431	data: Data,
	2432
	2433	pub const use_pthreads = is_posix and builtin.link_libc;
	2434	const Data = if (use_pthreads) struct {
	2435	handle: c.pthread_t,
	2436	stack_addr: usize,
	2437	stack_len: usize,
	2438	} else switch (builtin.os) {
	2439	builtin.Os.linux => struct {
	2440	pid: i32,
	2441	stack_addr: usize,
	2442	stack_len: usize,
	2443	},
	2444	builtin.Os.windows => struct {
	2445	handle: windows.HANDLE,
	2446	alloc_start: &c_void,
	2447	heap_handle: windows.HANDLE,
	2448	},
	2449	else => @compileError("Unsupported OS"),
	2450	};
	2451
	2452	pub fn wait(self: &const Thread) void {
	2453	if (use_pthreads) {
	2454	const err = c.pthread_join(self.data.handle, null);
	2455	switch (err) {
	2456	0 => {},
	2457	posix.EINVAL => unreachable,
	2458	posix.ESRCH => unreachable,
	2459	posix.EDEADLK => unreachable,
	2460	else => unreachable,
	2461	}
	2462	assert(posix.munmap(self.data.stack_addr, self.data.stack_len) == 0);
	2463	} else switch (builtin.os) {
	2464	builtin.Os.linux => {
	2465	while (true) {
	2466	const pid_value = @atomicLoad(i32, &self.data.pid, builtin.AtomicOrder.SeqCst);
	2467	if (pid_value == 0) break;
	2468	const rc = linux.futex_wait(@ptrToInt(&self.data.pid), linux.FUTEX_WAIT, pid_value, null);
	2469	switch (linux.getErrno(rc)) {
	2470	0 => continue,
	2471	posix.EINTR => continue,
	2472	posix.EAGAIN => continue,
	2473	else => unreachable,
	2474	}
	2475	}
	2476	assert(posix.munmap(self.data.stack_addr, self.data.stack_len) == 0);
	2477	},
	2478	builtin.Os.windows => {
	2479	assert(windows.WaitForSingleObject(self.data.handle, windows.INFINITE) == windows.WAIT_OBJECT_0);
	2480	assert(windows.CloseHandle(self.data.handle) != 0);
	2481	assert(windows.HeapFree(self.data.heap_handle, 0, self.data.alloc_start) != 0);
	2482	},
	2483	else => @compileError("Unsupported OS"),
	2484	}
	2485	}
	2486	};
	2487
	2488	pub const SpawnThreadError = error {
	2489	/// A system-imposed limit on the number of threads was encountered.
	2490	/// There are a number of limits that may trigger this error:
	2491	/// * the RLIMIT_NPROC soft resource limit (set via setrlimit(2)),
	2492	/// which limits the number of processes and threads for a real
	2493	/// user ID, was reached;
	2494	/// * the kernel's system-wide limit on the number of processes and
	2495	/// threads, /proc/sys/kernel/threads-max, was reached (see
	2496	/// proc(5));
	2497	/// * the maximum number of PIDs, /proc/sys/kernel/pid_max, was
	2498	/// reached (see proc(5)); or
	2499	/// * the PID limit (pids.max) imposed by the cgroup "process num‐
	2500	/// ber" (PIDs) controller was reached.
	2501	ThreadQuotaExceeded,
	2502
	2503	/// The kernel cannot allocate sufficient memory to allocate a task structure
	2504	/// for the child, or to copy those parts of the caller's context that need to
	2505	/// be copied.
	2506	SystemResources,
	2507
	2508	/// Not enough userland memory to spawn the thread.
	2509	OutOfMemory,
	2510
	2511	Unexpected,
	2512	};
	2513
	2514	/// caller must call wait on the returned thread
	2515	/// fn startFn(@typeOf(context)) T
	2516	/// where T is u8, noreturn, void, or !void
	2517	/// caller must call wait on the returned thread
	2518	pub fn spawnThread(context: var, comptime startFn: var) SpawnThreadError!&Thread {
	2519	// TODO compile-time call graph analysis to determine stack upper bound
	2520	// https://github.com/zig-lang/zig/issues/157
	2521	const default_stack_size = 8 * 1024 * 1024;
	2522
	2523	const Context = @typeOf(context);
	2524	comptime assert(@ArgType(@typeOf(startFn), 0) == Context);
	2525
	2526	if (builtin.os == builtin.Os.windows) {
	2527	const WinThread = struct {
	2528	const OuterContext = struct {
	2529	thread: Thread,
	2530	inner: Context,
	2531	};
	2532	extern fn threadMain(arg: windows.LPVOID) windows.DWORD {
	2533	if (@sizeOf(Context) == 0) {
	2534	return startFn({});
	2535	} else {
	2536	return startFn(*@ptrCast(&Context, @alignCast(@alignOf(Context), arg)));
	2537	}
	2538	}
	2539	};
	2540
	2541	const heap_handle = windows.GetProcessHeap() ?? return SpawnThreadError.OutOfMemory;
	2542	const byte_count = @alignOf(WinThread.OuterContext) + @sizeOf(WinThread.OuterContext);
	2543	const bytes_ptr = windows.HeapAlloc(heap_handle, 0, byte_count) ?? return SpawnThreadError.OutOfMemory;
	2544	errdefer assert(windows.HeapFree(heap_handle, 0, bytes_ptr) != 0);
	2545	const bytes = @ptrCast(&u8, bytes_ptr)[0..byte_count];
	2546	const outer_context = std.heap.FixedBufferAllocator.init(bytes).allocator.create(WinThread.OuterContext) catch unreachable;
	2547	outer_context.inner = context;
	2548	outer_context.thread.data.heap_handle = heap_handle;
	2549	outer_context.thread.data.alloc_start = bytes_ptr;
	2550
	2551	const parameter = if (@sizeOf(Context) == 0) null else @ptrCast(&c_void, &outer_context.inner);
	2552	outer_context.thread.data.handle = windows.CreateThread(null, default_stack_size, WinThread.threadMain, parameter, 0, null) ?? {
	2553	const err = windows.GetLastError();
	2554	return switch (err) {
	2555	else => os.unexpectedErrorWindows(err),
	2556	};
	2557	};
	2558	return &outer_context.thread;
	2559	}
	2560
	2561	const MainFuncs = struct {
	2562	extern fn linuxThreadMain(ctx_addr: usize) u8 {
	2563	if (@sizeOf(Context) == 0) {
	2564	return startFn({});
	2565	} else {
	2566	return startFn(*@intToPtr(&const Context, ctx_addr));
	2567	}
	2568	}
	2569	extern fn posixThreadMain(ctx: ?&c_void) ?&c_void {
	2570	if (@sizeOf(Context) == 0) {
	2571	_ = startFn({});
	2572	return null;
	2573	} else {
	2574	_ = startFn(*@ptrCast(&const Context, @alignCast(@alignOf(Context), ctx)));
	2575	return null;
	2576	}
	2577	}
	2578	};
	2579
	2580	const MAP_GROWSDOWN = if (builtin.os == builtin.Os.linux) linux.MAP_GROWSDOWN else 0;
	2581
	2582	const mmap_len = default_stack_size;
	2583	const stack_addr = posix.mmap(null, mmap_len, posix.PROT_READ \| posix.PROT_WRITE, posix.MAP_PRIVATE \| posix.MAP_ANONYMOUS \| MAP_GROWSDOWN, -1, 0);
	2584	if (stack_addr == posix.MAP_FAILED) return error.OutOfMemory;
	2585	errdefer assert(posix.munmap(stack_addr, mmap_len) == 0);
	2586
	2587	var stack_end: usize = stack_addr + mmap_len;
	2588	var arg: usize = undefined;
	2589	if (@sizeOf(Context) != 0) {
	2590	stack_end -= @sizeOf(Context);
	2591	stack_end -= stack_end % @alignOf(Context);
	2592	assert(stack_end >= stack_addr);
	2593	const context_ptr = @alignCast(@alignOf(Context), @intToPtr(&Context, stack_end));
	2594	*context_ptr = context;
	2595	arg = stack_end;
	2596	}
	2597
	2598	stack_end -= @sizeOf(Thread);
	2599	stack_end -= stack_end % @alignOf(Thread);
	2600	assert(stack_end >= stack_addr);
	2601	const thread_ptr = @alignCast(@alignOf(Thread), @intToPtr(&Thread, stack_end));
	2602
	2603	thread_ptr.data.stack_addr = stack_addr;
	2604	thread_ptr.data.stack_len = mmap_len;
	2605
	2606	if (builtin.os == builtin.Os.windows) {
	2607	// use windows API directly
	2608	@compileError("TODO support spawnThread for Windows");
	2609	} else if (Thread.use_pthreads) {
	2610	// use pthreads
	2611	var attr: c.pthread_attr_t = undefined;
	2612	if (c.pthread_attr_init(&attr) != 0) return SpawnThreadError.SystemResources;
	2613	defer assert(c.pthread_attr_destroy(&attr) == 0);
	2614
	2615	// align to page
	2616	stack_end -= stack_end % os.page_size;
	2617	assert(c.pthread_attr_setstack(&attr, @intToPtr(&c_void, stack_addr), stack_end - stack_addr) == 0);
	2618
	2619	const err = c.pthread_create(&thread_ptr.data.handle, &attr, MainFuncs.posixThreadMain, @intToPtr(&c_void, arg));
	2620	switch (err) {
	2621	0 => return thread_ptr,
	2622	posix.EAGAIN => return SpawnThreadError.SystemResources,
	2623	posix.EPERM => unreachable,
	2624	posix.EINVAL => unreachable,
	2625	else => return unexpectedErrorPosix(usize(err)),
	2626	}
	2627	} else if (builtin.os == builtin.Os.linux) {
	2628	// use linux API directly. TODO use posix.CLONE_SETTLS and initialize thread local storage correctly
	2629	const flags = posix.CLONE_VM \| posix.CLONE_FS \| posix.CLONE_FILES \| posix.CLONE_SIGHAND \| posix.CLONE_THREAD \| posix.CLONE_SYSVSEM \| posix.CLONE_PARENT_SETTID \| posix.CLONE_CHILD_CLEARTID \| posix.CLONE_DETACHED;
	2630	const newtls: usize = 0;
	2631	const rc = posix.clone(MainFuncs.linuxThreadMain, stack_end, flags, arg, &thread_ptr.data.pid, newtls, &thread_ptr.data.pid);
	2632	const err = posix.getErrno(rc);
	2633	switch (err) {
	2634	0 => return thread_ptr,
	2635	posix.EAGAIN => return SpawnThreadError.ThreadQuotaExceeded,
	2636	posix.EINVAL => unreachable,
	2637	posix.ENOMEM => return SpawnThreadError.SystemResources,
	2638	posix.ENOSPC => unreachable,
	2639	posix.EPERM => unreachable,
	2640	posix.EUSERS => unreachable,
	2641	else => return unexpectedErrorPosix(err),
	2642	}
	2643	} else {
	2644	@compileError("Unsupported OS");
	2645	}
	2646	}
	2647
	2648	pub fn posixWait(pid: i32) i32 {
	2649	var status: i32 = undefined;
	2650	while (true) {
	2651	const err = posix.getErrno(posix.waitpid(pid, &status, 0));
	2652	switch (err) {
	2653	0 => return status,
	2654	posix.EINTR => continue,
	2655	posix.ECHILD => unreachable, // The process specified does not exist. It would be a race condition to handle this error.
	2656	posix.EINVAL => unreachable, // The options argument was invalid
	2657	else => unreachable,
	2658	}
	2659	}
	2660	}

std/os/linux/i386.zig deleted-505

...	...	@@ -1,505 +0,0 @@
1		const std = @import("../../index.zig");
2		const linux = std.os.linux;
3		const socklen_t = linux.socklen_t;
4		const iovec = linux.iovec;
5
6		pub const SYS_restart_syscall = 0;
7		pub const SYS_exit = 1;
8		pub const SYS_fork = 2;
9		pub const SYS_read = 3;
10		pub const SYS_write = 4;
11		pub const SYS_open = 5;
12		pub const SYS_close = 6;
13		pub const SYS_waitpid = 7;
14		pub const SYS_creat = 8;
15		pub const SYS_link = 9;
16		pub const SYS_unlink = 10;
17		pub const SYS_execve = 11;
18		pub const SYS_chdir = 12;
19		pub const SYS_time = 13;
20		pub const SYS_mknod = 14;
21		pub const SYS_chmod = 15;
22		pub const SYS_lchown = 16;
23		pub const SYS_break = 17;
24		pub const SYS_oldstat = 18;
25		pub const SYS_lseek = 19;
26		pub const SYS_getpid = 20;
27		pub const SYS_mount = 21;
28		pub const SYS_umount = 22;
29		pub const SYS_setuid = 23;
30		pub const SYS_getuid = 24;
31		pub const SYS_stime = 25;
32		pub const SYS_ptrace = 26;
33		pub const SYS_alarm = 27;
34		pub const SYS_oldfstat = 28;
35		pub const SYS_pause = 29;
36		pub const SYS_utime = 30;
37		pub const SYS_stty = 31;
38		pub const SYS_gtty = 32;
39		pub const SYS_access = 33;
40		pub const SYS_nice = 34;
41		pub const SYS_ftime = 35;
42		pub const SYS_sync = 36;
43		pub const SYS_kill = 37;
44		pub const SYS_rename = 38;
45		pub const SYS_mkdir = 39;
46		pub const SYS_rmdir = 40;
47		pub const SYS_dup = 41;
48		pub const SYS_pipe = 42;
49		pub const SYS_times = 43;
50		pub const SYS_prof = 44;
51		pub const SYS_brk = 45;
52		pub const SYS_setgid = 46;
53		pub const SYS_getgid = 47;
54		pub const SYS_signal = 48;
55		pub const SYS_geteuid = 49;
56		pub const SYS_getegid = 50;
57		pub const SYS_acct = 51;
58		pub const SYS_umount2 = 52;
59		pub const SYS_lock = 53;
60		pub const SYS_ioctl = 54;
61		pub const SYS_fcntl = 55;
62		pub const SYS_mpx = 56;
63		pub const SYS_setpgid = 57;
64		pub const SYS_ulimit = 58;
65		pub const SYS_oldolduname = 59;
66		pub const SYS_umask = 60;
67		pub const SYS_chroot = 61;
68		pub const SYS_ustat = 62;
69		pub const SYS_dup2 = 63;
70		pub const SYS_getppid = 64;
71		pub const SYS_getpgrp = 65;
72		pub const SYS_setsid = 66;
73		pub const SYS_sigaction = 67;
74		pub const SYS_sgetmask = 68;
75		pub const SYS_ssetmask = 69;
76		pub const SYS_setreuid = 70;
77		pub const SYS_setregid = 71;
78		pub const SYS_sigsuspend = 72;
79		pub const SYS_sigpending = 73;
80		pub const SYS_sethostname = 74;
81		pub const SYS_setrlimit = 75;
82		pub const SYS_getrlimit = 76;
83		pub const SYS_getrusage = 77;
84		pub const SYS_gettimeofday = 78;
85		pub const SYS_settimeofday = 79;
86		pub const SYS_getgroups = 80;
87		pub const SYS_setgroups = 81;
88		pub const SYS_select = 82;
89		pub const SYS_symlink = 83;
90		pub const SYS_oldlstat = 84;
91		pub const SYS_readlink = 85;
92		pub const SYS_uselib = 86;
93		pub const SYS_swapon = 87;
94		pub const SYS_reboot = 88;
95		pub const SYS_readdir = 89;
96		pub const SYS_mmap = 90;
97		pub const SYS_munmap = 91;
98		pub const SYS_truncate = 92;
99		pub const SYS_ftruncate = 93;
100		pub const SYS_fchmod = 94;
101		pub const SYS_fchown = 95;
102		pub const SYS_getpriority = 96;
103		pub const SYS_setpriority = 97;
104		pub const SYS_profil = 98;
105		pub const SYS_statfs = 99;
106		pub const SYS_fstatfs = 100;
107		pub const SYS_ioperm = 101;
108		pub const SYS_socketcall = 102;
109		pub const SYS_syslog = 103;
110		pub const SYS_setitimer = 104;
111		pub const SYS_getitimer = 105;
112		pub const SYS_stat = 106;
113		pub const SYS_lstat = 107;
114		pub const SYS_fstat = 108;
115		pub const SYS_olduname = 109;
116		pub const SYS_iopl = 110;
117		pub const SYS_vhangup = 111;
118		pub const SYS_idle = 112;
119		pub const SYS_vm86old = 113;
120		pub const SYS_wait4 = 114;
121		pub const SYS_swapoff = 115;
122		pub const SYS_sysinfo = 116;
123		pub const SYS_ipc = 117;
124		pub const SYS_fsync = 118;
125		pub const SYS_sigreturn = 119;
126		pub const SYS_clone = 120;
127		pub const SYS_setdomainname = 121;
128		pub const SYS_uname = 122;
129		pub const SYS_modify_ldt = 123;
130		pub const SYS_adjtimex = 124;
131		pub const SYS_mprotect = 125;
132		pub const SYS_sigprocmask = 126;
133		pub const SYS_create_module = 127;
134		pub const SYS_init_module = 128;
135		pub const SYS_delete_module = 129;
136		pub const SYS_get_kernel_syms = 130;
137		pub const SYS_quotactl = 131;
138		pub const SYS_getpgid = 132;
139		pub const SYS_fchdir = 133;
140		pub const SYS_bdflush = 134;
141		pub const SYS_sysfs = 135;
142		pub const SYS_personality = 136;
143		pub const SYS_afs_syscall = 137;
144		pub const SYS_setfsuid = 138;
145		pub const SYS_setfsgid = 139;
146		pub const SYS__llseek = 140;
147		pub const SYS_getdents = 141;
148		pub const SYS__newselect = 142;
149		pub const SYS_flock = 143;
150		pub const SYS_msync = 144;
151		pub const SYS_readv = 145;
152		pub const SYS_writev = 146;
153		pub const SYS_getsid = 147;
154		pub const SYS_fdatasync = 148;
155		pub const SYS__sysctl = 149;
156		pub const SYS_mlock = 150;
157		pub const SYS_munlock = 151;
158		pub const SYS_mlockall = 152;
159		pub const SYS_munlockall = 153;
160		pub const SYS_sched_setparam = 154;
161		pub const SYS_sched_getparam = 155;
162		pub const SYS_sched_setscheduler = 156;
163		pub const SYS_sched_getscheduler = 157;
164		pub const SYS_sched_yield = 158;
165		pub const SYS_sched_get_priority_max = 159;
166		pub const SYS_sched_get_priority_min = 160;
167		pub const SYS_sched_rr_get_interval = 161;
168		pub const SYS_nanosleep = 162;
169		pub const SYS_mremap = 163;
170		pub const SYS_setresuid = 164;
171		pub const SYS_getresuid = 165;
172		pub const SYS_vm86 = 166;
173		pub const SYS_query_module = 167;
174		pub const SYS_poll = 168;
175		pub const SYS_nfsservctl = 169;
176		pub const SYS_setresgid = 170;
177		pub const SYS_getresgid = 171;
178		pub const SYS_prctl = 172;
179		pub const SYS_rt_sigreturn = 173;
180		pub const SYS_rt_sigaction = 174;
181		pub const SYS_rt_sigprocmask = 175;
182		pub const SYS_rt_sigpending = 176;
183		pub const SYS_rt_sigtimedwait = 177;
184		pub const SYS_rt_sigqueueinfo = 178;
185		pub const SYS_rt_sigsuspend = 179;
186		pub const SYS_pread64 = 180;
187		pub const SYS_pwrite64 = 181;
188		pub const SYS_chown = 182;
189		pub const SYS_getcwd = 183;
190		pub const SYS_capget = 184;
191		pub const SYS_capset = 185;
192		pub const SYS_sigaltstack = 186;
193		pub const SYS_sendfile = 187;
194		pub const SYS_getpmsg = 188;
195		pub const SYS_putpmsg = 189;
196		pub const SYS_vfork = 190;
197		pub const SYS_ugetrlimit = 191;
198		pub const SYS_mmap2 = 192;
199		pub const SYS_truncate64 = 193;
200		pub const SYS_ftruncate64 = 194;
201		pub const SYS_stat64 = 195;
202		pub const SYS_lstat64 = 196;
203		pub const SYS_fstat64 = 197;
204		pub const SYS_lchown32 = 198;
205		pub const SYS_getuid32 = 199;
206		pub const SYS_getgid32 = 200;
207		pub const SYS_geteuid32 = 201;
208		pub const SYS_getegid32 = 202;
209		pub const SYS_setreuid32 = 203;
210		pub const SYS_setregid32 = 204;
211		pub const SYS_getgroups32 = 205;
212		pub const SYS_setgroups32 = 206;
213		pub const SYS_fchown32 = 207;
214		pub const SYS_setresuid32 = 208;
215		pub const SYS_getresuid32 = 209;
216		pub const SYS_setresgid32 = 210;
217		pub const SYS_getresgid32 = 211;
218		pub const SYS_chown32 = 212;
219		pub const SYS_setuid32 = 213;
220		pub const SYS_setgid32 = 214;
221		pub const SYS_setfsuid32 = 215;
222		pub const SYS_setfsgid32 = 216;
223		pub const SYS_pivot_root = 217;
224		pub const SYS_mincore = 218;
225		pub const SYS_madvise = 219;
226		pub const SYS_madvise1 = 219;
227		pub const SYS_getdents64 = 220;
228		pub const SYS_fcntl64 = 221;
229		pub const SYS_gettid = 224;
230		pub const SYS_readahead = 225;
231		pub const SYS_setxattr = 226;
232		pub const SYS_lsetxattr = 227;
233		pub const SYS_fsetxattr = 228;
234		pub const SYS_getxattr = 229;
235		pub const SYS_lgetxattr = 230;
236		pub const SYS_fgetxattr = 231;
237		pub const SYS_listxattr = 232;
238		pub const SYS_llistxattr = 233;
239		pub const SYS_flistxattr = 234;
240		pub const SYS_removexattr = 235;
241		pub const SYS_lremovexattr = 236;
242		pub const SYS_fremovexattr = 237;
243		pub const SYS_tkill = 238;
244		pub const SYS_sendfile64 = 239;
245		pub const SYS_futex = 240;
246		pub const SYS_sched_setaffinity = 241;
247		pub const SYS_sched_getaffinity = 242;
248		pub const SYS_set_thread_area = 243;
249		pub const SYS_get_thread_area = 244;
250		pub const SYS_io_setup = 245;
251		pub const SYS_io_destroy = 246;
252		pub const SYS_io_getevents = 247;
253		pub const SYS_io_submit = 248;
254		pub const SYS_io_cancel = 249;
255		pub const SYS_fadvise64 = 250;
256		pub const SYS_exit_group = 252;
257		pub const SYS_lookup_dcookie = 253;
258		pub const SYS_epoll_create = 254;
259		pub const SYS_epoll_ctl = 255;
260		pub const SYS_epoll_wait = 256;
261		pub const SYS_remap_file_pages = 257;
262		pub const SYS_set_tid_address = 258;
263		pub const SYS_timer_create = 259;
264		pub const SYS_timer_settime = SYS_timer_create+1;
265		pub const SYS_timer_gettime = SYS_timer_create+2;
266		pub const SYS_timer_getoverrun = SYS_timer_create+3;
267		pub const SYS_timer_delete = SYS_timer_create+4;
268		pub const SYS_clock_settime = SYS_timer_create+5;
269		pub const SYS_clock_gettime = SYS_timer_create+6;
270		pub const SYS_clock_getres = SYS_timer_create+7;
271		pub const SYS_clock_nanosleep = SYS_timer_create+8;
272		pub const SYS_statfs64 = 268;
273		pub const SYS_fstatfs64 = 269;
274		pub const SYS_tgkill = 270;
275		pub const SYS_utimes = 271;
276		pub const SYS_fadvise64_64 = 272;
277		pub const SYS_vserver = 273;
278		pub const SYS_mbind = 274;
279		pub const SYS_get_mempolicy = 275;
280		pub const SYS_set_mempolicy = 276;
281		pub const SYS_mq_open = 277;
282		pub const SYS_mq_unlink = SYS_mq_open+1;
283		pub const SYS_mq_timedsend = SYS_mq_open+2;
284		pub const SYS_mq_timedreceive = SYS_mq_open+3;
285		pub const SYS_mq_notify = SYS_mq_open+4;
286		pub const SYS_mq_getsetattr = SYS_mq_open+5;
287		pub const SYS_kexec_load = 283;
288		pub const SYS_waitid = 284;
289		pub const SYS_add_key = 286;
290		pub const SYS_request_key = 287;
291		pub const SYS_keyctl = 288;
292		pub const SYS_ioprio_set = 289;
293		pub const SYS_ioprio_get = 290;
294		pub const SYS_inotify_init = 291;
295		pub const SYS_inotify_add_watch = 292;
296		pub const SYS_inotify_rm_watch = 293;
297		pub const SYS_migrate_pages = 294;
298		pub const SYS_openat = 295;
299		pub const SYS_mkdirat = 296;
300		pub const SYS_mknodat = 297;
301		pub const SYS_fchownat = 298;
302		pub const SYS_futimesat = 299;
303		pub const SYS_fstatat64 = 300;
304		pub const SYS_unlinkat = 301;
305		pub const SYS_renameat = 302;
306		pub const SYS_linkat = 303;
307		pub const SYS_symlinkat = 304;
308		pub const SYS_readlinkat = 305;
309		pub const SYS_fchmodat = 306;
310		pub const SYS_faccessat = 307;
311		pub const SYS_pselect6 = 308;
312		pub const SYS_ppoll = 309;
313		pub const SYS_unshare = 310;
314		pub const SYS_set_robust_list = 311;
315		pub const SYS_get_robust_list = 312;
316		pub const SYS_splice = 313;
317		pub const SYS_sync_file_range = 314;
318		pub const SYS_tee = 315;
319		pub const SYS_vmsplice = 316;
320		pub const SYS_move_pages = 317;
321		pub const SYS_getcpu = 318;
322		pub const SYS_epoll_pwait = 319;
323		pub const SYS_utimensat = 320;
324		pub const SYS_signalfd = 321;
325		pub const SYS_timerfd_create = 322;
326		pub const SYS_eventfd = 323;
327		pub const SYS_fallocate = 324;
328		pub const SYS_timerfd_settime = 325;
329		pub const SYS_timerfd_gettime = 326;
330		pub const SYS_signalfd4 = 327;
331		pub const SYS_eventfd2 = 328;
332		pub const SYS_epoll_create1 = 329;
333		pub const SYS_dup3 = 330;
334		pub const SYS_pipe2 = 331;
335		pub const SYS_inotify_init1 = 332;
336		pub const SYS_preadv = 333;
337		pub const SYS_pwritev = 334;
338		pub const SYS_rt_tgsigqueueinfo = 335;
339		pub const SYS_perf_event_open = 336;
340		pub const SYS_recvmmsg = 337;
341		pub const SYS_fanotify_init = 338;
342		pub const SYS_fanotify_mark = 339;
343		pub const SYS_prlimit64 = 340;
344		pub const SYS_name_to_handle_at = 341;
345		pub const SYS_open_by_handle_at = 342;
346		pub const SYS_clock_adjtime = 343;
347		pub const SYS_syncfs = 344;
348		pub const SYS_sendmmsg = 345;
349		pub const SYS_setns = 346;
350		pub const SYS_process_vm_readv = 347;
351		pub const SYS_process_vm_writev = 348;
352		pub const SYS_kcmp = 349;
353		pub const SYS_finit_module = 350;
354		pub const SYS_sched_setattr = 351;
355		pub const SYS_sched_getattr = 352;
356		pub const SYS_renameat2 = 353;
357		pub const SYS_seccomp = 354;
358		pub const SYS_getrandom = 355;
359		pub const SYS_memfd_create = 356;
360		pub const SYS_bpf = 357;
361		pub const SYS_execveat = 358;
362		pub const SYS_socket = 359;
363		pub const SYS_socketpair = 360;
364		pub const SYS_bind = 361;
365		pub const SYS_connect = 362;
366		pub const SYS_listen = 363;
367		pub const SYS_accept4 = 364;
368		pub const SYS_getsockopt = 365;
369		pub const SYS_setsockopt = 366;
370		pub const SYS_getsockname = 367;
371		pub const SYS_getpeername = 368;
372		pub const SYS_sendto = 369;
373		pub const SYS_sendmsg = 370;
374		pub const SYS_recvfrom = 371;
375		pub const SYS_recvmsg = 372;
376		pub const SYS_shutdown = 373;
377		pub const SYS_userfaultfd = 374;
378		pub const SYS_membarrier = 375;
379		pub const SYS_mlock2 = 376;
380
381
382		pub const O_CREAT = 0o100;
383		pub const O_EXCL = 0o200;
384		pub const O_NOCTTY = 0o400;
385		pub const O_TRUNC = 0o1000;
386		pub const O_APPEND = 0o2000;
387		pub const O_NONBLOCK = 0o4000;
388		pub const O_DSYNC = 0o10000;
389		pub const O_SYNC = 0o4010000;
390		pub const O_RSYNC = 0o4010000;
391		pub const O_DIRECTORY = 0o200000;
392		pub const O_NOFOLLOW = 0o400000;
393		pub const O_CLOEXEC = 0o2000000;
394
395		pub const O_ASYNC = 0o20000;
396		pub const O_DIRECT = 0o40000;
397		pub const O_LARGEFILE = 0o100000;
398		pub const O_NOATIME = 0o1000000;
399		pub const O_PATH = 0o10000000;
400		pub const O_TMPFILE = 0o20200000;
401		pub const O_NDELAY = O_NONBLOCK;
402
403		pub const F_DUPFD = 0;
404		pub const F_GETFD = 1;
405		pub const F_SETFD = 2;
406		pub const F_GETFL = 3;
407		pub const F_SETFL = 4;
408
409		pub const F_SETOWN = 8;
410		pub const F_GETOWN = 9;
411		pub const F_SETSIG = 10;
412		pub const F_GETSIG = 11;
413
414		pub const F_GETLK = 12;
415		pub const F_SETLK = 13;
416		pub const F_SETLKW = 14;
417
418		pub const F_SETOWN_EX = 15;
419		pub const F_GETOWN_EX = 16;
420
421		pub const F_GETOWNER_UIDS = 17;
422
423		pub inline fn syscall0(number: usize) usize {
424		return asm volatile ("int $0x80"
425		: [ret] "={eax}" (-> usize)
426		: [number] "{eax}" (number));
427		}
428
429		pub inline fn syscall1(number: usize, arg1: usize) usize {
430		return asm volatile ("int $0x80"
431		: [ret] "={eax}" (-> usize)
432		: [number] "{eax}" (number),
433		[arg1] "{ebx}" (arg1));
434		}
435
436		pub inline fn syscall2(number: usize, arg1: usize, arg2: usize) usize {
437		return asm volatile ("int $0x80"
438		: [ret] "={eax}" (-> usize)
439		: [number] "{eax}" (number),
440		[arg1] "{ebx}" (arg1),
441		[arg2] "{ecx}" (arg2));
442		}
443
444		pub inline fn syscall3(number: usize, arg1: usize, arg2: usize, arg3: usize) usize {
445		return asm volatile ("int $0x80"
446		: [ret] "={eax}" (-> usize)
447		: [number] "{eax}" (number),
448		[arg1] "{ebx}" (arg1),
449		[arg2] "{ecx}" (arg2),
450		[arg3] "{edx}" (arg3));
451		}
452
453		pub inline fn syscall4(number: usize, arg1: usize, arg2: usize, arg3: usize, arg4: usize) usize {
454		return asm volatile ("int $0x80"
455		: [ret] "={eax}" (-> usize)
456		: [number] "{eax}" (number),
457		[arg1] "{ebx}" (arg1),
458		[arg2] "{ecx}" (arg2),
459		[arg3] "{edx}" (arg3),
460		[arg4] "{esi}" (arg4));
461		}
462
463		pub inline fn syscall5(number: usize, arg1: usize, arg2: usize, arg3: usize,
464		arg4: usize, arg5: usize) usize
465		{
466		return asm volatile ("int $0x80"
467		: [ret] "={eax}" (-> usize)
468		: [number] "{eax}" (number),
469		[arg1] "{ebx}" (arg1),
470		[arg2] "{ecx}" (arg2),
471		[arg3] "{edx}" (arg3),
472		[arg4] "{esi}" (arg4),
473		[arg5] "{edi}" (arg5));
474		}
475
476		pub inline fn syscall6(number: usize, arg1: usize, arg2: usize, arg3: usize,
477		arg4: usize, arg5: usize, arg6: usize) usize
478		{
479		return asm volatile ("int $0x80"
480		: [ret] "={eax}" (-> usize)
481		: [number] "{eax}" (number),
482		[arg1] "{ebx}" (arg1),
483		[arg2] "{ecx}" (arg2),
484		[arg3] "{edx}" (arg3),
485		[arg4] "{esi}" (arg4),
486		[arg5] "{edi}" (arg5),
487		[arg6] "{ebp}" (arg6));
488		}
489
490		pub nakedcc fn restore() void {
491		asm volatile (
492		\\popl %%eax
493		\\movl $119, %%eax
494		\\int $0x80
495		:
496		:
497		: "rcx", "r11");
498		}
499
500		pub nakedcc fn restore_rt() void {
501		asm volatile ("int $0x80"
502		:
503		: [number] "{eax}" (usize(SYS_rt_sigreturn))
504		: "rcx", "r11");
505		}

std/os/linux/index.zig+621-68

...	...	@@ -1,6 +1,7 @@
1	1	const std = @import("../../index.zig");
2	2	const assert = std.debug.assert;
3	3	const builtin = @import("builtin");
	4	const vdso = @import("vdso.zig");
4	5	pub use switch (builtin.arch) {
5	6	builtin.Arch.x86_64 => @import("x86_64.zig"),
6	7	builtin.Arch.i386 => @import("i386.zig"),
...	...	@@ -14,6 +15,22 @@ pub const STDIN_FILENO = 0;
14	15	pub const STDOUT_FILENO = 1;
15	16	pub const STDERR_FILENO = 2;
16	17
	18	pub const FUTEX_WAIT = 0;
	19	pub const FUTEX_WAKE = 1;
	20	pub const FUTEX_FD = 2;
	21	pub const FUTEX_REQUEUE = 3;
	22	pub const FUTEX_CMP_REQUEUE = 4;
	23	pub const FUTEX_WAKE_OP = 5;
	24	pub const FUTEX_LOCK_PI = 6;
	25	pub const FUTEX_UNLOCK_PI = 7;
	26	pub const FUTEX_TRYLOCK_PI = 8;
	27	pub const FUTEX_WAIT_BITSET = 9;
	28
	29	pub const FUTEX_PRIVATE_FLAG = 128;
	30
	31	pub const FUTEX_CLOCK_REALTIME = 256;
	32
	33
17	34	pub const PROT_NONE = 0;
18	35	pub const PROT_READ = 1;
19	36	pub const PROT_WRITE = 2;
...	...	@@ -38,6 +55,11 @@ pub const MAP_STACK = 0x20000;
38	55	pub const MAP_HUGETLB = 0x40000;
39	56	pub const MAP_FILE = 0;
40	57
	58	pub const F_OK = 0;
	59	pub const X_OK = 1;
	60	pub const W_OK = 2;
	61	pub const R_OK = 4;
	62
41	63	pub const WNOHANG = 1;
42	64	pub const WUNTRACED = 2;
43	65	pub const WSTOPPED = 2;
...	...	@@ -101,17 +123,6 @@ pub const SIG_BLOCK = 0;
101	123	pub const SIG_UNBLOCK = 1;
102	124	pub const SIG_SETMASK = 2;
103	125
104		pub const SOCK_STREAM = 1;
105		pub const SOCK_DGRAM = 2;
106		pub const SOCK_RAW = 3;
107		pub const SOCK_RDM = 4;
108		pub const SOCK_SEQPACKET = 5;
109		pub const SOCK_DCCP = 6;
110		pub const SOCK_PACKET = 10;
111		pub const SOCK_CLOEXEC = 0o2000000;
112		pub const SOCK_NONBLOCK = 0o4000;
113
114
115	126	pub const PROTO_ip = 0o000;
116	127	pub const PROTO_icmp = 0o001;
117	128	pub const PROTO_igmp = 0o002;
...	...	@@ -149,6 +160,20 @@ pub const PROTO_encap = 0o142;
149	160	pub const PROTO_pim = 0o147;
150	161	pub const PROTO_raw = 0o377;
151	162
	163	pub const SHUT_RD = 0;
	164	pub const SHUT_WR = 1;
	165	pub const SHUT_RDWR = 2;
	166
	167	pub const SOCK_STREAM = 1;
	168	pub const SOCK_DGRAM = 2;
	169	pub const SOCK_RAW = 3;
	170	pub const SOCK_RDM = 4;
	171	pub const SOCK_SEQPACKET = 5;
	172	pub const SOCK_DCCP = 6;
	173	pub const SOCK_PACKET = 10;
	174	pub const SOCK_CLOEXEC = 0o2000000;
	175	pub const SOCK_NONBLOCK = 0o4000;
	176
152	177	pub const PF_UNSPEC = 0;
153	178	pub const PF_LOCAL = 1;
154	179	pub const PF_UNIX = PF_LOCAL;
...	...	@@ -193,7 +218,10 @@ pub const PF_CAIF = 37;
193	218	pub const PF_ALG = 38;
194	219	pub const PF_NFC = 39;
195	220	pub const PF_VSOCK = 40;
196		pub const PF_MAX = 41;
	221	pub const PF_KCM = 41;
	222	pub const PF_QIPCRTR = 42;
	223	pub const PF_SMC = 43;
	224	pub const PF_MAX = 44;
197	225
198	226	pub const AF_UNSPEC = PF_UNSPEC;
199	227	pub const AF_LOCAL = PF_LOCAL;
...	...	@@ -239,8 +267,137 @@ pub const AF_CAIF = PF_CAIF;
239	267	pub const AF_ALG = PF_ALG;
240	268	pub const AF_NFC = PF_NFC;
241	269	pub const AF_VSOCK = PF_VSOCK;
	270	pub const AF_KCM = PF_KCM;
	271	pub const AF_QIPCRTR = PF_QIPCRTR;
	272	pub const AF_SMC = PF_SMC;
242	273	pub const AF_MAX = PF_MAX;
243	274
	275	pub const SO_DEBUG = 1;
	276	pub const SO_REUSEADDR = 2;
	277	pub const SO_TYPE = 3;
	278	pub const SO_ERROR = 4;
	279	pub const SO_DONTROUTE = 5;
	280	pub const SO_BROADCAST = 6;
	281	pub const SO_SNDBUF = 7;
	282	pub const SO_RCVBUF = 8;
	283	pub const SO_KEEPALIVE = 9;
	284	pub const SO_OOBINLINE = 10;
	285	pub const SO_NO_CHECK = 11;
	286	pub const SO_PRIORITY = 12;
	287	pub const SO_LINGER = 13;
	288	pub const SO_BSDCOMPAT = 14;
	289	pub const SO_REUSEPORT = 15;
	290	pub const SO_PASSCRED = 16;
	291	pub const SO_PEERCRED = 17;
	292	pub const SO_RCVLOWAT = 18;
	293	pub const SO_SNDLOWAT = 19;
	294	pub const SO_RCVTIMEO = 20;
	295	pub const SO_SNDTIMEO = 21;
	296	pub const SO_ACCEPTCONN = 30;
	297	pub const SO_SNDBUFFORCE = 32;
	298	pub const SO_RCVBUFFORCE = 33;
	299	pub const SO_PROTOCOL = 38;
	300	pub const SO_DOMAIN = 39;
	301
	302	pub const SO_SECURITY_AUTHENTICATION = 22;
	303	pub const SO_SECURITY_ENCRYPTION_TRANSPORT = 23;
	304	pub const SO_SECURITY_ENCRYPTION_NETWORK = 24;
	305
	306	pub const SO_BINDTODEVICE = 25;
	307
	308	pub const SO_ATTACH_FILTER = 26;
	309	pub const SO_DETACH_FILTER = 27;
	310	pub const SO_GET_FILTER = SO_ATTACH_FILTER;
	311
	312	pub const SO_PEERNAME = 28;
	313	pub const SO_TIMESTAMP = 29;
	314	pub const SCM_TIMESTAMP = SO_TIMESTAMP;
	315
	316	pub const SO_PEERSEC = 31;
	317	pub const SO_PASSSEC = 34;
	318	pub const SO_TIMESTAMPNS = 35;
	319	pub const SCM_TIMESTAMPNS = SO_TIMESTAMPNS;
	320	pub const SO_MARK = 36;
	321	pub const SO_TIMESTAMPING = 37;
	322	pub const SCM_TIMESTAMPING = SO_TIMESTAMPING;
	323	pub const SO_RXQ_OVFL = 40;
	324	pub const SO_WIFI_STATUS = 41;
	325	pub const SCM_WIFI_STATUS = SO_WIFI_STATUS;
	326	pub const SO_PEEK_OFF = 42;
	327	pub const SO_NOFCS = 43;
	328	pub const SO_LOCK_FILTER = 44;
	329	pub const SO_SELECT_ERR_QUEUE = 45;
	330	pub const SO_BUSY_POLL = 46;
	331	pub const SO_MAX_PACING_RATE = 47;
	332	pub const SO_BPF_EXTENSIONS = 48;
	333	pub const SO_INCOMING_CPU = 49;
	334	pub const SO_ATTACH_BPF = 50;
	335	pub const SO_DETACH_BPF = SO_DETACH_FILTER;
	336	pub const SO_ATTACH_REUSEPORT_CBPF = 51;
	337	pub const SO_ATTACH_REUSEPORT_EBPF = 52;
	338	pub const SO_CNX_ADVICE = 53;
	339	pub const SCM_TIMESTAMPING_OPT_STATS = 54;
	340	pub const SO_MEMINFO = 55;
	341	pub const SO_INCOMING_NAPI_ID = 56;
	342	pub const SO_COOKIE = 57;
	343	pub const SCM_TIMESTAMPING_PKTINFO = 58;
	344	pub const SO_PEERGROUPS = 59;
	345	pub const SO_ZEROCOPY = 60;
	346
	347	pub const SOL_SOCKET = 1;
	348
	349	pub const SOL_IP = 0;
	350	pub const SOL_IPV6 = 41;
	351	pub const SOL_ICMPV6 = 58;
	352
	353	pub const SOL_RAW = 255;
	354	pub const SOL_DECNET = 261;
	355	pub const SOL_X25 = 262;
	356	pub const SOL_PACKET = 263;
	357	pub const SOL_ATM = 264;
	358	pub const SOL_AAL = 265;
	359	pub const SOL_IRDA = 266;
	360	pub const SOL_NETBEUI = 267;
	361	pub const SOL_LLC = 268;
	362	pub const SOL_DCCP = 269;
	363	pub const SOL_NETLINK = 270;
	364	pub const SOL_TIPC = 271;
	365	pub const SOL_RXRPC = 272;
	366	pub const SOL_PPPOL2TP = 273;
	367	pub const SOL_BLUETOOTH = 274;
	368	pub const SOL_PNPIPE = 275;
	369	pub const SOL_RDS = 276;
	370	pub const SOL_IUCV = 277;
	371	pub const SOL_CAIF = 278;
	372	pub const SOL_ALG = 279;
	373	pub const SOL_NFC = 280;
	374	pub const SOL_KCM = 281;
	375	pub const SOL_TLS = 282;
	376
	377	pub const SOMAXCONN = 128;
	378
	379	pub const MSG_OOB = 0x0001;
	380	pub const MSG_PEEK = 0x0002;
	381	pub const MSG_DONTROUTE = 0x0004;
	382	pub const MSG_CTRUNC = 0x0008;
	383	pub const MSG_PROXY = 0x0010;
	384	pub const MSG_TRUNC = 0x0020;
	385	pub const MSG_DONTWAIT = 0x0040;
	386	pub const MSG_EOR = 0x0080;
	387	pub const MSG_WAITALL = 0x0100;
	388	pub const MSG_FIN = 0x0200;
	389	pub const MSG_SYN = 0x0400;
	390	pub const MSG_CONFIRM = 0x0800;
	391	pub const MSG_RST = 0x1000;
	392	pub const MSG_ERRQUEUE = 0x2000;
	393	pub const MSG_NOSIGNAL = 0x4000;
	394	pub const MSG_MORE = 0x8000;
	395	pub const MSG_WAITFORONE = 0x10000;
	396	pub const MSG_BATCH = 0x40000;
	397	pub const MSG_ZEROCOPY = 0x4000000;
	398	pub const MSG_FASTOPEN = 0x20000000;
	399	pub const MSG_CMSG_CLOEXEC = 0x40000000;
	400
244	401	pub const DT_UNKNOWN = 0;
245	402	pub const DT_FIFO = 1;
246	403	pub const DT_CHR = 2;
...	...	@@ -343,6 +500,126 @@ pub const CLOCK_BOOTTIME_ALARM = 9;
343	500	pub const CLOCK_SGI_CYCLE = 10;
344	501	pub const CLOCK_TAI = 11;
345	502
	503	pub const CSIGNAL = 0x000000ff;
	504	pub const CLONE_VM = 0x00000100;
	505	pub const CLONE_FS = 0x00000200;
	506	pub const CLONE_FILES = 0x00000400;
	507	pub const CLONE_SIGHAND = 0x00000800;
	508	pub const CLONE_PTRACE = 0x00002000;
	509	pub const CLONE_VFORK = 0x00004000;
	510	pub const CLONE_PARENT = 0x00008000;
	511	pub const CLONE_THREAD = 0x00010000;
	512	pub const CLONE_NEWNS = 0x00020000;
	513	pub const CLONE_SYSVSEM = 0x00040000;
	514	pub const CLONE_SETTLS = 0x00080000;
	515	pub const CLONE_PARENT_SETTID = 0x00100000;
	516	pub const CLONE_CHILD_CLEARTID = 0x00200000;
	517	pub const CLONE_DETACHED = 0x00400000;
	518	pub const CLONE_UNTRACED = 0x00800000;
	519	pub const CLONE_CHILD_SETTID = 0x01000000;
	520	pub const CLONE_NEWCGROUP = 0x02000000;
	521	pub const CLONE_NEWUTS = 0x04000000;
	522	pub const CLONE_NEWIPC = 0x08000000;
	523	pub const CLONE_NEWUSER = 0x10000000;
	524	pub const CLONE_NEWPID = 0x20000000;
	525	pub const CLONE_NEWNET = 0x40000000;
	526	pub const CLONE_IO = 0x80000000;
	527
	528	pub const MS_RDONLY = 1;
	529	pub const MS_NOSUID = 2;
	530	pub const MS_NODEV = 4;
	531	pub const MS_NOEXEC = 8;
	532	pub const MS_SYNCHRONOUS = 16;
	533	pub const MS_REMOUNT = 32;
	534	pub const MS_MANDLOCK = 64;
	535	pub const MS_DIRSYNC = 128;
	536	pub const MS_NOATIME = 1024;
	537	pub const MS_NODIRATIME = 2048;
	538	pub const MS_BIND = 4096;
	539	pub const MS_MOVE = 8192;
	540	pub const MS_REC = 16384;
	541	pub const MS_SILENT = 32768;
	542	pub const MS_POSIXACL = (1<<16);
	543	pub const MS_UNBINDABLE = (1<<17);
	544	pub const MS_PRIVATE = (1<<18);
	545	pub const MS_SLAVE = (1<<19);
	546	pub const MS_SHARED = (1<<20);
	547	pub const MS_RELATIME = (1<<21);
	548	pub const MS_KERNMOUNT = (1<<22);
	549	pub const MS_I_VERSION = (1<<23);
	550	pub const MS_STRICTATIME = (1<<24);
	551	pub const MS_LAZYTIME = (1<<25);
	552	pub const MS_NOREMOTELOCK = (1<<27);
	553	pub const MS_NOSEC = (1<<28);
	554	pub const MS_BORN = (1<<29);
	555	pub const MS_ACTIVE = (1<<30);
	556	pub const MS_NOUSER = (1<<31);
	557
	558	pub const MS_RMT_MASK = (MS_RDONLY\|MS_SYNCHRONOUS\|MS_MANDLOCK\|MS_I_VERSION\|MS_LAZYTIME);
	559
	560	pub const MS_MGC_VAL = 0xc0ed0000;
	561	pub const MS_MGC_MSK = 0xffff0000;
	562
	563	pub const MNT_FORCE = 1;
	564	pub const MNT_DETACH = 2;
	565	pub const MNT_EXPIRE = 4;
	566	pub const UMOUNT_NOFOLLOW = 8;
	567
	568
	569	pub const S_IFMT = 0o170000;
	570
	571	pub const S_IFDIR = 0o040000;
	572	pub const S_IFCHR = 0o020000;
	573	pub const S_IFBLK = 0o060000;
	574	pub const S_IFREG = 0o100000;
	575	pub const S_IFIFO = 0o010000;
	576	pub const S_IFLNK = 0o120000;
	577	pub const S_IFSOCK = 0o140000;
	578
	579	pub const S_ISUID = 0o4000;
	580	pub const S_ISGID = 0o2000;
	581	pub const S_ISVTX = 0o1000;
	582	pub const S_IRUSR = 0o400;
	583	pub const S_IWUSR = 0o200;
	584	pub const S_IXUSR = 0o100;
	585	pub const S_IRWXU = 0o700;
	586	pub const S_IRGRP = 0o040;
	587	pub const S_IWGRP = 0o020;
	588	pub const S_IXGRP = 0o010;
	589	pub const S_IRWXG = 0o070;
	590	pub const S_IROTH = 0o004;
	591	pub const S_IWOTH = 0o002;
	592	pub const S_IXOTH = 0o001;
	593	pub const S_IRWXO = 0o007;
	594
	595	pub fn S_ISREG(m: u32) bool {
	596	return m & S_IFMT == S_IFREG;
	597	}
	598
	599	pub fn S_ISDIR(m: u32) bool {
	600	return m & S_IFMT == S_IFDIR;
	601	}
	602
	603	pub fn S_ISCHR(m: u32) bool {
	604	return m & S_IFMT == S_IFCHR;
	605	}
	606
	607	pub fn S_ISBLK(m: u32) bool {
	608	return m & S_IFMT == S_IFBLK;
	609	}
	610
	611	pub fn S_ISFIFO(m: u32) bool {
	612	return m & S_IFMT == S_IFIFO;
	613	}
	614
	615	pub fn S_ISLNK(m: u32) bool {
	616	return m & S_IFMT == S_IFLNK;
	617	}
	618
	619	pub fn S_ISSOCK(m: u32) bool {
	620	return m & S_IFMT == S_IFSOCK;
	621	}
	622
346	623	pub const TFD_NONBLOCK = O_NONBLOCK;
347	624	pub const TFD_CLOEXEC = O_CLOEXEC;
348	625
...	...	@@ -380,6 +657,10 @@ pub fn chdir(path: &const u8) usize {
380	657	return syscall1(SYS_chdir, @ptrToInt(path));
381	658	}
382	659
	660	pub fn chroot(path: &const u8) usize {
	661	return syscall1(SYS_chroot, @ptrToInt(path));
	662	}
	663
383	664	pub fn execve(path: &const u8, argv: &const ?&const u8, envp: &const ?&const u8) usize {
384	665	return syscall3(SYS_execve, @ptrToInt(path), @ptrToInt(argv), @ptrToInt(envp));
385	666	}
...	...	@@ -388,6 +669,10 @@ pub fn fork() usize {
388	669	return syscall0(SYS_fork);
389	670	}
390	671
	672	pub fn futex_wait(uaddr: usize, futex_op: u32, val: i32, timeout: ?&timespec) usize {
	673	return syscall4(SYS_futex, uaddr, futex_op, @bitCast(u32, val), @ptrToInt(timeout));
	674	}
	675
391	676	pub fn getcwd(buf: &u8, size: usize) usize {
392	677	return syscall2(SYS_getcwd, @ptrToInt(buf), size);
393	678	}
...	...	@@ -409,13 +694,25 @@ pub fn mkdir(path: &const u8, mode: u32) usize {
409	694	return syscall2(SYS_mkdir, @ptrToInt(path), mode);
410	695	}
411	696
412		pub fn mmap(address: ?&u8, length: usize, prot: usize, flags: usize, fd: i32, offset: isize) usize {
	697	pub fn mount(special: &const u8, dir: &const u8, fstype: &const u8, flags: usize, data: usize) usize {
	698	return syscall5(SYS_mount, @ptrToInt(special), @ptrToInt(dir), @ptrToInt(fstype), flags, data);
	699	}
	700
	701	pub fn umount(special: &const u8) usize {
	702	return syscall2(SYS_umount2, @ptrToInt(special), 0);
	703	}
	704
	705	pub fn umount2(special: &const u8, flags: u32) usize {
	706	return syscall2(SYS_umount2, @ptrToInt(special), flags);
	707	}
	708
	709	pub fn mmap(address: ?&u8, length: usize, prot: usize, flags: u32, fd: i32, offset: isize) usize {
413	710	return syscall6(SYS_mmap, @ptrToInt(address), length, prot, flags, usize(fd),
414	711	@bitCast(usize, offset));
415	712	}
416	713
417		pub fn munmap(address: &u8, length: usize) usize {
418		return syscall2(SYS_munmap, @ptrToInt(address), length);
	714	pub fn munmap(address: usize, length: usize) usize {
	715	return syscall2(SYS_munmap, address, length);
419	716	}
420	717
421	718	pub fn read(fd: i32, buf: &u8, count: usize) usize {
...	...	@@ -434,6 +731,10 @@ pub fn pread(fd: i32, buf: &u8, count: usize, offset: usize) usize {
434	731	return syscall4(SYS_pread, usize(fd), @ptrToInt(buf), count, offset);
435	732	}
436	733
	734	pub fn access(path: &const u8, mode: u32) usize {
	735	return syscall2(SYS_access, @ptrToInt(path), mode);
	736	}
	737
437	738	pub fn pipe(fd: &[2]i32) usize {
438	739	return pipe2(fd, 0);
439	740	}
...	...	@@ -466,6 +767,16 @@ pub fn openat(dirfd: i32, path: &const u8, flags: usize, mode: usize) usize {
466	767	return syscall4(SYS_openat, usize(dirfd), @ptrToInt(path), flags, mode);
467	768	}
468	769
	770	/// See also `clone` (from the arch-specific include)
	771	pub fn clone5(flags: usize, child_stack_ptr: usize, parent_tid: &i32, child_tid: &i32, newtls: usize) usize {
	772	return syscall5(SYS_clone, flags, child_stack_ptr, @ptrToInt(parent_tid), @ptrToInt(child_tid), newtls);
	773	}
	774
	775	/// See also `clone` (from the arch-specific include)
	776	pub fn clone2(flags: usize, child_stack_ptr: usize) usize {
	777	return syscall2(SYS_clone, flags, child_stack_ptr);
	778	}
	779
469	780	pub fn close(fd: i32) usize {
470	781	return syscall1(SYS_close, usize(fd));
471	782	}
...	...	@@ -495,6 +806,45 @@ pub fn waitpid(pid: i32, status: &i32, options: i32) usize {
495	806	return syscall4(SYS_wait4, @bitCast(usize, isize(pid)), @ptrToInt(status), @bitCast(usize, isize(options)), 0);
496	807	}
497	808
	809	pub fn clock_gettime(clk_id: i32, tp: &timespec) usize {
	810	if (VDSO_CGT_SYM.len != 0) {
	811	const f = @atomicLoad(@typeOf(init_vdso_clock_gettime), &vdso_clock_gettime, builtin.AtomicOrder.Unordered);
	812	if (@ptrToInt(f) != 0) {
	813	const rc = f(clk_id, tp);
	814	switch (rc) {
	815	0, @bitCast(usize, isize(-EINVAL)) => return rc,
	816	else => {},
	817	}
	818	}
	819	}
	820	return syscall2(SYS_clock_gettime, @bitCast(usize, isize(clk_id)), @ptrToInt(tp));
	821	}
	822	var vdso_clock_gettime = init_vdso_clock_gettime;
	823	extern fn init_vdso_clock_gettime(clk: i32, ts: &timespec) usize {
	824	const addr = vdso.lookup(VDSO_CGT_VER, VDSO_CGT_SYM);
	825	var f = @intToPtr(@typeOf(init_vdso_clock_gettime), addr);
	826	_ = @cmpxchgStrong(@typeOf(init_vdso_clock_gettime), &vdso_clock_gettime, init_vdso_clock_gettime, f,
	827	builtin.AtomicOrder.Monotonic, builtin.AtomicOrder.Monotonic);
	828	if (@ptrToInt(f) == 0) return @bitCast(usize, isize(-ENOSYS));
	829	return f(clk, ts);
	830	}
	831
	832	pub fn clock_getres(clk_id: i32, tp: &timespec) usize {
	833	return syscall2(SYS_clock_getres, @bitCast(usize, isize(clk_id)), @ptrToInt(tp));
	834	}
	835
	836	pub fn clock_settime(clk_id: i32, tp: &const timespec) usize {
	837	return syscall2(SYS_clock_settime, @bitCast(usize, isize(clk_id)), @ptrToInt(tp));
	838	}
	839
	840	pub fn gettimeofday(tv: &timeval, tz: &timezone) usize {
	841	return syscall2(SYS_gettimeofday, @ptrToInt(tv), @ptrToInt(tz));
	842	}
	843
	844	pub fn settimeofday(tv: &const timeval, tz: &const timezone) usize {
	845	return syscall2(SYS_settimeofday, @ptrToInt(tv), @ptrToInt(tz));
	846	}
	847
498	848	pub fn nanosleep(req: &const timespec, rem: ?&timespec) usize {
499	849	return syscall2(SYS_nanosleep, @ptrToInt(req), @ptrToInt(rem));
500	850	}
...	...	@@ -515,6 +865,58 @@ pub fn setregid(rgid: u32, egid: u32) usize {
515	865	return syscall2(SYS_setregid, rgid, egid);
516	866	}
517	867
	868	pub fn getuid() u32 {
	869	return u32(syscall0(SYS_getuid));
	870	}
	871
	872	pub fn getgid() u32 {
	873	return u32(syscall0(SYS_getgid));
	874	}
	875
	876	pub fn geteuid() u32 {
	877	return u32(syscall0(SYS_geteuid));
	878	}
	879
	880	pub fn getegid() u32 {
	881	return u32(syscall0(SYS_getegid));
	882	}
	883
	884	pub fn seteuid(euid: u32) usize {
	885	return syscall1(SYS_seteuid, euid);
	886	}
	887
	888	pub fn setegid(egid: u32) usize {
	889	return syscall1(SYS_setegid, egid);
	890	}
	891
	892	pub fn getresuid(ruid: &u32, euid: &u32, suid: &u32) usize {
	893	return syscall3(SYS_getresuid, @ptrToInt(ruid), @ptrToInt(euid), @ptrToInt(suid));
	894	}
	895
	896	pub fn getresgid(rgid: &u32, egid: &u32, sgid: &u32) usize {
	897	return syscall3(SYS_getresgid, @ptrToInt(rgid), @ptrToInt(egid), @ptrToInt(sgid));
	898	}
	899
	900	pub fn setresuid(ruid: u32, euid: u32, suid: u32) usize {
	901	return syscall3(SYS_setresuid, ruid, euid, suid);
	902	}
	903
	904	pub fn setresgid(rgid: u32, egid: u32, sgid: u32) usize {
	905	return syscall3(SYS_setresgid, rgid, egid, sgid);
	906	}
	907
	908	pub fn getgroups(size: usize, list: &u32) usize {
	909	return syscall2(SYS_getgroups, size, @ptrToInt(list));
	910	}
	911
	912	pub fn setgroups(size: usize, list: &const u32) usize {
	913	return syscall2(SYS_setgroups, size, @ptrToInt(list));
	914	}
	915
	916	pub fn getpid() i32 {
	917	return @bitCast(i32, u32(syscall0(SYS_getpid)));
	918	}
	919
518	920	pub fn sigprocmask(flags: u32, noalias set: &const sigset_t, noalias oldset: ?&sigset_t) usize {
519	921	return syscall4(SYS_rt_sigprocmask, flags, @ptrToInt(set), @ptrToInt(oldset), NSIG/8);
520	922	}
...	...	@@ -599,30 +1001,27 @@ pub fn sigismember(set: &const sigset_t, sig: u6) bool {
599	1001	return ((*set)[usize(s) / usize.bit_count] & (usize(1) << (s & (usize.bit_count - 1)))) != 0;
600	1002	}
601	1003
602
	1004	pub const in_port_t = u16;
603	1005	pub const sa_family_t = u16;
604	1006	pub const socklen_t = u32;
605		pub const in_addr = u32;
606		pub const in6_addr = [16]u8;
607	1007
608		pub const sockaddr = extern struct {
609		family: sa_family_t,
610		port: u16,
611		data: [12]u8,
	1008	pub const sockaddr = extern union {
	1009	in: sockaddr_in,
	1010	in6: sockaddr_in6,
612	1011	};
613	1012
614	1013	pub const sockaddr_in = extern struct {
615	1014	family: sa_family_t,
616		port: u16,
617		addr: in_addr,
	1015	port: in_port_t,
	1016	addr: u32,
618	1017	zero: [8]u8,
619	1018	};
620	1019
621	1020	pub const sockaddr_in6 = extern struct {
622	1021	family: sa_family_t,
623		port: u16,
	1022	port: in_port_t,
624	1023	flowinfo: u32,
625		addr: in6_addr,
	1024	addr: [16]u8,
626	1025	scope_id: u32,
627	1026	};
628	1027
...	...	@@ -639,16 +1038,16 @@ pub fn getpeername(fd: i32, noalias addr: &sockaddr, noalias len: &socklen_t) us
639	1038	return syscall3(SYS_getpeername, usize(fd), @ptrToInt(addr), @ptrToInt(len));
640	1039	}
641	1040
642		pub fn socket(domain: i32, socket_type: i32, protocol: i32) usize {
643		return syscall3(SYS_socket, usize(domain), usize(socket_type), usize(protocol));
	1041	pub fn socket(domain: u32, socket_type: u32, protocol: u32) usize {
	1042	return syscall3(SYS_socket, domain, socket_type, protocol);
644	1043	}
645	1044
646		pub fn setsockopt(fd: i32, level: i32, optname: i32, optval: &const u8, optlen: socklen_t) usize {
647		return syscall5(SYS_setsockopt, usize(fd), usize(level), usize(optname), usize(optval), @ptrToInt(optlen));
	1045	pub fn setsockopt(fd: i32, level: u32, optname: u32, optval: &const u8, optlen: socklen_t) usize {
	1046	return syscall5(SYS_setsockopt, usize(fd), level, optname, usize(optval), @ptrToInt(optlen));
648	1047	}
649	1048
650		pub fn getsockopt(fd: i32, level: i32, optname: i32, noalias optval: &u8, noalias optlen: &socklen_t) usize {
651		return syscall5(SYS_getsockopt, usize(fd), usize(level), usize(optname), @ptrToInt(optval), @ptrToInt(optlen));
	1049	pub fn getsockopt(fd: i32, level: u32, optname: u32, noalias optval: &u8, noalias optlen: &socklen_t) usize {
	1050	return syscall5(SYS_getsockopt, usize(fd), level, optname, @ptrToInt(optval), @ptrToInt(optlen));
652	1051	}
653	1052
654	1053	pub fn sendmsg(fd: i32, msg: &const msghdr, flags: u32) usize {
...	...	@@ -677,8 +1076,8 @@ pub fn bind(fd: i32, addr: &const sockaddr, len: socklen_t) usize {
677	1076	return syscall3(SYS_bind, usize(fd), @ptrToInt(addr), usize(len));
678	1077	}
679	1078
680		pub fn listen(fd: i32, backlog: i32) usize {
681		return syscall2(SYS_listen, usize(fd), usize(backlog));
	1079	pub fn listen(fd: i32, backlog: u32) usize {
	1080	return syscall2(SYS_listen, usize(fd), backlog);
682	1081	}
683	1082
684	1083	pub fn sendto(fd: i32, buf: &const u8, len: usize, flags: u32, addr: ?&const sockaddr, alen: socklen_t) usize {
...	...	@@ -697,46 +1096,83 @@ pub fn accept4(fd: i32, noalias addr: &sockaddr, noalias len: &socklen_t, flags:
697	1096	return syscall4(SYS_accept4, usize(fd), @ptrToInt(addr), @ptrToInt(len), flags);
698	1097	}
699	1098
700		// error NameTooLong;
701		// error SystemResources;
702		// error Io;
703		//
704		// pub fn if_nametoindex(name: []u8) !u32 {
705		// var ifr: ifreq = undefined;
706		//
707		// if (name.len >= ifr.ifr_name.len) {
708		// return error.NameTooLong;
709		// }
710		//
711		// const socket_ret = socket(AF_UNIX, SOCK_DGRAM\|SOCK_CLOEXEC, 0);
712		// const socket_err = getErrno(socket_ret);
713		// if (socket_err > 0) {
714		// return error.SystemResources;
715		// }
716		// const socket_fd = i32(socket_ret);
717		// @memcpy(&ifr.ifr_name[0], &name[0], name.len);
718		// ifr.ifr_name[name.len] = 0;
719		// const ioctl_ret = ioctl(socket_fd, SIOCGIFINDEX, &ifr);
720		// close(socket_fd);
721		// const ioctl_err = getErrno(ioctl_ret);
722		// if (ioctl_err > 0) {
723		// return error.Io;
724		// }
725		// return ifr.ifr_ifindex;
726		// }
727
728	1099	pub fn fstat(fd: i32, stat_buf: &Stat) usize {
729	1100	return syscall2(SYS_fstat, usize(fd), @ptrToInt(stat_buf));
730	1101	}
731	1102
732		pub const epoll_data = extern union {
	1103	pub fn stat(pathname: &const u8, statbuf: &Stat) usize {
	1104	return syscall2(SYS_stat, @ptrToInt(pathname), @ptrToInt(statbuf));
	1105	}
	1106
	1107	pub fn lstat(pathname: &const u8, statbuf: &Stat) usize {
	1108	return syscall2(SYS_lstat, @ptrToInt(pathname), @ptrToInt(statbuf));
	1109	}
	1110
	1111	pub fn listxattr(path: &const u8, list: &u8, size: usize) usize {
	1112	return syscall3(SYS_listxattr, @ptrToInt(path), @ptrToInt(list), size);
	1113	}
	1114
	1115	pub fn llistxattr(path: &const u8, list: &u8, size: usize) usize {
	1116	return syscall3(SYS_llistxattr, @ptrToInt(path), @ptrToInt(list), size);
	1117	}
	1118
	1119	pub fn flistxattr(fd: usize, list: &u8, size: usize) usize {
	1120	return syscall3(SYS_flistxattr, fd, @ptrToInt(list), size);
	1121	}
	1122
	1123	pub fn getxattr(path: &const u8, name: &const u8, value: &void, size: usize) usize {
	1124	return syscall4(SYS_getxattr, @ptrToInt(path), @ptrToInt(name), @ptrToInt(value), size);
	1125	}
	1126
	1127	pub fn lgetxattr(path: &const u8, name: &const u8, value: &void, size: usize) usize {
	1128	return syscall4(SYS_lgetxattr, @ptrToInt(path), @ptrToInt(name), @ptrToInt(value), size);
	1129	}
	1130
	1131	pub fn fgetxattr(fd: usize, name: &const u8, value: &void, size: usize) usize {
	1132	return syscall4(SYS_lgetxattr, fd, @ptrToInt(name), @ptrToInt(value), size);
	1133	}
	1134
	1135	pub fn setxattr(path: &const u8, name: &const u8, value: &const void,
	1136	size: usize, flags: usize) usize {
	1137
	1138	return syscall5(SYS_setxattr, @ptrToInt(path), @ptrToInt(name), @ptrToInt(value),
	1139	size, flags);
	1140	}
	1141
	1142	pub fn lsetxattr(path: &const u8, name: &const u8, value: &const void,
	1143	size: usize, flags: usize) usize {
	1144
	1145	return syscall5(SYS_lsetxattr, @ptrToInt(path), @ptrToInt(name), @ptrToInt(value),
	1146	size, flags);
	1147	}
	1148
	1149	pub fn fsetxattr(fd: usize, name: &const u8, value: &const void,
	1150	size: usize, flags: usize) usize {
	1151
	1152	return syscall5(SYS_fsetxattr, fd, @ptrToInt(name), @ptrToInt(value),
	1153	size, flags);
	1154	}
	1155
	1156	pub fn removexattr(path: &const u8, name: &const u8) usize {
	1157	return syscall2(SYS_removexattr, @ptrToInt(path), @ptrToInt(name));
	1158	}
	1159
	1160	pub fn lremovexattr(path: &const u8, name: &const u8) usize {
	1161	return syscall2(SYS_lremovexattr, @ptrToInt(path), @ptrToInt(name));
	1162	}
	1163
	1164	pub fn fremovexattr(fd: usize, name: &const u8) usize {
	1165	return syscall2(SYS_fremovexattr, fd, @ptrToInt(name));
	1166	}
	1167
	1168	pub const epoll_data = packed union {
733	1169	ptr: usize,
734	1170	fd: i32,
735	1171	@"u32": u32,
736	1172	@"u64": u64,
737	1173	};
738	1174
739		pub const epoll_event = extern struct {
	1175	pub const epoll_event = packed struct {
740	1176	events: u32,
741	1177	data: epoll_data,
742	1178	};
...	...	@@ -749,7 +1185,7 @@ pub fn epoll_create1(flags: usize) usize {
749	1185	return syscall1(SYS_epoll_create1, flags);
750	1186	}
751	1187
752		pub fn epoll_ctl(epoll_fd: i32, op: i32, fd: i32, ev: &epoll_event) usize {
	1188	pub fn epoll_ctl(epoll_fd: i32, op: u32, fd: i32, ev: &epoll_event) usize {
753	1189	return syscall4(SYS_epoll_ctl, usize(epoll_fd), usize(op), usize(fd), @ptrToInt(ev));
754	1190	}
755	1191
...	...	@@ -774,9 +1210,126 @@ pub fn timerfd_settime(fd: i32, flags: u32, new_value: &const itimerspec, old_va
774	1210	return syscall4(SYS_timerfd_settime, usize(fd), usize(flags), @ptrToInt(new_value), @ptrToInt(old_value));
775	1211	}
776	1212
777		test "import linux test" {
778		// TODO lazy analysis should prevent this test from being compiled on windows, but
779		// it is still compiled on windows
	1213	pub const _LINUX_CAPABILITY_VERSION_1 = 0x19980330;
	1214	pub const _LINUX_CAPABILITY_U32S_1 = 1;
	1215
	1216	pub const _LINUX_CAPABILITY_VERSION_2 = 0x20071026;
	1217	pub const _LINUX_CAPABILITY_U32S_2 = 2;
	1218
	1219	pub const _LINUX_CAPABILITY_VERSION_3 = 0x20080522;
	1220	pub const _LINUX_CAPABILITY_U32S_3 = 2;
	1221
	1222	pub const VFS_CAP_REVISION_MASK = 0xFF000000;
	1223	pub const VFS_CAP_REVISION_SHIFT = 24;
	1224	pub const VFS_CAP_FLAGS_MASK = ~VFS_CAP_REVISION_MASK;
	1225	pub const VFS_CAP_FLAGS_EFFECTIVE = 0x000001;
	1226
	1227	pub const VFS_CAP_REVISION_1 = 0x01000000;
	1228	pub const VFS_CAP_U32_1 = 1;
	1229	pub const XATTR_CAPS_SZ_1 = @sizeOf(u32)(1 + 2VFS_CAP_U32_1);
	1230
	1231	pub const VFS_CAP_REVISION_2 = 0x02000000;
	1232	pub const VFS_CAP_U32_2 = 2;
	1233	pub const XATTR_CAPS_SZ_2 = @sizeOf(u32)(1 + 2VFS_CAP_U32_2);
	1234
	1235	pub const XATTR_CAPS_SZ = XATTR_CAPS_SZ_2;
	1236	pub const VFS_CAP_U32 = VFS_CAP_U32_2;
	1237	pub const VFS_CAP_REVISION = VFS_CAP_REVISION_2;
	1238
	1239	pub const vfs_cap_data = extern struct {
	1240	//all of these are mandated as little endian
	1241	//when on disk.
	1242	const Data = struct {
	1243	permitted: u32,
	1244	inheritable: u32,
	1245	};
	1246
	1247	magic_etc: u32,
	1248	data: [VFS_CAP_U32]Data,
	1249	};
	1250
	1251
	1252	pub const CAP_CHOWN = 0;
	1253	pub const CAP_DAC_OVERRIDE = 1;
	1254	pub const CAP_DAC_READ_SEARCH = 2;
	1255	pub const CAP_FOWNER = 3;
	1256	pub const CAP_FSETID = 4;
	1257	pub const CAP_KILL = 5;
	1258	pub const CAP_SETGID = 6;
	1259	pub const CAP_SETUID = 7;
	1260	pub const CAP_SETPCAP = 8;
	1261	pub const CAP_LINUX_IMMUTABLE = 9;
	1262	pub const CAP_NET_BIND_SERVICE = 10;
	1263	pub const CAP_NET_BROADCAST = 11;
	1264	pub const CAP_NET_ADMIN = 12;
	1265	pub const CAP_NET_RAW = 13;
	1266	pub const CAP_IPC_LOCK = 14;
	1267	pub const CAP_IPC_OWNER = 15;
	1268	pub const CAP_SYS_MODULE = 16;
	1269	pub const CAP_SYS_RAWIO = 17;
	1270	pub const CAP_SYS_CHROOT = 18;
	1271	pub const CAP_SYS_PTRACE = 19;
	1272	pub const CAP_SYS_PACCT = 20;
	1273	pub const CAP_SYS_ADMIN = 21;
	1274	pub const CAP_SYS_BOOT = 22;
	1275	pub const CAP_SYS_NICE = 23;
	1276	pub const CAP_SYS_RESOURCE = 24;
	1277	pub const CAP_SYS_TIME = 25;
	1278	pub const CAP_SYS_TTY_CONFIG = 26;
	1279	pub const CAP_MKNOD = 27;
	1280	pub const CAP_LEASE = 28;
	1281	pub const CAP_AUDIT_WRITE = 29;
	1282	pub const CAP_AUDIT_CONTROL = 30;
	1283	pub const CAP_SETFCAP = 31;
	1284	pub const CAP_MAC_OVERRIDE = 32;
	1285	pub const CAP_MAC_ADMIN = 33;
	1286	pub const CAP_SYSLOG = 34;
	1287	pub const CAP_WAKE_ALARM = 35;
	1288	pub const CAP_BLOCK_SUSPEND = 36;
	1289	pub const CAP_AUDIT_READ = 37;
	1290	pub const CAP_LAST_CAP = CAP_AUDIT_READ;
	1291
	1292	pub fn cap_valid(u8: x) bool {
	1293	return x >= 0 and x <= CAP_LAST_CAP;
	1294	}
	1295
	1296	pub fn CAP_TO_MASK(cap: u8) u32 {
	1297	return u32(1) << u5(cap & 31);
	1298	}
	1299
	1300	pub fn CAP_TO_INDEX(cap: u8) u8 {
	1301	return cap >> 5;
	1302	}
	1303
	1304	pub const cap_t = extern struct {
	1305	hdrp: &cap_user_header_t,
	1306	datap: &cap_user_data_t,
	1307	};
	1308
	1309	pub const cap_user_header_t = extern struct {
	1310	version: u32,
	1311	pid: usize,
	1312	};
	1313
	1314	pub const cap_user_data_t = extern struct {
	1315	effective: u32,
	1316	permitted: u32,
	1317	inheritable: u32,
	1318	};
	1319
	1320	pub fn unshare(flags: usize) usize {
	1321	return syscall1(SYS_unshare, usize(flags));
	1322	}
	1323
	1324	pub fn capget(hdrp: &cap_user_header_t, datap: &cap_user_data_t) usize {
	1325	return syscall2(SYS_capget, @ptrToInt(hdrp), @ptrToInt(datap));
	1326	}
	1327
	1328	pub fn capset(hdrp: &cap_user_header_t, datap: &const cap_user_data_t) usize {
	1329	return syscall2(SYS_capset, @ptrToInt(hdrp), @ptrToInt(datap));
	1330	}
	1331
	1332	test "import" {
780	1333	if (builtin.os == builtin.Os.linux) {
781	1334	_ = @import("test.zig");
782	1335	}

std/os/linux/test.zig+1

...	...	@@ -1,4 +1,5 @@
1	1	const std = @import("../../index.zig");
	2	const builtin = @import("builtin");
2	3	const linux = std.os.linux;
3	4	const assert = std.debug.assert;
4	5

std/os/linux/vdso.zig created+89

...	...	@@ -0,0 +1,89 @@
	1	const std = @import("../../index.zig");
	2	const elf = std.elf;
	3	const linux = std.os.linux;
	4	const cstr = std.cstr;
	5	const mem = std.mem;
	6
	7	pub fn lookup(vername: []const u8, name: []const u8) usize {
	8	const vdso_addr = std.os.linux_aux_raw[std.elf.AT_SYSINFO_EHDR];
	9	if (vdso_addr == 0) return 0;
	10
	11	const eh = @intToPtr(&elf.Ehdr, vdso_addr);
	12	var ph_addr: usize = vdso_addr + eh.e_phoff;
	13	const ph = @intToPtr(&elf.Phdr, ph_addr);
	14
	15	var maybe_dynv: ?&usize = null;
	16	var base: usize = @maxValue(usize);
	17	{
	18	var i: usize = 0;
	19	while (i < eh.e_phnum) : ({i += 1; ph_addr += eh.e_phentsize;}) {
	20	const this_ph = @intToPtr(&elf.Phdr, ph_addr);
	21	switch (this_ph.p_type) {
	22	elf.PT_LOAD => base = vdso_addr + this_ph.p_offset - this_ph.p_vaddr,
	23	elf.PT_DYNAMIC => maybe_dynv = @intToPtr(&usize, vdso_addr + this_ph.p_offset),
	24	else => {},
	25	}
	26	}
	27	}
	28	const dynv = maybe_dynv ?? return 0;
	29	if (base == @maxValue(usize)) return 0;
	30
	31	var maybe_strings: ?&u8 = null;
	32	var maybe_syms: ?&elf.Sym = null;
	33	var maybe_hashtab: ?&linux.Elf_Symndx = null;
	34	var maybe_versym: ?&u16 = null;
	35	var maybe_verdef: ?&elf.Verdef = null;
	36
	37	{
	38	var i: usize = 0;
	39	while (dynv[i] != 0) : (i += 2) {
	40	const p = base + dynv[i + 1];
	41	switch (dynv[i]) {
	42	elf.DT_STRTAB => maybe_strings = @intToPtr(&u8, p),
	43	elf.DT_SYMTAB => maybe_syms = @intToPtr(&elf.Sym, p),
	44	elf.DT_HASH => maybe_hashtab = @intToPtr(&linux.Elf_Symndx, p),
	45	elf.DT_VERSYM => maybe_versym = @intToPtr(&u16, p),
	46	elf.DT_VERDEF => maybe_verdef = @intToPtr(&elf.Verdef, p),
	47	else => {},
	48	}
	49	}
	50	}
	51
	52	const strings = maybe_strings ?? return 0;
	53	const syms = maybe_syms ?? return 0;
	54	const hashtab = maybe_hashtab ?? return 0;
	55	if (maybe_verdef == null) maybe_versym = null;
	56
	57
	58	const OK_TYPES = (1<<elf.STT_NOTYPE \| 1<<elf.STT_OBJECT \| 1<<elf.STT_FUNC \| 1<<elf.STT_COMMON);
	59	const OK_BINDS = (1<<elf.STB_GLOBAL \| 1<<elf.STB_WEAK \| 1<<elf.STB_GNU_UNIQUE);
	60
	61	var i: usize = 0;
	62	while (i < hashtab[1]) : (i += 1) {
	63	if (0==(u32(1)<<u5(syms[i].st_info&0xf) & OK_TYPES)) continue;
	64	if (0==(u32(1)<<u5(syms[i].st_info>>4) & OK_BINDS)) continue;
	65	if (0==syms[i].st_shndx) continue;
	66	if (!mem.eql(u8, name, cstr.toSliceConst(&strings[syms[i].st_name]))) continue;
	67	if (maybe_versym) \|versym\| {
	68	if (!checkver(??maybe_verdef, versym[i], vername, strings))
	69	continue;
	70	}
	71	return base + syms[i].st_value;
	72	}
	73
	74	return 0;
	75	}
	76
	77	fn checkver(def_arg: &elf.Verdef, vsym_arg: i32, vername: []const u8, strings: &u8) bool {
	78	var def = def_arg;
	79	const vsym = @bitCast(u32, vsym_arg) & 0x7fff;
	80	while (true) {
	81	if (0==(def.vd_flags & elf.VER_FLG_BASE) and (def.vd_ndx & 0x7fff) == vsym)
	82	break;
	83	if (def.vd_next == 0)
	84	return false;
	85	def = @intToPtr(&elf.Verdef, @ptrToInt(def) + def.vd_next);
	86	}
	87	const aux = @intToPtr(&elf.Verdaux, @ptrToInt(def ) + def.vd_aux);
	88	return mem.eql(u8, vername, cstr.toSliceConst(&strings[aux.vda_name]));
	89	}

std/os/linux/x86_64.zig+21

...	...	@@ -371,6 +371,13 @@ pub const F_GETOWN_EX = 16;
371	371
372	372	pub const F_GETOWNER_UIDS = 17;
373	373
	374
	375	pub const VDSO_USEFUL = true;
	376	pub const VDSO_CGT_SYM = "__vdso_clock_gettime";
	377	pub const VDSO_CGT_VER = "LINUX_2.6";
	378	pub const VDSO_GETCPU_SYM = "__vdso_getcpu";
	379	pub const VDSO_GETCPU_VER = "LINUX_2.6";
	380
374	381	pub fn syscall0(number: usize) usize {
375	382	return asm volatile ("syscall"
376	383	: [ret] "={rax}" (-> usize)
...	...	@@ -443,6 +450,9 @@ pub fn syscall6(number: usize, arg1: usize, arg2: usize, arg3: usize, arg4: usiz
443	450	: "rcx", "r11");
444	451	}
445	452
	453	/// This matches the libc clone function.
	454	pub extern fn clone(func: extern fn(arg: usize) u8, stack: usize, flags: usize, arg: usize, ptid: &i32, tls: usize, ctid: &i32) usize;
	455
446	456	pub nakedcc fn restore_rt() void {
447	457	return asm volatile ("syscall"
448	458	:
...	...	@@ -489,6 +499,16 @@ pub const timespec = extern struct {
489	499	tv_nsec: isize,
490	500	};
491	501
	502	pub const timeval = extern struct {
	503	tv_sec: isize,
	504	tv_usec: isize,
	505	};
	506
	507	pub const timezone = extern struct {
	508	tz_minuteswest: i32,
	509	tz_dsttime: i32,
	510	};
	511
492	512	pub const dirent = extern struct {
493	513	d_ino: usize,
494	514	d_off: usize,
...	...	@@ -496,3 +516,4 @@ pub const dirent = extern struct {
496	516	d_name: u8, // field address is the address of first byte of name
497	517	};
498	518
	519	pub const Elf_Symndx = u32;

std/os/test.zig+44

...	...	@@ -6,6 +6,8 @@ const io = std.io;
6	6	const a = std.debug.global_allocator;
7	7
8	8	const builtin = @import("builtin");
	9	const AtomicRmwOp = builtin.AtomicRmwOp;
	10	const AtomicOrder = builtin.AtomicOrder;
9	11
10	12	test "makePath, put some files in it, deleteTree" {
11	13	if (builtin.os == builtin.Os.windows) {
...	...	@@ -23,3 +25,45 @@ test "makePath, put some files in it, deleteTree" {
23	25	assert(err == error.PathNotFound);
24	26	}
25	27	}
	28
	29	test "access file" {
	30	if (builtin.os == builtin.Os.windows) {
	31	return;
	32	}
	33
	34	try os.makePath(a, "os_test_tmp");
	35	if (os.File.access(a, "os_test_tmp/file.txt", os.default_file_mode)) \|ok\| {
	36	unreachable;
	37	} else \|err\| {
	38	assert(err == error.NotFound);
	39	}
	40
	41	try io.writeFile(a, "os_test_tmp/file.txt", "");
	42	assert((try os.File.access(a, "os_test_tmp/file.txt", os.default_file_mode)) == true);
	43	try os.deleteTree(a, "os_test_tmp");
	44	}
	45
	46	test "spawn threads" {
	47	var shared_ctx: i32 = 1;
	48
	49	const thread1 = try std.os.spawnThread({}, start1);
	50	const thread2 = try std.os.spawnThread(&shared_ctx, start2);
	51	const thread3 = try std.os.spawnThread(&shared_ctx, start2);
	52	const thread4 = try std.os.spawnThread(&shared_ctx, start2);
	53
	54	thread1.wait();
	55	thread2.wait();
	56	thread3.wait();
	57	thread4.wait();
	58
	59	assert(shared_ctx == 4);
	60	}
	61
	62	fn start1(ctx: void) u8 {
	63	return 0;
	64	}
	65
	66	fn start2(ctx: &i32) u8 {
	67	_ = @atomicRmw(i32, ctx, AtomicRmwOp.Add, 1, AtomicOrder.SeqCst);
	68	return 0;
	69	}

std/os/time.zig created+288

...	...	@@ -0,0 +1,288 @@
	1	const std = @import("../index.zig");
	2	const builtin = @import("builtin");
	3	const Os = builtin.Os;
	4	const debug = std.debug;
	5
	6	const windows = std.os.windows;
	7	const linux = std.os.linux;
	8	const darwin = std.os.darwin;
	9	const posix = std.os.posix;
	10
	11	pub const epoch = @import("epoch.zig");
	12
	13	/// Sleep for the specified duration
	14	pub fn sleep(seconds: usize, nanoseconds: usize) void {
	15	switch (builtin.os) {
	16	Os.linux, Os.macosx, Os.ios => {
	17	posixSleep(u63(seconds), u63(nanoseconds));
	18	},
	19	Os.windows => {
	20	const ns_per_ms = ns_per_s / ms_per_s;
	21	const milliseconds = seconds * ms_per_s + nanoseconds / ns_per_ms;
	22	windows.Sleep(windows.DWORD(milliseconds));
	23	},
	24	else => @compileError("Unsupported OS"),
	25	}
	26	}
	27
	28	const u63 = @IntType(false, 63);
	29	pub fn posixSleep(seconds: u63, nanoseconds: u63) void {
	30	var req = posix.timespec {
	31	.tv_sec = seconds,
	32	.tv_nsec = nanoseconds,
	33	};
	34	var rem: posix.timespec = undefined;
	35	while (true) {
	36	const ret_val = posix.nanosleep(&req, &rem);
	37	const err = posix.getErrno(ret_val);
	38	if (err == 0) return;
	39	switch (err) {
	40	posix.EFAULT => unreachable,
	41	posix.EINVAL => {
	42	// Sometimes Darwin returns EINVAL for no reason.
	43	// We treat it as a spurious wakeup.
	44	return;
	45	},
	46	posix.EINTR => {
	47	req = rem;
	48	continue;
	49	},
	50	else => return,
	51	}
	52	}
	53	}
	54
	55	/// Get the posix timestamp, UTC, in seconds
	56	pub fn timestamp() u64 {
	57	return @divFloor(milliTimestamp(), ms_per_s);
	58	}
	59
	60	/// Get the posix timestamp, UTC, in milliseconds
	61	pub const milliTimestamp = switch (builtin.os) {
	62	Os.windows => milliTimestampWindows,
	63	Os.linux => milliTimestampPosix,
	64	Os.macosx, Os.ios => milliTimestampDarwin,
	65	else => @compileError("Unsupported OS"),
	66	};
	67
	68	fn milliTimestampWindows() u64 {
	69	//FileTime has a granularity of 100 nanoseconds
	70	// and uses the NTFS/Windows epoch
	71	var ft: i64 = undefined;
	72	windows.GetSystemTimeAsFileTime(&ft);
	73	const hns_per_ms = (ns_per_s / 100) / ms_per_s;
	74	const epoch_adj = epoch.windows * ms_per_s;
	75	return u64(@divFloor(ft, hns_per_ms) + epoch_adj);
	76	}
	77
	78	fn milliTimestampDarwin() u64 {
	79	//Sources suggest MacOS 10.12 has support for
	80	// posix clock_gettime.
	81	var tv: darwin.timeval = undefined;
	82	var err = darwin.gettimeofday(&tv, null);
	83	debug.assert(err == 0);
	84	const sec_ms = u64(tv.tv_sec) * ms_per_s;
	85	const usec_ms = @divFloor(u64(tv.tv_usec), us_per_s / ms_per_s);
	86	return u64(sec_ms) + u64(usec_ms);
	87	}
	88
	89	fn milliTimestampPosix() u64 {
	90	//From what I can tell there's no reason clock_gettime
	91	// should ever fail for us with CLOCK_REALTIME,
	92	// seccomp aside.
	93	var ts: posix.timespec = undefined;
	94	const err = posix.clock_gettime(posix.CLOCK_REALTIME, &ts);
	95	debug.assert(err == 0);
	96	const sec_ms = u64(ts.tv_sec) * ms_per_s;
	97	const nsec_ms = @divFloor(u64(ts.tv_nsec), ns_per_s / ms_per_s);
	98	return sec_ms + nsec_ms;
	99	}
	100
	101	/// Divisions of a second
	102	pub const ns_per_s = 1000000000;
	103	pub const us_per_s = 1000000;
	104	pub const ms_per_s = 1000;
	105	pub const cs_per_s = 100;
	106
	107	/// Common time divisions
	108	pub const s_per_min = 60;
	109	pub const s_per_hour = s_per_min * 60;
	110	pub const s_per_day = s_per_hour * 24;
	111	pub const s_per_week = s_per_day * 7;
	112
	113
	114	/// A monotonic high-performance timer.
	115	/// Timer.start() must be called to initialize the struct, which captures
	116	/// the counter frequency on windows and darwin, records the resolution,
	117	/// and gives the user an oportunity to check for the existnece of
	118	/// monotonic clocks without forcing them to check for error on each read.
	119	/// .resolution is in nanoseconds on all platforms but .start_time's meaning
	120	/// depends on the OS. On Windows and Darwin it is a hardware counter
	121	/// value that requires calculation to convert to a meaninful unit.
	122	pub const Timer = struct {
	123
	124	//if we used resolution's value when performing the
	125	// performance counter calc on windows/darwin, it would
	126	// be less precise
	127	frequency: switch (builtin.os) {
	128	Os.windows => u64,
	129	Os.macosx, Os.ios => darwin.mach_timebase_info_data,
	130	else => void,
	131	},
	132	resolution: u64,
	133	start_time: u64,
	134
	135
	136	//At some point we may change our minds on RAW, but for now we're
	137	// sticking with posix standard MONOTONIC. For more information, see:
	138	// https://github.com/zig-lang/zig/pull/933
	139	//
	140	//const monotonic_clock_id = switch(builtin.os) {
	141	// Os.linux => linux.CLOCK_MONOTONIC_RAW,
	142	// else => posix.CLOCK_MONOTONIC,
	143	//};
	144	const monotonic_clock_id = posix.CLOCK_MONOTONIC;
	145
	146
	147	/// Initialize the timer structure.
	148	//This gives us an oportunity to grab the counter frequency in windows.
	149	//On Windows: QueryPerformanceCounter will succeed on anything >= XP/2000.
	150	//On Posix: CLOCK_MONOTONIC will only fail if the monotonic counter is not
	151	// supported, or if the timespec pointer is out of bounds, which should be
	152	// impossible here barring cosmic rays or other such occurances of
	153	// incredibly bad luck.
	154	//On Darwin: This cannot fail, as far as I am able to tell.
	155	const TimerError = error{TimerUnsupported, Unexpected};
	156	pub fn start() TimerError!Timer {
	157	var self: Timer = undefined;
	158
	159	switch (builtin.os) {
	160	Os.windows => {
	161	var freq: i64 = undefined;
	162	var err = windows.QueryPerformanceFrequency(&freq);
	163	if (err == windows.FALSE) return error.TimerUnsupported;
	164	self.frequency = u64(freq);
	165	self.resolution = @divFloor(ns_per_s, self.frequency);
	166
	167	var start_time: i64 = undefined;
	168	err = windows.QueryPerformanceCounter(&start_time);
	169	debug.assert(err != windows.FALSE);
	170	self.start_time = u64(start_time);
	171	},
	172	Os.linux => {
	173	//On Linux, seccomp can do arbitrary things to our ability to call
	174	// syscalls, including return any errno value it wants and
	175	// inconsistently throwing errors. Since we can't account for
	176	// abuses of seccomp in a reasonable way, we'll assume that if
	177	// seccomp is going to block us it will at least do so consistently
	178	var ts: posix.timespec = undefined;
	179	var result = posix.clock_getres(monotonic_clock_id, &ts);
	180	var errno = posix.getErrno(result);
	181	switch (errno) {
	182	0 => {},
	183	posix.EINVAL => return error.TimerUnsupported,
	184	else => return std.os.unexpectedErrorPosix(errno),
	185	}
	186	self.resolution = u64(ts.tv_sec) * u64(ns_per_s) + u64(ts.tv_nsec);
	187
	188	result = posix.clock_gettime(monotonic_clock_id, &ts);
	189	errno = posix.getErrno(result);
	190	if (errno != 0) return std.os.unexpectedErrorPosix(errno);
	191	self.start_time = u64(ts.tv_sec) * u64(ns_per_s) + u64(ts.tv_nsec);
	192	},
	193	Os.macosx, Os.ios => {
	194	darwin.mach_timebase_info(&self.frequency);
	195	self.resolution = @divFloor(self.frequency.numer, self.frequency.denom);
	196	self.start_time = darwin.mach_absolute_time();
	197	},
	198	else => @compileError("Unsupported OS"),
	199	}
	200	return self;
	201	}
	202
	203	/// Reads the timer value since start or the last reset in nanoseconds
	204	pub fn read(self: &Timer) u64 {
	205	var clock = clockNative() - self.start_time;
	206	return switch (builtin.os) {
	207	Os.windows => @divFloor(clock * ns_per_s, self.frequency),
	208	Os.linux => clock,
	209	Os.macosx, Os.ios => @divFloor(clock * self.frequency.numer, self.frequency.denom),
	210	else => @compileError("Unsupported OS"),
	211	};
	212	}
	213
	214	/// Resets the timer value to 0/now.
	215	pub fn reset(self: &Timer) void
	216	{
	217	self.start_time = clockNative();
	218	}
	219
	220	/// Returns the current value of the timer in nanoseconds, then resets it
	221	pub fn lap(self: &Timer) u64 {
	222	var now = clockNative();
	223	var lap_time = self.read();
	224	self.start_time = now;
	225	return lap_time;
	226	}
	227
	228
	229	const clockNative = switch (builtin.os) {
	230	Os.windows => clockWindows,
	231	Os.linux => clockLinux,
	232	Os.macosx, Os.ios => clockDarwin,
	233	else => @compileError("Unsupported OS"),
	234	};
	235
	236	fn clockWindows() u64 {
	237	var result: i64 = undefined;
	238	var err = windows.QueryPerformanceCounter(&result);
	239	debug.assert(err != windows.FALSE);
	240	return u64(result);
	241	}
	242
	243	fn clockDarwin() u64 {
	244	return darwin.mach_absolute_time();
	245	}
	246
	247	fn clockLinux() u64 {
	248	var ts: posix.timespec = undefined;
	249	var result = posix.clock_gettime(monotonic_clock_id, &ts);
	250	debug.assert(posix.getErrno(result) == 0);
	251	return u64(ts.tv_sec) * u64(ns_per_s) + u64(ts.tv_nsec);
	252	}
	253	};
	254
	255
	256
	257
	258
	259	test "os.time.sleep" {
	260	sleep(0, 1);
	261	}
	262
	263	test "os.time.timestamp" {
	264	const ns_per_ms = (ns_per_s / ms_per_s);
	265	const margin = 50;
	266
	267	const time_0 = milliTimestamp();
	268	sleep(0, ns_per_ms);
	269	const time_1 = milliTimestamp();
	270	const interval = time_1 - time_0;
	271	debug.assert(interval > 0 and interval < margin);
	272	}
	273
	274	test "os.time.Timer" {
	275	const ns_per_ms = (ns_per_s / ms_per_s);
	276	const margin = ns_per_ms * 50;
	277
	278	var timer = try Timer.start();
	279	sleep(0, 10 * ns_per_ms);
	280	const time_0 = timer.read();
	281	debug.assert(time_0 > 0 and time_0 < margin);
	282
	283	const time_1 = timer.lap();
	284	debug.assert(time_1 >= time_0);
	285
	286	timer.reset();
	287	debug.assert(timer.read() < time_1);
	288	}

std/os/windows/index.zig+19

...	...	@@ -28,6 +28,9 @@ pub extern "kernel32" stdcallcc fn CreateProcessA(lpApplicationName: ?LPCSTR, lp
28	28	pub extern "kernel32" stdcallcc fn CreateSymbolicLinkA(lpSymlinkFileName: LPCSTR, lpTargetFileName: LPCSTR,
29	29	dwFlags: DWORD) BOOLEAN;
30	30
	31
	32	pub extern "kernel32" stdcallcc fn CreateThread(lpThreadAttributes: ?LPSECURITY_ATTRIBUTES, dwStackSize: SIZE_T, lpStartAddress: LPTHREAD_START_ROUTINE, lpParameter: ?LPVOID, dwCreationFlags: DWORD, lpThreadId: ?LPDWORD) ?HANDLE;
	33
31	34	pub extern "kernel32" stdcallcc fn DeleteFileA(lpFileName: LPCSTR) BOOL;
32	35
33	36	pub extern "kernel32" stdcallcc fn ExitProcess(exit_code: UINT) noreturn;
...	...	@@ -61,6 +64,8 @@ pub extern "kernel32" stdcallcc fn GetFinalPathNameByHandleA(hFile: HANDLE, lpsz
61	64
62	65	pub extern "kernel32" stdcallcc fn GetProcessHeap() ?HANDLE;
63	66
	67	pub extern "kernel32" stdcallcc fn GetSystemTimeAsFileTime(?&FILETIME) void;
	68
64	69	pub extern "kernel32" stdcallcc fn HeapCreate(flOptions: DWORD, dwInitialSize: SIZE_T, dwMaximumSize: SIZE_T) ?HANDLE;
65	70	pub extern "kernel32" stdcallcc fn HeapDestroy(hHeap: HANDLE) BOOL;
66	71	pub extern "kernel32" stdcallcc fn HeapReAlloc(hHeap: HANDLE, dwFlags: DWORD, lpMem: &c_void, dwBytes: SIZE_T) ?&c_void;
...	...	@@ -77,6 +82,12 @@ pub extern "kernel32" stdcallcc fn HeapFree(hHeap: HANDLE, dwFlags: DWORD, lpMem
77	82
78	83	pub extern "kernel32" stdcallcc fn MoveFileExA(lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR,
79	84	dwFlags: DWORD) BOOL;
	85
	86	pub extern "kernel32" stdcallcc fn QueryPerformanceCounter(lpPerformanceCount: &LARGE_INTEGER) BOOL;
	87
	88	pub extern "kernel32" stdcallcc fn QueryPerformanceFrequency(lpFrequency: &LARGE_INTEGER) BOOL;
	89
	90	pub extern "kernel32" stdcallcc fn PathFileExists(pszPath: ?LPCTSTR) BOOL;
80	91
81	92	pub extern "kernel32" stdcallcc fn ReadFile(in_hFile: HANDLE, out_lpBuffer: &c_void,
82	93	in_nNumberOfBytesToRead: DWORD, out_lpNumberOfBytesRead: &DWORD,
...	...	@@ -137,6 +148,7 @@ pub const UNICODE = false;
137	148	pub const WCHAR = u16;
138	149	pub const WORD = u16;
139	150	pub const LARGE_INTEGER = i64;
	151	pub const FILETIME = i64;
140	152
141	153	pub const TRUE = 1;
142	154	pub const FALSE = 0;
...	...	@@ -308,3 +320,10 @@ pub const FILE_END = 2;
308	320	pub const HEAP_CREATE_ENABLE_EXECUTE = 0x00040000;
309	321	pub const HEAP_GENERATE_EXCEPTIONS = 0x00000004;
310	322	pub const HEAP_NO_SERIALIZE = 0x00000001;
	323
	324	pub const PTHREAD_START_ROUTINE = extern fn(LPVOID) DWORD;
	325	pub const LPTHREAD_START_ROUTINE = PTHREAD_START_ROUTINE;
	326
	327	test "import" {
	328	_ = @import("util.zig");
	329	}

std/rand/index.zig+19-5

...	...	@@ -19,6 +19,7 @@ const builtin = @import("builtin");
19	19	const assert = std.debug.assert;
20	20	const mem = std.mem;
21	21	const math = std.math;
	22	const ziggurat = @import("ziggurat.zig");
22	23
23	24	// When you need fast unbiased random numbers
24	25	pub const DefaultPrng = Xoroshiro128;
...	...	@@ -109,15 +110,28 @@ pub const Random = struct {
109	110	}
110	111	}
111	112
112		/// Return a floating point value normally distributed in the range [0, 1].
	113	/// Return a floating point value normally distributed with mean = 0, stddev = 1.
	114	///
	115	/// To use different parameters, use: floatNorm(...) * desiredStddev + desiredMean.
113	116	pub fn floatNorm(r: &Random, comptime T: type) T {
114		// TODO(tiehuis): See https://www.doornik.com/research/ziggurat.pdf
115		@compileError("floatNorm is unimplemented");
	117	const value = ziggurat.next_f64(r, ziggurat.NormDist);
	118	switch (T) {
	119	f32 => return f32(value),
	120	f64 => return value,
	121	else => @compileError("unknown floating point type"),
	122	}
116	123	}
117	124
118		/// Return a exponentially distributed float between (0, @maxValue(f64))
	125	/// Return an exponentially distributed float with a rate parameter of 1.
	126	///
	127	/// To use a different rate parameter, use: floatExp(...) / desiredRate.
119	128	pub fn floatExp(r: &Random, comptime T: type) T {
120		@compileError("floatExp is unimplemented");
	129	const value = ziggurat.next_f64(r, ziggurat.ExpDist);
	130	switch (T) {
	131	f32 => return f32(value),
	132	f64 => return value,
	133	else => @compileError("unknown floating point type"),
	134	}
121	135	}
122	136
123	137	/// Shuffle a slice into a random order.

std/rand/ziggurat.zig created+146

...	...	@@ -0,0 +1,146 @@
	1	// Implements ZIGNOR [1].
	2	//
	3	// [1]: Jurgen A. Doornik (2005). [An Improved Ziggurat Method to Generate Normal Random Samples]
	4	// (https://www.doornik.com/research/ziggurat.pdf). Nuffield College, Oxford.
	5	//
	6	// rust/rand used as a reference;
	7	//
	8	// NOTE: This seems interesting but reference code is a bit hard to grok:
	9	// https://sbarral.github.io/etf.
	10
	11	const std = @import("../index.zig");
	12	const math = std.math;
	13	const Random = std.rand.Random;
	14
	15	pub fn next_f64(random: &Random, comptime tables: &const ZigTable) f64 {
	16	while (true) {
	17	// We manually construct a float from parts as we can avoid an extra random lookup here by
	18	// using the unused exponent for the lookup table entry.
	19	const bits = random.scalar(u64);
	20	const i = usize(bits & 0xff);
	21
	22	const u = blk: {
	23	if (tables.is_symmetric) {
	24	// Generate a value in the range [2, 4) and scale into [-1, 1)
	25	const repr = ((0x3ff + 1) << 52) \| (bits >> 12);
	26	break :blk @bitCast(f64, repr) - 3.0;
	27	} else {
	28	// Generate a value in the range [1, 2) and scale into (0, 1)
	29	const repr = (0x3ff << 52) \| (bits >> 12);
	30	break :blk @bitCast(f64, repr) - (1.0 - math.f64_epsilon / 2.0);
	31	}
	32	};
	33
	34	const x = u * tables.x[i];
	35	const test_x = if (tables.is_symmetric) math.fabs(x) else x;
	36
	37	// equivalent to \|u\| < tables.x[i+1] / tables.x[i] (or u < tables.x[i+1] / tables.x[i])
	38	if (test_x < tables.x[i + 1]) {
	39	return x;
	40	}
	41
	42	if (i == 0) {
	43	return tables.zero_case(random, u);
	44	}
	45
	46	// equivalent to f1 + DRanU() * (f0 - f1) < 1
	47	if (tables.f[i + 1] + (tables.f[i] - tables.f[i + 1]) * random.float(f64) < tables.pdf(x)) {
	48	return x;
	49	}
	50	}
	51	}
	52
	53	pub const ZigTable = struct {
	54	r: f64,
	55	x: [257]f64,
	56	f: [257]f64,
	57
	58	// probability density function used as a fallback
	59	pdf: fn(f64) f64,
	60	// whether the distribution is symmetric
	61	is_symmetric: bool,
	62	// fallback calculation in the case we are in the 0 block
	63	zero_case: fn(&Random, f64) f64,
	64	};
	65
	66	// zigNorInit
	67	fn ZigTableGen(comptime is_symmetric: bool, comptime r: f64, comptime v: f64, comptime f: fn(f64) f64,
	68	comptime f_inv: fn(f64) f64, comptime zero_case: fn(&Random, f64) f64) ZigTable {
	69	var tables: ZigTable = undefined;
	70
	71	tables.is_symmetric = is_symmetric;
	72	tables.r = r;
	73	tables.pdf = f;
	74	tables.zero_case = zero_case;
	75
	76	tables.x[0] = v / f(r);
	77	tables.x[1] = r;
	78
	79	for (tables.x[2..256]) \|*entry, i\| {
	80	const last = tables.x[2 + i - 1];
	81	*entry = f_inv(v / last + f(last));
	82	}
	83	tables.x[256] = 0;
	84
	85	for (tables.f[0..]) \|*entry, i\| {
	86	*entry = f(tables.x[i]);
	87	}
	88
	89	return tables;
	90	}
	91
	92	// N(0, 1)
	93	pub const NormDist = blk: {
	94	@setEvalBranchQuota(30000);
	95	break :blk ZigTableGen(true, norm_r, norm_v, norm_f, norm_f_inv, norm_zero_case);
	96	};
	97
	98	const norm_r = 3.6541528853610088;
	99	const norm_v = 0.00492867323399;
	100
	101	fn norm_f(x: f64) f64 { return math.exp(-x * x / 2.0); }
	102	fn norm_f_inv(y: f64) f64 { return math.sqrt(-2.0 * math.ln(y)); }
	103	fn norm_zero_case(random: &Random, u: f64) f64 {
	104	var x: f64 = 1;
	105	var y: f64 = 0;
	106
	107	while (-2.0 * y < x * x) {
	108	x = math.ln(random.float(f64)) / norm_r;
	109	y = math.ln(random.float(f64));
	110	}
	111
	112	if (u < 0) {
	113	return x - norm_r;
	114	} else {
	115	return norm_r - x;
	116	}
	117	}
	118
	119	test "ziggurant normal dist sanity" {
	120	var prng = std.rand.DefaultPrng.init(0);
	121	var i: usize = 0;
	122	while (i < 1000) : (i += 1) {
	123	_ = prng.random.floatNorm(f64);
	124	}
	125	}
	126
	127	// Exp(1)
	128	pub const ExpDist = blk: {
	129	@setEvalBranchQuota(30000);
	130	break :blk ZigTableGen(false, exp_r, exp_v, exp_f, exp_f_inv, exp_zero_case);
	131	};
	132
	133	const exp_r = 7.69711747013104972;
	134	const exp_v = 0.0039496598225815571993;
	135
	136	fn exp_f(x: f64) f64 { return math.exp(-x); }
	137	fn exp_f_inv(y: f64) f64 { return -math.ln(y); }
	138	fn exp_zero_case(random: &Random, _: f64) f64 { return exp_r - math.ln(random.float(f64)); }
	139
	140	test "ziggurant exp dist sanity" {
	141	var prng = std.rand.DefaultPrng.init(0);
	142	var i: usize = 0;
	143	while (i < 1000) : (i += 1) {
	144	_ = prng.random.floatExp(f64);
	145	}
	146	}

std/segmented_list.zig created+379

...	...	@@ -0,0 +1,379 @@
	1	const std = @import("index.zig");
	2	const assert = std.debug.assert;
	3	const Allocator = std.mem.Allocator;
	4
	5	// Imagine that `fn at(self: &Self, index: usize) &T` is a customer asking for a box
	6	// from a warehouse, based on a flat array, boxes ordered from 0 to N - 1.
	7	// But the warehouse actually stores boxes in shelves of increasing powers of 2 sizes.
	8	// So when the customer requests a box index, we have to translate it to shelf index
	9	// and box index within that shelf. Illustration:
	10	//
	11	// customer indexes:
	12	// shelf 0: 0
	13	// shelf 1: 1 2
	14	// shelf 2: 3 4 5 6
	15	// shelf 3: 7 8 9 10 11 12 13 14
	16	// shelf 4: 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
	17	// shelf 5: 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62
	18	// ...
	19	//
	20	// warehouse indexes:
	21	// shelf 0: 0
	22	// shelf 1: 0 1
	23	// shelf 2: 0 1 2 3
	24	// shelf 3: 0 1 2 3 4 5 6 7
	25	// shelf 4: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
	26	// shelf 5: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
	27	// ...
	28	//
	29	// With this arrangement, here are the equations to get the shelf index and
	30	// box index based on customer box index:
	31	//
	32	// shelf_index = floor(log2(customer_index + 1))
	33	// shelf_count = ceil(log2(box_count + 1))
	34	// box_index = customer_index + 1 - 2 ** shelf
	35	// shelf_size = 2 ** shelf_index
	36	//
	37	// Now we complicate it a little bit further by adding a preallocated shelf, which must be
	38	// a power of 2:
	39	// prealloc=4
	40	//
	41	// customer indexes:
	42	// prealloc: 0 1 2 3
	43	// shelf 0: 4 5 6 7 8 9 10 11
	44	// shelf 1: 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
	45	// shelf 2: 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59
	46	// ...
	47	//
	48	// warehouse indexes:
	49	// prealloc: 0 1 2 3
	50	// shelf 0: 0 1 2 3 4 5 6 7
	51	// shelf 1: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
	52	// shelf 2: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
	53	// ...
	54	//
	55	// Now the equations are:
	56	//
	57	// shelf_index = floor(log2(customer_index + prealloc)) - log2(prealloc) - 1
	58	// shelf_count = ceil(log2(box_count + prealloc)) - log2(prealloc) - 1
	59	// box_index = customer_index + prealloc - 2 ** (log2(prealloc) + 1 + shelf)
	60	// shelf_size = prealloc * 2 ** (shelf_index + 1)
	61
	62	/// This is a stack data structure where pointers to indexes have the same lifetime as the data structure
	63	/// itself, unlike ArrayList where push() invalidates all existing element pointers.
	64	/// The tradeoff is that elements are not guaranteed to be contiguous. For that, use ArrayList.
	65	/// Note however that most elements are contiguous, making this data structure cache-friendly.
	66	///
	67	/// Because it never has to copy elements from an old location to a new location, it does not require
	68	/// its elements to be copyable, and it avoids wasting memory when backed by an ArenaAllocator.
	69	/// Note that the push() and pop() convenience methods perform a copy, but you can instead use
	70	/// addOne(), at(), setCapacity(), and shrinkCapacity() to avoid copying items.
	71	///
	72	/// This data structure has O(1) push and O(1) pop.
	73	///
	74	/// It supports preallocated elements, making it especially well suited when the expected maximum
	75	/// size is small. `prealloc_item_count` must be 0, or a power of 2.
	76	pub fn SegmentedList(comptime T: type, comptime prealloc_item_count: usize) type {
	77	return struct {
	78	const Self = this;
	79	const prealloc_exp = blk: {
	80	// we don't use the prealloc_exp constant when prealloc_item_count is 0.
	81	assert(prealloc_item_count != 0);
	82
	83	const value = std.math.log2_int(usize, prealloc_item_count);
	84	assert((1 << value) == prealloc_item_count); // prealloc_item_count must be a power of 2
	85	break :blk @typeOf(1)(value);
	86	};
	87	const ShelfIndex = std.math.Log2Int(usize);
	88
	89	prealloc_segment: [prealloc_item_count]T,
	90	dynamic_segments: []&T,
	91	allocator: &Allocator,
	92	len: usize,
	93
	94	pub const prealloc_count = prealloc_item_count;
	95
	96	/// Deinitialize with `deinit`
	97	pub fn init(allocator: &Allocator) Self {
	98	return Self {
	99	.allocator = allocator,
	100	.len = 0,
	101	.prealloc_segment = undefined,
	102	.dynamic_segments = []&T{},
	103	};
	104	}
	105
	106	pub fn deinit(self: &Self) void {
	107	self.freeShelves(ShelfIndex(self.dynamic_segments.len), 0);
	108	self.allocator.free(self.dynamic_segments);
	109	*self = undefined;
	110	}
	111
	112	pub fn at(self: &Self, i: usize) &T {
	113	assert(i < self.len);
	114	return self.uncheckedAt(i);
	115	}
	116
	117	pub fn count(self: &const Self) usize {
	118	return self.len;
	119	}
	120
	121	pub fn push(self: &Self, item: &const T) !void {
	122	const new_item_ptr = try self.addOne();
	123	new_item_ptr = item;
	124	}
	125
	126	pub fn pushMany(self: &Self, items: []const T) !void {
	127	for (items) \|item\| {
	128	try self.push(item);
	129	}
	130	}
	131
	132	pub fn pop(self: &Self) ?T {
	133	if (self.len == 0)
	134	return null;
	135
	136	const index = self.len - 1;
	137	const result = *self.uncheckedAt(index);
	138	self.len = index;
	139	return result;
	140	}
	141
	142	pub fn addOne(self: &Self) !&T {
	143	const new_length = self.len + 1;
	144	try self.growCapacity(new_length);
	145	const result = self.uncheckedAt(self.len);
	146	self.len = new_length;
	147	return result;
	148	}
	149
	150	/// Grows or shrinks capacity to match usage.
	151	pub fn setCapacity(self: &Self, new_capacity: usize) !void {
	152	if (new_capacity <= usize(1) << (prealloc_exp + self.dynamic_segments.len)) {
	153	return self.shrinkCapacity(new_capacity);
	154	} else {
	155	return self.growCapacity(new_capacity);
	156	}
	157	}
	158
	159	/// Only grows capacity, or retains current capacity
	160	pub fn growCapacity(self: &Self, new_capacity: usize) !void {
	161	const new_cap_shelf_count = shelfCount(new_capacity);
	162	const old_shelf_count = ShelfIndex(self.dynamic_segments.len);
	163	if (new_cap_shelf_count > old_shelf_count) {
	164	self.dynamic_segments = try self.allocator.realloc(&T, self.dynamic_segments, new_cap_shelf_count);
	165	var i = old_shelf_count;
	166	errdefer {
	167	self.freeShelves(i, old_shelf_count);
	168	self.dynamic_segments = self.allocator.shrink(&T, self.dynamic_segments, old_shelf_count);
	169	}
	170	while (i < new_cap_shelf_count) : (i += 1) {
	171	self.dynamic_segments[i] = (try self.allocator.alloc(T, shelfSize(i))).ptr;
	172	}
	173	}
	174	}
	175
	176	/// Only shrinks capacity or retains current capacity
	177	pub fn shrinkCapacity(self: &Self, new_capacity: usize) void {
	178	if (new_capacity <= prealloc_item_count) {
	179	const len = ShelfIndex(self.dynamic_segments.len);
	180	self.freeShelves(len, 0);
	181	self.allocator.free(self.dynamic_segments);
	182	self.dynamic_segments = []&T{};
	183	return;
	184	}
	185
	186	const new_cap_shelf_count = shelfCount(new_capacity);
	187	const old_shelf_count = ShelfIndex(self.dynamic_segments.len);
	188	assert(new_cap_shelf_count <= old_shelf_count);
	189	if (new_cap_shelf_count == old_shelf_count) {
	190	return;
	191	}
	192
	193	self.freeShelves(old_shelf_count, new_cap_shelf_count);
	194	self.dynamic_segments = self.allocator.shrink(&T, self.dynamic_segments, new_cap_shelf_count);
	195	}
	196
	197	pub fn uncheckedAt(self: &Self, index: usize) &T {
	198	if (index < prealloc_item_count) {
	199	return &self.prealloc_segment[index];
	200	}
	201	const shelf_index = shelfIndex(index);
	202	const box_index = boxIndex(index, shelf_index);
	203	return &self.dynamic_segments[shelf_index][box_index];
	204	}
	205
	206	fn shelfCount(box_count: usize) ShelfIndex {
	207	if (prealloc_item_count == 0) {
	208	return std.math.log2_int_ceil(usize, box_count + 1);
	209	}
	210	return std.math.log2_int_ceil(usize, box_count + prealloc_item_count) - prealloc_exp - 1;
	211	}
	212
	213	fn shelfSize(shelf_index: ShelfIndex) usize {
	214	if (prealloc_item_count == 0) {
	215	return usize(1) << shelf_index;
	216	}
	217	return usize(1) << (shelf_index + (prealloc_exp + 1));
	218	}
	219
	220	fn shelfIndex(list_index: usize) ShelfIndex {
	221	if (prealloc_item_count == 0) {
	222	return std.math.log2_int(usize, list_index + 1);
	223	}
	224	return std.math.log2_int(usize, list_index + prealloc_item_count) - prealloc_exp - 1;
	225	}
	226
	227	fn boxIndex(list_index: usize, shelf_index: ShelfIndex) usize {
	228	if (prealloc_item_count == 0) {
	229	return (list_index + 1) - (usize(1) << shelf_index);
	230	}
	231	return list_index + prealloc_item_count - (usize(1) << ((prealloc_exp + 1) + shelf_index));
	232	}
	233
	234	fn freeShelves(self: &Self, from_count: ShelfIndex, to_count: ShelfIndex) void {
	235	var i = from_count;
	236	while (i != to_count) {
	237	i -= 1;
	238	self.allocator.free(self.dynamic_segments[i][0..shelfSize(i)]);
	239	}
	240	}
	241
	242	pub const Iterator = struct {
	243	list: &Self,
	244	index: usize,
	245	box_index: usize,
	246	shelf_index: ShelfIndex,
	247	shelf_size: usize,
	248
	249	pub fn next(it: &Iterator) ?&T {
	250	if (it.index >= it.list.len)
	251	return null;
	252	if (it.index < prealloc_item_count) {
	253	const ptr = &it.list.prealloc_segment[it.index];
	254	it.index += 1;
	255	if (it.index == prealloc_item_count) {
	256	it.box_index = 0;
	257	it.shelf_index = 0;
	258	it.shelf_size = prealloc_item_count * 2;
	259	}
	260	return ptr;
	261	}
	262
	263	const ptr = &it.list.dynamic_segments[it.shelf_index][it.box_index];
	264	it.index += 1;
	265	it.box_index += 1;
	266	if (it.box_index == it.shelf_size) {
	267	it.shelf_index += 1;
	268	it.box_index = 0;
	269	it.shelf_size *= 2;
	270	}
	271	return ptr;
	272	}
	273
	274	pub fn prev(it: &Iterator) ?&T {
	275	if (it.index == 0)
	276	return null;
	277
	278	it.index -= 1;
	279	if (it.index < prealloc_item_count)
	280	return &it.list.prealloc_segment[it.index];
	281
	282	if (it.box_index == 0) {
	283	it.shelf_index -= 1;
	284	it.shelf_size /= 2;
	285	it.box_index = it.shelf_size - 1;
	286	} else {
	287	it.box_index -= 1;
	288	}
	289
	290	return &it.list.dynamic_segments[it.shelf_index][it.box_index];
	291	}
	292
	293	pub fn peek(it: &Iterator) ?&T {
	294	if (it.index >= it.list.len)
	295	return null;
	296	if (it.index < prealloc_item_count)
	297	return &it.list.prealloc_segment[it.index];
	298
	299	return &it.list.dynamic_segments[it.shelf_index][it.box_index];
	300	}
	301	};
	302
	303	pub fn iterator(self: &Self, start_index: usize) Iterator {
	304	var it = Iterator {
	305	.list = self,
	306	.index = start_index,
	307	.shelf_index = undefined,
	308	.box_index = undefined,
	309	.shelf_size = undefined,
	310	};
	311	if (start_index >= prealloc_item_count) {
	312	it.shelf_index = shelfIndex(start_index);
	313	it.box_index = boxIndex(start_index, it.shelf_index);
	314	it.shelf_size = shelfSize(it.shelf_index);
	315	}
	316	return it;
	317	}
	318	};
	319	}
	320
	321	test "std.SegmentedList" {
	322	var da = std.heap.DirectAllocator.init();
	323	defer da.deinit();
	324	var a = &da.allocator;
	325
	326	try testSegmentedList(0, a);
	327	try testSegmentedList(1, a);
	328	try testSegmentedList(2, a);
	329	try testSegmentedList(4, a);
	330	try testSegmentedList(8, a);
	331	try testSegmentedList(16, a);
	332	}
	333
	334	fn testSegmentedList(comptime prealloc: usize, allocator: &Allocator) !void {
	335	var list = SegmentedList(i32, prealloc).init(allocator);
	336	defer list.deinit();
	337
	338	{var i: usize = 0; while (i < 100) : (i += 1) {
	339	try list.push(i32(i + 1));
	340	assert(list.len == i + 1);
	341	}}
	342
	343	{var i: usize = 0; while (i < 100) : (i += 1) {
	344	assert(*list.at(i) == i32(i + 1));
	345	}}
	346
	347	{
	348	var it = list.iterator(0);
	349	var x: i32 = 0;
	350	while (it.next()) \|item\| {
	351	x += 1;
	352	assert(*item == x);
	353	}
	354	assert(x == 100);
	355	while (it.prev()) \|item\| : (x -= 1) {
	356	assert(*item == x);
	357	}
	358	assert(x == 0);
	359	}
	360
	361	assert(??list.pop() == 100);
	362	assert(list.len == 99);
	363
	364	try list.pushMany([]i32 { 1, 2, 3 });
	365	assert(list.len == 102);
	366	assert(??list.pop() == 3);
	367	assert(??list.pop() == 2);
	368	assert(??list.pop() == 1);
	369	assert(list.len == 99);
	370
	371	try list.pushMany([]const i32 {});
	372	assert(list.len == 99);
	373
	374	var i: i32 = 99;
	375	while (list.pop()) \|item\| : (i -= 1) {
	376	assert(item == i);
	377	list.shrinkCapacity(list.len);
	378	}
	379	}

std/special/bootstrap.zig+19-8

...	...	@@ -48,22 +48,33 @@ extern fn WinMainCRTStartup() noreturn {
48	48	fn posixCallMainAndExit() noreturn {
49	49	const argc = *argc_ptr;
50	50	const argv = @ptrCast(&&u8, &argc_ptr[1]);
51		const envp = @ptrCast(&?&u8, &argv[argc + 1]);
	51	const envp_nullable = @ptrCast(&?&u8, &argv[argc + 1]);
	52	var envp_count: usize = 0;
	53	while (envp_nullable[envp_count]) \|_\| : (envp_count += 1) {}
	54	const envp = @ptrCast(&&u8, envp_nullable)[0..envp_count];
	55	if (builtin.os == builtin.Os.linux) {
	56	const auxv = &@ptrCast(&usize, envp.ptr)[envp_count + 1];
	57	var i: usize = 0;
	58	while (auxv[i] != 0) : (i += 2) {
	59	if (auxv[i] < std.os.linux_aux_raw.len) std.os.linux_aux_raw[auxv[i]] = auxv[i+1];
	60	}
	61	std.debug.assert(std.os.linux_aux_raw[std.elf.AT_PAGESZ] == std.os.page_size);
	62	}
	63
52	64	std.os.posix.exit(callMainWithArgs(argc, argv, envp));
53	65	}
54	66
55		fn callMainWithArgs(argc: usize, argv: &&u8, envp: &?&u8) u8 {
	67	fn callMainWithArgs(argc: usize, argv: &&u8, envp: []&u8) u8 {
56	68	std.os.ArgIteratorPosix.raw = argv[0..argc];
57
58		var env_count: usize = 0;
59		while (envp[env_count] != null) : (env_count += 1) {}
60		std.os.posix_environ_raw = @ptrCast(&&u8, envp)[0..env_count];
61
	69	std.os.posix_environ_raw = envp;
62	70	return callMain();
63	71	}
64	72
65	73	extern fn main(c_argc: i32, c_argv: &&u8, c_envp: &?&u8) i32 {
66		return callMainWithArgs(usize(c_argc), c_argv, c_envp);
	74	var env_count: usize = 0;
	75	while (c_envp[env_count] != null) : (env_count += 1) {}
	76	const envp = @ptrCast(&&u8, c_envp)[0..env_count];
	77	return callMainWithArgs(usize(c_argc), c_argv, envp);
67	78	}
68	79
69	80	fn callMain() u8 {

std/special/bootstrap_lib.zig+2-1

...	...	@@ -1,9 +1,10 @@
1	1	// This file is included in the compilation unit when exporting a library on windows.
2	2
3	3	const std = @import("std");
	4	const builtin = @import("builtin");
4	5
5	6	comptime {
6		@export("_DllMainCRTStartup", _DllMainCRTStartup);
	7	@export("_DllMainCRTStartup", _DllMainCRTStartup, builtin.GlobalLinkage.Strong);
7	8	}
8	9
9	10	stdcallcc fn _DllMainCRTStartup(hinstDLL: std.os.windows.HINSTANCE, fdwReason: std.os.windows.DWORD,

std/special/builtin.zig+272-9

...	...	@@ -14,37 +14,91 @@ pub fn panic(msg: []const u8, error_return_trace: ?&builtin.StackTrace) noreturn
14	14	}
15	15	}
16	16
17		// Note that memset does not return `dest`, like the libc API.
18		// The semantics of memset is dictated by the corresponding
19		// LLVM intrinsics, not by the libc API.
20		export fn memset(dest: ?&u8, c: u8, n: usize) void {
	17	export fn memset(dest: ?&u8, c: u8, n: usize) ?&u8 {
21	18	@setRuntimeSafety(false);
22	19
23	20	var index: usize = 0;
24	21	while (index != n) : (index += 1)
25	22	(??dest)[index] = c;
	23
	24	return dest;
26	25	}
27	26
28		// Note that memcpy does not return `dest`, like the libc API.
29		// The semantics of memcpy is dictated by the corresponding
30		// LLVM intrinsics, not by the libc API.
31		export fn memcpy(noalias dest: ?&u8, noalias src: ?&const u8, n: usize) void {
	27	export fn memcpy(noalias dest: ?&u8, noalias src: ?&const u8, n: usize) ?&u8 {
32	28	@setRuntimeSafety(false);
33	29
34	30	var index: usize = 0;
35	31	while (index != n) : (index += 1)
36	32	(??dest)[index] = (??src)[index];
	33
	34	return dest;
	35	}
	36
	37	export fn memmove(dest: ?&u8, src: ?&const u8, n: usize) ?&u8 {
	38	@setRuntimeSafety(false);
	39
	40	if (@ptrToInt(dest) < @ptrToInt(src)) {
	41	var index: usize = 0;
	42	while (index != n) : (index += 1) {
	43	(??dest)[index] = (??src)[index];
	44	}
	45	} else {
	46	var index = n;
	47	while (index != 0) {
	48	index -= 1;
	49	(??dest)[index] = (??src)[index];
	50	}
	51	}
	52
	53	return dest;
37	54	}
38	55
39	56	comptime {
40		if (builtin.mode != builtin.Mode.ReleaseFast and builtin.os != builtin.Os.windows) {
	57	if (builtin.mode != builtin.Mode.ReleaseFast and
	58	builtin.mode != builtin.Mode.ReleaseSmall and
	59	builtin.os != builtin.Os.windows) {
41	60	@export("__stack_chk_fail", __stack_chk_fail, builtin.GlobalLinkage.Strong);
42	61	}
	62	if (builtin.os == builtin.Os.linux and builtin.arch == builtin.Arch.x86_64) {
	63	@export("clone", clone, builtin.GlobalLinkage.Strong);
	64	}
43	65	}
44	66	extern fn __stack_chk_fail() noreturn {
45	67	@panic("stack smashing detected");
46	68	}
47	69
	70	// TODO we should be able to put this directly in std/linux/x86_64.zig but
	71	// it causes a segfault in release mode. this is a workaround of calling it
	72	// across .o file boundaries. fix comptime @ptrCast of nakedcc functions.
	73	nakedcc fn clone() void {
	74	asm volatile (
	75	\\ xor %%eax,%%eax
	76	\\ mov $56,%%al
	77	\\ mov %%rdi,%%r11
	78	\\ mov %%rdx,%%rdi
	79	\\ mov %%r8,%%rdx
	80	\\ mov %%r9,%%r8
	81	\\ mov 8(%%rsp),%%r10
	82	\\ mov %%r11,%%r9
	83	\\ and $-16,%%rsi
	84	\\ sub $8,%%rsi
	85	\\ mov %%rcx,(%%rsi)
	86	\\ syscall
	87	\\ test %%eax,%%eax
	88	\\ jnz 1f
	89	\\ xor %%ebp,%%ebp
	90	\\ pop %%rdi
	91	\\ call *%%r9
	92	\\ mov %%eax,%%edi
	93	\\ xor %%eax,%%eax
	94	\\ mov $60,%%al
	95	\\ syscall
	96	\\ hlt
	97	\\1: ret
	98	\\
	99	);
	100	}
	101
48	102	const math = @import("../math/index.zig");
49	103
50	104	export fn fmodf(x: f32, y: f32) f32 { return generic_fmod(f32, x, y); }
...	...	@@ -142,3 +196,212 @@ fn isNan(comptime T: type, bits: T) bool {
142	196	unreachable;
143	197	}
144	198	}
	199
	200	// NOTE: The original code is full of implicit signed -> unsigned assumptions and u32 wraparound
	201	// behaviour. Most intermediate i32 values are changed to u32 where appropriate but there are
	202	// potentially some edge cases remaining that are not handled in the same way.
	203	export fn sqrt(x: f64) f64 {
	204	const tiny: f64 = 1.0e-300;
	205	const sign: u32 = 0x80000000;
	206	const u = @bitCast(u64, x);
	207
	208	var ix0 = u32(u >> 32);
	209	var ix1 = u32(u & 0xFFFFFFFF);
	210
	211	// sqrt(nan) = nan, sqrt(+inf) = +inf, sqrt(-inf) = nan
	212	if (ix0 & 0x7FF00000 == 0x7FF00000) {
	213	return x * x + x;
	214	}
	215
	216	// sqrt(+-0) = +-0
	217	if (x == 0.0) {
	218	return x;
	219	}
	220	// sqrt(-ve) = snan
	221	if (ix0 & sign != 0) {
	222	return math.snan(f64);
	223	}
	224
	225	// normalize x
	226	var m = i32(ix0 >> 20);
	227	if (m == 0) {
	228	// subnormal
	229	while (ix0 == 0) {
	230	m -= 21;
	231	ix0 \|= ix1 >> 11;
	232	ix1 <<= 21;
	233	}
	234
	235	// subnormal
	236	var i: u32 = 0;
	237	while (ix0 & 0x00100000 == 0) : (i += 1) {
	238	ix0 <<= 1;
	239	}
	240	m -= i32(i) - 1;
	241	ix0 \|= ix1 >> u5(32 - i);
	242	ix1 <<= u5(i);
	243	}
	244
	245	// unbias exponent
	246	m -= 1023;
	247	ix0 = (ix0 & 0x000FFFFF) \| 0x00100000;
	248	if (m & 1 != 0) {
	249	ix0 += ix0 + (ix1 >> 31);
	250	ix1 = ix1 +% ix1;
	251	}
	252	m >>= 1;
	253
	254	// sqrt(x) bit by bit
	255	ix0 += ix0 + (ix1 >> 31);
	256	ix1 = ix1 +% ix1;
	257
	258	var q: u32 = 0;
	259	var q1: u32 = 0;
	260	var s0: u32 = 0;
	261	var s1: u32 = 0;
	262	var r: u32 = 0x00200000;
	263	var t: u32 = undefined;
	264	var t1: u32 = undefined;
	265
	266	while (r != 0) {
	267	t = s0 +% r;
	268	if (t <= ix0) {
	269	s0 = t + r;
	270	ix0 -= t;
	271	q += r;
	272	}
	273	ix0 = ix0 +% ix0 +% (ix1 >> 31);
	274	ix1 = ix1 +% ix1;
	275	r >>= 1;
	276	}
	277
	278	r = sign;
	279	while (r != 0) {
	280	t = s1 +% r;
	281	t = s0;
	282	if (t < ix0 or (t == ix0 and t1 <= ix1)) {
	283	s1 = t1 +% r;
	284	if (t1 & sign == sign and s1 & sign == 0) {
	285	s0 += 1;
	286	}
	287	ix0 -= t;
	288	if (ix1 < t1) {
	289	ix0 -= 1;
	290	}
	291	ix1 = ix1 -% t1;
	292	q1 += r;
	293	}
	294	ix0 = ix0 +% ix0 +% (ix1 >> 31);
	295	ix1 = ix1 +% ix1;
	296	r >>= 1;
	297	}
	298
	299	// rounding direction
	300	if (ix0 \| ix1 != 0) {
	301	var z = 1.0 - tiny; // raise inexact
	302	if (z >= 1.0) {
	303	z = 1.0 + tiny;
	304	if (q1 == 0xFFFFFFFF) {
	305	q1 = 0;
	306	q += 1;
	307	} else if (z > 1.0) {
	308	if (q1 == 0xFFFFFFFE) {
	309	q += 1;
	310	}
	311	q1 += 2;
	312	} else {
	313	q1 += q1 & 1;
	314	}
	315	}
	316	}
	317
	318	ix0 = (q >> 1) + 0x3FE00000;
	319	ix1 = q1 >> 1;
	320	if (q & 1 != 0) {
	321	ix1 \|= 0x80000000;
	322	}
	323
	324	// NOTE: musl here appears to rely on signed twos-complement wraparound. +% has the same
	325	// behaviour at least.
	326	var iix0 = i32(ix0);
	327	iix0 = iix0 +% (m << 20);
	328
	329	const uz = (u64(iix0) << 32) \| ix1;
	330	return @bitCast(f64, uz);
	331	}
	332
	333	export fn sqrtf(x: f32) f32 {
	334	const tiny: f32 = 1.0e-30;
	335	const sign: i32 = @bitCast(i32, u32(0x80000000));
	336	var ix: i32 = @bitCast(i32, x);
	337
	338	if ((ix & 0x7F800000) == 0x7F800000) {
	339	return x * x + x; // sqrt(nan) = nan, sqrt(+inf) = +inf, sqrt(-inf) = snan
	340	}
	341
	342	// zero
	343	if (ix <= 0) {
	344	if (ix & ~sign == 0) {
	345	return x; // sqrt (+-0) = +-0
	346	}
	347	if (ix < 0) {
	348	return math.snan(f32);
	349	}
	350	}
	351
	352	// normalize
	353	var m = ix >> 23;
	354	if (m == 0) {
	355	// subnormal
	356	var i: i32 = 0;
	357	while (ix & 0x00800000 == 0) : (i += 1) {
	358	ix <<= 1;
	359	}
	360	m -= i - 1;
	361	}
	362
	363	m -= 127; // unbias exponent
	364	ix = (ix & 0x007FFFFF) \| 0x00800000;
	365
	366	if (m & 1 != 0) { // odd m, double x to even
	367	ix += ix;
	368	}
	369
	370	m >>= 1; // m = [m / 2]
	371
	372	// sqrt(x) bit by bit
	373	ix += ix;
	374	var q: i32 = 0; // q = sqrt(x)
	375	var s: i32 = 0;
	376	var r: i32 = 0x01000000; // r = moving bit right -> left
	377
	378	while (r != 0) {
	379	const t = s + r;
	380	if (t <= ix) {
	381	s = t + r;
	382	ix -= t;
	383	q += r;
	384	}
	385	ix += ix;
	386	r >>= 1;
	387	}
	388
	389	// floating add to find rounding direction
	390	if (ix != 0) {
	391	var z = 1.0 - tiny; // inexact
	392	if (z >= 1.0) {
	393	z = 1.0 + tiny;
	394	if (z > 1.0) {
	395	q += 2;
	396	} else {
	397	if (q & 1 != 0) {
	398	q += 1;
	399	}
	400	}
	401	}
	402	}
	403
	404	ix = (q >> 1) + 0x3f000000;
	405	ix += m << 23;
	406	return @bitCast(f32, ix);
	407	}

std/special/compiler_rt/fixuint.zig+1-1

...	...	@@ -1,5 +1,5 @@
1	1	const is_test = @import("builtin").is_test;
2		const Log2Int = @import("../../math/index.zig").Log2Int;
	2	const Log2Int = @import("std").math.Log2Int;
3	3
4	4	pub fn fixuint(comptime fp_t: type, comptime fixuint_t: type, a: fp_t) fixuint_t {
5	5	@setRuntimeSafety(is_test);

std/special/compiler_rt/fixunsdfdi_test.zig+1-1

...	...	@@ -1,5 +1,5 @@
1	1	const __fixunsdfdi = @import("fixunsdfdi.zig").__fixunsdfdi;
2		const assert = @import("../../index.zig").debug.assert;
	2	const assert = @import("std").debug.assert;
3	3
4	4	fn test__fixunsdfdi(a: f64, expected: u64) void {
5	5	const x = __fixunsdfdi(a);

std/special/compiler_rt/fixunsdfsi_test.zig+1-1

...	...	@@ -1,5 +1,5 @@
1	1	const __fixunsdfsi = @import("fixunsdfsi.zig").__fixunsdfsi;
2		const assert = @import("../../index.zig").debug.assert;
	2	const assert = @import("std").debug.assert;
3	3
4	4	fn test__fixunsdfsi(a: f64, expected: u32) void {
5	5	const x = __fixunsdfsi(a);

std/special/compiler_rt/fixunsdfti_test.zig+1-1

...	...	@@ -1,5 +1,5 @@
1	1	const __fixunsdfti = @import("fixunsdfti.zig").__fixunsdfti;
2		const assert = @import("../../index.zig").debug.assert;
	2	const assert = @import("std").debug.assert;
3	3
4	4	fn test__fixunsdfti(a: f64, expected: u128) void {
5	5	const x = __fixunsdfti(a);

std/special/compiler_rt/fixunssfdi_test.zig+1-1

...	...	@@ -1,5 +1,5 @@
1	1	const __fixunssfdi = @import("fixunssfdi.zig").__fixunssfdi;
2		const assert = @import("../../index.zig").debug.assert;
	2	const assert = @import("std").debug.assert;
3	3
4	4	fn test__fixunssfdi(a: f32, expected: u64) void {
5	5	const x = __fixunssfdi(a);

std/special/compiler_rt/fixunssfsi_test.zig+1-1

...	...	@@ -1,5 +1,5 @@
1	1	const __fixunssfsi = @import("fixunssfsi.zig").__fixunssfsi;
2		const assert = @import("../../index.zig").debug.assert;
	2	const assert = @import("std").debug.assert;
3	3
4	4	fn test__fixunssfsi(a: f32, expected: u32) void {
5	5	const x = __fixunssfsi(a);

std/special/compiler_rt/fixunssfti_test.zig+1-1

...	...	@@ -1,5 +1,5 @@
1	1	const __fixunssfti = @import("fixunssfti.zig").__fixunssfti;
2		const assert = @import("../../index.zig").debug.assert;
	2	const assert = @import("std").debug.assert;
3	3
4	4	fn test__fixunssfti(a: f32, expected: u128) void {
5	5	const x = __fixunssfti(a);

std/special/compiler_rt/fixunstfdi_test.zig+1-1

...	...	@@ -1,5 +1,5 @@
1	1	const __fixunstfdi = @import("fixunstfdi.zig").__fixunstfdi;
2		const assert = @import("../../index.zig").debug.assert;
	2	const assert = @import("std").debug.assert;
3	3
4	4	fn test__fixunstfdi(a: f128, expected: u64) void {
5	5	const x = __fixunstfdi(a);

std/special/compiler_rt/fixunstfsi_test.zig+1-1

...	...	@@ -1,5 +1,5 @@
1	1	const __fixunstfsi = @import("fixunstfsi.zig").__fixunstfsi;
2		const assert = @import("../../index.zig").debug.assert;
	2	const assert = @import("std").debug.assert;
3	3
4	4	fn test__fixunstfsi(a: f128, expected: u32) void {
5	5	const x = __fixunstfsi(a);

std/special/compiler_rt/fixunstfti_test.zig+1-1

...	...	@@ -1,5 +1,5 @@
1	1	const __fixunstfti = @import("fixunstfti.zig").__fixunstfti;
2		const assert = @import("../../index.zig").debug.assert;
	2	const assert = @import("std").debug.assert;
3	3
4	4	fn test__fixunstfti(a: f128, expected: u128) void {
5	5	const x = __fixunstfti(a);

std/special/compiler_rt/index.zig+20-6

...	...	@@ -32,10 +32,6 @@ comptime {
32	32	@export("__fixunstfti", @import("fixunstfti.zig").__fixunstfti, linkage);
33	33
34	34	@export("__udivmoddi4", @import("udivmoddi4.zig").__udivmoddi4, linkage);
35		@export("__udivmodti4", @import("udivmodti4.zig").__udivmodti4, linkage);
36
37		@export("__udivti3", @import("udivti3.zig").__udivti3, linkage);
38		@export("__umodti3", @import("umodti3.zig").__umodti3, linkage);
39	35
40	36	@export("__udivsi3", __udivsi3, linkage);
41	37	@export("__udivdi3", __udivdi3, linkage);
...	...	@@ -62,13 +58,21 @@ comptime {
62	58	@export("__chkstk", __chkstk, strong_linkage);
63	59	@export("___chkstk_ms", ___chkstk_ms, linkage);
64	60	}
	61	@export("__udivti3", @import("udivti3.zig").__udivti3_windows_x86_64, linkage);
	62	@export("__udivmodti4", @import("udivmodti4.zig").__udivmodti4_windows_x86_64, linkage);
	63	@export("__umodti3", @import("umodti3.zig").__umodti3_windows_x86_64, linkage);
65	64	},
66	65	else => {},
67	66	}
	67	} else {
	68	@export("__udivti3", @import("udivti3.zig").__udivti3, linkage);
	69	@export("__udivmodti4", @import("udivmodti4.zig").__udivmodti4, linkage);
	70	@export("__umodti3", @import("umodti3.zig").__umodti3, linkage);
68	71	}
69	72	}
70	73
71		const assert = @import("../../index.zig").debug.assert;
	74	const std = @import("std");
	75	const assert = std.debug.assert;
72	76
73	77	const __udivmoddi4 = @import("udivmoddi4.zig").__udivmoddi4;
74	78
...	...	@@ -77,12 +81,22 @@ const __udivmoddi4 = @import("udivmoddi4.zig").__udivmoddi4;
77	81	pub fn panic(msg: []const u8, error_return_trace: ?&builtin.StackTrace) noreturn {
78	82	@setCold(true);
79	83	if (is_test) {
80		@import("std").debug.panic("{}", msg);
	84	std.debug.panic("{}", msg);
81	85	} else {
82	86	unreachable;
83	87	}
84	88	}
85	89
	90	pub fn setXmm0(comptime T: type, value: T) void {
	91	comptime assert(builtin.arch == builtin.Arch.x86_64);
	92	const aligned_value: T align(16) = value;
	93	asm volatile (
	94	\\movaps (%[ptr]), %%xmm0
	95	:
	96	: [ptr] "r" (&aligned_value)
	97	: "xmm0");
	98	}
	99
86	100	extern fn __udivdi3(a: u64, b: u64) u64 {
87	101	@setRuntimeSafety(is_test);
88	102	return __udivmoddi4(a, b, null);

std/special/compiler_rt/udivmod.zig+1-1

...	...	@@ -9,7 +9,7 @@ pub fn udivmod(comptime DoubleInt: type, a: DoubleInt, b: DoubleInt, maybe_rem:
9	9
10	10	const SingleInt = @IntType(false, @divExact(DoubleInt.bit_count, 2));
11	11	const SignedDoubleInt = @IntType(true, DoubleInt.bit_count);
12		const Log2SingleInt = @import("../../math/index.zig").Log2Int(SingleInt);
	12	const Log2SingleInt = @import("std").math.Log2Int(SingleInt);
13	13
14	14	const n = *@ptrCast(&const [2]SingleInt, &a); // TODO issue #421
15	15	const d = *@ptrCast(&const [2]SingleInt, &b); // TODO issue #421

std/special/compiler_rt/udivmodti4.zig+6

...	...	@@ -1,11 +1,17 @@
1	1	const udivmod = @import("udivmod.zig").udivmod;
2	2	const builtin = @import("builtin");
	3	const compiler_rt = @import("index.zig");
3	4
4	5	pub extern fn __udivmodti4(a: u128, b: u128, maybe_rem: ?&u128) u128 {
5	6	@setRuntimeSafety(builtin.is_test);
6	7	return udivmod(u128, a, b, maybe_rem);
7	8	}
8	9
	10	pub extern fn __udivmodti4_windows_x86_64(a: &const u128, b: &const u128, maybe_rem: ?&u128) void {
	11	@setRuntimeSafety(builtin.is_test);
	12	compiler_rt.setXmm0(u128, udivmod(u128, a, b, maybe_rem));
	13	}
	14
9	15	test "import udivmodti4" {
10	16	_ = @import("udivmodti4_test.zig");
11	17	}

std/special/compiler_rt/udivti3.zig+7-2

...	...	@@ -1,7 +1,12 @@
1		const __udivmodti4 = @import("udivmodti4.zig").__udivmodti4;
	1	const udivmodti4 = @import("udivmodti4.zig");
2	2	const builtin = @import("builtin");
3	3
4	4	pub extern fn __udivti3(a: u128, b: u128) u128 {
5	5	@setRuntimeSafety(builtin.is_test);
6		return __udivmodti4(a, b, null);
	6	return udivmodti4.__udivmodti4(a, b, null);
	7	}
	8
	9	pub extern fn __udivti3_windows_x86_64(a: &const u128, b: &const u128) void {
	10	@setRuntimeSafety(builtin.is_test);
	11	udivmodti4.__udivmodti4_windows_x86_64(a, b, null);
7	12	}

std/special/compiler_rt/umodti3.zig+8-2

...	...	@@ -1,9 +1,15 @@
1		const __udivmodti4 = @import("udivmodti4.zig").__udivmodti4;
	1	const udivmodti4 = @import("udivmodti4.zig");
2	2	const builtin = @import("builtin");
	3	const compiler_rt = @import("index.zig");
3	4
4	5	pub extern fn __umodti3(a: u128, b: u128) u128 {
5	6	@setRuntimeSafety(builtin.is_test);
6	7	var r: u128 = undefined;
7		_ = __udivmodti4(a, b, &r);
	8	_ = udivmodti4.__udivmodti4(a, b, &r);
8	9	return r;
9	10	}
	11
	12	pub extern fn __umodti3_windows_x86_64(a: &const u128, b: &const u128) void {
	13	@setRuntimeSafety(builtin.is_test);
	14	compiler_rt.setXmm0(u128, __umodti3(a, b));
	15	}

std/unicode.zig+151-12

...	...	@@ -1,6 +1,16 @@
1	1	const std = @import("./index.zig");
2	2	const debug = std.debug;
3	3
	4	/// Returns how many bytes the UTF-8 representation would require
	5	/// for the given codepoint.
	6	pub fn utf8CodepointSequenceLength(c: u32) !u3 {
	7	if (c < 0x80) return u3(1);
	8	if (c < 0x800) return u3(2);
	9	if (c < 0x10000) return u3(3);
	10	if (c < 0x110000) return u3(4);
	11	return error.CodepointTooLarge;
	12	}
	13
4	14	/// Given the first byte of a UTF-8 codepoint,
5	15	/// returns a number 1-4 indicating the total length of the codepoint in bytes.
6	16	/// If this byte does not match the form of a UTF-8 start byte, returns Utf8InvalidStartByte.
...	...	@@ -12,11 +22,47 @@ pub fn utf8ByteSequenceLength(first_byte: u8) !u3 {
12	22	return error.Utf8InvalidStartByte;
13	23	}
14	24
	25	/// Encodes the given codepoint into a UTF-8 byte sequence.
	26	/// c: the codepoint.
	27	/// out: the out buffer to write to. Must have a len >= utf8CodepointSequenceLength(c).
	28	/// Errors: if c cannot be encoded in UTF-8.
	29	/// Returns: the number of bytes written to out.
	30	pub fn utf8Encode(c: u32, out: []u8) !u3 {
	31	const length = try utf8CodepointSequenceLength(c);
	32	debug.assert(out.len >= length);
	33	switch (length) {
	34	// The pattern for each is the same
	35	// - Increasing the initial shift by 6 each time
	36	// - Each time after the first shorten the shifted
	37	// value to a max of 0b111111 (63)
	38	1 => out[0] = u8(c), // Can just do 0 + codepoint for initial range
	39	2 => {
	40	out[0] = u8(0b11000000 \| (c >> 6));
	41	out[1] = u8(0b10000000 \| (c & 0b111111));
	42	},
	43	3 => {
	44	if (0xd800 <= c and c <= 0xdfff) return error.Utf8CannotEncodeSurrogateHalf;
	45	out[0] = u8(0b11100000 \| (c >> 12));
	46	out[1] = u8(0b10000000 \| ((c >> 6) & 0b111111));
	47	out[2] = u8(0b10000000 \| (c & 0b111111));
	48	},
	49	4 => {
	50	out[0] = u8(0b11110000 \| (c >> 18));
	51	out[1] = u8(0b10000000 \| ((c >> 12) & 0b111111));
	52	out[2] = u8(0b10000000 \| ((c >> 6) & 0b111111));
	53	out[3] = u8(0b10000000 \| (c & 0b111111));
	54	},
	55	else => unreachable,
	56	}
	57	return length;
	58	}
	59
	60	const Utf8DecodeError = Utf8Decode2Error \|\| Utf8Decode3Error \|\| Utf8Decode4Error;
15	61	/// Decodes the UTF-8 codepoint encoded in the given slice of bytes.
16	62	/// bytes.len must be equal to utf8ByteSequenceLength(bytes[0]) catch unreachable.
17	63	/// If you already know the length at comptime, you can call one of
18	64	/// utf8Decode2,utf8Decode3,utf8Decode4 directly instead of this function.
19		pub fn utf8Decode(bytes: []const u8) !u32 {
	65	pub fn utf8Decode(bytes: []const u8) Utf8DecodeError!u32 {
20	66	return switch (bytes.len) {
21	67	1 => u32(bytes[0]),
22	68	2 => utf8Decode2(bytes),
...	...	@@ -25,7 +71,12 @@ pub fn utf8Decode(bytes: []const u8) !u32 {
25	71	else => unreachable,
26	72	};
27	73	}
28		pub fn utf8Decode2(bytes: []const u8) !u32 {
	74
	75	const Utf8Decode2Error = error{
	76	Utf8ExpectedContinuation,
	77	Utf8OverlongEncoding,
	78	};
	79	pub fn utf8Decode2(bytes: []const u8) Utf8Decode2Error!u32 {
29	80	debug.assert(bytes.len == 2);
30	81	debug.assert(bytes[0] & 0b11100000 == 0b11000000);
31	82	var value: u32 = bytes[0] & 0b00011111;
...	...	@@ -38,7 +89,13 @@ pub fn utf8Decode2(bytes: []const u8) !u32 {
38	89
39	90	return value;
40	91	}
41		pub fn utf8Decode3(bytes: []const u8) !u32 {
	92
	93	const Utf8Decode3Error = error{
	94	Utf8ExpectedContinuation,
	95	Utf8OverlongEncoding,
	96	Utf8EncodesSurrogateHalf,
	97	};
	98	pub fn utf8Decode3(bytes: []const u8) Utf8Decode3Error!u32 {
42	99	debug.assert(bytes.len == 3);
43	100	debug.assert(bytes[0] & 0b11110000 == 0b11100000);
44	101	var value: u32 = bytes[0] & 0b00001111;
...	...	@@ -56,7 +113,13 @@ pub fn utf8Decode3(bytes: []const u8) !u32 {
56	113
57	114	return value;
58	115	}
59		pub fn utf8Decode4(bytes: []const u8) !u32 {
	116
	117	const Utf8Decode4Error = error{
	118	Utf8ExpectedContinuation,
	119	Utf8OverlongEncoding,
	120	Utf8CodepointTooLarge,
	121	};
	122	pub fn utf8Decode4(bytes: []const u8) Utf8Decode4Error!u32 {
60	123	debug.assert(bytes.len == 4);
61	124	debug.assert(bytes[0] & 0b11111000 == 0b11110000);
62	125	var value: u32 = bytes[0] & 0b00000111;
...	...	@@ -158,19 +221,67 @@ const Utf8Iterator = struct {
158	221	pub fn nextCodepoint(it: &Utf8Iterator) ?u32 {
159	222	const slice = it.nextCodepointSlice() ?? return null;
160	223
161		const r = switch (slice.len) {
162		1 => u32(slice[0]),
163		2 => utf8Decode2(slice),
164		3 => utf8Decode3(slice),
165		4 => utf8Decode4(slice),
	224	switch (slice.len) {
	225	1 => return u32(slice[0]),
	226	2 => return utf8Decode2(slice) catch unreachable,
	227	3 => return utf8Decode3(slice) catch unreachable,
	228	4 => return utf8Decode4(slice) catch unreachable,
166	229	else => unreachable,
167		};
168
169		return r catch unreachable;
	230	}
170	231	}
171	232	};
172	233
	234	test "utf8 encode" {
	235	comptime testUtf8Encode() catch unreachable;
	236	try testUtf8Encode();
	237	}
	238	fn testUtf8Encode() !void {
	239	// A few taken from wikipedia a few taken elsewhere
	240	var array: [4]u8 = undefined;
	241	debug.assert((try utf8Encode(try utf8Decode("€"), array[0..])) == 3);
	242	debug.assert(array[0] == 0b11100010);
	243	debug.assert(array[1] == 0b10000010);
	244	debug.assert(array[2] == 0b10101100);
	245
	246	debug.assert((try utf8Encode(try utf8Decode("$"), array[0..])) == 1);
	247	debug.assert(array[0] == 0b00100100);
	248
	249	debug.assert((try utf8Encode(try utf8Decode("¢"), array[0..])) == 2);
	250	debug.assert(array[0] == 0b11000010);
	251	debug.assert(array[1] == 0b10100010);
	252
	253	debug.assert((try utf8Encode(try utf8Decode("𐍈"), array[0..])) == 4);
	254	debug.assert(array[0] == 0b11110000);
	255	debug.assert(array[1] == 0b10010000);
	256	debug.assert(array[2] == 0b10001101);
	257	debug.assert(array[3] == 0b10001000);
	258	}
	259
	260	test "utf8 encode error" {
	261	comptime testUtf8EncodeError();
	262	testUtf8EncodeError();
	263	}
	264	fn testUtf8EncodeError() void {
	265	var array: [4]u8 = undefined;
	266	testErrorEncode(0xd800, array[0..], error.Utf8CannotEncodeSurrogateHalf);
	267	testErrorEncode(0xdfff, array[0..], error.Utf8CannotEncodeSurrogateHalf);
	268	testErrorEncode(0x110000, array[0..], error.CodepointTooLarge);
	269	testErrorEncode(0xffffffff, array[0..], error.CodepointTooLarge);
	270	}
	271
	272	fn testErrorEncode(codePoint: u32, array: []u8, expectedErr: error) void {
	273	if (utf8Encode(codePoint, array)) \|_\| {
	274	unreachable;
	275	} else \|err\| {
	276	debug.assert(err == expectedErr);
	277	}
	278	}
	279
173	280	test "utf8 iterator on ascii" {
	281	comptime testUtf8IteratorOnAscii();
	282	testUtf8IteratorOnAscii();
	283	}
	284	fn testUtf8IteratorOnAscii() void {
174	285	const s = Utf8View.initComptime("abc");
175	286
176	287	var it1 = s.iterator();
...	...	@@ -187,6 +298,10 @@ test "utf8 iterator on ascii" {
187	298	}
188	299
189	300	test "utf8 view bad" {
	301	comptime testUtf8ViewBad();
	302	testUtf8ViewBad();
	303	}
	304	fn testUtf8ViewBad() void {
190	305	// Compile-time error.
191	306	// const s3 = Utf8View.initComptime("\xfe\xf2");
192	307
...	...	@@ -195,6 +310,10 @@ test "utf8 view bad" {
195	310	}
196	311
197	312	test "utf8 view ok" {
	313	comptime testUtf8ViewOk();
	314	testUtf8ViewOk();
	315	}
	316	fn testUtf8ViewOk() void {
198	317	const s = Utf8View.initComptime("東京市");
199	318
200	319	var it1 = s.iterator();
...	...	@@ -211,6 +330,10 @@ test "utf8 view ok" {
211	330	}
212	331
213	332	test "bad utf8 slice" {
	333	comptime testBadUtf8Slice();
	334	testBadUtf8Slice();
	335	}
	336	fn testBadUtf8Slice() void {
214	337	debug.assert(utf8ValidateSlice("abc"));
215	338	debug.assert(!utf8ValidateSlice("abc\xc0"));
216	339	debug.assert(!utf8ValidateSlice("abc\xc0abc"));
...	...	@@ -218,6 +341,10 @@ test "bad utf8 slice" {
218	341	}
219	342
220	343	test "valid utf8" {
	344	comptime testValidUtf8();
	345	testValidUtf8();
	346	}
	347	fn testValidUtf8() void {
221	348	testValid("\x00", 0x0);
222	349	testValid("\x20", 0x20);
223	350	testValid("\x7f", 0x7f);
...	...	@@ -233,6 +360,10 @@ test "valid utf8" {
233	360	}
234	361
235	362	test "invalid utf8 continuation bytes" {
	363	comptime testInvalidUtf8ContinuationBytes();
	364	testInvalidUtf8ContinuationBytes();
	365	}
	366	fn testInvalidUtf8ContinuationBytes() void {
236	367	// unexpected continuation
237	368	testError("\x80", error.Utf8InvalidStartByte);
238	369	testError("\xbf", error.Utf8InvalidStartByte);
...	...	@@ -261,6 +392,10 @@ test "invalid utf8 continuation bytes" {
261	392	}
262	393
263	394	test "overlong utf8 codepoint" {
	395	comptime testOverlongUtf8Codepoint();
	396	testOverlongUtf8Codepoint();
	397	}
	398	fn testOverlongUtf8Codepoint() void {
264	399	testError("\xc0\x80", error.Utf8OverlongEncoding);
265	400	testError("\xc1\xbf", error.Utf8OverlongEncoding);
266	401	testError("\xe0\x80\x80", error.Utf8OverlongEncoding);
...	...	@@ -270,6 +405,10 @@ test "overlong utf8 codepoint" {
270	405	}
271	406
272	407	test "misc invalid utf8" {
	408	comptime testMiscInvalidUtf8();
	409	testMiscInvalidUtf8();
	410	}
	411	fn testMiscInvalidUtf8() void {
273	412	// codepoint out of bounds
274	413	testError("\xf4\x90\x80\x80", error.Utf8CodepointTooLarge);
275	414	testError("\xf7\xbf\xbf\xbf", error.Utf8CodepointTooLarge);

std/zig/ast.zig+2054-525

...	...	@@ -1,647 +1,2176 @@
1	1	const std = @import("../index.zig");
2	2	const assert = std.debug.assert;
3		const ArrayList = std.ArrayList;
4		const Token = std.zig.Token;
	3	const SegmentedList = std.SegmentedList;
5	4	const mem = std.mem;
	5	const Token = std.zig.Token;
	6
	7	pub const TokenIndex = usize;
	8
	9	pub const Tree = struct {
	10	source: []const u8,
	11	tokens: TokenList,
	12	root_node: &Node.Root,
	13	arena_allocator: std.heap.ArenaAllocator,
	14	errors: ErrorList,
	15
	16	pub const TokenList = SegmentedList(Token, 64);
	17	pub const ErrorList = SegmentedList(Error, 0);
	18
	19	pub fn deinit(self: &Tree) void {
	20	self.arena_allocator.deinit();
	21	}
	22
	23	pub fn renderError(self: &Tree, parse_error: &Error, stream: var) !void {
	24	return parse_error.render(&self.tokens, stream);
	25	}
	26
	27	pub fn tokenSlice(self: &Tree, token_index: TokenIndex) []const u8 {
	28	return self.tokenSlicePtr(self.tokens.at(token_index));
	29	}
	30
	31	pub fn tokenSlicePtr(self: &Tree, token: &const Token) []const u8 {
	32	return self.source[token.start..token.end];
	33	}
	34
	35	pub const Location = struct {
	36	line: usize,
	37	column: usize,
	38	line_start: usize,
	39	line_end: usize,
	40	};
	41
	42	pub fn tokenLocationPtr(self: &Tree, start_index: usize, token: &const Token) Location {
	43	var loc = Location {
	44	.line = 0,
	45	.column = 0,
	46	.line_start = start_index,
	47	.line_end = self.source.len,
	48	};
	49	const token_start = token.start;
	50	for (self.source[start_index..]) \|c, i\| {
	51	if (i + start_index == token_start) {
	52	loc.line_end = i + start_index;
	53	while (loc.line_end < self.source.len and self.source[loc.line_end] != '\n') : (loc.line_end += 1) {}
	54	return loc;
	55	}
	56	if (c == '\n') {
	57	loc.line += 1;
	58	loc.column = 0;
	59	loc.line_start = i + 1;
	60	} else {
	61	loc.column += 1;
	62	}
	63	}
	64	return loc;
	65	}
	66
	67	pub fn tokenLocation(self: &Tree, start_index: usize, token_index: TokenIndex) Location {
	68	return self.tokenLocationPtr(start_index, self.tokens.at(token_index));
	69	}
	70	};
	71
	72	pub const Error = union(enum) {
	73	InvalidToken: InvalidToken,
	74	ExpectedVarDeclOrFn: ExpectedVarDeclOrFn,
	75	ExpectedAggregateKw: ExpectedAggregateKw,
	76	UnattachedDocComment: UnattachedDocComment,
	77	ExpectedEqOrSemi: ExpectedEqOrSemi,
	78	ExpectedSemiOrLBrace: ExpectedSemiOrLBrace,
	79	ExpectedLabelable: ExpectedLabelable,
	80	ExpectedInlinable: ExpectedInlinable,
	81	ExpectedAsmOutputReturnOrType: ExpectedAsmOutputReturnOrType,
	82	ExpectedCall: ExpectedCall,
	83	ExpectedCallOrFnProto: ExpectedCallOrFnProto,
	84	ExpectedSliceOrRBracket: ExpectedSliceOrRBracket,
	85	ExtraAlignQualifier: ExtraAlignQualifier,
	86	ExtraConstQualifier: ExtraConstQualifier,
	87	ExtraVolatileQualifier: ExtraVolatileQualifier,
	88	ExpectedPrimaryExpr: ExpectedPrimaryExpr,
	89	ExpectedToken: ExpectedToken,
	90	ExpectedCommaOrEnd: ExpectedCommaOrEnd,
	91
	92	pub fn render(self: &Error, tokens: &Tree.TokenList, stream: var) !void {
	93	switch (*self) {
	94	// TODO https://github.com/zig-lang/zig/issues/683
	95	@TagType(Error).InvalidToken => \|*x\| return x.render(tokens, stream),
	96	@TagType(Error).ExpectedVarDeclOrFn => \|*x\| return x.render(tokens, stream),
	97	@TagType(Error).ExpectedAggregateKw => \|*x\| return x.render(tokens, stream),
	98	@TagType(Error).UnattachedDocComment => \|*x\| return x.render(tokens, stream),
	99	@TagType(Error).ExpectedEqOrSemi => \|*x\| return x.render(tokens, stream),
	100	@TagType(Error).ExpectedSemiOrLBrace => \|*x\| return x.render(tokens, stream),
	101	@TagType(Error).ExpectedLabelable => \|*x\| return x.render(tokens, stream),
	102	@TagType(Error).ExpectedInlinable => \|*x\| return x.render(tokens, stream),
	103	@TagType(Error).ExpectedAsmOutputReturnOrType => \|*x\| return x.render(tokens, stream),
	104	@TagType(Error).ExpectedCall => \|*x\| return x.render(tokens, stream),
	105	@TagType(Error).ExpectedCallOrFnProto => \|*x\| return x.render(tokens, stream),
	106	@TagType(Error).ExpectedSliceOrRBracket => \|*x\| return x.render(tokens, stream),
	107	@TagType(Error).ExtraAlignQualifier => \|*x\| return x.render(tokens, stream),
	108	@TagType(Error).ExtraConstQualifier => \|*x\| return x.render(tokens, stream),
	109	@TagType(Error).ExtraVolatileQualifier => \|*x\| return x.render(tokens, stream),
	110	@TagType(Error).ExpectedPrimaryExpr => \|*x\| return x.render(tokens, stream),
	111	@TagType(Error).ExpectedToken => \|*x\| return x.render(tokens, stream),
	112	@TagType(Error).ExpectedCommaOrEnd => \|*x\| return x.render(tokens, stream),
	113	}
	114	}
	115
	116	pub fn loc(self: &Error) TokenIndex {
	117	switch (*self) {
	118	// TODO https://github.com/zig-lang/zig/issues/683
	119	@TagType(Error).InvalidToken => \|x\| return x.token,
	120	@TagType(Error).ExpectedVarDeclOrFn => \|x\| return x.token,
	121	@TagType(Error).ExpectedAggregateKw => \|x\| return x.token,
	122	@TagType(Error).UnattachedDocComment => \|x\| return x.token,
	123	@TagType(Error).ExpectedEqOrSemi => \|x\| return x.token,
	124	@TagType(Error).ExpectedSemiOrLBrace => \|x\| return x.token,
	125	@TagType(Error).ExpectedLabelable => \|x\| return x.token,
	126	@TagType(Error).ExpectedInlinable => \|x\| return x.token,
	127	@TagType(Error).ExpectedAsmOutputReturnOrType => \|x\| return x.token,
	128	@TagType(Error).ExpectedCall => \|x\| return x.node.firstToken(),
	129	@TagType(Error).ExpectedCallOrFnProto => \|x\| return x.node.firstToken(),
	130	@TagType(Error).ExpectedSliceOrRBracket => \|x\| return x.token,
	131	@TagType(Error).ExtraAlignQualifier => \|x\| return x.token,
	132	@TagType(Error).ExtraConstQualifier => \|x\| return x.token,
	133	@TagType(Error).ExtraVolatileQualifier => \|x\| return x.token,
	134	@TagType(Error).ExpectedPrimaryExpr => \|x\| return x.token,
	135	@TagType(Error).ExpectedToken => \|x\| return x.token,
	136	@TagType(Error).ExpectedCommaOrEnd => \|x\| return x.token,
	137	}
	138	}
	139
	140	pub const InvalidToken = SingleTokenError("Invalid token {}");
	141	pub const ExpectedVarDeclOrFn = SingleTokenError("Expected variable declaration or function, found {}");
	142	pub const ExpectedAggregateKw = SingleTokenError("Expected " ++
	143	@tagName(Token.Id.Keyword_struct) ++ ", " ++ @tagName(Token.Id.Keyword_union) ++ ", or " ++
	144	@tagName(Token.Id.Keyword_enum) ++ ", found {}");
	145	pub const ExpectedEqOrSemi = SingleTokenError("Expected '=' or ';', found {}");
	146	pub const ExpectedSemiOrLBrace = SingleTokenError("Expected ';' or '{{', found {}");
	147	pub const ExpectedLabelable = SingleTokenError("Expected 'while', 'for', 'inline', 'suspend', or '{{', found {}");
	148	pub const ExpectedInlinable = SingleTokenError("Expected 'while' or 'for', found {}");
	149	pub const ExpectedAsmOutputReturnOrType = SingleTokenError("Expected '->' or " ++
	150	@tagName(Token.Id.Identifier) ++ ", found {}");
	151	pub const ExpectedSliceOrRBracket = SingleTokenError("Expected ']' or '..', found {}");
	152	pub const ExpectedPrimaryExpr = SingleTokenError("Expected primary expression, found {}");
	153
	154	pub const UnattachedDocComment = SimpleError("Unattached documentation comment");
	155	pub const ExtraAlignQualifier = SimpleError("Extra align qualifier");
	156	pub const ExtraConstQualifier = SimpleError("Extra const qualifier");
	157	pub const ExtraVolatileQualifier = SimpleError("Extra volatile qualifier");
	158
	159	pub const ExpectedCall = struct {
	160	node: &Node,
	161
	162	pub fn render(self: &ExpectedCall, tokens: &Tree.TokenList, stream: var) !void {
	163	return stream.print("expected " ++ @tagName(@TagType(Node.SuffixOp.Op).Call) ++ ", found {}",
	164	@tagName(self.node.id));
	165	}
	166	};
	167
	168	pub const ExpectedCallOrFnProto = struct {
	169	node: &Node,
	170
	171	pub fn render(self: &ExpectedCallOrFnProto, tokens: &Tree.TokenList, stream: var) !void {
	172	return stream.print("expected " ++ @tagName(@TagType(Node.SuffixOp.Op).Call) ++ " or " ++
	173	@tagName(Node.Id.FnProto) ++ ", found {}", @tagName(self.node.id));
	174	}
	175	};
	176
	177	pub const ExpectedToken = struct {
	178	token: TokenIndex,
	179	expected_id: @TagType(Token.Id),
	180
	181	pub fn render(self: &ExpectedToken, tokens: &Tree.TokenList, stream: var) !void {
	182	const token_name = @tagName(tokens.at(self.token).id);
	183	return stream.print("expected {}, found {}", @tagName(self.expected_id), token_name);
	184	}
	185	};
	186
	187	pub const ExpectedCommaOrEnd = struct {
	188	token: TokenIndex,
	189	end_id: @TagType(Token.Id),
	190
	191	pub fn render(self: &ExpectedCommaOrEnd, tokens: &Tree.TokenList, stream: var) !void {
	192	const token_name = @tagName(tokens.at(self.token).id);
	193	return stream.print("expected ',' or {}, found {}", @tagName(self.end_id), token_name);
	194	}
	195	};
	196
	197	fn SingleTokenError(comptime msg: []const u8) type {
	198	return struct {
	199	const ThisError = this;
	200
	201	token: TokenIndex,
	202
	203	pub fn render(self: &ThisError, tokens: &Tree.TokenList, stream: var) !void {
	204	const token_name = @tagName(tokens.at(self.token).id);
	205	return stream.print(msg, token_name);
	206	}
	207	};
	208	}
	209
	210	fn SimpleError(comptime msg: []const u8) type {
	211	return struct {
	212	const ThisError = this;
	213
	214	token: TokenIndex,
	215
	216	pub fn render(self: &ThisError, tokens: &Tree.TokenList, stream: var) !void {
	217	return stream.write(msg);
	218	}
	219	};
	220	}
	221	};
6	222
7	223	pub const Node = struct {
8	224	id: Id,
9		comment: ?&NodeLineComment,
10	225
11	226	pub const Id = enum {
	227	// Top level
12	228	Root,
	229	Use,
	230	TestDecl,
	231
	232	// Statements
13	233	VarDecl,
14		Identifier,
15		FnProto,
16		ParamDecl,
17		Block,
	234	Defer,
	235
	236	// Operators
18	237	InfixOp,
19	238	PrefixOp,
	239	SuffixOp,
	240
	241	// Control flow
	242	Switch,
	243	While,
	244	For,
	245	If,
	246	ControlFlowExpression,
	247	Suspend,
	248
	249	// Type expressions
	250	VarType,
	251	ErrorType,
	252	FnProto,
	253	PromiseType,
	254
	255	// Primary expressions
20	256	IntegerLiteral,
21	257	FloatLiteral,
22	258	StringLiteral,
	259	MultilineStringLiteral,
	260	CharLiteral,
	261	BoolLiteral,
	262	NullLiteral,
23	263	UndefinedLiteral,
	264	ThisLiteral,
	265	Unreachable,
	266	Identifier,
	267	GroupedExpression,
24	268	BuiltinCall,
25		Call,
	269	ErrorSetDecl,
	270	ContainerDecl,
	271	Asm,
	272	Comptime,
	273	Block,
	274
	275	// Misc
26	276	LineComment,
27		TestDecl,
	277	DocComment,
	278	SwitchCase,
	279	SwitchElse,
	280	Else,
	281	Payload,
	282	PointerPayload,
	283	PointerIndexPayload,
	284	StructField,
	285	UnionTag,
	286	EnumTag,
	287	ErrorTag,
	288	AsmInput,
	289	AsmOutput,
	290	AsyncAttribute,
	291	ParamDecl,
	292	FieldInitializer,
28	293	};
29	294
30		pub fn iterate(base: &Node, index: usize) ?&Node {
31		return switch (base.id) {
32		Id.Root => @fieldParentPtr(NodeRoot, "base", base).iterate(index),
33		Id.VarDecl => @fieldParentPtr(NodeVarDecl, "base", base).iterate(index),
34		Id.Identifier => @fieldParentPtr(NodeIdentifier, "base", base).iterate(index),
35		Id.FnProto => @fieldParentPtr(NodeFnProto, "base", base).iterate(index),
36		Id.ParamDecl => @fieldParentPtr(NodeParamDecl, "base", base).iterate(index),
37		Id.Block => @fieldParentPtr(NodeBlock, "base", base).iterate(index),
38		Id.InfixOp => @fieldParentPtr(NodeInfixOp, "base", base).iterate(index),
39		Id.PrefixOp => @fieldParentPtr(NodePrefixOp, "base", base).iterate(index),
40		Id.IntegerLiteral => @fieldParentPtr(NodeIntegerLiteral, "base", base).iterate(index),
41		Id.FloatLiteral => @fieldParentPtr(NodeFloatLiteral, "base", base).iterate(index),
42		Id.StringLiteral => @fieldParentPtr(NodeStringLiteral, "base", base).iterate(index),
43		Id.UndefinedLiteral => @fieldParentPtr(NodeUndefinedLiteral, "base", base).iterate(index),
44		Id.BuiltinCall => @fieldParentPtr(NodeBuiltinCall, "base", base).iterate(index),
45		Id.Call => @fieldParentPtr(NodeCall, "base", base).iterate(index),
46		Id.LineComment => @fieldParentPtr(NodeLineComment, "base", base).iterate(index),
47		Id.TestDecl => @fieldParentPtr(NodeTestDecl, "base", base).iterate(index),
48		};
	295	pub fn cast(base: &Node, comptime T: type) ?&T {
	296	if (base.id == comptime typeToId(T)) {
	297	return @fieldParentPtr(T, "base", base);
	298	}
	299	return null;
49	300	}
50	301
51		pub fn firstToken(base: &Node) Token {
52		return switch (base.id) {
53		Id.Root => @fieldParentPtr(NodeRoot, "base", base).firstToken(),
54		Id.VarDecl => @fieldParentPtr(NodeVarDecl, "base", base).firstToken(),
55		Id.Identifier => @fieldParentPtr(NodeIdentifier, "base", base).firstToken(),
56		Id.FnProto => @fieldParentPtr(NodeFnProto, "base", base).firstToken(),
57		Id.ParamDecl => @fieldParentPtr(NodeParamDecl, "base", base).firstToken(),
58		Id.Block => @fieldParentPtr(NodeBlock, "base", base).firstToken(),
59		Id.InfixOp => @fieldParentPtr(NodeInfixOp, "base", base).firstToken(),
60		Id.PrefixOp => @fieldParentPtr(NodePrefixOp, "base", base).firstToken(),
61		Id.IntegerLiteral => @fieldParentPtr(NodeIntegerLiteral, "base", base).firstToken(),
62		Id.FloatLiteral => @fieldParentPtr(NodeFloatLiteral, "base", base).firstToken(),
63		Id.StringLiteral => @fieldParentPtr(NodeStringLiteral, "base", base).firstToken(),
64		Id.UndefinedLiteral => @fieldParentPtr(NodeUndefinedLiteral, "base", base).firstToken(),
65		Id.BuiltinCall => @fieldParentPtr(NodeBuiltinCall, "base", base).firstToken(),
66		Id.Call => @fieldParentPtr(NodeCall, "base", base).firstToken(),
67		Id.LineComment => @fieldParentPtr(NodeLineComment, "base", base).firstToken(),
68		Id.TestDecl => @fieldParentPtr(NodeTestDecl, "base", base).firstToken(),
69		};
	302	pub fn iterate(base: &Node, index: usize) ?&Node {
	303	comptime var i = 0;
	304	inline while (i < @memberCount(Id)) : (i += 1) {
	305	if (base.id == @field(Id, @memberName(Id, i))) {
	306	const T = @field(Node, @memberName(Id, i));
	307	return @fieldParentPtr(T, "base", base).iterate(index);
	308	}
	309	}
	310	unreachable;
70	311	}
71	312
72		pub fn lastToken(base: &Node) Token {
73		return switch (base.id) {
74		Id.Root => @fieldParentPtr(NodeRoot, "base", base).lastToken(),
75		Id.VarDecl => @fieldParentPtr(NodeVarDecl, "base", base).lastToken(),
76		Id.Identifier => @fieldParentPtr(NodeIdentifier, "base", base).lastToken(),
77		Id.FnProto => @fieldParentPtr(NodeFnProto, "base", base).lastToken(),
78		Id.ParamDecl => @fieldParentPtr(NodeParamDecl, "base", base).lastToken(),
79		Id.Block => @fieldParentPtr(NodeBlock, "base", base).lastToken(),
80		Id.InfixOp => @fieldParentPtr(NodeInfixOp, "base", base).lastToken(),
81		Id.PrefixOp => @fieldParentPtr(NodePrefixOp, "base", base).lastToken(),
82		Id.IntegerLiteral => @fieldParentPtr(NodeIntegerLiteral, "base", base).lastToken(),
83		Id.FloatLiteral => @fieldParentPtr(NodeFloatLiteral, "base", base).lastToken(),
84		Id.StringLiteral => @fieldParentPtr(NodeStringLiteral, "base", base).lastToken(),
85		Id.UndefinedLiteral => @fieldParentPtr(NodeUndefinedLiteral, "base", base).lastToken(),
86		Id.BuiltinCall => @fieldParentPtr(NodeBuiltinCall, "base", base).lastToken(),
87		Id.Call => @fieldParentPtr(NodeCall, "base", base).lastToken(),
88		Id.LineComment => @fieldParentPtr(NodeLineComment, "base", base).lastToken(),
89		Id.TestDecl => @fieldParentPtr(NodeTestDecl, "base", base).lastToken(),
90		};
	313	pub fn firstToken(base: &Node) TokenIndex {
	314	comptime var i = 0;
	315	inline while (i < @memberCount(Id)) : (i += 1) {
	316	if (base.id == @field(Id, @memberName(Id, i))) {
	317	const T = @field(Node, @memberName(Id, i));
	318	return @fieldParentPtr(T, "base", base).firstToken();
	319	}
	320	}
	321	unreachable;
91	322	}
92		};
93	323
94		pub const NodeRoot = struct {
95		base: Node,
96		decls: ArrayList(&Node),
97		eof_token: Token,
98
99		pub fn iterate(self: &NodeRoot, index: usize) ?&Node {
100		if (index < self.decls.len) {
101		return self.decls.items[self.decls.len - index - 1];
	324	pub fn lastToken(base: &Node) TokenIndex {
	325	comptime var i = 0;
	326	inline while (i < @memberCount(Id)) : (i += 1) {
	327	if (base.id == @field(Id, @memberName(Id, i))) {
	328	const T = @field(Node, @memberName(Id, i));
	329	return @fieldParentPtr(T, "base", base).lastToken();
	330	}
102	331	}
103		return null;
	332	unreachable;
104	333	}
105	334
106		pub fn firstToken(self: &NodeRoot) Token {
107		return if (self.decls.len == 0) self.eof_token else self.decls.at(0).firstToken();
	335	pub fn typeToId(comptime T: type) Id {
	336	comptime var i = 0;
	337	inline while (i < @memberCount(Id)) : (i += 1) {
	338	if (T == @field(Node, @memberName(Id, i))) {
	339	return @field(Id, @memberName(Id, i));
	340	}
	341	}
	342	unreachable;
108	343	}
109	344
110		pub fn lastToken(self: &NodeRoot) Token {
111		return if (self.decls.len == 0) self.eof_token else self.decls.at(self.decls.len - 1).lastToken();
	345	pub fn requireSemiColon(base: &const Node) bool {
	346	var n = base;
	347	while (true) {
	348	switch (n.id) {
	349	Id.Root,
	350	Id.StructField,
	351	Id.UnionTag,
	352	Id.EnumTag,
	353	Id.ParamDecl,
	354	Id.Block,
	355	Id.Payload,
	356	Id.PointerPayload,
	357	Id.PointerIndexPayload,
	358	Id.Switch,
	359	Id.SwitchCase,
	360	Id.SwitchElse,
	361	Id.FieldInitializer,
	362	Id.DocComment,
	363	Id.LineComment,
	364	Id.TestDecl => return false,
	365	Id.While => {
	366	const while_node = @fieldParentPtr(While, "base", n);
	367	if (while_node.@"else") \|@"else"\| {
	368	n = @"else".base;
	369	continue;
	370	}
	371
	372	return while_node.body.id != Id.Block;
	373	},
	374	Id.For => {
	375	const for_node = @fieldParentPtr(For, "base", n);
	376	if (for_node.@"else") \|@"else"\| {
	377	n = @"else".base;
	378	continue;
	379	}
	380
	381	return for_node.body.id != Id.Block;
	382	},
	383	Id.If => {
	384	const if_node = @fieldParentPtr(If, "base", n);
	385	if (if_node.@"else") \|@"else"\| {
	386	n = @"else".base;
	387	continue;
	388	}
	389
	390	return if_node.body.id != Id.Block;
	391	},
	392	Id.Else => {
	393	const else_node = @fieldParentPtr(Else, "base", n);
	394	n = else_node.body;
	395	continue;
	396	},
	397	Id.Defer => {
	398	const defer_node = @fieldParentPtr(Defer, "base", n);
	399	return defer_node.expr.id != Id.Block;
	400	},
	401	Id.Comptime => {
	402	const comptime_node = @fieldParentPtr(Comptime, "base", n);
	403	return comptime_node.expr.id != Id.Block;
	404	},
	405	Id.Suspend => {
	406	const suspend_node = @fieldParentPtr(Suspend, "base", n);
	407	if (suspend_node.body) \|body\| {
	408	return body.id != Id.Block;
	409	}
	410
	411	return true;
	412	},
	413	else => return true,
	414	}
	415	}
112	416	}
113		};
114	417
115		pub const NodeVarDecl = struct {
116		base: Node,
117		visib_token: ?Token,
118		name_token: Token,
119		eq_token: Token,
120		mut_token: Token,
121		comptime_token: ?Token,
122		extern_token: ?Token,
123		lib_name: ?&Node,
124		type_node: ?&Node,
125		align_node: ?&Node,
126		init_node: ?&Node,
127		semicolon_token: Token,
128
129		pub fn iterate(self: &NodeVarDecl, index: usize) ?&Node {
130		var i = index;
131
132		if (self.type_node) \|type_node\| {
133		if (i < 1) return type_node;
134		i -= 1;
	418
	419	pub const Root = struct {
	420	base: Node,
	421	doc_comments: ?&DocComment,
	422	decls: DeclList,
	423	eof_token: TokenIndex,
	424
	425	pub const DeclList = SegmentedList(&Node, 4);
	426
	427	pub fn iterate(self: &Root, index: usize) ?&Node {
	428	if (index < self.decls.len) {
	429	return self.decls.items[self.decls.len - index - 1];
	430	}
	431	return null;
135	432	}
136	433
137		if (self.align_node) \|align_node\| {
138		if (i < 1) return align_node;
139		i -= 1;
	434	pub fn firstToken(self: &Root) TokenIndex {
	435	return if (self.decls.len == 0) self.eof_token else (*self.decls.at(0)).firstToken();
140	436	}
141	437
142		if (self.init_node) \|init_node\| {
143		if (i < 1) return init_node;
144		i -= 1;
	438	pub fn lastToken(self: &Root) TokenIndex {
	439	return if (self.decls.len == 0) self.eof_token else (*self.decls.at(self.decls.len - 1)).lastToken();
145	440	}
	441	};
146	442
147		return null;
148		}
	443	pub const VarDecl = struct {
	444	base: Node,
	445	doc_comments: ?&DocComment,
	446	visib_token: ?TokenIndex,
	447	name_token: TokenIndex,
	448	eq_token: TokenIndex,
	449	mut_token: TokenIndex,
	450	comptime_token: ?TokenIndex,
	451	extern_export_token: ?TokenIndex,
	452	lib_name: ?&Node,
	453	type_node: ?&Node,
	454	align_node: ?&Node,
	455	init_node: ?&Node,
	456	semicolon_token: TokenIndex,
	457
	458	pub fn iterate(self: &VarDecl, index: usize) ?&Node {
	459	var i = index;
	460
	461	if (self.type_node) \|type_node\| {
	462	if (i < 1) return type_node;
	463	i -= 1;
	464	}
149	465
150		pub fn firstToken(self: &NodeVarDecl) Token {
151		if (self.visib_token) \|visib_token\| return visib_token;
152		if (self.comptime_token) \|comptime_token\| return comptime_token;
153		if (self.extern_token) \|extern_token\| return extern_token;
154		assert(self.lib_name == null);
155		return self.mut_token;
156		}
	466	if (self.align_node) \|align_node\| {
	467	if (i < 1) return align_node;
	468	i -= 1;
	469	}
157	470
158		pub fn lastToken(self: &NodeVarDecl) Token {
159		return self.semicolon_token;
160		}
161		};
	471	if (self.init_node) \|init_node\| {
	472	if (i < 1) return init_node;
	473	i -= 1;
	474	}
162	475
163		pub const NodeIdentifier = struct {
164		base: Node,
165		name_token: Token,
	476	return null;
	477	}
166	478
167		pub fn iterate(self: &NodeIdentifier, index: usize) ?&Node {
168		return null;
169		}
	479	pub fn firstToken(self: &VarDecl) TokenIndex {
	480	if (self.visib_token) \|visib_token\| return visib_token;
	481	if (self.comptime_token) \|comptime_token\| return comptime_token;
	482	if (self.extern_export_token) \|extern_export_token\| return extern_export_token;
	483	assert(self.lib_name == null);
	484	return self.mut_token;
	485	}
170	486
171		pub fn firstToken(self: &NodeIdentifier) Token {
172		return self.name_token;
173		}
	487	pub fn lastToken(self: &VarDecl) TokenIndex {
	488	return self.semicolon_token;
	489	}
	490	};
174	491
175		pub fn lastToken(self: &NodeIdentifier) Token {
176		return self.name_token;
177		}
178		};
	492	pub const Use = struct {
	493	base: Node,
	494	doc_comments: ?&DocComment,
	495	visib_token: ?TokenIndex,
	496	expr: &Node,
	497	semicolon_token: TokenIndex,
	498
	499	pub fn iterate(self: &Use, index: usize) ?&Node {
	500	var i = index;
179	501
180		pub const NodeFnProto = struct {
181		base: Node,
182		visib_token: ?Token,
183		fn_token: Token,
184		name_token: ?Token,
185		params: ArrayList(&Node),
186		return_type: ReturnType,
187		var_args_token: ?Token,
188		extern_token: ?Token,
189		inline_token: ?Token,
190		cc_token: ?Token,
191		body_node: ?&Node,
192		lib_name: ?&Node, // populated if this is an extern declaration
193		align_expr: ?&Node, // populated if align(A) is present
194
195		pub const ReturnType = union(enum) {
196		Explicit: &Node,
197		Infer: Token,
198		InferErrorSet: &Node,
199		};
200
201		pub fn iterate(self: &NodeFnProto, index: usize) ?&Node {
202		var i = index;
203
204		if (self.body_node) \|body_node\| {
205		if (i < 1) return body_node;
	502	if (i < 1) return self.expr;
206	503	i -= 1;
	504
	505	return null;
207	506	}
208	507
209		switch (self.return_type) {
210		// TODO allow this and next prong to share bodies since the types are the same
211		ReturnType.Explicit => \|node\| {
212		if (i < 1) return node;
213		i -= 1;
214		},
215		ReturnType.InferErrorSet => \|node\| {
216		if (i < 1) return node;
217		i -= 1;
218		},
219		ReturnType.Infer => {},
	508	pub fn firstToken(self: &Use) TokenIndex {
	509	if (self.visib_token) \|visib_token\| return visib_token;
	510	return self.expr.firstToken();
220	511	}
221	512
222		if (self.align_expr) \|align_expr\| {
223		if (i < 1) return align_expr;
224		i -= 1;
	513	pub fn lastToken(self: &Use) TokenIndex {
	514	return self.semicolon_token;
225	515	}
	516	};
226	517
227		if (i < self.params.len) return self.params.items[self.params.len - i - 1];
228		i -= self.params.len;
	518	pub const ErrorSetDecl = struct {
	519	base: Node,
	520	error_token: TokenIndex,
	521	decls: DeclList,
	522	rbrace_token: TokenIndex,
229	523
230		if (self.lib_name) \|lib_name\| {
231		if (i < 1) return lib_name;
232		i -= 1;
	524	pub const DeclList = SegmentedList(&Node, 2);
	525
	526	pub fn iterate(self: &ErrorSetDecl, index: usize) ?&Node {
	527	var i = index;
	528
	529	if (i < self.decls.len) return *self.decls.at(i);
	530	i -= self.decls.len;
	531
	532	return null;
233	533	}
234	534
235		return null;
236		}
	535	pub fn firstToken(self: &ErrorSetDecl) TokenIndex {
	536	return self.error_token;
	537	}
237	538
238		pub fn firstToken(self: &NodeFnProto) Token {
239		if (self.visib_token) \|visib_token\| return visib_token;
240		if (self.extern_token) \|extern_token\| return extern_token;
241		assert(self.lib_name == null);
242		if (self.inline_token) \|inline_token\| return inline_token;
243		if (self.cc_token) \|cc_token\| return cc_token;
244		return self.fn_token;
245		}
	539	pub fn lastToken(self: &ErrorSetDecl) TokenIndex {
	540	return self.rbrace_token;
	541	}
	542	};
	543
	544	pub const ContainerDecl = struct {
	545	base: Node,
	546	ltoken: TokenIndex,
	547	layout: Layout,
	548	kind: Kind,
	549	init_arg_expr: InitArg,
	550	fields_and_decls: DeclList,
	551	rbrace_token: TokenIndex,
	552
	553	pub const DeclList = Root.DeclList;
	554
	555	const Layout = enum {
	556	Auto,
	557	Extern,
	558	Packed,
	559	};
	560
	561	const Kind = enum {
	562	Struct,
	563	Enum,
	564	Union,
	565	};
	566
	567	const InitArg = union(enum) {
	568	None,
	569	Enum: ?&Node,
	570	Type: &Node,
	571	};
	572
	573	pub fn iterate(self: &ContainerDecl, index: usize) ?&Node {
	574	var i = index;
	575
	576	switch (self.init_arg_expr) {
	577	InitArg.Type => \|t\| {
	578	if (i < 1) return t;
	579	i -= 1;
	580	},
	581	InitArg.None,
	582	InitArg.Enum => { }
	583	}
246	584
247		pub fn lastToken(self: &NodeFnProto) Token {
248		if (self.body_node) \|body_node\| return body_node.lastToken();
249		switch (self.return_type) {
250		// TODO allow this and next prong to share bodies since the types are the same
251		ReturnType.Explicit => \|node\| return node.lastToken(),
252		ReturnType.InferErrorSet => \|node\| return node.lastToken(),
253		ReturnType.Infer => \|token\| return token,
	585	if (i < self.fields_and_decls.len) return *self.fields_and_decls.at(i);
	586	i -= self.fields_and_decls.len;
	587
	588	return null;
254	589	}
255		}
256		};
257	590
258		pub const NodeParamDecl = struct {
259		base: Node,
260		comptime_token: ?Token,
261		noalias_token: ?Token,
262		name_token: ?Token,
263		type_node: &Node,
264		var_args_token: ?Token,
	591	pub fn firstToken(self: &ContainerDecl) TokenIndex {
	592	return self.ltoken;
	593	}
265	594
266		pub fn iterate(self: &NodeParamDecl, index: usize) ?&Node {
267		var i = index;
	595	pub fn lastToken(self: &ContainerDecl) TokenIndex {
	596	return self.rbrace_token;
	597	}
	598	};
268	599
269		if (i < 1) return self.type_node;
270		i -= 1;
	600	pub const StructField = struct {
	601	base: Node,
	602	doc_comments: ?&DocComment,
	603	visib_token: ?TokenIndex,
	604	name_token: TokenIndex,
	605	type_expr: &Node,
271	606
272		return null;
273		}
	607	pub fn iterate(self: &StructField, index: usize) ?&Node {
	608	var i = index;
274	609
275		pub fn firstToken(self: &NodeParamDecl) Token {
276		if (self.comptime_token) \|comptime_token\| return comptime_token;
277		if (self.noalias_token) \|noalias_token\| return noalias_token;
278		if (self.name_token) \|name_token\| return name_token;
279		return self.type_node.firstToken();
280		}
	610	if (i < 1) return self.type_expr;
	611	i -= 1;
281	612
282		pub fn lastToken(self: &NodeParamDecl) Token {
283		if (self.var_args_token) \|var_args_token\| return var_args_token;
284		return self.type_node.lastToken();
285		}
286		};
	613	return null;
	614	}
287	615
288		pub const NodeBlock = struct {
289		base: Node,
290		begin_token: Token,
291		end_token: Token,
292		statements: ArrayList(&Node),
	616	pub fn firstToken(self: &StructField) TokenIndex {
	617	if (self.visib_token) \|visib_token\| return visib_token;
	618	return self.name_token;
	619	}
293	620
294		pub fn iterate(self: &NodeBlock, index: usize) ?&Node {
295		var i = index;
	621	pub fn lastToken(self: &StructField) TokenIndex {
	622	return self.type_expr.lastToken();
	623	}
	624	};
296	625
297		if (i < self.statements.len) return self.statements.items[i];
298		i -= self.statements.len;
	626	pub const UnionTag = struct {
	627	base: Node,
	628	doc_comments: ?&DocComment,
	629	name_token: TokenIndex,
	630	type_expr: ?&Node,
	631	value_expr: ?&Node,
299	632
300		return null;
301		}
	633	pub fn iterate(self: &UnionTag, index: usize) ?&Node {
	634	var i = index;
302	635
303		pub fn firstToken(self: &NodeBlock) Token {
304		return self.begin_token;
305		}
	636	if (self.type_expr) \|type_expr\| {
	637	if (i < 1) return type_expr;
	638	i -= 1;
	639	}
306	640
307		pub fn lastToken(self: &NodeBlock) Token {
308		return self.end_token;
309		}
310		};
	641	if (self.value_expr) \|value_expr\| {
	642	if (i < 1) return value_expr;
	643	i -= 1;
	644	}
311	645
312		pub const NodeInfixOp = struct {
313		base: Node,
314		op_token: Token,
315		lhs: &Node,
316		op: InfixOp,
317		rhs: &Node,
318
319		const InfixOp = enum {
320		Add,
321		AddWrap,
322		ArrayCat,
323		ArrayMult,
324		Assign,
325		AssignBitAnd,
326		AssignBitOr,
327		AssignBitShiftLeft,
328		AssignBitShiftRight,
329		AssignBitXor,
330		AssignDiv,
331		AssignMinus,
332		AssignMinusWrap,
333		AssignMod,
334		AssignPlus,
335		AssignPlusWrap,
336		AssignTimes,
337		AssignTimesWarp,
338		BangEqual,
339		BitAnd,
340		BitOr,
341		BitShiftLeft,
342		BitShiftRight,
343		BitXor,
344		BoolAnd,
345		BoolOr,
346		Div,
347		EqualEqual,
348		ErrorUnion,
349		GreaterOrEqual,
350		GreaterThan,
351		LessOrEqual,
352		LessThan,
353		MergeErrorSets,
354		Mod,
355		Mult,
356		MultWrap,
357		Period,
358		Sub,
359		SubWrap,
360		UnwrapMaybe,
361		};
362
363		pub fn iterate(self: &NodeInfixOp, index: usize) ?&Node {
364		var i = index;
365
366		if (i < 1) return self.lhs;
367		i -= 1;
368
369		switch (self.op) {
370		InfixOp.Add,
371		InfixOp.AddWrap,
372		InfixOp.ArrayCat,
373		InfixOp.ArrayMult,
374		InfixOp.Assign,
375		InfixOp.AssignBitAnd,
376		InfixOp.AssignBitOr,
377		InfixOp.AssignBitShiftLeft,
378		InfixOp.AssignBitShiftRight,
379		InfixOp.AssignBitXor,
380		InfixOp.AssignDiv,
381		InfixOp.AssignMinus,
382		InfixOp.AssignMinusWrap,
383		InfixOp.AssignMod,
384		InfixOp.AssignPlus,
385		InfixOp.AssignPlusWrap,
386		InfixOp.AssignTimes,
387		InfixOp.AssignTimesWarp,
388		InfixOp.BangEqual,
389		InfixOp.BitAnd,
390		InfixOp.BitOr,
391		InfixOp.BitShiftLeft,
392		InfixOp.BitShiftRight,
393		InfixOp.BitXor,
394		InfixOp.BoolAnd,
395		InfixOp.BoolOr,
396		InfixOp.Div,
397		InfixOp.EqualEqual,
398		InfixOp.ErrorUnion,
399		InfixOp.GreaterOrEqual,
400		InfixOp.GreaterThan,
401		InfixOp.LessOrEqual,
402		InfixOp.LessThan,
403		InfixOp.MergeErrorSets,
404		InfixOp.Mod,
405		InfixOp.Mult,
406		InfixOp.MultWrap,
407		InfixOp.Period,
408		InfixOp.Sub,
409		InfixOp.SubWrap,
410		InfixOp.UnwrapMaybe => {},
411		}
412
413		if (i < 1) return self.rhs;
414		i -= 1;
	646	return null;
	647	}
415	648
416		return null;
417		}
	649	pub fn firstToken(self: &UnionTag) TokenIndex {
	650	return self.name_token;
	651	}
418	652
419		pub fn firstToken(self: &NodeInfixOp) Token {
420		return self.lhs.firstToken();
421		}
	653	pub fn lastToken(self: &UnionTag) TokenIndex {
	654	if (self.value_expr) \|value_expr\| {
	655	return value_expr.lastToken();
	656	}
	657	if (self.type_expr) \|type_expr\| {
	658	return type_expr.lastToken();
	659	}
422	660
423		pub fn lastToken(self: &NodeInfixOp) Token {
424		return self.rhs.lastToken();
425		}
426		};
	661	return self.name_token;
	662	}
	663	};
427	664
428		pub const NodePrefixOp = struct {
429		base: Node,
430		op_token: Token,
431		op: PrefixOp,
432		rhs: &Node,
433
434		const PrefixOp = union(enum) {
435		AddrOf: AddrOfInfo,
436		BitNot,
437		BoolNot,
438		Deref,
439		Negation,
440		NegationWrap,
441		Return,
442		Try,
443		UnwrapMaybe,
444		};
445		const AddrOfInfo = struct {
446		align_expr: ?&Node,
447		bit_offset_start_token: ?Token,
448		bit_offset_end_token: ?Token,
449		const_token: ?Token,
450		volatile_token: ?Token,
451		};
452
453		pub fn iterate(self: &NodePrefixOp, index: usize) ?&Node {
454		var i = index;
455
456		switch (self.op) {
457		PrefixOp.AddrOf => \|addr_of_info\| {
458		if (addr_of_info.align_expr) \|align_expr\| {
459		if (i < 1) return align_expr;
460		i -= 1;
461		}
462		},
463		PrefixOp.BitNot,
464		PrefixOp.BoolNot,
465		PrefixOp.Deref,
466		PrefixOp.Negation,
467		PrefixOp.NegationWrap,
468		PrefixOp.Return,
469		PrefixOp.Try,
470		PrefixOp.UnwrapMaybe => {},
	665	pub const EnumTag = struct {
	666	base: Node,
	667	doc_comments: ?&DocComment,
	668	name_token: TokenIndex,
	669	value: ?&Node,
	670
	671	pub fn iterate(self: &EnumTag, index: usize) ?&Node {
	672	var i = index;
	673
	674	if (self.value) \|value\| {
	675	if (i < 1) return value;
	676	i -= 1;
	677	}
	678
	679	return null;
471	680	}
472	681
473		if (i < 1) return self.rhs;
474		i -= 1;
	682	pub fn firstToken(self: &EnumTag) TokenIndex {
	683	return self.name_token;
	684	}
475	685
476		return null;
477		}
	686	pub fn lastToken(self: &EnumTag) TokenIndex {
	687	if (self.value) \|value\| {
	688	return value.lastToken();
	689	}
478	690
479		pub fn firstToken(self: &NodePrefixOp) Token {
480		return self.op_token;
481		}
	691	return self.name_token;
	692	}
	693	};
482	694
483		pub fn lastToken(self: &NodePrefixOp) Token {
484		return self.rhs.lastToken();
485		}
486		};
	695	pub const ErrorTag = struct {
	696	base: Node,
	697	doc_comments: ?&DocComment,
	698	name_token: TokenIndex,
487	699
488		pub const NodeIntegerLiteral = struct {
489		base: Node,
490		token: Token,
	700	pub fn iterate(self: &ErrorTag, index: usize) ?&Node {
	701	var i = index;
491	702
492		pub fn iterate(self: &NodeIntegerLiteral, index: usize) ?&Node {
493		return null;
494		}
	703	if (self.doc_comments) \|comments\| {
	704	if (i < 1) return &comments.base;
	705	i -= 1;
	706	}
495	707
496		pub fn firstToken(self: &NodeIntegerLiteral) Token {
497		return self.token;
498		}
	708	return null;
	709	}
499	710
500		pub fn lastToken(self: &NodeIntegerLiteral) Token {
501		return self.token;
502		}
503		};
	711	pub fn firstToken(self: &ErrorTag) TokenIndex {
	712	return self.name_token;
	713	}
504	714
505		pub const NodeFloatLiteral = struct {
506		base: Node,
507		token: Token,
	715	pub fn lastToken(self: &ErrorTag) TokenIndex {
	716	return self.name_token;
	717	}
	718	};
508	719
509		pub fn iterate(self: &NodeFloatLiteral, index: usize) ?&Node {
510		return null;
511		}
	720	pub const Identifier = struct {
	721	base: Node,
	722	token: TokenIndex,
512	723
513		pub fn firstToken(self: &NodeFloatLiteral) Token {
514		return self.token;
515		}
	724	pub fn iterate(self: &Identifier, index: usize) ?&Node {
	725	return null;
	726	}
516	727
517		pub fn lastToken(self: &NodeFloatLiteral) Token {
518		return self.token;
519		}
520		};
	728	pub fn firstToken(self: &Identifier) TokenIndex {
	729	return self.token;
	730	}
521	731
522		pub const NodeBuiltinCall = struct {
523		base: Node,
524		builtin_token: Token,
525		params: ArrayList(&Node),
526		rparen_token: Token,
	732	pub fn lastToken(self: &Identifier) TokenIndex {
	733	return self.token;
	734	}
	735	};
527	736
528		pub fn iterate(self: &NodeBuiltinCall, index: usize) ?&Node {
529		var i = index;
	737	pub const AsyncAttribute = struct {
	738	base: Node,
	739	async_token: TokenIndex,
	740	allocator_type: ?&Node,
	741	rangle_bracket: ?TokenIndex,
530	742
531		if (i < self.params.len) return self.params.at(i);
532		i -= self.params.len;
	743	pub fn iterate(self: &AsyncAttribute, index: usize) ?&Node {
	744	var i = index;
533	745
534		return null;
535		}
	746	if (self.allocator_type) \|allocator_type\| {
	747	if (i < 1) return allocator_type;
	748	i -= 1;
	749	}
536	750
537		pub fn firstToken(self: &NodeBuiltinCall) Token {
538		return self.builtin_token;
539		}
	751	return null;
	752	}
540	753
541		pub fn lastToken(self: &NodeBuiltinCall) Token {
542		return self.rparen_token;
543		}
544		};
	754	pub fn firstToken(self: &AsyncAttribute) TokenIndex {
	755	return self.async_token;
	756	}
545	757
546		pub const NodeCall = struct {
547		base: Node,
548		callee: &Node,
549		params: ArrayList(&Node),
550		rparen_token: Token,
	758	pub fn lastToken(self: &AsyncAttribute) TokenIndex {
	759	if (self.rangle_bracket) \|rangle_bracket\| {
	760	return rangle_bracket;
	761	}
551	762
552		pub fn iterate(self: &NodeCall, index: usize) ?&Node {
553		var i = index;
	763	return self.async_token;
	764	}
	765	};
554	766
555		if (i < 1) return self.callee;
556		i -= 1;
	767	pub const FnProto = struct {
	768	base: Node,
	769	doc_comments: ?&DocComment,
	770	visib_token: ?TokenIndex,
	771	fn_token: TokenIndex,
	772	name_token: ?TokenIndex,
	773	params: ParamList,
	774	return_type: ReturnType,
	775	var_args_token: ?TokenIndex,
	776	extern_export_inline_token: ?TokenIndex,
	777	cc_token: ?TokenIndex,
	778	async_attr: ?&AsyncAttribute,
	779	body_node: ?&Node,
	780	lib_name: ?&Node, // populated if this is an extern declaration
	781	align_expr: ?&Node, // populated if align(A) is present
	782
	783	pub const ParamList = SegmentedList(&Node, 2);
	784
	785	pub const ReturnType = union(enum) {
	786	Explicit: &Node,
	787	InferErrorSet: &Node,
	788	};
557	789
558		if (i < self.params.len) return self.params.at(i);
559		i -= self.params.len;
	790	pub fn iterate(self: &FnProto, index: usize) ?&Node {
	791	var i = index;
560	792
561		return null;
562		}
	793	if (self.body_node) \|body_node\| {
	794	if (i < 1) return body_node;
	795	i -= 1;
	796	}
563	797
564		pub fn firstToken(self: &NodeCall) Token {
565		return self.callee.firstToken();
566		}
	798	switch (self.return_type) {
	799	// TODO allow this and next prong to share bodies since the types are the same
	800	ReturnType.Explicit => \|node\| {
	801	if (i < 1) return node;
	802	i -= 1;
	803	},
	804	ReturnType.InferErrorSet => \|node\| {
	805	if (i < 1) return node;
	806	i -= 1;
	807	},
	808	}
567	809
568		pub fn lastToken(self: &NodeCall) Token {
569		return self.rparen_token;
570		}
571		};
	810	if (self.align_expr) \|align_expr\| {
	811	if (i < 1) return align_expr;
	812	i -= 1;
	813	}
572	814
573		pub const NodeStringLiteral = struct {
574		base: Node,
575		token: Token,
	815	if (i < self.params.len) return self.params.items[self.params.len - i - 1];
	816	i -= self.params.len;
576	817
577		pub fn iterate(self: &NodeStringLiteral, index: usize) ?&Node {
578		return null;
579		}
	818	if (self.lib_name) \|lib_name\| {
	819	if (i < 1) return lib_name;
	820	i -= 1;
	821	}
580	822
581		pub fn firstToken(self: &NodeStringLiteral) Token {
582		return self.token;
583		}
	823	return null;
	824	}
584	825
585		pub fn lastToken(self: &NodeStringLiteral) Token {
586		return self.token;
587		}
588		};
	826	pub fn firstToken(self: &FnProto) TokenIndex {
	827	if (self.visib_token) \|visib_token\| return visib_token;
	828	if (self.extern_export_inline_token) \|extern_export_inline_token\| return extern_export_inline_token;
	829	assert(self.lib_name == null);
	830	if (self.cc_token) \|cc_token\| return cc_token;
	831	return self.fn_token;
	832	}
589	833
590		pub const NodeUndefinedLiteral = struct {
591		base: Node,
592		token: Token,
	834	pub fn lastToken(self: &FnProto) TokenIndex {
	835	if (self.body_node) \|body_node\| return body_node.lastToken();
	836	switch (self.return_type) {
	837	// TODO allow this and next prong to share bodies since the types are the same
	838	ReturnType.Explicit => \|node\| return node.lastToken(),
	839	ReturnType.InferErrorSet => \|node\| return node.lastToken(),
	840	}
	841	}
	842	};
593	843
594		pub fn iterate(self: &NodeUndefinedLiteral, index: usize) ?&Node {
595		return null;
596		}
	844	pub const PromiseType = struct {
	845	base: Node,
	846	promise_token: TokenIndex,
	847	result: ?Result,
597	848
598		pub fn firstToken(self: &NodeUndefinedLiteral) Token {
599		return self.token;
600		}
	849	pub const Result = struct {
	850	arrow_token: TokenIndex,
	851	return_type: &Node,
	852	};
601	853
602		pub fn lastToken(self: &NodeUndefinedLiteral) Token {
603		return self.token;
604		}
605		};
	854	pub fn iterate(self: &PromiseType, index: usize) ?&Node {
	855	var i = index;
606	856
607		pub const NodeLineComment = struct {
608		base: Node,
609		lines: ArrayList(Token),
	857	if (self.result) \|result\| {
	858	if (i < 1) return result.return_type;
	859	i -= 1;
	860	}
610	861
611		pub fn iterate(self: &NodeLineComment, index: usize) ?&Node {
612		return null;
613		}
	862	return null;
	863	}
614	864
615		pub fn firstToken(self: &NodeLineComment) Token {
616		return self.lines.at(0);
617		}
	865	pub fn firstToken(self: &PromiseType) TokenIndex {
	866	return self.promise_token;
	867	}
618	868
619		pub fn lastToken(self: &NodeLineComment) Token {
620		return self.lines.at(self.lines.len - 1);
621		}
622		};
	869	pub fn lastToken(self: &PromiseType) TokenIndex {
	870	if (self.result) \|result\| return result.return_type.lastToken();
	871	return self.promise_token;
	872	}
	873	};
623	874
624		pub const NodeTestDecl = struct {
625		base: Node,
626		test_token: Token,
627		name_token: Token,
628		body_node: &Node,
	875	pub const ParamDecl = struct {
	876	base: Node,
	877	comptime_token: ?TokenIndex,
	878	noalias_token: ?TokenIndex,
	879	name_token: ?TokenIndex,
	880	type_node: &Node,
	881	var_args_token: ?TokenIndex,
629	882
630		pub fn iterate(self: &NodeTestDecl, index: usize) ?&Node {
631		var i = index;
	883	pub fn iterate(self: &ParamDecl, index: usize) ?&Node {
	884	var i = index;
632	885
633		if (i < 1) return self.body_node;
634		i -= 1;
	886	if (i < 1) return self.type_node;
	887	i -= 1;
635	888
636		return null;
637		}
	889	return null;
	890	}
638	891
639		pub fn firstToken(self: &NodeTestDecl) Token {
640		return self.test_token;
641		}
	892	pub fn firstToken(self: &ParamDecl) TokenIndex {
	893	if (self.comptime_token) \|comptime_token\| return comptime_token;
	894	if (self.noalias_token) \|noalias_token\| return noalias_token;
	895	if (self.name_token) \|name_token\| return name_token;
	896	return self.type_node.firstToken();
	897	}
642	898
643		pub fn lastToken(self: &NodeTestDecl) Token {
644		return self.body_node.lastToken();
645		}
	899	pub fn lastToken(self: &ParamDecl) TokenIndex {
	900	if (self.var_args_token) \|var_args_token\| return var_args_token;
	901	return self.type_node.lastToken();
	902	}
	903	};
	904
	905	pub const Block = struct {
	906	base: Node,
	907	label: ?TokenIndex,
	908	lbrace: TokenIndex,
	909	statements: StatementList,
	910	rbrace: TokenIndex,
	911
	912	pub const StatementList = Root.DeclList;
	913
	914	pub fn iterate(self: &Block, index: usize) ?&Node {
	915	var i = index;
	916
	917	if (i < self.statements.len) return self.statements.items[i];
	918	i -= self.statements.len;
	919
	920	return null;
	921	}
	922
	923	pub fn firstToken(self: &Block) TokenIndex {
	924	if (self.label) \|label\| {
	925	return label;
	926	}
	927
	928	return self.lbrace;
	929	}
	930
	931	pub fn lastToken(self: &Block) TokenIndex {
	932	return self.rbrace;
	933	}
	934	};
	935
	936	pub const Defer = struct {
	937	base: Node,
	938	defer_token: TokenIndex,
	939	kind: Kind,
	940	expr: &Node,
	941
	942	const Kind = enum {
	943	Error,
	944	Unconditional,
	945	};
	946
	947	pub fn iterate(self: &Defer, index: usize) ?&Node {
	948	var i = index;
	949
	950	if (i < 1) return self.expr;
	951	i -= 1;
	952
	953	return null;
	954	}
	955
	956	pub fn firstToken(self: &Defer) TokenIndex {
	957	return self.defer_token;
	958	}
	959
	960	pub fn lastToken(self: &Defer) TokenIndex {
	961	return self.expr.lastToken();
	962	}
	963	};
	964
	965	pub const Comptime = struct {
	966	base: Node,
	967	doc_comments: ?&DocComment,
	968	comptime_token: TokenIndex,
	969	expr: &Node,
	970
	971	pub fn iterate(self: &Comptime, index: usize) ?&Node {
	972	var i = index;
	973
	974	if (i < 1) return self.expr;
	975	i -= 1;
	976
	977	return null;
	978	}
	979
	980	pub fn firstToken(self: &Comptime) TokenIndex {
	981	return self.comptime_token;
	982	}
	983
	984	pub fn lastToken(self: &Comptime) TokenIndex {
	985	return self.expr.lastToken();
	986	}
	987	};
	988
	989	pub const Payload = struct {
	990	base: Node,
	991	lpipe: TokenIndex,
	992	error_symbol: &Node,
	993	rpipe: TokenIndex,
	994
	995	pub fn iterate(self: &Payload, index: usize) ?&Node {
	996	var i = index;
	997
	998	if (i < 1) return self.error_symbol;
	999	i -= 1;
	1000
	1001	return null;
	1002	}
	1003
	1004	pub fn firstToken(self: &Payload) TokenIndex {
	1005	return self.lpipe;
	1006	}
	1007
	1008	pub fn lastToken(self: &Payload) TokenIndex {
	1009	return self.rpipe;
	1010	}
	1011	};
	1012
	1013	pub const PointerPayload = struct {
	1014	base: Node,
	1015	lpipe: TokenIndex,
	1016	ptr_token: ?TokenIndex,
	1017	value_symbol: &Node,
	1018	rpipe: TokenIndex,
	1019
	1020	pub fn iterate(self: &PointerPayload, index: usize) ?&Node {
	1021	var i = index;
	1022
	1023	if (i < 1) return self.value_symbol;
	1024	i -= 1;
	1025
	1026	return null;
	1027	}
	1028
	1029	pub fn firstToken(self: &PointerPayload) TokenIndex {
	1030	return self.lpipe;
	1031	}
	1032
	1033	pub fn lastToken(self: &PointerPayload) TokenIndex {
	1034	return self.rpipe;
	1035	}
	1036	};
	1037
	1038	pub const PointerIndexPayload = struct {
	1039	base: Node,
	1040	lpipe: TokenIndex,
	1041	ptr_token: ?TokenIndex,
	1042	value_symbol: &Node,
	1043	index_symbol: ?&Node,
	1044	rpipe: TokenIndex,
	1045
	1046	pub fn iterate(self: &PointerIndexPayload, index: usize) ?&Node {
	1047	var i = index;
	1048
	1049	if (i < 1) return self.value_symbol;
	1050	i -= 1;
	1051
	1052	if (self.index_symbol) \|index_symbol\| {
	1053	if (i < 1) return index_symbol;
	1054	i -= 1;
	1055	}
	1056
	1057	return null;
	1058	}
	1059
	1060	pub fn firstToken(self: &PointerIndexPayload) TokenIndex {
	1061	return self.lpipe;
	1062	}
	1063
	1064	pub fn lastToken(self: &PointerIndexPayload) TokenIndex {
	1065	return self.rpipe;
	1066	}
	1067	};
	1068
	1069	pub const Else = struct {
	1070	base: Node,
	1071	else_token: TokenIndex,
	1072	payload: ?&Node,
	1073	body: &Node,
	1074
	1075	pub fn iterate(self: &Else, index: usize) ?&Node {
	1076	var i = index;
	1077
	1078	if (self.payload) \|payload\| {
	1079	if (i < 1) return payload;
	1080	i -= 1;
	1081	}
	1082
	1083	if (i < 1) return self.body;
	1084	i -= 1;
	1085
	1086	return null;
	1087	}
	1088
	1089	pub fn firstToken(self: &Else) TokenIndex {
	1090	return self.else_token;
	1091	}
	1092
	1093	pub fn lastToken(self: &Else) TokenIndex {
	1094	return self.body.lastToken();
	1095	}
	1096	};
	1097
	1098	pub const Switch = struct {
	1099	base: Node,
	1100	switch_token: TokenIndex,
	1101	expr: &Node,
	1102	/// these can be SwitchCase nodes or LineComment nodes
	1103	cases: CaseList,
	1104	rbrace: TokenIndex,
	1105
	1106	pub const CaseList = SegmentedList(&Node, 2);
	1107
	1108	pub fn iterate(self: &Switch, index: usize) ?&Node {
	1109	var i = index;
	1110
	1111	if (i < 1) return self.expr;
	1112	i -= 1;
	1113
	1114	if (i < self.cases.len) return *self.cases.at(i);
	1115	i -= self.cases.len;
	1116
	1117	return null;
	1118	}
	1119
	1120	pub fn firstToken(self: &Switch) TokenIndex {
	1121	return self.switch_token;
	1122	}
	1123
	1124	pub fn lastToken(self: &Switch) TokenIndex {
	1125	return self.rbrace;
	1126	}
	1127	};
	1128
	1129	pub const SwitchCase = struct {
	1130	base: Node,
	1131	items: ItemList,
	1132	payload: ?&Node,
	1133	expr: &Node,
	1134
	1135	pub const ItemList = SegmentedList(&Node, 1);
	1136
	1137	pub fn iterate(self: &SwitchCase, index: usize) ?&Node {
	1138	var i = index;
	1139
	1140	if (i < self.items.len) return *self.items.at(i);
	1141	i -= self.items.len;
	1142
	1143	if (self.payload) \|payload\| {
	1144	if (i < 1) return payload;
	1145	i -= 1;
	1146	}
	1147
	1148	if (i < 1) return self.expr;
	1149	i -= 1;
	1150
	1151	return null;
	1152	}
	1153
	1154	pub fn firstToken(self: &SwitchCase) TokenIndex {
	1155	return (*self.items.at(0)).firstToken();
	1156	}
	1157
	1158	pub fn lastToken(self: &SwitchCase) TokenIndex {
	1159	return self.expr.lastToken();
	1160	}
	1161	};
	1162
	1163	pub const SwitchElse = struct {
	1164	base: Node,
	1165	token: TokenIndex,
	1166
	1167	pub fn iterate(self: &SwitchElse, index: usize) ?&Node {
	1168	return null;
	1169	}
	1170
	1171	pub fn firstToken(self: &SwitchElse) TokenIndex {
	1172	return self.token;
	1173	}
	1174
	1175	pub fn lastToken(self: &SwitchElse) TokenIndex {
	1176	return self.token;
	1177	}
	1178	};
	1179
	1180	pub const While = struct {
	1181	base: Node,
	1182	label: ?TokenIndex,
	1183	inline_token: ?TokenIndex,
	1184	while_token: TokenIndex,
	1185	condition: &Node,
	1186	payload: ?&Node,
	1187	continue_expr: ?&Node,
	1188	body: &Node,
	1189	@"else": ?&Else,
	1190
	1191	pub fn iterate(self: &While, index: usize) ?&Node {
	1192	var i = index;
	1193
	1194	if (i < 1) return self.condition;
	1195	i -= 1;
	1196
	1197	if (self.payload) \|payload\| {
	1198	if (i < 1) return payload;
	1199	i -= 1;
	1200	}
	1201
	1202	if (self.continue_expr) \|continue_expr\| {
	1203	if (i < 1) return continue_expr;
	1204	i -= 1;
	1205	}
	1206
	1207	if (i < 1) return self.body;
	1208	i -= 1;
	1209
	1210	if (self.@"else") \|@"else"\| {
	1211	if (i < 1) return &@"else".base;
	1212	i -= 1;
	1213	}
	1214
	1215	return null;
	1216	}
	1217
	1218	pub fn firstToken(self: &While) TokenIndex {
	1219	if (self.label) \|label\| {
	1220	return label;
	1221	}
	1222
	1223	if (self.inline_token) \|inline_token\| {
	1224	return inline_token;
	1225	}
	1226
	1227	return self.while_token;
	1228	}
	1229
	1230	pub fn lastToken(self: &While) TokenIndex {
	1231	if (self.@"else") \|@"else"\| {
	1232	return @"else".body.lastToken();
	1233	}
	1234
	1235	return self.body.lastToken();
	1236	}
	1237	};
	1238
	1239	pub const For = struct {
	1240	base: Node,
	1241	label: ?TokenIndex,
	1242	inline_token: ?TokenIndex,
	1243	for_token: TokenIndex,
	1244	array_expr: &Node,
	1245	payload: ?&Node,
	1246	body: &Node,
	1247	@"else": ?&Else,
	1248
	1249	pub fn iterate(self: &For, index: usize) ?&Node {
	1250	var i = index;
	1251
	1252	if (i < 1) return self.array_expr;
	1253	i -= 1;
	1254
	1255	if (self.payload) \|payload\| {
	1256	if (i < 1) return payload;
	1257	i -= 1;
	1258	}
	1259
	1260	if (i < 1) return self.body;
	1261	i -= 1;
	1262
	1263	if (self.@"else") \|@"else"\| {
	1264	if (i < 1) return &@"else".base;
	1265	i -= 1;
	1266	}
	1267
	1268	return null;
	1269	}
	1270
	1271	pub fn firstToken(self: &For) TokenIndex {
	1272	if (self.label) \|label\| {
	1273	return label;
	1274	}
	1275
	1276	if (self.inline_token) \|inline_token\| {
	1277	return inline_token;
	1278	}
	1279
	1280	return self.for_token;
	1281	}
	1282
	1283	pub fn lastToken(self: &For) TokenIndex {
	1284	if (self.@"else") \|@"else"\| {
	1285	return @"else".body.lastToken();
	1286	}
	1287
	1288	return self.body.lastToken();
	1289	}
	1290	};
	1291
	1292	pub const If = struct {
	1293	base: Node,
	1294	if_token: TokenIndex,
	1295	condition: &Node,
	1296	payload: ?&Node,
	1297	body: &Node,
	1298	@"else": ?&Else,
	1299
	1300	pub fn iterate(self: &If, index: usize) ?&Node {
	1301	var i = index;
	1302
	1303	if (i < 1) return self.condition;
	1304	i -= 1;
	1305
	1306	if (self.payload) \|payload\| {
	1307	if (i < 1) return payload;
	1308	i -= 1;
	1309	}
	1310
	1311	if (i < 1) return self.body;
	1312	i -= 1;
	1313
	1314	if (self.@"else") \|@"else"\| {
	1315	if (i < 1) return &@"else".base;
	1316	i -= 1;
	1317	}
	1318
	1319	return null;
	1320	}
	1321
	1322	pub fn firstToken(self: &If) TokenIndex {
	1323	return self.if_token;
	1324	}
	1325
	1326	pub fn lastToken(self: &If) TokenIndex {
	1327	if (self.@"else") \|@"else"\| {
	1328	return @"else".body.lastToken();
	1329	}
	1330
	1331	return self.body.lastToken();
	1332	}
	1333	};
	1334
	1335	pub const InfixOp = struct {
	1336	base: Node,
	1337	op_token: TokenIndex,
	1338	lhs: &Node,
	1339	op: Op,
	1340	rhs: &Node,
	1341
	1342	pub const Op = union(enum) {
	1343	Add,
	1344	AddWrap,
	1345	ArrayCat,
	1346	ArrayMult,
	1347	Assign,
	1348	AssignBitAnd,
	1349	AssignBitOr,
	1350	AssignBitShiftLeft,
	1351	AssignBitShiftRight,
	1352	AssignBitXor,
	1353	AssignDiv,
	1354	AssignMinus,
	1355	AssignMinusWrap,
	1356	AssignMod,
	1357	AssignPlus,
	1358	AssignPlusWrap,
	1359	AssignTimes,
	1360	AssignTimesWarp,
	1361	BangEqual,
	1362	BitAnd,
	1363	BitOr,
	1364	BitShiftLeft,
	1365	BitShiftRight,
	1366	BitXor,
	1367	BoolAnd,
	1368	BoolOr,
	1369	Catch: ?&Node,
	1370	Div,
	1371	EqualEqual,
	1372	ErrorUnion,
	1373	GreaterOrEqual,
	1374	GreaterThan,
	1375	LessOrEqual,
	1376	LessThan,
	1377	MergeErrorSets,
	1378	Mod,
	1379	Mult,
	1380	MultWrap,
	1381	Period,
	1382	Range,
	1383	Sub,
	1384	SubWrap,
	1385	UnwrapMaybe,
	1386	};
	1387
	1388	pub fn iterate(self: &InfixOp, index: usize) ?&Node {
	1389	var i = index;
	1390
	1391	if (i < 1) return self.lhs;
	1392	i -= 1;
	1393
	1394	switch (self.op) {
	1395	Op.Catch => \|maybe_payload\| {
	1396	if (maybe_payload) \|payload\| {
	1397	if (i < 1) return payload;
	1398	i -= 1;
	1399	}
	1400	},
	1401
	1402	Op.Add,
	1403	Op.AddWrap,
	1404	Op.ArrayCat,
	1405	Op.ArrayMult,
	1406	Op.Assign,
	1407	Op.AssignBitAnd,
	1408	Op.AssignBitOr,
	1409	Op.AssignBitShiftLeft,
	1410	Op.AssignBitShiftRight,
	1411	Op.AssignBitXor,
	1412	Op.AssignDiv,
	1413	Op.AssignMinus,
	1414	Op.AssignMinusWrap,
	1415	Op.AssignMod,
	1416	Op.AssignPlus,
	1417	Op.AssignPlusWrap,
	1418	Op.AssignTimes,
	1419	Op.AssignTimesWarp,
	1420	Op.BangEqual,
	1421	Op.BitAnd,
	1422	Op.BitOr,
	1423	Op.BitShiftLeft,
	1424	Op.BitShiftRight,
	1425	Op.BitXor,
	1426	Op.BoolAnd,
	1427	Op.BoolOr,
	1428	Op.Div,
	1429	Op.EqualEqual,
	1430	Op.ErrorUnion,
	1431	Op.GreaterOrEqual,
	1432	Op.GreaterThan,
	1433	Op.LessOrEqual,
	1434	Op.LessThan,
	1435	Op.MergeErrorSets,
	1436	Op.Mod,
	1437	Op.Mult,
	1438	Op.MultWrap,
	1439	Op.Period,
	1440	Op.Range,
	1441	Op.Sub,
	1442	Op.SubWrap,
	1443	Op.UnwrapMaybe => {},
	1444	}
	1445
	1446	if (i < 1) return self.rhs;
	1447	i -= 1;
	1448
	1449	return null;
	1450	}
	1451
	1452	pub fn firstToken(self: &InfixOp) TokenIndex {
	1453	return self.lhs.firstToken();
	1454	}
	1455
	1456	pub fn lastToken(self: &InfixOp) TokenIndex {
	1457	return self.rhs.lastToken();
	1458	}
	1459	};
	1460
	1461	pub const PrefixOp = struct {
	1462	base: Node,
	1463	op_token: TokenIndex,
	1464	op: Op,
	1465	rhs: &Node,
	1466
	1467	const Op = union(enum) {
	1468	AddrOf: AddrOfInfo,
	1469	ArrayType: &Node,
	1470	Await,
	1471	BitNot,
	1472	BoolNot,
	1473	Cancel,
	1474	Deref,
	1475	MaybeType,
	1476	Negation,
	1477	NegationWrap,
	1478	Resume,
	1479	SliceType: AddrOfInfo,
	1480	Try,
	1481	UnwrapMaybe,
	1482	};
	1483
	1484	const AddrOfInfo = struct {
	1485	align_expr: ?&Node,
	1486	bit_offset_start_token: ?TokenIndex,
	1487	bit_offset_end_token: ?TokenIndex,
	1488	const_token: ?TokenIndex,
	1489	volatile_token: ?TokenIndex,
	1490	};
	1491
	1492	pub fn iterate(self: &PrefixOp, index: usize) ?&Node {
	1493	var i = index;
	1494
	1495	switch (self.op) {
	1496	Op.SliceType => \|addr_of_info\| {
	1497	if (addr_of_info.align_expr) \|align_expr\| {
	1498	if (i < 1) return align_expr;
	1499	i -= 1;
	1500	}
	1501	},
	1502	Op.AddrOf => \|addr_of_info\| {
	1503	if (addr_of_info.align_expr) \|align_expr\| {
	1504	if (i < 1) return align_expr;
	1505	i -= 1;
	1506	}
	1507	},
	1508	Op.ArrayType => \|size_expr\| {
	1509	if (i < 1) return size_expr;
	1510	i -= 1;
	1511	},
	1512	Op.Await,
	1513	Op.BitNot,
	1514	Op.BoolNot,
	1515	Op.Cancel,
	1516	Op.Deref,
	1517	Op.MaybeType,
	1518	Op.Negation,
	1519	Op.NegationWrap,
	1520	Op.Try,
	1521	Op.Resume,
	1522	Op.UnwrapMaybe => {},
	1523	}
	1524
	1525	if (i < 1) return self.rhs;
	1526	i -= 1;
	1527
	1528	return null;
	1529	}
	1530
	1531	pub fn firstToken(self: &PrefixOp) TokenIndex {
	1532	return self.op_token;
	1533	}
	1534
	1535	pub fn lastToken(self: &PrefixOp) TokenIndex {
	1536	return self.rhs.lastToken();
	1537	}
	1538	};
	1539
	1540	pub const FieldInitializer = struct {
	1541	base: Node,
	1542	period_token: TokenIndex,
	1543	name_token: TokenIndex,
	1544	expr: &Node,
	1545
	1546	pub fn iterate(self: &FieldInitializer, index: usize) ?&Node {
	1547	var i = index;
	1548
	1549	if (i < 1) return self.expr;
	1550	i -= 1;
	1551
	1552	return null;
	1553	}
	1554
	1555	pub fn firstToken(self: &FieldInitializer) TokenIndex {
	1556	return self.period_token;
	1557	}
	1558
	1559	pub fn lastToken(self: &FieldInitializer) TokenIndex {
	1560	return self.expr.lastToken();
	1561	}
	1562	};
	1563
	1564	pub const SuffixOp = struct {
	1565	base: Node,
	1566	lhs: &Node,
	1567	op: Op,
	1568	rtoken: TokenIndex,
	1569
	1570	pub const Op = union(enum) {
	1571	Call: Call,
	1572	ArrayAccess: &Node,
	1573	Slice: Slice,
	1574	ArrayInitializer: InitList,
	1575	StructInitializer: InitList,
	1576
	1577	pub const InitList = SegmentedList(&Node, 2);
	1578
	1579	pub const Call = struct {
	1580	params: ParamList,
	1581	async_attr: ?&AsyncAttribute,
	1582
	1583	pub const ParamList = SegmentedList(&Node, 2);
	1584	};
	1585
	1586	pub const Slice = struct {
	1587	start: &Node,
	1588	end: ?&Node,
	1589	};
	1590	};
	1591
	1592	pub fn iterate(self: &SuffixOp, index: usize) ?&Node {
	1593	var i = index;
	1594
	1595	if (i < 1) return self.lhs;
	1596	i -= 1;
	1597
	1598	switch (self.op) {
	1599	Op.Call => \|call_info\| {
	1600	if (i < call_info.params.len) return *call_info.params.at(i);
	1601	i -= call_info.params.len;
	1602	},
	1603	Op.ArrayAccess => \|index_expr\| {
	1604	if (i < 1) return index_expr;
	1605	i -= 1;
	1606	},
	1607	Op.Slice => \|range\| {
	1608	if (i < 1) return range.start;
	1609	i -= 1;
	1610
	1611	if (range.end) \|end\| {
	1612	if (i < 1) return end;
	1613	i -= 1;
	1614	}
	1615	},
	1616	Op.ArrayInitializer => \|exprs\| {
	1617	if (i < exprs.len) return *exprs.at(i);
	1618	i -= exprs.len;
	1619	},
	1620	Op.StructInitializer => \|fields\| {
	1621	if (i < fields.len) return *fields.at(i);
	1622	i -= fields.len;
	1623	},
	1624	}
	1625
	1626	return null;
	1627	}
	1628
	1629	pub fn firstToken(self: &SuffixOp) TokenIndex {
	1630	return self.lhs.firstToken();
	1631	}
	1632
	1633	pub fn lastToken(self: &SuffixOp) TokenIndex {
	1634	return self.rtoken;
	1635	}
	1636	};
	1637
	1638	pub const GroupedExpression = struct {
	1639	base: Node,
	1640	lparen: TokenIndex,
	1641	expr: &Node,
	1642	rparen: TokenIndex,
	1643
	1644	pub fn iterate(self: &GroupedExpression, index: usize) ?&Node {
	1645	var i = index;
	1646
	1647	if (i < 1) return self.expr;
	1648	i -= 1;
	1649
	1650	return null;
	1651	}
	1652
	1653	pub fn firstToken(self: &GroupedExpression) TokenIndex {
	1654	return self.lparen;
	1655	}
	1656
	1657	pub fn lastToken(self: &GroupedExpression) TokenIndex {
	1658	return self.rparen;
	1659	}
	1660	};
	1661
	1662	pub const ControlFlowExpression = struct {
	1663	base: Node,
	1664	ltoken: TokenIndex,
	1665	kind: Kind,
	1666	rhs: ?&Node,
	1667
	1668	const Kind = union(enum) {
	1669	Break: ?&Node,
	1670	Continue: ?&Node,
	1671	Return,
	1672	};
	1673
	1674	pub fn iterate(self: &ControlFlowExpression, index: usize) ?&Node {
	1675	var i = index;
	1676
	1677	switch (self.kind) {
	1678	Kind.Break => \|maybe_label\| {
	1679	if (maybe_label) \|label\| {
	1680	if (i < 1) return label;
	1681	i -= 1;
	1682	}
	1683	},
	1684	Kind.Continue => \|maybe_label\| {
	1685	if (maybe_label) \|label\| {
	1686	if (i < 1) return label;
	1687	i -= 1;
	1688	}
	1689	},
	1690	Kind.Return => {},
	1691	}
	1692
	1693	if (self.rhs) \|rhs\| {
	1694	if (i < 1) return rhs;
	1695	i -= 1;
	1696	}
	1697
	1698	return null;
	1699	}
	1700
	1701	pub fn firstToken(self: &ControlFlowExpression) TokenIndex {
	1702	return self.ltoken;
	1703	}
	1704
	1705	pub fn lastToken(self: &ControlFlowExpression) TokenIndex {
	1706	if (self.rhs) \|rhs\| {
	1707	return rhs.lastToken();
	1708	}
	1709
	1710	switch (self.kind) {
	1711	Kind.Break => \|maybe_label\| {
	1712	if (maybe_label) \|label\| {
	1713	return label.lastToken();
	1714	}
	1715	},
	1716	Kind.Continue => \|maybe_label\| {
	1717	if (maybe_label) \|label\| {
	1718	return label.lastToken();
	1719	}
	1720	},
	1721	Kind.Return => return self.ltoken,
	1722	}
	1723
	1724	return self.ltoken;
	1725	}
	1726	};
	1727
	1728	pub const Suspend = struct {
	1729	base: Node,
	1730	label: ?TokenIndex,
	1731	suspend_token: TokenIndex,
	1732	payload: ?&Node,
	1733	body: ?&Node,
	1734
	1735	pub fn iterate(self: &Suspend, index: usize) ?&Node {
	1736	var i = index;
	1737
	1738	if (self.payload) \|payload\| {
	1739	if (i < 1) return payload;
	1740	i -= 1;
	1741	}
	1742
	1743	if (self.body) \|body\| {
	1744	if (i < 1) return body;
	1745	i -= 1;
	1746	}
	1747
	1748	return null;
	1749	}
	1750
	1751	pub fn firstToken(self: &Suspend) TokenIndex {
	1752	if (self.label) \|label\| return label;
	1753	return self.suspend_token;
	1754	}
	1755
	1756	pub fn lastToken(self: &Suspend) TokenIndex {
	1757	if (self.body) \|body\| {
	1758	return body.lastToken();
	1759	}
	1760
	1761	if (self.payload) \|payload\| {
	1762	return payload.lastToken();
	1763	}
	1764
	1765	return self.suspend_token;
	1766	}
	1767	};
	1768
	1769	pub const IntegerLiteral = struct {
	1770	base: Node,
	1771	token: TokenIndex,
	1772
	1773	pub fn iterate(self: &IntegerLiteral, index: usize) ?&Node {
	1774	return null;
	1775	}
	1776
	1777	pub fn firstToken(self: &IntegerLiteral) TokenIndex {
	1778	return self.token;
	1779	}
	1780
	1781	pub fn lastToken(self: &IntegerLiteral) TokenIndex {
	1782	return self.token;
	1783	}
	1784	};
	1785
	1786	pub const FloatLiteral = struct {
	1787	base: Node,
	1788	token: TokenIndex,
	1789
	1790	pub fn iterate(self: &FloatLiteral, index: usize) ?&Node {
	1791	return null;
	1792	}
	1793
	1794	pub fn firstToken(self: &FloatLiteral) TokenIndex {
	1795	return self.token;
	1796	}
	1797
	1798	pub fn lastToken(self: &FloatLiteral) TokenIndex {
	1799	return self.token;
	1800	}
	1801	};
	1802
	1803	pub const BuiltinCall = struct {
	1804	base: Node,
	1805	builtin_token: TokenIndex,
	1806	params: ParamList,
	1807	rparen_token: TokenIndex,
	1808
	1809	pub const ParamList = SegmentedList(&Node, 2);
	1810
	1811	pub fn iterate(self: &BuiltinCall, index: usize) ?&Node {
	1812	var i = index;
	1813
	1814	if (i < self.params.len) return *self.params.at(i);
	1815	i -= self.params.len;
	1816
	1817	return null;
	1818	}
	1819
	1820	pub fn firstToken(self: &BuiltinCall) TokenIndex {
	1821	return self.builtin_token;
	1822	}
	1823
	1824	pub fn lastToken(self: &BuiltinCall) TokenIndex {
	1825	return self.rparen_token;
	1826	}
	1827	};
	1828
	1829	pub const StringLiteral = struct {
	1830	base: Node,
	1831	token: TokenIndex,
	1832
	1833	pub fn iterate(self: &StringLiteral, index: usize) ?&Node {
	1834	return null;
	1835	}
	1836
	1837	pub fn firstToken(self: &StringLiteral) TokenIndex {
	1838	return self.token;
	1839	}
	1840
	1841	pub fn lastToken(self: &StringLiteral) TokenIndex {
	1842	return self.token;
	1843	}
	1844	};
	1845
	1846	pub const MultilineStringLiteral = struct {
	1847	base: Node,
	1848	lines: LineList,
	1849
	1850	pub const LineList = SegmentedList(TokenIndex, 4);
	1851
	1852	pub fn iterate(self: &MultilineStringLiteral, index: usize) ?&Node {
	1853	return null;
	1854	}
	1855
	1856	pub fn firstToken(self: &MultilineStringLiteral) TokenIndex {
	1857	return *self.lines.at(0);
	1858	}
	1859
	1860	pub fn lastToken(self: &MultilineStringLiteral) TokenIndex {
	1861	return *self.lines.at(self.lines.len - 1);
	1862	}
	1863	};
	1864
	1865	pub const CharLiteral = struct {
	1866	base: Node,
	1867	token: TokenIndex,
	1868
	1869	pub fn iterate(self: &CharLiteral, index: usize) ?&Node {
	1870	return null;
	1871	}
	1872
	1873	pub fn firstToken(self: &CharLiteral) TokenIndex {
	1874	return self.token;
	1875	}
	1876
	1877	pub fn lastToken(self: &CharLiteral) TokenIndex {
	1878	return self.token;
	1879	}
	1880	};
	1881
	1882	pub const BoolLiteral = struct {
	1883	base: Node,
	1884	token: TokenIndex,
	1885
	1886	pub fn iterate(self: &BoolLiteral, index: usize) ?&Node {
	1887	return null;
	1888	}
	1889
	1890	pub fn firstToken(self: &BoolLiteral) TokenIndex {
	1891	return self.token;
	1892	}
	1893
	1894	pub fn lastToken(self: &BoolLiteral) TokenIndex {
	1895	return self.token;
	1896	}
	1897	};
	1898
	1899	pub const NullLiteral = struct {
	1900	base: Node,
	1901	token: TokenIndex,
	1902
	1903	pub fn iterate(self: &NullLiteral, index: usize) ?&Node {
	1904	return null;
	1905	}
	1906
	1907	pub fn firstToken(self: &NullLiteral) TokenIndex {
	1908	return self.token;
	1909	}
	1910
	1911	pub fn lastToken(self: &NullLiteral) TokenIndex {
	1912	return self.token;
	1913	}
	1914	};
	1915
	1916	pub const UndefinedLiteral = struct {
	1917	base: Node,
	1918	token: TokenIndex,
	1919
	1920	pub fn iterate(self: &UndefinedLiteral, index: usize) ?&Node {
	1921	return null;
	1922	}
	1923
	1924	pub fn firstToken(self: &UndefinedLiteral) TokenIndex {
	1925	return self.token;
	1926	}
	1927
	1928	pub fn lastToken(self: &UndefinedLiteral) TokenIndex {
	1929	return self.token;
	1930	}
	1931	};
	1932
	1933	pub const ThisLiteral = struct {
	1934	base: Node,
	1935	token: TokenIndex,
	1936
	1937	pub fn iterate(self: &ThisLiteral, index: usize) ?&Node {
	1938	return null;
	1939	}
	1940
	1941	pub fn firstToken(self: &ThisLiteral) TokenIndex {
	1942	return self.token;
	1943	}
	1944
	1945	pub fn lastToken(self: &ThisLiteral) TokenIndex {
	1946	return self.token;
	1947	}
	1948	};
	1949
	1950	pub const AsmOutput = struct {
	1951	base: Node,
	1952	symbolic_name: &Node,
	1953	constraint: &Node,
	1954	kind: Kind,
	1955
	1956	const Kind = union(enum) {
	1957	Variable: &Identifier,
	1958	Return: &Node
	1959	};
	1960
	1961	pub fn iterate(self: &AsmOutput, index: usize) ?&Node {
	1962	var i = index;
	1963
	1964	if (i < 1) return self.symbolic_name;
	1965	i -= 1;
	1966
	1967	if (i < 1) return self.constraint;
	1968	i -= 1;
	1969
	1970	switch (self.kind) {
	1971	Kind.Variable => \|variable_name\| {
	1972	if (i < 1) return &variable_name.base;
	1973	i -= 1;
	1974	},
	1975	Kind.Return => \|return_type\| {
	1976	if (i < 1) return return_type;
	1977	i -= 1;
	1978	}
	1979	}
	1980
	1981	return null;
	1982	}
	1983
	1984	pub fn firstToken(self: &AsmOutput) TokenIndex {
	1985	return self.symbolic_name.firstToken();
	1986	}
	1987
	1988	pub fn lastToken(self: &AsmOutput) TokenIndex {
	1989	return switch (self.kind) {
	1990	Kind.Variable => \|variable_name\| variable_name.lastToken(),
	1991	Kind.Return => \|return_type\| return_type.lastToken(),
	1992	};
	1993	}
	1994	};
	1995
	1996	pub const AsmInput = struct {
	1997	base: Node,
	1998	symbolic_name: &Node,
	1999	constraint: &Node,
	2000	expr: &Node,
	2001
	2002	pub fn iterate(self: &AsmInput, index: usize) ?&Node {
	2003	var i = index;
	2004
	2005	if (i < 1) return self.symbolic_name;
	2006	i -= 1;
	2007
	2008	if (i < 1) return self.constraint;
	2009	i -= 1;
	2010
	2011	if (i < 1) return self.expr;
	2012	i -= 1;
	2013
	2014	return null;
	2015	}
	2016
	2017	pub fn firstToken(self: &AsmInput) TokenIndex {
	2018	return self.symbolic_name.firstToken();
	2019	}
	2020
	2021	pub fn lastToken(self: &AsmInput) TokenIndex {
	2022	return self.expr.lastToken();
	2023	}
	2024	};
	2025
	2026	pub const Asm = struct {
	2027	base: Node,
	2028	asm_token: TokenIndex,
	2029	volatile_token: ?TokenIndex,
	2030	template: &Node,
	2031	outputs: OutputList,
	2032	inputs: InputList,
	2033	clobbers: ClobberList,
	2034	rparen: TokenIndex,
	2035
	2036	const OutputList = SegmentedList(&AsmOutput, 2);
	2037	const InputList = SegmentedList(&AsmInput, 2);
	2038	const ClobberList = SegmentedList(&Node, 2);
	2039
	2040	pub fn iterate(self: &Asm, index: usize) ?&Node {
	2041	var i = index;
	2042
	2043	if (i < self.outputs.len) return &(*self.outputs.at(index)).base;
	2044	i -= self.outputs.len;
	2045
	2046	if (i < self.inputs.len) return &(*self.inputs.at(index)).base;
	2047	i -= self.inputs.len;
	2048
	2049	if (i < self.clobbers.len) return *self.clobbers.at(index);
	2050	i -= self.clobbers.len;
	2051
	2052	return null;
	2053	}
	2054
	2055	pub fn firstToken(self: &Asm) TokenIndex {
	2056	return self.asm_token;
	2057	}
	2058
	2059	pub fn lastToken(self: &Asm) TokenIndex {
	2060	return self.rparen;
	2061	}
	2062	};
	2063
	2064	pub const Unreachable = struct {
	2065	base: Node,
	2066	token: TokenIndex,
	2067
	2068	pub fn iterate(self: &Unreachable, index: usize) ?&Node {
	2069	return null;
	2070	}
	2071
	2072	pub fn firstToken(self: &Unreachable) TokenIndex {
	2073	return self.token;
	2074	}
	2075
	2076	pub fn lastToken(self: &Unreachable) TokenIndex {
	2077	return self.token;
	2078	}
	2079	};
	2080
	2081	pub const ErrorType = struct {
	2082	base: Node,
	2083	token: TokenIndex,
	2084
	2085	pub fn iterate(self: &ErrorType, index: usize) ?&Node {
	2086	return null;
	2087	}
	2088
	2089	pub fn firstToken(self: &ErrorType) TokenIndex {
	2090	return self.token;
	2091	}
	2092
	2093	pub fn lastToken(self: &ErrorType) TokenIndex {
	2094	return self.token;
	2095	}
	2096	};
	2097
	2098	pub const VarType = struct {
	2099	base: Node,
	2100	token: TokenIndex,
	2101
	2102	pub fn iterate(self: &VarType, index: usize) ?&Node {
	2103	return null;
	2104	}
	2105
	2106	pub fn firstToken(self: &VarType) TokenIndex {
	2107	return self.token;
	2108	}
	2109
	2110	pub fn lastToken(self: &VarType) TokenIndex {
	2111	return self.token;
	2112	}
	2113	};
	2114
	2115	pub const LineComment = struct {
	2116	base: Node,
	2117	token: TokenIndex,
	2118
	2119	pub fn iterate(self: &LineComment, index: usize) ?&Node {
	2120	return null;
	2121	}
	2122
	2123	pub fn firstToken(self: &LineComment) TokenIndex {
	2124	return self.token;
	2125	}
	2126
	2127	pub fn lastToken(self: &LineComment) TokenIndex {
	2128	return self.token;
	2129	}
	2130	};
	2131
	2132	pub const DocComment = struct {
	2133	base: Node,
	2134	lines: LineList,
	2135
	2136	pub const LineList = SegmentedList(TokenIndex, 4);
	2137
	2138	pub fn iterate(self: &DocComment, index: usize) ?&Node {
	2139	return null;
	2140	}
	2141
	2142	pub fn firstToken(self: &DocComment) TokenIndex {
	2143	return *self.lines.at(0);
	2144	}
	2145
	2146	pub fn lastToken(self: &DocComment) TokenIndex {
	2147	return *self.lines.at(self.lines.len - 1);
	2148	}
	2149	};
	2150
	2151	pub const TestDecl = struct {
	2152	base: Node,
	2153	doc_comments: ?&DocComment,
	2154	test_token: TokenIndex,
	2155	name: &Node,
	2156	body_node: &Node,
	2157
	2158	pub fn iterate(self: &TestDecl, index: usize) ?&Node {
	2159	var i = index;
	2160
	2161	if (i < 1) return self.body_node;
	2162	i -= 1;
	2163
	2164	return null;
	2165	}
	2166
	2167	pub fn firstToken(self: &TestDecl) TokenIndex {
	2168	return self.test_token;
	2169	}
	2170
	2171	pub fn lastToken(self: &TestDecl) TokenIndex {
	2172	return self.body_node.lastToken();
	2173	}
	2174	};
646	2175	};
647	2176

std/zig/bench.zig created+38

...	...	@@ -0,0 +1,38 @@
	1	const std = @import("std");
	2	const mem = std.mem;
	3	const warn = std.debug.warn;
	4	const Tokenizer = std.zig.Tokenizer;
	5	const Parser = std.zig.Parser;
	6	const io = std.io;
	7
	8	const source = @embedFile("../os/index.zig");
	9	var fixed_buffer_mem: [10 * 1024 * 1024]u8 = undefined;
	10
	11	pub fn main() !void {
	12	var i: usize = 0;
	13	var timer = try std.os.time.Timer.start();
	14	const start = timer.lap();
	15	const iterations = 100;
	16	var memory_used: usize = 0;
	17	while (i < iterations) : (i += 1) {
	18	memory_used += testOnce();
	19	}
	20	const end = timer.read();
	21	memory_used /= iterations;
	22	const elapsed_s = f64(end - start) / std.os.time.ns_per_s;
	23	const bytes_per_sec = f64(source.len * iterations) / elapsed_s;
	24	const mb_per_sec = bytes_per_sec / (1024 * 1024);
	25
	26	var stdout_file = try std.io.getStdOut();
	27	const stdout = &std.io.FileOutStream.init(&stdout_file).stream;
	28	try stdout.print("{.3} MB/s, {} KB used \n", mb_per_sec, memory_used / 1024);
	29	}
	30
	31	fn testOnce() usize {
	32	var fixed_buf_alloc = std.heap.FixedBufferAllocator.init(fixed_buffer_mem[0..]);
	33	var allocator = &fixed_buf_alloc.allocator;
	34	var tokenizer = Tokenizer.init(source);
	35	var parser = Parser.init(&tokenizer, allocator, "(memory buffer)");
	36	_ = parser.parse() catch @panic("parse failure");
	37	return fixed_buf_alloc.end_index;
	38	}

std/zig/index.zig+5-3

...	...	@@ -1,11 +1,13 @@
1	1	const tokenizer = @import("tokenizer.zig");
2	2	pub const Token = tokenizer.Token;
3	3	pub const Tokenizer = tokenizer.Tokenizer;
4		pub const Parser = @import("parser.zig").Parser;
	4	pub const parse = @import("parse.zig").parse;
	5	pub const render = @import("render.zig").render;
5	6	pub const ast = @import("ast.zig");
6	7
7	8	test "std.zig tests" {
8		_ = @import("tokenizer.zig");
9		_ = @import("parser.zig");
10	9	_ = @import("ast.zig");
	10	_ = @import("parse.zig");
	11	_ = @import("render.zig");
	12	_ = @import("tokenizer.zig");
11	13	}

std/zig/parse.zig created+3503

...	...	@@ -0,0 +1,3503 @@
	1	const std = @import("../index.zig");
	2	const assert = std.debug.assert;
	3	const mem = std.mem;
	4	const ast = std.zig.ast;
	5	const Tokenizer = std.zig.Tokenizer;
	6	const Token = std.zig.Token;
	7	const TokenIndex = ast.TokenIndex;
	8	const Error = ast.Error;
	9
	10	/// Returns an AST tree, allocated with the parser's allocator.
	11	/// Result should be freed with tree.deinit() when there are
	12	/// no more references to any AST nodes of the tree.
	13	pub fn parse(allocator: &mem.Allocator, source: []const u8) !ast.Tree {
	14	var tree_arena = std.heap.ArenaAllocator.init(allocator);
	15	errdefer tree_arena.deinit();
	16
	17	var stack = std.ArrayList(State).init(allocator);
	18	defer stack.deinit();
	19
	20	const arena = &tree_arena.allocator;
	21	const root_node = try createNode(arena, ast.Node.Root,
	22	ast.Node.Root {
	23	.base = undefined,
	24	.decls = ast.Node.Root.DeclList.init(arena),
	25	.doc_comments = null,
	26	// initialized when we get the eof token
	27	.eof_token = undefined,
	28	}
	29	);
	30
	31	var tree = ast.Tree {
	32	.source = source,
	33	.root_node = root_node,
	34	.arena_allocator = tree_arena,
	35	.tokens = ast.Tree.TokenList.init(arena),
	36	.errors = ast.Tree.ErrorList.init(arena),
	37	};
	38
	39	var tokenizer = Tokenizer.init(tree.source);
	40	while (true) {
	41	const token_ptr = try tree.tokens.addOne();
	42	*token_ptr = tokenizer.next();
	43	if (token_ptr.id == Token.Id.Eof)
	44	break;
	45	}
	46	var tok_it = tree.tokens.iterator(0);
	47
	48	try stack.append(State.TopLevel);
	49
	50	while (true) {
	51	// This gives us 1 free push that can't fail
	52	const state = stack.pop();
	53
	54	switch (state) {
	55	State.TopLevel => {
	56	while (try eatLineComment(arena, &tok_it, &tree)) \|line_comment\| {
	57	try root_node.decls.push(&line_comment.base);
	58	}
	59
	60	const comments = try eatDocComments(arena, &tok_it, &tree);
	61
	62	const token = nextToken(&tok_it, &tree);
	63	const token_index = token.index;
	64	const token_ptr = token.ptr;
	65	switch (token_ptr.id) {
	66	Token.Id.Keyword_test => {
	67	stack.append(State.TopLevel) catch unreachable;
	68
	69	const block = try arena.construct(ast.Node.Block {
	70	.base = ast.Node {
	71	.id = ast.Node.Id.Block,
	72	},
	73	.label = null,
	74	.lbrace = undefined,
	75	.statements = ast.Node.Block.StatementList.init(arena),
	76	.rbrace = undefined,
	77	});
	78	const test_node = try arena.construct(ast.Node.TestDecl {
	79	.base = ast.Node {
	80	.id = ast.Node.Id.TestDecl,
	81	},
	82	.doc_comments = comments,
	83	.test_token = token_index,
	84	.name = undefined,
	85	.body_node = &block.base,
	86	});
	87	try root_node.decls.push(&test_node.base);
	88	try stack.append(State { .Block = block });
	89	try stack.append(State {
	90	.ExpectTokenSave = ExpectTokenSave {
	91	.id = Token.Id.LBrace,
	92	.ptr = &block.rbrace,
	93	}
	94	});
	95	try stack.append(State { .StringLiteral = OptionalCtx { .Required = &test_node.name } });
	96	continue;
	97	},
	98	Token.Id.Eof => {
	99	root_node.eof_token = token_index;
	100	root_node.doc_comments = comments;
	101	return tree;
	102	},
	103	Token.Id.Keyword_pub => {
	104	stack.append(State.TopLevel) catch unreachable;
	105	try stack.append(State {
	106	.TopLevelExtern = TopLevelDeclCtx {
	107	.decls = &root_node.decls,
	108	.visib_token = token_index,
	109	.extern_export_inline_token = null,
	110	.lib_name = null,
	111	.comments = comments,
	112	}
	113	});
	114	continue;
	115	},
	116	Token.Id.Keyword_comptime => {
	117	const block = try createNode(arena, ast.Node.Block,
	118	ast.Node.Block {
	119	.base = undefined,
	120	.label = null,
	121	.lbrace = undefined,
	122	.statements = ast.Node.Block.StatementList.init(arena),
	123	.rbrace = undefined,
	124	}
	125	);
	126	const node = try arena.construct(ast.Node.Comptime {
	127	.base = ast.Node {
	128	.id = ast.Node.Id.Comptime,
	129	},
	130	.comptime_token = token_index,
	131	.expr = &block.base,
	132	.doc_comments = comments,
	133	});
	134	try root_node.decls.push(&node.base);
	135
	136	stack.append(State.TopLevel) catch unreachable;
	137	try stack.append(State { .Block = block });
	138	try stack.append(State {
	139	.ExpectTokenSave = ExpectTokenSave {
	140	.id = Token.Id.LBrace,
	141	.ptr = &block.rbrace,
	142	}
	143	});
	144	continue;
	145	},
	146	else => {
	147	putBackToken(&tok_it, &tree);
	148	stack.append(State.TopLevel) catch unreachable;
	149	try stack.append(State {
	150	.TopLevelExtern = TopLevelDeclCtx {
	151	.decls = &root_node.decls,
	152	.visib_token = null,
	153	.extern_export_inline_token = null,
	154	.lib_name = null,
	155	.comments = comments,
	156	}
	157	});
	158	continue;
	159	},
	160	}
	161	},
	162	State.TopLevelExtern => \|ctx\| {
	163	const token = nextToken(&tok_it, &tree);
	164	const token_index = token.index;
	165	const token_ptr = token.ptr;
	166	switch (token_ptr.id) {
	167	Token.Id.Keyword_export, Token.Id.Keyword_inline => {
	168	stack.append(State {
	169	.TopLevelDecl = TopLevelDeclCtx {
	170	.decls = ctx.decls,
	171	.visib_token = ctx.visib_token,
	172	.extern_export_inline_token = AnnotatedToken {
	173	.index = token_index,
	174	.ptr = token_ptr,
	175	},
	176	.lib_name = null,
	177	.comments = ctx.comments,
	178	},
	179	}) catch unreachable;
	180	continue;
	181	},
	182	Token.Id.Keyword_extern => {
	183	stack.append(State {
	184	.TopLevelLibname = TopLevelDeclCtx {
	185	.decls = ctx.decls,
	186	.visib_token = ctx.visib_token,
	187	.extern_export_inline_token = AnnotatedToken {
	188	.index = token_index,
	189	.ptr = token_ptr,
	190	},
	191	.lib_name = null,
	192	.comments = ctx.comments,
	193	},
	194	}) catch unreachable;
	195	continue;
	196	},
	197	else => {
	198	putBackToken(&tok_it, &tree);
	199	stack.append(State { .TopLevelDecl = ctx }) catch unreachable;
	200	continue;
	201	}
	202	}
	203	},
	204	State.TopLevelLibname => \|ctx\| {
	205	const lib_name = blk: {
	206	const lib_name_token = nextToken(&tok_it, &tree);
	207	const lib_name_token_index = lib_name_token.index;
	208	const lib_name_token_ptr = lib_name_token.ptr;
	209	break :blk (try parseStringLiteral(arena, &tok_it, lib_name_token_ptr, lib_name_token_index, &tree)) ?? {
	210	putBackToken(&tok_it, &tree);
	211	break :blk null;
	212	};
	213	};
	214
	215	stack.append(State {
	216	.TopLevelDecl = TopLevelDeclCtx {
	217	.decls = ctx.decls,
	218	.visib_token = ctx.visib_token,
	219	.extern_export_inline_token = ctx.extern_export_inline_token,
	220	.lib_name = lib_name,
	221	.comments = ctx.comments,
	222	},
	223	}) catch unreachable;
	224	continue;
	225	},
	226	State.TopLevelDecl => \|ctx\| {
	227	const token = nextToken(&tok_it, &tree);
	228	const token_index = token.index;
	229	const token_ptr = token.ptr;
	230	switch (token_ptr.id) {
	231	Token.Id.Keyword_use => {
	232	if (ctx.extern_export_inline_token) \|annotated_token\| {
	233	*(try tree.errors.addOne()) = Error {
	234	.InvalidToken = Error.InvalidToken { .token = annotated_token.index },
	235	};
	236	return tree;
	237	}
	238
	239	const node = try arena.construct(ast.Node.Use {
	240	.base = ast.Node {.id = ast.Node.Id.Use },
	241	.visib_token = ctx.visib_token,
	242	.expr = undefined,
	243	.semicolon_token = undefined,
	244	.doc_comments = ctx.comments,
	245	});
	246	try ctx.decls.push(&node.base);
	247
	248	stack.append(State {
	249	.ExpectTokenSave = ExpectTokenSave {
	250	.id = Token.Id.Semicolon,
	251	.ptr = &node.semicolon_token,
	252	}
	253	}) catch unreachable;
	254	try stack.append(State { .Expression = OptionalCtx { .Required = &node.expr } });
	255	continue;
	256	},
	257	Token.Id.Keyword_var, Token.Id.Keyword_const => {
	258	if (ctx.extern_export_inline_token) \|annotated_token\| {
	259	if (annotated_token.ptr.id == Token.Id.Keyword_inline) {
	260	*(try tree.errors.addOne()) = Error {
	261	.InvalidToken = Error.InvalidToken { .token = annotated_token.index },
	262	};
	263	return tree;
	264	}
	265	}
	266
	267	try stack.append(State {
	268	.VarDecl = VarDeclCtx {
	269	.comments = ctx.comments,
	270	.visib_token = ctx.visib_token,
	271	.lib_name = ctx.lib_name,
	272	.comptime_token = null,
	273	.extern_export_token = if (ctx.extern_export_inline_token) \|at\| at.index else null,
	274	.mut_token = token_index,
	275	.list = ctx.decls
	276	}
	277	});
	278	continue;
	279	},
	280	Token.Id.Keyword_fn, Token.Id.Keyword_nakedcc,
	281	Token.Id.Keyword_stdcallcc, Token.Id.Keyword_async => {
	282	const fn_proto = try arena.construct(ast.Node.FnProto {
	283	.base = ast.Node {
	284	.id = ast.Node.Id.FnProto,
	285	},
	286	.doc_comments = ctx.comments,
	287	.visib_token = ctx.visib_token,
	288	.name_token = null,
	289	.fn_token = undefined,
	290	.params = ast.Node.FnProto.ParamList.init(arena),
	291	.return_type = undefined,
	292	.var_args_token = null,
	293	.extern_export_inline_token = if (ctx.extern_export_inline_token) \|at\| at.index else null,
	294	.cc_token = null,
	295	.async_attr = null,
	296	.body_node = null,
	297	.lib_name = ctx.lib_name,
	298	.align_expr = null,
	299	});
	300	try ctx.decls.push(&fn_proto.base);
	301	stack.append(State { .FnDef = fn_proto }) catch unreachable;
	302	try stack.append(State { .FnProto = fn_proto });
	303
	304	switch (token_ptr.id) {
	305	Token.Id.Keyword_nakedcc, Token.Id.Keyword_stdcallcc => {
	306	fn_proto.cc_token = token_index;
	307	try stack.append(State {
	308	.ExpectTokenSave = ExpectTokenSave {
	309	.id = Token.Id.Keyword_fn,
	310	.ptr = &fn_proto.fn_token,
	311	}
	312	});
	313	continue;
	314	},
	315	Token.Id.Keyword_async => {
	316	const async_node = try createNode(arena, ast.Node.AsyncAttribute,
	317	ast.Node.AsyncAttribute {
	318	.base = undefined,
	319	.async_token = token_index,
	320	.allocator_type = null,
	321	.rangle_bracket = null,
	322	}
	323	);
	324	fn_proto.async_attr = async_node;
	325
	326	try stack.append(State {
	327	.ExpectTokenSave = ExpectTokenSave {
	328	.id = Token.Id.Keyword_fn,
	329	.ptr = &fn_proto.fn_token,
	330	}
	331	});
	332	try stack.append(State { .AsyncAllocator = async_node });
	333	continue;
	334	},
	335	Token.Id.Keyword_fn => {
	336	fn_proto.fn_token = token_index;
	337	continue;
	338	},
	339	else => unreachable,
	340	}
	341	},
	342	else => {
	343	*(try tree.errors.addOne()) = Error {
	344	.ExpectedVarDeclOrFn = Error.ExpectedVarDeclOrFn { .token = token_index },
	345	};
	346	return tree;
	347	},
	348	}
	349	},
	350	State.TopLevelExternOrField => \|ctx\| {
	351	if (eatToken(&tok_it, &tree, Token.Id.Identifier)) \|identifier\| {
	352	std.debug.assert(ctx.container_decl.kind == ast.Node.ContainerDecl.Kind.Struct);
	353	const node = try arena.construct(ast.Node.StructField {
	354	.base = ast.Node {
	355	.id = ast.Node.Id.StructField,
	356	},
	357	.doc_comments = ctx.comments,
	358	.visib_token = ctx.visib_token,
	359	.name_token = identifier,
	360	.type_expr = undefined,
	361	});
	362	const node_ptr = try ctx.container_decl.fields_and_decls.addOne();
	363	*node_ptr = &node.base;
	364
	365	stack.append(State { .FieldListCommaOrEnd = ctx.container_decl }) catch unreachable;
	366	try stack.append(State { .Expression = OptionalCtx { .Required = &node.type_expr } });
	367	try stack.append(State { .ExpectToken = Token.Id.Colon });
	368	continue;
	369	}
	370
	371	stack.append(State{ .ContainerDecl = ctx.container_decl }) catch unreachable;
	372	try stack.append(State {
	373	.TopLevelExtern = TopLevelDeclCtx {
	374	.decls = &ctx.container_decl.fields_and_decls,
	375	.visib_token = ctx.visib_token,
	376	.extern_export_inline_token = null,
	377	.lib_name = null,
	378	.comments = ctx.comments,
	379	}
	380	});
	381	continue;
	382	},
	383
	384	State.FieldInitValue => \|ctx\| {
	385	const eq_tok = nextToken(&tok_it, &tree);
	386	const eq_tok_index = eq_tok.index;
	387	const eq_tok_ptr = eq_tok.ptr;
	388	if (eq_tok_ptr.id != Token.Id.Equal) {
	389	putBackToken(&tok_it, &tree);
	390	continue;
	391	}
	392	stack.append(State { .Expression = ctx }) catch unreachable;
	393	continue;
	394	},
	395
	396	State.ContainerKind => \|ctx\| {
	397	const token = nextToken(&tok_it, &tree);
	398	const token_index = token.index;
	399	const token_ptr = token.ptr;
	400	const node = try createToCtxNode(arena, ctx.opt_ctx, ast.Node.ContainerDecl,
	401	ast.Node.ContainerDecl {
	402	.base = undefined,
	403	.ltoken = ctx.ltoken,
	404	.layout = ctx.layout,
	405	.kind = switch (token_ptr.id) {
	406	Token.Id.Keyword_struct => ast.Node.ContainerDecl.Kind.Struct,
	407	Token.Id.Keyword_union => ast.Node.ContainerDecl.Kind.Union,
	408	Token.Id.Keyword_enum => ast.Node.ContainerDecl.Kind.Enum,
	409	else => {
	410	*(try tree.errors.addOne()) = Error {
	411	.ExpectedAggregateKw = Error.ExpectedAggregateKw { .token = token_index },
	412	};
	413	return tree;
	414	},
	415	},
	416	.init_arg_expr = ast.Node.ContainerDecl.InitArg.None,
	417	.fields_and_decls = ast.Node.ContainerDecl.DeclList.init(arena),
	418	.rbrace_token = undefined,
	419	}
	420	);
	421
	422	stack.append(State { .ContainerDecl = node }) catch unreachable;
	423	try stack.append(State { .ExpectToken = Token.Id.LBrace });
	424	try stack.append(State { .ContainerInitArgStart = node });
	425	continue;
	426	},
	427
	428	State.ContainerInitArgStart => \|container_decl\| {
	429	if (eatToken(&tok_it, &tree, Token.Id.LParen) == null) {
	430	continue;
	431	}
	432
	433	stack.append(State { .ExpectToken = Token.Id.RParen }) catch unreachable;
	434	try stack.append(State { .ContainerInitArg = container_decl });
	435	continue;
	436	},
	437
	438	State.ContainerInitArg => \|container_decl\| {
	439	const init_arg_token = nextToken(&tok_it, &tree);
	440	const init_arg_token_index = init_arg_token.index;
	441	const init_arg_token_ptr = init_arg_token.ptr;
	442	switch (init_arg_token_ptr.id) {
	443	Token.Id.Keyword_enum => {
	444	container_decl.init_arg_expr = ast.Node.ContainerDecl.InitArg {.Enum = null};
	445	const lparen_tok = nextToken(&tok_it, &tree);
	446	const lparen_tok_index = lparen_tok.index;
	447	const lparen_tok_ptr = lparen_tok.ptr;
	448	if (lparen_tok_ptr.id == Token.Id.LParen) {
	449	try stack.append(State { .ExpectToken = Token.Id.RParen } );
	450	try stack.append(State { .Expression = OptionalCtx {
	451	.RequiredNull = &container_decl.init_arg_expr.Enum,
	452	} });
	453	} else {
	454	putBackToken(&tok_it, &tree);
	455	}
	456	},
	457	else => {
	458	putBackToken(&tok_it, &tree);
	459	container_decl.init_arg_expr = ast.Node.ContainerDecl.InitArg { .Type = undefined };
	460	stack.append(State { .Expression = OptionalCtx { .Required = &container_decl.init_arg_expr.Type } }) catch unreachable;
	461	},
	462	}
	463	continue;
	464	},
	465
	466	State.ContainerDecl => \|container_decl\| {
	467	while (try eatLineComment(arena, &tok_it, &tree)) \|line_comment\| {
	468	try container_decl.fields_and_decls.push(&line_comment.base);
	469	}
	470
	471	const comments = try eatDocComments(arena, &tok_it, &tree);
	472	const token = nextToken(&tok_it, &tree);
	473	const token_index = token.index;
	474	const token_ptr = token.ptr;
	475	switch (token_ptr.id) {
	476	Token.Id.Identifier => {
	477	switch (container_decl.kind) {
	478	ast.Node.ContainerDecl.Kind.Struct => {
	479	const node = try arena.construct(ast.Node.StructField {
	480	.base = ast.Node {
	481	.id = ast.Node.Id.StructField,
	482	},
	483	.doc_comments = comments,
	484	.visib_token = null,
	485	.name_token = token_index,
	486	.type_expr = undefined,
	487	});
	488	const node_ptr = try container_decl.fields_and_decls.addOne();
	489	*node_ptr = &node.base;
	490
	491	try stack.append(State { .FieldListCommaOrEnd = container_decl });
	492	try stack.append(State { .TypeExprBegin = OptionalCtx { .Required = &node.type_expr } });
	493	try stack.append(State { .ExpectToken = Token.Id.Colon });
	494	continue;
	495	},
	496	ast.Node.ContainerDecl.Kind.Union => {
	497	const node = try arena.construct(ast.Node.UnionTag {
	498	.base = ast.Node {.id = ast.Node.Id.UnionTag },
	499	.name_token = token_index,
	500	.type_expr = null,
	501	.value_expr = null,
	502	.doc_comments = comments,
	503	});
	504	try container_decl.fields_and_decls.push(&node.base);
	505
	506	stack.append(State { .FieldListCommaOrEnd = container_decl }) catch unreachable;
	507	try stack.append(State { .FieldInitValue = OptionalCtx { .RequiredNull = &node.value_expr } });
	508	try stack.append(State { .TypeExprBegin = OptionalCtx { .RequiredNull = &node.type_expr } });
	509	try stack.append(State { .IfToken = Token.Id.Colon });
	510	continue;
	511	},
	512	ast.Node.ContainerDecl.Kind.Enum => {
	513	const node = try arena.construct(ast.Node.EnumTag {
	514	.base = ast.Node { .id = ast.Node.Id.EnumTag },
	515	.name_token = token_index,
	516	.value = null,
	517	.doc_comments = comments,
	518	});
	519	try container_decl.fields_and_decls.push(&node.base);
	520
	521	stack.append(State { .FieldListCommaOrEnd = container_decl }) catch unreachable;
	522	try stack.append(State { .Expression = OptionalCtx { .RequiredNull = &node.value } });
	523	try stack.append(State { .IfToken = Token.Id.Equal });
	524	continue;
	525	},
	526	}
	527	},
	528	Token.Id.Keyword_pub => {
	529	switch (container_decl.kind) {
	530	ast.Node.ContainerDecl.Kind.Struct => {
	531	try stack.append(State {
	532	.TopLevelExternOrField = TopLevelExternOrFieldCtx {
	533	.visib_token = token_index,
	534	.container_decl = container_decl,
	535	.comments = comments,
	536	}
	537	});
	538	continue;
	539	},
	540	else => {
	541	stack.append(State{ .ContainerDecl = container_decl }) catch unreachable;
	542	try stack.append(State {
	543	.TopLevelExtern = TopLevelDeclCtx {
	544	.decls = &container_decl.fields_and_decls,
	545	.visib_token = token_index,
	546	.extern_export_inline_token = null,
	547	.lib_name = null,
	548	.comments = comments,
	549	}
	550	});
	551	continue;
	552	}
	553	}
	554	},
	555	Token.Id.Keyword_export => {
	556	stack.append(State{ .ContainerDecl = container_decl }) catch unreachable;
	557	try stack.append(State {
	558	.TopLevelExtern = TopLevelDeclCtx {
	559	.decls = &container_decl.fields_and_decls,
	560	.visib_token = token_index,
	561	.extern_export_inline_token = null,
	562	.lib_name = null,
	563	.comments = comments,
	564	}
	565	});
	566	continue;
	567	},
	568	Token.Id.RBrace => {
	569	if (comments != null) {
	570	*(try tree.errors.addOne()) = Error {
	571	.UnattachedDocComment = Error.UnattachedDocComment { .token = token_index },
	572	};
	573	return tree;
	574	}
	575	container_decl.rbrace_token = token_index;
	576	continue;
	577	},
	578	else => {
	579	putBackToken(&tok_it, &tree);
	580	stack.append(State{ .ContainerDecl = container_decl }) catch unreachable;
	581	try stack.append(State {
	582	.TopLevelExtern = TopLevelDeclCtx {
	583	.decls = &container_decl.fields_and_decls,
	584	.visib_token = null,
	585	.extern_export_inline_token = null,
	586	.lib_name = null,
	587	.comments = comments,
	588	}
	589	});
	590	continue;
	591	}
	592	}
	593	},
	594
	595
	596	State.VarDecl => \|ctx\| {
	597	const var_decl = try arena.construct(ast.Node.VarDecl {
	598	.base = ast.Node {
	599	.id = ast.Node.Id.VarDecl,
	600	},
	601	.doc_comments = ctx.comments,
	602	.visib_token = ctx.visib_token,
	603	.mut_token = ctx.mut_token,
	604	.comptime_token = ctx.comptime_token,
	605	.extern_export_token = ctx.extern_export_token,
	606	.type_node = null,
	607	.align_node = null,
	608	.init_node = null,
	609	.lib_name = ctx.lib_name,
	610	// initialized later
	611	.name_token = undefined,
	612	.eq_token = undefined,
	613	.semicolon_token = undefined,
	614	});
	615	try ctx.list.push(&var_decl.base);
	616
	617	try stack.append(State { .VarDeclAlign = var_decl });
	618	try stack.append(State { .TypeExprBegin = OptionalCtx { .RequiredNull = &var_decl.type_node} });
	619	try stack.append(State { .IfToken = Token.Id.Colon });
	620	try stack.append(State {
	621	.ExpectTokenSave = ExpectTokenSave {
	622	.id = Token.Id.Identifier,
	623	.ptr = &var_decl.name_token,
	624	}
	625	});
	626	continue;
	627	},
	628	State.VarDeclAlign => \|var_decl\| {
	629	try stack.append(State { .VarDeclEq = var_decl });
	630
	631	const next_token = nextToken(&tok_it, &tree);
	632	const next_token_index = next_token.index;
	633	const next_token_ptr = next_token.ptr;
	634	if (next_token_ptr.id == Token.Id.Keyword_align) {
	635	try stack.append(State { .ExpectToken = Token.Id.RParen });
	636	try stack.append(State { .Expression = OptionalCtx { .RequiredNull = &var_decl.align_node} });
	637	try stack.append(State { .ExpectToken = Token.Id.LParen });
	638	continue;
	639	}
	640
	641	putBackToken(&tok_it, &tree);
	642	continue;
	643	},
	644	State.VarDeclEq => \|var_decl\| {
	645	const token = nextToken(&tok_it, &tree);
	646	const token_index = token.index;
	647	const token_ptr = token.ptr;
	648	switch (token_ptr.id) {
	649	Token.Id.Equal => {
	650	var_decl.eq_token = token_index;
	651	stack.append(State {
	652	.ExpectTokenSave = ExpectTokenSave {
	653	.id = Token.Id.Semicolon,
	654	.ptr = &var_decl.semicolon_token,
	655	},
	656	}) catch unreachable;
	657	try stack.append(State { .Expression = OptionalCtx { .RequiredNull = &var_decl.init_node } });
	658	continue;
	659	},
	660	Token.Id.Semicolon => {
	661	var_decl.semicolon_token = token_index;
	662	continue;
	663	},
	664	else => {
	665	*(try tree.errors.addOne()) = Error {
	666	.ExpectedEqOrSemi = Error.ExpectedEqOrSemi { .token = token_index },
	667	};
	668	return tree;
	669	}
	670	}
	671	},
	672
	673
	674	State.FnDef => \|fn_proto\| {
	675	const token = nextToken(&tok_it, &tree);
	676	const token_index = token.index;
	677	const token_ptr = token.ptr;
	678	switch(token_ptr.id) {
	679	Token.Id.LBrace => {
	680	const block = try arena.construct(ast.Node.Block {
	681	.base = ast.Node { .id = ast.Node.Id.Block },
	682	.label = null,
	683	.lbrace = token_index,
	684	.statements = ast.Node.Block.StatementList.init(arena),
	685	.rbrace = undefined,
	686	});
	687	fn_proto.body_node = &block.base;
	688	stack.append(State { .Block = block }) catch unreachable;
	689	continue;
	690	},
	691	Token.Id.Semicolon => continue,
	692	else => {
	693	*(try tree.errors.addOne()) = Error {
	694	.ExpectedSemiOrLBrace = Error.ExpectedSemiOrLBrace { .token = token_index },
	695	};
	696	return tree;
	697	},
	698	}
	699	},
	700	State.FnProto => \|fn_proto\| {
	701	stack.append(State { .FnProtoAlign = fn_proto }) catch unreachable;
	702	try stack.append(State { .ParamDecl = fn_proto });
	703	try stack.append(State { .ExpectToken = Token.Id.LParen });
	704
	705	if (eatToken(&tok_it, &tree, Token.Id.Identifier)) \|name_token\| {
	706	fn_proto.name_token = name_token;
	707	}
	708	continue;
	709	},
	710	State.FnProtoAlign => \|fn_proto\| {
	711	stack.append(State { .FnProtoReturnType = fn_proto }) catch unreachable;
	712
	713	if (eatToken(&tok_it, &tree, Token.Id.Keyword_align)) \|align_token\| {
	714	try stack.append(State { .ExpectToken = Token.Id.RParen });
	715	try stack.append(State { .Expression = OptionalCtx { .RequiredNull = &fn_proto.align_expr } });
	716	try stack.append(State { .ExpectToken = Token.Id.LParen });
	717	}
	718	continue;
	719	},
	720	State.FnProtoReturnType => \|fn_proto\| {
	721	const token = nextToken(&tok_it, &tree);
	722	const token_index = token.index;
	723	const token_ptr = token.ptr;
	724	switch (token_ptr.id) {
	725	Token.Id.Bang => {
	726	fn_proto.return_type = ast.Node.FnProto.ReturnType { .InferErrorSet = undefined };
	727	stack.append(State {
	728	.TypeExprBegin = OptionalCtx { .Required = &fn_proto.return_type.InferErrorSet },
	729	}) catch unreachable;
	730	continue;
	731	},
	732	else => {
	733	// TODO: this is a special case. Remove this when #760 is fixed
	734	if (token_ptr.id == Token.Id.Keyword_error) {
	735	if ((??tok_it.peek()).id == Token.Id.LBrace) {
	736	const error_type_node = try arena.construct(ast.Node.ErrorType {
	737	.base = ast.Node { .id = ast.Node.Id.ErrorType },
	738	.token = token_index,
	739	});
	740	fn_proto.return_type = ast.Node.FnProto.ReturnType {
	741	.Explicit = &error_type_node.base,
	742	};
	743	continue;
	744	}
	745	}
	746
	747	putBackToken(&tok_it, &tree);
	748	fn_proto.return_type = ast.Node.FnProto.ReturnType { .Explicit = undefined };
	749	stack.append(State { .TypeExprBegin = OptionalCtx { .Required = &fn_proto.return_type.Explicit }, }) catch unreachable;
	750	continue;
	751	},
	752	}
	753	},
	754
	755
	756	State.ParamDecl => \|fn_proto\| {
	757	if (eatToken(&tok_it, &tree, Token.Id.RParen)) \|_\| {
	758	continue;
	759	}
	760	const param_decl = try arena.construct(ast.Node.ParamDecl {
	761	.base = ast.Node {.id = ast.Node.Id.ParamDecl },
	762	.comptime_token = null,
	763	.noalias_token = null,
	764	.name_token = null,
	765	.type_node = undefined,
	766	.var_args_token = null,
	767	});
	768	try fn_proto.params.push(&param_decl.base);
	769
	770	stack.append(State {
	771	.ParamDeclEnd = ParamDeclEndCtx {
	772	.param_decl = param_decl,
	773	.fn_proto = fn_proto,
	774	}
	775	}) catch unreachable;
	776	try stack.append(State { .ParamDeclName = param_decl });
	777	try stack.append(State { .ParamDeclAliasOrComptime = param_decl });
	778	continue;
	779	},
	780	State.ParamDeclAliasOrComptime => \|param_decl\| {
	781	if (eatToken(&tok_it, &tree, Token.Id.Keyword_comptime)) \|comptime_token\| {
	782	param_decl.comptime_token = comptime_token;
	783	} else if (eatToken(&tok_it, &tree, Token.Id.Keyword_noalias)) \|noalias_token\| {
	784	param_decl.noalias_token = noalias_token;
	785	}
	786	continue;
	787	},
	788	State.ParamDeclName => \|param_decl\| {
	789	// TODO: Here, we eat two tokens in one state. This means that we can't have
	790	// comments between these two tokens.
	791	if (eatToken(&tok_it, &tree, Token.Id.Identifier)) \|ident_token\| {
	792	if (eatToken(&tok_it, &tree, Token.Id.Colon)) \|_\| {
	793	param_decl.name_token = ident_token;
	794	} else {
	795	putBackToken(&tok_it, &tree);
	796	}
	797	}
	798	continue;
	799	},
	800	State.ParamDeclEnd => \|ctx\| {
	801	if (eatToken(&tok_it, &tree, Token.Id.Ellipsis3)) \|ellipsis3\| {
	802	ctx.param_decl.var_args_token = ellipsis3;
	803	stack.append(State { .ExpectToken = Token.Id.RParen }) catch unreachable;
	804	continue;
	805	}
	806
	807	try stack.append(State { .ParamDeclComma = ctx.fn_proto });
	808	try stack.append(State {
	809	.TypeExprBegin = OptionalCtx { .Required = &ctx.param_decl.type_node }
	810	});
	811	continue;
	812	},
	813	State.ParamDeclComma => \|fn_proto\| {
	814	switch (expectCommaOrEnd(&tok_it, &tree, Token.Id.RParen)) {
	815	ExpectCommaOrEndResult.end_token => \|t\| {
	816	if (t == null) {
	817	stack.append(State { .ParamDecl = fn_proto }) catch unreachable;
	818	}
	819	continue;
	820	},
	821	ExpectCommaOrEndResult.parse_error => \|e\| {
	822	try tree.errors.push(e);
	823	return tree;
	824	},
	825	}
	826	},
	827
	828	State.MaybeLabeledExpression => \|ctx\| {
	829	if (eatToken(&tok_it, &tree, Token.Id.Colon)) \|_\| {
	830	stack.append(State {
	831	.LabeledExpression = LabelCtx {
	832	.label = ctx.label,
	833	.opt_ctx = ctx.opt_ctx,
	834	}
	835	}) catch unreachable;
	836	continue;
	837	}
	838
	839	_ = try createToCtxLiteral(arena, ctx.opt_ctx, ast.Node.Identifier, ctx.label);
	840	continue;
	841	},
	842	State.LabeledExpression => \|ctx\| {
	843	const token = nextToken(&tok_it, &tree);
	844	const token_index = token.index;
	845	const token_ptr = token.ptr;
	846	switch (token_ptr.id) {
	847	Token.Id.LBrace => {
	848	const block = try createToCtxNode(arena, ctx.opt_ctx, ast.Node.Block,
	849	ast.Node.Block {
	850	.base = undefined,
	851	.label = ctx.label,
	852	.lbrace = token_index,
	853	.statements = ast.Node.Block.StatementList.init(arena),
	854	.rbrace = undefined,
	855	}
	856	);
	857	stack.append(State { .Block = block }) catch unreachable;
	858	continue;
	859	},
	860	Token.Id.Keyword_while => {
	861	stack.append(State {
	862	.While = LoopCtx {
	863	.label = ctx.label,
	864	.inline_token = null,
	865	.loop_token = token_index,
	866	.opt_ctx = ctx.opt_ctx.toRequired(),
	867	}
	868	}) catch unreachable;
	869	continue;
	870	},
	871	Token.Id.Keyword_for => {
	872	stack.append(State {
	873	.For = LoopCtx {
	874	.label = ctx.label,
	875	.inline_token = null,
	876	.loop_token = token_index,
	877	.opt_ctx = ctx.opt_ctx.toRequired(),
	878	}
	879	}) catch unreachable;
	880	continue;
	881	},
	882	Token.Id.Keyword_suspend => {
	883	const node = try arena.construct(ast.Node.Suspend {
	884	.base = ast.Node {
	885	.id = ast.Node.Id.Suspend,
	886	},
	887	.label = ctx.label,
	888	.suspend_token = token_index,
	889	.payload = null,
	890	.body = null,
	891	});
	892	ctx.opt_ctx.store(&node.base);
	893	stack.append(State { .SuspendBody = node }) catch unreachable;
	894	try stack.append(State { .Payload = OptionalCtx { .Optional = &node.payload } });
	895	continue;
	896	},
	897	Token.Id.Keyword_inline => {
	898	stack.append(State {
	899	.Inline = InlineCtx {
	900	.label = ctx.label,
	901	.inline_token = token_index,
	902	.opt_ctx = ctx.opt_ctx.toRequired(),
	903	}
	904	}) catch unreachable;
	905	continue;
	906	},
	907	else => {
	908	if (ctx.opt_ctx != OptionalCtx.Optional) {
	909	*(try tree.errors.addOne()) = Error {
	910	.ExpectedLabelable = Error.ExpectedLabelable { .token = token_index },
	911	};
	912	return tree;
	913	}
	914
	915	putBackToken(&tok_it, &tree);
	916	continue;
	917	},
	918	}
	919	},
	920	State.Inline => \|ctx\| {
	921	const token = nextToken(&tok_it, &tree);
	922	const token_index = token.index;
	923	const token_ptr = token.ptr;
	924	switch (token_ptr.id) {
	925	Token.Id.Keyword_while => {
	926	stack.append(State {
	927	.While = LoopCtx {
	928	.inline_token = ctx.inline_token,
	929	.label = ctx.label,
	930	.loop_token = token_index,
	931	.opt_ctx = ctx.opt_ctx.toRequired(),
	932	}
	933	}) catch unreachable;
	934	continue;
	935	},
	936	Token.Id.Keyword_for => {
	937	stack.append(State {
	938	.For = LoopCtx {
	939	.inline_token = ctx.inline_token,
	940	.label = ctx.label,
	941	.loop_token = token_index,
	942	.opt_ctx = ctx.opt_ctx.toRequired(),
	943	}
	944	}) catch unreachable;
	945	continue;
	946	},
	947	else => {
	948	if (ctx.opt_ctx != OptionalCtx.Optional) {
	949	*(try tree.errors.addOne()) = Error {
	950	.ExpectedInlinable = Error.ExpectedInlinable { .token = token_index },
	951	};
	952	return tree;
	953	}
	954
	955	putBackToken(&tok_it, &tree);
	956	continue;
	957	},
	958	}
	959	},
	960	State.While => \|ctx\| {
	961	const node = try createToCtxNode(arena, ctx.opt_ctx, ast.Node.While,
	962	ast.Node.While {
	963	.base = undefined,
	964	.label = ctx.label,
	965	.inline_token = ctx.inline_token,
	966	.while_token = ctx.loop_token,
	967	.condition = undefined,
	968	.payload = null,
	969	.continue_expr = null,
	970	.body = undefined,
	971	.@"else" = null,
	972	}
	973	);
	974	stack.append(State { .Else = &node.@"else" }) catch unreachable;
	975	try stack.append(State { .Expression = OptionalCtx { .Required = &node.body } });
	976	try stack.append(State { .WhileContinueExpr = &node.continue_expr });
	977	try stack.append(State { .IfToken = Token.Id.Colon });
	978	try stack.append(State { .PointerPayload = OptionalCtx { .Optional = &node.payload } });
	979	try stack.append(State { .ExpectToken = Token.Id.RParen });
	980	try stack.append(State { .Expression = OptionalCtx { .Required = &node.condition } });
	981	try stack.append(State { .ExpectToken = Token.Id.LParen });
	982	continue;
	983	},
	984	State.WhileContinueExpr => \|dest\| {
	985	stack.append(State { .ExpectToken = Token.Id.RParen }) catch unreachable;
	986	try stack.append(State { .AssignmentExpressionBegin = OptionalCtx { .RequiredNull = dest } });
	987	try stack.append(State { .ExpectToken = Token.Id.LParen });
	988	continue;
	989	},
	990	State.For => \|ctx\| {
	991	const node = try createToCtxNode(arena, ctx.opt_ctx, ast.Node.For,
	992	ast.Node.For {
	993	.base = undefined,
	994	.label = ctx.label,
	995	.inline_token = ctx.inline_token,
	996	.for_token = ctx.loop_token,
	997	.array_expr = undefined,
	998	.payload = null,
	999	.body = undefined,
	1000	.@"else" = null,
	1001	}
	1002	);
	1003	stack.append(State { .Else = &node.@"else" }) catch unreachable;
	1004	try stack.append(State { .Expression = OptionalCtx { .Required = &node.body } });
	1005	try stack.append(State { .PointerIndexPayload = OptionalCtx { .Optional = &node.payload } });
	1006	try stack.append(State { .ExpectToken = Token.Id.RParen });
	1007	try stack.append(State { .Expression = OptionalCtx { .Required = &node.array_expr } });
	1008	try stack.append(State { .ExpectToken = Token.Id.LParen });
	1009	continue;
	1010	},
	1011	State.Else => \|dest\| {
	1012	if (eatToken(&tok_it, &tree, Token.Id.Keyword_else)) \|else_token\| {
	1013	const node = try createNode(arena, ast.Node.Else,
	1014	ast.Node.Else {
	1015	.base = undefined,
	1016	.else_token = else_token,
	1017	.payload = null,
	1018	.body = undefined,
	1019	}
	1020	);
	1021	*dest = node;
	1022
	1023	stack.append(State { .Expression = OptionalCtx { .Required = &node.body } }) catch unreachable;
	1024	try stack.append(State { .Payload = OptionalCtx { .Optional = &node.payload } });
	1025	continue;
	1026	} else {
	1027	continue;
	1028	}
	1029	},
	1030
	1031
	1032	State.Block => \|block\| {
	1033	const token = nextToken(&tok_it, &tree);
	1034	const token_index = token.index;
	1035	const token_ptr = token.ptr;
	1036	switch (token_ptr.id) {
	1037	Token.Id.RBrace => {
	1038	block.rbrace = token_index;
	1039	continue;
	1040	},
	1041	else => {
	1042	putBackToken(&tok_it, &tree);
	1043	stack.append(State { .Block = block }) catch unreachable;
	1044
	1045	var any_comments = false;
	1046	while (try eatLineComment(arena, &tok_it, &tree)) \|line_comment\| {
	1047	try block.statements.push(&line_comment.base);
	1048	any_comments = true;
	1049	}
	1050	if (any_comments) continue;
	1051
	1052	try stack.append(State { .Statement = block });
	1053	continue;
	1054	},
	1055	}
	1056	},
	1057	State.Statement => \|block\| {
	1058	const token = nextToken(&tok_it, &tree);
	1059	const token_index = token.index;
	1060	const token_ptr = token.ptr;
	1061	switch (token_ptr.id) {
	1062	Token.Id.Keyword_comptime => {
	1063	stack.append(State {
	1064	.ComptimeStatement = ComptimeStatementCtx {
	1065	.comptime_token = token_index,
	1066	.block = block,
	1067	}
	1068	}) catch unreachable;
	1069	continue;
	1070	},
	1071	Token.Id.Keyword_var, Token.Id.Keyword_const => {
	1072	stack.append(State {
	1073	.VarDecl = VarDeclCtx {
	1074	.comments = null,
	1075	.visib_token = null,
	1076	.comptime_token = null,
	1077	.extern_export_token = null,
	1078	.lib_name = null,
	1079	.mut_token = token_index,
	1080	.list = &block.statements,
	1081	}
	1082	}) catch unreachable;
	1083	continue;
	1084	},
	1085	Token.Id.Keyword_defer, Token.Id.Keyword_errdefer => {
	1086	const node = try arena.construct(ast.Node.Defer {
	1087	.base = ast.Node {
	1088	.id = ast.Node.Id.Defer,
	1089	},
	1090	.defer_token = token_index,
	1091	.kind = switch (token_ptr.id) {
	1092	Token.Id.Keyword_defer => ast.Node.Defer.Kind.Unconditional,
	1093	Token.Id.Keyword_errdefer => ast.Node.Defer.Kind.Error,
	1094	else => unreachable,
	1095	},
	1096	.expr = undefined,
	1097	});
	1098	const node_ptr = try block.statements.addOne();
	1099	*node_ptr = &node.base;
	1100
	1101	stack.append(State { .Semicolon = node_ptr }) catch unreachable;
	1102	try stack.append(State { .AssignmentExpressionBegin = OptionalCtx{ .Required = &node.expr } });
	1103	continue;
	1104	},
	1105	Token.Id.LBrace => {
	1106	const inner_block = try arena.construct(ast.Node.Block {
	1107	.base = ast.Node { .id = ast.Node.Id.Block },
	1108	.label = null,
	1109	.lbrace = token_index,
	1110	.statements = ast.Node.Block.StatementList.init(arena),
	1111	.rbrace = undefined,
	1112	});
	1113	try block.statements.push(&inner_block.base);
	1114
	1115	stack.append(State { .Block = inner_block }) catch unreachable;
	1116	continue;
	1117	},
	1118	else => {
	1119	putBackToken(&tok_it, &tree);
	1120	const statement = try block.statements.addOne();
	1121	try stack.append(State { .Semicolon = statement });
	1122	try stack.append(State { .AssignmentExpressionBegin = OptionalCtx{ .Required = statement } });
	1123	continue;
	1124	}
	1125	}
	1126	},
	1127	State.ComptimeStatement => \|ctx\| {
	1128	const token = nextToken(&tok_it, &tree);
	1129	const token_index = token.index;
	1130	const token_ptr = token.ptr;
	1131	switch (token_ptr.id) {
	1132	Token.Id.Keyword_var, Token.Id.Keyword_const => {
	1133	stack.append(State {
	1134	.VarDecl = VarDeclCtx {
	1135	.comments = null,
	1136	.visib_token = null,
	1137	.comptime_token = ctx.comptime_token,
	1138	.extern_export_token = null,
	1139	.lib_name = null,
	1140	.mut_token = token_index,
	1141	.list = &ctx.block.statements,
	1142	}
	1143	}) catch unreachable;
	1144	continue;
	1145	},
	1146	else => {
	1147	putBackToken(&tok_it, &tree);
	1148	putBackToken(&tok_it, &tree);
	1149	const statement = try ctx.block.statements.addOne();
	1150	try stack.append(State { .Semicolon = statement });
	1151	try stack.append(State { .Expression = OptionalCtx { .Required = statement } });
	1152	continue;
	1153	}
	1154	}
	1155	},
	1156	State.Semicolon => \|node_ptr\| {
	1157	const node = *node_ptr;
	1158	if (node.requireSemiColon()) {
	1159	stack.append(State { .ExpectToken = Token.Id.Semicolon }) catch unreachable;
	1160	continue;
	1161	}
	1162	continue;
	1163	},
	1164
	1165	State.AsmOutputItems => \|items\| {
	1166	const lbracket = nextToken(&tok_it, &tree);
	1167	const lbracket_index = lbracket.index;
	1168	const lbracket_ptr = lbracket.ptr;
	1169	if (lbracket_ptr.id != Token.Id.LBracket) {
	1170	putBackToken(&tok_it, &tree);
	1171	continue;
	1172	}
	1173
	1174	const node = try createNode(arena, ast.Node.AsmOutput,
	1175	ast.Node.AsmOutput {
	1176	.base = undefined,
	1177	.symbolic_name = undefined,
	1178	.constraint = undefined,
	1179	.kind = undefined,
	1180	}
	1181	);
	1182	try items.push(node);
	1183
	1184	stack.append(State { .AsmOutputItems = items }) catch unreachable;
	1185	try stack.append(State { .IfToken = Token.Id.Comma });
	1186	try stack.append(State { .ExpectToken = Token.Id.RParen });
	1187	try stack.append(State { .AsmOutputReturnOrType = node });
	1188	try stack.append(State { .ExpectToken = Token.Id.LParen });
	1189	try stack.append(State { .StringLiteral = OptionalCtx { .Required = &node.constraint } });
	1190	try stack.append(State { .ExpectToken = Token.Id.RBracket });
	1191	try stack.append(State { .Identifier = OptionalCtx { .Required = &node.symbolic_name } });
	1192	continue;
	1193	},
	1194	State.AsmOutputReturnOrType => \|node\| {
	1195	const token = nextToken(&tok_it, &tree);
	1196	const token_index = token.index;
	1197	const token_ptr = token.ptr;
	1198	switch (token_ptr.id) {
	1199	Token.Id.Identifier => {
	1200	node.kind = ast.Node.AsmOutput.Kind { .Variable = try createLiteral(arena, ast.Node.Identifier, token_index) };
	1201	continue;
	1202	},
	1203	Token.Id.Arrow => {
	1204	node.kind = ast.Node.AsmOutput.Kind { .Return = undefined };
	1205	try stack.append(State { .TypeExprBegin = OptionalCtx { .Required = &node.kind.Return } });
	1206	continue;
	1207	},
	1208	else => {
	1209	*(try tree.errors.addOne()) = Error {
	1210	.ExpectedAsmOutputReturnOrType = Error.ExpectedAsmOutputReturnOrType {
	1211	.token = token_index,
	1212	},
	1213	};
	1214	return tree;
	1215	},
	1216	}
	1217	},
	1218	State.AsmInputItems => \|items\| {
	1219	const lbracket = nextToken(&tok_it, &tree);
	1220	const lbracket_index = lbracket.index;
	1221	const lbracket_ptr = lbracket.ptr;
	1222	if (lbracket_ptr.id != Token.Id.LBracket) {
	1223	putBackToken(&tok_it, &tree);
	1224	continue;
	1225	}
	1226
	1227	const node = try createNode(arena, ast.Node.AsmInput,
	1228	ast.Node.AsmInput {
	1229	.base = undefined,
	1230	.symbolic_name = undefined,
	1231	.constraint = undefined,
	1232	.expr = undefined,
	1233	}
	1234	);
	1235	try items.push(node);
	1236
	1237	stack.append(State { .AsmInputItems = items }) catch unreachable;
	1238	try stack.append(State { .IfToken = Token.Id.Comma });
	1239	try stack.append(State { .ExpectToken = Token.Id.RParen });
	1240	try stack.append(State { .Expression = OptionalCtx { .Required = &node.expr } });
	1241	try stack.append(State { .ExpectToken = Token.Id.LParen });
	1242	try stack.append(State { .StringLiteral = OptionalCtx { .Required = &node.constraint } });
	1243	try stack.append(State { .ExpectToken = Token.Id.RBracket });
	1244	try stack.append(State { .Identifier = OptionalCtx { .Required = &node.symbolic_name } });
	1245	continue;
	1246	},
	1247	State.AsmClobberItems => \|items\| {
	1248	stack.append(State { .AsmClobberItems = items }) catch unreachable;
	1249	try stack.append(State { .IfToken = Token.Id.Comma });
	1250	try stack.append(State { .StringLiteral = OptionalCtx { .Required = try items.addOne() } });
	1251	continue;
	1252	},
	1253
	1254
	1255	State.ExprListItemOrEnd => \|list_state\| {
	1256	if (eatToken(&tok_it, &tree, list_state.end)) \|token_index\| {
	1257	*list_state.ptr = token_index;
	1258	continue;
	1259	}
	1260
	1261	stack.append(State { .ExprListCommaOrEnd = list_state }) catch unreachable;
	1262	try stack.append(State { .Expression = OptionalCtx { .Required = try list_state.list.addOne() } });
	1263	continue;
	1264	},
	1265	State.ExprListCommaOrEnd => \|list_state\| {
	1266	switch (expectCommaOrEnd(&tok_it, &tree, list_state.end)) {
	1267	ExpectCommaOrEndResult.end_token => \|maybe_end\| if (maybe_end) \|end\| {
	1268	*list_state.ptr = end;
	1269	continue;
	1270	} else {
	1271	stack.append(State { .ExprListItemOrEnd = list_state }) catch unreachable;
	1272	continue;
	1273	},
	1274	ExpectCommaOrEndResult.parse_error => \|e\| {
	1275	try tree.errors.push(e);
	1276	return tree;
	1277	},
	1278	}
	1279	},
	1280	State.FieldInitListItemOrEnd => \|list_state\| {
	1281	while (try eatLineComment(arena, &tok_it, &tree)) \|line_comment\| {
	1282	try list_state.list.push(&line_comment.base);
	1283	}
	1284
	1285	if (eatToken(&tok_it, &tree, Token.Id.RBrace)) \|rbrace\| {
	1286	*list_state.ptr = rbrace;
	1287	continue;
	1288	}
	1289
	1290	const node = try arena.construct(ast.Node.FieldInitializer {
	1291	.base = ast.Node {
	1292	.id = ast.Node.Id.FieldInitializer,
	1293	},
	1294	.period_token = undefined,
	1295	.name_token = undefined,
	1296	.expr = undefined,
	1297	});
	1298	try list_state.list.push(&node.base);
	1299
	1300	stack.append(State { .FieldInitListCommaOrEnd = list_state }) catch unreachable;
	1301	try stack.append(State { .Expression = OptionalCtx{ .Required = &node.expr } });
	1302	try stack.append(State { .ExpectToken = Token.Id.Equal });
	1303	try stack.append(State {
	1304	.ExpectTokenSave = ExpectTokenSave {
	1305	.id = Token.Id.Identifier,
	1306	.ptr = &node.name_token,
	1307	}
	1308	});
	1309	try stack.append(State {
	1310	.ExpectTokenSave = ExpectTokenSave {
	1311	.id = Token.Id.Period,
	1312	.ptr = &node.period_token,
	1313	}
	1314	});
	1315	continue;
	1316	},
	1317	State.FieldInitListCommaOrEnd => \|list_state\| {
	1318	switch (expectCommaOrEnd(&tok_it, &tree, Token.Id.RBrace)) {
	1319	ExpectCommaOrEndResult.end_token => \|maybe_end\| if (maybe_end) \|end\| {
	1320	*list_state.ptr = end;
	1321	continue;
	1322	} else {
	1323	stack.append(State { .FieldInitListItemOrEnd = list_state }) catch unreachable;
	1324	continue;
	1325	},
	1326	ExpectCommaOrEndResult.parse_error => \|e\| {
	1327	try tree.errors.push(e);
	1328	return tree;
	1329	},
	1330	}
	1331	},
	1332	State.FieldListCommaOrEnd => \|container_decl\| {
	1333	switch (expectCommaOrEnd(&tok_it, &tree, Token.Id.RBrace)) {
	1334	ExpectCommaOrEndResult.end_token => \|maybe_end\| if (maybe_end) \|end\| {
	1335	container_decl.rbrace_token = end;
	1336	continue;
	1337	} else {
	1338	try stack.append(State { .ContainerDecl = container_decl });
	1339	continue;
	1340	},
	1341	ExpectCommaOrEndResult.parse_error => \|e\| {
	1342	try tree.errors.push(e);
	1343	return tree;
	1344	},
	1345	}
	1346	},
	1347	State.ErrorTagListItemOrEnd => \|list_state\| {
	1348	while (try eatLineComment(arena, &tok_it, &tree)) \|line_comment\| {
	1349	try list_state.list.push(&line_comment.base);
	1350	}
	1351
	1352	if (eatToken(&tok_it, &tree, Token.Id.RBrace)) \|rbrace\| {
	1353	*list_state.ptr = rbrace;
	1354	continue;
	1355	}
	1356
	1357	const node_ptr = try list_state.list.addOne();
	1358
	1359	try stack.append(State { .ErrorTagListCommaOrEnd = list_state });
	1360	try stack.append(State { .ErrorTag = node_ptr });
	1361	continue;
	1362	},
	1363	State.ErrorTagListCommaOrEnd => \|list_state\| {
	1364	switch (expectCommaOrEnd(&tok_it, &tree, Token.Id.RBrace)) {
	1365	ExpectCommaOrEndResult.end_token => \|maybe_end\| if (maybe_end) \|end\| {
	1366	*list_state.ptr = end;
	1367	continue;
	1368	} else {
	1369	stack.append(State { .ErrorTagListItemOrEnd = list_state }) catch unreachable;
	1370	continue;
	1371	},
	1372	ExpectCommaOrEndResult.parse_error => \|e\| {
	1373	try tree.errors.push(e);
	1374	return tree;
	1375	},
	1376	}
	1377	},
	1378	State.SwitchCaseOrEnd => \|list_state\| {
	1379	while (try eatLineComment(arena, &tok_it, &tree)) \|line_comment\| {
	1380	try list_state.list.push(&line_comment.base);
	1381	}
	1382
	1383	if (eatToken(&tok_it, &tree, Token.Id.RBrace)) \|rbrace\| {
	1384	*list_state.ptr = rbrace;
	1385	continue;
	1386	}
	1387
	1388	const comments = try eatDocComments(arena, &tok_it, &tree);
	1389	const node = try arena.construct(ast.Node.SwitchCase {
	1390	.base = ast.Node {
	1391	.id = ast.Node.Id.SwitchCase,
	1392	},
	1393	.items = ast.Node.SwitchCase.ItemList.init(arena),
	1394	.payload = null,
	1395	.expr = undefined,
	1396	});
	1397	try list_state.list.push(&node.base);
	1398	try stack.append(State { .SwitchCaseCommaOrEnd = list_state });
	1399	try stack.append(State { .AssignmentExpressionBegin = OptionalCtx { .Required = &node.expr } });
	1400	try stack.append(State { .PointerPayload = OptionalCtx { .Optional = &node.payload } });
	1401	try stack.append(State { .SwitchCaseFirstItem = &node.items });
	1402
	1403	continue;
	1404	},
	1405
	1406	State.SwitchCaseCommaOrEnd => \|list_state\| {
	1407	switch (expectCommaOrEnd(&tok_it, &tree, Token.Id.RParen)) {
	1408	ExpectCommaOrEndResult.end_token => \|maybe_end\| if (maybe_end) \|end\| {
	1409	*list_state.ptr = end;
	1410	continue;
	1411	} else {
	1412	try stack.append(State { .SwitchCaseOrEnd = list_state });
	1413	continue;
	1414	},
	1415	ExpectCommaOrEndResult.parse_error => \|e\| {
	1416	try tree.errors.push(e);
	1417	return tree;
	1418	},
	1419	}
	1420	},
	1421
	1422	State.SwitchCaseFirstItem => \|case_items\| {
	1423	const token = nextToken(&tok_it, &tree);
	1424	const token_index = token.index;
	1425	const token_ptr = token.ptr;
	1426	if (token_ptr.id == Token.Id.Keyword_else) {
	1427	const else_node = try arena.construct(ast.Node.SwitchElse {
	1428	.base = ast.Node{ .id = ast.Node.Id.SwitchElse},
	1429	.token = token_index,
	1430	});
	1431	try case_items.push(&else_node.base);
	1432
	1433	try stack.append(State { .ExpectToken = Token.Id.EqualAngleBracketRight });
	1434	continue;
	1435	} else {
	1436	putBackToken(&tok_it, &tree);
	1437	try stack.append(State { .SwitchCaseItem = case_items });
	1438	continue;
	1439	}
	1440	},
	1441	State.SwitchCaseItem => \|case_items\| {
	1442	stack.append(State { .SwitchCaseItemCommaOrEnd = case_items }) catch unreachable;
	1443	try stack.append(State { .RangeExpressionBegin = OptionalCtx { .Required = try case_items.addOne() } });
	1444	},
	1445	State.SwitchCaseItemCommaOrEnd => \|case_items\| {
	1446	switch (expectCommaOrEnd(&tok_it, &tree, Token.Id.EqualAngleBracketRight)) {
	1447	ExpectCommaOrEndResult.end_token => \|t\| {
	1448	if (t == null) {
	1449	stack.append(State { .SwitchCaseItem = case_items }) catch unreachable;
	1450	}
	1451	continue;
	1452	},
	1453	ExpectCommaOrEndResult.parse_error => \|e\| {
	1454	try tree.errors.push(e);
	1455	return tree;
	1456	},
	1457	}
	1458	continue;
	1459	},
	1460
	1461
	1462	State.SuspendBody => \|suspend_node\| {
	1463	if (suspend_node.payload != null) {
	1464	try stack.append(State { .AssignmentExpressionBegin = OptionalCtx { .RequiredNull = &suspend_node.body } });
	1465	}
	1466	continue;
	1467	},
	1468	State.AsyncAllocator => \|async_node\| {
	1469	if (eatToken(&tok_it, &tree, Token.Id.AngleBracketLeft) == null) {
	1470	continue;
	1471	}
	1472
	1473	async_node.rangle_bracket = TokenIndex(0);
	1474	try stack.append(State {
	1475	.ExpectTokenSave = ExpectTokenSave {
	1476	.id = Token.Id.AngleBracketRight,
	1477	.ptr = &??async_node.rangle_bracket,
	1478	}
	1479	});
	1480	try stack.append(State { .TypeExprBegin = OptionalCtx { .RequiredNull = &async_node.allocator_type } });
	1481	continue;
	1482	},
	1483	State.AsyncEnd => \|ctx\| {
	1484	const node = ctx.ctx.get() ?? continue;
	1485
	1486	switch (node.id) {
	1487	ast.Node.Id.FnProto => {
	1488	const fn_proto = @fieldParentPtr(ast.Node.FnProto, "base", node);
	1489	fn_proto.async_attr = ctx.attribute;
	1490	continue;
	1491	},
	1492	ast.Node.Id.SuffixOp => {
	1493	const suffix_op = @fieldParentPtr(ast.Node.SuffixOp, "base", node);
	1494	if (suffix_op.op == @TagType(ast.Node.SuffixOp.Op).Call) {
	1495	suffix_op.op.Call.async_attr = ctx.attribute;
	1496	continue;
	1497	}
	1498
	1499	*(try tree.errors.addOne()) = Error {
	1500	.ExpectedCall = Error.ExpectedCall { .node = node },
	1501	};
	1502	return tree;
	1503	},
	1504	else => {
	1505	*(try tree.errors.addOne()) = Error {
	1506	.ExpectedCallOrFnProto = Error.ExpectedCallOrFnProto { .node = node },
	1507	};
	1508	return tree;
	1509	}
	1510	}
	1511	},
	1512
	1513
	1514	State.ExternType => \|ctx\| {
	1515	if (eatToken(&tok_it, &tree, Token.Id.Keyword_fn)) \|fn_token\| {
	1516	const fn_proto = try arena.construct(ast.Node.FnProto {
	1517	.base = ast.Node {
	1518	.id = ast.Node.Id.FnProto,
	1519	},
	1520	.doc_comments = ctx.comments,
	1521	.visib_token = null,
	1522	.name_token = null,
	1523	.fn_token = fn_token,
	1524	.params = ast.Node.FnProto.ParamList.init(arena),
	1525	.return_type = undefined,
	1526	.var_args_token = null,
	1527	.extern_export_inline_token = ctx.extern_token,
	1528	.cc_token = null,
	1529	.async_attr = null,
	1530	.body_node = null,
	1531	.lib_name = null,
	1532	.align_expr = null,
	1533	});
	1534	ctx.opt_ctx.store(&fn_proto.base);
	1535	stack.append(State { .FnProto = fn_proto }) catch unreachable;
	1536	continue;
	1537	}
	1538
	1539	stack.append(State {
	1540	.ContainerKind = ContainerKindCtx {
	1541	.opt_ctx = ctx.opt_ctx,
	1542	.ltoken = ctx.extern_token,
	1543	.layout = ast.Node.ContainerDecl.Layout.Extern,
	1544	},
	1545	}) catch unreachable;
	1546	continue;
	1547	},
	1548	State.SliceOrArrayAccess => \|node\| {
	1549	const token = nextToken(&tok_it, &tree);
	1550	const token_index = token.index;
	1551	const token_ptr = token.ptr;
	1552	switch (token_ptr.id) {
	1553	Token.Id.Ellipsis2 => {
	1554	const start = node.op.ArrayAccess;
	1555	node.op = ast.Node.SuffixOp.Op {
	1556	.Slice = ast.Node.SuffixOp.Op.Slice {
	1557	.start = start,
	1558	.end = null,
	1559	}
	1560	};
	1561
	1562	stack.append(State {
	1563	.ExpectTokenSave = ExpectTokenSave {
	1564	.id = Token.Id.RBracket,
	1565	.ptr = &node.rtoken,
	1566	}
	1567	}) catch unreachable;
	1568	try stack.append(State { .Expression = OptionalCtx { .Optional = &node.op.Slice.end } });
	1569	continue;
	1570	},
	1571	Token.Id.RBracket => {
	1572	node.rtoken = token_index;
	1573	continue;
	1574	},
	1575	else => {
	1576	*(try tree.errors.addOne()) = Error {
	1577	.ExpectedSliceOrRBracket = Error.ExpectedSliceOrRBracket { .token = token_index },
	1578	};
	1579	return tree;
	1580	}
	1581	}
	1582	},
	1583	State.SliceOrArrayType => \|node\| {
	1584	if (eatToken(&tok_it, &tree, Token.Id.RBracket)) \|_\| {
	1585	node.op = ast.Node.PrefixOp.Op {
	1586	.SliceType = ast.Node.PrefixOp.AddrOfInfo {
	1587	.align_expr = null,
	1588	.bit_offset_start_token = null,
	1589	.bit_offset_end_token = null,
	1590	.const_token = null,
	1591	.volatile_token = null,
	1592	}
	1593	};
	1594	stack.append(State { .TypeExprBegin = OptionalCtx { .Required = &node.rhs } }) catch unreachable;
	1595	try stack.append(State { .AddrOfModifiers = &node.op.SliceType });
	1596	continue;
	1597	}
	1598
	1599	node.op = ast.Node.PrefixOp.Op { .ArrayType = undefined };
	1600	stack.append(State { .TypeExprBegin = OptionalCtx { .Required = &node.rhs } }) catch unreachable;
	1601	try stack.append(State { .ExpectToken = Token.Id.RBracket });
	1602	try stack.append(State { .Expression = OptionalCtx { .Required = &node.op.ArrayType } });
	1603	continue;
	1604	},
	1605	State.AddrOfModifiers => \|addr_of_info\| {
	1606	const token = nextToken(&tok_it, &tree);
	1607	const token_index = token.index;
	1608	const token_ptr = token.ptr;
	1609	switch (token_ptr.id) {
	1610	Token.Id.Keyword_align => {
	1611	stack.append(state) catch unreachable;
	1612	if (addr_of_info.align_expr != null) {
	1613	*(try tree.errors.addOne()) = Error {
	1614	.ExtraAlignQualifier = Error.ExtraAlignQualifier { .token = token_index },
	1615	};
	1616	return tree;
	1617	}
	1618	try stack.append(State { .ExpectToken = Token.Id.RParen });
	1619	try stack.append(State { .Expression = OptionalCtx { .RequiredNull = &addr_of_info.align_expr} });
	1620	try stack.append(State { .ExpectToken = Token.Id.LParen });
	1621	continue;
	1622	},
	1623	Token.Id.Keyword_const => {
	1624	stack.append(state) catch unreachable;
	1625	if (addr_of_info.const_token != null) {
	1626	*(try tree.errors.addOne()) = Error {
	1627	.ExtraConstQualifier = Error.ExtraConstQualifier { .token = token_index },
	1628	};
	1629	return tree;
	1630	}
	1631	addr_of_info.const_token = token_index;
	1632	continue;
	1633	},
	1634	Token.Id.Keyword_volatile => {
	1635	stack.append(state) catch unreachable;
	1636	if (addr_of_info.volatile_token != null) {
	1637	*(try tree.errors.addOne()) = Error {
	1638	.ExtraVolatileQualifier = Error.ExtraVolatileQualifier { .token = token_index },
	1639	};
	1640	return tree;
	1641	}
	1642	addr_of_info.volatile_token = token_index;
	1643	continue;
	1644	},
	1645	else => {
	1646	putBackToken(&tok_it, &tree);
	1647	continue;
	1648	},
	1649	}
	1650	},
	1651
	1652
	1653	State.Payload => \|opt_ctx\| {
	1654	const token = nextToken(&tok_it, &tree);
	1655	const token_index = token.index;
	1656	const token_ptr = token.ptr;
	1657	if (token_ptr.id != Token.Id.Pipe) {
	1658	if (opt_ctx != OptionalCtx.Optional) {
	1659	*(try tree.errors.addOne()) = Error {
	1660	.ExpectedToken = Error.ExpectedToken {
	1661	.token = token_index,
	1662	.expected_id = Token.Id.Pipe,
	1663	},
	1664	};
	1665	return tree;
	1666	}
	1667
	1668	putBackToken(&tok_it, &tree);
	1669	continue;
	1670	}
	1671
	1672	const node = try createToCtxNode(arena, opt_ctx, ast.Node.Payload,
	1673	ast.Node.Payload {
	1674	.base = undefined,
	1675	.lpipe = token_index,
	1676	.error_symbol = undefined,
	1677	.rpipe = undefined
	1678	}
	1679	);
	1680
	1681	stack.append(State {
	1682	.ExpectTokenSave = ExpectTokenSave {
	1683	.id = Token.Id.Pipe,
	1684	.ptr = &node.rpipe,
	1685	}
	1686	}) catch unreachable;
	1687	try stack.append(State { .Identifier = OptionalCtx { .Required = &node.error_symbol } });
	1688	continue;
	1689	},
	1690	State.PointerPayload => \|opt_ctx\| {
	1691	const token = nextToken(&tok_it, &tree);
	1692	const token_index = token.index;
	1693	const token_ptr = token.ptr;
	1694	if (token_ptr.id != Token.Id.Pipe) {
	1695	if (opt_ctx != OptionalCtx.Optional) {
	1696	*(try tree.errors.addOne()) = Error {
	1697	.ExpectedToken = Error.ExpectedToken {
	1698	.token = token_index,
	1699	.expected_id = Token.Id.Pipe,
	1700	},
	1701	};
	1702	return tree;
	1703	}
	1704
	1705	putBackToken(&tok_it, &tree);
	1706	continue;
	1707	}
	1708
	1709	const node = try createToCtxNode(arena, opt_ctx, ast.Node.PointerPayload,
	1710	ast.Node.PointerPayload {
	1711	.base = undefined,
	1712	.lpipe = token_index,
	1713	.ptr_token = null,
	1714	.value_symbol = undefined,
	1715	.rpipe = undefined
	1716	}
	1717	);
	1718
	1719	try stack.append(State {
	1720	.ExpectTokenSave = ExpectTokenSave {
	1721	.id = Token.Id.Pipe,
	1722	.ptr = &node.rpipe,
	1723	}
	1724	});
	1725	try stack.append(State { .Identifier = OptionalCtx { .Required = &node.value_symbol } });
	1726	try stack.append(State {
	1727	.OptionalTokenSave = OptionalTokenSave {
	1728	.id = Token.Id.Asterisk,
	1729	.ptr = &node.ptr_token,
	1730	}
	1731	});
	1732	continue;
	1733	},
	1734	State.PointerIndexPayload => \|opt_ctx\| {
	1735	const token = nextToken(&tok_it, &tree);
	1736	const token_index = token.index;
	1737	const token_ptr = token.ptr;
	1738	if (token_ptr.id != Token.Id.Pipe) {
	1739	if (opt_ctx != OptionalCtx.Optional) {
	1740	*(try tree.errors.addOne()) = Error {
	1741	.ExpectedToken = Error.ExpectedToken {
	1742	.token = token_index,
	1743	.expected_id = Token.Id.Pipe,
	1744	},
	1745	};
	1746	return tree;
	1747	}
	1748
	1749	putBackToken(&tok_it, &tree);
	1750	continue;
	1751	}
	1752
	1753	const node = try createToCtxNode(arena, opt_ctx, ast.Node.PointerIndexPayload,
	1754	ast.Node.PointerIndexPayload {
	1755	.base = undefined,
	1756	.lpipe = token_index,
	1757	.ptr_token = null,
	1758	.value_symbol = undefined,
	1759	.index_symbol = null,
	1760	.rpipe = undefined
	1761	}
	1762	);
	1763
	1764	stack.append(State {
	1765	.ExpectTokenSave = ExpectTokenSave {
	1766	.id = Token.Id.Pipe,
	1767	.ptr = &node.rpipe,
	1768	}
	1769	}) catch unreachable;
	1770	try stack.append(State { .Identifier = OptionalCtx { .RequiredNull = &node.index_symbol } });
	1771	try stack.append(State { .IfToken = Token.Id.Comma });
	1772	try stack.append(State { .Identifier = OptionalCtx { .Required = &node.value_symbol } });
	1773	try stack.append(State {
	1774	.OptionalTokenSave = OptionalTokenSave {
	1775	.id = Token.Id.Asterisk,
	1776	.ptr = &node.ptr_token,
	1777	}
	1778	});
	1779	continue;
	1780	},
	1781
	1782
	1783	State.Expression => \|opt_ctx\| {
	1784	const token = nextToken(&tok_it, &tree);
	1785	const token_index = token.index;
	1786	const token_ptr = token.ptr;
	1787	switch (token_ptr.id) {
	1788	Token.Id.Keyword_return, Token.Id.Keyword_break, Token.Id.Keyword_continue => {
	1789	const node = try createToCtxNode(arena, opt_ctx, ast.Node.ControlFlowExpression,
	1790	ast.Node.ControlFlowExpression {
	1791	.base = undefined,
	1792	.ltoken = token_index,
	1793	.kind = undefined,
	1794	.rhs = null,
	1795	}
	1796	);
	1797
	1798	stack.append(State { .Expression = OptionalCtx { .Optional = &node.rhs } }) catch unreachable;
	1799
	1800	switch (token_ptr.id) {
	1801	Token.Id.Keyword_break => {
	1802	node.kind = ast.Node.ControlFlowExpression.Kind { .Break = null };
	1803	try stack.append(State { .Identifier = OptionalCtx { .RequiredNull = &node.kind.Break } });
	1804	try stack.append(State { .IfToken = Token.Id.Colon });
	1805	},
	1806	Token.Id.Keyword_continue => {
	1807	node.kind = ast.Node.ControlFlowExpression.Kind { .Continue = null };
	1808	try stack.append(State { .Identifier = OptionalCtx { .RequiredNull = &node.kind.Continue } });
	1809	try stack.append(State { .IfToken = Token.Id.Colon });
	1810	},
	1811	Token.Id.Keyword_return => {
	1812	node.kind = ast.Node.ControlFlowExpression.Kind.Return;
	1813	},
	1814	else => unreachable,
	1815	}
	1816	continue;
	1817	},
	1818	Token.Id.Keyword_try, Token.Id.Keyword_cancel, Token.Id.Keyword_resume => {
	1819	const node = try createToCtxNode(arena, opt_ctx, ast.Node.PrefixOp,
	1820	ast.Node.PrefixOp {
	1821	.base = undefined,
	1822	.op_token = token_index,
	1823	.op = switch (token_ptr.id) {
	1824	Token.Id.Keyword_try => ast.Node.PrefixOp.Op { .Try = void{} },
	1825	Token.Id.Keyword_cancel => ast.Node.PrefixOp.Op { .Cancel = void{} },
	1826	Token.Id.Keyword_resume => ast.Node.PrefixOp.Op { .Resume = void{} },
	1827	else => unreachable,
	1828	},
	1829	.rhs = undefined,
	1830	}
	1831	);
	1832
	1833	stack.append(State { .Expression = OptionalCtx { .Required = &node.rhs } }) catch unreachable;
	1834	continue;
	1835	},
	1836	else => {
	1837	if (!try parseBlockExpr(&stack, arena, opt_ctx, token_ptr, token_index)) {
	1838	putBackToken(&tok_it, &tree);
	1839	stack.append(State { .UnwrapExpressionBegin = opt_ctx }) catch unreachable;
	1840	}
	1841	continue;
	1842	}
	1843	}
	1844	},
	1845	State.RangeExpressionBegin => \|opt_ctx\| {
	1846	stack.append(State { .RangeExpressionEnd = opt_ctx }) catch unreachable;
	1847	try stack.append(State { .Expression = opt_ctx });
	1848	continue;
	1849	},
	1850	State.RangeExpressionEnd => \|opt_ctx\| {
	1851	const lhs = opt_ctx.get() ?? continue;
	1852
	1853	if (eatToken(&tok_it, &tree, Token.Id.Ellipsis3)) \|ellipsis3\| {
	1854	const node = try createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
	1855	ast.Node.InfixOp {
	1856	.base = undefined,
	1857	.lhs = lhs,
	1858	.op_token = ellipsis3,
	1859	.op = ast.Node.InfixOp.Op.Range,
	1860	.rhs = undefined,
	1861	}
	1862	);
	1863	stack.append(State { .Expression = OptionalCtx { .Required = &node.rhs } }) catch unreachable;
	1864	continue;
	1865	}
	1866	},
	1867	State.AssignmentExpressionBegin => \|opt_ctx\| {
	1868	stack.append(State { .AssignmentExpressionEnd = opt_ctx }) catch unreachable;
	1869	try stack.append(State { .Expression = opt_ctx });
	1870	continue;
	1871	},
	1872
	1873	State.AssignmentExpressionEnd => \|opt_ctx\| {
	1874	const lhs = opt_ctx.get() ?? continue;
	1875
	1876	const token = nextToken(&tok_it, &tree);
	1877	const token_index = token.index;
	1878	const token_ptr = token.ptr;
	1879	if (tokenIdToAssignment(token_ptr.id)) \|ass_id\| {
	1880	const node = try createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
	1881	ast.Node.InfixOp {
	1882	.base = undefined,
	1883	.lhs = lhs,
	1884	.op_token = token_index,
	1885	.op = ass_id,
	1886	.rhs = undefined,
	1887	}
	1888	);
	1889	stack.append(State { .AssignmentExpressionEnd = opt_ctx.toRequired() }) catch unreachable;
	1890	try stack.append(State { .Expression = OptionalCtx { .Required = &node.rhs } });
	1891	continue;
	1892	} else {
	1893	putBackToken(&tok_it, &tree);
	1894	continue;
	1895	}
	1896	},
	1897
	1898	State.UnwrapExpressionBegin => \|opt_ctx\| {
	1899	stack.append(State { .UnwrapExpressionEnd = opt_ctx }) catch unreachable;
	1900	try stack.append(State { .BoolOrExpressionBegin = opt_ctx });
	1901	continue;
	1902	},
	1903
	1904	State.UnwrapExpressionEnd => \|opt_ctx\| {
	1905	const lhs = opt_ctx.get() ?? continue;
	1906
	1907	const token = nextToken(&tok_it, &tree);
	1908	const token_index = token.index;
	1909	const token_ptr = token.ptr;
	1910	if (tokenIdToUnwrapExpr(token_ptr.id)) \|unwrap_id\| {
	1911	const node = try createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
	1912	ast.Node.InfixOp {
	1913	.base = undefined,
	1914	.lhs = lhs,
	1915	.op_token = token_index,
	1916	.op = unwrap_id,
	1917	.rhs = undefined,
	1918	}
	1919	);
	1920
	1921	stack.append(State { .UnwrapExpressionEnd = opt_ctx.toRequired() }) catch unreachable;
	1922	try stack.append(State { .Expression = OptionalCtx { .Required = &node.rhs } });
	1923
	1924	if (node.op == ast.Node.InfixOp.Op.Catch) {
	1925	try stack.append(State { .Payload = OptionalCtx { .Optional = &node.op.Catch } });
	1926	}
	1927	continue;
	1928	} else {
	1929	putBackToken(&tok_it, &tree);
	1930	continue;
	1931	}
	1932	},
	1933
	1934	State.BoolOrExpressionBegin => \|opt_ctx\| {
	1935	stack.append(State { .BoolOrExpressionEnd = opt_ctx }) catch unreachable;
	1936	try stack.append(State { .BoolAndExpressionBegin = opt_ctx });
	1937	continue;
	1938	},
	1939
	1940	State.BoolOrExpressionEnd => \|opt_ctx\| {
	1941	const lhs = opt_ctx.get() ?? continue;
	1942
	1943	if (eatToken(&tok_it, &tree, Token.Id.Keyword_or)) \|or_token\| {
	1944	const node = try createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
	1945	ast.Node.InfixOp {
	1946	.base = undefined,
	1947	.lhs = lhs,
	1948	.op_token = or_token,
	1949	.op = ast.Node.InfixOp.Op.BoolOr,
	1950	.rhs = undefined,
	1951	}
	1952	);
	1953	stack.append(State { .BoolOrExpressionEnd = opt_ctx.toRequired() }) catch unreachable;
	1954	try stack.append(State { .BoolAndExpressionBegin = OptionalCtx { .Required = &node.rhs } });
	1955	continue;
	1956	}
	1957	},
	1958
	1959	State.BoolAndExpressionBegin => \|opt_ctx\| {
	1960	stack.append(State { .BoolAndExpressionEnd = opt_ctx }) catch unreachable;
	1961	try stack.append(State { .ComparisonExpressionBegin = opt_ctx });
	1962	continue;
	1963	},
	1964
	1965	State.BoolAndExpressionEnd => \|opt_ctx\| {
	1966	const lhs = opt_ctx.get() ?? continue;
	1967
	1968	if (eatToken(&tok_it, &tree, Token.Id.Keyword_and)) \|and_token\| {
	1969	const node = try createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
	1970	ast.Node.InfixOp {
	1971	.base = undefined,
	1972	.lhs = lhs,
	1973	.op_token = and_token,
	1974	.op = ast.Node.InfixOp.Op.BoolAnd,
	1975	.rhs = undefined,
	1976	}
	1977	);
	1978	stack.append(State { .BoolAndExpressionEnd = opt_ctx.toRequired() }) catch unreachable;
	1979	try stack.append(State { .ComparisonExpressionBegin = OptionalCtx { .Required = &node.rhs } });
	1980	continue;
	1981	}
	1982	},
	1983
	1984	State.ComparisonExpressionBegin => \|opt_ctx\| {
	1985	stack.append(State { .ComparisonExpressionEnd = opt_ctx }) catch unreachable;
	1986	try stack.append(State { .BinaryOrExpressionBegin = opt_ctx });
	1987	continue;
	1988	},
	1989
	1990	State.ComparisonExpressionEnd => \|opt_ctx\| {
	1991	const lhs = opt_ctx.get() ?? continue;
	1992
	1993	const token = nextToken(&tok_it, &tree);
	1994	const token_index = token.index;
	1995	const token_ptr = token.ptr;
	1996	if (tokenIdToComparison(token_ptr.id)) \|comp_id\| {
	1997	const node = try createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
	1998	ast.Node.InfixOp {
	1999	.base = undefined,
	2000	.lhs = lhs,
	2001	.op_token = token_index,
	2002	.op = comp_id,
	2003	.rhs = undefined,
	2004	}
	2005	);
	2006	stack.append(State { .ComparisonExpressionEnd = opt_ctx.toRequired() }) catch unreachable;
	2007	try stack.append(State { .BinaryOrExpressionBegin = OptionalCtx { .Required = &node.rhs } });
	2008	continue;
	2009	} else {
	2010	putBackToken(&tok_it, &tree);
	2011	continue;
	2012	}
	2013	},
	2014
	2015	State.BinaryOrExpressionBegin => \|opt_ctx\| {
	2016	stack.append(State { .BinaryOrExpressionEnd = opt_ctx }) catch unreachable;
	2017	try stack.append(State { .BinaryXorExpressionBegin = opt_ctx });
	2018	continue;
	2019	},
	2020
	2021	State.BinaryOrExpressionEnd => \|opt_ctx\| {
	2022	const lhs = opt_ctx.get() ?? continue;
	2023
	2024	if (eatToken(&tok_it, &tree, Token.Id.Pipe)) \|pipe\| {
	2025	const node = try createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
	2026	ast.Node.InfixOp {
	2027	.base = undefined,
	2028	.lhs = lhs,
	2029	.op_token = pipe,
	2030	.op = ast.Node.InfixOp.Op.BitOr,
	2031	.rhs = undefined,
	2032	}
	2033	);
	2034	stack.append(State { .BinaryOrExpressionEnd = opt_ctx.toRequired() }) catch unreachable;
	2035	try stack.append(State { .BinaryXorExpressionBegin = OptionalCtx { .Required = &node.rhs } });
	2036	continue;
	2037	}
	2038	},
	2039
	2040	State.BinaryXorExpressionBegin => \|opt_ctx\| {
	2041	stack.append(State { .BinaryXorExpressionEnd = opt_ctx }) catch unreachable;
	2042	try stack.append(State { .BinaryAndExpressionBegin = opt_ctx });
	2043	continue;
	2044	},
	2045
	2046	State.BinaryXorExpressionEnd => \|opt_ctx\| {
	2047	const lhs = opt_ctx.get() ?? continue;
	2048
	2049	if (eatToken(&tok_it, &tree, Token.Id.Caret)) \|caret\| {
	2050	const node = try createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
	2051	ast.Node.InfixOp {
	2052	.base = undefined,
	2053	.lhs = lhs,
	2054	.op_token = caret,
	2055	.op = ast.Node.InfixOp.Op.BitXor,
	2056	.rhs = undefined,
	2057	}
	2058	);
	2059	stack.append(State { .BinaryXorExpressionEnd = opt_ctx.toRequired() }) catch unreachable;
	2060	try stack.append(State { .BinaryAndExpressionBegin = OptionalCtx { .Required = &node.rhs } });
	2061	continue;
	2062	}
	2063	},
	2064
	2065	State.BinaryAndExpressionBegin => \|opt_ctx\| {
	2066	stack.append(State { .BinaryAndExpressionEnd = opt_ctx }) catch unreachable;
	2067	try stack.append(State { .BitShiftExpressionBegin = opt_ctx });
	2068	continue;
	2069	},
	2070
	2071	State.BinaryAndExpressionEnd => \|opt_ctx\| {
	2072	const lhs = opt_ctx.get() ?? continue;
	2073
	2074	if (eatToken(&tok_it, &tree, Token.Id.Ampersand)) \|ampersand\| {
	2075	const node = try createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
	2076	ast.Node.InfixOp {
	2077	.base = undefined,
	2078	.lhs = lhs,
	2079	.op_token = ampersand,
	2080	.op = ast.Node.InfixOp.Op.BitAnd,
	2081	.rhs = undefined,
	2082	}
	2083	);
	2084	stack.append(State { .BinaryAndExpressionEnd = opt_ctx.toRequired() }) catch unreachable;
	2085	try stack.append(State { .BitShiftExpressionBegin = OptionalCtx { .Required = &node.rhs } });
	2086	continue;
	2087	}
	2088	},
	2089
	2090	State.BitShiftExpressionBegin => \|opt_ctx\| {
	2091	stack.append(State { .BitShiftExpressionEnd = opt_ctx }) catch unreachable;
	2092	try stack.append(State { .AdditionExpressionBegin = opt_ctx });
	2093	continue;
	2094	},
	2095
	2096	State.BitShiftExpressionEnd => \|opt_ctx\| {
	2097	const lhs = opt_ctx.get() ?? continue;
	2098
	2099	const token = nextToken(&tok_it, &tree);
	2100	const token_index = token.index;
	2101	const token_ptr = token.ptr;
	2102	if (tokenIdToBitShift(token_ptr.id)) \|bitshift_id\| {
	2103	const node = try createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
	2104	ast.Node.InfixOp {
	2105	.base = undefined,
	2106	.lhs = lhs,
	2107	.op_token = token_index,
	2108	.op = bitshift_id,
	2109	.rhs = undefined,
	2110	}
	2111	);
	2112	stack.append(State { .BitShiftExpressionEnd = opt_ctx.toRequired() }) catch unreachable;
	2113	try stack.append(State { .AdditionExpressionBegin = OptionalCtx { .Required = &node.rhs } });
	2114	continue;
	2115	} else {
	2116	putBackToken(&tok_it, &tree);
	2117	continue;
	2118	}
	2119	},
	2120
	2121	State.AdditionExpressionBegin => \|opt_ctx\| {
	2122	stack.append(State { .AdditionExpressionEnd = opt_ctx }) catch unreachable;
	2123	try stack.append(State { .MultiplyExpressionBegin = opt_ctx });
	2124	continue;
	2125	},
	2126
	2127	State.AdditionExpressionEnd => \|opt_ctx\| {
	2128	const lhs = opt_ctx.get() ?? continue;
	2129
	2130	const token = nextToken(&tok_it, &tree);
	2131	const token_index = token.index;
	2132	const token_ptr = token.ptr;
	2133	if (tokenIdToAddition(token_ptr.id)) \|add_id\| {
	2134	const node = try createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
	2135	ast.Node.InfixOp {
	2136	.base = undefined,
	2137	.lhs = lhs,
	2138	.op_token = token_index,
	2139	.op = add_id,
	2140	.rhs = undefined,
	2141	}
	2142	);
	2143	stack.append(State { .AdditionExpressionEnd = opt_ctx.toRequired() }) catch unreachable;
	2144	try stack.append(State { .MultiplyExpressionBegin = OptionalCtx { .Required = &node.rhs } });
	2145	continue;
	2146	} else {
	2147	putBackToken(&tok_it, &tree);
	2148	continue;
	2149	}
	2150	},
	2151
	2152	State.MultiplyExpressionBegin => \|opt_ctx\| {
	2153	stack.append(State { .MultiplyExpressionEnd = opt_ctx }) catch unreachable;
	2154	try stack.append(State { .CurlySuffixExpressionBegin = opt_ctx });
	2155	continue;
	2156	},
	2157
	2158	State.MultiplyExpressionEnd => \|opt_ctx\| {
	2159	const lhs = opt_ctx.get() ?? continue;
	2160
	2161	const token = nextToken(&tok_it, &tree);
	2162	const token_index = token.index;
	2163	const token_ptr = token.ptr;
	2164	if (tokenIdToMultiply(token_ptr.id)) \|mult_id\| {
	2165	const node = try createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
	2166	ast.Node.InfixOp {
	2167	.base = undefined,
	2168	.lhs = lhs,
	2169	.op_token = token_index,
	2170	.op = mult_id,
	2171	.rhs = undefined,
	2172	}
	2173	);
	2174	stack.append(State { .MultiplyExpressionEnd = opt_ctx.toRequired() }) catch unreachable;
	2175	try stack.append(State { .CurlySuffixExpressionBegin = OptionalCtx { .Required = &node.rhs } });
	2176	continue;
	2177	} else {
	2178	putBackToken(&tok_it, &tree);
	2179	continue;
	2180	}
	2181	},
	2182
	2183	State.CurlySuffixExpressionBegin => \|opt_ctx\| {
	2184	stack.append(State { .CurlySuffixExpressionEnd = opt_ctx }) catch unreachable;
	2185	try stack.append(State { .IfToken = Token.Id.LBrace });
	2186	try stack.append(State { .TypeExprBegin = opt_ctx });
	2187	continue;
	2188	},
	2189
	2190	State.CurlySuffixExpressionEnd => \|opt_ctx\| {
	2191	const lhs = opt_ctx.get() ?? continue;
	2192
	2193	if ((??tok_it.peek()).id == Token.Id.Period) {
	2194	const node = try arena.construct(ast.Node.SuffixOp {
	2195	.base = ast.Node { .id = ast.Node.Id.SuffixOp },
	2196	.lhs = lhs,
	2197	.op = ast.Node.SuffixOp.Op {
	2198	.StructInitializer = ast.Node.SuffixOp.Op.InitList.init(arena),
	2199	},
	2200	.rtoken = undefined,
	2201	});
	2202	opt_ctx.store(&node.base);
	2203
	2204	stack.append(State { .CurlySuffixExpressionEnd = opt_ctx.toRequired() }) catch unreachable;
	2205	try stack.append(State { .IfToken = Token.Id.LBrace });
	2206	try stack.append(State {
	2207	.FieldInitListItemOrEnd = ListSave(@typeOf(node.op.StructInitializer)) {
	2208	.list = &node.op.StructInitializer,
	2209	.ptr = &node.rtoken,
	2210	}
	2211	});
	2212	continue;
	2213	}
	2214
	2215	const node = try createToCtxNode(arena, opt_ctx, ast.Node.SuffixOp,
	2216	ast.Node.SuffixOp {
	2217	.base = undefined,
	2218	.lhs = lhs,
	2219	.op = ast.Node.SuffixOp.Op {
	2220	.ArrayInitializer = ast.Node.SuffixOp.Op.InitList.init(arena),
	2221	},
	2222	.rtoken = undefined,
	2223	}
	2224	);
	2225	stack.append(State { .CurlySuffixExpressionEnd = opt_ctx.toRequired() }) catch unreachable;
	2226	try stack.append(State { .IfToken = Token.Id.LBrace });
	2227	try stack.append(State {
	2228	.ExprListItemOrEnd = ExprListCtx {
	2229	.list = &node.op.ArrayInitializer,
	2230	.end = Token.Id.RBrace,
	2231	.ptr = &node.rtoken,
	2232	}
	2233	});
	2234	continue;
	2235	},
	2236
	2237	State.TypeExprBegin => \|opt_ctx\| {
	2238	stack.append(State { .TypeExprEnd = opt_ctx }) catch unreachable;
	2239	try stack.append(State { .PrefixOpExpression = opt_ctx });
	2240	continue;
	2241	},
	2242
	2243	State.TypeExprEnd => \|opt_ctx\| {
	2244	const lhs = opt_ctx.get() ?? continue;
	2245
	2246	if (eatToken(&tok_it, &tree, Token.Id.Bang)) \|bang\| {
	2247	const node = try createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
	2248	ast.Node.InfixOp {
	2249	.base = undefined,
	2250	.lhs = lhs,
	2251	.op_token = bang,
	2252	.op = ast.Node.InfixOp.Op.ErrorUnion,
	2253	.rhs = undefined,
	2254	}
	2255	);
	2256	stack.append(State { .TypeExprEnd = opt_ctx.toRequired() }) catch unreachable;
	2257	try stack.append(State { .PrefixOpExpression = OptionalCtx { .Required = &node.rhs } });
	2258	continue;
	2259	}
	2260	},
	2261
	2262	State.PrefixOpExpression => \|opt_ctx\| {
	2263	const token = nextToken(&tok_it, &tree);
	2264	const token_index = token.index;
	2265	const token_ptr = token.ptr;
	2266	if (tokenIdToPrefixOp(token_ptr.id)) \|prefix_id\| {
	2267	var node = try createToCtxNode(arena, opt_ctx, ast.Node.PrefixOp,
	2268	ast.Node.PrefixOp {
	2269	.base = undefined,
	2270	.op_token = token_index,
	2271	.op = prefix_id,
	2272	.rhs = undefined,
	2273	}
	2274	);
	2275
	2276	// Treat '**' token as two derefs
	2277	if (token_ptr.id == Token.Id.AsteriskAsterisk) {
	2278	const child = try createNode(arena, ast.Node.PrefixOp,
	2279	ast.Node.PrefixOp {
	2280	.base = undefined,
	2281	.op_token = token_index,
	2282	.op = prefix_id,
	2283	.rhs = undefined,
	2284	}
	2285	);
	2286	node.rhs = &child.base;
	2287	node = child;
	2288	}
	2289
	2290	stack.append(State { .TypeExprBegin = OptionalCtx { .Required = &node.rhs } }) catch unreachable;
	2291	if (node.op == ast.Node.PrefixOp.Op.AddrOf) {
	2292	try stack.append(State { .AddrOfModifiers = &node.op.AddrOf });
	2293	}
	2294	continue;
	2295	} else {
	2296	putBackToken(&tok_it, &tree);
	2297	stack.append(State { .SuffixOpExpressionBegin = opt_ctx }) catch unreachable;
	2298	continue;
	2299	}
	2300	},
	2301
	2302	State.SuffixOpExpressionBegin => \|opt_ctx\| {
	2303	if (eatToken(&tok_it, &tree, Token.Id.Keyword_async)) \|async_token\| {
	2304	const async_node = try createNode(arena, ast.Node.AsyncAttribute,
	2305	ast.Node.AsyncAttribute {
	2306	.base = undefined,
	2307	.async_token = async_token,
	2308	.allocator_type = null,
	2309	.rangle_bracket = null,
	2310	}
	2311	);
	2312	stack.append(State {
	2313	.AsyncEnd = AsyncEndCtx {
	2314	.ctx = opt_ctx,
	2315	.attribute = async_node,
	2316	}
	2317	}) catch unreachable;
	2318	try stack.append(State { .SuffixOpExpressionEnd = opt_ctx.toRequired() });
	2319	try stack.append(State { .PrimaryExpression = opt_ctx.toRequired() });
	2320	try stack.append(State { .AsyncAllocator = async_node });
	2321	continue;
	2322	}
	2323
	2324	stack.append(State { .SuffixOpExpressionEnd = opt_ctx }) catch unreachable;
	2325	try stack.append(State { .PrimaryExpression = opt_ctx });
	2326	continue;
	2327	},
	2328
	2329	State.SuffixOpExpressionEnd => \|opt_ctx\| {
	2330	const lhs = opt_ctx.get() ?? continue;
	2331
	2332	const token = nextToken(&tok_it, &tree);
	2333	const token_index = token.index;
	2334	const token_ptr = token.ptr;
	2335	switch (token_ptr.id) {
	2336	Token.Id.LParen => {
	2337	const node = try createToCtxNode(arena, opt_ctx, ast.Node.SuffixOp,
	2338	ast.Node.SuffixOp {
	2339	.base = undefined,
	2340	.lhs = lhs,
	2341	.op = ast.Node.SuffixOp.Op {
	2342	.Call = ast.Node.SuffixOp.Op.Call {
	2343	.params = ast.Node.SuffixOp.Op.Call.ParamList.init(arena),
	2344	.async_attr = null,
	2345	}
	2346	},
	2347	.rtoken = undefined,
	2348	}
	2349	);
	2350	stack.append(State { .SuffixOpExpressionEnd = opt_ctx.toRequired() }) catch unreachable;
	2351	try stack.append(State {
	2352	.ExprListItemOrEnd = ExprListCtx {
	2353	.list = &node.op.Call.params,
	2354	.end = Token.Id.RParen,
	2355	.ptr = &node.rtoken,
	2356	}
	2357	});
	2358	continue;
	2359	},
	2360	Token.Id.LBracket => {
	2361	const node = try createToCtxNode(arena, opt_ctx, ast.Node.SuffixOp,
	2362	ast.Node.SuffixOp {
	2363	.base = undefined,
	2364	.lhs = lhs,
	2365	.op = ast.Node.SuffixOp.Op {
	2366	.ArrayAccess = undefined,
	2367	},
	2368	.rtoken = undefined
	2369	}
	2370	);
	2371	stack.append(State { .SuffixOpExpressionEnd = opt_ctx.toRequired() }) catch unreachable;
	2372	try stack.append(State { .SliceOrArrayAccess = node });
	2373	try stack.append(State { .Expression = OptionalCtx { .Required = &node.op.ArrayAccess }});
	2374	continue;
	2375	},
	2376	Token.Id.Period => {
	2377	const node = try createToCtxNode(arena, opt_ctx, ast.Node.InfixOp,
	2378	ast.Node.InfixOp {
	2379	.base = undefined,
	2380	.lhs = lhs,
	2381	.op_token = token_index,
	2382	.op = ast.Node.InfixOp.Op.Period,
	2383	.rhs = undefined,
	2384	}
	2385	);
	2386	stack.append(State { .SuffixOpExpressionEnd = opt_ctx.toRequired() }) catch unreachable;
	2387	try stack.append(State { .Identifier = OptionalCtx { .Required = &node.rhs } });
	2388	continue;
	2389	},
	2390	else => {
	2391	putBackToken(&tok_it, &tree);
	2392	continue;
	2393	},
	2394	}
	2395	},
	2396
	2397	State.PrimaryExpression => \|opt_ctx\| {
	2398	const token = nextToken(&tok_it, &tree);
	2399	switch (token.ptr.id) {
	2400	Token.Id.IntegerLiteral => {
	2401	_ = try createToCtxLiteral(arena, opt_ctx, ast.Node.StringLiteral, token.index);
	2402	continue;
	2403	},
	2404	Token.Id.FloatLiteral => {
	2405	_ = try createToCtxLiteral(arena, opt_ctx, ast.Node.FloatLiteral, token.index);
	2406	continue;
	2407	},
	2408	Token.Id.CharLiteral => {
	2409	_ = try createToCtxLiteral(arena, opt_ctx, ast.Node.CharLiteral, token.index);
	2410	continue;
	2411	},
	2412	Token.Id.Keyword_undefined => {
	2413	_ = try createToCtxLiteral(arena, opt_ctx, ast.Node.UndefinedLiteral, token.index);
	2414	continue;
	2415	},
	2416	Token.Id.Keyword_true, Token.Id.Keyword_false => {
	2417	_ = try createToCtxLiteral(arena, opt_ctx, ast.Node.BoolLiteral, token.index);
	2418	continue;
	2419	},
	2420	Token.Id.Keyword_null => {
	2421	_ = try createToCtxLiteral(arena, opt_ctx, ast.Node.NullLiteral, token.index);
	2422	continue;
	2423	},
	2424	Token.Id.Keyword_this => {
	2425	_ = try createToCtxLiteral(arena, opt_ctx, ast.Node.ThisLiteral, token.index);
	2426	continue;
	2427	},
	2428	Token.Id.Keyword_var => {
	2429	_ = try createToCtxLiteral(arena, opt_ctx, ast.Node.VarType, token.index);
	2430	continue;
	2431	},
	2432	Token.Id.Keyword_unreachable => {
	2433	_ = try createToCtxLiteral(arena, opt_ctx, ast.Node.Unreachable, token.index);
	2434	continue;
	2435	},
	2436	Token.Id.Keyword_promise => {
	2437	const node = try arena.construct(ast.Node.PromiseType {
	2438	.base = ast.Node {
	2439	.id = ast.Node.Id.PromiseType,
	2440	},
	2441	.promise_token = token.index,
	2442	.result = null,
	2443	});
	2444	opt_ctx.store(&node.base);
	2445	const next_token = nextToken(&tok_it, &tree);
	2446	const next_token_index = next_token.index;
	2447	const next_token_ptr = next_token.ptr;
	2448	if (next_token_ptr.id != Token.Id.Arrow) {
	2449	putBackToken(&tok_it, &tree);
	2450	continue;
	2451	}
	2452	node.result = ast.Node.PromiseType.Result {
	2453	.arrow_token = next_token_index,
	2454	.return_type = undefined,
	2455	};
	2456	const return_type_ptr = &((??node.result).return_type);
	2457	try stack.append(State { .Expression = OptionalCtx { .Required = return_type_ptr, } });
	2458	continue;
	2459	},
	2460	Token.Id.StringLiteral, Token.Id.MultilineStringLiteralLine => {
	2461	opt_ctx.store((try parseStringLiteral(arena, &tok_it, token.ptr, token.index, &tree)) ?? unreachable);
	2462	continue;
	2463	},
	2464	Token.Id.LParen => {
	2465	const node = try createToCtxNode(arena, opt_ctx, ast.Node.GroupedExpression,
	2466	ast.Node.GroupedExpression {
	2467	.base = undefined,
	2468	.lparen = token.index,
	2469	.expr = undefined,
	2470	.rparen = undefined,
	2471	}
	2472	);
	2473	stack.append(State {
	2474	.ExpectTokenSave = ExpectTokenSave {
	2475	.id = Token.Id.RParen,
	2476	.ptr = &node.rparen,
	2477	}
	2478	}) catch unreachable;
	2479	try stack.append(State { .Expression = OptionalCtx { .Required = &node.expr } });
	2480	continue;
	2481	},
	2482	Token.Id.Builtin => {
	2483	const node = try createToCtxNode(arena, opt_ctx, ast.Node.BuiltinCall,
	2484	ast.Node.BuiltinCall {
	2485	.base = undefined,
	2486	.builtin_token = token.index,
	2487	.params = ast.Node.BuiltinCall.ParamList.init(arena),
	2488	.rparen_token = undefined,
	2489	}
	2490	);
	2491	stack.append(State {
	2492	.ExprListItemOrEnd = ExprListCtx {
	2493	.list = &node.params,
	2494	.end = Token.Id.RParen,
	2495	.ptr = &node.rparen_token,
	2496	}
	2497	}) catch unreachable;
	2498	try stack.append(State { .ExpectToken = Token.Id.LParen, });
	2499	continue;
	2500	},
	2501	Token.Id.LBracket => {
	2502	const node = try createToCtxNode(arena, opt_ctx, ast.Node.PrefixOp,
	2503	ast.Node.PrefixOp {
	2504	.base = undefined,
	2505	.op_token = token.index,
	2506	.op = undefined,
	2507	.rhs = undefined,
	2508	}
	2509	);
	2510	stack.append(State { .SliceOrArrayType = node }) catch unreachable;
	2511	continue;
	2512	},
	2513	Token.Id.Keyword_error => {
	2514	stack.append(State {
	2515	.ErrorTypeOrSetDecl = ErrorTypeOrSetDeclCtx {
	2516	.error_token = token.index,
	2517	.opt_ctx = opt_ctx
	2518	}
	2519	}) catch unreachable;
	2520	continue;
	2521	},
	2522	Token.Id.Keyword_packed => {
	2523	stack.append(State {
	2524	.ContainerKind = ContainerKindCtx {
	2525	.opt_ctx = opt_ctx,
	2526	.ltoken = token.index,
	2527	.layout = ast.Node.ContainerDecl.Layout.Packed,
	2528	},
	2529	}) catch unreachable;
	2530	continue;
	2531	},
	2532	Token.Id.Keyword_extern => {
	2533	stack.append(State {
	2534	.ExternType = ExternTypeCtx {
	2535	.opt_ctx = opt_ctx,
	2536	.extern_token = token.index,
	2537	.comments = null,
	2538	},
	2539	}) catch unreachable;
	2540	continue;
	2541	},
	2542	Token.Id.Keyword_struct, Token.Id.Keyword_union, Token.Id.Keyword_enum => {
	2543	putBackToken(&tok_it, &tree);
	2544	stack.append(State {
	2545	.ContainerKind = ContainerKindCtx {
	2546	.opt_ctx = opt_ctx,
	2547	.ltoken = token.index,
	2548	.layout = ast.Node.ContainerDecl.Layout.Auto,
	2549	},
	2550	}) catch unreachable;
	2551	continue;
	2552	},
	2553	Token.Id.Identifier => {
	2554	stack.append(State {
	2555	.MaybeLabeledExpression = MaybeLabeledExpressionCtx {
	2556	.label = token.index,
	2557	.opt_ctx = opt_ctx
	2558	}
	2559	}) catch unreachable;
	2560	continue;
	2561	},
	2562	Token.Id.Keyword_fn => {
	2563	const fn_proto = try arena.construct(ast.Node.FnProto {
	2564	.base = ast.Node {
	2565	.id = ast.Node.Id.FnProto,
	2566	},
	2567	.doc_comments = null,
	2568	.visib_token = null,
	2569	.name_token = null,
	2570	.fn_token = token.index,
	2571	.params = ast.Node.FnProto.ParamList.init(arena),
	2572	.return_type = undefined,
	2573	.var_args_token = null,
	2574	.extern_export_inline_token = null,
	2575	.cc_token = null,
	2576	.async_attr = null,
	2577	.body_node = null,
	2578	.lib_name = null,
	2579	.align_expr = null,
	2580	});
	2581	opt_ctx.store(&fn_proto.base);
	2582	stack.append(State { .FnProto = fn_proto }) catch unreachable;
	2583	continue;
	2584	},
	2585	Token.Id.Keyword_nakedcc, Token.Id.Keyword_stdcallcc => {
	2586	const fn_proto = try arena.construct(ast.Node.FnProto {
	2587	.base = ast.Node {
	2588	.id = ast.Node.Id.FnProto,
	2589	},
	2590	.doc_comments = null,
	2591	.visib_token = null,
	2592	.name_token = null,
	2593	.fn_token = undefined,
	2594	.params = ast.Node.FnProto.ParamList.init(arena),
	2595	.return_type = undefined,
	2596	.var_args_token = null,
	2597	.extern_export_inline_token = null,
	2598	.cc_token = token.index,
	2599	.async_attr = null,
	2600	.body_node = null,
	2601	.lib_name = null,
	2602	.align_expr = null,
	2603	});
	2604	opt_ctx.store(&fn_proto.base);
	2605	stack.append(State { .FnProto = fn_proto }) catch unreachable;
	2606	try stack.append(State {
	2607	.ExpectTokenSave = ExpectTokenSave {
	2608	.id = Token.Id.Keyword_fn,
	2609	.ptr = &fn_proto.fn_token
	2610	}
	2611	});
	2612	continue;
	2613	},
	2614	Token.Id.Keyword_asm => {
	2615	const node = try createToCtxNode(arena, opt_ctx, ast.Node.Asm,
	2616	ast.Node.Asm {
	2617	.base = undefined,
	2618	.asm_token = token.index,
	2619	.volatile_token = null,
	2620	.template = undefined,
	2621	.outputs = ast.Node.Asm.OutputList.init(arena),
	2622	.inputs = ast.Node.Asm.InputList.init(arena),
	2623	.clobbers = ast.Node.Asm.ClobberList.init(arena),
	2624	.rparen = undefined,
	2625	}
	2626	);
	2627	stack.append(State {
	2628	.ExpectTokenSave = ExpectTokenSave {
	2629	.id = Token.Id.RParen,
	2630	.ptr = &node.rparen,
	2631	}
	2632	}) catch unreachable;
	2633	try stack.append(State { .AsmClobberItems = &node.clobbers });
	2634	try stack.append(State { .IfToken = Token.Id.Colon });
	2635	try stack.append(State { .AsmInputItems = &node.inputs });
	2636	try stack.append(State { .IfToken = Token.Id.Colon });
	2637	try stack.append(State { .AsmOutputItems = &node.outputs });
	2638	try stack.append(State { .IfToken = Token.Id.Colon });
	2639	try stack.append(State { .StringLiteral = OptionalCtx { .Required = &node.template } });
	2640	try stack.append(State { .ExpectToken = Token.Id.LParen });
	2641	try stack.append(State {
	2642	.OptionalTokenSave = OptionalTokenSave {
	2643	.id = Token.Id.Keyword_volatile,
	2644	.ptr = &node.volatile_token,
	2645	}
	2646	});
	2647	},
	2648	Token.Id.Keyword_inline => {
	2649	stack.append(State {
	2650	.Inline = InlineCtx {
	2651	.label = null,
	2652	.inline_token = token.index,
	2653	.opt_ctx = opt_ctx,
	2654	}
	2655	}) catch unreachable;
	2656	continue;
	2657	},
	2658	else => {
	2659	if (!try parseBlockExpr(&stack, arena, opt_ctx, token.ptr, token.index)) {
	2660	putBackToken(&tok_it, &tree);
	2661	if (opt_ctx != OptionalCtx.Optional) {
	2662	*(try tree.errors.addOne()) = Error {
	2663	.ExpectedPrimaryExpr = Error.ExpectedPrimaryExpr { .token = token.index },
	2664	};
	2665	return tree;
	2666	}
	2667	}
	2668	continue;
	2669	}
	2670	}
	2671	},
	2672
	2673
	2674	State.ErrorTypeOrSetDecl => \|ctx\| {
	2675	if (eatToken(&tok_it, &tree, Token.Id.LBrace) == null) {
	2676	_ = try createToCtxLiteral(arena, ctx.opt_ctx, ast.Node.ErrorType, ctx.error_token);
	2677	continue;
	2678	}
	2679
	2680	const node = try arena.construct(ast.Node.ErrorSetDecl {
	2681	.base = ast.Node {
	2682	.id = ast.Node.Id.ErrorSetDecl,
	2683	},
	2684	.error_token = ctx.error_token,
	2685	.decls = ast.Node.ErrorSetDecl.DeclList.init(arena),
	2686	.rbrace_token = undefined,
	2687	});
	2688	ctx.opt_ctx.store(&node.base);
	2689
	2690	stack.append(State {
	2691	.ErrorTagListItemOrEnd = ListSave(@typeOf(node.decls)) {
	2692	.list = &node.decls,
	2693	.ptr = &node.rbrace_token,
	2694	}
	2695	}) catch unreachable;
	2696	continue;
	2697	},
	2698	State.StringLiteral => \|opt_ctx\| {
	2699	const token = nextToken(&tok_it, &tree);
	2700	const token_index = token.index;
	2701	const token_ptr = token.ptr;
	2702	opt_ctx.store(
	2703	(try parseStringLiteral(arena, &tok_it, token_ptr, token_index, &tree)) ?? {
	2704	putBackToken(&tok_it, &tree);
	2705	if (opt_ctx != OptionalCtx.Optional) {
	2706	*(try tree.errors.addOne()) = Error {
	2707	.ExpectedPrimaryExpr = Error.ExpectedPrimaryExpr { .token = token_index },
	2708	};
	2709	return tree;
	2710	}
	2711
	2712	continue;
	2713	}
	2714	);
	2715	},
	2716
	2717	State.Identifier => \|opt_ctx\| {
	2718	if (eatToken(&tok_it, &tree, Token.Id.Identifier)) \|ident_token\| {
	2719	_ = try createToCtxLiteral(arena, opt_ctx, ast.Node.Identifier, ident_token);
	2720	continue;
	2721	}
	2722
	2723	if (opt_ctx != OptionalCtx.Optional) {
	2724	const token = nextToken(&tok_it, &tree);
	2725	const token_index = token.index;
	2726	const token_ptr = token.ptr;
	2727	*(try tree.errors.addOne()) = Error {
	2728	.ExpectedToken = Error.ExpectedToken {
	2729	.token = token_index,
	2730	.expected_id = Token.Id.Identifier,
	2731	},
	2732	};
	2733	return tree;
	2734	}
	2735	},
	2736
	2737	State.ErrorTag => \|node_ptr\| {
	2738	const comments = try eatDocComments(arena, &tok_it, &tree);
	2739	const ident_token = nextToken(&tok_it, &tree);
	2740	const ident_token_index = ident_token.index;
	2741	const ident_token_ptr = ident_token.ptr;
	2742	if (ident_token_ptr.id != Token.Id.Identifier) {
	2743	*(try tree.errors.addOne()) = Error {
	2744	.ExpectedToken = Error.ExpectedToken {
	2745	.token = ident_token_index,
	2746	.expected_id = Token.Id.Identifier,
	2747	},
	2748	};
	2749	return tree;
	2750	}
	2751
	2752	const node = try arena.construct(ast.Node.ErrorTag {
	2753	.base = ast.Node {
	2754	.id = ast.Node.Id.ErrorTag,
	2755	},
	2756	.doc_comments = comments,
	2757	.name_token = ident_token_index,
	2758	});
	2759	*node_ptr = &node.base;
	2760	continue;
	2761	},
	2762
	2763	State.ExpectToken => \|token_id\| {
	2764	const token = nextToken(&tok_it, &tree);
	2765	const token_index = token.index;
	2766	const token_ptr = token.ptr;
	2767	if (token_ptr.id != token_id) {
	2768	*(try tree.errors.addOne()) = Error {
	2769	.ExpectedToken = Error.ExpectedToken {
	2770	.token = token_index,
	2771	.expected_id = token_id,
	2772	},
	2773	};
	2774	return tree;
	2775	}
	2776	continue;
	2777	},
	2778	State.ExpectTokenSave => \|expect_token_save\| {
	2779	const token = nextToken(&tok_it, &tree);
	2780	const token_index = token.index;
	2781	const token_ptr = token.ptr;
	2782	if (token_ptr.id != expect_token_save.id) {
	2783	*(try tree.errors.addOne()) = Error {
	2784	.ExpectedToken = Error.ExpectedToken {
	2785	.token = token_index,
	2786	.expected_id = expect_token_save.id,
	2787	},
	2788	};
	2789	return tree;
	2790	}
	2791	*expect_token_save.ptr = token_index;
	2792	continue;
	2793	},
	2794	State.IfToken => \|token_id\| {
	2795	if (eatToken(&tok_it, &tree, token_id)) \|_\| {
	2796	continue;
	2797	}
	2798
	2799	_ = stack.pop();
	2800	continue;
	2801	},
	2802	State.IfTokenSave => \|if_token_save\| {
	2803	if (eatToken(&tok_it, &tree, if_token_save.id)) \|token_index\| {
	2804	*if_token_save.ptr = token_index;
	2805	continue;
	2806	}
	2807
	2808	_ = stack.pop();
	2809	continue;
	2810	},
	2811	State.OptionalTokenSave => \|optional_token_save\| {
	2812	if (eatToken(&tok_it, &tree, optional_token_save.id)) \|token_index\| {
	2813	*optional_token_save.ptr = token_index;
	2814	continue;
	2815	}
	2816
	2817	continue;
	2818	},
	2819	}
	2820	}
	2821	}
	2822
	2823	const AnnotatedToken = struct {
	2824	ptr: &Token,
	2825	index: TokenIndex,
	2826	};
	2827
	2828	const TopLevelDeclCtx = struct {
	2829	decls: &ast.Node.Root.DeclList,
	2830	visib_token: ?TokenIndex,
	2831	extern_export_inline_token: ?AnnotatedToken,
	2832	lib_name: ?&ast.Node,
	2833	comments: ?&ast.Node.DocComment,
	2834	};
	2835
	2836	const VarDeclCtx = struct {
	2837	mut_token: TokenIndex,
	2838	visib_token: ?TokenIndex,
	2839	comptime_token: ?TokenIndex,
	2840	extern_export_token: ?TokenIndex,
	2841	lib_name: ?&ast.Node,
	2842	list: &ast.Node.Root.DeclList,
	2843	comments: ?&ast.Node.DocComment,
	2844	};
	2845
	2846	const TopLevelExternOrFieldCtx = struct {
	2847	visib_token: TokenIndex,
	2848	container_decl: &ast.Node.ContainerDecl,
	2849	comments: ?&ast.Node.DocComment,
	2850	};
	2851
	2852	const ExternTypeCtx = struct {
	2853	opt_ctx: OptionalCtx,
	2854	extern_token: TokenIndex,
	2855	comments: ?&ast.Node.DocComment,
	2856	};
	2857
	2858	const ContainerKindCtx = struct {
	2859	opt_ctx: OptionalCtx,
	2860	ltoken: TokenIndex,
	2861	layout: ast.Node.ContainerDecl.Layout,
	2862	};
	2863
	2864	const ExpectTokenSave = struct {
	2865	id: @TagType(Token.Id),
	2866	ptr: &TokenIndex,
	2867	};
	2868
	2869	const OptionalTokenSave = struct {
	2870	id: @TagType(Token.Id),
	2871	ptr: &?TokenIndex,
	2872	};
	2873
	2874	const ExprListCtx = struct {
	2875	list: &ast.Node.SuffixOp.Op.InitList,
	2876	end: Token.Id,
	2877	ptr: &TokenIndex,
	2878	};
	2879
	2880	fn ListSave(comptime List: type) type {
	2881	return struct {
	2882	list: &List,
	2883	ptr: &TokenIndex,
	2884	};
	2885	}
	2886
	2887	const MaybeLabeledExpressionCtx = struct {
	2888	label: TokenIndex,
	2889	opt_ctx: OptionalCtx,
	2890	};
	2891
	2892	const LabelCtx = struct {
	2893	label: ?TokenIndex,
	2894	opt_ctx: OptionalCtx,
	2895	};
	2896
	2897	const InlineCtx = struct {
	2898	label: ?TokenIndex,
	2899	inline_token: ?TokenIndex,
	2900	opt_ctx: OptionalCtx,
	2901	};
	2902
	2903	const LoopCtx = struct {
	2904	label: ?TokenIndex,
	2905	inline_token: ?TokenIndex,
	2906	loop_token: TokenIndex,
	2907	opt_ctx: OptionalCtx,
	2908	};
	2909
	2910	const AsyncEndCtx = struct {
	2911	ctx: OptionalCtx,
	2912	attribute: &ast.Node.AsyncAttribute,
	2913	};
	2914
	2915	const ErrorTypeOrSetDeclCtx = struct {
	2916	opt_ctx: OptionalCtx,
	2917	error_token: TokenIndex,
	2918	};
	2919
	2920	const ParamDeclEndCtx = struct {
	2921	fn_proto: &ast.Node.FnProto,
	2922	param_decl: &ast.Node.ParamDecl,
	2923	};
	2924
	2925	const ComptimeStatementCtx = struct {
	2926	comptime_token: TokenIndex,
	2927	block: &ast.Node.Block,
	2928	};
	2929
	2930	const OptionalCtx = union(enum) {
	2931	Optional: &?&ast.Node,
	2932	RequiredNull: &?&ast.Node,
	2933	Required: &&ast.Node,
	2934
	2935	pub fn store(self: &const OptionalCtx, value: &ast.Node) void {
	2936	switch (*self) {
	2937	OptionalCtx.Optional => \|ptr\| *ptr = value,
	2938	OptionalCtx.RequiredNull => \|ptr\| *ptr = value,
	2939	OptionalCtx.Required => \|ptr\| *ptr = value,
	2940	}
	2941	}
	2942
	2943	pub fn get(self: &const OptionalCtx) ?&ast.Node {
	2944	switch (*self) {
	2945	OptionalCtx.Optional => \|ptr\| return *ptr,
	2946	OptionalCtx.RequiredNull => \|ptr\| return ??*ptr,
	2947	OptionalCtx.Required => \|ptr\| return *ptr,
	2948	}
	2949	}
	2950
	2951	pub fn toRequired(self: &const OptionalCtx) OptionalCtx {
	2952	switch (*self) {
	2953	OptionalCtx.Optional => \|ptr\| {
	2954	return OptionalCtx { .RequiredNull = ptr };
	2955	},
	2956	OptionalCtx.RequiredNull => \|ptr\| return *self,
	2957	OptionalCtx.Required => \|ptr\| return *self,
	2958	}
	2959	}
	2960	};
	2961
	2962	const AddCommentsCtx = struct {
	2963	node_ptr: &&ast.Node,
	2964	comments: ?&ast.Node.DocComment,
	2965	};
	2966
	2967	const State = union(enum) {
	2968	TopLevel,
	2969	TopLevelExtern: TopLevelDeclCtx,
	2970	TopLevelLibname: TopLevelDeclCtx,
	2971	TopLevelDecl: TopLevelDeclCtx,
	2972	TopLevelExternOrField: TopLevelExternOrFieldCtx,
	2973
	2974	ContainerKind: ContainerKindCtx,
	2975	ContainerInitArgStart: &ast.Node.ContainerDecl,
	2976	ContainerInitArg: &ast.Node.ContainerDecl,
	2977	ContainerDecl: &ast.Node.ContainerDecl,
	2978
	2979	VarDecl: VarDeclCtx,
	2980	VarDeclAlign: &ast.Node.VarDecl,
	2981	VarDeclEq: &ast.Node.VarDecl,
	2982
	2983	FnDef: &ast.Node.FnProto,
	2984	FnProto: &ast.Node.FnProto,
	2985	FnProtoAlign: &ast.Node.FnProto,
	2986	FnProtoReturnType: &ast.Node.FnProto,
	2987
	2988	ParamDecl: &ast.Node.FnProto,
	2989	ParamDeclAliasOrComptime: &ast.Node.ParamDecl,
	2990	ParamDeclName: &ast.Node.ParamDecl,
	2991	ParamDeclEnd: ParamDeclEndCtx,
	2992	ParamDeclComma: &ast.Node.FnProto,
	2993
	2994	MaybeLabeledExpression: MaybeLabeledExpressionCtx,
	2995	LabeledExpression: LabelCtx,
	2996	Inline: InlineCtx,
	2997	While: LoopCtx,
	2998	WhileContinueExpr: &?&ast.Node,
	2999	For: LoopCtx,
	3000	Else: &?&ast.Node.Else,
	3001
	3002	Block: &ast.Node.Block,
	3003	Statement: &ast.Node.Block,
	3004	ComptimeStatement: ComptimeStatementCtx,
	3005	Semicolon: &&ast.Node,
	3006
	3007	AsmOutputItems: &ast.Node.Asm.OutputList,
	3008	AsmOutputReturnOrType: &ast.Node.AsmOutput,
	3009	AsmInputItems: &ast.Node.Asm.InputList,
	3010	AsmClobberItems: &ast.Node.Asm.ClobberList,
	3011
	3012	ExprListItemOrEnd: ExprListCtx,
	3013	ExprListCommaOrEnd: ExprListCtx,
	3014	FieldInitListItemOrEnd: ListSave(ast.Node.SuffixOp.Op.InitList),
	3015	FieldInitListCommaOrEnd: ListSave(ast.Node.SuffixOp.Op.InitList),
	3016	FieldListCommaOrEnd: &ast.Node.ContainerDecl,
	3017	FieldInitValue: OptionalCtx,
	3018	ErrorTagListItemOrEnd: ListSave(ast.Node.ErrorSetDecl.DeclList),
	3019	ErrorTagListCommaOrEnd: ListSave(ast.Node.ErrorSetDecl.DeclList),
	3020	SwitchCaseOrEnd: ListSave(ast.Node.Switch.CaseList),
	3021	SwitchCaseCommaOrEnd: ListSave(ast.Node.Switch.CaseList),
	3022	SwitchCaseFirstItem: &ast.Node.SwitchCase.ItemList,
	3023	SwitchCaseItem: &ast.Node.SwitchCase.ItemList,
	3024	SwitchCaseItemCommaOrEnd: &ast.Node.SwitchCase.ItemList,
	3025
	3026	SuspendBody: &ast.Node.Suspend,
	3027	AsyncAllocator: &ast.Node.AsyncAttribute,
	3028	AsyncEnd: AsyncEndCtx,
	3029
	3030	ExternType: ExternTypeCtx,
	3031	SliceOrArrayAccess: &ast.Node.SuffixOp,
	3032	SliceOrArrayType: &ast.Node.PrefixOp,
	3033	AddrOfModifiers: &ast.Node.PrefixOp.AddrOfInfo,
	3034
	3035	Payload: OptionalCtx,
	3036	PointerPayload: OptionalCtx,
	3037	PointerIndexPayload: OptionalCtx,
	3038
	3039	Expression: OptionalCtx,
	3040	RangeExpressionBegin: OptionalCtx,
	3041	RangeExpressionEnd: OptionalCtx,
	3042	AssignmentExpressionBegin: OptionalCtx,
	3043	AssignmentExpressionEnd: OptionalCtx,
	3044	UnwrapExpressionBegin: OptionalCtx,
	3045	UnwrapExpressionEnd: OptionalCtx,
	3046	BoolOrExpressionBegin: OptionalCtx,
	3047	BoolOrExpressionEnd: OptionalCtx,
	3048	BoolAndExpressionBegin: OptionalCtx,
	3049	BoolAndExpressionEnd: OptionalCtx,
	3050	ComparisonExpressionBegin: OptionalCtx,
	3051	ComparisonExpressionEnd: OptionalCtx,
	3052	BinaryOrExpressionBegin: OptionalCtx,
	3053	BinaryOrExpressionEnd: OptionalCtx,
	3054	BinaryXorExpressionBegin: OptionalCtx,
	3055	BinaryXorExpressionEnd: OptionalCtx,
	3056	BinaryAndExpressionBegin: OptionalCtx,
	3057	BinaryAndExpressionEnd: OptionalCtx,
	3058	BitShiftExpressionBegin: OptionalCtx,
	3059	BitShiftExpressionEnd: OptionalCtx,
	3060	AdditionExpressionBegin: OptionalCtx,
	3061	AdditionExpressionEnd: OptionalCtx,
	3062	MultiplyExpressionBegin: OptionalCtx,
	3063	MultiplyExpressionEnd: OptionalCtx,
	3064	CurlySuffixExpressionBegin: OptionalCtx,
	3065	CurlySuffixExpressionEnd: OptionalCtx,
	3066	TypeExprBegin: OptionalCtx,
	3067	TypeExprEnd: OptionalCtx,
	3068	PrefixOpExpression: OptionalCtx,
	3069	SuffixOpExpressionBegin: OptionalCtx,
	3070	SuffixOpExpressionEnd: OptionalCtx,
	3071	PrimaryExpression: OptionalCtx,
	3072
	3073	ErrorTypeOrSetDecl: ErrorTypeOrSetDeclCtx,
	3074	StringLiteral: OptionalCtx,
	3075	Identifier: OptionalCtx,
	3076	ErrorTag: &&ast.Node,
	3077
	3078
	3079	IfToken: @TagType(Token.Id),
	3080	IfTokenSave: ExpectTokenSave,
	3081	ExpectToken: @TagType(Token.Id),
	3082	ExpectTokenSave: ExpectTokenSave,
	3083	OptionalTokenSave: OptionalTokenSave,
	3084	};
	3085
	3086	fn eatDocComments(arena: &mem.Allocator, tok_it: &ast.Tree.TokenList.Iterator, tree: &ast.Tree) !?&ast.Node.DocComment {
	3087	var result: ?&ast.Node.DocComment = null;
	3088	while (true) {
	3089	if (eatToken(tok_it, tree, Token.Id.DocComment)) \|line_comment\| {
	3090	const node = blk: {
	3091	if (result) \|comment_node\| {
	3092	break :blk comment_node;
	3093	} else {
	3094	const comment_node = try arena.construct(ast.Node.DocComment {
	3095	.base = ast.Node {
	3096	.id = ast.Node.Id.DocComment,
	3097	},
	3098	.lines = ast.Node.DocComment.LineList.init(arena),
	3099	});
	3100	result = comment_node;
	3101	break :blk comment_node;
	3102	}
	3103	};
	3104	try node.lines.push(line_comment);
	3105	continue;
	3106	}
	3107	break;
	3108	}
	3109	return result;
	3110	}
	3111
	3112	fn eatLineComment(arena: &mem.Allocator, tok_it: &ast.Tree.TokenList.Iterator, tree: &ast.Tree) !?&ast.Node.LineComment {
	3113	const token = eatToken(tok_it, tree, Token.Id.LineComment) ?? return null;
	3114	return try arena.construct(ast.Node.LineComment {
	3115	.base = ast.Node {
	3116	.id = ast.Node.Id.LineComment,
	3117	},
	3118	.token = token,
	3119	});
	3120	}
	3121
	3122	fn parseStringLiteral(arena: &mem.Allocator, tok_it: &ast.Tree.TokenList.Iterator,
	3123	token_ptr: &const Token, token_index: TokenIndex, tree: &ast.Tree) !?&ast.Node
	3124	{
	3125	switch (token_ptr.id) {
	3126	Token.Id.StringLiteral => {
	3127	return &(try createLiteral(arena, ast.Node.StringLiteral, token_index)).base;
	3128	},
	3129	Token.Id.MultilineStringLiteralLine => {
	3130	const node = try arena.construct(ast.Node.MultilineStringLiteral {
	3131	.base = ast.Node { .id = ast.Node.Id.MultilineStringLiteral },
	3132	.lines = ast.Node.MultilineStringLiteral.LineList.init(arena),
	3133	});
	3134	try node.lines.push(token_index);
	3135	while (true) {
	3136	const multiline_str = nextToken(tok_it, tree);
	3137	const multiline_str_index = multiline_str.index;
	3138	const multiline_str_ptr = multiline_str.ptr;
	3139	if (multiline_str_ptr.id != Token.Id.MultilineStringLiteralLine) {
	3140	putBackToken(tok_it, tree);
	3141	break;
	3142	}
	3143
	3144	try node.lines.push(multiline_str_index);
	3145	}
	3146
	3147	return &node.base;
	3148	},
	3149	// TODO: We shouldn't need a cast, but:
	3150	// zig: /home/jc/Documents/zig/src/ir.cpp:7962: TypeTableEntry* ir_resolve_peer_types(IrAnalyze, AstNode, IrInstruction**, size_t): Assertion `err_set_type != nullptr' failed.
	3151	else => return (?&ast.Node)(null),
	3152	}
	3153	}
	3154
	3155	fn parseBlockExpr(stack: &std.ArrayList(State), arena: &mem.Allocator, ctx: &const OptionalCtx,
	3156	token_ptr: &const Token, token_index: TokenIndex) !bool {
	3157	switch (token_ptr.id) {
	3158	Token.Id.Keyword_suspend => {
	3159	const node = try createToCtxNode(arena, ctx, ast.Node.Suspend,
	3160	ast.Node.Suspend {
	3161	.base = undefined,
	3162	.label = null,
	3163	.suspend_token = token_index,
	3164	.payload = null,
	3165	.body = null,
	3166	}
	3167	);
	3168
	3169	stack.append(State { .SuspendBody = node }) catch unreachable;
	3170	try stack.append(State { .Payload = OptionalCtx { .Optional = &node.payload } });
	3171	return true;
	3172	},
	3173	Token.Id.Keyword_if => {
	3174	const node = try createToCtxNode(arena, ctx, ast.Node.If,
	3175	ast.Node.If {
	3176	.base = undefined,
	3177	.if_token = token_index,
	3178	.condition = undefined,
	3179	.payload = null,
	3180	.body = undefined,
	3181	.@"else" = null,
	3182	}
	3183	);
	3184
	3185	stack.append(State { .Else = &node.@"else" }) catch unreachable;
	3186	try stack.append(State { .Expression = OptionalCtx { .Required = &node.body } });
	3187	try stack.append(State { .PointerPayload = OptionalCtx { .Optional = &node.payload } });
	3188	try stack.append(State { .ExpectToken = Token.Id.RParen });
	3189	try stack.append(State { .Expression = OptionalCtx { .Required = &node.condition } });
	3190	try stack.append(State { .ExpectToken = Token.Id.LParen });
	3191	return true;
	3192	},
	3193	Token.Id.Keyword_while => {
	3194	stack.append(State {
	3195	.While = LoopCtx {
	3196	.label = null,
	3197	.inline_token = null,
	3198	.loop_token = token_index,
	3199	.opt_ctx = *ctx,
	3200	}
	3201	}) catch unreachable;
	3202	return true;
	3203	},
	3204	Token.Id.Keyword_for => {
	3205	stack.append(State {
	3206	.For = LoopCtx {
	3207	.label = null,
	3208	.inline_token = null,
	3209	.loop_token = token_index,
	3210	.opt_ctx = *ctx,
	3211	}
	3212	}) catch unreachable;
	3213	return true;
	3214	},
	3215	Token.Id.Keyword_switch => {
	3216	const node = try arena.construct(ast.Node.Switch {
	3217	.base = ast.Node {
	3218	.id = ast.Node.Id.Switch,
	3219	},
	3220	.switch_token = token_index,
	3221	.expr = undefined,
	3222	.cases = ast.Node.Switch.CaseList.init(arena),
	3223	.rbrace = undefined,
	3224	});
	3225	ctx.store(&node.base);
	3226
	3227	stack.append(State {
	3228	.SwitchCaseOrEnd = ListSave(@typeOf(node.cases)) {
	3229	.list = &node.cases,
	3230	.ptr = &node.rbrace,
	3231	},
	3232	}) catch unreachable;
	3233	try stack.append(State { .ExpectToken = Token.Id.LBrace });
	3234	try stack.append(State { .ExpectToken = Token.Id.RParen });
	3235	try stack.append(State { .Expression = OptionalCtx { .Required = &node.expr } });
	3236	try stack.append(State { .ExpectToken = Token.Id.LParen });
	3237	return true;
	3238	},
	3239	Token.Id.Keyword_comptime => {
	3240	const node = try createToCtxNode(arena, ctx, ast.Node.Comptime,
	3241	ast.Node.Comptime {
	3242	.base = undefined,
	3243	.comptime_token = token_index,
	3244	.expr = undefined,
	3245	.doc_comments = null,
	3246	}
	3247	);
	3248	try stack.append(State { .Expression = OptionalCtx { .Required = &node.expr } });
	3249	return true;
	3250	},
	3251	Token.Id.LBrace => {
	3252	const block = try arena.construct(ast.Node.Block {
	3253	.base = ast.Node {.id = ast.Node.Id.Block },
	3254	.label = null,
	3255	.lbrace = token_index,
	3256	.statements = ast.Node.Block.StatementList.init(arena),
	3257	.rbrace = undefined,
	3258	});
	3259	ctx.store(&block.base);
	3260	stack.append(State { .Block = block }) catch unreachable;
	3261	return true;
	3262	},
	3263	else => {
	3264	return false;
	3265	}
	3266	}
	3267	}
	3268
	3269	const ExpectCommaOrEndResult = union(enum) {
	3270	end_token: ?TokenIndex,
	3271	parse_error: Error,
	3272	};
	3273
	3274	fn expectCommaOrEnd(tok_it: &ast.Tree.TokenList.Iterator, tree: &ast.Tree, end: @TagType(Token.Id)) ExpectCommaOrEndResult {
	3275	const token = nextToken(tok_it, tree);
	3276	const token_index = token.index;
	3277	const token_ptr = token.ptr;
	3278	switch (token_ptr.id) {
	3279	Token.Id.Comma => return ExpectCommaOrEndResult { .end_token = null},
	3280	else => {
	3281	if (end == token_ptr.id) {
	3282	return ExpectCommaOrEndResult { .end_token = token_index };
	3283	}
	3284
	3285	return ExpectCommaOrEndResult {
	3286	.parse_error = Error {
	3287	.ExpectedCommaOrEnd = Error.ExpectedCommaOrEnd {
	3288	.token = token_index,
	3289	.end_id = end,
	3290	},
	3291	},
	3292	};
	3293	},
	3294	}
	3295	}
	3296
	3297	fn tokenIdToAssignment(id: &const Token.Id) ?ast.Node.InfixOp.Op {
	3298	// TODO: We have to cast all cases because of this:
	3299	// error: expected type '?InfixOp', found '?@TagType(InfixOp)'
	3300	return switch (*id) {
	3301	Token.Id.AmpersandEqual => ast.Node.InfixOp.Op { .AssignBitAnd = {} },
	3302	Token.Id.AngleBracketAngleBracketLeftEqual => ast.Node.InfixOp.Op { .AssignBitShiftLeft = {} },
	3303	Token.Id.AngleBracketAngleBracketRightEqual => ast.Node.InfixOp.Op { .AssignBitShiftRight = {} },
	3304	Token.Id.AsteriskEqual => ast.Node.InfixOp.Op { .AssignTimes = {} },
	3305	Token.Id.AsteriskPercentEqual => ast.Node.InfixOp.Op { .AssignTimesWarp = {} },
	3306	Token.Id.CaretEqual => ast.Node.InfixOp.Op { .AssignBitXor = {} },
	3307	Token.Id.Equal => ast.Node.InfixOp.Op { .Assign = {} },
	3308	Token.Id.MinusEqual => ast.Node.InfixOp.Op { .AssignMinus = {} },
	3309	Token.Id.MinusPercentEqual => ast.Node.InfixOp.Op { .AssignMinusWrap = {} },
	3310	Token.Id.PercentEqual => ast.Node.InfixOp.Op { .AssignMod = {} },
	3311	Token.Id.PipeEqual => ast.Node.InfixOp.Op { .AssignBitOr = {} },
	3312	Token.Id.PlusEqual => ast.Node.InfixOp.Op { .AssignPlus = {} },
	3313	Token.Id.PlusPercentEqual => ast.Node.InfixOp.Op { .AssignPlusWrap = {} },
	3314	Token.Id.SlashEqual => ast.Node.InfixOp.Op { .AssignDiv = {} },
	3315	else => null,
	3316	};
	3317	}
	3318
	3319	fn tokenIdToUnwrapExpr(id: @TagType(Token.Id)) ?ast.Node.InfixOp.Op {
	3320	return switch (id) {
	3321	Token.Id.Keyword_catch => ast.Node.InfixOp.Op { .Catch = null },
	3322	Token.Id.QuestionMarkQuestionMark => ast.Node.InfixOp.Op { .UnwrapMaybe = void{} },
	3323	else => null,
	3324	};
	3325	}
	3326
	3327	fn tokenIdToComparison(id: @TagType(Token.Id)) ?ast.Node.InfixOp.Op {
	3328	return switch (id) {
	3329	Token.Id.BangEqual => ast.Node.InfixOp.Op { .BangEqual = void{} },
	3330	Token.Id.EqualEqual => ast.Node.InfixOp.Op { .EqualEqual = void{} },
	3331	Token.Id.AngleBracketLeft => ast.Node.InfixOp.Op { .LessThan = void{} },
	3332	Token.Id.AngleBracketLeftEqual => ast.Node.InfixOp.Op { .LessOrEqual = void{} },
	3333	Token.Id.AngleBracketRight => ast.Node.InfixOp.Op { .GreaterThan = void{} },
	3334	Token.Id.AngleBracketRightEqual => ast.Node.InfixOp.Op { .GreaterOrEqual = void{} },
	3335	else => null,
	3336	};
	3337	}
	3338
	3339	fn tokenIdToBitShift(id: @TagType(Token.Id)) ?ast.Node.InfixOp.Op {
	3340	return switch (id) {
	3341	Token.Id.AngleBracketAngleBracketLeft => ast.Node.InfixOp.Op { .BitShiftLeft = void{} },
	3342	Token.Id.AngleBracketAngleBracketRight => ast.Node.InfixOp.Op { .BitShiftRight = void{} },
	3343	else => null,
	3344	};
	3345	}
	3346
	3347	fn tokenIdToAddition(id: @TagType(Token.Id)) ?ast.Node.InfixOp.Op {
	3348	return switch (id) {
	3349	Token.Id.Minus => ast.Node.InfixOp.Op { .Sub = void{} },
	3350	Token.Id.MinusPercent => ast.Node.InfixOp.Op { .SubWrap = void{} },
	3351	Token.Id.Plus => ast.Node.InfixOp.Op { .Add = void{} },
	3352	Token.Id.PlusPercent => ast.Node.InfixOp.Op { .AddWrap = void{} },
	3353	Token.Id.PlusPlus => ast.Node.InfixOp.Op { .ArrayCat = void{} },
	3354	else => null,
	3355	};
	3356	}
	3357
	3358	fn tokenIdToMultiply(id: @TagType(Token.Id)) ?ast.Node.InfixOp.Op {
	3359	return switch (id) {
	3360	Token.Id.Slash => ast.Node.InfixOp.Op { .Div = void{} },
	3361	Token.Id.Asterisk => ast.Node.InfixOp.Op { .Mult = void{} },
	3362	Token.Id.AsteriskAsterisk => ast.Node.InfixOp.Op { .ArrayMult = void{} },
	3363	Token.Id.AsteriskPercent => ast.Node.InfixOp.Op { .MultWrap = void{} },
	3364	Token.Id.Percent => ast.Node.InfixOp.Op { .Mod = void{} },
	3365	Token.Id.PipePipe => ast.Node.InfixOp.Op { .MergeErrorSets = void{} },
	3366	else => null,
	3367	};
	3368	}
	3369
	3370	fn tokenIdToPrefixOp(id: @TagType(Token.Id)) ?ast.Node.PrefixOp.Op {
	3371	return switch (id) {
	3372	Token.Id.Bang => ast.Node.PrefixOp.Op { .BoolNot = void{} },
	3373	Token.Id.Tilde => ast.Node.PrefixOp.Op { .BitNot = void{} },
	3374	Token.Id.Minus => ast.Node.PrefixOp.Op { .Negation = void{} },
	3375	Token.Id.MinusPercent => ast.Node.PrefixOp.Op { .NegationWrap = void{} },
	3376	Token.Id.Asterisk, Token.Id.AsteriskAsterisk => ast.Node.PrefixOp.Op { .Deref = void{} },
	3377	Token.Id.Ampersand => ast.Node.PrefixOp.Op {
	3378	.AddrOf = ast.Node.PrefixOp.AddrOfInfo {
	3379	.align_expr = null,
	3380	.bit_offset_start_token = null,
	3381	.bit_offset_end_token = null,
	3382	.const_token = null,
	3383	.volatile_token = null,
	3384	},
	3385	},
	3386	Token.Id.QuestionMark => ast.Node.PrefixOp.Op { .MaybeType = void{} },
	3387	Token.Id.QuestionMarkQuestionMark => ast.Node.PrefixOp.Op { .UnwrapMaybe = void{} },
	3388	Token.Id.Keyword_await => ast.Node.PrefixOp.Op { .Await = void{} },
	3389	Token.Id.Keyword_try => ast.Node.PrefixOp.Op { .Try = void{ } },
	3390	else => null,
	3391	};
	3392	}
	3393
	3394	fn createNode(arena: &mem.Allocator, comptime T: type, init_to: &const T) !&T {
	3395	const node = try arena.create(T);
	3396	node = init_to;
	3397	node.base = blk: {
	3398	const id = ast.Node.typeToId(T);
	3399	break :blk ast.Node {
	3400	.id = id,
	3401	};
	3402	};
	3403
	3404	return node;
	3405	}
	3406
	3407	fn createToCtxNode(arena: &mem.Allocator, opt_ctx: &const OptionalCtx, comptime T: type, init_to: &const T) !&T {
	3408	const node = try createNode(arena, T, init_to);
	3409	opt_ctx.store(&node.base);
	3410
	3411	return node;
	3412	}
	3413
	3414	fn createLiteral(arena: &mem.Allocator, comptime T: type, token_index: TokenIndex) !&T {
	3415	return createNode(arena, T,
	3416	T {
	3417	.base = undefined,
	3418	.token = token_index,
	3419	}
	3420	);
	3421	}
	3422
	3423	fn createToCtxLiteral(arena: &mem.Allocator, opt_ctx: &const OptionalCtx, comptime T: type, token_index: TokenIndex) !&T {
	3424	const node = try createLiteral(arena, T, token_index);
	3425	opt_ctx.store(&node.base);
	3426
	3427	return node;
	3428	}
	3429
	3430	fn eatToken(tok_it: &ast.Tree.TokenList.Iterator, tree: &ast.Tree, id: @TagType(Token.Id)) ?TokenIndex {
	3431	const token = nextToken(tok_it, tree);
	3432
	3433	if (token.ptr.id == id)
	3434	return token.index;
	3435
	3436	putBackToken(tok_it, tree);
	3437	return null;
	3438	}
	3439
	3440	fn nextToken(tok_it: &ast.Tree.TokenList.Iterator, tree: &ast.Tree) AnnotatedToken {
	3441	const result = AnnotatedToken {
	3442	.index = tok_it.index,
	3443	.ptr = ??tok_it.next(),
	3444	};
	3445	// possibly skip a following same line token
	3446	const token = tok_it.next() ?? return result;
	3447	if (token.id != Token.Id.LineComment) {
	3448	putBackToken(tok_it, tree);
	3449	return result;
	3450	}
	3451	const loc = tree.tokenLocationPtr(result.ptr.end, token);
	3452	if (loc.line != 0) {
	3453	putBackToken(tok_it, tree);
	3454	}
	3455	return result;
	3456	}
	3457
	3458	fn putBackToken(tok_it: &ast.Tree.TokenList.Iterator, tree: &ast.Tree) void {
	3459	const prev_tok = ??tok_it.prev();
	3460	if (prev_tok.id == Token.Id.LineComment) {
	3461	const minus2_tok = tok_it.prev() ?? return;
	3462	const loc = tree.tokenLocationPtr(minus2_tok.end, prev_tok);
	3463	if (loc.line != 0) {
	3464	_ = tok_it.next();
	3465	}
	3466	}
	3467	}
	3468
	3469	const RenderAstFrame = struct {
	3470	node: &ast.Node,
	3471	indent: usize,
	3472	};
	3473
	3474	pub fn renderAst(allocator: &mem.Allocator, tree: &const ast.Tree, stream: var) !void {
	3475	var stack = std.ArrayList(State).init(allocator);
	3476	defer stack.deinit();
	3477
	3478	try stack.append(RenderAstFrame {
	3479	.node = &root_node.base,
	3480	.indent = 0,
	3481	});
	3482
	3483	while (stack.popOrNull()) \|frame\| {
	3484	{
	3485	var i: usize = 0;
	3486	while (i < frame.indent) : (i += 1) {
	3487	try stream.print(" ");
	3488	}
	3489	}
	3490	try stream.print("{}\n", @tagName(frame.node.id));
	3491	var child_i: usize = 0;
	3492	while (frame.node.iterate(child_i)) \|child\| : (child_i += 1) {
	3493	try stack.append(RenderAstFrame {
	3494	.node = child,
	3495	.indent = frame.indent + 2,
	3496	});
	3497	}
	3498	}
	3499	}
	3500
	3501	test "std.zig.parser" {
	3502	_ = @import("parser_test.zig");
	3503	}

std/zig/parser.zig deleted-1733

...	...	@@ -1,1733 +0,0 @@
1		const std = @import("../index.zig");
2		const assert = std.debug.assert;
3		const ArrayList = std.ArrayList;
4		const mem = std.mem;
5		const ast = std.zig.ast;
6		const Tokenizer = std.zig.Tokenizer;
7		const Token = std.zig.Token;
8		const builtin = @import("builtin");
9		const io = std.io;
10
11		// TODO when we make parse errors into error types instead of printing directly,
12		// get rid of this
13		const warn = std.debug.warn;
14
15		pub const Parser = struct {
16		util_allocator: &mem.Allocator,
17		tokenizer: &Tokenizer,
18		put_back_tokens: [2]Token,
19		put_back_count: usize,
20		source_file_name: []const u8,
21		pending_line_comment_node: ?&ast.NodeLineComment,
22
23		pub const Tree = struct {
24		root_node: &ast.NodeRoot,
25		arena_allocator: std.heap.ArenaAllocator,
26
27		pub fn deinit(self: &Tree) void {
28		self.arena_allocator.deinit();
29		}
30		};
31
32		// This memory contents are used only during a function call. It's used to repurpose memory;
33		// we reuse the same bytes for the stack data structure used by parsing, tree rendering, and
34		// source rendering.
35		const utility_bytes_align = @alignOf( union { a: RenderAstFrame, b: State, c: RenderState } );
36		utility_bytes: []align(utility_bytes_align) u8,
37
38		/// allocator must outlive the returned Parser and all the parse trees you create with it.
39		pub fn init(tokenizer: &Tokenizer, allocator: &mem.Allocator, source_file_name: []const u8) Parser {
40		return Parser {
41		.util_allocator = allocator,
42		.tokenizer = tokenizer,
43		.put_back_tokens = undefined,
44		.put_back_count = 0,
45		.source_file_name = source_file_name,
46		.utility_bytes = []align(utility_bytes_align) u8{},
47		.pending_line_comment_node = null,
48		};
49		}
50
51		pub fn deinit(self: &Parser) void {
52		self.util_allocator.free(self.utility_bytes);
53		}
54
55		const TopLevelDeclCtx = struct {
56		visib_token: ?Token,
57		extern_token: ?Token,
58		};
59
60		const DestPtr = union(enum) {
61		Field: &&ast.Node,
62		NullableField: &?&ast.Node,
63		List: &ArrayList(&ast.Node),
64
65		pub fn store(self: &const DestPtr, value: &ast.Node) !void {
66		switch (*self) {
67		DestPtr.Field => \|ptr\| *ptr = value,
68		DestPtr.NullableField => \|ptr\| *ptr = value,
69		DestPtr.List => \|list\| try list.append(value),
70		}
71		}
72		};
73
74		const ExpectTokenSave = struct {
75		id: Token.Id,
76		ptr: &Token,
77		};
78
79		const State = union(enum) {
80		TopLevel,
81		TopLevelExtern: ?Token,
82		TopLevelDecl: TopLevelDeclCtx,
83		Expression: DestPtr,
84		ExpectOperand,
85		Operand: &ast.Node,
86		AfterOperand,
87		InfixOp: &ast.NodeInfixOp,
88		PrefixOp: &ast.NodePrefixOp,
89		SuffixOp: &ast.Node,
90		AddrOfModifiers: &ast.NodePrefixOp.AddrOfInfo,
91		TypeExpr: DestPtr,
92		VarDecl: &ast.NodeVarDecl,
93		VarDeclAlign: &ast.NodeVarDecl,
94		VarDeclEq: &ast.NodeVarDecl,
95		ExpectToken: @TagType(Token.Id),
96		ExpectTokenSave: ExpectTokenSave,
97		FnProto: &ast.NodeFnProto,
98		FnProtoAlign: &ast.NodeFnProto,
99		FnProtoReturnType: &ast.NodeFnProto,
100		ParamDecl: &ast.NodeFnProto,
101		ParamDeclComma,
102		FnDef: &ast.NodeFnProto,
103		Block: &ast.NodeBlock,
104		Statement: &ast.NodeBlock,
105		ExprListItemOrEnd: &ArrayList(&ast.Node),
106		ExprListCommaOrEnd: &ArrayList(&ast.Node),
107		};
108
109		/// Returns an AST tree, allocated with the parser's allocator.
110		/// Result should be freed with tree.deinit() when there are
111		/// no more references to any AST nodes of the tree.
112		pub fn parse(self: &Parser) !Tree {
113		var stack = self.initUtilityArrayList(State);
114		defer self.deinitUtilityArrayList(stack);
115
116		var arena_allocator = std.heap.ArenaAllocator.init(self.util_allocator);
117		errdefer arena_allocator.deinit();
118
119		const arena = &arena_allocator.allocator;
120		const root_node = try self.createRoot(arena);
121
122		try stack.append(State.TopLevel);
123
124		while (true) {
125		//{
126		// const token = self.getNextToken();
127		// warn("{} ", @tagName(token.id));
128		// self.putBackToken(token);
129		// var i: usize = stack.len;
130		// while (i != 0) {
131		// i -= 1;
132		// warn("{} ", @tagName(stack.items[i]));
133		// }
134		// warn("\n");
135		//}
136
137		// look for line comments
138		while (true) {
139		const token = self.getNextToken();
140		if (token.id == Token.Id.LineComment) {
141		const node = blk: {
142		if (self.pending_line_comment_node) \|comment_node\| {
143		break :blk comment_node;
144		} else {
145		const comment_node = try arena.create(ast.NodeLineComment);
146		*comment_node = ast.NodeLineComment {
147		.base = ast.Node {
148		.id = ast.Node.Id.LineComment,
149		.comment = null,
150		},
151		.lines = ArrayList(Token).init(arena),
152		};
153		self.pending_line_comment_node = comment_node;
154		break :blk comment_node;
155		}
156		};
157		try node.lines.append(token);
158		continue;
159		}
160		self.putBackToken(token);
161		break;
162		}
163
164		// This gives us 1 free append that can't fail
165		const state = stack.pop();
166
167		switch (state) {
168		State.TopLevel => {
169		const token = self.getNextToken();
170		switch (token.id) {
171		Token.Id.Keyword_pub, Token.Id.Keyword_export => {
172		stack.append(State { .TopLevelExtern = token }) catch unreachable;
173		continue;
174		},
175		Token.Id.Keyword_test => {
176		stack.append(State.TopLevel) catch unreachable;
177
178		const name_token = self.getNextToken();
179		if (name_token.id != Token.Id.StringLiteral)
180		return self.parseError(token, "expected {}, found {}", @tagName(Token.Id.StringLiteral), @tagName(name_token.id));
181
182		const lbrace = self.getNextToken();
183		if (lbrace.id != Token.Id.LBrace)
184		return self.parseError(token, "expected {}, found {}", @tagName(Token.Id.LBrace), @tagName(name_token.id));
185
186		const block = try self.createBlock(arena, token);
187		const test_decl = try self.createAttachTestDecl(arena, &root_node.decls, token, name_token, block);
188		try stack.append(State { .Block = block });
189		continue;
190		},
191		Token.Id.Eof => {
192		root_node.eof_token = token;
193		return Tree {.root_node = root_node, .arena_allocator = arena_allocator};
194		},
195		else => {
196		self.putBackToken(token);
197		stack.append(State { .TopLevelExtern = null }) catch unreachable;
198		continue;
199		},
200		}
201		},
202		State.TopLevelExtern => \|visib_token\| {
203		const token = self.getNextToken();
204		if (token.id == Token.Id.Keyword_extern) {
205		stack.append(State {
206		.TopLevelDecl = TopLevelDeclCtx {
207		.visib_token = visib_token,
208		.extern_token = token,
209		},
210		}) catch unreachable;
211		continue;
212		}
213		self.putBackToken(token);
214		stack.append(State {
215		.TopLevelDecl = TopLevelDeclCtx {
216		.visib_token = visib_token,
217		.extern_token = null,
218		},
219		}) catch unreachable;
220		continue;
221		},
222		State.TopLevelDecl => \|ctx\| {
223		const token = self.getNextToken();
224		switch (token.id) {
225		Token.Id.Keyword_var, Token.Id.Keyword_const => {
226		stack.append(State.TopLevel) catch unreachable;
227		// TODO shouldn't need these casts
228		const var_decl_node = try self.createAttachVarDecl(arena, &root_node.decls, ctx.visib_token,
229		token, (?Token)(null), ctx.extern_token);
230		try stack.append(State { .VarDecl = var_decl_node });
231		continue;
232		},
233		Token.Id.Keyword_fn => {
234		stack.append(State.TopLevel) catch unreachable;
235		// TODO shouldn't need these casts
236		const fn_proto = try self.createAttachFnProto(arena, &root_node.decls, token,
237		ctx.extern_token, (?Token)(null), ctx.visib_token, (?Token)(null));
238		try stack.append(State { .FnDef = fn_proto });
239		try stack.append(State { .FnProto = fn_proto });
240		continue;
241		},
242		Token.Id.StringLiteral => {
243		@panic("TODO extern with string literal");
244		},
245		Token.Id.Keyword_nakedcc, Token.Id.Keyword_stdcallcc => {
246		stack.append(State.TopLevel) catch unreachable;
247		const fn_token = try self.eatToken(Token.Id.Keyword_fn);
248		// TODO shouldn't need this cast
249		const fn_proto = try self.createAttachFnProto(arena, &root_node.decls, fn_token,
250		ctx.extern_token, (?Token)(token), (?Token)(null), (?Token)(null));
251		try stack.append(State { .FnDef = fn_proto });
252		try stack.append(State { .FnProto = fn_proto });
253		continue;
254		},
255		else => return self.parseError(token, "expected variable declaration or function, found {}", @tagName(token.id)),
256		}
257		},
258		State.VarDecl => \|var_decl\| {
259		var_decl.name_token = try self.eatToken(Token.Id.Identifier);
260		stack.append(State { .VarDeclAlign = var_decl }) catch unreachable;
261
262		const next_token = self.getNextToken();
263		if (next_token.id == Token.Id.Colon) {
264		try stack.append(State { .TypeExpr = DestPtr {.NullableField = &var_decl.type_node} });
265		continue;
266		}
267
268		self.putBackToken(next_token);
269		continue;
270		},
271		State.VarDeclAlign => \|var_decl\| {
272		stack.append(State { .VarDeclEq = var_decl }) catch unreachable;
273
274		const next_token = self.getNextToken();
275		if (next_token.id == Token.Id.Keyword_align) {
276		_ = try self.eatToken(Token.Id.LParen);
277		try stack.append(State { .ExpectToken = Token.Id.RParen });
278		try stack.append(State { .Expression = DestPtr{.NullableField = &var_decl.align_node} });
279		continue;
280		}
281
282		self.putBackToken(next_token);
283		continue;
284		},
285		State.VarDeclEq => \|var_decl\| {
286		const token = self.getNextToken();
287		if (token.id == Token.Id.Equal) {
288		var_decl.eq_token = token;
289		stack.append(State {
290		.ExpectTokenSave = ExpectTokenSave {
291		.id = Token.Id.Semicolon,
292		.ptr = &var_decl.semicolon_token,
293		},
294		}) catch unreachable;
295		try stack.append(State {
296		.Expression = DestPtr {.NullableField = &var_decl.init_node},
297		});
298		continue;
299		}
300		if (token.id == Token.Id.Semicolon) {
301		var_decl.semicolon_token = token;
302		continue;
303		}
304		return self.parseError(token, "expected '=' or ';', found {}", @tagName(token.id));
305		},
306		State.ExpectToken => \|token_id\| {
307		_ = try self.eatToken(token_id);
308		continue;
309		},
310
311		State.ExpectTokenSave => \|expect_token_save\| {
312		*expect_token_save.ptr = try self.eatToken(expect_token_save.id);
313		continue;
314		},
315
316		State.Expression => \|dest_ptr\| {
317		// save the dest_ptr for later
318		stack.append(state) catch unreachable;
319		try stack.append(State.ExpectOperand);
320		continue;
321		},
322		State.ExpectOperand => {
323		// we'll either get an operand (like 1 or x),
324		// or a prefix operator (like ~ or return).
325		const token = self.getNextToken();
326		switch (token.id) {
327		Token.Id.Keyword_return => {
328		try stack.append(State { .PrefixOp = try self.createPrefixOp(arena, token,
329		ast.NodePrefixOp.PrefixOp.Return) });
330		try stack.append(State.ExpectOperand);
331		continue;
332		},
333		Token.Id.Keyword_try => {
334		try stack.append(State { .PrefixOp = try self.createPrefixOp(arena, token,
335		ast.NodePrefixOp.PrefixOp.Try) });
336		try stack.append(State.ExpectOperand);
337		continue;
338		},
339		Token.Id.Minus => {
340		try stack.append(State { .PrefixOp = try self.createPrefixOp(arena, token,
341		ast.NodePrefixOp.PrefixOp.Negation) });
342		try stack.append(State.ExpectOperand);
343		continue;
344		},
345		Token.Id.MinusPercent => {
346		try stack.append(State { .PrefixOp = try self.createPrefixOp(arena, token,
347		ast.NodePrefixOp.PrefixOp.NegationWrap) });
348		try stack.append(State.ExpectOperand);
349		continue;
350		},
351		Token.Id.Tilde => {
352		try stack.append(State { .PrefixOp = try self.createPrefixOp(arena, token,
353		ast.NodePrefixOp.PrefixOp.BitNot) });
354		try stack.append(State.ExpectOperand);
355		continue;
356		},
357		Token.Id.QuestionMarkQuestionMark => {
358		try stack.append(State { .PrefixOp = try self.createPrefixOp(arena, token,
359		ast.NodePrefixOp.PrefixOp.UnwrapMaybe) });
360		try stack.append(State.ExpectOperand);
361		continue;
362		},
363		Token.Id.Bang => {
364		try stack.append(State { .PrefixOp = try self.createPrefixOp(arena, token,
365		ast.NodePrefixOp.PrefixOp.BoolNot) });
366		try stack.append(State.ExpectOperand);
367		continue;
368		},
369		Token.Id.Asterisk => {
370		try stack.append(State { .PrefixOp = try self.createPrefixOp(arena, token,
371		ast.NodePrefixOp.PrefixOp.Deref) });
372		try stack.append(State.ExpectOperand);
373		continue;
374		},
375		Token.Id.Ampersand => {
376		const prefix_op = try self.createPrefixOp(arena, token, ast.NodePrefixOp.PrefixOp{
377		.AddrOf = ast.NodePrefixOp.AddrOfInfo {
378		.align_expr = null,
379		.bit_offset_start_token = null,
380		.bit_offset_end_token = null,
381		.const_token = null,
382		.volatile_token = null,
383		}
384		});
385		try stack.append(State { .PrefixOp = prefix_op });
386		try stack.append(State.ExpectOperand);
387		try stack.append(State { .AddrOfModifiers = &prefix_op.op.AddrOf });
388		continue;
389		},
390		Token.Id.Identifier => {
391		try stack.append(State {
392		.Operand = &(try self.createIdentifier(arena, token)).base
393		});
394		try stack.append(State.AfterOperand);
395		continue;
396		},
397		Token.Id.IntegerLiteral => {
398		try stack.append(State {
399		.Operand = &(try self.createIntegerLiteral(arena, token)).base
400		});
401		try stack.append(State.AfterOperand);
402		continue;
403		},
404		Token.Id.FloatLiteral => {
405		try stack.append(State {
406		.Operand = &(try self.createFloatLiteral(arena, token)).base
407		});
408		try stack.append(State.AfterOperand);
409		continue;
410		},
411		Token.Id.Keyword_undefined => {
412		try stack.append(State {
413		.Operand = &(try self.createUndefined(arena, token)).base
414		});
415		try stack.append(State.AfterOperand);
416		continue;
417		},
418		Token.Id.Builtin => {
419		const node = try arena.create(ast.NodeBuiltinCall);
420		*node = ast.NodeBuiltinCall {
421		.base = self.initNode(ast.Node.Id.BuiltinCall),
422		.builtin_token = token,
423		.params = ArrayList(&ast.Node).init(arena),
424		.rparen_token = undefined,
425		};
426		try stack.append(State {
427		.Operand = &node.base
428		});
429		try stack.append(State.AfterOperand);
430		try stack.append(State {.ExprListItemOrEnd = &node.params });
431		try stack.append(State {
432		.ExpectTokenSave = ExpectTokenSave {
433		.id = Token.Id.LParen,
434		.ptr = &node.rparen_token,
435		},
436		});
437		continue;
438		},
439		Token.Id.StringLiteral => {
440		const node = try arena.create(ast.NodeStringLiteral);
441		*node = ast.NodeStringLiteral {
442		.base = self.initNode(ast.Node.Id.StringLiteral),
443		.token = token,
444		};
445		try stack.append(State {
446		.Operand = &node.base
447		});
448		try stack.append(State.AfterOperand);
449		continue;
450		},
451
452		else => return self.parseError(token, "expected primary expression, found {}", @tagName(token.id)),
453		}
454		},
455
456		State.AfterOperand => {
457		// we'll either get an infix operator (like != or ^),
458		// or a postfix operator (like () or {}),
459		// otherwise this expression is done (like on a ; or else).
460		var token = self.getNextToken();
461		if (tokenIdToInfixOp(token.id)) \|infix_id\| {
462		try stack.append(State {
463		.InfixOp = try self.createInfixOp(arena, token, infix_id)
464		});
465		try stack.append(State.ExpectOperand);
466		continue;
467
468		} else if (token.id == Token.Id.LParen) {
469		self.putBackToken(token);
470
471		const node = try arena.create(ast.NodeCall);
472		*node = ast.NodeCall {
473		.base = self.initNode(ast.Node.Id.Call),
474		.callee = undefined,
475		.params = ArrayList(&ast.Node).init(arena),
476		.rparen_token = undefined,
477		};
478		try stack.append(State { .SuffixOp = &node.base });
479		try stack.append(State.AfterOperand);
480		try stack.append(State {.ExprListItemOrEnd = &node.params });
481		try stack.append(State {
482		.ExpectTokenSave = ExpectTokenSave {
483		.id = Token.Id.LParen,
484		.ptr = &node.rparen_token,
485		},
486		});
487		continue;
488
489		// TODO: Parse postfix operator
490		} else {
491		// no postfix/infix operator after this operand.
492		self.putBackToken(token);
493
494		var expression = popSuffixOp(&stack);
495		while (true) {
496		switch (stack.pop()) {
497		State.Expression => \|dest_ptr\| {
498		// we're done
499		try dest_ptr.store(expression);
500		break;
501		},
502		State.InfixOp => \|infix_op\| {
503		infix_op.rhs = expression;
504		infix_op.lhs = popSuffixOp(&stack);
505		expression = &infix_op.base;
506		continue;
507		},
508		State.PrefixOp => \|prefix_op\| {
509		prefix_op.rhs = expression;
510		expression = &prefix_op.base;
511		continue;
512		},
513		else => unreachable,
514		}
515		}
516		continue;
517		}
518		},
519
520		State.ExprListItemOrEnd => \|params\| {
521		var token = self.getNextToken();
522		switch (token.id) {
523		Token.Id.RParen => continue,
524		else => {
525		self.putBackToken(token);
526		stack.append(State { .ExprListCommaOrEnd = params }) catch unreachable;
527		try stack.append(State { .Expression = DestPtr{.List = params} });
528		},
529		}
530		},
531
532		State.ExprListCommaOrEnd => \|params\| {
533		var token = self.getNextToken();
534		switch (token.id) {
535		Token.Id.Comma => {
536		stack.append(State { .ExprListItemOrEnd = params }) catch unreachable;
537		},
538		Token.Id.RParen => continue,
539		else => return self.parseError(token, "expected ',' or ')', found {}", @tagName(token.id)),
540		}
541		},
542
543		State.AddrOfModifiers => \|addr_of_info\| {
544		var token = self.getNextToken();
545		switch (token.id) {
546		Token.Id.Keyword_align => {
547		stack.append(state) catch unreachable;
548		if (addr_of_info.align_expr != null) return self.parseError(token, "multiple align qualifiers");
549		_ = try self.eatToken(Token.Id.LParen);
550		try stack.append(State { .ExpectToken = Token.Id.RParen });
551		try stack.append(State { .Expression = DestPtr{.NullableField = &addr_of_info.align_expr} });
552		continue;
553		},
554		Token.Id.Keyword_const => {
555		stack.append(state) catch unreachable;
556		if (addr_of_info.const_token != null) return self.parseError(token, "duplicate qualifier: const");
557		addr_of_info.const_token = token;
558		continue;
559		},
560		Token.Id.Keyword_volatile => {
561		stack.append(state) catch unreachable;
562		if (addr_of_info.volatile_token != null) return self.parseError(token, "duplicate qualifier: volatile");
563		addr_of_info.volatile_token = token;
564		continue;
565		},
566		else => {
567		self.putBackToken(token);
568		continue;
569		},
570		}
571		},
572
573		State.TypeExpr => \|dest_ptr\| {
574		const token = self.getNextToken();
575		if (token.id == Token.Id.Keyword_var) {
576		@panic("TODO param with type var");
577		}
578		self.putBackToken(token);
579
580		stack.append(State { .Expression = dest_ptr }) catch unreachable;
581		continue;
582		},
583
584		State.FnProto => \|fn_proto\| {
585		stack.append(State { .FnProtoAlign = fn_proto }) catch unreachable;
586		try stack.append(State { .ParamDecl = fn_proto });
587		try stack.append(State { .ExpectToken = Token.Id.LParen });
588
589		const next_token = self.getNextToken();
590		if (next_token.id == Token.Id.Identifier) {
591		fn_proto.name_token = next_token;
592		continue;
593		}
594		self.putBackToken(next_token);
595		continue;
596		},
597
598		State.FnProtoAlign => \|fn_proto\| {
599		const token = self.getNextToken();
600		if (token.id == Token.Id.Keyword_align) {
601		@panic("TODO fn proto align");
602		}
603		self.putBackToken(token);
604		stack.append(State {
605		.FnProtoReturnType = fn_proto,
606		}) catch unreachable;
607		continue;
608		},
609
610		State.FnProtoReturnType => \|fn_proto\| {
611		const token = self.getNextToken();
612		switch (token.id) {
613		Token.Id.Keyword_var => {
614		fn_proto.return_type = ast.NodeFnProto.ReturnType { .Infer = token };
615		},
616		Token.Id.Bang => {
617		fn_proto.return_type = ast.NodeFnProto.ReturnType { .InferErrorSet = undefined };
618		stack.append(State {
619		.TypeExpr = DestPtr {.Field = &fn_proto.return_type.InferErrorSet},
620		}) catch unreachable;
621		},
622		else => {
623		self.putBackToken(token);
624		fn_proto.return_type = ast.NodeFnProto.ReturnType { .Explicit = undefined };
625		stack.append(State {
626		.TypeExpr = DestPtr {.Field = &fn_proto.return_type.Explicit},
627		}) catch unreachable;
628		},
629		}
630		if (token.id == Token.Id.Keyword_align) {
631		@panic("TODO fn proto align");
632		}
633		continue;
634		},
635
636		State.ParamDecl => \|fn_proto\| {
637		var token = self.getNextToken();
638		if (token.id == Token.Id.RParen) {
639		continue;
640		}
641		const param_decl = try self.createAttachParamDecl(arena, &fn_proto.params);
642		if (token.id == Token.Id.Keyword_comptime) {
643		param_decl.comptime_token = token;
644		token = self.getNextToken();
645		} else if (token.id == Token.Id.Keyword_noalias) {
646		param_decl.noalias_token = token;
647		token = self.getNextToken();
648		}
649		if (token.id == Token.Id.Identifier) {
650		const next_token = self.getNextToken();
651		if (next_token.id == Token.Id.Colon) {
652		param_decl.name_token = token;
653		token = self.getNextToken();
654		} else {
655		self.putBackToken(next_token);
656		}
657		}
658		if (token.id == Token.Id.Ellipsis3) {
659		param_decl.var_args_token = token;
660		stack.append(State { .ExpectToken = Token.Id.RParen }) catch unreachable;
661		continue;
662		} else {
663		self.putBackToken(token);
664		}
665
666		stack.append(State { .ParamDecl = fn_proto }) catch unreachable;
667		try stack.append(State.ParamDeclComma);
668		try stack.append(State {
669		.TypeExpr = DestPtr {.Field = &param_decl.type_node}
670		});
671		continue;
672		},
673
674		State.ParamDeclComma => {
675		const token = self.getNextToken();
676		switch (token.id) {
677		Token.Id.RParen => {
678		_ = stack.pop(); // pop off the ParamDecl
679		continue;
680		},
681		Token.Id.Comma => continue,
682		else => return self.parseError(token, "expected ',' or ')', found {}", @tagName(token.id)),
683		}
684		},
685
686		State.FnDef => \|fn_proto\| {
687		const token = self.getNextToken();
688		switch(token.id) {
689		Token.Id.LBrace => {
690		const block = try self.createBlock(arena, token);
691		fn_proto.body_node = &block.base;
692		stack.append(State { .Block = block }) catch unreachable;
693		continue;
694		},
695		Token.Id.Semicolon => continue,
696		else => return self.parseError(token, "expected ';' or '{{', found {}", @tagName(token.id)),
697		}
698		},
699
700		State.Block => \|block\| {
701		const token = self.getNextToken();
702		switch (token.id) {
703		Token.Id.RBrace => {
704		block.end_token = token;
705		continue;
706		},
707		else => {
708		self.putBackToken(token);
709		stack.append(State { .Block = block }) catch unreachable;
710		try stack.append(State { .Statement = block });
711		continue;
712		},
713		}
714		},
715
716		State.Statement => \|block\| {
717		{
718		// Look for comptime var, comptime const
719		const comptime_token = self.getNextToken();
720		if (comptime_token.id == Token.Id.Keyword_comptime) {
721		const mut_token = self.getNextToken();
722		if (mut_token.id == Token.Id.Keyword_var or mut_token.id == Token.Id.Keyword_const) {
723		// TODO shouldn't need these casts
724		const var_decl = try self.createAttachVarDecl(arena, &block.statements, (?Token)(null),
725		mut_token, (?Token)(comptime_token), (?Token)(null));
726		try stack.append(State { .VarDecl = var_decl });
727		continue;
728		}
729		self.putBackToken(mut_token);
730		}
731		self.putBackToken(comptime_token);
732		}
733		{
734		// Look for const, var
735		const mut_token = self.getNextToken();
736		if (mut_token.id == Token.Id.Keyword_var or mut_token.id == Token.Id.Keyword_const) {
737		// TODO shouldn't need these casts
738		const var_decl = try self.createAttachVarDecl(arena, &block.statements, (?Token)(null),
739		mut_token, (?Token)(null), (?Token)(null));
740		try stack.append(State { .VarDecl = var_decl });
741		continue;
742		}
743		self.putBackToken(mut_token);
744		}
745
746		stack.append(State { .ExpectToken = Token.Id.Semicolon }) catch unreachable;
747		try stack.append(State { .Expression = DestPtr{.List = &block.statements} });
748		continue;
749		},
750
751		// These are data, not control flow.
752		State.InfixOp => unreachable,
753		State.PrefixOp => unreachable,
754		State.SuffixOp => unreachable,
755		State.Operand => unreachable,
756		}
757		}
758		}
759
760		fn popSuffixOp(stack: &ArrayList(State)) &ast.Node {
761		var expression: &ast.Node = undefined;
762		var left_leaf_ptr: &&ast.Node = &expression;
763		while (true) {
764		switch (stack.pop()) {
765		State.SuffixOp => \|suffix_op\| {
766		switch (suffix_op.id) {
767		ast.Node.Id.Call => {
768		const call = @fieldParentPtr(ast.NodeCall, "base", suffix_op);
769		*left_leaf_ptr = &call.base;
770		left_leaf_ptr = &call.callee;
771		continue;
772		},
773		else => unreachable,
774		}
775		},
776		State.Operand => \|operand\| {
777		*left_leaf_ptr = operand;
778		break;
779		},
780		else => unreachable,
781		}
782		}
783
784		return expression;
785		}
786
787		fn tokenIdToInfixOp(id: &const Token.Id) ?ast.NodeInfixOp.InfixOp {
788		return switch (*id) {
789		Token.Id.Ampersand => ast.NodeInfixOp.InfixOp.BitAnd,
790		Token.Id.AmpersandEqual => ast.NodeInfixOp.InfixOp.AssignBitAnd,
791		Token.Id.AngleBracketAngleBracketLeft => ast.NodeInfixOp.InfixOp.BitShiftLeft,
792		Token.Id.AngleBracketAngleBracketLeftEqual => ast.NodeInfixOp.InfixOp.AssignBitShiftLeft,
793		Token.Id.AngleBracketAngleBracketRight => ast.NodeInfixOp.InfixOp.BitShiftRight,
794		Token.Id.AngleBracketAngleBracketRightEqual => ast.NodeInfixOp.InfixOp.AssignBitShiftRight,
795		Token.Id.AngleBracketLeft => ast.NodeInfixOp.InfixOp.LessThan,
796		Token.Id.AngleBracketLeftEqual => ast.NodeInfixOp.InfixOp.LessOrEqual,
797		Token.Id.AngleBracketRight => ast.NodeInfixOp.InfixOp.GreaterThan,
798		Token.Id.AngleBracketRightEqual => ast.NodeInfixOp.InfixOp.GreaterOrEqual,
799		Token.Id.Asterisk => ast.NodeInfixOp.InfixOp.Mult,
800		Token.Id.AsteriskAsterisk => ast.NodeInfixOp.InfixOp.ArrayMult,
801		Token.Id.AsteriskEqual => ast.NodeInfixOp.InfixOp.AssignTimes,
802		Token.Id.AsteriskPercent => ast.NodeInfixOp.InfixOp.MultWrap,
803		Token.Id.AsteriskPercentEqual => ast.NodeInfixOp.InfixOp.AssignTimesWarp,
804		Token.Id.Bang => ast.NodeInfixOp.InfixOp.ErrorUnion,
805		Token.Id.BangEqual => ast.NodeInfixOp.InfixOp.BangEqual,
806		Token.Id.Caret => ast.NodeInfixOp.InfixOp.BitXor,
807		Token.Id.CaretEqual => ast.NodeInfixOp.InfixOp.AssignBitXor,
808		Token.Id.Equal => ast.NodeInfixOp.InfixOp.Assign,
809		Token.Id.EqualEqual => ast.NodeInfixOp.InfixOp.EqualEqual,
810		Token.Id.Keyword_and => ast.NodeInfixOp.InfixOp.BoolAnd,
811		Token.Id.Keyword_or => ast.NodeInfixOp.InfixOp.BoolOr,
812		Token.Id.Minus => ast.NodeInfixOp.InfixOp.Sub,
813		Token.Id.MinusEqual => ast.NodeInfixOp.InfixOp.AssignMinus,
814		Token.Id.MinusPercent => ast.NodeInfixOp.InfixOp.SubWrap,
815		Token.Id.MinusPercentEqual => ast.NodeInfixOp.InfixOp.AssignMinusWrap,
816		Token.Id.Percent => ast.NodeInfixOp.InfixOp.Mod,
817		Token.Id.PercentEqual => ast.NodeInfixOp.InfixOp.AssignMod,
818		Token.Id.Period => ast.NodeInfixOp.InfixOp.Period,
819		Token.Id.Pipe => ast.NodeInfixOp.InfixOp.BitOr,
820		Token.Id.PipeEqual => ast.NodeInfixOp.InfixOp.AssignBitOr,
821		Token.Id.PipePipe => ast.NodeInfixOp.InfixOp.MergeErrorSets,
822		Token.Id.Plus => ast.NodeInfixOp.InfixOp.Add,
823		Token.Id.PlusEqual => ast.NodeInfixOp.InfixOp.AssignPlus,
824		Token.Id.PlusPercent => ast.NodeInfixOp.InfixOp.AddWrap,
825		Token.Id.PlusPercentEqual => ast.NodeInfixOp.InfixOp.AssignPlusWrap,
826		Token.Id.PlusPlus => ast.NodeInfixOp.InfixOp.ArrayCat,
827		Token.Id.QuestionMarkQuestionMark => ast.NodeInfixOp.InfixOp.UnwrapMaybe,
828		Token.Id.Slash => ast.NodeInfixOp.InfixOp.Div,
829		Token.Id.SlashEqual => ast.NodeInfixOp.InfixOp.AssignDiv,
830		else => null,
831		};
832		}
833
834		fn initNode(self: &Parser, id: ast.Node.Id) ast.Node {
835		if (self.pending_line_comment_node) \|comment_node\| {
836		self.pending_line_comment_node = null;
837		return ast.Node {.id = id, .comment = comment_node};
838		}
839		return ast.Node {.id = id, .comment = null };
840		}
841
842		fn createRoot(self: &Parser, arena: &mem.Allocator) !&ast.NodeRoot {
843		const node = try arena.create(ast.NodeRoot);
844
845		*node = ast.NodeRoot {
846		.base = self.initNode(ast.Node.Id.Root),
847		.decls = ArrayList(&ast.Node).init(arena),
848		// initialized when we get the eof token
849		.eof_token = undefined,
850		};
851		return node;
852		}
853
854		fn createVarDecl(self: &Parser, arena: &mem.Allocator, visib_token: &const ?Token, mut_token: &const Token,
855		comptime_token: &const ?Token, extern_token: &const ?Token) !&ast.NodeVarDecl
856		{
857		const node = try arena.create(ast.NodeVarDecl);
858
859		*node = ast.NodeVarDecl {
860		.base = self.initNode(ast.Node.Id.VarDecl),
861		.visib_token = *visib_token,
862		.mut_token = *mut_token,
863		.comptime_token = *comptime_token,
864		.extern_token = *extern_token,
865		.type_node = null,
866		.align_node = null,
867		.init_node = null,
868		.lib_name = null,
869		// initialized later
870		.name_token = undefined,
871		.eq_token = undefined,
872		.semicolon_token = undefined,
873		};
874		return node;
875		}
876
877		fn createTestDecl(self: &Parser, arena: &mem.Allocator, test_token: &const Token, name_token: &const Token,
878		block: &ast.NodeBlock) !&ast.NodeTestDecl
879		{
880		const node = try arena.create(ast.NodeTestDecl);
881
882		*node = ast.NodeTestDecl {
883		.base = self.initNode(ast.Node.Id.TestDecl),
884		.test_token = *test_token,
885		.name_token = *name_token,
886		.body_node = &block.base,
887		};
888		return node;
889		}
890
891		fn createFnProto(self: &Parser, arena: &mem.Allocator, fn_token: &const Token, extern_token: &const ?Token,
892		cc_token: &const ?Token, visib_token: &const ?Token, inline_token: &const ?Token) !&ast.NodeFnProto
893		{
894		const node = try arena.create(ast.NodeFnProto);
895
896		*node = ast.NodeFnProto {
897		.base = self.initNode(ast.Node.Id.FnProto),
898		.visib_token = *visib_token,
899		.name_token = null,
900		.fn_token = *fn_token,
901		.params = ArrayList(&ast.Node).init(arena),
902		.return_type = undefined,
903		.var_args_token = null,
904		.extern_token = *extern_token,
905		.inline_token = *inline_token,
906		.cc_token = *cc_token,
907		.body_node = null,
908		.lib_name = null,
909		.align_expr = null,
910		};
911		return node;
912		}
913
914		fn createParamDecl(self: &Parser, arena: &mem.Allocator) !&ast.NodeParamDecl {
915		const node = try arena.create(ast.NodeParamDecl);
916
917		*node = ast.NodeParamDecl {
918		.base = self.initNode(ast.Node.Id.ParamDecl),
919		.comptime_token = null,
920		.noalias_token = null,
921		.name_token = null,
922		.type_node = undefined,
923		.var_args_token = null,
924		};
925		return node;
926		}
927
928		fn createBlock(self: &Parser, arena: &mem.Allocator, begin_token: &const Token) !&ast.NodeBlock {
929		const node = try arena.create(ast.NodeBlock);
930
931		*node = ast.NodeBlock {
932		.base = self.initNode(ast.Node.Id.Block),
933		.begin_token = *begin_token,
934		.end_token = undefined,
935		.statements = ArrayList(&ast.Node).init(arena),
936		};
937		return node;
938		}
939
940		fn createInfixOp(self: &Parser, arena: &mem.Allocator, op_token: &const Token, op: &const ast.NodeInfixOp.InfixOp) !&ast.NodeInfixOp {
941		const node = try arena.create(ast.NodeInfixOp);
942
943		*node = ast.NodeInfixOp {
944		.base = self.initNode(ast.Node.Id.InfixOp),
945		.op_token = *op_token,
946		.lhs = undefined,
947		.op = *op,
948		.rhs = undefined,
949		};
950		return node;
951		}
952
953		fn createPrefixOp(self: &Parser, arena: &mem.Allocator, op_token: &const Token, op: &const ast.NodePrefixOp.PrefixOp) !&ast.NodePrefixOp {
954		const node = try arena.create(ast.NodePrefixOp);
955
956		*node = ast.NodePrefixOp {
957		.base = self.initNode(ast.Node.Id.PrefixOp),
958		.op_token = *op_token,
959		.op = *op,
960		.rhs = undefined,
961		};
962		return node;
963		}
964
965		fn createIdentifier(self: &Parser, arena: &mem.Allocator, name_token: &const Token) !&ast.NodeIdentifier {
966		const node = try arena.create(ast.NodeIdentifier);
967
968		*node = ast.NodeIdentifier {
969		.base = self.initNode(ast.Node.Id.Identifier),
970		.name_token = *name_token,
971		};
972		return node;
973		}
974
975		fn createIntegerLiteral(self: &Parser, arena: &mem.Allocator, token: &const Token) !&ast.NodeIntegerLiteral {
976		const node = try arena.create(ast.NodeIntegerLiteral);
977
978		*node = ast.NodeIntegerLiteral {
979		.base = self.initNode(ast.Node.Id.IntegerLiteral),
980		.token = *token,
981		};
982		return node;
983		}
984
985		fn createFloatLiteral(self: &Parser, arena: &mem.Allocator, token: &const Token) !&ast.NodeFloatLiteral {
986		const node = try arena.create(ast.NodeFloatLiteral);
987
988		*node = ast.NodeFloatLiteral {
989		.base = self.initNode(ast.Node.Id.FloatLiteral),
990		.token = *token,
991		};
992		return node;
993		}
994
995		fn createUndefined(self: &Parser, arena: &mem.Allocator, token: &const Token) !&ast.NodeUndefinedLiteral {
996		const node = try arena.create(ast.NodeUndefinedLiteral);
997
998		*node = ast.NodeUndefinedLiteral {
999		.base = self.initNode(ast.Node.Id.UndefinedLiteral),
1000		.token = *token,
1001		};
1002		return node;
1003		}
1004
1005		fn createAttachIdentifier(self: &Parser, arena: &mem.Allocator, dest_ptr: &const DestPtr, name_token: &const Token) !&ast.NodeIdentifier {
1006		const node = try self.createIdentifier(arena, name_token);
1007		try dest_ptr.store(&node.base);
1008		return node;
1009		}
1010
1011		fn createAttachParamDecl(self: &Parser, arena: &mem.Allocator, list: &ArrayList(&ast.Node)) !&ast.NodeParamDecl {
1012		const node = try self.createParamDecl(arena);
1013		try list.append(&node.base);
1014		return node;
1015		}
1016
1017		fn createAttachFnProto(self: &Parser, arena: &mem.Allocator, list: &ArrayList(&ast.Node), fn_token: &const Token,
1018		extern_token: &const ?Token, cc_token: &const ?Token, visib_token: &const ?Token,
1019		inline_token: &const ?Token) !&ast.NodeFnProto
1020		{
1021		const node = try self.createFnProto(arena, fn_token, extern_token, cc_token, visib_token, inline_token);
1022		try list.append(&node.base);
1023		return node;
1024		}
1025
1026		fn createAttachVarDecl(self: &Parser, arena: &mem.Allocator, list: &ArrayList(&ast.Node),
1027		visib_token: &const ?Token, mut_token: &const Token, comptime_token: &const ?Token,
1028		extern_token: &const ?Token) !&ast.NodeVarDecl
1029		{
1030		const node = try self.createVarDecl(arena, visib_token, mut_token, comptime_token, extern_token);
1031		try list.append(&node.base);
1032		return node;
1033		}
1034
1035		fn createAttachTestDecl(self: &Parser, arena: &mem.Allocator, list: &ArrayList(&ast.Node),
1036		test_token: &const Token, name_token: &const Token, block: &ast.NodeBlock) !&ast.NodeTestDecl
1037		{
1038		const node = try self.createTestDecl(arena, test_token, name_token, block);
1039		try list.append(&node.base);
1040		return node;
1041		}
1042
1043		fn parseError(self: &Parser, token: &const Token, comptime fmt: []const u8, args: ...) (error{ParseError}) {
1044		const loc = self.tokenizer.getTokenLocation(token);
1045		warn("{}:{}:{}: error: " ++ fmt ++ "\n", self.source_file_name, token.line + 1, token.column + 1, args);
1046		warn("{}\n", self.tokenizer.buffer[loc.line_start..loc.line_end]);
1047		{
1048		var i: usize = 0;
1049		while (i < token.column) : (i += 1) {
1050		warn(" ");
1051		}
1052		}
1053		{
1054		const caret_count = token.end - token.start;
1055		var i: usize = 0;
1056		while (i < caret_count) : (i += 1) {
1057		warn("~");
1058		}
1059		}
1060		warn("\n");
1061		return error.ParseError;
1062		}
1063
1064		fn expectToken(self: &Parser, token: &const Token, id: @TagType(Token.Id)) !void {
1065		if (token.id != id) {
1066		return self.parseError(token, "expected {}, found {}", @tagName(id), @tagName(token.id));
1067		}
1068		}
1069
1070		fn eatToken(self: &Parser, id: @TagType(Token.Id)) !Token {
1071		const token = self.getNextToken();
1072		try self.expectToken(token, id);
1073		return token;
1074		}
1075
1076		fn putBackToken(self: &Parser, token: &const Token) void {
1077		self.put_back_tokens[self.put_back_count] = *token;
1078		self.put_back_count += 1;
1079		}
1080
1081		fn getNextToken(self: &Parser) Token {
1082		if (self.put_back_count != 0) {
1083		const put_back_index = self.put_back_count - 1;
1084		const put_back_token = self.put_back_tokens[put_back_index];
1085		self.put_back_count = put_back_index;
1086		return put_back_token;
1087		} else {
1088		return self.tokenizer.next();
1089		}
1090		}
1091
1092		const RenderAstFrame = struct {
1093		node: &ast.Node,
1094		indent: usize,
1095		};
1096
1097		pub fn renderAst(self: &Parser, stream: var, root_node: &ast.NodeRoot) !void {
1098		var stack = self.initUtilityArrayList(RenderAstFrame);
1099		defer self.deinitUtilityArrayList(stack);
1100
1101		try stack.append(RenderAstFrame {
1102		.node = &root_node.base,
1103		.indent = 0,
1104		});
1105
1106		while (stack.popOrNull()) \|frame\| {
1107		{
1108		var i: usize = 0;
1109		while (i < frame.indent) : (i += 1) {
1110		try stream.print(" ");
1111		}
1112		}
1113		try stream.print("{}\n", @tagName(frame.node.id));
1114		var child_i: usize = 0;
1115		while (frame.node.iterate(child_i)) \|child\| : (child_i += 1) {
1116		try stack.append(RenderAstFrame {
1117		.node = child,
1118		.indent = frame.indent + 2,
1119		});
1120		}
1121		}
1122		}
1123
1124		const RenderState = union(enum) {
1125		TopLevelDecl: &ast.Node,
1126		FnProtoRParen: &ast.NodeFnProto,
1127		ParamDecl: &ast.Node,
1128		Text: []const u8,
1129		Expression: &ast.Node,
1130		VarDecl: &ast.NodeVarDecl,
1131		Statement: &ast.Node,
1132		PrintIndent,
1133		Indent: usize,
1134		};
1135
1136		pub fn renderSource(self: &Parser, stream: var, root_node: &ast.NodeRoot) !void {
1137		var stack = self.initUtilityArrayList(RenderState);
1138		defer self.deinitUtilityArrayList(stack);
1139
1140		{
1141		try stack.append(RenderState { .Text = "\n"});
1142
1143		var i = root_node.decls.len;
1144		while (i != 0) {
1145		i -= 1;
1146		const decl = root_node.decls.items[i];
1147		try stack.append(RenderState {.TopLevelDecl = decl});
1148		if (i != 0) {
1149		try stack.append(RenderState {
1150		.Text = blk: {
1151		const prev_node = root_node.decls.at(i - 1);
1152		const prev_line_index = prev_node.lastToken().line;
1153		const this_line_index = decl.firstToken().line;
1154		if (this_line_index - prev_line_index >= 2) {
1155		break :blk "\n\n";
1156		}
1157		break :blk "\n";
1158		},
1159		});
1160		}
1161		}
1162		}
1163
1164		const indent_delta = 4;
1165		var indent: usize = 0;
1166		while (stack.popOrNull()) \|state\| {
1167		switch (state) {
1168		RenderState.TopLevelDecl => \|decl\| {
1169		switch (decl.id) {
1170		ast.Node.Id.FnProto => {
1171		const fn_proto = @fieldParentPtr(ast.NodeFnProto, "base", decl);
1172		if (fn_proto.visib_token) \|visib_token\| {
1173		switch (visib_token.id) {
1174		Token.Id.Keyword_pub => try stream.print("pub "),
1175		Token.Id.Keyword_export => try stream.print("export "),
1176		else => unreachable,
1177		}
1178		}
1179		if (fn_proto.extern_token) \|extern_token\| {
1180		try stream.print("{} ", self.tokenizer.getTokenSlice(extern_token));
1181		}
1182		try stream.print("fn");
1183
1184		if (fn_proto.name_token) \|name_token\| {
1185		try stream.print(" {}", self.tokenizer.getTokenSlice(name_token));
1186		}
1187
1188		try stream.print("(");
1189
1190		if (fn_proto.body_node == null) {
1191		try stack.append(RenderState { .Text = ";" });
1192		}
1193
1194		try stack.append(RenderState { .FnProtoRParen = fn_proto});
1195		var i = fn_proto.params.len;
1196		while (i != 0) {
1197		i -= 1;
1198		const param_decl_node = fn_proto.params.items[i];
1199		try stack.append(RenderState { .ParamDecl = param_decl_node});
1200		if (i != 0) {
1201		try stack.append(RenderState { .Text = ", " });
1202		}
1203		}
1204		},
1205		ast.Node.Id.VarDecl => {
1206		const var_decl = @fieldParentPtr(ast.NodeVarDecl, "base", decl);
1207		try stack.append(RenderState { .VarDecl = var_decl});
1208		},
1209		ast.Node.Id.TestDecl => {
1210		const test_decl = @fieldParentPtr(ast.NodeTestDecl, "base", decl);
1211		try stream.print("test {} ", self.tokenizer.getTokenSlice(test_decl.name_token));
1212		try stack.append(RenderState { .Expression = test_decl.body_node });
1213		},
1214		else => unreachable,
1215		}
1216		},
1217
1218		RenderState.VarDecl => \|var_decl\| {
1219		if (var_decl.visib_token) \|visib_token\| {
1220		try stream.print("{} ", self.tokenizer.getTokenSlice(visib_token));
1221		}
1222		if (var_decl.extern_token) \|extern_token\| {
1223		try stream.print("{} ", self.tokenizer.getTokenSlice(extern_token));
1224		if (var_decl.lib_name != null) {
1225		@panic("TODO");
1226		}
1227		}
1228		if (var_decl.comptime_token) \|comptime_token\| {
1229		try stream.print("{} ", self.tokenizer.getTokenSlice(comptime_token));
1230		}
1231		try stream.print("{} ", self.tokenizer.getTokenSlice(var_decl.mut_token));
1232		try stream.print("{}", self.tokenizer.getTokenSlice(var_decl.name_token));
1233
1234		try stack.append(RenderState { .Text = ";" });
1235		if (var_decl.init_node) \|init_node\| {
1236		try stack.append(RenderState { .Expression = init_node });
1237		try stack.append(RenderState { .Text = " = " });
1238		}
1239		if (var_decl.align_node) \|align_node\| {
1240		try stack.append(RenderState { .Text = ")" });
1241		try stack.append(RenderState { .Expression = align_node });
1242		try stack.append(RenderState { .Text = " align(" });
1243		}
1244		if (var_decl.type_node) \|type_node\| {
1245		try stream.print(": ");
1246		try stack.append(RenderState { .Expression = type_node });
1247		}
1248		},
1249
1250		RenderState.ParamDecl => \|base\| {
1251		const param_decl = @fieldParentPtr(ast.NodeParamDecl, "base", base);
1252		if (param_decl.comptime_token) \|comptime_token\| {
1253		try stream.print("{} ", self.tokenizer.getTokenSlice(comptime_token));
1254		}
1255		if (param_decl.noalias_token) \|noalias_token\| {
1256		try stream.print("{} ", self.tokenizer.getTokenSlice(noalias_token));
1257		}
1258		if (param_decl.name_token) \|name_token\| {
1259		try stream.print("{}: ", self.tokenizer.getTokenSlice(name_token));
1260		}
1261		if (param_decl.var_args_token) \|var_args_token\| {
1262		try stream.print("{}", self.tokenizer.getTokenSlice(var_args_token));
1263		} else {
1264		try stack.append(RenderState { .Expression = param_decl.type_node});
1265		}
1266		},
1267		RenderState.Text => \|bytes\| {
1268		try stream.write(bytes);
1269		},
1270		RenderState.Expression => \|base\| switch (base.id) {
1271		ast.Node.Id.Identifier => {
1272		const identifier = @fieldParentPtr(ast.NodeIdentifier, "base", base);
1273		try stream.print("{}", self.tokenizer.getTokenSlice(identifier.name_token));
1274		},
1275		ast.Node.Id.Block => {
1276		const block = @fieldParentPtr(ast.NodeBlock, "base", base);
1277		if (block.statements.len == 0) {
1278		try stream.write("{}");
1279		} else {
1280		try stream.write("{");
1281		try stack.append(RenderState { .Text = "}"});
1282		try stack.append(RenderState.PrintIndent);
1283		try stack.append(RenderState { .Indent = indent});
1284		try stack.append(RenderState { .Text = "\n"});
1285		var i = block.statements.len;
1286		while (i != 0) {
1287		i -= 1;
1288		const statement_node = block.statements.items[i];
1289		try stack.append(RenderState { .Statement = statement_node});
1290		try stack.append(RenderState.PrintIndent);
1291		try stack.append(RenderState { .Indent = indent + indent_delta});
1292		try stack.append(RenderState {
1293		.Text = blk: {
1294		if (i != 0) {
1295		const prev_statement_node = block.statements.items[i - 1];
1296		const prev_line_index = prev_statement_node.lastToken().line;
1297		const this_line_index = statement_node.firstToken().line;
1298		if (this_line_index - prev_line_index >= 2) {
1299		break :blk "\n\n";
1300		}
1301		}
1302		break :blk "\n";
1303		},
1304		});
1305		}
1306		}
1307		},
1308		ast.Node.Id.InfixOp => {
1309		const prefix_op_node = @fieldParentPtr(ast.NodeInfixOp, "base", base);
1310		try stack.append(RenderState { .Expression = prefix_op_node.rhs });
1311		const text = switch (prefix_op_node.op) {
1312		ast.NodeInfixOp.InfixOp.Add => " + ",
1313		ast.NodeInfixOp.InfixOp.AddWrap => " +% ",
1314		ast.NodeInfixOp.InfixOp.ArrayCat => " ++ ",
1315		ast.NodeInfixOp.InfixOp.ArrayMult => " ** ",
1316		ast.NodeInfixOp.InfixOp.Assign => " = ",
1317		ast.NodeInfixOp.InfixOp.AssignBitAnd => " &= ",
1318		ast.NodeInfixOp.InfixOp.AssignBitOr => " \|= ",
1319		ast.NodeInfixOp.InfixOp.AssignBitShiftLeft => " <<= ",
1320		ast.NodeInfixOp.InfixOp.AssignBitShiftRight => " >>= ",
1321		ast.NodeInfixOp.InfixOp.AssignBitXor => " ^= ",
1322		ast.NodeInfixOp.InfixOp.AssignDiv => " /= ",
1323		ast.NodeInfixOp.InfixOp.AssignMinus => " -= ",
1324		ast.NodeInfixOp.InfixOp.AssignMinusWrap => " -%= ",
1325		ast.NodeInfixOp.InfixOp.AssignMod => " %= ",
1326		ast.NodeInfixOp.InfixOp.AssignPlus => " += ",
1327		ast.NodeInfixOp.InfixOp.AssignPlusWrap => " +%= ",
1328		ast.NodeInfixOp.InfixOp.AssignTimes => " *= ",
1329		ast.NodeInfixOp.InfixOp.AssignTimesWarp => " *%= ",
1330		ast.NodeInfixOp.InfixOp.BangEqual => " != ",
1331		ast.NodeInfixOp.InfixOp.BitAnd => " & ",
1332		ast.NodeInfixOp.InfixOp.BitOr => " \| ",
1333		ast.NodeInfixOp.InfixOp.BitShiftLeft => " << ",
1334		ast.NodeInfixOp.InfixOp.BitShiftRight => " >> ",
1335		ast.NodeInfixOp.InfixOp.BitXor => " ^ ",
1336		ast.NodeInfixOp.InfixOp.BoolAnd => " and ",
1337		ast.NodeInfixOp.InfixOp.BoolOr => " or ",
1338		ast.NodeInfixOp.InfixOp.Div => " / ",
1339		ast.NodeInfixOp.InfixOp.EqualEqual => " == ",
1340		ast.NodeInfixOp.InfixOp.ErrorUnion => "!",
1341		ast.NodeInfixOp.InfixOp.GreaterOrEqual => " >= ",
1342		ast.NodeInfixOp.InfixOp.GreaterThan => " > ",
1343		ast.NodeInfixOp.InfixOp.LessOrEqual => " <= ",
1344		ast.NodeInfixOp.InfixOp.LessThan => " < ",
1345		ast.NodeInfixOp.InfixOp.MergeErrorSets => " \|\| ",
1346		ast.NodeInfixOp.InfixOp.Mod => " % ",
1347		ast.NodeInfixOp.InfixOp.Mult => " * ",
1348		ast.NodeInfixOp.InfixOp.MultWrap => " *% ",
1349		ast.NodeInfixOp.InfixOp.Period => ".",
1350		ast.NodeInfixOp.InfixOp.Sub => " - ",
1351		ast.NodeInfixOp.InfixOp.SubWrap => " -% ",
1352		ast.NodeInfixOp.InfixOp.UnwrapMaybe => " ?? ",
1353		};
1354
1355		try stack.append(RenderState { .Text = text });
1356		try stack.append(RenderState { .Expression = prefix_op_node.lhs });
1357		},
1358		ast.Node.Id.PrefixOp => {
1359		const prefix_op_node = @fieldParentPtr(ast.NodePrefixOp, "base", base);
1360		try stack.append(RenderState { .Expression = prefix_op_node.rhs });
1361		switch (prefix_op_node.op) {
1362		ast.NodePrefixOp.PrefixOp.AddrOf => \|addr_of_info\| {
1363		try stream.write("&");
1364		if (addr_of_info.volatile_token != null) {
1365		try stack.append(RenderState { .Text = "volatile "});
1366		}
1367		if (addr_of_info.const_token != null) {
1368		try stack.append(RenderState { .Text = "const "});
1369		}
1370		if (addr_of_info.align_expr) \|align_expr\| {
1371		try stream.print("align(");
1372		try stack.append(RenderState { .Text = ") "});
1373		try stack.append(RenderState { .Expression = align_expr});
1374		}
1375		},
1376		ast.NodePrefixOp.PrefixOp.BitNot => try stream.write("~"),
1377		ast.NodePrefixOp.PrefixOp.BoolNot => try stream.write("!"),
1378		ast.NodePrefixOp.PrefixOp.Deref => try stream.write("*"),
1379		ast.NodePrefixOp.PrefixOp.Negation => try stream.write("-"),
1380		ast.NodePrefixOp.PrefixOp.NegationWrap => try stream.write("-%"),
1381		ast.NodePrefixOp.PrefixOp.Return => try stream.write("return "),
1382		ast.NodePrefixOp.PrefixOp.Try => try stream.write("try "),
1383		ast.NodePrefixOp.PrefixOp.UnwrapMaybe => try stream.write("??"),
1384		}
1385		},
1386		ast.Node.Id.IntegerLiteral => {
1387		const integer_literal = @fieldParentPtr(ast.NodeIntegerLiteral, "base", base);
1388		try stream.print("{}", self.tokenizer.getTokenSlice(integer_literal.token));
1389		},
1390		ast.Node.Id.FloatLiteral => {
1391		const float_literal = @fieldParentPtr(ast.NodeFloatLiteral, "base", base);
1392		try stream.print("{}", self.tokenizer.getTokenSlice(float_literal.token));
1393		},
1394		ast.Node.Id.StringLiteral => {
1395		const string_literal = @fieldParentPtr(ast.NodeStringLiteral, "base", base);
1396		try stream.print("{}", self.tokenizer.getTokenSlice(string_literal.token));
1397		},
1398		ast.Node.Id.UndefinedLiteral => {
1399		const undefined_literal = @fieldParentPtr(ast.NodeUndefinedLiteral, "base", base);
1400		try stream.print("{}", self.tokenizer.getTokenSlice(undefined_literal.token));
1401		},
1402		ast.Node.Id.BuiltinCall => {
1403		const builtin_call = @fieldParentPtr(ast.NodeBuiltinCall, "base", base);
1404		try stream.print("{}(", self.tokenizer.getTokenSlice(builtin_call.builtin_token));
1405		try stack.append(RenderState { .Text = ")"});
1406		var i = builtin_call.params.len;
1407		while (i != 0) {
1408		i -= 1;
1409		const param_node = builtin_call.params.at(i);
1410		try stack.append(RenderState { .Expression = param_node});
1411		if (i != 0) {
1412		try stack.append(RenderState { .Text = ", " });
1413		}
1414		}
1415		},
1416		ast.Node.Id.Call => {
1417		const call = @fieldParentPtr(ast.NodeCall, "base", base);
1418		try stack.append(RenderState { .Text = ")"});
1419		var i = call.params.len;
1420		while (i != 0) {
1421		i -= 1;
1422		const param_node = call.params.at(i);
1423		try stack.append(RenderState { .Expression = param_node});
1424		if (i != 0) {
1425		try stack.append(RenderState { .Text = ", " });
1426		}
1427		}
1428		try stack.append(RenderState { .Text = "("});
1429		try stack.append(RenderState { .Expression = call.callee });
1430		},
1431		ast.Node.Id.FnProto => @panic("TODO fn proto in an expression"),
1432		ast.Node.Id.LineComment => @panic("TODO render line comment in an expression"),
1433
1434		ast.Node.Id.Root,
1435		ast.Node.Id.VarDecl,
1436		ast.Node.Id.TestDecl,
1437		ast.Node.Id.ParamDecl => unreachable,
1438		},
1439		RenderState.FnProtoRParen => \|fn_proto\| {
1440		try stream.print(")");
1441		if (fn_proto.align_expr != null) {
1442		@panic("TODO");
1443		}
1444		try stream.print(" ");
1445		if (fn_proto.body_node) \|body_node\| {
1446		try stack.append(RenderState { .Expression = body_node});
1447		try stack.append(RenderState { .Text = " "});
1448		}
1449		switch (fn_proto.return_type) {
1450		ast.NodeFnProto.ReturnType.Explicit => \|node\| {
1451		try stack.append(RenderState { .Expression = node});
1452		},
1453		ast.NodeFnProto.ReturnType.Infer => {
1454		try stream.print("var");
1455		},
1456		ast.NodeFnProto.ReturnType.InferErrorSet => \|node\| {
1457		try stream.print("!");
1458		try stack.append(RenderState { .Expression = node});
1459		},
1460		}
1461		},
1462		RenderState.Statement => \|base\| {
1463		if (base.comment) \|comment\| {
1464		for (comment.lines.toSliceConst()) \|line_token\| {
1465		try stream.print("{}\n", self.tokenizer.getTokenSlice(line_token));
1466		try stream.writeByteNTimes(' ', indent);
1467		}
1468		}
1469		switch (base.id) {
1470		ast.Node.Id.VarDecl => {
1471		const var_decl = @fieldParentPtr(ast.NodeVarDecl, "base", base);
1472		try stack.append(RenderState { .VarDecl = var_decl});
1473		},
1474		else => {
1475		try stack.append(RenderState { .Text = ";"});
1476		try stack.append(RenderState { .Expression = base});
1477		},
1478		}
1479		},
1480		RenderState.Indent => \|new_indent\| indent = new_indent,
1481		RenderState.PrintIndent => try stream.writeByteNTimes(' ', indent),
1482		}
1483		}
1484		}
1485
1486		fn initUtilityArrayList(self: &Parser, comptime T: type) ArrayList(T) {
1487		const new_byte_count = self.utility_bytes.len - self.utility_bytes.len % @sizeOf(T);
1488		self.utility_bytes = self.util_allocator.alignedShrink(u8, utility_bytes_align, self.utility_bytes, new_byte_count);
1489		const typed_slice = ([]T)(self.utility_bytes);
1490		return ArrayList(T) {
1491		.allocator = self.util_allocator,
1492		.items = typed_slice,
1493		.len = 0,
1494		};
1495		}
1496
1497		fn deinitUtilityArrayList(self: &Parser, list: var) void {
1498		self.utility_bytes = ([]align(utility_bytes_align) u8)(list.items);
1499		}
1500
1501		};
1502
1503		var fixed_buffer_mem: [100 * 1024]u8 = undefined;
1504
1505		fn testParse(source: []const u8, allocator: &mem.Allocator) ![]u8 {
1506		var tokenizer = Tokenizer.init(source);
1507		var parser = Parser.init(&tokenizer, allocator, "(memory buffer)");
1508		defer parser.deinit();
1509
1510		var tree = try parser.parse();
1511		defer tree.deinit();
1512
1513		var buffer = try std.Buffer.initSize(allocator, 0);
1514		errdefer buffer.deinit();
1515
1516		var buffer_out_stream = io.BufferOutStream.init(&buffer);
1517		try parser.renderSource(&buffer_out_stream.stream, tree.root_node);
1518		return buffer.toOwnedSlice();
1519		}
1520
1521		fn testCanonical(source: []const u8) !void {
1522		const needed_alloc_count = x: {
1523		// Try it once with unlimited memory, make sure it works
1524		var fixed_allocator = std.heap.FixedBufferAllocator.init(fixed_buffer_mem[0..]);
1525		var failing_allocator = std.debug.FailingAllocator.init(&fixed_allocator.allocator, @maxValue(usize));
1526		const result_source = try testParse(source, &failing_allocator.allocator);
1527		if (!mem.eql(u8, result_source, source)) {
1528		warn("\n====== expected this output: =========\n");
1529		warn("{}", source);
1530		warn("\n======== instead found this: =========\n");
1531		warn("{}", result_source);
1532		warn("\n======================================\n");
1533		return error.TestFailed;
1534		}
1535		failing_allocator.allocator.free(result_source);
1536		break :x failing_allocator.index;
1537		};
1538
1539		var fail_index: usize = 0;
1540		while (fail_index < needed_alloc_count) : (fail_index += 1) {
1541		var fixed_allocator = std.heap.FixedBufferAllocator.init(fixed_buffer_mem[0..]);
1542		var failing_allocator = std.debug.FailingAllocator.init(&fixed_allocator.allocator, fail_index);
1543		if (testParse(source, &failing_allocator.allocator)) \|_\| {
1544		return error.NondeterministicMemoryUsage;
1545		} else \|err\| switch (err) {
1546		error.OutOfMemory => {
1547		if (failing_allocator.allocated_bytes != failing_allocator.freed_bytes) {
1548		warn("\nfail_index: {}/{}\nallocated bytes: {}\nfreed bytes: {}\nallocations: {}\ndeallocations: {}\n",
1549		fail_index, needed_alloc_count,
1550		failing_allocator.allocated_bytes, failing_allocator.freed_bytes,
1551		failing_allocator.index, failing_allocator.deallocations);
1552		return error.MemoryLeakDetected;
1553		}
1554		},
1555		error.ParseError => @panic("test failed"),
1556		}
1557		}
1558		}
1559
1560		test "zig fmt" {
1561		try testCanonical(
1562		\\const std = @import("std");
1563		\\
1564		\\pub fn main() !void {
1565		\\ // If this program is run without stdout attached, exit with an error.
1566		\\ // another comment
1567		\\ var stdout_file = try std.io.getStdOut;
1568		\\}
1569		\\
1570		);
1571
1572		try testCanonical(
1573		\\const std = @import("std");
1574		\\
1575		\\pub fn main() !void {
1576		\\ var stdout_file = try std.io.getStdOut;
1577		\\ var stdout_file = try std.io.getStdOut;
1578		\\
1579		\\ var stdout_file = try std.io.getStdOut;
1580		\\ var stdout_file = try std.io.getStdOut;
1581		\\}
1582		\\
1583		);
1584
1585		try testCanonical(
1586		\\pub fn main() !void {}
1587		\\pub fn main() var {}
1588		\\pub fn main() i32 {}
1589		\\
1590		);
1591
1592		try testCanonical(
1593		\\const std = @import("std");
1594		\\const std = @import();
1595		\\
1596		);
1597
1598		try testCanonical(
1599		\\extern fn puts(s: &const u8) c_int;
1600		\\
1601		);
1602
1603		try testCanonical(
1604		\\const a = b;
1605		\\pub const a = b;
1606		\\var a = b;
1607		\\pub var a = b;
1608		\\const a: i32 = b;
1609		\\pub const a: i32 = b;
1610		\\var a: i32 = b;
1611		\\pub var a: i32 = b;
1612		\\
1613		);
1614
1615		try testCanonical(
1616		\\extern var foo: c_int;
1617		\\
1618		);
1619
1620		try testCanonical(
1621		\\var foo: c_int align(1);
1622		\\
1623		);
1624
1625		try testCanonical(
1626		\\fn main(argc: c_int, argv: &&u8) c_int {
1627		\\ const a = b;
1628		\\}
1629		\\
1630		);
1631
1632		try testCanonical(
1633		\\fn foo(argc: c_int, argv: &&u8) c_int {
1634		\\ return 0;
1635		\\}
1636		\\
1637		);
1638
1639		try testCanonical(
1640		\\extern fn f1(s: &align(&u8) u8) c_int;
1641		\\
1642		);
1643
1644		try testCanonical(
1645		\\extern fn f1(s: &&align(1) &const &volatile u8) c_int;
1646		\\extern fn f2(s: &align(1) const &align(1) volatile &const volatile u8) c_int;
1647		\\extern fn f3(s: &align(1) const volatile u8) c_int;
1648		\\
1649		);
1650
1651		try testCanonical(
1652		\\fn f1(a: bool, b: bool) bool {
1653		\\ a != b;
1654		\\ return a == b;
1655		\\}
1656		\\
1657		);
1658
1659		try testCanonical(
1660		\\test "test name" {
1661		\\ const a = 1;
1662		\\ var b = 1;
1663		\\}
1664		\\
1665		);
1666
1667		try testCanonical(
1668		\\test "infix operators" {
1669		\\ var i = undefined;
1670		\\ i = 2;
1671		\\ i *= 2;
1672		\\ i \|= 2;
1673		\\ i ^= 2;
1674		\\ i <<= 2;
1675		\\ i >>= 2;
1676		\\ i &= 2;
1677		\\ i *= 2;
1678		\\ i *%= 2;
1679		\\ i -= 2;
1680		\\ i -%= 2;
1681		\\ i += 2;
1682		\\ i +%= 2;
1683		\\ i /= 2;
1684		\\ i %= 2;
1685		\\ _ = i == i;
1686		\\ _ = i != i;
1687		\\ _ = i != i;
1688		\\ _ = i.i;
1689		\\ _ = i \|\| i;
1690		\\ _ = i!i;
1691		\\ _ = i ** i;
1692		\\ _ = i ++ i;
1693		\\ _ = i ?? i;
1694		\\ _ = i % i;
1695		\\ _ = i / i;
1696		\\ _ = i *% i;
1697		\\ _ = i * i;
1698		\\ _ = i -% i;
1699		\\ _ = i - i;
1700		\\ _ = i +% i;
1701		\\ _ = i + i;
1702		\\ _ = i << i;
1703		\\ _ = i >> i;
1704		\\ _ = i & i;
1705		\\ _ = i ^ i;
1706		\\ _ = i \| i;
1707		\\ _ = i >= i;
1708		\\ _ = i <= i;
1709		\\ _ = i > i;
1710		\\ _ = i < i;
1711		\\ _ = i and i;
1712		\\ _ = i or i;
1713		\\}
1714		\\
1715		);
1716
1717		try testCanonical(
1718		\\test "prefix operators" {
1719		\\ --%~??!*&0;
1720		\\}
1721		\\
1722		);
1723
1724		try testCanonical(
1725		\\test "test calls" {
1726		\\ a();
1727		\\ a(1);
1728		\\ a(1, 2);
1729		\\ a(1, 2) + a(1, 2);
1730		\\}
1731		\\
1732		);
1733		}

std/zig/parser_test.zig created+1183

...	...	@@ -0,0 +1,1183 @@
	1	test "zig fmt: same-line comment after a statement" {
	2	try testCanonical(
	3	\\test "" {
	4	\\ a = b;
	5	\\ debug.assert(H.digest_size <= H.block_size); // HMAC makes this assumption
	6	\\ a = b;
	7	\\}
	8	\\
	9	);
	10	}
	11
	12	test "zig fmt: same-line comment after var decl in struct" {
	13	try testCanonical(
	14	\\pub const vfs_cap_data = extern struct {
	15	\\ const Data = struct {}; // when on disk.
	16	\\};
	17	\\
	18	);
	19	}
	20
	21	test "zig fmt: same-line comment after field decl" {
	22	try testCanonical(
	23	\\pub const dirent = extern struct {
	24	\\ d_name: u8,
	25	\\ d_name: u8, // comment 1
	26	\\ d_name: u8,
	27	\\ d_name: u8, // comment 2
	28	\\ d_name: u8,
	29	\\};
	30	\\
	31	);
	32	}
	33
	34	test "zig fmt: same-line comment after switch prong" {
	35	try testCanonical(
	36	\\test "" {
	37	\\ switch (err) {
	38	\\ error.PathAlreadyExists => {}, // comment 2
	39	\\ else => return err, // comment 1
	40	\\ }
	41	\\}
	42	\\
	43	);
	44	}
	45
	46	test "zig fmt: same-line comment after non-block if expression" {
	47	try testCanonical(
	48	\\comptime {
	49	\\ if (sr > n_uword_bits - 1) // d > r
	50	\\ return 0;
	51	\\}
	52	\\
	53	);
	54	}
	55
	56	test "zig fmt: same-line comment on comptime expression" {
	57	try testCanonical(
	58	\\test "" {
	59	\\ comptime assert(@typeId(T) == builtin.TypeId.Int); // must pass an integer to absInt
	60	\\}
	61	\\
	62	);
	63	}
	64
	65	test "zig fmt: switch with empty body" {
	66	try testCanonical(
	67	\\test "" {
	68	\\ foo() catch \|err\| switch (err) {};
	69	\\}
	70	\\
	71	);
	72	}
	73
	74	test "zig fmt: float literal with exponent" {
	75	try testCanonical(
	76	\\pub const f64_true_min = 4.94065645841246544177e-324;
	77	\\
	78	);
	79	}
	80
	81	test "zig fmt: line comments in struct initializer" {
	82	try testCanonical(
	83	\\fn foo() void {
	84	\\ return Self{
	85	\\ .a = b,
	86	\\
	87	\\ // Initialize these two fields to buffer_size so that
	88	\\ // in `readFn` we treat the state as being able to read
	89	\\ .start_index = buffer_size,
	90	\\ .end_index = buffer_size,
	91	\\
	92	\\ // middle
	93	\\
	94	\\ .a = b,
	95	\\
	96	\\ // end
	97	\\ };
	98	\\}
	99	\\
	100	);
	101	}
	102
	103	test "zig fmt: doc comments before struct field" {
	104	try testCanonical(
	105	\\pub const Allocator = struct {
	106	\\ /// Allocate byte_count bytes and return them in a slice, with the
	107	\\ /// slice's pointer aligned at least to alignment bytes.
	108	\\ allocFn: fn() void,
	109	\\};
	110	\\
	111	);
	112	}
	113
	114	test "zig fmt: error set declaration" {
	115	try testCanonical(
	116	\\const E = error{
	117	\\ A,
	118	\\ B,
	119	\\
	120	\\ C,
	121	\\};
	122	\\
	123	\\const Error = error{
	124	\\ /// no more memory
	125	\\ OutOfMemory,
	126	\\};
	127	\\
	128	\\const Error = error{
	129	\\ /// no more memory
	130	\\ OutOfMemory,
	131	\\
	132	\\ /// another
	133	\\ Another,
	134	\\
	135	\\ // end
	136	\\};
	137	\\
	138	\\const Error = error{OutOfMemory};
	139	\\const Error = error{};
	140	\\
	141	);
	142	}
	143
	144	test "zig fmt: union(enum(u32)) with assigned enum values" {
	145	try testCanonical(
	146	\\const MultipleChoice = union(enum(u32)) {
	147	\\ A = 20,
	148	\\ B = 40,
	149	\\ C = 60,
	150	\\ D = 1000,
	151	\\};
	152	\\
	153	);
	154	}
	155
	156	test "zig fmt: labeled suspend" {
	157	try testCanonical(
	158	\\fn foo() void {
	159	\\ s: suspend \|p\| {
	160	\\ break :s;
	161	\\ }
	162	\\}
	163	\\
	164	);
	165	}
	166
	167	test "zig fmt: comments before error set decl" {
	168	try testCanonical(
	169	\\const UnexpectedError = error{
	170	\\ /// The Operating System returned an undocumented error code.
	171	\\ Unexpected,
	172	\\ // another
	173	\\ Another,
	174	\\
	175	\\ // in between
	176	\\
	177	\\ // at end
	178	\\};
	179	\\
	180	);
	181	}
	182
	183	test "zig fmt: comments before switch prong" {
	184	try testCanonical(
	185	\\test "" {
	186	\\ switch (err) {
	187	\\ error.PathAlreadyExists => continue,
	188	\\
	189	\\ // comment 1
	190	\\
	191	\\ // comment 2
	192	\\ else => return err,
	193	\\ // at end
	194	\\ }
	195	\\}
	196	\\
	197	);
	198	}
	199
	200	test "zig fmt: comments before var decl in struct" {
	201	try testCanonical(
	202	\\pub const vfs_cap_data = extern struct {
	203	\\ // All of these are mandated as little endian
	204	\\ // when on disk.
	205	\\ const Data = struct {
	206	\\ permitted: u32,
	207	\\ inheritable: u32,
	208	\\ };
	209	\\
	210	\\ // in between
	211	\\
	212	\\ /// All of these are mandated as little endian
	213	\\ /// when on disk.
	214	\\ const Data = struct {
	215	\\ permitted: u32,
	216	\\ inheritable: u32,
	217	\\ };
	218	\\
	219	\\ // at end
	220	\\};
	221	\\
	222	);
	223	}
	224
	225	test "zig fmt: array literal with 1 item on 1 line" {
	226	try testCanonical(
	227	\\var s = []const u64{0} ** 25;
	228	\\
	229	);
	230	}
	231
	232	test "zig fmt: comments before global variables" {
	233	try testCanonical(
	234	\\/// Foo copies keys and values before they go into the map, and
	235	\\/// frees them when they get removed.
	236	\\pub const Foo = struct {};
	237	\\
	238	);
	239	}
	240
	241	test "zig fmt: comments in statements" {
	242	try testCanonical(
	243	\\test "std" {
	244	\\ // statement comment
	245	\\ _ = @import("foo/bar.zig");
	246	\\
	247	\\ // middle
	248	\\ // middle2
	249	\\
	250	\\ // end
	251	\\}
	252	\\
	253	);
	254	}
	255
	256	test "zig fmt: comments before test decl" {
	257	try testCanonical(
	258	\\/// top level doc comment
	259	\\test "hi" {}
	260	\\
	261	\\// top level normal comment
	262	\\test "hi" {}
	263	\\
	264	\\// middle
	265	\\
	266	\\// end
	267	\\
	268	);
	269	}
	270
	271	test "zig fmt: preserve spacing" {
	272	try testCanonical(
	273	\\const std = @import("std");
	274	\\
	275	\\pub fn main() !void {
	276	\\ var stdout_file = try std.io.getStdOut;
	277	\\ var stdout_file = try std.io.getStdOut;
	278	\\
	279	\\ var stdout_file = try std.io.getStdOut;
	280	\\ var stdout_file = try std.io.getStdOut;
	281	\\}
	282	\\
	283	);
	284	}
	285
	286	test "zig fmt: return types" {
	287	try testCanonical(
	288	\\pub fn main() !void {}
	289	\\pub fn main() var {}
	290	\\pub fn main() i32 {}
	291	\\
	292	);
	293	}
	294
	295	test "zig fmt: imports" {
	296	try testCanonical(
	297	\\const std = @import("std");
	298	\\const std = @import();
	299	\\
	300	);
	301	}
	302
	303	test "zig fmt: global declarations" {
	304	try testCanonical(
	305	\\const a = b;
	306	\\pub const a = b;
	307	\\var a = b;
	308	\\pub var a = b;
	309	\\const a: i32 = b;
	310	\\pub const a: i32 = b;
	311	\\var a: i32 = b;
	312	\\pub var a: i32 = b;
	313	\\extern const a: i32 = b;
	314	\\pub extern const a: i32 = b;
	315	\\extern var a: i32 = b;
	316	\\pub extern var a: i32 = b;
	317	\\extern "a" const a: i32 = b;
	318	\\pub extern "a" const a: i32 = b;
	319	\\extern "a" var a: i32 = b;
	320	\\pub extern "a" var a: i32 = b;
	321	\\
	322	);
	323	}
	324
	325	test "zig fmt: extern declaration" {
	326	try testCanonical(
	327	\\extern var foo: c_int;
	328	\\
	329	);
	330	}
	331
	332	test "zig fmt: alignment" {
	333	try testCanonical(
	334	\\var foo: c_int align(1);
	335	\\
	336	);
	337	}
	338
	339	test "zig fmt: C main" {
	340	try testCanonical(
	341	\\fn main(argc: c_int, argv: &&u8) c_int {
	342	\\ const a = b;
	343	\\}
	344	\\
	345	);
	346	}
	347
	348	test "zig fmt: return" {
	349	try testCanonical(
	350	\\fn foo(argc: c_int, argv: &&u8) c_int {
	351	\\ return 0;
	352	\\}
	353	\\
	354	\\fn bar() void {
	355	\\ return;
	356	\\}
	357	\\
	358	);
	359	}
	360
	361	test "zig fmt: pointer attributes" {
	362	try testCanonical(
	363	\\extern fn f1(s: &align(&u8) u8) c_int;
	364	\\extern fn f2(s: &&align(1) &const &volatile u8) c_int;
	365	\\extern fn f3(s: &align(1) const &align(1) volatile &const volatile u8) c_int;
	366	\\extern fn f4(s: &align(1) const volatile u8) c_int;
	367	\\
	368	);
	369	}
	370
	371	test "zig fmt: slice attributes" {
	372	try testCanonical(
	373	\\extern fn f1(s: &align(&u8) u8) c_int;
	374	\\extern fn f2(s: &&align(1) &const &volatile u8) c_int;
	375	\\extern fn f3(s: &align(1) const &align(1) volatile &const volatile u8) c_int;
	376	\\extern fn f4(s: &align(1) const volatile u8) c_int;
	377	\\
	378	);
	379	}
	380
	381	test "zig fmt: test declaration" {
	382	try testCanonical(
	383	\\test "test name" {
	384	\\ const a = 1;
	385	\\ var b = 1;
	386	\\}
	387	\\
	388	);
	389	}
	390
	391	test "zig fmt: infix operators" {
	392	try testCanonical(
	393	\\test "infix operators" {
	394	\\ var i = undefined;
	395	\\ i = 2;
	396	\\ i *= 2;
	397	\\ i \|= 2;
	398	\\ i ^= 2;
	399	\\ i <<= 2;
	400	\\ i >>= 2;
	401	\\ i &= 2;
	402	\\ i *= 2;
	403	\\ i *%= 2;
	404	\\ i -= 2;
	405	\\ i -%= 2;
	406	\\ i += 2;
	407	\\ i +%= 2;
	408	\\ i /= 2;
	409	\\ i %= 2;
	410	\\ _ = i == i;
	411	\\ _ = i != i;
	412	\\ _ = i != i;
	413	\\ _ = i.i;
	414	\\ _ = i \|\| i;
	415	\\ _ = i!i;
	416	\\ _ = i ** i;
	417	\\ _ = i ++ i;
	418	\\ _ = i ?? i;
	419	\\ _ = i % i;
	420	\\ _ = i / i;
	421	\\ _ = i *% i;
	422	\\ _ = i * i;
	423	\\ _ = i -% i;
	424	\\ _ = i - i;
	425	\\ _ = i +% i;
	426	\\ _ = i + i;
	427	\\ _ = i << i;
	428	\\ _ = i >> i;
	429	\\ _ = i & i;
	430	\\ _ = i ^ i;
	431	\\ _ = i \| i;
	432	\\ _ = i >= i;
	433	\\ _ = i <= i;
	434	\\ _ = i > i;
	435	\\ _ = i < i;
	436	\\ _ = i and i;
	437	\\ _ = i or i;
	438	\\}
	439	\\
	440	);
	441	}
	442
	443	test "zig fmt: precedence" {
	444	try testCanonical(
	445	\\test "precedence" {
	446	\\ a!b();
	447	\\ (a!b)();
	448	\\ !a!b;
	449	\\ !(a!b);
	450	\\ !a{};
	451	\\ !(a{});
	452	\\ a + b{};
	453	\\ (a + b){};
	454	\\ a << b + c;
	455	\\ (a << b) + c;
	456	\\ a & b << c;
	457	\\ (a & b) << c;
	458	\\ a ^ b & c;
	459	\\ (a ^ b) & c;
	460	\\ a \| b ^ c;
	461	\\ (a \| b) ^ c;
	462	\\ a == b \| c;
	463	\\ (a == b) \| c;
	464	\\ a and b == c;
	465	\\ (a and b) == c;
	466	\\ a or b and c;
	467	\\ (a or b) and c;
	468	\\ (a or b) and c;
	469	\\}
	470	\\
	471	);
	472	}
	473
	474	test "zig fmt: prefix operators" {
	475	try testCanonical(
	476	\\test "prefix operators" {
	477	\\ try return --%~??!*&0;
	478	\\}
	479	\\
	480	);
	481	}
	482
	483	test "zig fmt: call expression" {
	484	try testCanonical(
	485	\\test "test calls" {
	486	\\ a();
	487	\\ a(1);
	488	\\ a(1, 2);
	489	\\ a(1, 2) + a(1, 2);
	490	\\}
	491	\\
	492	);
	493	}
	494
	495	test "zig fmt: var args" {
	496	try testCanonical(
	497	\\fn print(args: ...) void {}
	498	\\
	499	);
	500	}
	501
	502	test "zig fmt: var type" {
	503	try testCanonical(
	504	\\fn print(args: var) var {}
	505	\\const Var = var;
	506	\\const i: var = 0;
	507	\\
	508	);
	509	}
	510
	511	test "zig fmt: functions" {
	512	try testCanonical(
	513	\\extern fn puts(s: &const u8) c_int;
	514	\\extern "c" fn puts(s: &const u8) c_int;
	515	\\export fn puts(s: &const u8) c_int;
	516	\\inline fn puts(s: &const u8) c_int;
	517	\\pub extern fn puts(s: &const u8) c_int;
	518	\\pub extern "c" fn puts(s: &const u8) c_int;
	519	\\pub export fn puts(s: &const u8) c_int;
	520	\\pub inline fn puts(s: &const u8) c_int;
	521	\\pub extern fn puts(s: &const u8) align(2 + 2) c_int;
	522	\\pub extern "c" fn puts(s: &const u8) align(2 + 2) c_int;
	523	\\pub export fn puts(s: &const u8) align(2 + 2) c_int;
	524	\\pub inline fn puts(s: &const u8) align(2 + 2) c_int;
	525	\\
	526	);
	527	}
	528
	529	test "zig fmt: multiline string" {
	530	try testCanonical(
	531	\\test "" {
	532	\\ const s1 =
	533	\\ \\one
	534	\\ \\two)
	535	\\ \\three
	536	\\ ;
	537	\\ const s2 =
	538	\\ c\\one
	539	\\ c\\two)
	540	\\ c\\three
	541	\\ ;
	542	\\}
	543	\\
	544	);
	545	}
	546
	547	test "zig fmt: values" {
	548	try testCanonical(
	549	\\test "values" {
	550	\\ 1;
	551	\\ 1.0;
	552	\\ "string";
	553	\\ c"cstring";
	554	\\ 'c';
	555	\\ true;
	556	\\ false;
	557	\\ null;
	558	\\ undefined;
	559	\\ error;
	560	\\ this;
	561	\\ unreachable;
	562	\\}
	563	\\
	564	);
	565	}
	566
	567	test "zig fmt: indexing" {
	568	try testCanonical(
	569	\\test "test index" {
	570	\\ a[0];
	571	\\ a[0 + 5];
	572	\\ a[0..];
	573	\\ a[0..5];
	574	\\ a[a[0]];
	575	\\ a[a[0..]];
	576	\\ a[a[0..5]];
	577	\\ a[a[0]..];
	578	\\ a[a[0..5]..];
	579	\\ a[a[0]..a[0]];
	580	\\ a[a[0..5]..a[0]];
	581	\\ a[a[0..5]..a[0..5]];
	582	\\}
	583	\\
	584	);
	585	}
	586
	587	test "zig fmt: struct declaration" {
	588	try testCanonical(
	589	\\const S = struct {
	590	\\ const Self = this;
	591	\\ f1: u8,
	592	\\ pub f3: u8,
	593	\\
	594	\\ fn method(self: &Self) Self {
	595	\\ return *self;
	596	\\ }
	597	\\
	598	\\ f2: u8,
	599	\\};
	600	\\
	601	\\const Ps = packed struct {
	602	\\ a: u8,
	603	\\ pub b: u8,
	604	\\
	605	\\ c: u8,
	606	\\};
	607	\\
	608	\\const Es = extern struct {
	609	\\ a: u8,
	610	\\ pub b: u8,
	611	\\
	612	\\ c: u8,
	613	\\};
	614	\\
	615	);
	616	}
	617
	618	test "zig fmt: enum declaration" {
	619	try testCanonical(
	620	\\const E = enum {
	621	\\ Ok,
	622	\\ SomethingElse = 0,
	623	\\};
	624	\\
	625	\\const E2 = enum(u8) {
	626	\\ Ok,
	627	\\ SomethingElse = 255,
	628	\\ SomethingThird,
	629	\\};
	630	\\
	631	\\const Ee = extern enum {
	632	\\ Ok,
	633	\\ SomethingElse,
	634	\\ SomethingThird,
	635	\\};
	636	\\
	637	\\const Ep = packed enum {
	638	\\ Ok,
	639	\\ SomethingElse,
	640	\\ SomethingThird,
	641	\\};
	642	\\
	643	);
	644	}
	645
	646	test "zig fmt: union declaration" {
	647	try testCanonical(
	648	\\const U = union {
	649	\\ Int: u8,
	650	\\ Float: f32,
	651	\\ None,
	652	\\ Bool: bool,
	653	\\};
	654	\\
	655	\\const Ue = union(enum) {
	656	\\ Int: u8,
	657	\\ Float: f32,
	658	\\ None,
	659	\\ Bool: bool,
	660	\\};
	661	\\
	662	\\const E = enum {
	663	\\ Int,
	664	\\ Float,
	665	\\ None,
	666	\\ Bool,
	667	\\};
	668	\\
	669	\\const Ue2 = union(E) {
	670	\\ Int: u8,
	671	\\ Float: f32,
	672	\\ None,
	673	\\ Bool: bool,
	674	\\};
	675	\\
	676	\\const Eu = extern union {
	677	\\ Int: u8,
	678	\\ Float: f32,
	679	\\ None,
	680	\\ Bool: bool,
	681	\\};
	682	\\
	683	);
	684	}
	685
	686	test "zig fmt: arrays" {
	687	try testCanonical(
	688	\\test "test array" {
	689	\\ const a: [2]u8 = [2]u8{
	690	\\ 1,
	691	\\ 2,
	692	\\ };
	693	\\ const a: [2]u8 = []u8{
	694	\\ 1,
	695	\\ 2,
	696	\\ };
	697	\\ const a: [0]u8 = []u8{};
	698	\\}
	699	\\
	700	);
	701	}
	702
	703	test "zig fmt: container initializers" {
	704	try testCanonical(
	705	\\const a0 = []u8{};
	706	\\const a1 = []u8{1};
	707	\\const a2 = []u8{
	708	\\ 1,
	709	\\ 2,
	710	\\ 3,
	711	\\ 4,
	712	\\};
	713	\\const s0 = S{};
	714	\\const s1 = S{ .a = 1 };
	715	\\const s2 = S{
	716	\\ .a = 1,
	717	\\ .b = 2,
	718	\\};
	719	\\
	720	);
	721	}
	722
	723	test "zig fmt: catch" {
	724	try testCanonical(
	725	\\test "catch" {
	726	\\ const a: error!u8 = 0;
	727	\\ _ = a catch return;
	728	\\ _ = a catch \|err\| return;
	729	\\}
	730	\\
	731	);
	732	}
	733
	734	test "zig fmt: blocks" {
	735	try testCanonical(
	736	\\test "blocks" {
	737	\\ {
	738	\\ const a = 0;
	739	\\ const b = 0;
	740	\\ }
	741	\\
	742	\\ blk: {
	743	\\ const a = 0;
	744	\\ const b = 0;
	745	\\ }
	746	\\
	747	\\ const r = blk: {
	748	\\ const a = 0;
	749	\\ const b = 0;
	750	\\ };
	751	\\}
	752	\\
	753	);
	754	}
	755
	756	test "zig fmt: switch" {
	757	try testCanonical(
	758	\\test "switch" {
	759	\\ switch (0) {
	760	\\ 0 => {},
	761	\\ 1 => unreachable,
	762	\\ 2,
	763	\\ 3 => {},
	764	\\ 4 ... 7 => {},
	765	\\ 1 + 4 * 3 + 22 => {},
	766	\\ else => {
	767	\\ const a = 1;
	768	\\ const b = a;
	769	\\ },
	770	\\ }
	771	\\
	772	\\ const res = switch (0) {
	773	\\ 0 => 0,
	774	\\ 1 => 2,
	775	\\ 1 => a = 4,
	776	\\ else => 4,
	777	\\ };
	778	\\
	779	\\ const Union = union(enum) {
	780	\\ Int: i64,
	781	\\ Float: f64,
	782	\\ };
	783	\\
	784	\\ switch (u) {
	785	\\ Union.Int => \|int\| {},
	786	\\ Union.Float => \|*float\| unreachable,
	787	\\ }
	788	\\}
	789	\\
	790	);
	791	}
	792
	793	test "zig fmt: while" {
	794	try testCanonical(
	795	\\test "while" {
	796	\\ while (10 < 1) {
	797	\\ unreachable;
	798	\\ }
	799	\\
	800	\\ while (10 < 1)
	801	\\ unreachable;
	802	\\
	803	\\ var i: usize = 0;
	804	\\ while (i < 10) : (i += 1) {
	805	\\ continue;
	806	\\ }
	807	\\
	808	\\ i = 0;
	809	\\ while (i < 10) : (i += 1)
	810	\\ continue;
	811	\\
	812	\\ i = 0;
	813	\\ var j: usize = 0;
	814	\\ while (i < 10) : ({
	815	\\ i += 1;
	816	\\ j += 1;
	817	\\ }) {
	818	\\ continue;
	819	\\ }
	820	\\
	821	\\ var a: ?u8 = 2;
	822	\\ while (a) \|v\| : (a = null) {
	823	\\ continue;
	824	\\ }
	825	\\
	826	\\ while (a) \|v\| : (a = null)
	827	\\ unreachable;
	828	\\
	829	\\ label: while (10 < 0) {
	830	\\ unreachable;
	831	\\ }
	832	\\
	833	\\ const res = while (0 < 10) {
	834	\\ break 7;
	835	\\ } else {
	836	\\ unreachable;
	837	\\ };
	838	\\
	839	\\ const res = while (0 < 10)
	840	\\ break 7
	841	\\ else
	842	\\ unreachable;
	843	\\
	844	\\ var a: error!u8 = 0;
	845	\\ while (a) \|v\| {
	846	\\ a = error.Err;
	847	\\ } else \|err\| {
	848	\\ i = 1;
	849	\\ }
	850	\\
	851	\\ comptime var k: usize = 0;
	852	\\ inline while (i < 10) : (i += 1)
	853	\\ j += 2;
	854	\\}
	855	\\
	856	);
	857	}
	858
	859	test "zig fmt: for" {
	860	try testCanonical(
	861	\\test "for" {
	862	\\ for (a) \|v\| {
	863	\\ continue;
	864	\\ }
	865	\\
	866	\\ for (a) \|v\|
	867	\\ continue;
	868	\\
	869	\\ for (a) \|*v\|
	870	\\ continue;
	871	\\
	872	\\ for (a) \|v, i\| {
	873	\\ continue;
	874	\\ }
	875	\\
	876	\\ for (a) \|v, i\|
	877	\\ continue;
	878	\\
	879	\\ const res = for (a) \|v, i\| {
	880	\\ break v;
	881	\\ } else {
	882	\\ unreachable;
	883	\\ };
	884	\\
	885	\\ var num: usize = 0;
	886	\\ inline for (a) \|v, i\| {
	887	\\ num += v;
	888	\\ num += i;
	889	\\ }
	890	\\}
	891	\\
	892	);
	893	}
	894
	895	test "zig fmt: if" {
	896	try testCanonical(
	897	\\test "if" {
	898	\\ if (10 < 0) {
	899	\\ unreachable;
	900	\\ }
	901	\\
	902	\\ if (10 < 0) unreachable;
	903	\\
	904	\\ if (10 < 0) {
	905	\\ unreachable;
	906	\\ } else {
	907	\\ const a = 20;
	908	\\ }
	909	\\
	910	\\ if (10 < 0) {
	911	\\ unreachable;
	912	\\ } else if (5 < 0) {
	913	\\ unreachable;
	914	\\ } else {
	915	\\ const a = 20;
	916	\\ }
	917	\\
	918	\\ const is_world_broken = if (10 < 0) true else false;
	919	\\ const some_number = 1 + if (10 < 0) 2 else 3;
	920	\\
	921	\\ const a: ?u8 = 10;
	922	\\ const b: ?u8 = null;
	923	\\ if (a) \|v\| {
	924	\\ const some = v;
	925	\\ } else if (b) \|*v\| {
	926	\\ unreachable;
	927	\\ } else {
	928	\\ const some = 10;
	929	\\ }
	930	\\
	931	\\ const non_null_a = if (a) \|v\| v else 0;
	932	\\
	933	\\ const a_err: error!u8 = 0;
	934	\\ if (a_err) \|v\| {
	935	\\ const p = v;
	936	\\ } else \|err\| {
	937	\\ unreachable;
	938	\\ }
	939	\\}
	940	\\
	941	);
	942	}
	943
	944	test "zig fmt: defer" {
	945	try testCanonical(
	946	\\test "defer" {
	947	\\ var i: usize = 0;
	948	\\ defer i = 1;
	949	\\ defer {
	950	\\ i += 2;
	951	\\ i *= i;
	952	\\ }
	953	\\
	954	\\ errdefer i += 3;
	955	\\ errdefer {
	956	\\ i += 2;
	957	\\ i /= i;
	958	\\ }
	959	\\}
	960	\\
	961	);
	962	}
	963
	964	test "zig fmt: comptime" {
	965	try testCanonical(
	966	\\fn a() u8 {
	967	\\ return 5;
	968	\\}
	969	\\
	970	\\fn b(comptime i: u8) u8 {
	971	\\ return i;
	972	\\}
	973	\\
	974	\\const av = comptime a();
	975	\\const av2 = comptime blk: {
	976	\\ var res = a();
	977	\\ res *= b(2);
	978	\\ break :blk res;
	979	\\};
	980	\\
	981	\\comptime {
	982	\\ _ = a();
	983	\\}
	984	\\
	985	\\test "comptime" {
	986	\\ const av3 = comptime a();
	987	\\ const av4 = comptime blk: {
	988	\\ var res = a();
	989	\\ res *= a();
	990	\\ break :blk res;
	991	\\ };
	992	\\
	993	\\ comptime var i = 0;
	994	\\ comptime {
	995	\\ i = a();
	996	\\ i += b(i);
	997	\\ }
	998	\\}
	999	\\
	1000	);
	1001	}
	1002
	1003	test "zig fmt: fn type" {
	1004	try testCanonical(
	1005	\\fn a(i: u8) u8 {
	1006	\\ return i + 1;
	1007	\\}
	1008	\\
	1009	\\const a: fn(u8) u8 = undefined;
	1010	\\const b: extern fn(u8) u8 = undefined;
	1011	\\const c: nakedcc fn(u8) u8 = undefined;
	1012	\\const ap: fn(u8) u8 = a;
	1013	\\
	1014	);
	1015	}
	1016
	1017	test "zig fmt: inline asm" {
	1018	try testCanonical(
	1019	\\pub fn syscall1(number: usize, arg1: usize) usize {
	1020	\\ return asm volatile ("syscall"
	1021	\\ : [ret] "={rax}" (-> usize)
	1022	\\ : [number] "{rax}" (number),
	1023	\\ [arg1] "{rdi}" (arg1)
	1024	\\ : "rcx", "r11");
	1025	\\}
	1026	\\
	1027	);
	1028	}
	1029
	1030	test "zig fmt: coroutines" {
	1031	try testCanonical(
	1032	\\async fn simpleAsyncFn() void {
	1033	\\ const a = async a.b();
	1034	\\ x += 1;
	1035	\\ suspend;
	1036	\\ x += 1;
	1037	\\ suspend \|p\| {}
	1038	\\ const p: promise->void = async simpleAsyncFn() catch unreachable;
	1039	\\ await p;
	1040	\\}
	1041	\\
	1042	\\test "coroutine suspend, resume, cancel" {
	1043	\\ const p: promise = try async<std.debug.global_allocator> testAsyncSeq();
	1044	\\ resume p;
	1045	\\ cancel p;
	1046	\\}
	1047	\\
	1048	);
	1049	}
	1050
	1051	test "zig fmt: Block after if" {
	1052	try testCanonical(
	1053	\\test "Block after if" {
	1054	\\ if (true) {
	1055	\\ const a = 0;
	1056	\\ }
	1057	\\
	1058	\\ {
	1059	\\ const a = 0;
	1060	\\ }
	1061	\\}
	1062	\\
	1063	);
	1064	}
	1065
	1066	test "zig fmt: use" {
	1067	try testCanonical(
	1068	\\use @import("std");
	1069	\\pub use @import("std");
	1070	\\
	1071	);
	1072	}
	1073
	1074	test "zig fmt: string identifier" {
	1075	try testCanonical(
	1076	\\const @"a b" = @"c d".@"e f";
	1077	\\fn @"g h"() void {}
	1078	\\
	1079	);
	1080	}
	1081
	1082	test "zig fmt: error return" {
	1083	try testCanonical(
	1084	\\fn err() error {
	1085	\\ call();
	1086	\\ return error.InvalidArgs;
	1087	\\}
	1088	\\
	1089	);
	1090	}
	1091
	1092	const std = @import("std");
	1093	const mem = std.mem;
	1094	const warn = std.debug.warn;
	1095	const io = std.io;
	1096
	1097	var fixed_buffer_mem: [100 * 1024]u8 = undefined;
	1098
	1099	fn testParse(source: []const u8, allocator: &mem.Allocator) ![]u8 {
	1100	var stderr_file = try io.getStdErr();
	1101	var stderr = &io.FileOutStream.init(&stderr_file).stream;
	1102
	1103	var tree = try std.zig.parse(allocator, source);
	1104	defer tree.deinit();
	1105
	1106	var error_it = tree.errors.iterator(0);
	1107	while (error_it.next()) \|parse_error\| {
	1108	const token = tree.tokens.at(parse_error.loc());
	1109	const loc = tree.tokenLocation(0, parse_error.loc());
	1110	try stderr.print("(memory buffer):{}:{}: error: ", loc.line + 1, loc.column + 1);
	1111	try tree.renderError(parse_error, stderr);
	1112	try stderr.print("\n{}\n", source[loc.line_start..loc.line_end]);
	1113	{
	1114	var i: usize = 0;
	1115	while (i < loc.column) : (i += 1) {
	1116	try stderr.write(" ");
	1117	}
	1118	}
	1119	{
	1120	const caret_count = token.end - token.start;
	1121	var i: usize = 0;
	1122	while (i < caret_count) : (i += 1) {
	1123	try stderr.write("~");
	1124	}
	1125	}
	1126	try stderr.write("\n");
	1127	}
	1128	if (tree.errors.len != 0) {
	1129	return error.ParseError;
	1130	}
	1131
	1132	var buffer = try std.Buffer.initSize(allocator, 0);
	1133	errdefer buffer.deinit();
	1134
	1135	var buffer_out_stream = io.BufferOutStream.init(&buffer);
	1136	try std.zig.render(allocator, &buffer_out_stream.stream, &tree);
	1137	return buffer.toOwnedSlice();
	1138	}
	1139
	1140	fn testTransform(source: []const u8, expected_source: []const u8) !void {
	1141	const needed_alloc_count = x: {
	1142	// Try it once with unlimited memory, make sure it works
	1143	var fixed_allocator = std.heap.FixedBufferAllocator.init(fixed_buffer_mem[0..]);
	1144	var failing_allocator = std.debug.FailingAllocator.init(&fixed_allocator.allocator, @maxValue(usize));
	1145	const result_source = try testParse(source, &failing_allocator.allocator);
	1146	if (!mem.eql(u8, result_source, expected_source)) {
	1147	warn("\n====== expected this output: =========\n");
	1148	warn("{}", expected_source);
	1149	warn("\n======== instead found this: =========\n");
	1150	warn("{}", result_source);
	1151	warn("\n======================================\n");
	1152	return error.TestFailed;
	1153	}
	1154	failing_allocator.allocator.free(result_source);
	1155	break :x failing_allocator.index;
	1156	};
	1157
	1158	var fail_index: usize = 0;
	1159	while (fail_index < needed_alloc_count) : (fail_index += 1) {
	1160	var fixed_allocator = std.heap.FixedBufferAllocator.init(fixed_buffer_mem[0..]);
	1161	var failing_allocator = std.debug.FailingAllocator.init(&fixed_allocator.allocator, fail_index);
	1162	if (testParse(source, &failing_allocator.allocator)) \|_\| {
	1163	return error.NondeterministicMemoryUsage;
	1164	} else \|err\| switch (err) {
	1165	error.OutOfMemory => {
	1166	if (failing_allocator.allocated_bytes != failing_allocator.freed_bytes) {
	1167	warn("\nfail_index: {}/{}\nallocated bytes: {}\nfreed bytes: {}\nallocations: {}\ndeallocations: {}\n",
	1168	fail_index, needed_alloc_count,
	1169	failing_allocator.allocated_bytes, failing_allocator.freed_bytes,
	1170	failing_allocator.index, failing_allocator.deallocations);
	1171	return error.MemoryLeakDetected;
	1172	}
	1173	},
	1174	error.ParseError => @panic("test failed"),
	1175	else => @panic("test failed"),
	1176	}
	1177	}
	1178	}
	1179
	1180	fn testCanonical(source: []const u8) !void {
	1181	return testTransform(source, source);
	1182	}
	1183

std/zig/render.zig created+1270

...	...	@@ -0,0 +1,1270 @@
	1	const std = @import("../index.zig");
	2	const assert = std.debug.assert;
	3	const mem = std.mem;
	4	const ast = std.zig.ast;
	5	const Token = std.zig.Token;
	6
	7	const RenderState = union(enum) {
	8	TopLevelDecl: &ast.Node,
	9	ParamDecl: &ast.Node,
	10	Text: []const u8,
	11	Expression: &ast.Node,
	12	VarDecl: &ast.Node.VarDecl,
	13	Statement: &ast.Node,
	14	PrintIndent,
	15	Indent: usize,
	16	MaybeSemiColon: &ast.Node,
	17	Token: ast.TokenIndex,
	18	NonBreakToken: ast.TokenIndex,
	19	};
	20
	21	const indent_delta = 4;
	22
	23	pub fn render(allocator: &mem.Allocator, stream: var, tree: &ast.Tree) !void {
	24	var stack = std.ArrayList(RenderState).init(allocator);
	25	defer stack.deinit();
	26
	27	{
	28	try stack.append(RenderState { .Text = "\n"});
	29
	30	var i = tree.root_node.decls.len;
	31	while (i != 0) {
	32	i -= 1;
	33	const decl = *tree.root_node.decls.at(i);
	34	try stack.append(RenderState {.TopLevelDecl = decl});
	35	if (i != 0) {
	36	try stack.append(RenderState {
	37	.Text = blk: {
	38	const prev_node = *tree.root_node.decls.at(i - 1);
	39	const prev_node_last_token = tree.tokens.at(prev_node.lastToken());
	40	const loc = tree.tokenLocation(prev_node_last_token.end, decl.firstToken());
	41	if (loc.line >= 2) {
	42	break :blk "\n\n";
	43	}
	44	break :blk "\n";
	45	},
	46	});
	47	}
	48	}
	49	}
	50
	51	var indent: usize = 0;
	52	while (stack.popOrNull()) \|state\| {
	53	switch (state) {
	54	RenderState.TopLevelDecl => \|decl\| {
	55	switch (decl.id) {
	56	ast.Node.Id.FnProto => {
	57	const fn_proto = @fieldParentPtr(ast.Node.FnProto, "base", decl);
	58	try renderComments(tree, stream, fn_proto, indent);
	59
	60	if (fn_proto.body_node) \|body_node\| {
	61	stack.append(RenderState { .Expression = body_node}) catch unreachable;
	62	try stack.append(RenderState { .Text = " "});
	63	} else {
	64	stack.append(RenderState { .Text = ";" }) catch unreachable;
	65	}
	66
	67	try stack.append(RenderState { .Expression = decl });
	68	},
	69	ast.Node.Id.Use => {
	70	const use_decl = @fieldParentPtr(ast.Node.Use, "base", decl);
	71	if (use_decl.visib_token) \|visib_token\| {
	72	try stream.print("{} ", tree.tokenSlice(visib_token));
	73	}
	74	try stream.print("use ");
	75	try stack.append(RenderState { .Text = ";" });
	76	try stack.append(RenderState { .Expression = use_decl.expr });
	77	},
	78	ast.Node.Id.VarDecl => {
	79	const var_decl = @fieldParentPtr(ast.Node.VarDecl, "base", decl);
	80	try renderComments(tree, stream, var_decl, indent);
	81	try stack.append(RenderState { .VarDecl = var_decl});
	82	},
	83	ast.Node.Id.TestDecl => {
	84	const test_decl = @fieldParentPtr(ast.Node.TestDecl, "base", decl);
	85	try renderComments(tree, stream, test_decl, indent);
	86	try stream.print("test ");
	87	try stack.append(RenderState { .Expression = test_decl.body_node });
	88	try stack.append(RenderState { .Text = " " });
	89	try stack.append(RenderState { .Expression = test_decl.name });
	90	},
	91	ast.Node.Id.StructField => {
	92	const field = @fieldParentPtr(ast.Node.StructField, "base", decl);
	93	try renderComments(tree, stream, field, indent);
	94	if (field.visib_token) \|visib_token\| {
	95	try stream.print("{} ", tree.tokenSlice(visib_token));
	96	}
	97	try stream.print("{}: ", tree.tokenSlice(field.name_token));
	98	try stack.append(RenderState { .Token = field.lastToken() + 1 });
	99	try stack.append(RenderState { .Expression = field.type_expr});
	100	},
	101	ast.Node.Id.UnionTag => {
	102	const tag = @fieldParentPtr(ast.Node.UnionTag, "base", decl);
	103	try renderComments(tree, stream, tag, indent);
	104	try stream.print("{}", tree.tokenSlice(tag.name_token));
	105
	106	try stack.append(RenderState { .Text = "," });
	107
	108	if (tag.value_expr) \|value_expr\| {
	109	try stack.append(RenderState { .Expression = value_expr });
	110	try stack.append(RenderState { .Text = " = " });
	111	}
	112
	113	if (tag.type_expr) \|type_expr\| {
	114	try stream.print(": ");
	115	try stack.append(RenderState { .Expression = type_expr});
	116	}
	117	},
	118	ast.Node.Id.EnumTag => {
	119	const tag = @fieldParentPtr(ast.Node.EnumTag, "base", decl);
	120	try renderComments(tree, stream, tag, indent);
	121	try stream.print("{}", tree.tokenSlice(tag.name_token));
	122
	123	try stack.append(RenderState { .Text = "," });
	124	if (tag.value) \|value\| {
	125	try stream.print(" = ");
	126	try stack.append(RenderState { .Expression = value});
	127	}
	128	},
	129	ast.Node.Id.ErrorTag => {
	130	const tag = @fieldParentPtr(ast.Node.ErrorTag, "base", decl);
	131	try renderComments(tree, stream, tag, indent);
	132	try stream.print("{}", tree.tokenSlice(tag.name_token));
	133	},
	134	ast.Node.Id.Comptime => {
	135	try stack.append(RenderState { .MaybeSemiColon = decl });
	136	try stack.append(RenderState { .Expression = decl });
	137	},
	138	ast.Node.Id.LineComment => {
	139	const line_comment_node = @fieldParentPtr(ast.Node.LineComment, "base", decl);
	140	try stream.write(tree.tokenSlice(line_comment_node.token));
	141	},
	142	else => unreachable,
	143	}
	144	},
	145
	146	RenderState.VarDecl => \|var_decl\| {
	147	try stack.append(RenderState { .Token = var_decl.semicolon_token });
	148	if (var_decl.init_node) \|init_node\| {
	149	try stack.append(RenderState { .Expression = init_node });
	150	const text = if (init_node.id == ast.Node.Id.MultilineStringLiteral) " =" else " = ";
	151	try stack.append(RenderState { .Text = text });
	152	}
	153	if (var_decl.align_node) \|align_node\| {
	154	try stack.append(RenderState { .Text = ")" });
	155	try stack.append(RenderState { .Expression = align_node });
	156	try stack.append(RenderState { .Text = " align(" });
	157	}
	158	if (var_decl.type_node) \|type_node\| {
	159	try stack.append(RenderState { .Expression = type_node });
	160	try stack.append(RenderState { .Text = ": " });
	161	}
	162	try stack.append(RenderState { .Text = tree.tokenSlice(var_decl.name_token) });
	163	try stack.append(RenderState { .Text = " " });
	164	try stack.append(RenderState { .Text = tree.tokenSlice(var_decl.mut_token) });
	165
	166	if (var_decl.comptime_token) \|comptime_token\| {
	167	try stack.append(RenderState { .Text = " " });
	168	try stack.append(RenderState { .Text = tree.tokenSlice(comptime_token) });
	169	}
	170
	171	if (var_decl.extern_export_token) \|extern_export_token\| {
	172	if (var_decl.lib_name != null) {
	173	try stack.append(RenderState { .Text = " " });
	174	try stack.append(RenderState { .Expression = ??var_decl.lib_name });
	175	}
	176	try stack.append(RenderState { .Text = " " });
	177	try stack.append(RenderState { .Text = tree.tokenSlice(extern_export_token) });
	178	}
	179
	180	if (var_decl.visib_token) \|visib_token\| {
	181	try stack.append(RenderState { .Text = " " });
	182	try stack.append(RenderState { .Text = tree.tokenSlice(visib_token) });
	183	}
	184	},
	185
	186	RenderState.ParamDecl => \|base\| {
	187	const param_decl = @fieldParentPtr(ast.Node.ParamDecl, "base", base);
	188	if (param_decl.comptime_token) \|comptime_token\| {
	189	try stream.print("{} ", tree.tokenSlice(comptime_token));
	190	}
	191	if (param_decl.noalias_token) \|noalias_token\| {
	192	try stream.print("{} ", tree.tokenSlice(noalias_token));
	193	}
	194	if (param_decl.name_token) \|name_token\| {
	195	try stream.print("{}: ", tree.tokenSlice(name_token));
	196	}
	197	if (param_decl.var_args_token) \|var_args_token\| {
	198	try stream.print("{}", tree.tokenSlice(var_args_token));
	199	} else {
	200	try stack.append(RenderState { .Expression = param_decl.type_node});
	201	}
	202	},
	203	RenderState.Text => \|bytes\| {
	204	try stream.write(bytes);
	205	},
	206	RenderState.Expression => \|base\| switch (base.id) {
	207	ast.Node.Id.Identifier => {
	208	const identifier = @fieldParentPtr(ast.Node.Identifier, "base", base);
	209	try stream.print("{}", tree.tokenSlice(identifier.token));
	210	},
	211	ast.Node.Id.Block => {
	212	const block = @fieldParentPtr(ast.Node.Block, "base", base);
	213	if (block.label) \|label\| {
	214	try stream.print("{}: ", tree.tokenSlice(label));
	215	}
	216
	217	if (block.statements.len == 0) {
	218	try stream.write("{}");
	219	} else {
	220	try stream.write("{");
	221	try stack.append(RenderState { .Text = "}"});
	222	try stack.append(RenderState.PrintIndent);
	223	try stack.append(RenderState { .Indent = indent});
	224	try stack.append(RenderState { .Text = "\n"});
	225	var i = block.statements.len;
	226	while (i != 0) {
	227	i -= 1;
	228	const statement_node = *block.statements.at(i);
	229	try stack.append(RenderState { .Statement = statement_node});
	230	try stack.append(RenderState.PrintIndent);
	231	try stack.append(RenderState { .Indent = indent + indent_delta});
	232	try stack.append(RenderState {
	233	.Text = blk: {
	234	if (i != 0) {
	235	const prev_node = *block.statements.at(i - 1);
	236	const prev_node_last_token_end = tree.tokens.at(prev_node.lastToken()).end;
	237	const loc = tree.tokenLocation(prev_node_last_token_end, statement_node.firstToken());
	238	if (loc.line >= 2) {
	239	break :blk "\n\n";
	240	}
	241	}
	242	break :blk "\n";
	243	},
	244	});
	245	}
	246	}
	247	},
	248	ast.Node.Id.Defer => {
	249	const defer_node = @fieldParentPtr(ast.Node.Defer, "base", base);
	250	try stream.print("{} ", tree.tokenSlice(defer_node.defer_token));
	251	try stack.append(RenderState { .Expression = defer_node.expr });
	252	},
	253	ast.Node.Id.Comptime => {
	254	const comptime_node = @fieldParentPtr(ast.Node.Comptime, "base", base);
	255	try stream.print("{} ", tree.tokenSlice(comptime_node.comptime_token));
	256	try stack.append(RenderState { .Expression = comptime_node.expr });
	257	},
	258	ast.Node.Id.AsyncAttribute => {
	259	const async_attr = @fieldParentPtr(ast.Node.AsyncAttribute, "base", base);
	260	try stream.print("{}", tree.tokenSlice(async_attr.async_token));
	261
	262	if (async_attr.allocator_type) \|allocator_type\| {
	263	try stack.append(RenderState { .Text = ">" });
	264	try stack.append(RenderState { .Expression = allocator_type });
	265	try stack.append(RenderState { .Text = "<" });
	266	}
	267	},
	268	ast.Node.Id.Suspend => {
	269	const suspend_node = @fieldParentPtr(ast.Node.Suspend, "base", base);
	270	if (suspend_node.label) \|label\| {
	271	try stream.print("{}: ", tree.tokenSlice(label));
	272	}
	273	try stream.print("{}", tree.tokenSlice(suspend_node.suspend_token));
	274
	275	if (suspend_node.body) \|body\| {
	276	try stack.append(RenderState { .Expression = body });
	277	try stack.append(RenderState { .Text = " " });
	278	}
	279
	280	if (suspend_node.payload) \|payload\| {
	281	try stack.append(RenderState { .Expression = payload });
	282	try stack.append(RenderState { .Text = " " });
	283	}
	284	},
	285	ast.Node.Id.InfixOp => {
	286	const prefix_op_node = @fieldParentPtr(ast.Node.InfixOp, "base", base);
	287	try stack.append(RenderState { .Expression = prefix_op_node.rhs });
	288
	289	if (prefix_op_node.op == ast.Node.InfixOp.Op.Catch) {
	290	if (prefix_op_node.op.Catch) \|payload\| {
	291	try stack.append(RenderState { .Text = " " });
	292	try stack.append(RenderState { .Expression = payload });
	293	}
	294	try stack.append(RenderState { .Text = " catch " });
	295	} else {
	296	const text = switch (prefix_op_node.op) {
	297	ast.Node.InfixOp.Op.Add => " + ",
	298	ast.Node.InfixOp.Op.AddWrap => " +% ",
	299	ast.Node.InfixOp.Op.ArrayCat => " ++ ",
	300	ast.Node.InfixOp.Op.ArrayMult => " ** ",
	301	ast.Node.InfixOp.Op.Assign => " = ",
	302	ast.Node.InfixOp.Op.AssignBitAnd => " &= ",
	303	ast.Node.InfixOp.Op.AssignBitOr => " \|= ",
	304	ast.Node.InfixOp.Op.AssignBitShiftLeft => " <<= ",
	305	ast.Node.InfixOp.Op.AssignBitShiftRight => " >>= ",
	306	ast.Node.InfixOp.Op.AssignBitXor => " ^= ",
	307	ast.Node.InfixOp.Op.AssignDiv => " /= ",
	308	ast.Node.InfixOp.Op.AssignMinus => " -= ",
	309	ast.Node.InfixOp.Op.AssignMinusWrap => " -%= ",
	310	ast.Node.InfixOp.Op.AssignMod => " %= ",
	311	ast.Node.InfixOp.Op.AssignPlus => " += ",
	312	ast.Node.InfixOp.Op.AssignPlusWrap => " +%= ",
	313	ast.Node.InfixOp.Op.AssignTimes => " *= ",
	314	ast.Node.InfixOp.Op.AssignTimesWarp => " *%= ",
	315	ast.Node.InfixOp.Op.BangEqual => " != ",
	316	ast.Node.InfixOp.Op.BitAnd => " & ",
	317	ast.Node.InfixOp.Op.BitOr => " \| ",
	318	ast.Node.InfixOp.Op.BitShiftLeft => " << ",
	319	ast.Node.InfixOp.Op.BitShiftRight => " >> ",
	320	ast.Node.InfixOp.Op.BitXor => " ^ ",
	321	ast.Node.InfixOp.Op.BoolAnd => " and ",
	322	ast.Node.InfixOp.Op.BoolOr => " or ",
	323	ast.Node.InfixOp.Op.Div => " / ",
	324	ast.Node.InfixOp.Op.EqualEqual => " == ",
	325	ast.Node.InfixOp.Op.ErrorUnion => "!",
	326	ast.Node.InfixOp.Op.GreaterOrEqual => " >= ",
	327	ast.Node.InfixOp.Op.GreaterThan => " > ",
	328	ast.Node.InfixOp.Op.LessOrEqual => " <= ",
	329	ast.Node.InfixOp.Op.LessThan => " < ",
	330	ast.Node.InfixOp.Op.MergeErrorSets => " \|\| ",
	331	ast.Node.InfixOp.Op.Mod => " % ",
	332	ast.Node.InfixOp.Op.Mult => " * ",
	333	ast.Node.InfixOp.Op.MultWrap => " *% ",
	334	ast.Node.InfixOp.Op.Period => ".",
	335	ast.Node.InfixOp.Op.Sub => " - ",
	336	ast.Node.InfixOp.Op.SubWrap => " -% ",
	337	ast.Node.InfixOp.Op.UnwrapMaybe => " ?? ",
	338	ast.Node.InfixOp.Op.Range => " ... ",
	339	ast.Node.InfixOp.Op.Catch => unreachable,
	340	};
	341
	342	try stack.append(RenderState { .Text = text });
	343	}
	344	try stack.append(RenderState { .Expression = prefix_op_node.lhs });
	345	},
	346	ast.Node.Id.PrefixOp => {
	347	const prefix_op_node = @fieldParentPtr(ast.Node.PrefixOp, "base", base);
	348	try stack.append(RenderState { .Expression = prefix_op_node.rhs });
	349	switch (prefix_op_node.op) {
	350	ast.Node.PrefixOp.Op.AddrOf => \|addr_of_info\| {
	351	try stream.write("&");
	352	if (addr_of_info.volatile_token != null) {
	353	try stack.append(RenderState { .Text = "volatile "});
	354	}
	355	if (addr_of_info.const_token != null) {
	356	try stack.append(RenderState { .Text = "const "});
	357	}
	358	if (addr_of_info.align_expr) \|align_expr\| {
	359	try stream.print("align(");
	360	try stack.append(RenderState { .Text = ") "});
	361	try stack.append(RenderState { .Expression = align_expr});
	362	}
	363	},
	364	ast.Node.PrefixOp.Op.SliceType => \|addr_of_info\| {
	365	try stream.write("[]");
	366	if (addr_of_info.volatile_token != null) {
	367	try stack.append(RenderState { .Text = "volatile "});
	368	}
	369	if (addr_of_info.const_token != null) {
	370	try stack.append(RenderState { .Text = "const "});
	371	}
	372	if (addr_of_info.align_expr) \|align_expr\| {
	373	try stream.print("align(");
	374	try stack.append(RenderState { .Text = ") "});
	375	try stack.append(RenderState { .Expression = align_expr});
	376	}
	377	},
	378	ast.Node.PrefixOp.Op.ArrayType => \|array_index\| {
	379	try stack.append(RenderState { .Text = "]"});
	380	try stack.append(RenderState { .Expression = array_index});
	381	try stack.append(RenderState { .Text = "["});
	382	},
	383	ast.Node.PrefixOp.Op.BitNot => try stream.write("~"),
	384	ast.Node.PrefixOp.Op.BoolNot => try stream.write("!"),
	385	ast.Node.PrefixOp.Op.Deref => try stream.write("*"),
	386	ast.Node.PrefixOp.Op.Negation => try stream.write("-"),
	387	ast.Node.PrefixOp.Op.NegationWrap => try stream.write("-%"),
	388	ast.Node.PrefixOp.Op.Try => try stream.write("try "),
	389	ast.Node.PrefixOp.Op.UnwrapMaybe => try stream.write("??"),
	390	ast.Node.PrefixOp.Op.MaybeType => try stream.write("?"),
	391	ast.Node.PrefixOp.Op.Await => try stream.write("await "),
	392	ast.Node.PrefixOp.Op.Cancel => try stream.write("cancel "),
	393	ast.Node.PrefixOp.Op.Resume => try stream.write("resume "),
	394	}
	395	},
	396	ast.Node.Id.SuffixOp => {
	397	const suffix_op = @fieldParentPtr(ast.Node.SuffixOp, "base", base);
	398
	399	switch (suffix_op.op) {
	400	@TagType(ast.Node.SuffixOp.Op).Call => \|*call_info\| {
	401	try stack.append(RenderState { .Text = ")"});
	402	var i = call_info.params.len;
	403	while (i != 0) {
	404	i -= 1;
	405	const param_node = *call_info.params.at(i);
	406	try stack.append(RenderState { .Expression = param_node});
	407	if (i != 0) {
	408	try stack.append(RenderState { .Text = ", " });
	409	}
	410	}
	411	try stack.append(RenderState { .Text = "("});
	412	try stack.append(RenderState { .Expression = suffix_op.lhs });
	413
	414	if (call_info.async_attr) \|async_attr\| {
	415	try stack.append(RenderState { .Text = " "});
	416	try stack.append(RenderState { .Expression = &async_attr.base });
	417	}
	418	},
	419	ast.Node.SuffixOp.Op.ArrayAccess => \|index_expr\| {
	420	try stack.append(RenderState { .Text = "]"});
	421	try stack.append(RenderState { .Expression = index_expr});
	422	try stack.append(RenderState { .Text = "["});
	423	try stack.append(RenderState { .Expression = suffix_op.lhs });
	424	},
	425	@TagType(ast.Node.SuffixOp.Op).Slice => \|range\| {
	426	try stack.append(RenderState { .Text = "]"});
	427	if (range.end) \|end\| {
	428	try stack.append(RenderState { .Expression = end});
	429	}
	430	try stack.append(RenderState { .Text = ".."});
	431	try stack.append(RenderState { .Expression = range.start});
	432	try stack.append(RenderState { .Text = "["});
	433	try stack.append(RenderState { .Expression = suffix_op.lhs });
	434	},
	435	ast.Node.SuffixOp.Op.StructInitializer => \|*field_inits\| {
	436	if (field_inits.len == 0) {
	437	try stack.append(RenderState { .Text = "{}" });
	438	try stack.append(RenderState { .Expression = suffix_op.lhs });
	439	continue;
	440	}
	441	if (field_inits.len == 1) {
	442	const field_init = *field_inits.at(0);
	443
	444	try stack.append(RenderState { .Text = " }" });
	445	try stack.append(RenderState { .Expression = field_init });
	446	try stack.append(RenderState { .Text = "{ " });
	447	try stack.append(RenderState { .Expression = suffix_op.lhs });
	448	continue;
	449	}
	450	try stack.append(RenderState { .Text = "}"});
	451	try stack.append(RenderState.PrintIndent);
	452	try stack.append(RenderState { .Indent = indent });
	453	try stack.append(RenderState { .Text = "\n" });
	454	var i = field_inits.len;
	455	while (i != 0) {
	456	i -= 1;
	457	const field_init = *field_inits.at(i);
	458	if (field_init.id != ast.Node.Id.LineComment) {
	459	try stack.append(RenderState { .Text = "," });
	460	}
	461	try stack.append(RenderState { .Expression = field_init });
	462	try stack.append(RenderState.PrintIndent);
	463	if (i != 0) {
	464	try stack.append(RenderState { .Text = blk: {
	465	const prev_node = *field_inits.at(i - 1);
	466	const prev_node_last_token_end = tree.tokens.at(prev_node.lastToken()).end;
	467	const loc = tree.tokenLocation(prev_node_last_token_end, field_init.firstToken());
	468	if (loc.line >= 2) {
	469	break :blk "\n\n";
	470	}
	471	break :blk "\n";
	472	}});
	473	}
	474	}
	475	try stack.append(RenderState { .Indent = indent + indent_delta });
	476	try stack.append(RenderState { .Text = "{\n"});
	477	try stack.append(RenderState { .Expression = suffix_op.lhs });
	478	},
	479	ast.Node.SuffixOp.Op.ArrayInitializer => \|*exprs\| {
	480	if (exprs.len == 0) {
	481	try stack.append(RenderState { .Text = "{}" });
	482	try stack.append(RenderState { .Expression = suffix_op.lhs });
	483	continue;
	484	}
	485	if (exprs.len == 1) {
	486	const expr = *exprs.at(0);
	487
	488	try stack.append(RenderState { .Text = "}" });
	489	try stack.append(RenderState { .Expression = expr });
	490	try stack.append(RenderState { .Text = "{" });
	491	try stack.append(RenderState { .Expression = suffix_op.lhs });
	492	continue;
	493	}
	494
	495	try stack.append(RenderState { .Text = "}"});
	496	try stack.append(RenderState.PrintIndent);
	497	try stack.append(RenderState { .Indent = indent });
	498	var i = exprs.len;
	499	while (i != 0) {
	500	i -= 1;
	501	const expr = *exprs.at(i);
	502	try stack.append(RenderState { .Text = ",\n" });
	503	try stack.append(RenderState { .Expression = expr });
	504	try stack.append(RenderState.PrintIndent);
	505	}
	506	try stack.append(RenderState { .Indent = indent + indent_delta });
	507	try stack.append(RenderState { .Text = "{\n"});
	508	try stack.append(RenderState { .Expression = suffix_op.lhs });
	509	},
	510	}
	511	},
	512	ast.Node.Id.ControlFlowExpression => {
	513	const flow_expr = @fieldParentPtr(ast.Node.ControlFlowExpression, "base", base);
	514
	515	if (flow_expr.rhs) \|rhs\| {
	516	try stack.append(RenderState { .Expression = rhs });
	517	try stack.append(RenderState { .Text = " " });
	518	}
	519
	520	switch (flow_expr.kind) {
	521	ast.Node.ControlFlowExpression.Kind.Break => \|maybe_label\| {
	522	try stream.print("break");
	523	if (maybe_label) \|label\| {
	524	try stream.print(" :");
	525	try stack.append(RenderState { .Expression = label });
	526	}
	527	},
	528	ast.Node.ControlFlowExpression.Kind.Continue => \|maybe_label\| {
	529	try stream.print("continue");
	530	if (maybe_label) \|label\| {
	531	try stream.print(" :");
	532	try stack.append(RenderState { .Expression = label });
	533	}
	534	},
	535	ast.Node.ControlFlowExpression.Kind.Return => {
	536	try stream.print("return");
	537	},
	538
	539	}
	540	},
	541	ast.Node.Id.Payload => {
	542	const payload = @fieldParentPtr(ast.Node.Payload, "base", base);
	543	try stack.append(RenderState { .Text = "\|"});
	544	try stack.append(RenderState { .Expression = payload.error_symbol });
	545	try stack.append(RenderState { .Text = "\|"});
	546	},
	547	ast.Node.Id.PointerPayload => {
	548	const payload = @fieldParentPtr(ast.Node.PointerPayload, "base", base);
	549	try stack.append(RenderState { .Text = "\|"});
	550	try stack.append(RenderState { .Expression = payload.value_symbol });
	551
	552	if (payload.ptr_token) \|ptr_token\| {
	553	try stack.append(RenderState { .Text = tree.tokenSlice(ptr_token) });
	554	}
	555
	556	try stack.append(RenderState { .Text = "\|"});
	557	},
	558	ast.Node.Id.PointerIndexPayload => {
	559	const payload = @fieldParentPtr(ast.Node.PointerIndexPayload, "base", base);
	560	try stack.append(RenderState { .Text = "\|"});
	561
	562	if (payload.index_symbol) \|index_symbol\| {
	563	try stack.append(RenderState { .Expression = index_symbol });
	564	try stack.append(RenderState { .Text = ", "});
	565	}
	566
	567	try stack.append(RenderState { .Expression = payload.value_symbol });
	568
	569	if (payload.ptr_token) \|ptr_token\| {
	570	try stack.append(RenderState { .Text = tree.tokenSlice(ptr_token) });
	571	}
	572
	573	try stack.append(RenderState { .Text = "\|"});
	574	},
	575	ast.Node.Id.GroupedExpression => {
	576	const grouped_expr = @fieldParentPtr(ast.Node.GroupedExpression, "base", base);
	577	try stack.append(RenderState { .Text = ")"});
	578	try stack.append(RenderState { .Expression = grouped_expr.expr });
	579	try stack.append(RenderState { .Text = "("});
	580	},
	581	ast.Node.Id.FieldInitializer => {
	582	const field_init = @fieldParentPtr(ast.Node.FieldInitializer, "base", base);
	583	try stream.print(".{} = ", tree.tokenSlice(field_init.name_token));
	584	try stack.append(RenderState { .Expression = field_init.expr });
	585	},
	586	ast.Node.Id.IntegerLiteral => {
	587	const integer_literal = @fieldParentPtr(ast.Node.IntegerLiteral, "base", base);
	588	try stream.print("{}", tree.tokenSlice(integer_literal.token));
	589	},
	590	ast.Node.Id.FloatLiteral => {
	591	const float_literal = @fieldParentPtr(ast.Node.FloatLiteral, "base", base);
	592	try stream.print("{}", tree.tokenSlice(float_literal.token));
	593	},
	594	ast.Node.Id.StringLiteral => {
	595	const string_literal = @fieldParentPtr(ast.Node.StringLiteral, "base", base);
	596	try stream.print("{}", tree.tokenSlice(string_literal.token));
	597	},
	598	ast.Node.Id.CharLiteral => {
	599	const char_literal = @fieldParentPtr(ast.Node.CharLiteral, "base", base);
	600	try stream.print("{}", tree.tokenSlice(char_literal.token));
	601	},
	602	ast.Node.Id.BoolLiteral => {
	603	const bool_literal = @fieldParentPtr(ast.Node.CharLiteral, "base", base);
	604	try stream.print("{}", tree.tokenSlice(bool_literal.token));
	605	},
	606	ast.Node.Id.NullLiteral => {
	607	const null_literal = @fieldParentPtr(ast.Node.NullLiteral, "base", base);
	608	try stream.print("{}", tree.tokenSlice(null_literal.token));
	609	},
	610	ast.Node.Id.ThisLiteral => {
	611	const this_literal = @fieldParentPtr(ast.Node.ThisLiteral, "base", base);
	612	try stream.print("{}", tree.tokenSlice(this_literal.token));
	613	},
	614	ast.Node.Id.Unreachable => {
	615	const unreachable_node = @fieldParentPtr(ast.Node.Unreachable, "base", base);
	616	try stream.print("{}", tree.tokenSlice(unreachable_node.token));
	617	},
	618	ast.Node.Id.ErrorType => {
	619	const error_type = @fieldParentPtr(ast.Node.ErrorType, "base", base);
	620	try stream.print("{}", tree.tokenSlice(error_type.token));
	621	},
	622	ast.Node.Id.VarType => {
	623	const var_type = @fieldParentPtr(ast.Node.VarType, "base", base);
	624	try stream.print("{}", tree.tokenSlice(var_type.token));
	625	},
	626	ast.Node.Id.ContainerDecl => {
	627	const container_decl = @fieldParentPtr(ast.Node.ContainerDecl, "base", base);
	628
	629	switch (container_decl.layout) {
	630	ast.Node.ContainerDecl.Layout.Packed => try stream.print("packed "),
	631	ast.Node.ContainerDecl.Layout.Extern => try stream.print("extern "),
	632	ast.Node.ContainerDecl.Layout.Auto => { },
	633	}
	634
	635	switch (container_decl.kind) {
	636	ast.Node.ContainerDecl.Kind.Struct => try stream.print("struct"),
	637	ast.Node.ContainerDecl.Kind.Enum => try stream.print("enum"),
	638	ast.Node.ContainerDecl.Kind.Union => try stream.print("union"),
	639	}
	640
	641	if (container_decl.fields_and_decls.len == 0) {
	642	try stack.append(RenderState { .Text = "{}"});
	643	} else {
	644	try stack.append(RenderState { .Text = "}"});
	645	try stack.append(RenderState.PrintIndent);
	646	try stack.append(RenderState { .Indent = indent });
	647	try stack.append(RenderState { .Text = "\n"});
	648
	649	var i = container_decl.fields_and_decls.len;
	650	while (i != 0) {
	651	i -= 1;
	652	const node = *container_decl.fields_and_decls.at(i);
	653	try stack.append(RenderState { .TopLevelDecl = node});
	654	try stack.append(RenderState.PrintIndent);
	655	try stack.append(RenderState {
	656	.Text = blk: {
	657	if (i != 0) {
	658	const prev_node = *container_decl.fields_and_decls.at(i - 1);
	659	const prev_node_last_token_end = tree.tokens.at(prev_node.lastToken()).end;
	660	const loc = tree.tokenLocation(prev_node_last_token_end, node.firstToken());
	661	if (loc.line >= 2) {
	662	break :blk "\n\n";
	663	}
	664	}
	665	break :blk "\n";
	666	},
	667	});
	668	}
	669	try stack.append(RenderState { .Indent = indent + indent_delta});
	670	try stack.append(RenderState { .Text = "{"});
	671	}
	672
	673	switch (container_decl.init_arg_expr) {
	674	ast.Node.ContainerDecl.InitArg.None => try stack.append(RenderState { .Text = " "}),
	675	ast.Node.ContainerDecl.InitArg.Enum => \|enum_tag_type\| {
	676	if (enum_tag_type) \|expr\| {
	677	try stack.append(RenderState { .Text = ")) "});
	678	try stack.append(RenderState { .Expression = expr});
	679	try stack.append(RenderState { .Text = "(enum("});
	680	} else {
	681	try stack.append(RenderState { .Text = "(enum) "});
	682	}
	683	},
	684	ast.Node.ContainerDecl.InitArg.Type => \|type_expr\| {
	685	try stack.append(RenderState { .Text = ") "});
	686	try stack.append(RenderState { .Expression = type_expr});
	687	try stack.append(RenderState { .Text = "("});
	688	},
	689	}
	690	},
	691	ast.Node.Id.ErrorSetDecl => {
	692	const err_set_decl = @fieldParentPtr(ast.Node.ErrorSetDecl, "base", base);
	693
	694	if (err_set_decl.decls.len == 0) {
	695	try stream.write("error{}");
	696	continue;
	697	}
	698
	699	if (err_set_decl.decls.len == 1) blk: {
	700	const node = *err_set_decl.decls.at(0);
	701
	702	// if there are any doc comments or same line comments
	703	// don't try to put it all on one line
	704	if (node.cast(ast.Node.ErrorTag)) \|tag\| {
	705	if (tag.doc_comments != null) break :blk;
	706	} else {
	707	break :blk;
	708	}
	709
	710
	711	try stream.write("error{");
	712	try stack.append(RenderState { .Text = "}" });
	713	try stack.append(RenderState { .TopLevelDecl = node });
	714	continue;
	715	}
	716
	717	try stream.write("error{");
	718
	719	try stack.append(RenderState { .Text = "}"});
	720	try stack.append(RenderState.PrintIndent);
	721	try stack.append(RenderState { .Indent = indent });
	722	try stack.append(RenderState { .Text = "\n"});
	723
	724	var i = err_set_decl.decls.len;
	725	while (i != 0) {
	726	i -= 1;
	727	const node = *err_set_decl.decls.at(i);
	728	if (node.id != ast.Node.Id.LineComment) {
	729	try stack.append(RenderState { .Text = "," });
	730	}
	731	try stack.append(RenderState { .TopLevelDecl = node });
	732	try stack.append(RenderState.PrintIndent);
	733	try stack.append(RenderState {
	734	.Text = blk: {
	735	if (i != 0) {
	736	const prev_node = *err_set_decl.decls.at(i - 1);
	737	const prev_node_last_token_end = tree.tokens.at(prev_node.lastToken()).end;
	738	const loc = tree.tokenLocation(prev_node_last_token_end, node.firstToken());
	739	if (loc.line >= 2) {
	740	break :blk "\n\n";
	741	}
	742	}
	743	break :blk "\n";
	744	},
	745	});
	746	}
	747	try stack.append(RenderState { .Indent = indent + indent_delta});
	748	},
	749	ast.Node.Id.MultilineStringLiteral => {
	750	const multiline_str_literal = @fieldParentPtr(ast.Node.MultilineStringLiteral, "base", base);
	751	try stream.print("\n");
	752
	753	var i : usize = 0;
	754	while (i < multiline_str_literal.lines.len) : (i += 1) {
	755	const t = *multiline_str_literal.lines.at(i);
	756	try stream.writeByteNTimes(' ', indent + indent_delta);
	757	try stream.print("{}", tree.tokenSlice(t));
	758	}
	759	try stream.writeByteNTimes(' ', indent);
	760	},
	761	ast.Node.Id.UndefinedLiteral => {
	762	const undefined_literal = @fieldParentPtr(ast.Node.UndefinedLiteral, "base", base);
	763	try stream.print("{}", tree.tokenSlice(undefined_literal.token));
	764	},
	765	ast.Node.Id.BuiltinCall => {
	766	const builtin_call = @fieldParentPtr(ast.Node.BuiltinCall, "base", base);
	767	try stream.print("{}(", tree.tokenSlice(builtin_call.builtin_token));
	768	try stack.append(RenderState { .Text = ")"});
	769	var i = builtin_call.params.len;
	770	while (i != 0) {
	771	i -= 1;
	772	const param_node = *builtin_call.params.at(i);
	773	try stack.append(RenderState { .Expression = param_node});
	774	if (i != 0) {
	775	try stack.append(RenderState { .Text = ", " });
	776	}
	777	}
	778	},
	779	ast.Node.Id.FnProto => {
	780	const fn_proto = @fieldParentPtr(ast.Node.FnProto, "base", base);
	781
	782	switch (fn_proto.return_type) {
	783	ast.Node.FnProto.ReturnType.Explicit => \|node\| {
	784	try stack.append(RenderState { .Expression = node});
	785	},
	786	ast.Node.FnProto.ReturnType.InferErrorSet => \|node\| {
	787	try stack.append(RenderState { .Expression = node});
	788	try stack.append(RenderState { .Text = "!"});
	789	},
	790	}
	791
	792	if (fn_proto.align_expr) \|align_expr\| {
	793	try stack.append(RenderState { .Text = ") " });
	794	try stack.append(RenderState { .Expression = align_expr});
	795	try stack.append(RenderState { .Text = "align(" });
	796	}
	797
	798	try stack.append(RenderState { .Text = ") " });
	799	var i = fn_proto.params.len;
	800	while (i != 0) {
	801	i -= 1;
	802	const param_decl_node = *fn_proto.params.at(i);
	803	try stack.append(RenderState { .ParamDecl = param_decl_node});
	804	if (i != 0) {
	805	try stack.append(RenderState { .Text = ", " });
	806	}
	807	}
	808
	809	try stack.append(RenderState { .Text = "(" });
	810	if (fn_proto.name_token) \|name_token\| {
	811	try stack.append(RenderState { .Text = tree.tokenSlice(name_token) });
	812	try stack.append(RenderState { .Text = " " });
	813	}
	814
	815	try stack.append(RenderState { .Text = "fn" });
	816
	817	if (fn_proto.async_attr) \|async_attr\| {
	818	try stack.append(RenderState { .Text = " " });
	819	try stack.append(RenderState { .Expression = &async_attr.base });
	820	}
	821
	822	if (fn_proto.cc_token) \|cc_token\| {
	823	try stack.append(RenderState { .Text = " " });
	824	try stack.append(RenderState { .Text = tree.tokenSlice(cc_token) });
	825	}
	826
	827	if (fn_proto.lib_name) \|lib_name\| {
	828	try stack.append(RenderState { .Text = " " });
	829	try stack.append(RenderState { .Expression = lib_name });
	830	}
	831	if (fn_proto.extern_export_inline_token) \|extern_export_inline_token\| {
	832	try stack.append(RenderState { .Text = " " });
	833	try stack.append(RenderState { .Text = tree.tokenSlice(extern_export_inline_token) });
	834	}
	835
	836	if (fn_proto.visib_token) \|visib_token_index\| {
	837	const visib_token = tree.tokens.at(visib_token_index);
	838	assert(visib_token.id == Token.Id.Keyword_pub or visib_token.id == Token.Id.Keyword_export);
	839	try stack.append(RenderState { .Text = " " });
	840	try stack.append(RenderState { .Text = tree.tokenSlice(visib_token_index) });
	841	}
	842	},
	843	ast.Node.Id.PromiseType => {
	844	const promise_type = @fieldParentPtr(ast.Node.PromiseType, "base", base);
	845	try stream.write(tree.tokenSlice(promise_type.promise_token));
	846	if (promise_type.result) \|result\| {
	847	try stream.write(tree.tokenSlice(result.arrow_token));
	848	try stack.append(RenderState { .Expression = result.return_type});
	849	}
	850	},
	851	ast.Node.Id.LineComment => {
	852	const line_comment_node = @fieldParentPtr(ast.Node.LineComment, "base", base);
	853	try stream.write(tree.tokenSlice(line_comment_node.token));
	854	},
	855	ast.Node.Id.DocComment => unreachable, // doc comments are attached to nodes
	856	ast.Node.Id.Switch => {
	857	const switch_node = @fieldParentPtr(ast.Node.Switch, "base", base);
	858
	859	try stream.print("{} (", tree.tokenSlice(switch_node.switch_token));
	860
	861	if (switch_node.cases.len == 0) {
	862	try stack.append(RenderState { .Text = ") {}"});
	863	try stack.append(RenderState { .Expression = switch_node.expr });
	864	continue;
	865	}
	866
	867	try stack.append(RenderState { .Text = "}"});
	868	try stack.append(RenderState.PrintIndent);
	869	try stack.append(RenderState { .Indent = indent });
	870	try stack.append(RenderState { .Text = "\n"});
	871
	872	var i = switch_node.cases.len;
	873	while (i != 0) {
	874	i -= 1;
	875	const node = *switch_node.cases.at(i);
	876	try stack.append(RenderState { .Expression = node});
	877	try stack.append(RenderState.PrintIndent);
	878	try stack.append(RenderState {
	879	.Text = blk: {
	880	if (i != 0) {
	881	const prev_node = *switch_node.cases.at(i - 1);
	882	const prev_node_last_token_end = tree.tokens.at(prev_node.lastToken()).end;
	883	const loc = tree.tokenLocation(prev_node_last_token_end, node.firstToken());
	884	if (loc.line >= 2) {
	885	break :blk "\n\n";
	886	}
	887	}
	888	break :blk "\n";
	889	},
	890	});
	891	}
	892	try stack.append(RenderState { .Indent = indent + indent_delta});
	893	try stack.append(RenderState { .Text = ") {"});
	894	try stack.append(RenderState { .Expression = switch_node.expr });
	895	},
	896	ast.Node.Id.SwitchCase => {
	897	const switch_case = @fieldParentPtr(ast.Node.SwitchCase, "base", base);
	898
	899	try stack.append(RenderState { .Token = switch_case.lastToken() + 1 });
	900	try stack.append(RenderState { .Expression = switch_case.expr });
	901	if (switch_case.payload) \|payload\| {
	902	try stack.append(RenderState { .Text = " " });
	903	try stack.append(RenderState { .Expression = payload });
	904	}
	905	try stack.append(RenderState { .Text = " => "});
	906
	907	var i = switch_case.items.len;
	908	while (i != 0) {
	909	i -= 1;
	910	try stack.append(RenderState { .Expression = *switch_case.items.at(i) });
	911
	912	if (i != 0) {
	913	try stack.append(RenderState.PrintIndent);
	914	try stack.append(RenderState { .Text = ",\n" });
	915	}
	916	}
	917	},
	918	ast.Node.Id.SwitchElse => {
	919	const switch_else = @fieldParentPtr(ast.Node.SwitchElse, "base", base);
	920	try stream.print("{}", tree.tokenSlice(switch_else.token));
	921	},
	922	ast.Node.Id.Else => {
	923	const else_node = @fieldParentPtr(ast.Node.Else, "base", base);
	924	try stream.print("{}", tree.tokenSlice(else_node.else_token));
	925
	926	switch (else_node.body.id) {
	927	ast.Node.Id.Block, ast.Node.Id.If,
	928	ast.Node.Id.For, ast.Node.Id.While,
	929	ast.Node.Id.Switch => {
	930	try stream.print(" ");
	931	try stack.append(RenderState { .Expression = else_node.body });
	932	},
	933	else => {
	934	try stack.append(RenderState { .Indent = indent });
	935	try stack.append(RenderState { .Expression = else_node.body });
	936	try stack.append(RenderState.PrintIndent);
	937	try stack.append(RenderState { .Indent = indent + indent_delta });
	938	try stack.append(RenderState { .Text = "\n" });
	939	}
	940	}
	941
	942	if (else_node.payload) \|payload\| {
	943	try stack.append(RenderState { .Text = " " });
	944	try stack.append(RenderState { .Expression = payload });
	945	}
	946	},
	947	ast.Node.Id.While => {
	948	const while_node = @fieldParentPtr(ast.Node.While, "base", base);
	949	if (while_node.label) \|label\| {
	950	try stream.print("{}: ", tree.tokenSlice(label));
	951	}
	952
	953	if (while_node.inline_token) \|inline_token\| {
	954	try stream.print("{} ", tree.tokenSlice(inline_token));
	955	}
	956
	957	try stream.print("{} ", tree.tokenSlice(while_node.while_token));
	958
	959	if (while_node.@"else") \|@"else"\| {
	960	try stack.append(RenderState { .Expression = &@"else".base });
	961
	962	if (while_node.body.id == ast.Node.Id.Block) {
	963	try stack.append(RenderState { .Text = " " });
	964	} else {
	965	try stack.append(RenderState.PrintIndent);
	966	try stack.append(RenderState { .Text = "\n" });
	967	}
	968	}
	969
	970	if (while_node.body.id == ast.Node.Id.Block) {
	971	try stack.append(RenderState { .Expression = while_node.body });
	972	try stack.append(RenderState { .Text = " " });
	973	} else {
	974	try stack.append(RenderState { .Indent = indent });
	975	try stack.append(RenderState { .Expression = while_node.body });
	976	try stack.append(RenderState.PrintIndent);
	977	try stack.append(RenderState { .Indent = indent + indent_delta });
	978	try stack.append(RenderState { .Text = "\n" });
	979	}
	980
	981	if (while_node.continue_expr) \|continue_expr\| {
	982	try stack.append(RenderState { .Text = ")" });
	983	try stack.append(RenderState { .Expression = continue_expr });
	984	try stack.append(RenderState { .Text = ": (" });
	985	try stack.append(RenderState { .Text = " " });
	986	}
	987
	988	if (while_node.payload) \|payload\| {
	989	try stack.append(RenderState { .Expression = payload });
	990	try stack.append(RenderState { .Text = " " });
	991	}
	992
	993	try stack.append(RenderState { .Text = ")" });
	994	try stack.append(RenderState { .Expression = while_node.condition });
	995	try stack.append(RenderState { .Text = "(" });
	996	},
	997	ast.Node.Id.For => {
	998	const for_node = @fieldParentPtr(ast.Node.For, "base", base);
	999	if (for_node.label) \|label\| {
	1000	try stream.print("{}: ", tree.tokenSlice(label));
	1001	}
	1002
	1003	if (for_node.inline_token) \|inline_token\| {
	1004	try stream.print("{} ", tree.tokenSlice(inline_token));
	1005	}
	1006
	1007	try stream.print("{} ", tree.tokenSlice(for_node.for_token));
	1008
	1009	if (for_node.@"else") \|@"else"\| {
	1010	try stack.append(RenderState { .Expression = &@"else".base });
	1011
	1012	if (for_node.body.id == ast.Node.Id.Block) {
	1013	try stack.append(RenderState { .Text = " " });
	1014	} else {
	1015	try stack.append(RenderState.PrintIndent);
	1016	try stack.append(RenderState { .Text = "\n" });
	1017	}
	1018	}
	1019
	1020	if (for_node.body.id == ast.Node.Id.Block) {
	1021	try stack.append(RenderState { .Expression = for_node.body });
	1022	try stack.append(RenderState { .Text = " " });
	1023	} else {
	1024	try stack.append(RenderState { .Indent = indent });
	1025	try stack.append(RenderState { .Expression = for_node.body });
	1026	try stack.append(RenderState.PrintIndent);
	1027	try stack.append(RenderState { .Indent = indent + indent_delta });
	1028	try stack.append(RenderState { .Text = "\n" });
	1029	}
	1030
	1031	if (for_node.payload) \|payload\| {
	1032	try stack.append(RenderState { .Expression = payload });
	1033	try stack.append(RenderState { .Text = " " });
	1034	}
	1035
	1036	try stack.append(RenderState { .Text = ")" });
	1037	try stack.append(RenderState { .Expression = for_node.array_expr });
	1038	try stack.append(RenderState { .Text = "(" });
	1039	},
	1040	ast.Node.Id.If => {
	1041	const if_node = @fieldParentPtr(ast.Node.If, "base", base);
	1042	try stream.print("{} ", tree.tokenSlice(if_node.if_token));
	1043
	1044	switch (if_node.body.id) {
	1045	ast.Node.Id.Block, ast.Node.Id.If,
	1046	ast.Node.Id.For, ast.Node.Id.While,
	1047	ast.Node.Id.Switch => {
	1048	if (if_node.@"else") \|@"else"\| {
	1049	try stack.append(RenderState { .Expression = &@"else".base });
	1050
	1051	if (if_node.body.id == ast.Node.Id.Block) {
	1052	try stack.append(RenderState { .Text = " " });
	1053	} else {
	1054	try stack.append(RenderState.PrintIndent);
	1055	try stack.append(RenderState { .Text = "\n" });
	1056	}
	1057	}
	1058	},
	1059	else => {
	1060	if (if_node.@"else") \|@"else"\| {
	1061	try stack.append(RenderState { .Expression = @"else".body });
	1062
	1063	if (@"else".payload) \|payload\| {
	1064	try stack.append(RenderState { .Text = " " });
	1065	try stack.append(RenderState { .Expression = payload });
	1066	}
	1067
	1068	try stack.append(RenderState { .Text = " " });
	1069	try stack.append(RenderState { .Text = tree.tokenSlice(@"else".else_token) });
	1070	try stack.append(RenderState { .Text = " " });
	1071	}
	1072	}
	1073	}
	1074
	1075	try stack.append(RenderState { .Expression = if_node.body });
	1076
	1077	if (if_node.payload) \|payload\| {
	1078	try stack.append(RenderState { .Text = " " });
	1079	try stack.append(RenderState { .Expression = payload });
	1080	}
	1081
	1082	try stack.append(RenderState { .NonBreakToken = if_node.condition.lastToken() + 1 });
	1083	try stack.append(RenderState { .Expression = if_node.condition });
	1084	try stack.append(RenderState { .Text = "(" });
	1085	},
	1086	ast.Node.Id.Asm => {
	1087	const asm_node = @fieldParentPtr(ast.Node.Asm, "base", base);
	1088	try stream.print("{} ", tree.tokenSlice(asm_node.asm_token));
	1089
	1090	if (asm_node.volatile_token) \|volatile_token\| {
	1091	try stream.print("{} ", tree.tokenSlice(volatile_token));
	1092	}
	1093
	1094	try stack.append(RenderState { .Indent = indent });
	1095	try stack.append(RenderState { .Text = ")" });
	1096	{
	1097	var i = asm_node.clobbers.len;
	1098	while (i != 0) {
	1099	i -= 1;
	1100	try stack.append(RenderState { .Expression = *asm_node.clobbers.at(i) });
	1101
	1102	if (i != 0) {
	1103	try stack.append(RenderState { .Text = ", " });
	1104	}
	1105	}
	1106	}
	1107	try stack.append(RenderState { .Text = ": " });
	1108	try stack.append(RenderState.PrintIndent);
	1109	try stack.append(RenderState { .Indent = indent + indent_delta });
	1110	try stack.append(RenderState { .Text = "\n" });
	1111	{
	1112	var i = asm_node.inputs.len;
	1113	while (i != 0) {
	1114	i -= 1;
	1115	const node = *asm_node.inputs.at(i);
	1116	try stack.append(RenderState { .Expression = &node.base});
	1117
	1118	if (i != 0) {
	1119	try stack.append(RenderState.PrintIndent);
	1120	try stack.append(RenderState {
	1121	.Text = blk: {
	1122	const prev_node = *asm_node.inputs.at(i - 1);
	1123	const prev_node_last_token_end = tree.tokens.at(prev_node.lastToken()).end;
	1124	const loc = tree.tokenLocation(prev_node_last_token_end, node.firstToken());
	1125	if (loc.line >= 2) {
	1126	break :blk "\n\n";
	1127	}
	1128	break :blk "\n";
	1129	},
	1130	});
	1131	try stack.append(RenderState { .Text = "," });
	1132	}
	1133	}
	1134	}
	1135	try stack.append(RenderState { .Indent = indent + indent_delta + 2});
	1136	try stack.append(RenderState { .Text = ": "});
	1137	try stack.append(RenderState.PrintIndent);
	1138	try stack.append(RenderState { .Indent = indent + indent_delta});
	1139	try stack.append(RenderState { .Text = "\n" });
	1140	{
	1141	var i = asm_node.outputs.len;
	1142	while (i != 0) {
	1143	i -= 1;
	1144	const node = *asm_node.outputs.at(i);
	1145	try stack.append(RenderState { .Expression = &node.base});
	1146
	1147	if (i != 0) {
	1148	try stack.append(RenderState.PrintIndent);
	1149	try stack.append(RenderState {
	1150	.Text = blk: {
	1151	const prev_node = *asm_node.outputs.at(i - 1);
	1152	const prev_node_last_token_end = tree.tokens.at(prev_node.lastToken()).end;
	1153	const loc = tree.tokenLocation(prev_node_last_token_end, node.firstToken());
	1154	if (loc.line >= 2) {
	1155	break :blk "\n\n";
	1156	}
	1157	break :blk "\n";
	1158	},
	1159	});
	1160	try stack.append(RenderState { .Text = "," });
	1161	}
	1162	}
	1163	}
	1164	try stack.append(RenderState { .Indent = indent + indent_delta + 2});
	1165	try stack.append(RenderState { .Text = ": "});
	1166	try stack.append(RenderState.PrintIndent);
	1167	try stack.append(RenderState { .Indent = indent + indent_delta});
	1168	try stack.append(RenderState { .Text = "\n" });
	1169	try stack.append(RenderState { .Expression = asm_node.template });
	1170	try stack.append(RenderState { .Text = "(" });
	1171	},
	1172	ast.Node.Id.AsmInput => {
	1173	const asm_input = @fieldParentPtr(ast.Node.AsmInput, "base", base);
	1174
	1175	try stack.append(RenderState { .Text = ")"});
	1176	try stack.append(RenderState { .Expression = asm_input.expr});
	1177	try stack.append(RenderState { .Text = " ("});
	1178	try stack.append(RenderState { .Expression = asm_input.constraint });
	1179	try stack.append(RenderState { .Text = "] "});
	1180	try stack.append(RenderState { .Expression = asm_input.symbolic_name });
	1181	try stack.append(RenderState { .Text = "["});
	1182	},
	1183	ast.Node.Id.AsmOutput => {
	1184	const asm_output = @fieldParentPtr(ast.Node.AsmOutput, "base", base);
	1185
	1186	try stack.append(RenderState { .Text = ")"});
	1187	switch (asm_output.kind) {
	1188	ast.Node.AsmOutput.Kind.Variable => \|variable_name\| {
	1189	try stack.append(RenderState { .Expression = &variable_name.base});
	1190	},
	1191	ast.Node.AsmOutput.Kind.Return => \|return_type\| {
	1192	try stack.append(RenderState { .Expression = return_type});
	1193	try stack.append(RenderState { .Text = "-> "});
	1194	},
	1195	}
	1196	try stack.append(RenderState { .Text = " ("});
	1197	try stack.append(RenderState { .Expression = asm_output.constraint });
	1198	try stack.append(RenderState { .Text = "] "});
	1199	try stack.append(RenderState { .Expression = asm_output.symbolic_name });
	1200	try stack.append(RenderState { .Text = "["});
	1201	},
	1202
	1203	ast.Node.Id.StructField,
	1204	ast.Node.Id.UnionTag,
	1205	ast.Node.Id.EnumTag,
	1206	ast.Node.Id.ErrorTag,
	1207	ast.Node.Id.Root,
	1208	ast.Node.Id.VarDecl,
	1209	ast.Node.Id.Use,
	1210	ast.Node.Id.TestDecl,
	1211	ast.Node.Id.ParamDecl => unreachable,
	1212	},
	1213	RenderState.Statement => \|base\| {
	1214	switch (base.id) {
	1215	ast.Node.Id.VarDecl => {
	1216	const var_decl = @fieldParentPtr(ast.Node.VarDecl, "base", base);
	1217	try stack.append(RenderState { .VarDecl = var_decl});
	1218	},
	1219	else => {
	1220	try stack.append(RenderState { .MaybeSemiColon = base });
	1221	try stack.append(RenderState { .Expression = base });
	1222	},
	1223	}
	1224	},
	1225	RenderState.Indent => \|new_indent\| indent = new_indent,
	1226	RenderState.PrintIndent => try stream.writeByteNTimes(' ', indent),
	1227	RenderState.Token => \|token_index\| try renderToken(tree, stream, token_index, indent, true),
	1228	RenderState.NonBreakToken => \|token_index\| try renderToken(tree, stream, token_index, indent, false),
	1229	RenderState.MaybeSemiColon => \|base\| {
	1230	if (base.requireSemiColon()) {
	1231	const semicolon_index = base.lastToken() + 1;
	1232	assert(tree.tokens.at(semicolon_index).id == Token.Id.Semicolon);
	1233	try renderToken(tree, stream, semicolon_index, indent, true);
	1234	}
	1235	},
	1236	}
	1237	}
	1238	}
	1239
	1240	fn renderToken(tree: &ast.Tree, stream: var, token_index: ast.TokenIndex, indent: usize, line_break: bool) !void {
	1241	const token = tree.tokens.at(token_index);
	1242	try stream.write(tree.tokenSlicePtr(token));
	1243
	1244	const next_token = tree.tokens.at(token_index + 1);
	1245	if (next_token.id == Token.Id.LineComment) {
	1246	const loc = tree.tokenLocationPtr(token.end, next_token);
	1247	if (loc.line == 0) {
	1248	try stream.print(" {}", tree.tokenSlicePtr(next_token));
	1249	if (!line_break) {
	1250	try stream.write("\n");
	1251	try stream.writeByteNTimes(' ', indent + indent_delta);
	1252	return;
	1253	}
	1254	}
	1255	}
	1256
	1257	if (!line_break) {
	1258	try stream.writeByte(' ');
	1259	}
	1260	}
	1261
	1262	fn renderComments(tree: &ast.Tree, stream: var, node: var, indent: usize) !void {
	1263	const comment = node.doc_comments ?? return;
	1264	var it = comment.lines.iterator(0);
	1265	while (it.next()) \|line_token_index\| {
	1266	try stream.print("{}\n", tree.tokenSlice(*line_token_index));
	1267	try stream.writeByteNTimes(' ', indent);
	1268	}
	1269	}
	1270

std/zig/tokenizer.zig+301-119

...	...	@@ -5,56 +5,61 @@ pub const Token = struct {
5	5	id: Id,
6	6	start: usize,
7	7	end: usize,
8		line: usize,
9		column: usize,
10	8
11		const KeywordId = struct {
	9	const Keyword = struct {
12	10	bytes: []const u8,
13	11	id: Id,
14	12	};
15	13
16		const keywords = []KeywordId {
17		KeywordId{.bytes="align", .id = Id.Keyword_align},
18		KeywordId{.bytes="and", .id = Id.Keyword_and},
19		KeywordId{.bytes="asm", .id = Id.Keyword_asm},
20		KeywordId{.bytes="break", .id = Id.Keyword_break},
21		KeywordId{.bytes="catch", .id = Id.Keyword_catch},
22		KeywordId{.bytes="comptime", .id = Id.Keyword_comptime},
23		KeywordId{.bytes="const", .id = Id.Keyword_const},
24		KeywordId{.bytes="continue", .id = Id.Keyword_continue},
25		KeywordId{.bytes="defer", .id = Id.Keyword_defer},
26		KeywordId{.bytes="else", .id = Id.Keyword_else},
27		KeywordId{.bytes="enum", .id = Id.Keyword_enum},
28		KeywordId{.bytes="error", .id = Id.Keyword_error},
29		KeywordId{.bytes="export", .id = Id.Keyword_export},
30		KeywordId{.bytes="extern", .id = Id.Keyword_extern},
31		KeywordId{.bytes="false", .id = Id.Keyword_false},
32		KeywordId{.bytes="fn", .id = Id.Keyword_fn},
33		KeywordId{.bytes="for", .id = Id.Keyword_for},
34		KeywordId{.bytes="if", .id = Id.Keyword_if},
35		KeywordId{.bytes="inline", .id = Id.Keyword_inline},
36		KeywordId{.bytes="nakedcc", .id = Id.Keyword_nakedcc},
37		KeywordId{.bytes="noalias", .id = Id.Keyword_noalias},
38		KeywordId{.bytes="null", .id = Id.Keyword_null},
39		KeywordId{.bytes="or", .id = Id.Keyword_or},
40		KeywordId{.bytes="packed", .id = Id.Keyword_packed},
41		KeywordId{.bytes="pub", .id = Id.Keyword_pub},
42		KeywordId{.bytes="return", .id = Id.Keyword_return},
43		KeywordId{.bytes="section", .id = Id.Keyword_section},
44		KeywordId{.bytes="stdcallcc", .id = Id.Keyword_stdcallcc},
45		KeywordId{.bytes="struct", .id = Id.Keyword_struct},
46		KeywordId{.bytes="switch", .id = Id.Keyword_switch},
47		KeywordId{.bytes="test", .id = Id.Keyword_test},
48		KeywordId{.bytes="this", .id = Id.Keyword_this},
49		KeywordId{.bytes="true", .id = Id.Keyword_true},
50		KeywordId{.bytes="try", .id = Id.Keyword_try},
51		KeywordId{.bytes="undefined", .id = Id.Keyword_undefined},
52		KeywordId{.bytes="union", .id = Id.Keyword_union},
53		KeywordId{.bytes="unreachable", .id = Id.Keyword_unreachable},
54		KeywordId{.bytes="use", .id = Id.Keyword_use},
55		KeywordId{.bytes="var", .id = Id.Keyword_var},
56		KeywordId{.bytes="volatile", .id = Id.Keyword_volatile},
57		KeywordId{.bytes="while", .id = Id.Keyword_while},
	14	const keywords = []Keyword {
	15	Keyword{.bytes="align", .id = Id.Keyword_align},
	16	Keyword{.bytes="and", .id = Id.Keyword_and},
	17	Keyword{.bytes="asm", .id = Id.Keyword_asm},
	18	Keyword{.bytes="async", .id = Id.Keyword_async},
	19	Keyword{.bytes="await", .id = Id.Keyword_await},
	20	Keyword{.bytes="break", .id = Id.Keyword_break},
	21	Keyword{.bytes="catch", .id = Id.Keyword_catch},
	22	Keyword{.bytes="cancel", .id = Id.Keyword_cancel},
	23	Keyword{.bytes="comptime", .id = Id.Keyword_comptime},
	24	Keyword{.bytes="const", .id = Id.Keyword_const},
	25	Keyword{.bytes="continue", .id = Id.Keyword_continue},
	26	Keyword{.bytes="defer", .id = Id.Keyword_defer},
	27	Keyword{.bytes="else", .id = Id.Keyword_else},
	28	Keyword{.bytes="enum", .id = Id.Keyword_enum},
	29	Keyword{.bytes="errdefer", .id = Id.Keyword_errdefer},
	30	Keyword{.bytes="error", .id = Id.Keyword_error},
	31	Keyword{.bytes="export", .id = Id.Keyword_export},
	32	Keyword{.bytes="extern", .id = Id.Keyword_extern},
	33	Keyword{.bytes="false", .id = Id.Keyword_false},
	34	Keyword{.bytes="fn", .id = Id.Keyword_fn},
	35	Keyword{.bytes="for", .id = Id.Keyword_for},
	36	Keyword{.bytes="if", .id = Id.Keyword_if},
	37	Keyword{.bytes="inline", .id = Id.Keyword_inline},
	38	Keyword{.bytes="nakedcc", .id = Id.Keyword_nakedcc},
	39	Keyword{.bytes="noalias", .id = Id.Keyword_noalias},
	40	Keyword{.bytes="null", .id = Id.Keyword_null},
	41	Keyword{.bytes="or", .id = Id.Keyword_or},
	42	Keyword{.bytes="packed", .id = Id.Keyword_packed},
	43	Keyword{.bytes="promise", .id = Id.Keyword_promise},
	44	Keyword{.bytes="pub", .id = Id.Keyword_pub},
	45	Keyword{.bytes="resume", .id = Id.Keyword_resume},
	46	Keyword{.bytes="return", .id = Id.Keyword_return},
	47	Keyword{.bytes="section", .id = Id.Keyword_section},
	48	Keyword{.bytes="stdcallcc", .id = Id.Keyword_stdcallcc},
	49	Keyword{.bytes="struct", .id = Id.Keyword_struct},
	50	Keyword{.bytes="suspend", .id = Id.Keyword_suspend},
	51	Keyword{.bytes="switch", .id = Id.Keyword_switch},
	52	Keyword{.bytes="test", .id = Id.Keyword_test},
	53	Keyword{.bytes="this", .id = Id.Keyword_this},
	54	Keyword{.bytes="true", .id = Id.Keyword_true},
	55	Keyword{.bytes="try", .id = Id.Keyword_try},
	56	Keyword{.bytes="undefined", .id = Id.Keyword_undefined},
	57	Keyword{.bytes="union", .id = Id.Keyword_union},
	58	Keyword{.bytes="unreachable", .id = Id.Keyword_unreachable},
	59	Keyword{.bytes="use", .id = Id.Keyword_use},
	60	Keyword{.bytes="var", .id = Id.Keyword_var},
	61	Keyword{.bytes="volatile", .id = Id.Keyword_volatile},
	62	Keyword{.bytes="while", .id = Id.Keyword_while},
58	63	};
59	64
60	65	fn getKeyword(bytes: []const u8) ?Id {
...	...	@@ -72,7 +77,8 @@ pub const Token = struct {
72	77	Invalid,
73	78	Identifier,
74	79	StringLiteral: StrLitKind,
75		StringIdentifier,
	80	MultilineStringLiteralLine: StrLitKind,
	81	CharLiteral,
76	82	Eof,
77	83	Builtin,
78	84	Bang,
...	...	@@ -81,6 +87,7 @@ pub const Token = struct {
81	87	PipeEqual,
82	88	Equal,
83	89	EqualEqual,
	90	EqualAngleBracketRight,
84	91	BangEqual,
85	92	LParen,
86	93	RParen,
...	...	@@ -89,6 +96,8 @@ pub const Token = struct {
89	96	PercentEqual,
90	97	LBrace,
91	98	RBrace,
	99	LBracket,
	100	RBracket,
92	101	Period,
93	102	Ellipsis2,
94	103	Ellipsis3,
...	...	@@ -129,10 +138,14 @@ pub const Token = struct {
129	138	IntegerLiteral,
130	139	FloatLiteral,
131	140	LineComment,
	141	DocComment,
132	142	Keyword_align,
133	143	Keyword_and,
134	144	Keyword_asm,
	145	Keyword_async,
	146	Keyword_await,
135	147	Keyword_break,
	148	Keyword_cancel,
136	149	Keyword_catch,
137	150	Keyword_comptime,
138	151	Keyword_const,
...	...	@@ -140,6 +153,7 @@ pub const Token = struct {
140	153	Keyword_defer,
141	154	Keyword_else,
142	155	Keyword_enum,
	156	Keyword_errdefer,
143	157	Keyword_error,
144	158	Keyword_export,
145	159	Keyword_extern,
...	...	@@ -153,11 +167,14 @@ pub const Token = struct {
153	167	Keyword_null,
154	168	Keyword_or,
155	169	Keyword_packed,
	170	Keyword_promise,
156	171	Keyword_pub,
	172	Keyword_resume,
157	173	Keyword_return,
158	174	Keyword_section,
159	175	Keyword_stdcallcc,
160	176	Keyword_struct,
	177	Keyword_suspend,
161	178	Keyword_switch,
162	179	Keyword_test,
163	180	Keyword_this,
...	...	@@ -176,33 +193,8 @@ pub const Token = struct {
176	193	pub const Tokenizer = struct {
177	194	buffer: []const u8,
178	195	index: usize,
179		line: usize,
180		column: usize,
181	196	pending_invalid_token: ?Token,
182	197
183		pub const LineLocation = struct {
184		line_start: usize,
185		line_end: usize,
186		};
187
188		pub fn getTokenLocation(self: &Tokenizer, token: &const Token) LineLocation {
189		var loc = LineLocation {
190		.line_start = 0,
191		.line_end = self.buffer.len,
192		};
193		for (self.buffer) \|c, i\| {
194		if (i == token.start) {
195		loc.line_end = i;
196		while (loc.line_end < self.buffer.len and self.buffer[loc.line_end] != '\n') : (loc.line_end += 1) {}
197		return loc;
198		}
199		if (c == '\n') {
200		loc.line_start = i + 1;
201		}
202		}
203		return loc;
204		}
205
206	198	/// For debugging purposes
207	199	pub fn dump(self: &Tokenizer, token: &const Token) void {
208	200	std.debug.warn("{} \"{}\"\n", @tagName(token.id), self.buffer[token.start..token.end]);
...	...	@@ -212,8 +204,6 @@ pub const Tokenizer = struct {
212	204	return Tokenizer {
213	205	.buffer = buffer,
214	206	.index = 0,
215		.line = 0,
216		.column = 0,
217	207	.pending_invalid_token = null,
218	208	};
219	209	}
...	...	@@ -225,6 +215,12 @@ pub const Tokenizer = struct {
225	215	C,
226	216	StringLiteral,
227	217	StringLiteralBackslash,
	218	MultilineStringLiteralLine,
	219	MultilineStringLiteralLineBackslash,
	220	CharLiteral,
	221	CharLiteralBackslash,
	222	CharLiteralEnd,
	223	Backslash,
228	224	Equal,
229	225	Bang,
230	226	Pipe,
...	...	@@ -233,7 +229,10 @@ pub const Tokenizer = struct {
233	229	Asterisk,
234	230	AsteriskPercent,
235	231	Slash,
	232	LineCommentStart,
236	233	LineComment,
	234	DocCommentStart,
	235	DocComment,
237	236	Zero,
238	237	IntegerLiteral,
239	238	IntegerLiteralWithRadix,
...	...	@@ -261,26 +260,22 @@ pub const Tokenizer = struct {
261	260	self.pending_invalid_token = null;
262	261	return token;
263	262	}
	263	const start_index = self.index;
264	264	var state = State.Start;
265	265	var result = Token {
266	266	.id = Token.Id.Eof,
267	267	.start = self.index,
268	268	.end = undefined,
269		.line = self.line,
270		.column = self.column,
271	269	};
272		while (self.index < self.buffer.len) {
	270	while (self.index < self.buffer.len) : (self.index += 1) {
273	271	const c = self.buffer[self.index];
274	272	switch (state) {
275	273	State.Start => switch (c) {
276	274	' ' => {
277	275	result.start = self.index + 1;
278		result.column += 1;
279	276	},
280	277	'\n' => {
281	278	result.start = self.index + 1;
282		result.line += 1;
283		result.column = 0;
284	279	},
285	280	'c' => {
286	281	state = State.C;
...	...	@@ -290,6 +285,9 @@ pub const Tokenizer = struct {
290	285	state = State.StringLiteral;
291	286	result.id = Token.Id { .StringLiteral = Token.StrLitKind.Normal };
292	287	},
	288	'\'' => {
	289	state = State.CharLiteral;
	290	},
293	291	'a'...'b', 'd'...'z', 'A'...'Z', '_' => {
294	292	state = State.Identifier;
295	293	result.id = Token.Id.Identifier;
...	...	@@ -316,6 +314,16 @@ pub const Tokenizer = struct {
316	314	self.index += 1;
317	315	break;
318	316	},
	317	'[' => {
	318	result.id = Token.Id.LBracket;
	319	self.index += 1;
	320	break;
	321	},
	322	']' => {
	323	result.id = Token.Id.RBracket;
	324	self.index += 1;
	325	break;
	326	},
319	327	';' => {
320	328	result.id = Token.Id.Semicolon;
321	329	self.index += 1;
...	...	@@ -352,6 +360,10 @@ pub const Tokenizer = struct {
352	360	'^' => {
353	361	state = State.Caret;
354	362	},
	363	'\\' => {
	364	state = State.Backslash;
	365	result.id = Token.Id { .MultilineStringLiteralLine = Token.StrLitKind.Normal };
	366	},
355	367	'{' => {
356	368	result.id = Token.Id.LBrace;
357	369	self.index += 1;
...	...	@@ -396,7 +408,7 @@ pub const Tokenizer = struct {
396	408
397	409	State.SawAtSign => switch (c) {
398	410	'"' => {
399		result.id = Token.Id.StringIdentifier;
	411	result.id = Token.Id.Identifier;
400	412	state = State.StringLiteral;
401	413	},
402	414	else => {
...	...	@@ -532,8 +544,17 @@ pub const Tokenizer = struct {
532	544	'a'...'z', 'A'...'Z', '_', '0'...'9' => {},
533	545	else => break,
534	546	},
	547	State.Backslash => switch (c) {
	548	'\\' => {
	549	state = State.MultilineStringLiteralLine;
	550	},
	551	else => break,
	552	},
535	553	State.C => switch (c) {
536		'\\' => @panic("TODO"),
	554	'\\' => {
	555	state = State.Backslash;
	556	result.id = Token.Id { .MultilineStringLiteralLine = Token.StrLitKind.C };
	557	},
537	558	'"' => {
538	559	state = State.StringLiteral;
539	560	result.id = Token.Id { .StringLiteral = Token.StrLitKind.C };
...	...	@@ -562,6 +583,64 @@ pub const Tokenizer = struct {
562	583	},
563	584	},
564	585
	586	State.CharLiteral => switch (c) {
	587	'\\' => {
	588	state = State.CharLiteralBackslash;
	589	},
	590	'\'' => {
	591	result.id = Token.Id.Invalid;
	592	break;
	593	},
	594	else => {
	595	if (c < 0x20 or c == 0x7f) {
	596	result.id = Token.Id.Invalid;
	597	break;
	598	}
	599
	600	state = State.CharLiteralEnd;
	601	}
	602	},
	603
	604	State.CharLiteralBackslash => switch (c) {
	605	'\n' => {
	606	result.id = Token.Id.Invalid;
	607	break;
	608	},
	609	else => {
	610	state = State.CharLiteralEnd;
	611	},
	612	},
	613
	614	State.CharLiteralEnd => switch (c) {
	615	'\'' => {
	616	result.id = Token.Id.CharLiteral;
	617	self.index += 1;
	618	break;
	619	},
	620	else => {
	621	result.id = Token.Id.Invalid;
	622	break;
	623	},
	624	},
	625
	626	State.MultilineStringLiteralLine => switch (c) {
	627	'\\' => {
	628	state = State.MultilineStringLiteralLineBackslash;
	629	},
	630	'\n' => {
	631	self.index += 1;
	632	break;
	633	},
	634	else => self.checkLiteralCharacter(),
	635	},
	636
	637	State.MultilineStringLiteralLineBackslash => switch (c) {
	638	'\n' => break, // Look for this error later.
	639	else => {
	640	state = State.MultilineStringLiteralLine;
	641	},
	642	},
	643
565	644	State.Bang => switch (c) {
566	645	'=' => {
567	646	result.id = Token.Id.BangEqual;
...	...	@@ -597,6 +676,11 @@ pub const Tokenizer = struct {
597	676	self.index += 1;
598	677	break;
599	678	},
	679	'>' => {
	680	result.id = Token.Id.EqualAngleBracketRight;
	681	self.index += 1;
	682	break;
	683	},
600	684	else => {
601	685	result.id = Token.Id.Equal;
602	686	break;
...	...	@@ -713,8 +797,8 @@ pub const Tokenizer = struct {
713	797
714	798	State.Slash => switch (c) {
715	799	'/' => {
	800	state = State.LineCommentStart;
716	801	result.id = Token.Id.LineComment;
717		state = State.LineComment;
718	802	},
719	803	'=' => {
720	804	result.id = Token.Id.SlashEqual;
...	...	@@ -726,7 +810,31 @@ pub const Tokenizer = struct {
726	810	break;
727	811	},
728	812	},
729		State.LineComment => switch (c) {
	813	State.LineCommentStart => switch (c) {
	814	'/' => {
	815	state = State.DocCommentStart;
	816	},
	817	'\n' => break,
	818	else => {
	819	state = State.LineComment;
	820	self.checkLiteralCharacter();
	821	},
	822	},
	823	State.DocCommentStart => switch (c) {
	824	'/' => {
	825	state = State.LineComment;
	826	},
	827	'\n' => {
	828	result.id = Token.Id.DocComment;
	829	break;
	830	},
	831	else => {
	832	state = State.DocComment;
	833	result.id = Token.Id.DocComment;
	834	self.checkLiteralCharacter();
	835	},
	836	},
	837	State.LineComment, State.DocComment => switch (c) {
730	838	'\n' => break,
731	839	else => self.checkLiteralCharacter(),
732	840	},
...	...	@@ -773,10 +881,10 @@ pub const Tokenizer = struct {
773	881	},
774	882	},
775	883	State.FloatFraction => switch (c) {
776		'p', 'P' => {
	884	'p', 'P', 'e', 'E' => {
777	885	state = State.FloatExponentUnsigned;
778	886	},
779		'0'...'9', 'a'...'f', 'A'...'F' => {},
	887	'0'...'9' => {},
780	888	else => break,
781	889	},
782	890	State.FloatExponentUnsigned => switch (c) {
...	...	@@ -794,14 +902,6 @@ pub const Tokenizer = struct {
794	902	else => break,
795	903	},
796	904	}
797
798		self.index += 1;
799		if (c == '\n') {
800		self.line += 1;
801		self.column = 0;
802		} else {
803		self.column += 1;
804		}
805	905	} else if (self.index == self.buffer.len) {
806	906	switch (state) {
807	907	State.Start,
...	...	@@ -811,6 +911,7 @@ pub const Tokenizer = struct {
811	911	State.FloatFraction,
812	912	State.FloatExponentNumber,
813	913	State.StringLiteral, // find this error later
	914	State.MultilineStringLiteralLine,
814	915	State.Builtin => {},
815	916
816	917	State.Identifier => {
...	...	@@ -818,13 +919,22 @@ pub const Tokenizer = struct {
818	919	result.id = id;
819	920	}
820	921	},
	922	State.LineCommentStart,
821	923	State.LineComment => {
822		result.id = Token.Id.Eof;
	924	result.id = Token.Id.LineComment;
	925	},
	926	State.DocComment, State.DocCommentStart => {
	927	result.id = Token.Id.DocComment;
823	928	},
824	929
825	930	State.NumberDot,
826	931	State.FloatExponentUnsigned,
827	932	State.SawAtSign,
	933	State.Backslash,
	934	State.MultilineStringLiteralLineBackslash,
	935	State.CharLiteral,
	936	State.CharLiteralBackslash,
	937	State.CharLiteralEnd,
828	938	State.StringLiteralBackslash => {
829	939	result.id = Token.Id.Invalid;
830	940	},
...	...	@@ -894,6 +1004,7 @@ pub const Tokenizer = struct {
894	1004	},
895	1005	}
896	1006	}
	1007
897	1008	if (result.id == Token.Id.Eof) {
898	1009	if (self.pending_invalid_token) \|token\| {
899	1010	self.pending_invalid_token = null;
...	...	@@ -905,10 +1016,6 @@ pub const Tokenizer = struct {
905	1016	return result;
906	1017	}
907	1018
908		pub fn getTokenSlice(self: &const Tokenizer, token: &const Token) []const u8 {
909		return self.buffer[token.start..token.end];
910		}
911
912	1019	fn checkLiteralCharacter(self: &Tokenizer) void {
913	1020	if (self.pending_invalid_token != null) return;
914	1021	const invalid_length = self.getInvalidCharacterLength();
...	...	@@ -917,8 +1024,6 @@ pub const Tokenizer = struct {
917	1024	.id = Token.Id.Invalid,
918	1025	.start = self.index,
919	1026	.end = self.index + invalid_length,
920		.line = self.line,
921		.column = self.column,
922	1027	};
923	1028	}
924	1029
...	...	@@ -968,9 +1073,25 @@ test "tokenizer" {
968	1073	});
969	1074	}
970	1075
	1076	test "tokenizer - float literal" {
	1077	testTokenize("a = 4.94065645841246544177e-324;\n", []Token.Id {
	1078	Token.Id.Identifier,
	1079	Token.Id.Equal,
	1080	Token.Id.FloatLiteral,
	1081	Token.Id.Semicolon,
	1082	});
	1083	}
	1084
	1085	test "tokenizer - chars" {
	1086	testTokenize("'c'", []Token.Id {Token.Id.CharLiteral});
	1087	}
	1088
971	1089	test "tokenizer - invalid token characters" {
972	1090	testTokenize("#", []Token.Id{Token.Id.Invalid});
973	1091	testTokenize("`", []Token.Id{Token.Id.Invalid});
	1092	testTokenize("'c", []Token.Id {Token.Id.Invalid});
	1093	testTokenize("'", []Token.Id {Token.Id.Invalid});
	1094	testTokenize("''", []Token.Id {Token.Id.Invalid, Token.Id.Invalid});
974	1095	}
975	1096
976	1097	test "tokenizer - invalid literal/comment characters" {
...	...	@@ -979,41 +1100,77 @@ test "tokenizer - invalid literal/comment characters" {
979	1100	Token.Id.Invalid,
980	1101	});
981	1102	testTokenize("//\x00", []Token.Id {
	1103	Token.Id.LineComment,
982	1104	Token.Id.Invalid,
983	1105	});
984	1106	testTokenize("//\x1f", []Token.Id {
	1107	Token.Id.LineComment,
985	1108	Token.Id.Invalid,
986	1109	});
987	1110	testTokenize("//\x7f", []Token.Id {
	1111	Token.Id.LineComment,
988	1112	Token.Id.Invalid,
989	1113	});
990	1114	}
991	1115
992	1116	test "tokenizer - utf8" {
993		testTokenize("//\xc2\x80", []Token.Id{});
994		testTokenize("//\xf4\x8f\xbf\xbf", []Token.Id{});
	1117	testTokenize("//\xc2\x80", []Token.Id{Token.Id.LineComment});
	1118	testTokenize("//\xf4\x8f\xbf\xbf", []Token.Id{Token.Id.LineComment});
995	1119	}
996	1120
997	1121	test "tokenizer - invalid utf8" {
998		testTokenize("//\x80", []Token.Id{Token.Id.Invalid});
999		testTokenize("//\xbf", []Token.Id{Token.Id.Invalid});
1000		testTokenize("//\xf8", []Token.Id{Token.Id.Invalid});
1001		testTokenize("//\xff", []Token.Id{Token.Id.Invalid});
1002		testTokenize("//\xc2\xc0", []Token.Id{Token.Id.Invalid});
1003		testTokenize("//\xe0", []Token.Id{Token.Id.Invalid});
1004		testTokenize("//\xf0", []Token.Id{Token.Id.Invalid});
1005		testTokenize("//\xf0\x90\x80\xc0", []Token.Id{Token.Id.Invalid});
	1122	testTokenize("//\x80", []Token.Id{
	1123	Token.Id.LineComment,
	1124	Token.Id.Invalid,
	1125	});
	1126	testTokenize("//\xbf", []Token.Id{
	1127	Token.Id.LineComment,
	1128	Token.Id.Invalid,
	1129	});
	1130	testTokenize("//\xf8", []Token.Id{
	1131	Token.Id.LineComment,
	1132	Token.Id.Invalid,
	1133	});
	1134	testTokenize("//\xff", []Token.Id{
	1135	Token.Id.LineComment,
	1136	Token.Id.Invalid,
	1137	});
	1138	testTokenize("//\xc2\xc0", []Token.Id{
	1139	Token.Id.LineComment,
	1140	Token.Id.Invalid,
	1141	});
	1142	testTokenize("//\xe0", []Token.Id{
	1143	Token.Id.LineComment,
	1144	Token.Id.Invalid,
	1145	});
	1146	testTokenize("//\xf0", []Token.Id{
	1147	Token.Id.LineComment,
	1148	Token.Id.Invalid,
	1149	});
	1150	testTokenize("//\xf0\x90\x80\xc0", []Token.Id{
	1151	Token.Id.LineComment,
	1152	Token.Id.Invalid,
	1153	});
1006	1154	}
1007	1155
1008	1156	test "tokenizer - illegal unicode codepoints" {
1009	1157	// unicode newline characters.U+0085, U+2028, U+2029
1010		testTokenize("//\xc2\x84", []Token.Id{});
1011		testTokenize("//\xc2\x85", []Token.Id{Token.Id.Invalid});
1012		testTokenize("//\xc2\x86", []Token.Id{});
1013		testTokenize("//\xe2\x80\xa7", []Token.Id{});
1014		testTokenize("//\xe2\x80\xa8", []Token.Id{Token.Id.Invalid});
1015		testTokenize("//\xe2\x80\xa9", []Token.Id{Token.Id.Invalid});
1016		testTokenize("//\xe2\x80\xaa", []Token.Id{});
	1158	testTokenize("//\xc2\x84", []Token.Id{Token.Id.LineComment});
	1159	testTokenize("//\xc2\x85", []Token.Id{
	1160	Token.Id.LineComment,
	1161	Token.Id.Invalid,
	1162	});
	1163	testTokenize("//\xc2\x86", []Token.Id{Token.Id.LineComment});
	1164	testTokenize("//\xe2\x80\xa7", []Token.Id{Token.Id.LineComment});
	1165	testTokenize("//\xe2\x80\xa8", []Token.Id{
	1166	Token.Id.LineComment,
	1167	Token.Id.Invalid,
	1168	});
	1169	testTokenize("//\xe2\x80\xa9", []Token.Id{
	1170	Token.Id.LineComment,
	1171	Token.Id.Invalid,
	1172	});
	1173	testTokenize("//\xe2\x80\xaa", []Token.Id{Token.Id.LineComment});
1017	1174	}
1018	1175
1019	1176	test "tokenizer - string identifier and builtin fns" {
...	...	@@ -1022,7 +1179,7 @@ test "tokenizer - string identifier and builtin fns" {
1022	1179	,
1023	1180	[]Token.Id{
1024	1181	Token.Id.Keyword_const,
1025		Token.Id.StringIdentifier,
	1182	Token.Id.Identifier,
1026	1183	Token.Id.Equal,
1027	1184	Token.Id.Builtin,
1028	1185	Token.Id.LParen,
...	...	@@ -1040,11 +1197,36 @@ test "tokenizer - pipe and then invalid" {
1040	1197	});
1041	1198	}
1042	1199
	1200	test "tokenizer - line comment and doc comment" {
	1201	testTokenize("//", []Token.Id{Token.Id.LineComment});
	1202	testTokenize("// a / b", []Token.Id{Token.Id.LineComment});
	1203	testTokenize("// /", []Token.Id{Token.Id.LineComment});
	1204	testTokenize("/// a", []Token.Id{Token.Id.DocComment});
	1205	testTokenize("///", []Token.Id{Token.Id.DocComment});
	1206	testTokenize("////", []Token.Id{Token.Id.LineComment});
	1207	}
	1208
	1209	test "tokenizer - line comment followed by identifier" {
	1210	testTokenize(
	1211	\\ Unexpected,
	1212	\\ // another
	1213	\\ Another,
	1214	, []Token.Id{
	1215	Token.Id.Identifier,
	1216	Token.Id.Comma,
	1217	Token.Id.LineComment,
	1218	Token.Id.Identifier,
	1219	Token.Id.Comma,
	1220	});
	1221	}
	1222
1043	1223	fn testTokenize(source: []const u8, expected_tokens: []const Token.Id) void {
1044	1224	var tokenizer = Tokenizer.init(source);
1045	1225	for (expected_tokens) \|expected_token_id\| {
1046	1226	const token = tokenizer.next();
1047		std.debug.assert(@TagType(Token.Id)(token.id) == @TagType(Token.Id)(expected_token_id));
	1227	if (@TagType(Token.Id)(token.id) != @TagType(Token.Id)(expected_token_id)) {
	1228	std.debug.panic("expected {}, found {}\n", @tagName(@TagType(Token.Id)(expected_token_id)), @tagName(@TagType(Token.Id)(token.id)));
	1229	}
1048	1230	switch (expected_token_id) {
1049	1231	Token.Id.StringLiteral => \|expected_kind\| {
1050	1232	std.debug.assert(expected_kind == switch (token.id) { Token.Id.StringLiteral => \|kind\| kind, else => unreachable });

test/behavior.zig+3

...	...	@@ -12,6 +12,7 @@ comptime {
12	12	_ = @import("cases/bugs/655.zig");
13	13	_ = @import("cases/bugs/656.zig");
14	14	_ = @import("cases/bugs/828.zig");
	15	_ = @import("cases/bugs/920.zig");
15	16	_ = @import("cases/cast.zig");
16	17	_ = @import("cases/const_slice_child.zig");
17	18	_ = @import("cases/coroutines.zig");
...	...	@@ -35,6 +36,7 @@ comptime {
35	36	_ = @import("cases/pub_enum/index.zig");
36	37	_ = @import("cases/ref_var_in_if_after_if_2nd_switch_prong.zig");
37	38	_ = @import("cases/reflection.zig");
	39	_ = @import("cases/type_info.zig");
38	40	_ = @import("cases/sizeof_and_typeof.zig");
39	41	_ = @import("cases/slice.zig");
40	42	_ = @import("cases/struct.zig");
...	...	@@ -51,4 +53,5 @@ comptime {
51	53	_ = @import("cases/var_args.zig");
52	54	_ = @import("cases/void.zig");
53	55	_ = @import("cases/while.zig");
	56	_ = @import("cases/fn_in_struct_in_comptime.zig");
54	57	}

test/cases/atomics.zig+47-3

...	...	@@ -1,12 +1,24 @@
1		const assert = @import("std").debug.assert;
	1	const std = @import("std");
	2	const assert = std.debug.assert;
2	3	const builtin = @import("builtin");
3	4	const AtomicRmwOp = builtin.AtomicRmwOp;
4	5	const AtomicOrder = builtin.AtomicOrder;
5	6
6	7	test "cmpxchg" {
7	8	var x: i32 = 1234;
8		while (!@cmpxchg(&x, 1234, 5678, AtomicOrder.SeqCst, AtomicOrder.SeqCst)) {}
	9	if (@cmpxchgWeak(i32, &x, 99, 5678, AtomicOrder.SeqCst, AtomicOrder.SeqCst)) \|x1\| {
	10	assert(x1 == 1234);
	11	} else {
	12	@panic("cmpxchg should have failed");
	13	}
	14
	15	while (@cmpxchgWeak(i32, &x, 1234, 5678, AtomicOrder.SeqCst, AtomicOrder.SeqCst)) \|x1\| {
	16	assert(x1 == 1234);
	17	}
9	18	assert(x == 5678);
	19
	20	assert(@cmpxchgStrong(i32, &x, 5678, 42, AtomicOrder.SeqCst, AtomicOrder.SeqCst) == null);
	21	assert(x == 42);
10	22	}
11	23
12	24	test "fence" {
...	...	@@ -15,13 +27,45 @@ test "fence" {
15	27	x = 5678;
16	28	}
17	29
18		test "atomicrmw" {
	30	test "atomicrmw and atomicload" {
19	31	var data: u8 = 200;
20	32	testAtomicRmw(&data);
21	33	assert(data == 42);
	34	testAtomicLoad(&data);
22	35	}
23	36
24	37	fn testAtomicRmw(ptr: &u8) void {
25	38	const prev_value = @atomicRmw(u8, ptr, AtomicRmwOp.Xchg, 42, AtomicOrder.SeqCst);
26	39	assert(prev_value == 200);
	40	comptime {
	41	var x: i32 = 1234;
	42	const y: i32 = 12345;
	43	assert(@atomicLoad(i32, &x, AtomicOrder.SeqCst) == 1234);
	44	assert(@atomicLoad(i32, &y, AtomicOrder.SeqCst) == 12345);
	45	}
	46	}
	47
	48	fn testAtomicLoad(ptr: &u8) void {
	49	const x = @atomicLoad(u8, ptr, AtomicOrder.SeqCst);
	50	assert(x == 42);
	51	}
	52
	53	test "cmpxchg with ptr" {
	54	var data1: i32 = 1234;
	55	var data2: i32 = 5678;
	56	var data3: i32 = 9101;
	57	var x: &i32 = &data1;
	58	if (@cmpxchgWeak(&i32, &x, &data2, &data3, AtomicOrder.SeqCst, AtomicOrder.SeqCst)) \|x1\| {
	59	assert(x1 == &data1);
	60	} else {
	61	@panic("cmpxchg should have failed");
	62	}
	63
	64	while (@cmpxchgWeak(&i32, &x, &data1, &data3, AtomicOrder.SeqCst, AtomicOrder.SeqCst)) \|x1\| {
	65	assert(x1 == &data1);
	66	}
	67	assert(x == &data3);
	68
	69	assert(@cmpxchgStrong(&i32, &x, &data3, &data2, AtomicOrder.SeqCst, AtomicOrder.SeqCst) == null);
	70	assert(x == &data2);
27	71	}

test/cases/bugs/920.zig created+60

...	...	@@ -0,0 +1,60 @@
	1	const std = @import("std");
	2	const math = std.math;
	3	const Random = std.rand.Random;
	4
	5	const ZigTable = struct {
	6	r: f64,
	7	x: [257]f64,
	8	f: [257]f64,
	9
	10	pdf: fn(f64) f64,
	11	is_symmetric: bool,
	12	zero_case: fn(&Random, f64) f64,
	13	};
	14
	15	fn ZigTableGen(comptime is_symmetric: bool, comptime r: f64, comptime v: f64, comptime f: fn(f64) f64,
	16	comptime f_inv: fn(f64) f64, comptime zero_case: fn(&Random, f64) f64) ZigTable {
	17	var tables: ZigTable = undefined;
	18
	19	tables.is_symmetric = is_symmetric;
	20	tables.r = r;
	21	tables.pdf = f;
	22	tables.zero_case = zero_case;
	23
	24	tables.x[0] = v / f(r);
	25	tables.x[1] = r;
	26
	27	for (tables.x[2..256]) \|*entry, i\| {
	28	const last = tables.x[2 + i - 1];
	29	*entry = f_inv(v / last + f(last));
	30	}
	31	tables.x[256] = 0;
	32
	33	for (tables.f[0..]) \|*entry, i\| {
	34	*entry = f(tables.x[i]);
	35	}
	36
	37	return tables;
	38	}
	39
	40	const norm_r = 3.6541528853610088;
	41	const norm_v = 0.00492867323399;
	42
	43	fn norm_f(x: f64) f64 { return math.exp(-x * x / 2.0); }
	44	fn norm_f_inv(y: f64) f64 { return math.sqrt(-2.0 * math.ln(y)); }
	45	fn norm_zero_case(random: &Random, u: f64) f64 { return 0.0; }
	46
	47	const NormalDist = blk: {
	48	@setEvalBranchQuota(30000);
	49	break :blk ZigTableGen(true, norm_r, norm_v, norm_f, norm_f_inv, norm_zero_case);
	50	};
	51
	52	test "bug 920 fixed" {
	53	const NormalDist1 = blk: {
	54	break :blk ZigTableGen(true, norm_r, norm_v, norm_f, norm_f_inv, norm_zero_case);
	55	};
	56
	57	for (NormalDist1.f) \|_, i\| {
	58	std.debug.assert(NormalDist1.f[i] == NormalDist.f[i]);
	59	}
	60	}

test/cases/coroutines.zig+54

...	...	@@ -1,4 +1,5 @@
1	1	const std = @import("std");
	2	const builtin = @import("builtin");
2	3	const assert = std.debug.assert;
3	4
4	5	var x: i32 = 1;
...	...	@@ -189,3 +190,56 @@ async fn failing() !void {
189	190	suspend;
190	191	return error.Fail;
191	192	}
	193
	194	test "error return trace across suspend points - early return" {
	195	const p = nonFailing();
	196	resume p;
	197	const p2 = try async<std.debug.global_allocator> printTrace(p);
	198	cancel p2;
	199	}
	200
	201	test "error return trace across suspend points - async return" {
	202	const p = nonFailing();
	203	const p2 = try async<std.debug.global_allocator> printTrace(p);
	204	resume p;
	205	cancel p2;
	206	}
	207
	208	fn nonFailing() promise->error!void {
	209	return async<std.debug.global_allocator> suspendThenFail() catch unreachable;
	210	}
	211
	212	async fn suspendThenFail() error!void {
	213	suspend;
	214	return error.Fail;
	215	}
	216
	217	async fn printTrace(p: promise->error!void) void {
	218	(await p) catch \|e\| {
	219	std.debug.assert(e == error.Fail);
	220	if (@errorReturnTrace()) \|trace\| {
	221	assert(trace.index == 1);
	222	} else switch (builtin.mode) {
	223	builtin.Mode.Debug, builtin.Mode.ReleaseSafe => @panic("expected return trace"),
	224	builtin.Mode.ReleaseFast, builtin.Mode.ReleaseSmall => {},
	225	}
	226	};
	227	}
	228
	229	test "break from suspend" {
	230	var buf: [500]u8 = undefined;
	231	var a = &std.heap.FixedBufferAllocator.init(buf[0..]).allocator;
	232	var my_result: i32 = 1;
	233	const p = try async<a> testBreakFromSuspend(&my_result);
	234	cancel p;
	235	std.debug.assert(my_result == 2);
	236	}
	237
	238	async fn testBreakFromSuspend(my_result: &i32) void {
	239	s: suspend \|p\| {
	240	break :s;
	241	}
	242	*my_result += 1;
	243	suspend;
	244	*my_result += 1;
	245	}

test/cases/defer.zig+11

...	...	@@ -41,3 +41,14 @@ fn testBreakContInDefer(x: usize) void {
41	41	assert(i == 5);
42	42	}
43	43	}
	44
	45	test "defer and labeled break" {
	46	var i = usize(0);
	47
	48	blk: {
	49	defer i += 1;
	50	break :blk;
	51	}
	52
	53	assert(i == 1);
	54	}

test/cases/enum.zig+9

...	...	@@ -392,3 +392,12 @@ test "enum with 1 field but explicit tag type should still have the tag type" {
392	392	const Enum = enum(u8) { B = 2 };
393	393	comptime @import("std").debug.assert(@sizeOf(Enum) == @sizeOf(u8));
394	394	}
	395
	396	test "empty extern enum with members" {
	397	const E = extern enum {
	398	A,
	399	B,
	400	C,
	401	};
	402	assert(@sizeOf(E) == @sizeOf(c_int));
	403	}

test/cases/error.zig+66

...	...	@@ -175,3 +175,69 @@ fn baz_1() !i32 {
175	175	fn quux_1() !i32 {
176	176	return error.C;
177	177	}
	178
	179
	180	test "error: fn returning empty error set can be passed as fn returning any error" {
	181	entry();
	182	comptime entry();
	183	}
	184
	185	fn entry() void {
	186	foo2(bar2);
	187	}
	188
	189	fn foo2(f: fn()error!void) void {
	190	const x = f();
	191	}
	192
	193	fn bar2() (error{}!void) { }
	194
	195
	196	test "error: Zero sized error set returned with value payload crash" {
	197	_ = foo3(0);
	198	_ = comptime foo3(0);
	199	}
	200
	201	const Error = error{};
	202	fn foo3(b: usize) Error!usize {
	203	return b;
	204	}
	205
	206
	207	test "error: Infer error set from literals" {
	208	_ = nullLiteral("n") catch \|err\| handleErrors(err);
	209	_ = floatLiteral("n") catch \|err\| handleErrors(err);
	210	_ = intLiteral("n") catch \|err\| handleErrors(err);
	211	_ = comptime nullLiteral("n") catch \|err\| handleErrors(err);
	212	_ = comptime floatLiteral("n") catch \|err\| handleErrors(err);
	213	_ = comptime intLiteral("n") catch \|err\| handleErrors(err);
	214	}
	215
	216	fn handleErrors(err: var) noreturn {
	217	switch (err) {
	218	error.T => {}
	219	}
	220
	221	unreachable;
	222	}
	223
	224	fn nullLiteral(str: []const u8) !?i64 {
	225	if (str[0] == 'n')
	226	return null;
	227
	228	return error.T;
	229	}
	230
	231	fn floatLiteral(str: []const u8) !?f64 {
	232	if (str[0] == 'n')
	233	return 1.0;
	234
	235	return error.T;
	236	}
	237
	238	fn intLiteral(str: []const u8) !?i64 {
	239	if (str[0] == 'n')
	240	return 1;
	241
	242	return error.T;
	243	}

test/cases/eval.zig+23

...	...	@@ -513,3 +513,26 @@ test "array concat of slices gives slice" {
513	513	assert(std.mem.eql(u8, c, "aoeuasdf"));
514	514	}
515	515	}
	516
	517	test "comptime shlWithOverflow" {
	518	const ct_shifted: u64 = comptime amt: {
	519	var amt = u64(0);
	520	_ = @shlWithOverflow(u64, ~u64(0), 16, &amt);
	521	break :amt amt;
	522	};
	523
	524	const rt_shifted: u64 = amt: {
	525	var amt = u64(0);
	526	_ = @shlWithOverflow(u64, ~u64(0), 16, &amt);
	527	break :amt amt;
	528	};
	529
	530	assert(ct_shifted == rt_shifted);
	531	}
	532
	533	test "runtime 128 bit integer division" {
	534	var a: u128 = 152313999999999991610955792383;
	535	var b: u128 = 10000000000000000000;
	536	var c = a / b;
	537	assert(c == 15231399999);
	538	}

test/cases/fn.zig+17

...	...	@@ -94,3 +94,20 @@ test "inline function call" {
94	94	}
95	95
96	96	fn add(a: i32, b: i32) i32 { return a + b; }
	97
	98
	99	test "number literal as an argument" {
	100	numberLiteralArg(3);
	101	comptime numberLiteralArg(3);
	102	}
	103
	104	fn numberLiteralArg(a: var) void {
	105	assert(a == 3);
	106	}
	107
	108	test "assign inline fn to const variable" {
	109	const a = inlineFn;
	110	a();
	111	}
	112
	113	inline fn inlineFn() void { }

test/cases/fn_in_struct_in_comptime.zig created+17

...	...	@@ -0,0 +1,17 @@
	1	const assert = @import("std").debug.assert;
	2
	3	fn get_foo() fn(&u8)usize {
	4	comptime {
	5	return struct {
	6	fn func(ptr: &u8) usize {
	7	var u = @ptrToInt(ptr);
	8	return u;
	9	}
	10	}.func;
	11	}
	12	}
	13
	14	test "define a function in an anonymous struct in comptime" {
	15	const foo = get_foo();
	16	assert(foo(@intToPtr(&u8, 12345)) == 12345);
	17	}

test/cases/math.zig+41

...	...	@@ -349,6 +349,31 @@ test "big number shifting" {
349	349	}
350	350	}
351	351
	352	test "big number multi-limb shift and mask" {
	353	comptime {
	354	var a = 0xefffffffa0000001eeeeeeefaaaaaaab;
	355
	356	assert(u32(a & 0xffffffff) == 0xaaaaaaab);
	357	a >>= 32;
	358	assert(u32(a & 0xffffffff) == 0xeeeeeeef);
	359	a >>= 32;
	360	assert(u32(a & 0xffffffff) == 0xa0000001);
	361	a >>= 32;
	362	assert(u32(a & 0xffffffff) == 0xefffffff);
	363	a >>= 32;
	364
	365	assert(a == 0);
	366	}
	367	}
	368
	369	test "big number multi-limb partial shift right" {
	370	comptime {
	371	var a = 0x1ffffffffeeeeeeee;
	372	a >>= 16;
	373	assert(a == 0x1ffffffffeeee);
	374	}
	375	}
	376
352	377	test "xor" {
353	378	test_xor();
354	379	comptime test_xor();
...	...	@@ -402,3 +427,19 @@ test "comptime float rem int" {
402	427	assert(x == 1.0);
403	428	}
404	429	}
	430
	431	test "@sqrt" {
	432	testSqrt(f64, 12.0);
	433	comptime testSqrt(f64, 12.0);
	434	testSqrt(f32, 13.0);
	435	comptime testSqrt(f32, 13.0);
	436
	437	const x = 14.0;
	438	const y = x * x;
	439	const z = @sqrt(@typeOf(y), y);
	440	comptime assert(z == x);
	441	}
	442
	443	fn testSqrt(comptime T: type, x: T) void {
	444	assert(@sqrt(T, x * x) == x);
	445	}

test/cases/reflection.zig+24

...	...	@@ -1,5 +1,6 @@
1	1	const assert = @import("std").debug.assert;
2	2	const mem = @import("std").mem;
	3	const reflection = this;
3	4
4	5	test "reflection: array, pointer, nullable, error union type child" {
5	6	comptime {
...	...	@@ -56,7 +57,30 @@ test "reflection: enum member types and names" {
56	57
57	58	}
58	59
	60	test "reflection: @field" {
	61	var f = Foo {
	62	.one = 42,
	63	.two = true,
	64	.three = void{},
	65	};
	66
	67	assert(f.one == f.one);
	68	assert(@field(f, "o" ++ "ne") == f.one);
	69	assert(@field(f, "t" ++ "wo") == f.two);
	70	assert(@field(f, "th" ++ "ree") == f.three);
	71	assert(@field(Foo, "const" ++ "ant") == Foo.constant);
	72	assert(@field(Bar, "O" ++ "ne") == Bar.One);
	73	assert(@field(Bar, "T" ++ "wo") == Bar.Two);
	74	assert(@field(Bar, "Th" ++ "ree") == Bar.Three);
	75	assert(@field(Bar, "F" ++ "our") == Bar.Four);
	76	assert(@field(reflection, "dum" ++ "my")(true, 1, 2) == dummy(true, 1, 2));
	77	@field(f, "o" ++ "ne") = 4;
	78	assert(f.one == 4);
	79	}
	80
59	81	const Foo = struct {
	82	const constant = 52;
	83
60	84	one: i32,
61	85	two: bool,
62	86	three: void,

test/cases/type_info.zig created+200

...	...	@@ -0,0 +1,200 @@
	1	const assert = @import("std").debug.assert;
	2	const mem = @import("std").mem;
	3	const TypeInfo = @import("builtin").TypeInfo;
	4	const TypeId = @import("builtin").TypeId;
	5
	6	test "type info: tag type, void info" {
	7	comptime {
	8	assert(@TagType(TypeInfo) == TypeId);
	9	const void_info = @typeInfo(void);
	10	assert(TypeId(void_info) == TypeId.Void);
	11	assert(void_info.Void == {});
	12	}
	13	}
	14
	15	test "type info: integer, floating point type info" {
	16	comptime {
	17	const u8_info = @typeInfo(u8);
	18	assert(TypeId(u8_info) == TypeId.Int);
	19	assert(!u8_info.Int.is_signed);
	20	assert(u8_info.Int.bits == 8);
	21
	22	const f64_info = @typeInfo(f64);
	23	assert(TypeId(f64_info) == TypeId.Float);
	24	assert(f64_info.Float.bits == 64);
	25	}
	26	}
	27
	28	test "type info: pointer type info" {
	29	comptime {
	30	const u32_ptr_info = @typeInfo(&u32);
	31	assert(TypeId(u32_ptr_info) == TypeId.Pointer);
	32	assert(u32_ptr_info.Pointer.is_const == false);
	33	assert(u32_ptr_info.Pointer.is_volatile == false);
	34	assert(u32_ptr_info.Pointer.alignment == 4);
	35	assert(u32_ptr_info.Pointer.child == u32);
	36	}
	37	}
	38
	39	test "type info: slice type info" {
	40	comptime {
	41	const u32_slice_info = @typeInfo([]u32);
	42	assert(TypeId(u32_slice_info) == TypeId.Slice);
	43	assert(u32_slice_info.Slice.is_const == false);
	44	assert(u32_slice_info.Slice.is_volatile == false);
	45	assert(u32_slice_info.Slice.alignment == 4);
	46	assert(u32_slice_info.Slice.child == u32);
	47	}
	48	}
	49
	50	test "type info: array type info" {
	51	comptime {
	52	const arr_info = @typeInfo([42]bool);
	53	assert(TypeId(arr_info) == TypeId.Array);
	54	assert(arr_info.Array.len == 42);
	55	assert(arr_info.Array.child == bool);
	56	}
	57	}
	58
	59	test "type info: nullable type info" {
	60	comptime {
	61	const null_info = @typeInfo(?void);
	62	assert(TypeId(null_info) == TypeId.Nullable);
	63	assert(null_info.Nullable.child == void);
	64	}
	65	}
	66
	67	test "type info: promise info" {
	68	comptime {
	69	const null_promise_info = @typeInfo(promise);
	70	assert(TypeId(null_promise_info) == TypeId.Promise);
	71	assert(null_promise_info.Promise.child == @typeOf(undefined));
	72
	73	const promise_info = @typeInfo(promise->usize);
	74	assert(TypeId(promise_info) == TypeId.Promise);
	75	assert(promise_info.Promise.child == usize);
	76	}
	77
	78	}
	79
	80	test "type info: error set, error union info" {
	81	comptime {
	82	const TestErrorSet = error {
	83	First,
	84	Second,
	85	Third,
	86	};
	87
	88	const error_set_info = @typeInfo(TestErrorSet);
	89	assert(TypeId(error_set_info) == TypeId.ErrorSet);
	90	assert(error_set_info.ErrorSet.errors.len == 3);
	91	assert(mem.eql(u8, error_set_info.ErrorSet.errors[0].name, "First"));
	92	assert(error_set_info.ErrorSet.errors[2].value == usize(TestErrorSet.Third));
	93
	94	const error_union_info = @typeInfo(TestErrorSet!usize);
	95	assert(TypeId(error_union_info) == TypeId.ErrorUnion);
	96	assert(error_union_info.ErrorUnion.error_set == TestErrorSet);
	97	assert(error_union_info.ErrorUnion.payload == usize);
	98	}
	99	}
	100
	101	test "type info: enum info" {
	102	comptime {
	103	const Os = @import("builtin").Os;
	104
	105	const os_info = @typeInfo(Os);
	106	assert(TypeId(os_info) == TypeId.Enum);
	107	assert(os_info.Enum.layout == TypeInfo.ContainerLayout.Auto);
	108	assert(os_info.Enum.fields.len == 32);
	109	assert(mem.eql(u8, os_info.Enum.fields[1].name, "ananas"));
	110	assert(os_info.Enum.fields[10].value == 10);
	111	assert(os_info.Enum.tag_type == u5);
	112	assert(os_info.Enum.defs.len == 0);
	113	}
	114	}
	115
	116	test "type info: union info" {
	117	comptime {
	118	const typeinfo_info = @typeInfo(TypeInfo);
	119	assert(TypeId(typeinfo_info) == TypeId.Union);
	120	assert(typeinfo_info.Union.layout == TypeInfo.ContainerLayout.Auto);
	121	assert(typeinfo_info.Union.tag_type == TypeId);
	122	assert(typeinfo_info.Union.fields.len == 26);
	123	assert(typeinfo_info.Union.fields[4].enum_field != null);
	124	assert((??typeinfo_info.Union.fields[4].enum_field).value == 4);
	125	assert(typeinfo_info.Union.fields[4].field_type == @typeOf(@typeInfo(u8).Int));
	126	assert(typeinfo_info.Union.defs.len == 21);
	127
	128	const TestNoTagUnion = union {
	129	Foo: void,
	130	Bar: u32,
	131	};
	132
	133	const notag_union_info = @typeInfo(TestNoTagUnion);
	134	assert(TypeId(notag_union_info) == TypeId.Union);
	135	assert(notag_union_info.Union.tag_type == @typeOf(undefined));
	136	assert(notag_union_info.Union.layout == TypeInfo.ContainerLayout.Auto);
	137	assert(notag_union_info.Union.fields.len == 2);
	138	assert(notag_union_info.Union.fields[0].enum_field == null);
	139	assert(notag_union_info.Union.fields[1].field_type == u32);
	140
	141	const TestExternUnion = extern union {
	142	foo: &c_void,
	143	};
	144
	145	const extern_union_info = @typeInfo(TestExternUnion);
	146	assert(extern_union_info.Union.layout == TypeInfo.ContainerLayout.Extern);
	147	assert(extern_union_info.Union.tag_type == @typeOf(undefined));
	148	assert(extern_union_info.Union.fields[0].enum_field == null);
	149	assert(extern_union_info.Union.fields[0].field_type == &c_void);
	150	}
	151	}
	152
	153	test "type info: struct info" {
	154	comptime {
	155	const struct_info = @typeInfo(TestStruct);
	156	assert(TypeId(struct_info) == TypeId.Struct);
	157	assert(struct_info.Struct.layout == TypeInfo.ContainerLayout.Packed);
	158	assert(struct_info.Struct.fields.len == 3);
	159	assert(struct_info.Struct.fields[1].offset == null);
	160	assert(struct_info.Struct.fields[2].field_type == &TestStruct);
	161	assert(struct_info.Struct.defs.len == 2);
	162	assert(struct_info.Struct.defs[0].is_pub);
	163	assert(!struct_info.Struct.defs[0].data.Fn.is_extern);
	164	assert(struct_info.Struct.defs[0].data.Fn.lib_name == null);
	165	assert(struct_info.Struct.defs[0].data.Fn.return_type == void);
	166	assert(struct_info.Struct.defs[0].data.Fn.fn_type == fn(&const TestStruct)void);
	167	}
	168	}
	169
	170	const TestStruct = packed struct {
	171	const Self = this;
	172
	173	fieldA: usize,
	174	fieldB: void,
	175	fieldC: &Self,
	176
	177	pub fn foo(self: &const Self) void {}
	178	};
	179
	180	test "type info: function type info" {
	181	comptime {
	182	const fn_info = @typeInfo(@typeOf(foo));
	183	assert(TypeId(fn_info) == TypeId.Fn);
	184	assert(fn_info.Fn.calling_convention == TypeInfo.CallingConvention.Unspecified);
	185	assert(fn_info.Fn.is_generic);
	186	assert(fn_info.Fn.args.len == 2);
	187	assert(fn_info.Fn.is_var_args);
	188	assert(fn_info.Fn.return_type == @typeOf(undefined));
	189	assert(fn_info.Fn.async_allocator_type == @typeOf(undefined));
	190
	191	const test_instance: TestStruct = undefined;
	192	const bound_fn_info = @typeInfo(@typeOf(test_instance.foo));
	193	assert(TypeId(bound_fn_info) == TypeId.BoundFn);
	194	assert(bound_fn_info.BoundFn.args[0].arg_type == &const TestStruct);
	195	}
	196	}
	197
	198	fn foo(comptime a: usize, b: bool, args: ...) usize {
	199	return 0;
	200	}

test/cases/union.zig+22

...	...	@@ -45,6 +45,16 @@ test "basic unions" {
45	45	assert(foo.float == 12.34);
46	46	}
47	47
	48	test "comptime union field access" {
	49	comptime {
	50	var foo = Foo { .int = 0 };
	51	assert(foo.int == 0);
	52
	53	foo = Foo { .float = 42.42 };
	54	assert(foo.float == 42.42);
	55	}
	56	}
	57
48	58	test "init union with runtime value" {
49	59	var foo: Foo = undefined;
50	60
...	...	@@ -262,3 +272,15 @@ const PartialInstWithPayload = union(enum) {
262	272	Compiled: i32,
263	273	};
264	274
	275
	276	test "access a member of tagged union with conflicting enum tag name" {
	277	const Bar = union(enum) {
	278	A: A,
	279	B: B,
	280
	281	const A = u8;
	282	const B = void;
	283	};
	284
	285	comptime assert(Bar.A == u8);
	286	}

test/compile_errors.zig+86-9

...	...	@@ -1,6 +1,55 @@
1	1	const tests = @import("tests.zig");
2	2
3	3	pub fn addCases(cases: &tests.CompileErrorContext) void {
	4	cases.add("invalid deref on switch target",
	5	\\comptime {
	6	\\ var tile = Tile.Empty;
	7	\\ switch (*tile) {
	8	\\ Tile.Empty => {},
	9	\\ Tile.Filled => {},
	10	\\ }
	11	\\}
	12	\\const Tile = enum {
	13	\\ Empty,
	14	\\ Filled,
	15	\\};
	16	,
	17	".tmp_source.zig:3:13: error: invalid deref on switch target");
	18
	19	cases.add("invalid field access in comptime",
	20	\\comptime { var x = doesnt_exist.whatever; }
	21	,
	22	".tmp_source.zig:1:20: error: use of undeclared identifier 'doesnt_exist'");
	23
	24	cases.add("suspend inside suspend block",
	25	\\const std = @import("std");
	26	\\
	27	\\export fn entry() void {
	28	\\ var buf: [500]u8 = undefined;
	29	\\ var a = &std.heap.FixedBufferAllocator.init(buf[0..]).allocator;
	30	\\ const p = (async<a> foo()) catch unreachable;
	31	\\ cancel p;
	32	\\}
	33	\\
	34	\\async fn foo() void {
	35	\\ suspend \|p\| {
	36	\\ suspend \|p1\| {
	37	\\ }
	38	\\ }
	39	\\}
	40	,
	41	".tmp_source.zig:12:9: error: cannot suspend inside suspend block",
	42	".tmp_source.zig:11:5: note: other suspend block here");
	43
	44	cases.add("assign inline fn to non-comptime var",
	45	\\export fn entry() void {
	46	\\ var a = b;
	47	\\}
	48	\\inline fn b() void { }
	49	,
	50	".tmp_source.zig:2:5: error: functions marked inline must be stored in const or comptime var",
	51	".tmp_source.zig:4:8: note: declared here");
	52
4	53	cases.add("wrong type passed to @panic",
5	54	\\export fn entry() void {
6	55	\\ var e = error.Foo;
...	...	@@ -1385,17 +1434,17 @@ pub fn addCases(cases: &tests.CompileErrorContext) void {
1385	1434	\\const AtomicOrder = @import("builtin").AtomicOrder;
1386	1435	\\export fn f() void {
1387	1436	\\ var x: i32 = 1234;
1388		\\ while (!@cmpxchg(&x, 1234, 5678, AtomicOrder.Monotonic, AtomicOrder.SeqCst)) {}
	1437	\\ while (!@cmpxchgWeak(i32, &x, 1234, 5678, AtomicOrder.Monotonic, AtomicOrder.SeqCst)) {}
1389	1438	\\}
1390		, ".tmp_source.zig:4:72: error: failure atomic ordering must be no stricter than success");
	1439	, ".tmp_source.zig:4:81: error: failure atomic ordering must be no stricter than success");
1391	1440
1392	1441	cases.add("atomic orderings of cmpxchg - success Monotonic or stricter",
1393	1442	\\const AtomicOrder = @import("builtin").AtomicOrder;
1394	1443	\\export fn f() void {
1395	1444	\\ var x: i32 = 1234;
1396		\\ while (!@cmpxchg(&x, 1234, 5678, AtomicOrder.Unordered, AtomicOrder.Unordered)) {}
	1445	\\ while (!@cmpxchgWeak(i32, &x, 1234, 5678, AtomicOrder.Unordered, AtomicOrder.Unordered)) {}
1397	1446	\\}
1398		, ".tmp_source.zig:4:49: error: success atomic ordering must be Monotonic or stricter");
	1447	, ".tmp_source.zig:4:58: error: success atomic ordering must be Monotonic or stricter");
1399	1448
1400	1449	cases.add("negation overflow in function evaluation",
1401	1450	\\const y = neg(-128);
...	...	@@ -1723,7 +1772,7 @@ pub fn addCases(cases: &tests.CompileErrorContext) void {
1723	1772	\\}
1724	1773	\\
1725	1774	\\export fn entry() usize { return @sizeOf(@typeOf(bar)); }
1726		, ".tmp_source.zig:10:16: error: parameter of type '(integer literal)' requires comptime");
	1775	, ".tmp_source.zig:10:16: error: compiler bug: integer and float literals in var args function must be casted");
1727	1776
1728	1777	cases.add("assign too big number to u16",
1729	1778	\\export fn foo() void {
...	...	@@ -2451,11 +2500,11 @@ pub fn addCases(cases: &tests.CompileErrorContext) void {
2451	2500	\\const AtomicOrder = @import("builtin").AtomicOrder;
2452	2501	\\export fn entry() bool {
2453	2502	\\ var x: i32 align(1) = 1234;
2454		\\ while (!@cmpxchg(&x, 1234, 5678, AtomicOrder.SeqCst, AtomicOrder.SeqCst)) {}
	2503	\\ while (!@cmpxchgWeak(i32, &x, 1234, 5678, AtomicOrder.SeqCst, AtomicOrder.SeqCst)) {}
2455	2504	\\ return x == 5678;
2456	2505	\\}
2457	2506	,
2458		".tmp_source.zig:4:23: error: expected pointer alignment of at least 4, found 1");
	2507	".tmp_source.zig:4:32: error: expected type '&i32', found '&align(1) i32'");
2459	2508
2460	2509	cases.add("wrong size to an array literal",
2461	2510	\\comptime {
...	...	@@ -2525,10 +2574,10 @@ pub fn addCases(cases: &tests.CompileErrorContext) void {
2525	2574	cases.add("wrong types given to atomic order args in cmpxchg",
2526	2575	\\export fn entry() void {
2527	2576	\\ var x: i32 = 1234;
2528		\\ while (!@cmpxchg(&x, 1234, 5678, u32(1234), u32(1234))) {}
	2577	\\ while (!@cmpxchgWeak(i32, &x, 1234, 5678, u32(1234), u32(1234))) {}
2529	2578	\\}
2530	2579	,
2531		".tmp_source.zig:3:41: error: expected type 'AtomicOrder', found 'u32'");
	2580	".tmp_source.zig:3:50: error: expected type 'AtomicOrder', found 'u32'");
2532	2581
2533	2582	cases.add("wrong types given to @export",
2534	2583	\\extern fn entry() void { }
...	...	@@ -3160,4 +3209,32 @@ pub fn addCases(cases: &tests.CompileErrorContext) void {
3160	3209	\\}
3161	3210	,
3162	3211	".tmp_source.zig:5:42: error: zero-bit field 'val' in struct 'Empty' has no offset");
	3212
	3213	cases.add("invalid union field access in comptime",
	3214	\\const Foo = union {
	3215	\\ Bar: u8,
	3216	\\ Baz: void,
	3217	\\};
	3218	\\comptime {
	3219	\\ var foo = Foo {.Baz = {}};
	3220	\\ const bar_val = foo.Bar;
	3221	\\}
	3222	,
	3223	".tmp_source.zig:7:24: error: accessing union field 'Bar' while field 'Baz' is set");
	3224
	3225	cases.add("getting return type of generic function",
	3226	\\fn generic(a: var) void {}
	3227	\\comptime {
	3228	\\ _ = @typeOf(generic).ReturnType;
	3229	\\}
	3230	,
	3231	".tmp_source.zig:3:25: error: ReturnType has not been resolved because 'fn(var)var' is generic");
	3232
	3233	cases.add("getting @ArgType of generic function",
	3234	\\fn generic(a: var) void {}
	3235	\\comptime {
	3236	\\ _ = @ArgType(@typeOf(generic), 0);
	3237	\\}
	3238	,
	3239	".tmp_source.zig:3:36: error: @ArgType could not resolve the type of arg 0 because 'fn(var)var' is generic");
3163	3240	}

test/tests.zig+5-4

...	...	@@ -152,7 +152,7 @@ pub fn addPkgTests(b: &build.Builder, test_filter: ?[]const u8, root_src: []cons
152	152	const step = b.step(b.fmt("test-{}", name), desc);
153	153	for (test_targets) \|test_target\| {
154	154	const is_native = (test_target.os == builtin.os and test_target.arch == builtin.arch);
155		for ([]Mode{Mode.Debug, Mode.ReleaseSafe, Mode.ReleaseFast}) \|mode\| {
	155	for ([]Mode{Mode.Debug, Mode.ReleaseSafe, Mode.ReleaseFast, Mode.ReleaseSmall}) \|mode\| {
156	156	for ([]bool{false, true}) \|link_libc\| {
157	157	if (link_libc and !is_native) {
158	158	// don't assume we have a cross-compiling libc set up
...	...	@@ -451,7 +451,7 @@ pub const CompareOutputContext = struct {
451	451	self.step.dependOn(&run_and_cmp_output.step);
452	452	},
453	453	Special.None => {
454		for ([]Mode{Mode.Debug, Mode.ReleaseSafe, Mode.ReleaseFast}) \|mode\| {
	454	for ([]Mode{Mode.Debug, Mode.ReleaseSafe, Mode.ReleaseFast, Mode.ReleaseSmall}) \|mode\| {
455	455	const annotated_case_name = fmt.allocPrint(self.b.allocator, "{} {} ({})",
456	456	"compare-output", case.name, @tagName(mode)) catch unreachable;
457	457	if (self.test_filter) \|filter\| {
...	...	@@ -583,6 +583,7 @@ pub const CompileErrorContext = struct {
583	583	Mode.Debug => {},
584	584	Mode.ReleaseSafe => zig_args.append("--release-safe") catch unreachable,
585	585	Mode.ReleaseFast => zig_args.append("--release-fast") catch unreachable,
	586	Mode.ReleaseSmall => zig_args.append("--release-small") catch unreachable,
586	587	}
587	588
588	589	warn("Test {}/{} {}...", self.test_index+1, self.context.test_index, self.name);
...	...	@@ -704,7 +705,7 @@ pub const CompileErrorContext = struct {
704	705	pub fn addCase(self: &CompileErrorContext, case: &const TestCase) void {
705	706	const b = self.b;
706	707
707		for ([]Mode{Mode.Debug, Mode.ReleaseSafe, Mode.ReleaseFast}) \|mode\| {
	708	for ([]Mode{Mode.Debug, Mode.ReleaseFast}) \|mode\| {
708	709	const annotated_case_name = fmt.allocPrint(self.b.allocator, "compile-error {} ({})",
709	710	case.name, @tagName(mode)) catch unreachable;
710	711	if (self.test_filter) \|filter\| {
...	...	@@ -772,7 +773,7 @@ pub const BuildExamplesContext = struct {
772	773	pub fn addAllArgs(self: &BuildExamplesContext, root_src: []const u8, link_libc: bool) void {
773	774	const b = self.b;
774	775
775		for ([]Mode{Mode.Debug, Mode.ReleaseSafe, Mode.ReleaseFast}) \|mode\| {
	776	for ([]Mode{Mode.Debug, Mode.ReleaseSafe, Mode.ReleaseFast, Mode.ReleaseSmall}) \|mode\| {
776	777	const annotated_case_name = fmt.allocPrint(self.b.allocator, "build {} ({})",
777	778	root_src, @tagName(mode)) catch unreachable;
778	779	if (self.test_filter) \|filter\| {

test/translate_c.zig+43

...	...	@@ -1,6 +1,27 @@
1	1	const tests = @import("tests.zig");
2	2
3	3	pub fn addCases(cases: &tests.TranslateCContext) void {
	4	cases.add("double define struct",
	5	\\typedef struct Bar Bar;
	6	\\typedef struct Foo Foo;
	7	\\
	8	\\struct Foo {
	9	\\ Foo *a;
	10	\\};
	11	\\
	12	\\struct Bar {
	13	\\ Foo *a;
	14	\\};
	15	,
	16	\\pub const struct_Foo = extern struct {
	17	\\ a: ?&Foo,
	18	\\};
	19	\\pub const Foo = struct_Foo;
	20	\\pub const struct_Bar = extern struct {
	21	\\ a: ?&Foo,
	22	\\};
	23	);
	24
4	25	cases.addAllowWarnings("simple data types",
5	26	\\#include <stdint.h>
6	27	\\int foo(char a, unsigned char b, signed char c);
...	...	@@ -53,6 +74,28 @@ pub fn addCases(cases: &tests.TranslateCContext) void {
53	74	\\pub const Foo = enum_Foo;
54	75	);
55	76
	77	cases.add("enums",
	78	\\enum Foo {
	79	\\ FooA = 2,
	80	\\ FooB = 5,
	81	\\ Foo1,
	82	\\};
	83	,
	84	\\pub const enum_Foo = extern enum {
	85	\\ A = 2,
	86	\\ B = 5,
	87	\\ @"1" = 6,
	88	\\};
	89	,
	90	\\pub const FooA = enum_Foo.A;
	91	,
	92	\\pub const FooB = enum_Foo.B;
	93	,
	94	\\pub const Foo1 = enum_Foo.@"1";
	95	,
	96	\\pub const Foo = enum_Foo;
	97	);
	98
56	99	cases.add("restrict -> noalias",
57	100	\\void foo(void restrict bar, void restrict);
58	101	,