test "integer overflow at compile time" {
    const x: u8 = 255;
    _ = x + 1;
}

$ zig test 1-integer-overflow.zig
/home/ci/.cache/act/dc871dc959025405/hostexecutor/zig-code/features/1-integer-overflow.zig:3:11: error: overflow of integer type 'u8' with value '256'
    _ = x + 1;
        ~~^~~

test "integer overflow at runtime" {
    var x: u8 = 255;
    x += 1;
}

$ zig test 2-integer-overflow-runtime.zig
1/1 2-integer-overflow-runtime.test.integer overflow at runtime...thread 125288 panic: integer overflow
/home/ci/.cache/act/dc871dc959025405/hostexecutor/zig-code/features/2-integer-overflow-runtime.zig:3:7: 0x1238175 in test.integer overflow at runtime (2-integer-overflow-runtime.zig)
    x += 1;
      ^
/home/ci/deps/zig-x86_64-linux-0.16.0/lib/compiler/test_runner.zig:291:25: 0x11f35c6 in mainTerminal (test_runner.zig)
        if (test_fn.func()) |_| {
                        ^
/home/ci/deps/zig-x86_64-linux-0.16.0/lib/compiler/test_runner.zig:73:28: 0x11f2de2 in main (test_runner.zig)
        return mainTerminal(init);
                           ^
/home/ci/deps/zig-x86_64-linux-0.16.0/lib/std/start.zig:699:88: 0x11ef5f5 in callMain (std.zig)
    if (fn_info.params[0].type.? == std.process.Init.Minimal) return wrapMain(root.main(.{
                                                                                       ^
/home/ci/deps/zig-x86_64-linux-0.16.0/lib/std/start.zig:190:5: 0x11eefd1 in _start (std.zig)
    asm volatile (switch (native_arch) {
    ^
error: the following test command terminated with signal ABRT:
/home/ci/.cache/act/dc871dc959025405/hostexecutor/.zig-cache/o/7e2c031adc3bbd86c484a64a15390fa3/test --seed=0xb3fdb21

test "actually undefined behavior" {
    @setRuntimeSafety(false);
    var x: u8 = 255;
    x += 1; // XXX undefined behavior!
}

const std = @import("std");

pub fn main() void {
    std.debug.print("Hello, world!\n", .{});
}

$ zig build-exe 4-hello.zig
$ ./4-hello
Hello, world!

var y: i32 = add(10, x);
const x: i32 = add(12, 34);

test "global variables" {
    assert(x == 46);
    assert(y == 56);
}

fn add(a: i32, b: i32) i32 {
    return a + b;
}

const std = @import("std");
const assert = std.debug.assert;

$ zig test 5-global-variables.zig
1/1 5-global-variables.test.global variables...OK
All 1 tests passed.

test "null @intToPtr" {
    const foo: *i32 = @ptrFromInt(0x0);
    _ = foo;
}

$ zig test 6-null-to-ptr.zig
/home/ci/.cache/act/dc871dc959025405/hostexecutor/zig-code/features/6-null-to-ptr.zig:2:35: error: pointer type '*i32' does not allow address zero
    const foo: *i32 = @ptrFromInt(0x0);
                                  ^~~

const std = @import("std");
const assert = std.debug.assert;

test "null @intToPtr" {
    const ptr: ?*i32 = @ptrFromInt(0x0);
    assert(ptr == null);
}

$ zig test 7-optional-syntax.zig
1/1 7-optional-syntax.test.null @intToPtr...OK
All 1 tests passed.

// malloc prototype included for reference
extern fn malloc(size: size_t) ?*u8;

fn doAThing() ?*Foo {
    const ptr = malloc(1234) orelse return null;
    // ...
}

fn doAThing(optional_foo: ?*Foo) void {
    // do some stuff

    if (optional_foo) |foo| {
        doSomethingWithFoo(foo);
    }

    // do some stuff
}

const std = @import("std");

pub fn main() void {
    const msg = "hello this  is dog";
    var it = std.mem.tokenizeAny(u8, msg, " ");
    while (it.next()) |item| {
        std.debug.print("{s}\n", .{item});
    }
}

$ zig build-exe 10-optional-while.zig
$ ./10-optional-while
hello
this
is
dog

const Device = struct {
    name: []u8,

    fn create(allocator: *Allocator, id: u32) !Device {
        const device = try allocator.create(Device);
        errdefer allocator.destroy(device);

        device.name = try std.fmt.allocPrint(allocator, "Device(id={d})", id);
        errdefer allocator.free(device.name);

        if (id == 0) return error.ReservedDeviceId;

        return device;
    }
};

const std = @import("std");

pub fn main() void {
    _ = std.fs.cwd().openFile("does_not_exist/foo.txt", .{});
}

$ zig build-exe 12-errors-as-values.zig
/home/ci/.cache/act/dc871dc959025405/hostexecutor/zig-code/features/12-errors-as-values.zig:4:15: error: root source file struct 'fs' has no member named 'cwd'
    _ = std.fs.cwd().openFile("does_not_exist/foo.txt", .{});
        ~~~~~~^~~~
/home/ci/deps/zig-x86_64-linux-0.16.0/lib/std/fs.zig:1:1: note: struct declared here
//! File System.
^~~~~~~~~~~~~~~~
referenced by:
    callMain [inlined]: /home/ci/deps/zig-x86_64-linux-0.16.0/lib/std/start.zig:698:59
    callMainWithArgs [inlined]: /home/ci/deps/zig-x86_64-linux-0.16.0/lib/std/start.zig:638:20
    posixCallMainAndExit: /home/ci/deps/zig-x86_64-linux-0.16.0/lib/std/start.zig:590:38
    2 reference(s) hidden; use '-freference-trace=5' to see all references

const std = @import("std");
const Io = std.Io;

pub fn main(init: std.process.Init) void {
    const io = init.io;

    const file: Io.File = Io.Dir.cwd().openFile(io, "does_not_exist/foo.txt", .{}) catch |err| label: {
        std.debug.print("unable to open file: {}\n", .{err});
        break :label .stderr();
    };

    var file_writer = file.writer(io, &.{});
    file_writer.interface.writeAll("all your codebase are belong to us\n") catch return;
}

$ zig build-exe 13-errors-catch.zig
$ ./13-errors-catch
unable to open file: error.FileNotFound
all your codebase are belong to us

const std = @import("std");
const Io = std.Io;

pub fn main(init: std.process.Init) !void {
    const io = init.io;

    const file = try Io.Dir.cwd().openFile(io, "does_not_exist/foo.txt", .{});
    defer file.close(io);

    var file_writer = file.writer(io, &.{});
    try file_writer.interface.writeAll("all your codebase are belong to us\n");
}

$ zig build-exe 14-errors-try.zig
$ ./14-errors-try
error: FileNotFound
/home/ci/deps/zig-x86_64-linux-0.16.0/lib/std/Io/Threaded.zig:4866:35: 0x11905c0 in dirOpenFilePosix (std.zig)
                        .NOENT => return error.FileNotFound,
                                  ^
/home/ci/deps/zig-x86_64-linux-0.16.0/lib/std/Io/Dir.zig:578:5: 0x1033170 in openFile (std.zig)
    return io.vtable.dirOpenFile(io.userdata, dir, sub_path, options);
    ^
/home/ci/.cache/act/dc871dc959025405/hostexecutor/zig-code/features/14-errors-try.zig:7:18: 0x11d6b88 in main (14-errors-try.zig)
    const file = try Io.Dir.cwd().openFile(io, "does_not_exist/foo.txt", .{});
                 ^

const std = @import("std");

test "switch on error" {
    _ = parseInt("hi", 10) catch |err| switch (err) {};
}

fn parseInt(buf: []const u8, radix: u8) !u64 {
    var x: u64 = 0;

    for (buf) |c| {
        const digit = try charToDigit(c);

        if (digit >= radix) {
            return error.DigitExceedsRadix;
        }

        x = try std.math.mul(u64, x, radix);
        x = try std.math.add(u64, x, digit);
    }

    return x;
}

fn charToDigit(c: u8) !u8 {
    const value = switch (c) {
        '0'...'9' => c - '0',
        'A'...'Z' => c - 'A' + 10,
        'a'...'z' => c - 'a' + 10,
        else => return error.InvalidCharacter,
    };

    return value;
}

$ zig test 15-errors-switch.zig
/home/ci/.cache/act/dc871dc959025405/hostexecutor/zig-code/features/15-errors-switch.zig:4:40: error: switch must handle all possibilities
    _ = parseInt("hi", 10) catch |err| switch (err) {};
                                       ^~~~~~~~~~~~~~~
/home/ci/.cache/act/dc871dc959025405/hostexecutor/zig-code/features/15-errors-switch.zig:4:40: note: unhandled error value: 'error.Overflow'
/home/ci/.cache/act/dc871dc959025405/hostexecutor/zig-code/features/15-errors-switch.zig:4:40: note: unhandled error value: 'error.InvalidCharacter'
/home/ci/.cache/act/dc871dc959025405/hostexecutor/zig-code/features/15-errors-switch.zig:4:40: note: unhandled error value: 'error.DigitExceedsRadix'

const std = @import("std");
const Io = std.Io;

pub fn main(init: std.process.Init) void {
    const io = init.io;

    const file = Io.Dir.cwd().openFile(io, "does_not_exist/foo.txt", .{}) catch unreachable;
    defer file.close(io);

    var file_writer = file.writer(io, &.{});
    file_writer.interface.writeAll("all your codebase are belong to us\n") catch unreachable;
}

$ zig build-exe 16-unreachable.zig
$ ./16-unreachable
thread 125316 panic: attempt to unwrap error: FileNotFound
error return context:
/home/ci/deps/zig-x86_64-linux-0.16.0/lib/std/Io/Threaded.zig:4866:35: 0x11905c0 in dirOpenFilePosix (std.zig)
                        .NOENT => return error.FileNotFound,
                                  ^
/home/ci/deps/zig-x86_64-linux-0.16.0/lib/std/Io/Dir.zig:578:5: 0x1033170 in openFile (std.zig)
    return io.vtable.dirOpenFile(io.userdata, dir, sub_path, options);
    ^

stack trace:
/home/ci/.cache/act/dc871dc959025405/hostexecutor/zig-code/features/16-unreachable.zig:7:81: 0x11dc981 in main (16-unreachable.zig)
    const file = Io.Dir.cwd().openFile(io, "does_not_exist/foo.txt", .{}) catch unreachable;
                                                                                ^
/home/ci/deps/zig-x86_64-linux-0.16.0/lib/std/start.zig:737:30: 0x11d73e3 in callMain (std.zig)
    return wrapMain(root.main(.{
                             ^
/home/ci/deps/zig-x86_64-linux-0.16.0/lib/std/start.zig:190:5: 0x11d6a71 in _start (std.zig)
    asm volatile (switch (native_arch) {
    ^
(process terminated by signal)

const std = @import("std");

var address_buffer: [8]usize = undefined;

var trace1: std.debug.StackTrace = .{
    .return_addresses = address_buffer[0..4],
    .skipped = .none,
};

var trace2: std.debug.StackTrace = .{
    .return_addresses = address_buffer[4..],
    .skipped = .none,
};

pub fn main() void {
    foo();
    bar();

    std.debug.print("first one:\n", .{});
    std.debug.dumpStackTrace(&trace1);
    std.debug.print("\n\nsecond one:\n", .{});
    std.debug.dumpStackTrace(&trace2);
}

fn foo() void {
    trace1 = std.debug.captureCurrentStackTrace(.{}, address_buffer[0..4]);
}

fn bar() void {
    trace2 = std.debug.captureCurrentStackTrace(.{}, address_buffer[4..]);
}

$ zig build-exe 17-stack-traces.zig
$ ./17-stack-traces
first one:
/home/ci/.cache/act/dc871dc959025405/hostexecutor/zig-code/features/17-stack-traces.zig:26:48: 0x11d8c1f in foo (17-stack-traces.zig)
    trace1 = std.debug.captureCurrentStackTrace(.{}, address_buffer[0..4]);
                                               ^
/home/ci/.cache/act/dc871dc959025405/hostexecutor/zig-code/features/17-stack-traces.zig:16:8: 0x11d772c in main (17-stack-traces.zig)
    foo();
       ^
/home/ci/deps/zig-x86_64-linux-0.16.0/lib/std/start.zig:698:59: 0x11d7041 in callMain (std.zig)
    if (fn_info.params.len == 0) return wrapMain(root.main());
                                                          ^
/home/ci/deps/zig-x86_64-linux-0.16.0/lib/std/start.zig:190:5: 0x11d6a71 in _start (std.zig)
    asm volatile (switch (native_arch) {
    ^
(additional stack frames may have been skipped...)


second one:
/home/ci/.cache/act/dc871dc959025405/hostexecutor/zig-code/features/17-stack-traces.zig:30:48: 0x11d7d2f in bar (17-stack-traces.zig)
    trace2 = std.debug.captureCurrentStackTrace(.{}, address_buffer[4..]);
                                               ^
/home/ci/.cache/act/dc871dc959025405/hostexecutor/zig-code/features/17-stack-traces.zig:17:8: 0x11d7731 in main (17-stack-traces.zig)
    bar();
       ^
/home/ci/deps/zig-x86_64-linux-0.16.0/lib/std/start.zig:698:59: 0x11d7041 in callMain (std.zig)
    if (fn_info.params.len == 0) return wrapMain(root.main());
                                                          ^
/home/ci/deps/zig-x86_64-linux-0.16.0/lib/std/start.zig:190:5: 0x11d6a71 in _start (std.zig)
    asm volatile (switch (native_arch) {
    ^
(additional stack frames may have been skipped...)

const std = @import("std");
const assert = std.debug.assert;

test "types are values" {
    const T1 = u8;
    const T2 = bool;
    assert(T1 != T2);

    const x: T2 = true;
    assert(x);
}

$ zig test 18-types.zig
1/1 18-types.test.types are values...OK
All 1 tests passed.

const std = @import("std");

fn List(comptime T: type) type {
    return struct {
        items: []T,
        len: usize,
    };
}

pub fn main() void {
    var buffer: [10]i32 = undefined;
    var list: List(i32) = .{
        .items = &buffer,
        .len = 0,
    };
    list.items[0] = 1234;
    list.len += 1;

    std.debug.print("{d}\n", .{list.items.len});
}

$ zig build-exe 19-generics.zig
$ ./19-generics
10

const std = @import("std");

const Header = struct {
    magic: u32,
    name: []const u8,
};

pub fn main() void {
    printInfoAboutStruct(Header);
}

fn printInfoAboutStruct(comptime T: type) void {
    const info = @typeInfo(T);
    inline for (info.@"struct".fields) |field| {
        std.debug.print(
            "{s} has a field called {s} with type {s}\n",
            .{
                @typeName(T),
                field.name,
                @typeName(field.type),
            },
        );
    }
}

$ zig build-exe 20-reflection.zig
$ ./20-reflection
20-reflection.Header has a field called magic with type u32
20-reflection.Header has a field called name with type []const u8

const std = @import("std");
const assert = std.debug.assert;

fn fibonacci(x: u32) u32 {
    if (x <= 1) return x;
    return fibonacci(x - 1) + fibonacci(x - 2);
}

test "compile-time evaluation" {
    var array: [fibonacci(6)]i32 = undefined;

    @memset(&array, 42);

    comptime {
        assert(array.len == 12345);
    }
}

$ zig test 21-comptime.zig
/home/ci/deps/zig-x86_64-linux-0.16.0/lib/std/debug.zig:420:14: error: reached unreachable code
    if (!ok) unreachable; // assertion failure
             ^~~~~~~~~~~
/home/ci/.cache/act/dc871dc959025405/hostexecutor/zig-code/features/21-comptime.zig:15:15: note: called at comptime here
        assert(array.len == 12345);
        ~~~~~~^~~~~~~~~~~~~~~~~~~~

const c = @cImport(@cInclude("soundio/soundio.h"));
const std = @import("std");

fn sio_err(err: c_int) !void {
    switch (err) {
        c.SoundIoErrorNone => {},
        c.SoundIoErrorNoMem => return error.NoMem,
        c.SoundIoErrorInitAudioBackend => return error.InitAudioBackend,
        c.SoundIoErrorSystemResources => return error.SystemResources,
        c.SoundIoErrorOpeningDevice => return error.OpeningDevice,
        c.SoundIoErrorNoSuchDevice => return error.NoSuchDevice,
        c.SoundIoErrorInvalid => return error.Invalid,
        c.SoundIoErrorBackendUnavailable => return error.BackendUnavailable,
        c.SoundIoErrorStreaming => return error.Streaming,
        c.SoundIoErrorIncompatibleDevice => return error.IncompatibleDevice,
        c.SoundIoErrorNoSuchClient => return error.NoSuchClient,
        c.SoundIoErrorIncompatibleBackend => return error.IncompatibleBackend,
        c.SoundIoErrorBackendDisconnected => return error.BackendDisconnected,
        c.SoundIoErrorInterrupted => return error.Interrupted,
        c.SoundIoErrorUnderflow => return error.Underflow,
        c.SoundIoErrorEncodingString => return error.EncodingString,
        else => return error.Unknown,
    }
}

var seconds_offset: f32 = 0;

fn write_callback(
    maybe_outstream: ?[*]c.SoundIoOutStream,
    frame_count_min: c_int,
    frame_count_max: c_int,
) callconv(.C) void {
    _ = frame_count_min;
    const outstream: *c.SoundIoOutStream = &maybe_outstream.?[0];
    const layout = &outstream.layout;
    const float_sample_rate: f32 = @floatFromInt(outstream.sample_rate);
    const seconds_per_frame = 1.0 / float_sample_rate;
    var frames_left = frame_count_max;

    while (frames_left > 0) {
        var frame_count = frames_left;

        var areas: [*]c.SoundIoChannelArea = undefined;
        sio_err(c.soundio_outstream_begin_write(
            maybe_outstream,
            @ptrCast(&areas),
            &frame_count,
        )) catch |err| std.debug.panic("write failed: {s}", .{@errorName(err)});

        if (frame_count == 0) break;

        const pitch = 440.0;
        const radians_per_second = pitch * 2.0 * std.math.pi;
        var frame: c_int = 0;
        while (frame < frame_count) : (frame += 1) {
            const float_frame: f32 = @floatFromInt(frame);
            const sample = std.math.sin((seconds_offset + float_frame *
                seconds_per_frame) * radians_per_second);
            {
                var channel: usize = 0;
                while (channel < @as(usize, @intCast(layout.channel_count))) : (channel += 1) {
                    const channel_ptr = areas[channel].ptr;
                    const sample_ptr: *f32 = @ptrCast(@alignCast(&channel_ptr[@intCast(areas[channel].step * frame)]));
                    sample_ptr.* = sample;
                }
            }
        }
        const float_frame_count: f32 = @floatFromInt(frame_count);
        seconds_offset += seconds_per_frame * float_frame_count;

        sio_err(c.soundio_outstream_end_write(maybe_outstream)) catch |err| std.debug.panic("end write failed: {s}", .{@errorName(err)});

        frames_left -= frame_count;
    }
}

pub fn main() !void {
    const soundio = c.soundio_create();
    defer c.soundio_destroy(soundio);

    try sio_err(c.soundio_connect(soundio));

    c.soundio_flush_events(soundio);

    const default_output_index = c.soundio_default_output_device_index(soundio);
    if (default_output_index < 0) return error.NoOutputDeviceFound;

    const device = c.soundio_get_output_device(soundio, default_output_index) orelse return error.OutOfMemory;
    defer c.soundio_device_unref(device);

    std.debug.print("Output device: {s}\n", .{device.*.name});

    const outstream = c.soundio_outstream_create(device) orelse return error.OutOfMemory;
    defer c.soundio_outstream_destroy(outstream);

    outstream.*.format = c.SoundIoFormatFloat32NE;
    outstream.*.write_callback = write_callback;

    try sio_err(c.soundio_outstream_open(outstream));

    try sio_err(c.soundio_outstream_start(outstream));

    while (true) c.soundio_wait_events(soundio);
}

export fn add(a: i32, b: i32) i32 {
    return a + b;
}

const Builder = @import("std").build.Builder;

pub fn build(b: *Builder) void {
    const lib = b.addSharedLibrary("mathtest", "mathtest.zig", b.version(1, 0, 0));

    const exe = b.addExecutable("test", null);
    exe.addCSourceFile("test.c", &[_][]const u8{"-std=c99"});
    exe.linkLibrary(lib);
    exe.linkSystemLibrary("c");

    b.default_step.dependOn(&exe.step);

    const run_cmd = exe.run();

    const test_step = b.step("test", "Test the program");
    test_step.dependOn(&run_cmd.step);
}

const std = @import("std");

pub fn main() void {
    std.debug.print("Hello, world!\n", .{});
}

$ zig build-exe 4-hello.zig
$ ./4-hello
Hello, world!

const std = @import("std");

pub fn main() !void {
    std.debug.print("All your base are belong to us.\n", .{});
}

const Builder = @import("std").build.Builder;

pub fn build(b: *Builder) void {
    const mode = b.standardReleaseOptions();
    const exe = b.addExecutable("example", "src/main.zig");
    exe.setBuildMode(mode);

    const run_cmd = exe.run();

    const run_step = b.step("run", "Run the app");
    run_step.dependOn(&run_cmd.step);

    b.default_step.dependOn(&exe.step);
    b.installArtifact(exe);
}