Add various Zig code examples demonstrating switch statements, type casting, unions, and vector operations

- Implement basic and advanced switch statement examples in `switch.zig`
- Introduce type casting examples in `type-cast.zig`
- Create union type examples in `union.zig`
- Add unit tests for basic functions in `unit_test.zig`
- Implement unreachable code demonstration in `unreachable.zig`
- Showcase vector operations including basic usage, splatting, reduction, shuffling, and selection in `vector.zig`

Author: jinzhongjia

.github/workflows/build.yml

@@ -22,7 +22,7 @@ jobs:
     strategy:
       matrix:
         os: [ubuntu-latest, macos-latest, windows-latest]
-        version: [0.11.0, 0.12.1, 0.13.0, ""]
+        version: [0.11.0, 0.12.1, 0.13.0, 0.14.0, ""]
       fail-fast: false
     runs-on: ${{ matrix.os }}
     steps:

build/0.15.zig

@@ -44,20 +44,28 @@ pub fn build(b: *Build) void {
                 // build exe
                 const exe = b.addExecutable(.{
                     .name = output_name,
-                    .root_source_file = b.path(path),
-                    .target = target,
-                    .optimize = optimize,
+                    .root_module = b.addModule(output_name, .{
+                        .root_source_file = b.path(path),
+                        .target = target,
+                        .optimize = optimize,
+                    }),
                 });
                 exe.linkLibC();
 
                 // add to default install
                 b.installArtifact(exe);
 
                 // build test
+                const test_name = std.fmt.allocPrint(b.allocator, "{s}_test", .{output_name}) catch |err| {
+                    log.err("fmt test name failed, err is {}", .{err});
+                    std.process.exit(1);
+                };
                 const unit_tests = b.addTest(.{
-                    .root_source_file = b.path(path),
-                    .target = target,
-                    .optimize = optimize,
+                    .root_module = b.addModule(test_name, .{
+                        .root_source_file = b.path(path),
+                        .target = target,
+                        .optimize = optimize,
+                    }),
                 });
 
                 // add to default install

course/code/15

@@ -0,0 +1,136 @@
+pub fn main() !void {
+    CreateArray.main();
+    Matrix.main();
+    TerminatedArray.main();
+    Multiply.main();
+    Connect.main();
+    FuncInitArray.main();
+    ComptimeInitArray.main();
+}
+
+const CreateArray = struct {
+    // #region create_array
+    const print = @import("std").debug.print;
+
+    pub fn main() void {
+        const message = [5]u8{ 'h', 'e', 'l', 'l', 'o' };
+        // const message = [_]u8{ 'h', 'e', 'l', 'l', 'o' };
+        print("{s}\n", .{message}); // hello
+        print("{c}\n", .{message[0]}); // h
+    }
+    // #endregion create_array
+};
+
+const Deconstruct = struct {
+    // #region deconstruct
+    const print = @import("std").debug.print;
+
+    fn swizzleRgbaToBgra(rgba: [4]u8) [4]u8 {
+        // 解构
+        const r, const g, const b, const a = rgba;
+        return .{ b, g, r, a };
+    }
+
+    pub fn main() void {
+        const pos = [_]i32{ 1, 2 };
+        // 解构
+        const x, const y = pos;
+        print("x = {}, y = {}\n", .{ x, y });
+
+        const orange: [4]u8 = .{ 255, 165, 0, 255 };
+        print("{any}\n", .{swizzleRgbaToBgra(orange)});
+    }
+    // #endregion deconstruct
+};
+
+const Matrix = struct {
+    // #region matrix
+    const print = @import("std").debug.print;
+
+    pub fn main() void {
+        const matrix_4x4 = [4][4]f32{
+            [_]f32{ 1.0, 0.0, 0.0, 0.0 },
+            [_]f32{ 0.0, 1.0, 0.0, 1.0 },
+            [_]f32{ 0.0, 0.0, 1.0, 0.0 },
+            [_]f32{ 0.0, 0.0, 0.0, 1.0 },
+        };
+
+        for (matrix_4x4, 0..) |arr_val, arr_index| {
+            for (arr_val, 0..) |val, index| {
+                print("元素{}-{}是: {}\n", .{ arr_index, index, val });
+            }
+        }
+    }
+    // #endregion matrix
+};
+
+const TerminatedArray = struct {
+    // #region terminated_array
+    const print = @import("std").debug.print;
+
+    pub fn main() void {
+        const array = [_:0]u8{ 1, 2, 3, 4 };
+        print("数组长度为: {}\n", .{array.len}); // 4
+        print("数组最后一个元素值: {}\n", .{array[array.len - 1]}); // 4
+        print("哨兵值为: {}\n", .{array[array.len]}); // 0
+    }
+    // #endregion terminated_array
+};
+
+const Multiply = struct {
+    // #region multiply
+    const print = @import("std").debug.print;
+
+    pub fn main() void {
+        const small = [3]i8{ 1, 2, 3 };
+        const big: [9]i8 = small ** 3;
+        print("{any}\n", .{big}); // [9]i8{ 1, 2, 3, 1, 2, 3, 1, 2, 3 }
+    }
+    // #endregion multiply
+};
+
+const Connect = struct {
+    // #region connect
+    const print = @import("std").debug.print;
+
+    pub fn main() void {
+        const part_one = [_]i32{ 1, 2, 3, 4 };
+        const part_two = [_]i32{ 5, 6, 7, 8 };
+        const all_of_it = part_one ++ part_two; // [_]i32{ 1, 2, 3, 4, 5, 6, 7, 8 }
+
+        _ = all_of_it;
+    }
+    // #endregion connect
+};
+
+const FuncInitArray = struct {
+    // #region func_init_array
+    const print = @import("std").debug.print;
+
+    pub fn main() void {
+        const array = [_]i32{make(3)} ** 10;
+        print("{any}\n", .{array});
+    }
+
+    fn make(x: i32) i32 {
+        return x + 1;
+    }
+    // #endregion func_init_array
+};
+
+const ComptimeInitArray = struct {
+    // #region comptime_init_array
+    const print = @import("std").debug.print;
+
+    pub fn main() void {
+        const fancy_array = init: {
+            var initial_value: [10]usize = undefined;
+            for (&initial_value, 0..) |*pt, i| {
+                pt.* = i;
+            }
+            break :init initial_value;
+        };
+        print("{any}\n", .{fancy_array});
+    }
+    // #endregion comptime_init_array
+};

course/code/15/array.zig

@@ -0,0 +1,59 @@
+pub fn main() !void {}
+
+const external_assembly = struct {
+    // #region external_assembly
+    const std = @import("std");
+
+    comptime {
+        asm (
+            \\.global my_func;
+            \\.type my_func, @function;
+            \\my_func:
+            \\  lea (%rdi,%rsi,1),%eax
+            \\  retq
+        );
+    }
+
+    extern fn my_func(a: i32, b: i32) i32;
+
+    pub fn main() void {
+        std.debug.print("{}\n", .{my_func(2, 5)});
+    }
+    // #endregion external_assembly
+};
+
+const inline_assembly = struct {
+    // #region inline_assembly
+    pub fn main() noreturn {
+        const msg = "hello world\n";
+        _ = syscall3(SYS_write, STDOUT_FILENO, @intFromPtr(msg), msg.len);
+        _ = syscall1(SYS_exit, 0);
+        unreachable;
+    }
+
+    pub const SYS_write = 1;
+    pub const SYS_exit = 60;
+
+    pub const STDOUT_FILENO = 1;
+
+    pub fn syscall1(number: usize, arg1: usize) usize {
+        return asm volatile ("syscall"
+            : [ret] "={rax}" (-> usize),
+            : [number] "{rax}" (number),
+              [arg1] "{rdi}" (arg1),
+            : "rcx", "r11"
+        );
+    }
+
+    pub fn syscall3(number: usize, arg1: usize, arg2: usize, arg3: usize) usize {
+        return asm volatile ("syscall"
+            : [ret] "={rax}" (-> usize),
+            : [number] "{rax}" (number),
+              [arg1] "{rdi}" (arg1),
+              [arg2] "{rsi}" (arg2),
+              [arg3] "{rdx}" (arg3),
+            : "rcx", "r11"
+        );
+    }
+    // #endregion inline_assembly
+};

course/code/15/assembly.zig

@@ -0,0 +1,50 @@
+pub fn main() !void {
+    // #region atomic_value
+    const std = @import("std");
+    const RefCount = struct {
+        count: std.atomic.Value(usize),
+        dropFn: *const fn (*RefCount) void,
+
+        const RefCount = @This();
+
+        fn ref(rc: *RefCount) void {
+            // no synchronization necessary; just updating a counter.
+            _ = rc.count.fetchAdd(1, .monotonic);
+        }
+
+        fn unref(rc: *RefCount) void {
+            // release ensures code before unref() happens-before the
+            // count is decremented as dropFn could be called by then.
+            if (rc.count.fetchSub(1, .release) == 1) {
+                // seeing 1 in the counter means that other unref()s have happened,
+                // but it doesn't mean that uses before each unref() are visible.
+                // The load acquires the release-sequence created by previous unref()s
+                // in order to ensure visibility of uses before dropping.
+                _ = rc.count.load(.acquire);
+                (rc.dropFn)(rc);
+            }
+        }
+
+        fn noop(rc: *RefCount) void {
+            _ = rc;
+        }
+    };
+
+    var ref_count: RefCount = .{
+        .count = std.atomic.Value(usize).init(0),
+        .dropFn = RefCount.noop,
+    };
+    ref_count.ref();
+    ref_count.unref();
+    // #endregion atomic_value
+
+}
+
+test "spinLoopHint" {
+    const std = @import("std");
+    // #region spinLoopHint
+    for (0..10) |_| {
+        std.atomic.spinLoopHint();
+    }
+    // #endregion spinLoopHint
+}

course/code/15/atomic.zig

@@ -0,0 +1 @@
+该文件夹是构建系统的示例文件！

course/code/15/build_system/README.md

@@ -0,0 +1,22 @@
+const std = @import("std");
+
+pub fn build(b: *std.Build) void {
+    // 标准构建目标
+    const target = b.standardTargetOptions(.{});
+
+    // 标准构建模式
+    const optimize = b.standardOptimizeOption(.{});
+
+    // 添加一个二进制可执行程序构建
+    const exe = b.addExecutable(.{
+        .name = "zig",
+        .root_module = b.addModule("zig", .{
+            .root_source_file = b.path("src/main.zig"),
+            .target = target,
+            .optimize = optimize,
+        }),
+    });
+
+    // 添加到顶级 install step 中作为依赖
+    b.installArtifact(exe);
+}

course/code/15/build_system/basic/build.zig

@@ -0,0 +1,73 @@
+.{
+    // This is the default name used by packages depending on this one. For
+    // example, when a user runs `zig fetch --save <url>`, this field is used
+    // as the key in the `dependencies` table. Although the user can choose a
+    // different name, most users will stick with this provided value.
+    //
+    // It is redundant to include "zig" in this name because it is already
+    // within the Zig package namespace.
+    .name = .basic,
+
+    // This is a [Semantic Version](https://semver.org/).
+    // In a future version of Zig it will be used for package deduplication.
+    .version = "0.0.0",
+    .fingerprint = 0x907975534fe79435,
+
+    // This field is optional.
+    // This is currently advisory only; Zig does not yet do anything
+    // with this value.
+    //.minimum_zig_version = "0.11.0",
+
+    // This field is optional.
+    // Each dependency must either provide a `url` and `hash`, or a `path`.
+    // `zig build --fetch` can be used to fetch all dependencies of a package, recursively.
+    // Once all dependencies are fetched, `zig build` no longer requires
+    // internet connectivity.
+    .dependencies = .{
+        // See `zig fetch --save <url>` for a command-line interface for adding dependencies.
+        //.example = .{
+        //    // When updating this field to a new URL, be sure to delete the corresponding
+        //    // `hash`, otherwise you are communicating that you expect to find the old hash at
+        //    // the new URL.
+        //    .url = "https://example.com/foo.tar.gz",
+        //
+        //    // This is computed from the file contents of the directory of files that is
+        //    // obtained after fetching `url` and applying the inclusion rules given by
+        //    // `paths`.
+        //    //
+        //    // This field is the source of truth; packages do not come from a `url`; they
+        //    // come from a `hash`. `url` is just one of many possible mirrors for how to
+        //    // obtain a package matching this `hash`.
+        //    //
+        //    // Uses the [multihash](https://multiformats.io/multihash/) format.
+        //    .hash = "...",
+        //
+        //    // When this is provided, the package is found in a directory relative to the
+        //    // build root. In this case the package's hash is irrelevant and therefore not
+        //    // computed. This field and `url` are mutually exclusive.
+        //    .path = "foo",
+
+        //    // When this is set to `true`, a package is declared to be lazily
+        //    // fetched. This makes the dependency only get fetched if it is
+        //    // actually used.
+        //    .lazy = false,
+        //},
+    },
+
+    // Specifies the set of files and directories that are included in this package.
+    // Only files and directories listed here are included in the `hash` that
+    // is computed for this package. Only files listed here will remain on disk
+    // when using the zig package manager. As a rule of thumb, one should list
+    // files required for compilation plus any license(s).
+    // Paths are relative to the build root. Use the empty string (`""`) to refer to
+    // the build root itself.
+    // A directory listed here means that all files within, recursively, are included.
+    .paths = .{
+        "build.zig",
+        "build.zig.zon",
+        "src",
+        // For example...
+        //"LICENSE",
+        //"README.md",
+    },
+}