diff options
| -rw-r--r-- | dev-zig/zls/files/zls-0.10.0-add-builtin-data-for-new-zig-versions.patch | 3764 | ||||
| -rw-r--r-- | dev-zig/zls/zls-0.10.0-r1.ebuild | 141 |
2 files changed, 0 insertions, 3905 deletions
diff --git a/dev-zig/zls/files/zls-0.10.0-add-builtin-data-for-new-zig-versions.patch b/dev-zig/zls/files/zls-0.10.0-add-builtin-data-for-new-zig-versions.patch deleted file mode 100644 index 1810aef35..000000000 --- a/dev-zig/zls/files/zls-0.10.0-add-builtin-data-for-new-zig-versions.patch +++ /dev/null @@ -1,3764 +0,0 @@ -From 95f21d0d23fa67c3c1688cfbfa53905ab1f6a7d5 Mon Sep 17 00:00:00 2001 -From: BratishkaErik <25210740+BratishkaErik@users.noreply.github.com> -Date: Thu, 3 Nov 2022 02:24:51 +0600 -Subject: [PATCH] Add builtin data for 0.9.1 and 0.10.0 (#735) - -* Add builtin data for 0.9.1 - -* Add builtin data for 0.10.0 - -* Update builtin data for master ---- - src/data/0.10.0.zig | 1805 +++++++++++++++++++++++++++++++++++++++++++ - src/data/0.9.1.zig | 1777 ++++++++++++++++++++++++++++++++++++++++++ - src/data/data.zig | 2 + - src/data/master.zig | 40 +- - src/shared.zig | 2 + - 5 files changed, 3609 insertions(+), 17 deletions(-) - create mode 100644 src/data/0.10.0.zig - create mode 100644 src/data/0.9.1.zig - -diff --git a/src/data/0.10.0.zig b/src/data/0.10.0.zig -new file mode 100644 -index 00000000..82f7a25a ---- /dev/null -+++ b/src/data/0.10.0.zig -@@ -0,0 +1,1805 @@ -+const Builtin = struct { -+ name: []const u8, -+ signature: []const u8, -+ snippet: []const u8, -+ documentation: []const u8, -+ arguments: []const []const u8, -+}; -+ -+pub const builtins = [_]Builtin{ -+ .{ -+ .name = "@addrSpaceCast", -+ .signature = "@addrSpaceCast(comptime addrspace: std.builtin.AddressSpace, ptr: anytype) anytype", -+ .snippet = "@addrSpaceCast(${1:comptime addrspace: std.builtin.AddressSpace}, ${2:ptr: anytype})", -+ .documentation = -+ \\Converts a pointer from one address space to another. Depending on the current target and address spaces, this cast may be a no-op, a complex operation, or illegal. If the cast is legal, then the resulting pointer points to the same memory location as the pointer operand. It is always valid to cast a pointer between the same address spaces. -+ , -+ .arguments = &.{ -+ "comptime addrspace: std.builtin.AddressSpace", -+ "ptr: anytype", -+ }, -+ }, -+ .{ -+ .name = "@addWithOverflow", -+ .signature = "@addWithOverflow(comptime T: type, a: T, b: T, result: *T) bool", -+ .snippet = "@addWithOverflow(${1:comptime T: type}, ${2:a: T}, ${3:b: T}, ${4:result: *T})", -+ .documentation = -+ \\Performs `result.* = a + b`. If overflow or underflow occurs, stores the overflowed bits in `result` and returns `true`. If no overflow or underflow occurs, returns `false`. -+ , -+ .arguments = &.{ -+ "comptime T: type", -+ "a: T", -+ "b: T", -+ "result: *T", -+ }, -+ }, -+ .{ -+ .name = "@alignCast", -+ .signature = "@alignCast(comptime alignment: u29, ptr: anytype) anytype", -+ .snippet = "@alignCast(${1:comptime alignment: u29}, ${2:ptr: anytype})", -+ .documentation = -+ \\`ptr` can be `*T`, `?*T`, or `[]T`. It returns the same type as `ptr` except with the alignment adjusted to the new value. -+ \\ -+ \\A [pointer alignment safety check](https://ziglang.org/documentation/0.10.0/#Incorrect-Pointer-Alignment) is added to the generated code to make sure the pointer is aligned as promised. -+ , -+ .arguments = &.{ -+ "comptime alignment: u29", -+ "ptr: anytype", -+ }, -+ }, -+ .{ -+ .name = "@alignOf", -+ .signature = "@alignOf(comptime T: type) comptime_int", -+ .snippet = "@alignOf(${1:comptime T: type})", -+ .documentation = -+ \\This function returns the number of bytes that this type should be aligned to for the current target to match the C ABI. When the child type of a pointer has this alignment, the alignment can be omitted from the type. -+ \\ -+ \\```zig -+ \\const assert = @import("std").debug.assert; -+ \\comptime { -+ \\ assert(*u32 == *align(@alignOf(u32)) u32); -+ \\} -+ \\``` -+ \\ -+ \\The result is a target-specific compile time constant. It is guaranteed to be less than or equal to [@sizeOf(T)](https://ziglang.org/documentation/0.10.0/#@sizeOf). -+ , -+ .arguments = &.{ -+ "comptime T: type", -+ }, -+ }, -+ .{ -+ .name = "@as", -+ .signature = "@as(comptime T: type, expression) T", -+ .snippet = "@as(${1:comptime T: type}, ${2:expression})", -+ .documentation = -+ \\Performs [Type Coercion](https://ziglang.org/documentation/0.10.0/#Type-Coercion). This cast is allowed when the conversion is unambiguous and safe, and is the preferred way to convert between types, whenever possible. -+ , -+ .arguments = &.{ -+ "comptime T: type", -+ "expression", -+ }, -+ }, -+ .{ -+ .name = "@asyncCall", -+ .signature = "@asyncCall(frame_buffer: []align(@alignOf(@Frame(anyAsyncFunction))) u8, result_ptr, function_ptr, args: anytype) anyframe->T", -+ .snippet = "@asyncCall(${1:frame_buffer: []align(@alignOf(@Frame(anyAsyncFunction))) u8}, ${2:result_ptr}, ${3:function_ptr}, ${4:args: anytype})", -+ .documentation = -+ \\`@asyncCall` performs an `async` call on a function pointer, which may or may not be an [async function](https://ziglang.org/documentation/0.10.0/#Async-Functions). -+ \\ -+ \\The provided `frame_buffer` must be large enough to fit the entire function frame. This size can be determined with [@frameSize](https://ziglang.org/documentation/0.10.0/#frameSize). To provide a too-small buffer invokes safety-checked [Undefined Behavior](https://ziglang.org/documentation/0.10.0/#Undefined-Behavior). -+ \\ -+ \\`result_ptr` is optional ([null](https://ziglang.org/documentation/0.10.0/#null) may be provided). If provided, the function call will write its result directly to the result pointer, which will be available to read after [await](https://ziglang.org/documentation/0.10.0/#Async-and-Await) completes. Any result location provided to `await` will copy the result from `result_ptr`.</p> {#code_begin|test|async_struct_field_fn_pointer#} {#backend_stage1#} const std = @import("std"); const expect = std.testing.expect; test "async fn pointer in a struct field" { var data: i32 = 1; const Foo = struct { bar: fn (*i32) callconv(.Async) void, }; var foo = Foo{ .bar = func }; var bytes: [64]u8 align(@alignOf(@Frame(func))) = undefined; const f = @asyncCall(&bytes, {}, foo.bar, .{&data}); try expect(data == 2); resume f; try expect(data == 4); } fn func(y: *i32) void { defer y.* += 2; y.* += 1; suspend {} }` -+ , -+ .arguments = &.{ -+ "frame_buffer: []align(@alignOf(@Frame(anyAsyncFunction))) u8", -+ "result_ptr", -+ "function_ptr", -+ "args: anytype", -+ }, -+ }, -+ .{ -+ .name = "@atomicLoad", -+ .signature = "@atomicLoad(comptime T: type, ptr: *const T, comptime ordering: builtin.AtomicOrder) T", -+ .snippet = "@atomicLoad(${1:comptime T: type}, ${2:ptr: *const T}, ${3:comptime ordering: builtin.AtomicOrder})", -+ .documentation = -+ \\This builtin function atomically dereferences a pointer and returns the value. -+ \\ -+ \\`T` must be a pointer, a `bool`, a float, an integer or an enum. -+ , -+ .arguments = &.{ -+ "comptime T: type", -+ "ptr: *const T", -+ "comptime ordering: builtin.AtomicOrder", -+ }, -+ }, -+ .{ -+ .name = "@atomicRmw", -+ .signature = "@atomicRmw(comptime T: type, ptr: *T, comptime op: builtin.AtomicRmwOp, operand: T, comptime ordering: builtin.AtomicOrder) T", -+ .snippet = "@atomicRmw(${1:comptime T: type}, ${2:ptr: *T}, ${3:comptime op: builtin.AtomicRmwOp}, ${4:operand: T}, ${5:comptime ordering: builtin.AtomicOrder})", -+ .documentation = -+ \\This builtin function atomically modifies memory and then returns the previous value. -+ \\ -+ \\`T` must be a pointer, a `bool`, a float, an integer or an enum. -+ \\ -+ \\Supported operations: -+ \\ - `.Xchg` - stores the operand unmodified. Supports enums, integers and floats. -+ \\ - `.Add` - for integers, twos complement wraparound addition. Also supports [Floats](https://ziglang.org/documentation/0.10.0/#Floats). -+ \\ - `.Sub` - for integers, twos complement wraparound subtraction. Also supports [Floats](https://ziglang.org/documentation/0.10.0/#Floats). -+ \\ - `.And` - bitwise and -+ \\ - `.Nand` - bitwise nand -+ \\ - `.Or` - bitwise or -+ \\ - `.Xor` - bitwise xor -+ \\ - `.Max` - stores the operand if it is larger. Supports integers and floats. -+ \\ - `.Min` - stores the operand if it is smaller. Supports integers and floats. -+ , -+ .arguments = &.{ -+ "comptime T: type", -+ "ptr: *T", -+ "comptime op: builtin.AtomicRmwOp", -+ "operand: T", -+ "comptime ordering: builtin.AtomicOrder", -+ }, -+ }, -+ .{ -+ .name = "@atomicStore", -+ .signature = "@atomicStore(comptime T: type, ptr: *T, value: T, comptime ordering: builtin.AtomicOrder) void", -+ .snippet = "@atomicStore(${1:comptime T: type}, ${2:ptr: *T}, ${3:value: T}, ${4:comptime ordering: builtin.AtomicOrder})", -+ .documentation = -+ \\This builtin function atomically stores a value. -+ \\ -+ \\`T` must be a pointer, a `bool`, a float, an integer or an enum. -+ , -+ .arguments = &.{ -+ "comptime T: type", -+ "ptr: *T", -+ "value: T", -+ "comptime ordering: builtin.AtomicOrder", -+ }, -+ }, -+ .{ -+ .name = "@bitCast", -+ .signature = "@bitCast(comptime DestType: type, value: anytype) DestType", -+ .snippet = "@bitCast(${1:comptime DestType: type}, ${2:value: anytype})", -+ .documentation = -+ \\Converts a value of one type to another type. -+ \\ -+ \\Asserts that `@sizeOf(@TypeOf(value)) == @sizeOf(DestType)`. -+ \\ -+ \\Asserts that `@typeInfo(DestType) != .Pointer`. Use `@ptrCast` or `@intToPtr` if you need this. -+ \\ -+ \\Can be used for these things for example: -+ \\ - Convert `f32` to `u32` bits -+ \\ - Convert `i32` to `u32` preserving twos complement -+ \\ -+ \\Works at compile-time if `value` is known at compile time. It's a compile error to bitcast a value of undefined layout; this means that, besides the restriction from types which possess dedicated casting builtins (enums, pointers, error sets), bare structs, error unions, slices, optionals, and any other type without a well-defined memory layout, also cannot be used in this operation. -+ , -+ .arguments = &.{ -+ "comptime DestType: type", -+ "value: anytype", -+ }, -+ }, -+ .{ -+ .name = "@bitOffsetOf", -+ .signature = "@bitOffsetOf(comptime T: type, comptime field_name: []const u8) comptime_int", -+ .snippet = "@bitOffsetOf(${1:comptime T: type}, ${2:comptime field_name: []const u8})", -+ .documentation = -+ \\Returns the bit offset of a field relative to its containing struct. -+ \\ -+ \\For non [packed structs](https://ziglang.org/documentation/0.10.0/#packed-struct), this will always be divisible by `8`. For packed structs, non-byte-aligned fields will share a byte offset, but they will have different bit offsets. -+ , -+ .arguments = &.{ -+ "comptime T: type", -+ "comptime field_name: []const u8", -+ }, -+ }, -+ .{ -+ .name = "@boolToInt", -+ .signature = "@boolToInt(value: bool) u1", -+ .snippet = "@boolToInt(${1:value: bool})", -+ .documentation = -+ \\Converts `true` to `@as(u1, 1)` and `false` to `@as(u1, 0)`. -+ \\ -+ \\If the value is known at compile-time, the return type is `comptime_int` instead of `u1`. -+ , -+ .arguments = &.{ -+ "value: bool", -+ }, -+ }, -+ .{ -+ .name = "@bitSizeOf", -+ .signature = "@bitSizeOf(comptime T: type) comptime_int", -+ .snippet = "@bitSizeOf(${1:comptime T: type})", -+ .documentation = -+ \\This function returns the number of bits it takes to store `T` in memory if the type were a field in a packed struct/union. The result is a target-specific compile time constant. -+ \\ -+ \\This function measures the size at runtime. For types that are disallowed at runtime, such as `comptime_int` and `type`, the result is `0`. -+ , -+ .arguments = &.{ -+ "comptime T: type", -+ }, -+ }, -+ .{ -+ .name = "@breakpoint", -+ .signature = "@breakpoint()", -+ .snippet = "@breakpoint()", -+ .documentation = -+ \\This function inserts a platform-specific debug trap instruction which causes debuggers to break there. -+ \\ -+ \\This function is only valid within function scope. -+ , -+ .arguments = &.{}, -+ }, -+ .{ -+ .name = "@mulAdd", -+ .signature = "@mulAdd(comptime T: type, a: T, b: T, c: T) T", -+ .snippet = "@mulAdd(${1:comptime T: type}, ${2:a: T}, ${3:b: T}, ${4:c: T})", -+ .documentation = -+ \\Fused multiply-add, similar to `(a * b) + c`, except only rounds once, and is thus more accurate. -+ \\ -+ \\Supports [Floats](https://ziglang.org/documentation/0.10.0/#Floats) and [Vectors](https://ziglang.org/documentation/0.10.0/#Vectors) of floats. -+ , -+ .arguments = &.{ -+ "comptime T: type", -+ "a: T", -+ "b: T", -+ "c: T", -+ }, -+ }, -+ .{ -+ .name = "@byteSwap", -+ .signature = "@byteSwap(operand: anytype) T", -+ .snippet = "@byteSwap(${1:operand: anytype})", -+ .documentation = -+ \\`@TypeOf(operand)` must be an integer type or an integer vector type with bit count evenly divisible by 8. -+ \\ -+ \\`operand` may be an [integer](https://ziglang.org/documentation/0.10.0/#Integers) or [vector](https://ziglang.org/documentation/0.10.0/#Vectors). -+ \\ -+ \\Swaps the byte order of the integer. This converts a big endian integer to a little endian integer, and converts a little endian integer to a big endian integer. -+ \\ -+ \\Note that for the purposes of memory layout with respect to endianness, the integer type should be related to the number of bytes reported by [@sizeOf](https://ziglang.org/documentation/0.10.0/#sizeOf) bytes. This is demonstrated with `u24`. `@sizeOf(u24) == 4`, which means that a `u24` stored in memory takes 4 bytes, and those 4 bytes are what are swapped on a little vs big endian system. On the other hand, if `T` is specified to be `u24`, then only 3 bytes are reversed. -+ , -+ .arguments = &.{ -+ "operand: anytype", -+ }, -+ }, -+ .{ -+ .name = "@bitReverse", -+ .signature = "@bitReverse(integer: anytype) T", -+ .snippet = "@bitReverse(${1:integer: anytype})", -+ .documentation = -+ \\`@TypeOf(anytype)` accepts any integer type or integer vector type. -+ \\ -+ \\Reverses the bitpattern of an integer value, including the sign bit if applicable. -+ \\ -+ \\For example 0b10110110 (`u8 = 182`, `i8 = -74`) becomes 0b01101101 (`u8 = 109`, `i8 = 109`). -+ , -+ .arguments = &.{ -+ "integer: anytype", -+ }, -+ }, -+ .{ -+ .name = "@offsetOf", -+ .signature = "@offsetOf(comptime T: type, comptime field_name: []const u8) comptime_int", -+ .snippet = "@offsetOf(${1:comptime T: type}, ${2:comptime field_name: []const u8})", -+ .documentation = -+ \\Returns the byte offset of a field relative to its containing struct. -+ , -+ .arguments = &.{ -+ "comptime T: type", -+ "comptime field_name: []const u8", -+ }, -+ }, -+ .{ -+ .name = "@call", -+ .signature = "@call(options: std.builtin.CallOptions, function: anytype, args: anytype) anytype", -+ .snippet = "@call(${1:options: std.builtin.CallOptions}, ${2:function: anytype}, ${3:args: anytype})", -+ .documentation = -+ \\Calls a function, in the same way that invoking an expression with parentheses does: -+ \\ -+ \\```zig -+ \\const expect = @import("std").testing.expect; -+ \\ -+ \\test "noinline function call" { -+ \\ try expect(@call(.{}, add, .{3, 9}) == 12); -+ \\} -+ \\ -+ \\fn add(a: i32, b: i32) i32 { -+ \\ return a + b; -+ \\} -+ \\``` -+ \\ -+ \\`@call` allows more flexibility than normal function call syntax does. The `CallOptions` struct is reproduced here:</p> {#syntax_block|zig|builtin.CallOptions struct#} pub const CallOptions = struct { modifier: Modifier = .auto, /// Only valid when `Modifier` is `Modifier.async_kw`. stack: ?[]align(std.Target.stack_align) u8 = null, pub const Modifier = enum { /// Equivalent to function call syntax. auto, /// Equivalent to async keyword used with function call syntax. async_kw, /// Prevents tail call optimization. This guarantees that the return /// address will point to the callsite, as opposed to the callsite's /// callsite. If the call is otherwise required to be tail-called /// or inlined, a compile error is emitted instead. never_tail, /// Guarantees that the call will not be inlined. If the call is /// otherwise required to be inlined, a compile error is emitted instead. never_inline, /// Asserts that the function call will not suspend. This allows a /// non-async function to call an async function. no_async, /// Guarantees that the call will be generated with tail call optimization. /// If this is not possible, a compile error is emitted instead. always_tail, /// Guarantees that the call will inlined at the callsite. /// If this is not possible, a compile error is emitted instead. always_inline, /// Evaluates the call at compile-time. If the call cannot be completed at /// compile-time, a compile error is emitted instead. compile_time, }; }; {#end_syntax_block#} -+ , -+ .arguments = &.{ -+ "options: std.builtin.CallOptions", -+ "function: anytype", -+ "args: anytype", -+ }, -+ }, -+ .{ -+ .name = "@cDefine", -+ .signature = "@cDefine(comptime name: []u8, value)", -+ .snippet = "@cDefine(${1:comptime name: []u8}, ${2:value})", -+ .documentation = -+ \\This function can only occur inside `@cImport`. -+ \\ -+ \\This appends `#define $name $value` to the `@cImport` temporary buffer. -+ \\ -+ \\To define without a value, like this:`#define _GNU_SOURCE` -+ \\ -+ \\Use the void value, like this: -+ \\ -+ \\```zig -+ \\@cDefine("_GNU_SOURCE", {}) -+ \\``` -+ , -+ .arguments = &.{ -+ "comptime name: []u8", -+ "value", -+ }, -+ }, -+ .{ -+ .name = "@cImport", -+ .signature = "@cImport(expression) type", -+ .snippet = "@cImport(${1:expression})", -+ .documentation = -+ \\This function parses C code and imports the functions, types, variables, and compatible macro definitions into a new empty struct type, and then returns that type. -+ \\ -+ \\`expression` is interpreted at compile time. The builtin functions `@cInclude`, `@cDefine`, and `@cUndef` work within this expression, appending to a temporary buffer which is then parsed as C code. -+ \\ -+ \\Usually you should only have one `@cImport` in your entire application, because it saves the compiler from invoking clang multiple times, and prevents inline functions from being duplicated. -+ \\ -+ \\Reasons for having multiple `@cImport` expressions would be: -+ \\ - To avoid a symbol collision, for example if foo.h and bar.h both `#define CONNECTION_COUNT` -+ \\ - To analyze the C code with different preprocessor defines -+ , -+ .arguments = &.{ -+ "expression", -+ }, -+ }, -+ .{ -+ .name = "@cInclude", -+ .signature = "@cInclude(comptime path: []u8)", -+ .snippet = "@cInclude(${1:comptime path: []u8})", -+ .documentation = -+ \\This function can only occur inside `@cImport`. -+ \\ -+ \\This appends `#include <$path>\n` to the `c_import` temporary buffer. -+ , -+ .arguments = &.{ -+ "comptime path: []u8", -+ }, -+ }, -+ .{ -+ .name = "@clz", -+ .signature = "@clz(operand: anytype)", -+ .snippet = "@clz(${1:operand: anytype})", -+ .documentation = -+ \\`@TypeOf(operand)` must be an integer type or an integer vector type. -+ \\ -+ \\`operand` may be an [integer](https://ziglang.org/documentation/0.10.0/#Integers) or [vector](https://ziglang.org/documentation/0.10.0/#Vectors). -+ \\ -+ \\This function counts the number of most-significant (leading in a big-Endian sense) zeroes in an integer. -+ \\ -+ \\If `operand` is a [comptime](https://ziglang.org/documentation/0.10.0/#comptime)-known integer, the return type is `comptime_int`. Otherwise, the return type is an unsigned integer or vector of unsigned integers with the minimum number of bits that can represent the bit count of the integer type. -+ \\ -+ \\If `operand` is zero, `@clz` returns the bit width of integer type `T`. -+ , -+ .arguments = &.{ -+ "operand: anytype", -+ }, -+ }, -+ .{ -+ .name = "@cmpxchgStrong", -+ .signature = "@cmpxchgStrong(comptime T: type, ptr: *T, expected_value: T, new_value: T, success_order: AtomicOrder, fail_order: AtomicOrder) ?T", -+ .snippet = "@cmpxchgStrong(${1:comptime T: type}, ${2:ptr: *T}, ${3:expected_value: T}, ${4:new_value: T}, ${5:success_order: AtomicOrder}, ${6:fail_order: AtomicOrder})", -+ .documentation = -+ \\This function performs a strong atomic compare exchange operation. It's the equivalent of this code, except atomic: -+ \\ -+ \\```zig -+ \\fn cmpxchgStrongButNotAtomic(comptime T: type, ptr: *T, expected_value: T, new_value: T) ?T { -+ \\ const old_value = ptr.*; -+ \\ if (old_value == expected_value) { -+ \\ ptr.* = new_value; -+ \\ return null; -+ \\ } else { -+ \\ return old_value; -+ \\ } -+ \\} -+ \\``` -+ \\ -+ \\If you are using cmpxchg in a loop, [@cmpxchgWeak](https://ziglang.org/documentation/0.10.0/#cmpxchgWeak) is the better choice, because it can be implemented more efficiently in machine instructions. -+ \\ -+ \\`T` must be a pointer, a `bool`, a float, an integer or an enum. -+ \\ -+ \\`@typeInfo(@TypeOf(ptr)).Pointer.alignment` must be `>= @sizeOf(T).` -+ , -+ .arguments = &.{ -+ "comptime T: type", -+ "ptr: *T", -+ "expected_value: T", -+ "new_value: T", -+ "success_order: AtomicOrder", -+ "fail_order: AtomicOrder", -+ }, -+ }, -+ .{ -+ .name = "@cmpxchgWeak", -+ .signature = "@cmpxchgWeak(comptime T: type, ptr: *T, expected_value: T, new_value: T, success_order: AtomicOrder, fail_order: AtomicOrder) ?T", -+ .snippet = "@cmpxchgWeak(${1:comptime T: type}, ${2:ptr: *T}, ${3:expected_value: T}, ${4:new_value: T}, ${5:success_order: AtomicOrder}, ${6:fail_order: AtomicOrder})", -+ .documentation = -+ \\This function performs a weak atomic compare exchange operation. It's the equivalent of this code, except atomic:</p> {#syntax_block|zig|cmpxchgWeakButNotAtomic#} fn cmpxchgWeakButNotAtomic(comptime T: type, ptr: *T, expected_value: T, new_value: T) ?T { const old_value = ptr.*; if (old_value == expected_value and usuallyTrueButSometimesFalse()) { ptr.* = new_value; return null; } else { return old_value; } } {#end_syntax_block#} -+ \\ -+ \\If you are using cmpxchg in a loop, the sporadic failure will be no problem, and `cmpxchgWeak` is the better choice, because it can be implemented more efficiently in machine instructions. However if you need a stronger guarantee, use [@cmpxchgStrong](https://ziglang.org/documentation/0.10.0/#cmpxchgStrong). -+ \\ -+ \\`T` must be a pointer, a `bool`, a float, an integer or an enum. -+ \\ -+ \\`@typeInfo(@TypeOf(ptr)).Pointer.alignment` must be `>= @sizeOf(T).` -+ , -+ .arguments = &.{ -+ "comptime T: type", -+ "ptr: *T", -+ "expected_value: T", -+ "new_value: T", -+ "success_order: AtomicOrder", -+ "fail_order: AtomicOrder", -+ }, -+ }, -+ .{ -+ .name = "@compileError", -+ .signature = "@compileError(comptime msg: []u8)", -+ .snippet = "@compileError(${1:comptime msg: []u8})", -+ .documentation = -+ \\This function, when semantically analyzed, causes a compile error with the message `msg`. -+ \\ -+ \\There are several ways that code avoids being semantically checked, such as using `if` or `switch` with compile time constants, and `comptime` functions. -+ , -+ .arguments = &.{ -+ "comptime msg: []u8", -+ }, -+ }, -+ .{ -+ .name = "@compileLog", -+ .signature = "@compileLog(args: ...)", -+ .snippet = "@compileLog(${1:args: ...})", -+ .documentation = -+ \\This function prints the arguments passed to it at compile-time. -+ \\ -+ \\To prevent accidentally leaving compile log statements in a codebase, a compilation error is added to the build, pointing to the compile log statement. This error prevents code from being generated, but does not otherwise interfere with analysis. -+ \\ -+ \\This function can be used to do "printf debugging" on compile-time executing code. -+ \\ -+ \\```zig -+ \\const print = @import("std").debug.print; -+ \\ -+ \\const num1 = blk: { -+ \\ var val1: i32 = 99; -+ \\ @compileLog("comptime val1 = ", val1); -+ \\ val1 = val1 + 1; -+ \\ break :blk val1; -+ \\}; -+ \\ -+ \\test "main" { -+ \\ @compileLog("comptime in main"); -+ \\ -+ \\ print("Runtime in main, num1 = {}.\n", .{num1}); -+ \\} -+ \\``` -+ \\ -+ \\If all `@compileLog` calls are removed or not encountered by analysis, the program compiles successfully and the generated executable prints:</p> {#code_begin|test|without_compileLog#} const print = @import("std").debug.print; const num1 = blk: { var val1: i32 = 99; val1 = val1 + 1; break :blk val1; }; test "main" { print("Runtime in main, num1 = {}.\n", .{num1}); }` -+ , -+ .arguments = &.{ -+ "args: ...", -+ }, -+ }, -+ .{ -+ .name = "@ctz", -+ .signature = "@ctz(operand: anytype)", -+ .snippet = "@ctz(${1:operand: anytype})", -+ .documentation = -+ \\`@TypeOf(operand)` must be an integer type or an integer vector type. -+ \\ -+ \\`operand` may be an [integer](https://ziglang.org/documentation/0.10.0/#Integers) or [vector](https://ziglang.org/documentation/0.10.0/#Vectors). -+ \\ -+ \\This function counts the number of least-significant (trailing in a big-Endian sense) zeroes in an integer. -+ \\ -+ \\If `operand` is a [comptime](https://ziglang.org/documentation/0.10.0/#comptime)-known integer, the return type is `comptime_int`. Otherwise, the return type is an unsigned integer or vector of unsigned integers with the minimum number of bits that can represent the bit count of the integer type. -+ \\ -+ \\If `operand` is zero, `@ctz` returns the bit width of integer type `T`. -+ , -+ .arguments = &.{ -+ "operand: anytype", -+ }, -+ }, -+ .{ -+ .name = "@cUndef", -+ .signature = "@cUndef(comptime name: []u8)", -+ .snippet = "@cUndef(${1:comptime name: []u8})", -+ .documentation = -+ \\This function can only occur inside `@cImport`. -+ \\ -+ \\This appends `#undef $name` to the `@cImport` temporary buffer. -+ , -+ .arguments = &.{ -+ "comptime name: []u8", -+ }, -+ }, -+ .{ -+ .name = "@divExact", -+ .signature = "@divExact(numerator: T, denominator: T) T", -+ .snippet = "@divExact(${1:numerator: T}, ${2:denominator: T})", -+ .documentation = -+ \\Exact division. Caller guarantees `denominator != 0` and `@divTrunc(numerator, denominator) * denominator == numerator`. -+ \\ - `@divExact(6, 3) == 2` -+ \\ - `@divExact(a, b) * b == a` -+ \\ -+ \\For a function that returns a possible error code, use `@import("std").math.divExact`. -+ , -+ .arguments = &.{ -+ "numerator: T", -+ "denominator: T", -+ }, -+ }, -+ .{ -+ .name = "@divFloor", -+ .signature = "@divFloor(numerator: T, denominator: T) T", -+ .snippet = "@divFloor(${1:numerator: T}, ${2:denominator: T})", -+ .documentation = -+ \\Floored division. Rounds toward negative infinity. For unsigned integers it is the same as `numerator / denominator`. Caller guarantees `denominator != 0` and `!(@typeInfo(T) == .Int and T.is_signed and numerator == std.math.minInt(T) and denominator == -1)`. -+ \\ - `@divFloor(-5, 3) == -2` -+ \\ - `(@divFloor(a, b) * b) + @mod(a, b) == a` -+ \\ -+ \\For a function that returns a possible error code, use `@import("std").math.divFloor`. -+ , -+ .arguments = &.{ -+ "numerator: T", -+ "denominator: T", -+ }, -+ }, -+ .{ -+ .name = "@divTrunc", -+ .signature = "@divTrunc(numerator: T, denominator: T) T", -+ .snippet = "@divTrunc(${1:numerator: T}, ${2:denominator: T})", -+ .documentation = -+ \\Truncated division. Rounds toward zero. For unsigned integers it is the same as `numerator / denominator`. Caller guarantees `denominator != 0` and `!(@typeInfo(T) == .Int and T.is_signed and numerator == std.math.minInt(T) and denominator == -1)`. -+ \\ - `@divTrunc(-5, 3) == -1` -+ \\ - `(@divTrunc(a, b) * b) + @rem(a, b) == a` -+ \\ -+ \\For a function that returns a possible error code, use `@import("std").math.divTrunc`. -+ , -+ .arguments = &.{ -+ "numerator: T", -+ "denominator: T", -+ }, -+ }, -+ .{ -+ .name = "@embedFile", -+ .signature = "@embedFile(comptime path: []const u8) *const [N:0]u8", -+ .snippet = "@embedFile(${1:comptime path: []const u8})", -+ .documentation = -+ \\This function returns a compile time constant pointer to null-terminated, fixed-size array with length equal to the byte count of the file given by `path`. The contents of the array are the contents of the file. This is equivalent to a [string literal](https://ziglang.org/documentation/0.10.0/#String-Literals-and-Unicode-Code-Point-Literals) with the file contents. -+ \\ -+ \\`path` is absolute or relative to the current file, just like `@import`. -+ , -+ .arguments = &.{ -+ "comptime path: []const u8", -+ }, -+ }, -+ .{ -+ .name = "@enumToInt", -+ .signature = "@enumToInt(enum_or_tagged_union: anytype) anytype", -+ .snippet = "@enumToInt(${1:enum_or_tagged_union: anytype})", -+ .documentation = -+ \\Converts an enumeration value into its integer tag type. When a tagged union is passed, the tag value is used as the enumeration value. -+ \\ -+ \\If there is only one possible enum value, the result is a `comptime_int` known at [comptime](https://ziglang.org/documentation/0.10.0/#comptime). -+ , -+ .arguments = &.{ -+ "enum_or_tagged_union: anytype", -+ }, -+ }, -+ .{ -+ .name = "@errorName", -+ .signature = "@errorName(err: anyerror) [:0]const u8", -+ .snippet = "@errorName(${1:err: anyerror})", -+ .documentation = -+ \\This function returns the string representation of an error. The string representation of `error.OutOfMem` is `"OutOfMem"`. -+ \\ -+ \\If there are no calls to `@errorName` in an entire application, or all calls have a compile-time known value for `err`, then no error name table will be generated. -+ , -+ .arguments = &.{ -+ "err: anyerror", -+ }, -+ }, -+ .{ -+ .name = "@errorReturnTrace", -+ .signature = "@errorReturnTrace() ?*builtin.StackTrace", -+ .snippet = "@errorReturnTrace()", -+ .documentation = -+ \\If the binary is built with error return tracing, and this function is invoked in a function that calls a function with an error or error union return type, returns a stack trace object. Otherwise returns [null](https://ziglang.org/documentation/0.10.0/#null). -+ , -+ .arguments = &.{}, -+ }, -+ .{ -+ .name = "@errorToInt", -+ .signature = "@errorToInt(err: anytype) std.meta.Int(.unsigned, @sizeOf(anyerror) * 8)", -+ .snippet = "@errorToInt(${1:err: anytype})", -+ .documentation = -+ \\Supports the following types: -+ \\ - [The Global Error Set](https://ziglang.org/documentation/0.10.0/#The-Global-Error-Set) -+ \\ - [Error Set Type](https://ziglang.org/documentation/0.10.0/#Error-Set-Type) -+ \\ - [Error Union Type](https://ziglang.org/documentation/0.10.0/#Error-Union-Type) -+ \\ -+ \\Converts an error to the integer representation of an error. -+ \\ -+ \\It is generally recommended to avoid this cast, as the integer representation of an error is not stable across source code changes. -+ , -+ .arguments = &.{ -+ "err: anytype", -+ }, -+ }, -+ .{ -+ .name = "@errSetCast", -+ .signature = "@errSetCast(comptime T: DestType, value: anytype) DestType", -+ .snippet = "@errSetCast(${1:comptime T: DestType}, ${2:value: anytype})", -+ .documentation = -+ \\Converts an error value from one error set to another error set. Attempting to convert an error which is not in the destination error set results in safety-protected [Undefined Behavior](https://ziglang.org/documentation/0.10.0/#Undefined-Behavior). -+ , -+ .arguments = &.{ -+ "comptime T: DestType", -+ "value: anytype", -+ }, -+ }, -+ .{ -+ .name = "@export", -+ .signature = "@export(declaration, comptime options: std.builtin.ExportOptions) void", -+ .snippet = "@export(${1:declaration}, ${2:comptime options: std.builtin.ExportOptions})", -+ .documentation = -+ \\Creates a symbol in the output object file. -+ \\ -+ \\`declaration` must be one of two things: -+ \\ - An identifier (`x`) identifying a [function](https://ziglang.org/documentation/0.10.0/#Functions) or a [variable](https://ziglang.org/documentation/0.10.0/#Container-Level-Variables). -+ \\ - Field access (`x.y`) looking up a [function](https://ziglang.org/documentation/0.10.0/#Functions) or a [variable](https://ziglang.org/documentation/0.10.0/#Container-Level-Variables). -+ \\ -+ \\This builtin can be called from a [comptime](https://ziglang.org/documentation/0.10.0/#comptime) block to conditionally export symbols. When `declaration` is a function with the C calling convention and `options.linkage` is `Strong`, this is equivalent to the `export` keyword used on a function: -+ \\ -+ \\```zig -+ \\comptime { -+ \\ @export(internalName, .{ .name = "foo", .linkage = .Strong }); -+ \\} -+ \\ -+ \\fn internalName() callconv(.C) void {} -+ \\``` -+ \\ -+ \\This is equivalent to: -+ \\ -+ \\```zig -+ \\export fn foo() void {} -+ \\``` -+ \\ -+ \\Note that even when using `export`, the `@"foo"` syntax for [identifiers](https://ziglang.org/documentation/0.10.0/#Identifiers) can be used to choose any string for the symbol name: -+ \\ -+ \\```zig -+ \\export fn @"A function name that is a complete sentence."() void {} -+ \\``` -+ \\ -+ \\When looking at the resulting object, you can see the symbol is used verbatim: -+ \\ -+ \\```zig -+ \\00000000000001f0 T A function name that is a complete sentence. -+ \\``` -+ , -+ .arguments = &.{ -+ "declaration", -+ "comptime options: std.builtin.ExportOptions", -+ }, -+ }, -+ .{ -+ .name = "@extern", -+ .signature = "@extern(T: type, comptime options: std.builtin.ExternOptions) *T", -+ .snippet = "@extern(${1:T: type}, ${2:comptime options: std.builtin.ExternOptions})", -+ .documentation = -+ \\Creates a reference to an external symbol in the output object file. -+ , -+ .arguments = &.{ -+ "T: type", -+ "comptime options: std.builtin.ExternOptions", -+ }, -+ }, -+ .{ -+ .name = "@fence", -+ .signature = "@fence(order: AtomicOrder)", -+ .snippet = "@fence(${1:order: AtomicOrder})", -+ .documentation = -+ \\The `fence` function is used to introduce happens-before edges between operations. -+ \\ -+ \\`AtomicOrder` can be found with `@import("std").builtin.AtomicOrder`. -+ , -+ .arguments = &.{ -+ "order: AtomicOrder", -+ }, -+ }, -+ .{ -+ .name = "@field", -+ .signature = "@field(lhs: anytype, comptime field_name: []const u8) (field)", -+ .snippet = "@field(${1:lhs: anytype}, ${2:comptime field_name: []const u8})", -+ .documentation = -+ \\Performs field access by a compile-time string. Works on both fields and declarations.</p> {#code_begin|test|field_decl_access_by_string#} const std = @import("std"); const Point = struct { x: u32, y: u32, pub var z: u32 = 1; }; test "field access by string" { const expect = std.testing.expect; var p = Point{ .x = 0, .y = 0 }; @field(p, "x") = 4; @field(p, "y") = @field(p, "x") + 1; try expect(@field(p, "x") == 4); try expect(@field(p, "y") == 5); } test "decl access by string" { const expect = std.testing.expect; try expect(@field(Point, "z") == 1); @field(Point, "z") = 2; try expect(@field(Point, "z") == 2); }` -+ , -+ .arguments = &.{ -+ "lhs: anytype", -+ "comptime field_name: []const u8", -+ }, -+ }, -+ .{ -+ .name = "@fieldParentPtr", -+ .signature = "@fieldParentPtr(comptime ParentType: type, comptime field_name: []const u8, field_ptr: *T) *ParentType", -+ .snippet = "@fieldParentPtr(${1:comptime ParentType: type}, ${2:comptime field_name: []const u8}, ${3:field_ptr: *T})", -+ .documentation = -+ \\Given a pointer to a field, returns the base pointer of a struct. -+ , -+ .arguments = &.{ -+ "comptime ParentType: type", -+ "comptime field_name: []const u8", -+ "field_ptr: *T", -+ }, -+ }, -+ .{ -+ .name = "@floatCast", -+ .signature = "@floatCast(comptime DestType: type, value: anytype) DestType", -+ .snippet = "@floatCast(${1:comptime DestType: type}, ${2:value: anytype})", -+ .documentation = -+ \\Convert from one float type to another. This cast is safe, but may cause the numeric value to lose precision. -+ , -+ .arguments = &.{ -+ "comptime DestType: type", -+ "value: anytype", -+ }, -+ }, -+ .{ -+ .name = "@floatToInt", -+ .signature = "@floatToInt(comptime DestType: type, float: anytype) DestType", -+ .snippet = "@floatToInt(${1:comptime DestType: type}, ${2:float: anytype})", -+ .documentation = -+ \\Converts the integer part of a floating point number to the destination type. -+ \\ -+ \\If the integer part of the floating point number cannot fit in the destination type, it invokes safety-checked [Undefined Behavior](https://ziglang.org/documentation/0.10.0/#Undefined-Behavior). -+ , -+ .arguments = &.{ -+ "comptime DestType: type", -+ "float: anytype", -+ }, -+ }, -+ .{ -+ .name = "@frame", -+ .signature = "@frame() *@Frame(func)", -+ .snippet = "@frame()", -+ .documentation = -+ \\This function returns a pointer to the frame for a given function. This type can be [coerced](https://ziglang.org/documentation/0.10.0/#Type-Coercion) to `anyframe->T` and to `anyframe`, where `T` is the return type of the function in scope. -+ \\ -+ \\This function does not mark a suspension point, but it does cause the function in scope to become an [async function](https://ziglang.org/documentation/0.10.0/#Async-Functions). -+ , -+ .arguments = &.{}, -+ }, -+ .{ -+ .name = "@Frame", -+ .signature = "@Frame(func: anytype) type", -+ .snippet = "@Frame(${1:func: anytype})", -+ .documentation = -+ \\This function returns the frame type of a function. This works for [Async Functions](https://ziglang.org/documentation/0.10.0/#Async-Functions) as well as any function without a specific calling convention. -+ \\ -+ \\This type is suitable to be used as the return type of [async](https://ziglang.org/documentation/0.10.0/#Async-and-Await) which allows one to, for example, heap-allocate an async function frame:</p> {#code_begin|test|heap_allocated_frame#} {#backend_stage1#} const std = @import("std"); test "heap allocated frame" { const frame = try std.heap.page_allocator.create(@Frame(func)); frame.* = async func(); } fn func() void { suspend {} }` -+ , -+ .arguments = &.{ -+ "func: anytype", -+ }, -+ }, -+ .{ -+ .name = "@frameAddress", -+ .signature = "@frameAddress() usize", -+ .snippet = "@frameAddress()", -+ .documentation = -+ \\This function returns the base pointer of the current stack frame. -+ \\ -+ \\The implications of this are target-specific and not consistent across all platforms. The frame address may not be available in release mode due to aggressive optimizations. -+ \\ -+ \\This function is only valid within function scope. -+ , -+ .arguments = &.{}, -+ }, -+ .{ -+ .name = "@frameSize", -+ .signature = "@frameSize(func: anytype) usize", -+ .snippet = "@frameSize(${1:func: anytype})", -+ .documentation = -+ \\This is the same as `@sizeOf(@Frame(func))`, where `func` may be runtime-known. -+ \\ -+ \\This function is typically used in conjunction with [@asyncCall](https://ziglang.org/documentation/0.10.0/#asyncCall). -+ , -+ .arguments = &.{ -+ "func: anytype", -+ }, -+ }, -+ .{ -+ .name = "@hasDecl", -+ .signature = "@hasDecl(comptime Container: type, comptime name: []const u8) bool", -+ .snippet = "@hasDecl(${1:comptime Container: type}, ${2:comptime name: []const u8})", -+ .documentation = -+ \\Returns whether or not a [struct](https://ziglang.org/documentation/0.10.0/#struct), [enum](https://ziglang.org/documentation/0.10.0/#enum), or [union](https://ziglang.org/documentation/0.10.0/#union) has a declaration matching `name`.</p> {#code_begin|test|hasDecl#} const std = @import("std"); const expect = std.testing.expect; const Foo = struct { nope: i32, pub var blah = "xxx"; const hi = 1; }; test "@hasDecl" { try expect(@hasDecl(Foo, "blah")); // Even though `hi` is private, @hasDecl returns true because this test is // in the same file scope as Foo. It would return false if Foo was declared // in a different file. try expect(@hasDecl(Foo, "hi")); // @hasDecl is for declarations; not fields. try expect(!@hasDecl(Foo, "nope")); try expect(!@hasDecl(Foo, "nope1234")); }` -+ , -+ .arguments = &.{ -+ "comptime Container: type", -+ "comptime name: []const u8", -+ }, -+ }, -+ .{ -+ .name = "@hasField", -+ .signature = "@hasField(comptime Container: type, comptime name: []const u8) bool", -+ .snippet = "@hasField(${1:comptime Container: type}, ${2:comptime name: []const u8})", -+ .documentation = -+ \\Returns whether the field name of a struct, union, or enum exists. -+ \\ -+ \\The result is a compile time constant. -+ \\ -+ \\It does not include functions, variables, or constants. -+ , -+ .arguments = &.{ -+ "comptime Container: type", -+ "comptime name: []const u8", -+ }, -+ }, -+ .{ -+ .name = "@import", -+ .signature = "@import(comptime path: []u8) type", -+ .snippet = "@import(${1:comptime path: []u8})", -+ .documentation = -+ \\This function finds a zig file corresponding to `path` and adds it to the build, if it is not already added. -+ \\ -+ \\Zig source files are implicitly structs, with a name equal to the file's basename with the extension truncated. `@import` returns the struct type corresponding to the file. -+ \\ -+ \\Declarations which have the `pub` keyword may be referenced from a different source file than the one they are declared in. -+ \\ -+ \\`path` can be a relative path or it can be the name of a package. If it is a relative path, it is relative to the file that contains the `@import` function call. -+ \\ -+ \\The following packages are always available: -+ \\ - `@import("std")` - Zig Standard Library -+ \\ - `@import("builtin")` - Target-specific information. The command `zig build-exe --show-builtin` outputs the source to stdout for reference. -+ \\ - `@import("root")` - Points to the root source file. This is usually `src/main.zig` but it depends on what file is chosen to be built. -+ , -+ .arguments = &.{ -+ "comptime path: []u8", -+ }, -+ }, -+ .{ -+ .name = "@intCast", -+ .signature = "@intCast(comptime DestType: type, int: anytype) DestType", -+ .snippet = "@intCast(${1:comptime DestType: type}, ${2:int: anytype})", -+ .documentation = -+ \\Converts an integer to another integer while keeping the same numerical value. Attempting to convert a number which is out of range of the destination type results in safety-protected [Undefined Behavior](https://ziglang.org/documentation/0.10.0/#Undefined-Behavior). -+ \\ -+ \\```zig -+ \\test "integer cast panic" { -+ \\ var a: u16 = 0xabcd; -+ \\ var b: u8 = @intCast(u8, a); -+ \\ _ = b; -+ \\} -+ \\``` -+ \\ -+ \\To truncate the significant bits of a number out of range of the destination type, use [@truncate](https://ziglang.org/documentation/0.10.0/#truncate). -+ \\ -+ \\If `T` is `comptime_int`, then this is semantically equivalent to [Type Coercion](https://ziglang.org/documentation/0.10.0/#Type-Coercion). -+ , -+ .arguments = &.{ -+ "comptime DestType: type", -+ "int: anytype", -+ }, -+ }, -+ .{ -+ .name = "@intToEnum", -+ .signature = "@intToEnum(comptime DestType: type, integer: anytype) DestType", -+ .snippet = "@intToEnum(${1:comptime DestType: type}, ${2:integer: anytype})", -+ .documentation = -+ \\Converts an integer into an [enum](https://ziglang.org/documentation/0.10.0/#enum) value. -+ \\ -+ \\Attempting to convert an integer which represents no value in the chosen enum type invokes safety-checked [Undefined Behavior](https://ziglang.org/documentation/0.10.0/#Undefined-Behavior). -+ , -+ .arguments = &.{ -+ "comptime DestType: type", -+ "integer: anytype", -+ }, -+ }, -+ .{ -+ .name = "@intToError", -+ .signature = "@intToError(value: std.meta.Int(.unsigned, @sizeOf(anyerror) * 8)) anyerror", -+ .snippet = "@intToError(${1:value: std.meta.Int(.unsigned, @sizeOf(anyerror) * 8)})", -+ .documentation = -+ \\Converts from the integer representation of an error into [The Global Error Set](https://ziglang.org/documentation/0.10.0/#The-Global-Error-Set) type. -+ \\ -+ \\It is generally recommended to avoid this cast, as the integer representation of an error is not stable across source code changes. -+ \\ -+ \\Attempting to convert an integer that does not correspond to any error results in safety-protected [Undefined Behavior](https://ziglang.org/documentation/0.10.0/#Undefined-Behavior). -+ , -+ .arguments = &.{ -+ "value: std.meta.Int(.unsigned, @sizeOf(anyerror) * 8)", -+ }, -+ }, -+ .{ -+ .name = "@intToFloat", -+ .signature = "@intToFloat(comptime DestType: type, int: anytype) DestType", -+ .snippet = "@intToFloat(${1:comptime DestType: type}, ${2:int: anytype})", -+ .documentation = -+ \\Converts an integer to the closest floating point representation. To convert the other way, use [@floatToInt](https://ziglang.org/documentation/0.10.0/#floatToInt). This cast is always safe. -+ , -+ .arguments = &.{ -+ "comptime DestType: type", -+ "int: anytype", -+ }, -+ }, -+ .{ -+ .name = "@intToPtr", -+ .signature = "@intToPtr(comptime DestType: type, address: usize) DestType", -+ .snippet = "@intToPtr(${1:comptime DestType: type}, ${2:address: usize})", -+ .documentation = -+ \\Converts an integer to a [pointer](https://ziglang.org/documentation/0.10.0/#Pointers). To convert the other way, use [@ptrToInt](https://ziglang.org/documentation/0.10.0/#ptrToInt). Casting an address of 0 to a destination type which in not [optional](https://ziglang.org/documentation/0.10.0/#Optional-Pointers) and does not have the `allowzero` attribute will result in a [Pointer Cast Invalid Null](https://ziglang.org/documentation/0.10.0/#Pointer-Cast-Invalid-Null) panic when runtime safety checks are enabled. -+ \\ -+ \\If the destination pointer type does not allow address zero and `address` is zero, this invokes safety-checked [Undefined Behavior](https://ziglang.org/documentation/0.10.0/#Undefined-Behavior). -+ , -+ .arguments = &.{ -+ "comptime DestType: type", -+ "address: usize", -+ }, -+ }, -+ .{ -+ .name = "@max", -+ .signature = "@max(a: T, b: T) T", -+ .snippet = "@max(${1:a: T}, ${2:b: T})", -+ .documentation = -+ \\Returns the maximum value of `a` and `b`. This builtin accepts integers, floats, and vectors of either. In the latter case, the operation is performed element wise. -+ \\ -+ \\NaNs are handled as follows: if one of the operands of a (pairwise) operation is NaN, the other operand is returned. If both operands are NaN, NaN is returned. -+ , -+ .arguments = &.{ -+ "a: T", -+ "b: T", -+ }, -+ }, -+ .{ -+ .name = "@memcpy", -+ .signature = "@memcpy(noalias dest: [*]u8, noalias source: [*]const u8, byte_count: usize)", -+ .snippet = "@memcpy(${1:noalias dest: [*]u8}, ${2:noalias source: [*]const u8}, ${3:byte_count: usize})", -+ .documentation = -+ \\This function copies bytes from one region of memory to another. `dest` and `source` are both pointers and must not overlap. -+ \\ -+ \\This function is a low level intrinsic with no safety mechanisms. Most code should not use this function, instead using something like this: -+ \\ -+ \\```zig -+ \\for (source[0..byte_count]) |b, i| dest[i] = b; -+ \\``` -+ \\ -+ \\The optimizer is intelligent enough to turn the above snippet into a memcpy. -+ \\ -+ \\There is also a standard library function for this: -+ \\ -+ \\```zig -+ \\const mem = @import("std").mem; -+ \\mem.copy(u8, dest[0..byte_count], source[0..byte_count]); -+ \\``` -+ , -+ .arguments = &.{ -+ "noalias dest: [*]u8", -+ "noalias source: [*]const u8", -+ "byte_count: usize", -+ }, -+ }, -+ .{ -+ .name = "@memset", -+ .signature = "@memset(dest: [*]u8, c: u8, byte_count: usize)", -+ .snippet = "@memset(${1:dest: [*]u8}, ${2:c: u8}, ${3:byte_count: usize})", -+ .documentation = -+ \\This function sets a region of memory to `c`. `dest` is a pointer. -+ \\ -+ \\This function is a low level intrinsic with no safety mechanisms. Most code should not use this function, instead using something like this: -+ \\ -+ \\```zig -+ \\for (dest[0..byte_count]) |*b| b.* = c; -+ \\``` -+ \\ -+ \\The optimizer is intelligent enough to turn the above snippet into a memset. -+ \\ -+ \\There is also a standard library function for this: -+ \\ -+ \\```zig -+ \\const mem = @import("std").mem; -+ \\mem.set(u8, dest, c); -+ \\``` -+ , -+ .arguments = &.{ -+ "dest: [*]u8", -+ "c: u8", -+ "byte_count: usize", -+ }, -+ }, -+ .{ -+ .name = "@min", -+ .signature = "@min(a: T, b: T) T", -+ .snippet = "@min(${1:a: T}, ${2:b: T})", -+ .documentation = -+ \\Returns the minimum value of `a` and `b`. This builtin accepts integers, floats, and vectors of either. In the latter case, the operation is performed element wise. -+ \\ -+ \\NaNs are handled as follows: if one of the operands of a (pairwise) operation is NaN, the other operand is returned. If both operands are NaN, NaN is returned. -+ , -+ .arguments = &.{ -+ "a: T", -+ "b: T", -+ }, -+ }, -+ .{ -+ .name = "@wasmMemorySize", -+ .signature = "@wasmMemorySize(index: u32) u32", -+ .snippet = "@wasmMemorySize(${1:index: u32})", -+ .documentation = -+ \\This function returns the size of the Wasm memory identified by `index` as an unsigned value in units of Wasm pages. Note that each Wasm page is 64KB in size. -+ \\ -+ \\This function is a low level intrinsic with no safety mechanisms usually useful for allocator designers targeting Wasm. So unless you are writing a new allocator from scratch, you should use something like `@import("std").heap.WasmPageAllocator`. -+ , -+ .arguments = &.{ -+ "index: u32", -+ }, -+ }, -+ .{ -+ .name = "@wasmMemoryGrow", -+ .signature = "@wasmMemoryGrow(index: u32, delta: u32) i32", -+ .snippet = "@wasmMemoryGrow(${1:index: u32}, ${2:delta: u32})", -+ .documentation = -+ \\This function increases the size of the Wasm memory identified by `index` by `delta` in units of unsigned number of Wasm pages. Note that each Wasm page is 64KB in size. On success, returns previous memory size; on failure, if the allocation fails, returns -1. -+ \\ -+ \\This function is a low level intrinsic with no safety mechanisms usually useful for allocator designers targeting Wasm. So unless you are writing a new allocator from scratch, you should use something like `@import("std").heap.WasmPageAllocator`.</p> {#code_begin|test|wasmMemoryGrow#} const std = @import("std"); const native_arch = @import("builtin").target.cpu.arch; const expect = std.testing.expect; test "@wasmMemoryGrow" { if (native_arch != .wasm32) return error.SkipZigTest; var prev = @wasmMemorySize(0); try expect(prev == @wasmMemoryGrow(0, 1)); try expect(prev + 1 == @wasmMemorySize(0)); }` -+ , -+ .arguments = &.{ -+ "index: u32", -+ "delta: u32", -+ }, -+ }, -+ .{ -+ .name = "@mod", -+ .signature = "@mod(numerator: T, denominator: T) T", -+ .snippet = "@mod(${1:numerator: T}, ${2:denominator: T})", -+ .documentation = -+ \\Modulus division. For unsigned integers this is the same as `numerator % denominator`. Caller guarantees `denominator > 0`, otherwise the operation will result in a [Remainder Division by Zero](https://ziglang.org/documentation/0.10.0/#Remainder-Division-by-Zero) when runtime safety checks are enabled. -+ \\ - `@mod(-5, 3) == 1` -+ \\ - `(@divFloor(a, b) * b) + @mod(a, b) == a` -+ \\ -+ \\For a function that returns an error code, see `@import("std").math.mod`. -+ , -+ .arguments = &.{ -+ "numerator: T", -+ "denominator: T", -+ }, -+ }, -+ .{ -+ .name = "@mulWithOverflow", -+ .signature = "@mulWithOverflow(comptime T: type, a: T, b: T, result: *T) bool", -+ .snippet = "@mulWithOverflow(${1:comptime T: type}, ${2:a: T}, ${3:b: T}, ${4:result: *T})", -+ .documentation = -+ \\Performs `result.* = a * b`. If overflow or underflow occurs, stores the overflowed bits in `result` and returns `true`. If no overflow or underflow occurs, returns `false`. -+ , -+ .arguments = &.{ -+ "comptime T: type", -+ "a: T", -+ "b: T", -+ "result: *T", -+ }, -+ }, -+ .{ -+ .name = "@panic", -+ .signature = "@panic(message: []const u8) noreturn", -+ .snippet = "@panic(${1:message: []const u8})", -+ .documentation = -+ \\Invokes the panic handler function. By default the panic handler function calls the public `panic` function exposed in the root source file, or if there is not one specified, the `std.builtin.default_panic` function from `std/builtin.zig`. -+ \\ -+ \\Generally it is better to use `@import("std").debug.panic`. However, `@panic` can be useful for 2 scenarios: -+ \\ - From library code, calling the programmer's panic function if they exposed one in the root source file. -+ \\ - When mixing C and Zig code, calling the canonical panic implementation across multiple .o files. -+ , -+ .arguments = &.{ -+ "message: []const u8", -+ }, -+ }, -+ .{ -+ .name = "@popCount", -+ .signature = "@popCount(operand: anytype)", -+ .snippet = "@popCount(${1:operand: anytype})", -+ .documentation = -+ \\`@TypeOf(operand)` must be an integer type. -+ \\ -+ \\`operand` may be an [integer](https://ziglang.org/documentation/0.10.0/#Integers) or [vector](https://ziglang.org/documentation/0.10.0/#Vectors). -+ \\ -+ \\Counts the number of bits set in an integer. -+ \\ -+ \\If `operand` is a [comptime](https://ziglang.org/documentation/0.10.0/#comptime)-known integer, the return type is `comptime_int`. Otherwise, the return type is an unsigned integer or vector of unsigned integers with the minimum number of bits that can represent the bit count of the integer type. -+ , -+ .arguments = &.{ -+ "operand: anytype", -+ }, -+ }, -+ .{ -+ .name = "@prefetch", -+ .signature = "@prefetch(ptr: anytype, comptime options: std.builtin.PrefetchOptions)", -+ .snippet = "@prefetch(${1:ptr: anytype}, ${2:comptime options: std.builtin.PrefetchOptions})", -+ .documentation = -+ \\This builtin tells the compiler to emit a prefetch instruction if supported by the target CPU. If the target CPU does not support the requested prefetch instruction, this builtin is a no-op. This function has no effect on the behavior of the program, only on the performance characteristics. -+ \\ -+ \\The `ptr` argument may be any pointer type and determines the memory address to prefetch. This function does not dereference the pointer, it is perfectly legal to pass a pointer to invalid memory to this function and no illegal behavior will result. -+ \\ -+ \\The `options` argument is the following struct:</p> {#code_begin|syntax|builtin#} /// This data structure is used by the Zig language code generation and /// therefore must be kept in sync with the compiler implementation. pub const PrefetchOptions = struct { /// Whether the prefetch should prepare for a read or a write. rw: Rw = .read, /// 0 means no temporal locality. That is, the data can be immediately /// dropped from the cache after it is accessed. /// /// 3 means high temporal locality. That is, the data should be kept in /// the cache as it is likely to be accessed again soon. locality: u2 = 3, /// The cache that the prefetch should be preformed on. cache: Cache = .data, pub const Rw = enum { read, write, }; pub const Cache = enum { instruction, data, }; };` -+ , -+ .arguments = &.{ -+ "ptr: anytype", -+ "comptime options: std.builtin.PrefetchOptions", -+ }, -+ }, -+ .{ -+ .name = "@ptrCast", -+ .signature = "@ptrCast(comptime DestType: type, value: anytype) DestType", -+ .snippet = "@ptrCast(${1:comptime DestType: type}, ${2:value: anytype})", -+ .documentation = -+ \\Converts a pointer of one type to a pointer of another type. -+ \\ -+ \\[Optional Pointers](https://ziglang.org/documentation/0.10.0/#Optional-Pointers) are allowed. Casting an optional pointer which is [null](https://ziglang.org/documentation/0.10.0/#null) to a non-optional pointer invokes safety-checked [Undefined Behavior](https://ziglang.org/documentation/0.10.0/#Undefined-Behavior). -+ , -+ .arguments = &.{ -+ "comptime DestType: type", -+ "value: anytype", -+ }, -+ }, -+ .{ -+ .name = "@ptrToInt", -+ .signature = "@ptrToInt(value: anytype) usize", -+ .snippet = "@ptrToInt(${1:value: anytype})", -+ .documentation = -+ \\Converts `value` to a `usize` which is the address of the pointer. `value` can be `*T` or `?*T`. -+ \\ -+ \\To convert the other way, use [@intToPtr](https://ziglang.org/documentation/0.10.0/#intToPtr) -+ , -+ .arguments = &.{ -+ "value: anytype", -+ }, -+ }, -+ .{ -+ .name = "@rem", -+ .signature = "@rem(numerator: T, denominator: T) T", -+ .snippet = "@rem(${1:numerator: T}, ${2:denominator: T})", -+ .documentation = -+ \\Remainder division. For unsigned integers this is the same as `numerator % denominator`. Caller guarantees `denominator > 0`, otherwise the operation will result in a [Remainder Division by Zero](https://ziglang.org/documentation/0.10.0/#Remainder-Division-by-Zero) when runtime safety checks are enabled. -+ \\ - `@rem(-5, 3) == -2` -+ \\ - `(@divTrunc(a, b) * b) + @rem(a, b) == a` -+ \\ -+ \\For a function that returns an error code, see `@import("std").math.rem`. -+ , -+ .arguments = &.{ -+ "numerator: T", -+ "denominator: T", -+ }, -+ }, -+ .{ -+ .name = "@returnAddress", -+ .signature = "@returnAddress() usize", -+ .snippet = "@returnAddress()", -+ .documentation = -+ \\This function returns the address of the next machine code instruction that will be executed when the current function returns. -+ \\ -+ \\The implications of this are target-specific and not consistent across all platforms. -+ \\ -+ \\This function is only valid within function scope. If the function gets inlined into a calling function, the returned address will apply to the calling function. -+ , -+ .arguments = &.{}, -+ }, -+ .{ -+ .name = "@select", -+ .signature = "@select(comptime T: type, pred: @Vector(len, bool), a: @Vector(len, T), b: @Vector(len, T)) @Vector(len, T)", -+ .snippet = "@select(${1:comptime T: type}, ${2:pred: @Vector(len, bool)}, ${3:a: @Vector(len, T)}, ${4:b: @Vector(len, T)})", -+ .documentation = -+ \\Selects values element-wise from `a` or `b` based on `pred`. If `pred[i]` is `true`, the corresponding element in the result will be `a[i]` and otherwise `b[i]`. -+ , -+ .arguments = &.{ -+ "comptime T: type", -+ "pred: @Vector(len, bool)", -+ "a: @Vector(len, T)", -+ "b: @Vector(len, T)", -+ }, -+ }, -+ .{ -+ .name = "@setAlignStack", -+ .signature = "@setAlignStack(comptime alignment: u29)", -+ .snippet = "@setAlignStack(${1:comptime alignment: u29})", -+ .documentation = -+ \\Ensures that a function will have a stack alignment of at least `alignment` bytes. -+ , -+ .arguments = &.{ -+ "comptime alignment: u29", -+ }, -+ }, -+ .{ -+ .name = "@setCold", -+ .signature = "@setCold(comptime is_cold: bool)", -+ .snippet = "@setCold(${1:comptime is_cold: bool})", -+ .documentation = -+ \\Tells the optimizer that a function is rarely called. -+ , -+ .arguments = &.{ -+ "comptime is_cold: bool", -+ }, -+ }, -+ .{ -+ .name = "@setEvalBranchQuota", -+ .signature = "@setEvalBranchQuota(comptime new_quota: u32)", -+ .snippet = "@setEvalBranchQuota(${1:comptime new_quota: u32})", -+ .documentation = -+ \\Changes the maximum number of backwards branches that compile-time code execution can use before giving up and making a compile error. -+ \\ -+ \\If the `new_quota` is smaller than the default quota (`1000`) or a previously explicitly set quota, it is ignored. -+ \\ -+ \\Example: -+ \\ -+ \\```zig -+ \\test "foo" { -+ \\ comptime { -+ \\ var i = 0; -+ \\ while (i < 1001) : (i += 1) {} -+ \\ } -+ \\} -+ \\``` -+ \\ -+ \\Now we use `@setEvalBranchQuota`:</p> {#code_begin|test|setEvalBranchQuota#} test "foo" { comptime { @setEvalBranchQuota(1001); var i = 0; while (i < 1001) : (i += 1) {} } }` -+ , -+ .arguments = &.{ -+ "comptime new_quota: u32", -+ }, -+ }, -+ .{ -+ .name = "@setFloatMode", -+ .signature = "@setFloatMode(comptime mode: @import(\"std\").builtin.FloatMode)", -+ .snippet = "@setFloatMode(${1:comptime mode: @import(\"std\").builtin.FloatMode})", -+ .documentation = -+ \\Sets the floating point mode of the current scope. Possible values are: -+ \\ -+ \\```zig -+ \\pub const FloatMode = enum { -+ \\ Strict, -+ \\ Optimized, -+ \\}; -+ \\``` -+ \\ -+ \\ - `Strict` (default) - Floating point operations follow strict IEEE compliance. -+ \\ - `Optimized` - Floating point operations may do all of the following: <ul> -+ \\ - Assume the arguments and result are not NaN. Optimizations are required to retain defined behavior over NaNs, but the value of the result is undefined. -+ \\ - Assume the arguments and result are not +/-Inf. Optimizations are required to retain defined behavior over +/-Inf, but the value of the result is undefined. -+ \\ - Treat the sign of a zero argument or result as insignificant. -+ \\ - Use the reciprocal of an argument rather than perform division. -+ \\ - Perform floating-point contraction (e.g. fusing a multiply followed by an addition into a fused multiply-add). -+ \\ - Perform algebraically equivalent transformations that may change results in floating point (e.g. reassociate). This is equivalent to `-ffast-math` in GCC.</ul> -+ \\ -+ \\The floating point mode is inherited by child scopes, and can be overridden in any scope. You can set the floating point mode in a struct or module scope by using a comptime block. -+ , -+ .arguments = &.{ -+ "comptime mode: @import(\"std\").builtin.FloatMode", -+ }, -+ }, -+ .{ -+ .name = "@setRuntimeSafety", -+ .signature = "@setRuntimeSafety(comptime safety_on: bool) void", -+ .snippet = "@setRuntimeSafety(${1:comptime safety_on: bool})", -+ .documentation = -+ \\Sets whether runtime safety checks are enabled for the scope that contains the function call. -+ \\ -+ \\```zig -+ \\test "@setRuntimeSafety" { -+ \\ // The builtin applies to the scope that it is called in. So here, integer overflow -+ \\ // will not be caught in ReleaseFast and ReleaseSmall modes: -+ \\ // var x: u8 = 255; -+ \\ // x += 1; // undefined behavior in ReleaseFast/ReleaseSmall modes. -+ \\ { -+ \\ // However this block has safety enabled, so safety checks happen here, -+ \\ // even in ReleaseFast and ReleaseSmall modes. -+ \\ @setRuntimeSafety(true); -+ \\ var x: u8 = 255; -+ \\ x += 1; -+ \\ -+ \\ { -+ \\ // The value can be overridden at any scope. So here integer overflow -+ \\ // would not be caught in any build mode. -+ \\ @setRuntimeSafety(false); -+ \\ // var x: u8 = 255; -+ \\ // x += 1; // undefined behavior in all build modes. -+ \\ } -+ \\ } -+ \\} -+ \\``` -+ \\ -+ \\Note: it is [planned](https://github.com/ziglang/zig/issues/978) to replace `@setRuntimeSafety` with `@optimizeFor` -+ , -+ .arguments = &.{ -+ "comptime safety_on: bool", -+ }, -+ }, -+ .{ -+ .name = "@shlExact", -+ .signature = "@shlExact(value: T, shift_amt: Log2T) T", -+ .snippet = "@shlExact(${1:value: T}, ${2:shift_amt: Log2T})", -+ .documentation = -+ \\Performs the left shift operation (`<<`). For unsigned integers, the result is [undefined](https://ziglang.org/documentation/0.10.0/#undefined) if any 1 bits are shifted out. For signed integers, the result is [undefined](https://ziglang.org/documentation/0.10.0/#undefined) if any bits that disagree with the resultant sign bit are shifted out. -+ \\ -+ \\The type of `shift_amt` is an unsigned integer with `log2(@typeInfo(T).Int.bits)` bits. This is because `shift_amt >= @typeInfo(T).Int.bits` is undefined behavior. -+ , -+ .arguments = &.{ -+ "value: T", -+ "shift_amt: Log2T", -+ }, -+ }, -+ .{ -+ .name = "@shlWithOverflow", -+ .signature = "@shlWithOverflow(comptime T: type, a: T, shift_amt: Log2T, result: *T) bool", -+ .snippet = "@shlWithOverflow(${1:comptime T: type}, ${2:a: T}, ${3:shift_amt: Log2T}, ${4:result: *T})", -+ .documentation = -+ \\Performs `result.* = a << b`. If overflow or underflow occurs, stores the overflowed bits in `result` and returns `true`. If no overflow or underflow occurs, returns `false`. -+ \\ -+ \\The type of `shift_amt` is an unsigned integer with `log2(@typeInfo(T).Int.bits)` bits. This is because `shift_amt >= @typeInfo(T).Int.bits` is undefined behavior. -+ , -+ .arguments = &.{ -+ "comptime T: type", -+ "a: T", -+ "shift_amt: Log2T", -+ "result: *T", -+ }, -+ }, -+ .{ -+ .name = "@shrExact", -+ .signature = "@shrExact(value: T, shift_amt: Log2T) T", -+ .snippet = "@shrExact(${1:value: T}, ${2:shift_amt: Log2T})", -+ .documentation = -+ \\Performs the right shift operation (`>>`). Caller guarantees that the shift will not shift any 1 bits out. -+ \\ -+ \\The type of `shift_amt` is an unsigned integer with `log2(@typeInfo(T).Int.bits)` bits. This is because `shift_amt >= @typeInfo(T).Int.bits` is undefined behavior. -+ , -+ .arguments = &.{ -+ "value: T", -+ "shift_amt: Log2T", -+ }, -+ }, -+ .{ -+ .name = "@shuffle", -+ .signature = "@shuffle(comptime E: type, a: @Vector(a_len, E), b: @Vector(b_len, E), comptime mask: @Vector(mask_len, i32)) @Vector(mask_len, E)", -+ .snippet = "@shuffle(${1:comptime E: type}, ${2:a: @Vector(a_len, E)}, ${3:b: @Vector(b_len, E)}, ${4:comptime mask: @Vector(mask_len, i32)})", -+ .documentation = -+ \\Constructs a new [vector](https://ziglang.org/documentation/0.10.0/#Vectors) by selecting elements from `a` and `b` based on `mask`. -+ \\ -+ \\Each element in `mask` selects an element from either `a` or `b`. Positive numbers select from `a` starting at 0. Negative values select from `b`, starting at `-1` and going down. It is recommended to use the `~` operator for indexes from `b` so that both indexes can start from `0` (i.e. `~@as(i32, 0)` is `-1`). -+ \\ -+ \\For each element of `mask`, if it or the selected value from `a` or `b` is `undefined`, then the resulting element is `undefined`. -+ \\ -+ \\`a_len` and `b_len` may differ in length. Out-of-bounds element indexes in `mask` result in compile errors. -+ \\ -+ \\If `a` or `b` is `undefined`, it is equivalent to a vector of all `undefined` with the same length as the other vector. If both vectors are `undefined`, `@shuffle` returns a vector with all elements `undefined`. -+ \\ -+ \\`E` must be an [integer](https://ziglang.org/documentation/0.10.0/#Integers), [float](https://ziglang.org/documentation/0.10.0/#Floats), [pointer](https://ziglang.org/documentation/0.10.0/#Pointers), or `bool`. The mask may be any vector length, and its length determines the result length.</p> {#code_begin|test|vector_shuffle#} const std = @import("std"); const expect = std.testing.expect; test "vector @shuffle" { const a = @Vector(7, u8){ 'o', 'l', 'h', 'e', 'r', 'z', 'w' }; const b = @Vector(4, u8){ 'w', 'd', '!', 'x' }; // To shuffle within a single vector, pass undefined as the second argument. // Notice that we can re-order, duplicate, or omit elements of the input vector const mask1 = @Vector(5, i32){ 2, 3, 1, 1, 0 }; const res1: @Vector(5, u8) = @shuffle(u8, a, undefined, mask1); try expect(std.mem.eql(u8, &@as([5]u8, res1), "hello")); // Combining two vectors const mask2 = @Vector(6, i32){ -1, 0, 4, 1, -2, -3 }; const res2: @Vector(6, u8) = @shuffle(u8, a, b, mask2); try expect(std.mem.eql(u8, &@as([6]u8, res2), "world!")); }` -+ , -+ .arguments = &.{ -+ "comptime E: type", -+ "a: @Vector(a_len, E)", -+ "b: @Vector(b_len, E)", -+ "comptime mask: @Vector(mask_len, i32)", -+ }, -+ }, -+ .{ -+ .name = "@sizeOf", -+ .signature = "@sizeOf(comptime T: type) comptime_int", -+ .snippet = "@sizeOf(${1:comptime T: type})", -+ .documentation = -+ \\This function returns the number of bytes it takes to store `T` in memory. The result is a target-specific compile time constant. -+ \\ -+ \\This size may contain padding bytes. If there were two consecutive T in memory, this would be the offset in bytes between element at index 0 and the element at index 1. For [integer](https://ziglang.org/documentation/0.10.0/#Integers), consider whether you want to use `@sizeOf(T)` or `@typeInfo(T).Int.bits`. -+ \\ -+ \\This function measures the size at runtime. For types that are disallowed at runtime, such as `comptime_int` and `type`, the result is `0`. -+ , -+ .arguments = &.{ -+ "comptime T: type", -+ }, -+ }, -+ .{ -+ .name = "@splat", -+ .signature = "@splat(comptime len: u32, scalar: anytype) @Vector(len, @TypeOf(scalar))", -+ .snippet = "@splat(${1:comptime len: u32}, ${2:scalar: anytype})", -+ .documentation = -+ \\Produces a vector of length `len` where each element is the value `scalar`:</p> {#code_begin|test|vector_splat#} const std = @import("std"); const expect = std.testing.expect; test "vector @splat" { const scalar: u32 = 5; const result = @splat(4, scalar); comptime try expect(@TypeOf(result) == @Vector(4, u32)); try expect(std.mem.eql(u32, &@as([4]u32, result), &[_]u32{ 5, 5, 5, 5 })); }` -+ \\ -+ \\`scalar` must be an [integer](https://ziglang.org/documentation/0.10.0/#Integers), [bool](https://ziglang.org/documentation/0.10.0/#Primitive-Types), [float](https://ziglang.org/documentation/0.10.0/#Floats), or [pointer](https://ziglang.org/documentation/0.10.0/#Pointers). -+ , -+ .arguments = &.{ -+ "comptime len: u32", -+ "scalar: anytype", -+ }, -+ }, -+ .{ -+ .name = "@reduce", -+ .signature = "@reduce(comptime op: std.builtin.ReduceOp, value: anytype) E", -+ .snippet = "@reduce(${1:comptime op: std.builtin.ReduceOp}, ${2:value: anytype})", -+ .documentation = -+ \\Transforms a [vector](https://ziglang.org/documentation/0.10.0/#Vectors) into a scalar value (of type `E`) by performing a sequential horizontal reduction of its elements using the specified operator `op`. -+ \\ -+ \\Not every operator is available for every vector element type: -+ \\ - Every operator is available for [integer](https://ziglang.org/documentation/0.10.0/#Integers) vectors. -+ \\ - `.And`, `.Or`, `.Xor` are additionally available for `bool` vectors, -+ \\ - `.Min`, `.Max`, `.Add`, `.Mul` are additionally available for [floating point](https://ziglang.org/documentation/0.10.0/#Floats) vectors, -+ \\ -+ \\Note that `.Add` and `.Mul` reductions on integral types are wrapping; when applied on floating point types the operation associativity is preserved, unless the float mode is set to `Optimized`.</p> {#code_begin|test|vector_reduce#} const std = @import("std"); const expect = std.testing.expect; test "vector @reduce" { const value = @Vector(4, i32){ 1, -1, 1, -1 }; const result = value > @splat(4, @as(i32, 0)); // result is { true, false, true, false }; comptime try expect(@TypeOf(result) == @Vector(4, bool)); const is_all_true = @reduce(.And, result); comptime try expect(@TypeOf(is_all_true) == bool); try expect(is_all_true == false); }` -+ , -+ .arguments = &.{ -+ "comptime op: std.builtin.ReduceOp", -+ "value: anytype", -+ }, -+ }, -+ .{ -+ .name = "@src", -+ .signature = "@src() std.builtin.SourceLocation", -+ .snippet = "@src()", -+ .documentation = -+ \\Returns a `SourceLocation` struct representing the function's name and location in the source code. This must be called in a function.</p> {#code_begin|test|source_location#} const std = @import("std"); const expect = std.testing.expect; test "@src" { try doTheTest(); } fn doTheTest() !void { const src = @src(); try expect(src.line == 9); try expect(src.column == 17); try expect(std.mem.endsWith(u8, src.fn_name, "doTheTest")); try expect(std.mem.endsWith(u8, src.file, "source_location.zig")); }` -+ , -+ .arguments = &.{}, -+ }, -+ .{ -+ .name = "@sqrt", -+ .signature = "@sqrt(value: anytype) @TypeOf(value)", -+ .snippet = "@sqrt(${1:value: anytype})", -+ .documentation = -+ \\Performs the square root of a floating point number. Uses a dedicated hardware instruction when available. -+ \\ -+ \\Supports [Floats](https://ziglang.org/documentation/0.10.0/#Floats) and [Vectors](https://ziglang.org/documentation/0.10.0/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026). -+ , -+ .arguments = &.{ -+ "value: anytype", -+ }, -+ }, -+ .{ -+ .name = "@sin", -+ .signature = "@sin(value: anytype) @TypeOf(value)", -+ .snippet = "@sin(${1:value: anytype})", -+ .documentation = -+ \\Sine trigonometric function on a floating point number. Uses a dedicated hardware instruction when available. -+ \\ -+ \\Supports [Floats](https://ziglang.org/documentation/0.10.0/#Floats) and [Vectors](https://ziglang.org/documentation/0.10.0/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026). -+ , -+ .arguments = &.{ -+ "value: anytype", -+ }, -+ }, -+ .{ -+ .name = "@cos", -+ .signature = "@cos(value: anytype) @TypeOf(value)", -+ .snippet = "@cos(${1:value: anytype})", -+ .documentation = -+ \\Cosine trigonometric function on a floating point number. Uses a dedicated hardware instruction when available. -+ \\ -+ \\Supports [Floats](https://ziglang.org/documentation/0.10.0/#Floats) and [Vectors](https://ziglang.org/documentation/0.10.0/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026). -+ , -+ .arguments = &.{ -+ "value: anytype", -+ }, -+ }, -+ .{ -+ .name = "@tan", -+ .signature = "@tan(value: anytype) @TypeOf(value)", -+ .snippet = "@tan(${1:value: anytype})", -+ .documentation = -+ \\Tangent trigonometric function on a floating point number. Uses a dedicated hardware instruction when available. -+ \\ -+ \\Supports [Floats](https://ziglang.org/documentation/0.10.0/#Floats) and [Vectors](https://ziglang.org/documentation/0.10.0/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026). -+ , -+ .arguments = &.{ -+ "value: anytype", -+ }, -+ }, -+ .{ -+ .name = "@exp", -+ .signature = "@exp(value: anytype) @TypeOf(value)", -+ .snippet = "@exp(${1:value: anytype})", -+ .documentation = -+ \\Base-e exponential function on a floating point number. Uses a dedicated hardware instruction when available. -+ \\ -+ \\Supports [Floats](https://ziglang.org/documentation/0.10.0/#Floats) and [Vectors](https://ziglang.org/documentation/0.10.0/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026). -+ , -+ .arguments = &.{ -+ "value: anytype", -+ }, -+ }, -+ .{ -+ .name = "@exp2", -+ .signature = "@exp2(value: anytype) @TypeOf(value)", -+ .snippet = "@exp2(${1:value: anytype})", -+ .documentation = -+ \\Base-2 exponential function on a floating point number. Uses a dedicated hardware instruction when available. -+ \\ -+ \\Supports [Floats](https://ziglang.org/documentation/0.10.0/#Floats) and [Vectors](https://ziglang.org/documentation/0.10.0/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026). -+ , -+ .arguments = &.{ -+ "value: anytype", -+ }, -+ }, -+ .{ -+ .name = "@log", -+ .signature = "@log(value: anytype) @TypeOf(value)", -+ .snippet = "@log(${1:value: anytype})", -+ .documentation = -+ \\Returns the natural logarithm of a floating point number. Uses a dedicated hardware instruction when available. -+ \\ -+ \\Supports [Floats](https://ziglang.org/documentation/0.10.0/#Floats) and [Vectors](https://ziglang.org/documentation/0.10.0/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026). -+ , -+ .arguments = &.{ -+ "value: anytype", -+ }, -+ }, -+ .{ -+ .name = "@log2", -+ .signature = "@log2(value: anytype) @TypeOf(value)", -+ .snippet = "@log2(${1:value: anytype})", -+ .documentation = -+ \\Returns the logarithm to the base 2 of a floating point number. Uses a dedicated hardware instruction when available. -+ \\ -+ \\Supports [Floats](https://ziglang.org/documentation/0.10.0/#Floats) and [Vectors](https://ziglang.org/documentation/0.10.0/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026). -+ , -+ .arguments = &.{ -+ "value: anytype", -+ }, -+ }, -+ .{ -+ .name = "@log10", -+ .signature = "@log10(value: anytype) @TypeOf(value)", -+ .snippet = "@log10(${1:value: anytype})", -+ .documentation = -+ \\Returns the logarithm to the base 10 of a floating point number. Uses a dedicated hardware instruction when available. -+ \\ -+ \\Supports [Floats](https://ziglang.org/documentation/0.10.0/#Floats) and [Vectors](https://ziglang.org/documentation/0.10.0/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026). -+ , -+ .arguments = &.{ -+ "value: anytype", -+ }, -+ }, -+ .{ -+ .name = "@fabs", -+ .signature = "@fabs(value: anytype) @TypeOf(value)", -+ .snippet = "@fabs(${1:value: anytype})", -+ .documentation = -+ \\Returns the absolute value of a floating point number. Uses a dedicated hardware instruction when available. -+ \\ -+ \\Supports [Floats](https://ziglang.org/documentation/0.10.0/#Floats) and [Vectors](https://ziglang.org/documentation/0.10.0/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026). -+ , -+ .arguments = &.{ -+ "value: anytype", -+ }, -+ }, -+ .{ -+ .name = "@floor", -+ .signature = "@floor(value: anytype) @TypeOf(value)", -+ .snippet = "@floor(${1:value: anytype})", -+ .documentation = -+ \\Returns the largest integral value not greater than the given floating point number. Uses a dedicated hardware instruction when available. -+ \\ -+ \\Supports [Floats](https://ziglang.org/documentation/0.10.0/#Floats) and [Vectors](https://ziglang.org/documentation/0.10.0/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026). -+ , -+ .arguments = &.{ -+ "value: anytype", -+ }, -+ }, -+ .{ -+ .name = "@ceil", -+ .signature = "@ceil(value: anytype) @TypeOf(value)", -+ .snippet = "@ceil(${1:value: anytype})", -+ .documentation = -+ \\Returns the smallest integral value not less than the given floating point number. Uses a dedicated hardware instruction when available. -+ \\ -+ \\Supports [Floats](https://ziglang.org/documentation/0.10.0/#Floats) and [Vectors](https://ziglang.org/documentation/0.10.0/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026). -+ , -+ .arguments = &.{ -+ "value: anytype", -+ }, -+ }, -+ .{ -+ .name = "@trunc", -+ .signature = "@trunc(value: anytype) @TypeOf(value)", -+ .snippet = "@trunc(${1:value: anytype})", -+ .documentation = -+ \\Rounds the given floating point number to an integer, towards zero. Uses a dedicated hardware instruction when available. -+ \\ -+ \\Supports [Floats](https://ziglang.org/documentation/0.10.0/#Floats) and [Vectors](https://ziglang.org/documentation/0.10.0/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026). -+ , -+ .arguments = &.{ -+ "value: anytype", -+ }, -+ }, -+ .{ -+ .name = "@round", -+ .signature = "@round(value: anytype) @TypeOf(value)", -+ .snippet = "@round(${1:value: anytype})", -+ .documentation = -+ \\Rounds the given floating point number to an integer, away from zero. Uses a dedicated hardware instruction when available. -+ \\ -+ \\Supports [Floats](https://ziglang.org/documentation/0.10.0/#Floats) and [Vectors](https://ziglang.org/documentation/0.10.0/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026). -+ , -+ .arguments = &.{ -+ "value: anytype", -+ }, -+ }, -+ .{ -+ .name = "@subWithOverflow", -+ .signature = "@subWithOverflow(comptime T: type, a: T, b: T, result: *T) bool", -+ .snippet = "@subWithOverflow(${1:comptime T: type}, ${2:a: T}, ${3:b: T}, ${4:result: *T})", -+ .documentation = -+ \\Performs `result.* = a - b`. If overflow or underflow occurs, stores the overflowed bits in `result` and returns `true`. If no overflow or underflow occurs, returns `false`. -+ , -+ .arguments = &.{ -+ "comptime T: type", -+ "a: T", -+ "b: T", -+ "result: *T", -+ }, -+ }, -+ .{ -+ .name = "@tagName", -+ .signature = "@tagName(value: anytype) [:0]const u8", -+ .snippet = "@tagName(${1:value: anytype})", -+ .documentation = -+ \\Converts an enum value or union value to a string literal representing the name. -+ \\ -+ \\If the enum is non-exhaustive and the tag value does not map to a name, it invokes safety-checked [Undefined Behavior](https://ziglang.org/documentation/0.10.0/#Undefined-Behavior). -+ , -+ .arguments = &.{ -+ "value: anytype", -+ }, -+ }, -+ .{ -+ .name = "@This", -+ .signature = "@This() type", -+ .snippet = "@This()", -+ .documentation = -+ \\Returns the innermost struct, enum, or union that this function call is inside. This can be useful for an anonymous struct that needs to refer to itself:</p> {#code_begin|test|this_innermost#} const std = @import("std"); const expect = std.testing.expect; test "@This()" { var items = [_]i32{ 1, 2, 3, 4 }; const list = List(i32){ .items = items[0..] }; try expect(list.length() == 4); } fn List(comptime T: type) type { return struct { const Self = @This(); items: []T, fn length(self: Self) usize { return self.items.len; } }; }` -+ \\ -+ \\When `@This()` is used at file scope, it returns a reference to the struct that corresponds to the current file. -+ , -+ .arguments = &.{}, -+ }, -+ .{ -+ .name = "@truncate", -+ .signature = "@truncate(comptime T: type, integer: anytype) T", -+ .snippet = "@truncate(${1:comptime T: type}, ${2:integer: anytype})", -+ .documentation = -+ \\This function truncates bits from an integer type, resulting in a smaller or same-sized integer type. -+ \\ -+ \\This function always truncates the significant bits of the integer, regardless of endianness on the target platform. -+ \\ -+ \\Calling `@truncate` on a number out of range of the destination type is well defined and working code: -+ \\ -+ \\```zig -+ \\const std = @import("std"); -+ \\const expect = std.testing.expect; -+ \\ -+ \\test "integer truncation" { -+ \\ var a: u16 = 0xabcd; -+ \\ var b: u8 = @truncate(u8, a); -+ \\ try expect(b == 0xcd); -+ \\} -+ \\``` -+ \\ -+ \\Use [@intCast](https://ziglang.org/documentation/0.10.0/#intCast) to convert numbers guaranteed to fit the destination type. -+ , -+ .arguments = &.{ -+ "comptime T: type", -+ "integer: anytype", -+ }, -+ }, -+ .{ -+ .name = "@Type", -+ .signature = "@Type(comptime info: std.builtin.Type) type", -+ .snippet = "@Type(${1:comptime info: std.builtin.Type})", -+ .documentation = -+ \\This function is the inverse of [@typeInfo](https://ziglang.org/documentation/0.10.0/#typeInfo). It reifies type information into a `type`. -+ \\ -+ \\It is available for the following types: -+ \\ - `type` -+ \\ - `noreturn` -+ \\ - `void` -+ \\ - `bool` -+ \\ - [Integers](https://ziglang.org/documentation/0.10.0/#Integers) - The maximum bit count for an integer type is `65535`. -+ \\ - [Floats](https://ziglang.org/documentation/0.10.0/#Floats) -+ \\ - [Pointers](https://ziglang.org/documentation/0.10.0/#Pointers) -+ \\ - `comptime_int` -+ \\ - `comptime_float` -+ \\ - `@TypeOf(undefined)` -+ \\ - `@TypeOf(null)` -+ \\ - [Arrays](https://ziglang.org/documentation/0.10.0/#Arrays) -+ \\ - [Optionals](https://ziglang.org/documentation/0.10.0/#Optionals) -+ \\ - [Error Set Type](https://ziglang.org/documentation/0.10.0/#Error-Set-Type) -+ \\ - [Error Union Type](https://ziglang.org/documentation/0.10.0/#Error-Union-Type) -+ \\ - [Vectors](https://ziglang.org/documentation/0.10.0/#Vectors) -+ \\ - [opaque](https://ziglang.org/documentation/0.10.0/#opaque) -+ \\ - [@Frame](https://ziglang.org/documentation/0.10.0/#Frame) -+ \\ - `anyframe` -+ \\ - [struct](https://ziglang.org/documentation/0.10.0/#struct) -+ \\ - [enum](https://ziglang.org/documentation/0.10.0/#enum) -+ \\ - [Enum Literals](https://ziglang.org/documentation/0.10.0/#Enum-Literals) -+ \\ - [union](https://ziglang.org/documentation/0.10.0/#union) -+ \\ -+ \\For these types, `@Type` is not available: -+ \\ - [Functions](https://ziglang.org/documentation/0.10.0/#Functions) -+ \\ - BoundFn -+ , -+ .arguments = &.{ -+ "comptime info: std.builtin.Type", -+ }, -+ }, -+ .{ -+ .name = "@typeInfo", -+ .signature = "@typeInfo(comptime T: type) std.builtin.Type", -+ .snippet = "@typeInfo(${1:comptime T: type})", -+ .documentation = -+ \\Provides type reflection. -+ \\ -+ \\Type information of [structs](https://ziglang.org/documentation/0.10.0/#struct), [unions](https://ziglang.org/documentation/0.10.0/#union), [enums](https://ziglang.org/documentation/0.10.0/#enum), and [error sets](https://ziglang.org/documentation/0.10.0/#Error-Set-Type) has fields which are guaranteed to be in the same order as appearance in the source file. -+ \\ -+ \\Type information of [structs](https://ziglang.org/documentation/0.10.0/#struct), [unions](https://ziglang.org/documentation/0.10.0/#union), [enums](https://ziglang.org/documentation/0.10.0/#enum), and [opaques](https://ziglang.org/documentation/0.10.0/#opaque) has declarations, which are also guaranteed to be in the same order as appearance in the source file. -+ , -+ .arguments = &.{ -+ "comptime T: type", -+ }, -+ }, -+ .{ -+ .name = "@typeName", -+ .signature = "@typeName(T: type) *const [N:0]u8", -+ .snippet = "@typeName(${1:T: type})", -+ .documentation = -+ \\This function returns the string representation of a type, as an array. It is equivalent to a string literal of the type name. The returned type name is fully qualified with the parent namespace included as part of the type name with a series of dots. -+ , -+ .arguments = &.{ -+ "T: type", -+ }, -+ }, -+ .{ -+ .name = "@TypeOf", -+ .signature = "@TypeOf(...) type", -+ .snippet = "@TypeOf(${1:...})", -+ .documentation = -+ \\`@TypeOf` is a special builtin function that takes any (nonzero) number of expressions as parameters and returns the type of the result, using [Peer Type Resolution](https://ziglang.org/documentation/0.10.0/#Peer-Type-Resolution). -+ \\ -+ \\The expressions are evaluated, however they are guaranteed to have no *runtime* side-effects:</p> {#code_begin|test|no_runtime_side_effects#} const std = @import("std"); const expect = std.testing.expect; test "no runtime side effects" { var data: i32 = 0; const T = @TypeOf(foo(i32, &data)); comptime try expect(T == i32); try expect(data == 0); } fn foo(comptime T: type, ptr: *T) T { ptr.* += 1; return ptr.*; }` -+ , -+ .arguments = &.{ -+ "...", -+ }, -+ }, -+ .{ -+ .name = "@unionInit", -+ .signature = "@unionInit(comptime Union: type, comptime active_field_name: []const u8, init_expr) Union", -+ .snippet = "@unionInit(${1:comptime Union: type}, ${2:comptime active_field_name: []const u8}, ${3:init_expr})", -+ .documentation = -+ \\This is the same thing as [union](https://ziglang.org/documentation/0.10.0/#union) initialization syntax, except that the field name is a [comptime](https://ziglang.org/documentation/0.10.0/#comptime)-known value rather than an identifier token. -+ \\ -+ \\`@unionInit` forwards its [result location](https://ziglang.org/documentation/0.10.0/#Result-Location-Semantics) to `init_expr`. -+ , -+ .arguments = &.{ -+ "comptime Union: type", -+ "comptime active_field_name: []const u8", -+ "init_expr", -+ }, -+ }, -+ .{ -+ .name = "@Vector", -+ .signature = "@Vector(len: comptime_int, Element: type) type", -+ .snippet = "@Vector(${1:len: comptime_int}, ${2:Element: type})", -+ .documentation = -+ \\Creates [Vectors](https://ziglang.org/documentation/0.10.0/#Vectors). -+ , -+ .arguments = &.{ -+ "len: comptime_int", -+ "Element: type", -+ }, -+ }, -+}; -diff --git a/src/data/0.9.1.zig b/src/data/0.9.1.zig -new file mode 100644 -index 00000000..da1eddd5 ---- /dev/null -+++ b/src/data/0.9.1.zig -@@ -0,0 +1,1777 @@ -+const Builtin = struct { -+ name: []const u8, -+ signature: []const u8, -+ snippet: []const u8, -+ documentation: []const u8, -+ arguments: []const []const u8, -+}; -+ -+pub const builtins = [_]Builtin{ -+ .{ -+ .name = "@addWithOverflow", -+ .signature = "@addWithOverflow(comptime T: type, a: T, b: T, result: *T) bool", -+ .snippet = "@addWithOverflow(${1:comptime T: type}, ${2:a: T}, ${3:b: T}, ${4:result: *T})", -+ .documentation = -+ \\Performs `result.* = a + b`. If overflow or underflow occurs, stores the overflowed bits in `result` and returns `true`. If no overflow or underflow occurs, returns `false`. -+ , -+ .arguments = &.{ -+ "comptime T: type", -+ "a: T", -+ "b: T", -+ "result: *T", -+ }, -+ }, -+ .{ -+ .name = "@alignCast", -+ .signature = "@alignCast(comptime alignment: u29, ptr: anytype) anytype", -+ .snippet = "@alignCast(${1:comptime alignment: u29}, ${2:ptr: anytype})", -+ .documentation = -+ \\`ptr` can be `*T`, `fn()`, `?*T`, `?fn()`, or `[]T`. It returns the same type as `ptr` except with the alignment adjusted to the new value. -+ \\ -+ \\A [pointer alignment safety check](https://ziglang.org/documentation/0.9.1/#Incorrect-Pointer-Alignment) is added to the generated code to make sure the pointer is aligned as promised. -+ , -+ .arguments = &.{ -+ "comptime alignment: u29", -+ "ptr: anytype", -+ }, -+ }, -+ .{ -+ .name = "@alignOf", -+ .signature = "@alignOf(comptime T: type) comptime_int", -+ .snippet = "@alignOf(${1:comptime T: type})", -+ .documentation = -+ \\This function returns the number of bytes that this type should be aligned to for the current target to match the C ABI. When the child type of a pointer has this alignment, the alignment can be omitted from the type. -+ \\ -+ \\```zig -+ \\const expect = @import("std").debug.assert; -+ \\comptime { -+ \\ assert(*u32 == *align(@alignOf(u32)) u32); -+ \\} -+ \\``` -+ \\ -+ \\The result is a target-specific compile time constant. It is guaranteed to be less than or equal to [@sizeOf(T)](https://ziglang.org/documentation/0.9.1/#@sizeOf). -+ , -+ .arguments = &.{ -+ "comptime T: type", -+ }, -+ }, -+ .{ -+ .name = "@as", -+ .signature = "@as(comptime T: type, expression) T", -+ .snippet = "@as(${1:comptime T: type}, ${2:expression})", -+ .documentation = -+ \\Performs [Type Coercion](https://ziglang.org/documentation/0.9.1/#Type-Coercion). This cast is allowed when the conversion is unambiguous and safe, and is the preferred way to convert between types, whenever possible. -+ , -+ .arguments = &.{ -+ "comptime T: type", -+ "expression", -+ }, -+ }, -+ .{ -+ .name = "@asyncCall", -+ .signature = "@asyncCall(frame_buffer: []align(@alignOf(@Frame(anyAsyncFunction))) u8, result_ptr, function_ptr, args: anytype) anyframe->T", -+ .snippet = "@asyncCall(${1:frame_buffer: []align(@alignOf(@Frame(anyAsyncFunction))) u8}, ${2:result_ptr}, ${3:function_ptr}, ${4:args: anytype})", -+ .documentation = -+ \\`@asyncCall` performs an `async` call on a function pointer, which may or may not be an [async function](https://ziglang.org/documentation/0.9.1/#Async-Functions). -+ \\ -+ \\The provided `frame_buffer` must be large enough to fit the entire function frame. This size can be determined with [@frameSize](https://ziglang.org/documentation/0.9.1/#frameSize). To provide a too-small buffer invokes safety-checked [Undefined Behavior](https://ziglang.org/documentation/0.9.1/#Undefined-Behavior). -+ \\ -+ \\`result_ptr` is optional ([null](https://ziglang.org/documentation/0.9.1/#null) may be provided). If provided, the function call will write its result directly to the result pointer, which will be available to read after [await](https://ziglang.org/documentation/0.9.1/#Async-and-Await) completes. Any result location provided to `await` will copy the result from `result_ptr`.</p> {#code_begin|test|async_struct_field_fn_pointer#} const std = @import("std"); const expect = std.testing.expect; test "async fn pointer in a struct field" { var data: i32 = 1; const Foo = struct { bar: fn (*i32) callconv(.Async) void, }; var foo = Foo{ .bar = func }; var bytes: [64]u8 align(@alignOf(@Frame(func))) = undefined; const f = @asyncCall(&bytes, {}, foo.bar, .{&data}); try expect(data == 2); resume f; try expect(data == 4); } fn func(y: *i32) void { defer y.* += 2; y.* += 1; suspend {} }` -+ , -+ .arguments = &.{ -+ "frame_buffer: []align(@alignOf(@Frame(anyAsyncFunction))) u8", -+ "result_ptr", -+ "function_ptr", -+ "args: anytype", -+ }, -+ }, -+ .{ -+ .name = "@atomicLoad", -+ .signature = "@atomicLoad(comptime T: type, ptr: *const T, comptime ordering: builtin.AtomicOrder) T", -+ .snippet = "@atomicLoad(${1:comptime T: type}, ${2:ptr: *const T}, ${3:comptime ordering: builtin.AtomicOrder})", -+ .documentation = -+ \\This builtin function atomically dereferences a pointer and returns the value. -+ \\ -+ \\`T` must be a pointer, a `bool`, a float, an integer or an enum. -+ , -+ .arguments = &.{ -+ "comptime T: type", -+ "ptr: *const T", -+ "comptime ordering: builtin.AtomicOrder", -+ }, -+ }, -+ .{ -+ .name = "@atomicRmw", -+ .signature = "@atomicRmw(comptime T: type, ptr: *T, comptime op: builtin.AtomicRmwOp, operand: T, comptime ordering: builtin.AtomicOrder) T", -+ .snippet = "@atomicRmw(${1:comptime T: type}, ${2:ptr: *T}, ${3:comptime op: builtin.AtomicRmwOp}, ${4:operand: T}, ${5:comptime ordering: builtin.AtomicOrder})", -+ .documentation = -+ \\This builtin function atomically modifies memory and then returns the previous value. -+ \\ -+ \\`T` must be a pointer, a `bool`, a float, an integer or an enum. -+ \\ -+ \\Supported operations: -+ \\ - `.Xchg` - stores the operand unmodified. Supports enums, integers and floats. -+ \\ - `.Add` - for integers, twos complement wraparound addition. Also supports [Floats](https://ziglang.org/documentation/0.9.1/#Floats). -+ \\ - `.Sub` - for integers, twos complement wraparound subtraction. Also supports [Floats](https://ziglang.org/documentation/0.9.1/#Floats). -+ \\ - `.And` - bitwise and -+ \\ - `.Nand` - bitwise nand -+ \\ - `.Or` - bitwise or -+ \\ - `.Xor` - bitwise xor -+ \\ - `.Max` - stores the operand if it is larger. Supports integers and floats. -+ \\ - `.Min` - stores the operand if it is smaller. Supports integers and floats. -+ , -+ .arguments = &.{ -+ "comptime T: type", -+ "ptr: *T", -+ "comptime op: builtin.AtomicRmwOp", -+ "operand: T", -+ "comptime ordering: builtin.AtomicOrder", -+ }, -+ }, -+ .{ -+ .name = "@atomicStore", -+ .signature = "@atomicStore(comptime T: type, ptr: *T, value: T, comptime ordering: builtin.AtomicOrder) void", -+ .snippet = "@atomicStore(${1:comptime T: type}, ${2:ptr: *T}, ${3:value: T}, ${4:comptime ordering: builtin.AtomicOrder})", -+ .documentation = -+ \\This builtin function atomically stores a value. -+ \\ -+ \\`T` must be a pointer, a `bool`, a float, an integer or an enum. -+ , -+ .arguments = &.{ -+ "comptime T: type", -+ "ptr: *T", -+ "value: T", -+ "comptime ordering: builtin.AtomicOrder", -+ }, -+ }, -+ .{ -+ .name = "@bitCast", -+ .signature = "@bitCast(comptime DestType: type, value: anytype) DestType", -+ .snippet = "@bitCast(${1:comptime DestType: type}, ${2:value: anytype})", -+ .documentation = -+ \\Converts a value of one type to another type. -+ \\ -+ \\Asserts that `@sizeOf(@TypeOf(value)) == @sizeOf(DestType)`. -+ \\ -+ \\Asserts that `@typeInfo(DestType) != .Pointer`. Use `@ptrCast` or `@intToPtr` if you need this. -+ \\ -+ \\Can be used for these things for example: -+ \\ - Convert `f32` to `u32` bits -+ \\ - Convert `i32` to `u32` preserving twos complement -+ \\ -+ \\Works at compile-time if `value` is known at compile time. It's a compile error to bitcast a struct to a scalar type of the same size since structs have undefined layout. However if the struct is packed then it works. -+ , -+ .arguments = &.{ -+ "comptime DestType: type", -+ "value: anytype", -+ }, -+ }, -+ .{ -+ .name = "@bitOffsetOf", -+ .signature = "@bitOffsetOf(comptime T: type, comptime field_name: []const u8) comptime_int", -+ .snippet = "@bitOffsetOf(${1:comptime T: type}, ${2:comptime field_name: []const u8})", -+ .documentation = -+ \\Returns the bit offset of a field relative to its containing struct. -+ \\ -+ \\For non [packed structs](https://ziglang.org/documentation/0.9.1/#packed-struct), this will always be divisible by `8`. For packed structs, non-byte-aligned fields will share a byte offset, but they will have different bit offsets. -+ , -+ .arguments = &.{ -+ "comptime T: type", -+ "comptime field_name: []const u8", -+ }, -+ }, -+ .{ -+ .name = "@boolToInt", -+ .signature = "@boolToInt(value: bool) u1", -+ .snippet = "@boolToInt(${1:value: bool})", -+ .documentation = -+ \\Converts `true` to `@as(u1, 1)` and `false` to `@as(u1, 0)`. -+ \\ -+ \\If the value is known at compile-time, the return type is `comptime_int` instead of `u1`. -+ , -+ .arguments = &.{ -+ "value: bool", -+ }, -+ }, -+ .{ -+ .name = "@bitSizeOf", -+ .signature = "@bitSizeOf(comptime T: type) comptime_int", -+ .snippet = "@bitSizeOf(${1:comptime T: type})", -+ .documentation = -+ \\This function returns the number of bits it takes to store `T` in memory if the type were a field in a packed struct/union. The result is a target-specific compile time constant. -+ \\ -+ \\This function measures the size at runtime. For types that are disallowed at runtime, such as `comptime_int` and `type`, the result is `0`. -+ , -+ .arguments = &.{ -+ "comptime T: type", -+ }, -+ }, -+ .{ -+ .name = "@breakpoint", -+ .signature = "@breakpoint()", -+ .snippet = "@breakpoint()", -+ .documentation = -+ \\This function inserts a platform-specific debug trap instruction which causes debuggers to break there. -+ \\ -+ \\This function is only valid within function scope. -+ , -+ .arguments = &.{}, -+ }, -+ .{ -+ .name = "@mulAdd", -+ .signature = "@mulAdd(comptime T: type, a: T, b: T, c: T) T", -+ .snippet = "@mulAdd(${1:comptime T: type}, ${2:a: T}, ${3:b: T}, ${4:c: T})", -+ .documentation = -+ \\Fused multiply add, similar to `(a * b) + c`, except only rounds once, and is thus more accurate. -+ \\ -+ \\Supports Floats and Vectors of floats. -+ , -+ .arguments = &.{ -+ "comptime T: type", -+ "a: T", -+ "b: T", -+ "c: T", -+ }, -+ }, -+ .{ -+ .name = "@byteSwap", -+ .signature = "@byteSwap(comptime T: type, operand: T) T", -+ .snippet = "@byteSwap(${1:comptime T: type}, ${2:operand: T})", -+ .documentation = -+ \\`T` must be an integer type with bit count evenly divisible by 8. -+ \\ -+ \\`operand` may be an [integer](https://ziglang.org/documentation/0.9.1/#Integers) or [vector](https://ziglang.org/documentation/0.9.1/#Vectors). -+ \\ -+ \\Swaps the byte order of the integer. This converts a big endian integer to a little endian integer, and converts a little endian integer to a big endian integer. -+ \\ -+ \\Note that for the purposes of memory layout with respect to endianness, the integer type should be related to the number of bytes reported by [@sizeOf](https://ziglang.org/documentation/0.9.1/#sizeOf) bytes. This is demonstrated with `u24`. `@sizeOf(u24) == 4`, which means that a `u24` stored in memory takes 4 bytes, and those 4 bytes are what are swapped on a little vs big endian system. On the other hand, if `T` is specified to be `u24`, then only 3 bytes are reversed. -+ , -+ .arguments = &.{ -+ "comptime T: type", -+ "operand: T", -+ }, -+ }, -+ .{ -+ .name = "@bitReverse", -+ .signature = "@bitReverse(comptime T: type, integer: T) T", -+ .snippet = "@bitReverse(${1:comptime T: type}, ${2:integer: T})", -+ .documentation = -+ \\`T` accepts any integer type. -+ \\ -+ \\Reverses the bitpattern of an integer value, including the sign bit if applicable. -+ \\ -+ \\For example 0b10110110 (`u8 = 182`, `i8 = -74`) becomes 0b01101101 (`u8 = 109`, `i8 = 109`). -+ , -+ .arguments = &.{ -+ "comptime T: type", -+ "integer: T", -+ }, -+ }, -+ .{ -+ .name = "@offsetOf", -+ .signature = "@offsetOf(comptime T: type, comptime field_name: []const u8) comptime_int", -+ .snippet = "@offsetOf(${1:comptime T: type}, ${2:comptime field_name: []const u8})", -+ .documentation = -+ \\Returns the byte offset of a field relative to its containing struct. -+ , -+ .arguments = &.{ -+ "comptime T: type", -+ "comptime field_name: []const u8", -+ }, -+ }, -+ .{ -+ .name = "@call", -+ .signature = "@call(options: std.builtin.CallOptions, function: anytype, args: anytype) anytype", -+ .snippet = "@call(${1:options: std.builtin.CallOptions}, ${2:function: anytype}, ${3:args: anytype})", -+ .documentation = -+ \\Calls a function, in the same way that invoking an expression with parentheses does: -+ \\ -+ \\```zig -+ \\const expect = @import("std").testing.expect; -+ \\ -+ \\test "noinline function call" { -+ \\ try expect(@call(.{}, add, .{3, 9}) == 12); -+ \\} -+ \\ -+ \\fn add(a: i32, b: i32) i32 { -+ \\ return a + b; -+ \\} -+ \\``` -+ \\ -+ \\`@call` allows more flexibility than normal function call syntax does. The `CallOptions` struct is reproduced here:</p> {#syntax_block|zig|builtin.CallOptions struct#} pub const CallOptions = struct { modifier: Modifier = .auto, /// Only valid when `Modifier` is `Modifier.async_kw`. stack: ?[]align(std.Target.stack_align) u8 = null, pub const Modifier = enum { /// Equivalent to function call syntax. auto, /// Equivalent to async keyword used with function call syntax. async_kw, /// Prevents tail call optimization. This guarantees that the return /// address will point to the callsite, as opposed to the callsite's /// callsite. If the call is otherwise required to be tail-called /// or inlined, a compile error is emitted instead. never_tail, /// Guarantees that the call will not be inlined. If the call is /// otherwise required to be inlined, a compile error is emitted instead. never_inline, /// Asserts that the function call will not suspend. This allows a /// non-async function to call an async function. no_async, /// Guarantees that the call will be generated with tail call optimization. /// If this is not possible, a compile error is emitted instead. always_tail, /// Guarantees that the call will inlined at the callsite. /// If this is not possible, a compile error is emitted instead. always_inline, /// Evaluates the call at compile-time. If the call cannot be completed at /// compile-time, a compile error is emitted instead. compile_time, }; }; {#end_syntax_block#} -+ , -+ .arguments = &.{ -+ "options: std.builtin.CallOptions", -+ "function: anytype", -+ "args: anytype", -+ }, -+ }, -+ .{ -+ .name = "@cDefine", -+ .signature = "@cDefine(comptime name: []u8, value)", -+ .snippet = "@cDefine(${1:comptime name: []u8}, ${2:value})", -+ .documentation = -+ \\This function can only occur inside `@cImport`. -+ \\ -+ \\This appends `#define $name $value` to the `@cImport` temporary buffer. -+ \\ -+ \\To define without a value, like this:`#define _GNU_SOURCE` -+ \\ -+ \\Use the void value, like this: -+ \\ -+ \\```zig -+ \\@cDefine("_GNU_SOURCE", {}) -+ \\``` -+ , -+ .arguments = &.{ -+ "comptime name: []u8", -+ "value", -+ }, -+ }, -+ .{ -+ .name = "@cImport", -+ .signature = "@cImport(expression) type", -+ .snippet = "@cImport(${1:expression})", -+ .documentation = -+ \\This function parses C code and imports the functions, types, variables, and compatible macro definitions into a new empty struct type, and then returns that type. -+ \\ -+ \\`expression` is interpreted at compile time. The builtin functions `@cInclude`, `@cDefine`, and `@cUndef` work within this expression, appending to a temporary buffer which is then parsed as C code. -+ \\ -+ \\Usually you should only have one `@cImport` in your entire application, because it saves the compiler from invoking clang multiple times, and prevents inline functions from being duplicated. -+ \\ -+ \\Reasons for having multiple `@cImport` expressions would be: -+ \\ - To avoid a symbol collision, for example if foo.h and bar.h both `#define CONNECTION_COUNT` -+ \\ - To analyze the C code with different preprocessor defines -+ , -+ .arguments = &.{ -+ "expression", -+ }, -+ }, -+ .{ -+ .name = "@cInclude", -+ .signature = "@cInclude(comptime path: []u8)", -+ .snippet = "@cInclude(${1:comptime path: []u8})", -+ .documentation = -+ \\This function can only occur inside `@cImport`. -+ \\ -+ \\This appends `#include <$path>\n` to the `c_import` temporary buffer. -+ , -+ .arguments = &.{ -+ "comptime path: []u8", -+ }, -+ }, -+ .{ -+ .name = "@clz", -+ .signature = "@clz(comptime T: type, operand: T)", -+ .snippet = "@clz(${1:comptime T: type}, ${2:operand: T})", -+ .documentation = -+ \\`T` must be an integer type. -+ \\ -+ \\`operand` may be an [integer](https://ziglang.org/documentation/0.9.1/#Integers) or [vector](https://ziglang.org/documentation/0.9.1/#Vectors). -+ \\ -+ \\This function counts the number of most-significant (leading in a big-Endian sense) zeroes in an integer. -+ \\ -+ \\If `operand` is a [comptime](https://ziglang.org/documentation/0.9.1/#comptime)-known integer, the return type is `comptime_int`. Otherwise, the return type is an unsigned integer or vector of unsigned integers with the minimum number of bits that can represent the bit count of the integer type. -+ \\ -+ \\If `operand` is zero, `@clz` returns the bit width of integer type `T`. -+ , -+ .arguments = &.{ -+ "comptime T: type", -+ "operand: T", -+ }, -+ }, -+ .{ -+ .name = "@cmpxchgStrong", -+ .signature = "@cmpxchgStrong(comptime T: type, ptr: *T, expected_value: T, new_value: T, success_order: AtomicOrder, fail_order: AtomicOrder) ?T", -+ .snippet = "@cmpxchgStrong(${1:comptime T: type}, ${2:ptr: *T}, ${3:expected_value: T}, ${4:new_value: T}, ${5:success_order: AtomicOrder}, ${6:fail_order: AtomicOrder})", -+ .documentation = -+ \\This function performs a strong atomic compare exchange operation. It's the equivalent of this code, except atomic: -+ \\ -+ \\```zig -+ \\fn cmpxchgStrongButNotAtomic(comptime T: type, ptr: *T, expected_value: T, new_value: T) ?T { -+ \\ const old_value = ptr.*; -+ \\ if (old_value == expected_value) { -+ \\ ptr.* = new_value; -+ \\ return null; -+ \\ } else { -+ \\ return old_value; -+ \\ } -+ \\} -+ \\``` -+ \\ -+ \\If you are using cmpxchg in a loop, [@cmpxchgWeak](https://ziglang.org/documentation/0.9.1/#cmpxchgWeak) is the better choice, because it can be implemented more efficiently in machine instructions. -+ \\ -+ \\`T` must be a pointer, a `bool`, a float, an integer or an enum. -+ \\ -+ \\`@typeInfo(@TypeOf(ptr)).Pointer.alignment` must be `>= @sizeOf(T).` -+ , -+ .arguments = &.{ -+ "comptime T: type", -+ "ptr: *T", -+ "expected_value: T", -+ "new_value: T", -+ "success_order: AtomicOrder", -+ "fail_order: AtomicOrder", -+ }, -+ }, -+ .{ -+ .name = "@cmpxchgWeak", -+ .signature = "@cmpxchgWeak(comptime T: type, ptr: *T, expected_value: T, new_value: T, success_order: AtomicOrder, fail_order: AtomicOrder) ?T", -+ .snippet = "@cmpxchgWeak(${1:comptime T: type}, ${2:ptr: *T}, ${3:expected_value: T}, ${4:new_value: T}, ${5:success_order: AtomicOrder}, ${6:fail_order: AtomicOrder})", -+ .documentation = -+ \\This function performs a weak atomic compare exchange operation. It's the equivalent of this code, except atomic:</p> {#syntax_block|zig|cmpxchgWeakButNotAtomic#} fn cmpxchgWeakButNotAtomic(comptime T: type, ptr: *T, expected_value: T, new_value: T) ?T { const old_value = ptr.*; if (old_value == expected_value and usuallyTrueButSometimesFalse()) { ptr.* = new_value; return null; } else { return old_value; } } {#end_syntax_block#} -+ \\ -+ \\If you are using cmpxchg in a loop, the sporadic failure will be no problem, and `cmpxchgWeak` is the better choice, because it can be implemented more efficiently in machine instructions. However if you need a stronger guarantee, use [@cmpxchgStrong](https://ziglang.org/documentation/0.9.1/#cmpxchgStrong). -+ \\ -+ \\`T` must be a pointer, a `bool`, a float, an integer or an enum. -+ \\ -+ \\`@typeInfo(@TypeOf(ptr)).Pointer.alignment` must be `>= @sizeOf(T).` -+ , -+ .arguments = &.{ -+ "comptime T: type", -+ "ptr: *T", -+ "expected_value: T", -+ "new_value: T", -+ "success_order: AtomicOrder", -+ "fail_order: AtomicOrder", -+ }, -+ }, -+ .{ -+ .name = "@compileError", -+ .signature = "@compileError(comptime msg: []u8)", -+ .snippet = "@compileError(${1:comptime msg: []u8})", -+ .documentation = -+ \\This function, when semantically analyzed, causes a compile error with the message `msg`. -+ \\ -+ \\There are several ways that code avoids being semantically checked, such as using `if` or `switch` with compile time constants, and `comptime` functions. -+ , -+ .arguments = &.{ -+ "comptime msg: []u8", -+ }, -+ }, -+ .{ -+ .name = "@compileLog", -+ .signature = "@compileLog(args: ...)", -+ .snippet = "@compileLog(${1:args: ...})", -+ .documentation = -+ \\This function prints the arguments passed to it at compile-time. -+ \\ -+ \\To prevent accidentally leaving compile log statements in a codebase, a compilation error is added to the build, pointing to the compile log statement. This error prevents code from being generated, but does not otherwise interfere with analysis. -+ \\ -+ \\This function can be used to do "printf debugging" on compile-time executing code. -+ \\ -+ \\```zig -+ \\const print = @import("std").debug.print; -+ \\ -+ \\const num1 = blk: { -+ \\ var val1: i32 = 99; -+ \\ @compileLog("comptime val1 = ", val1); -+ \\ val1 = val1 + 1; -+ \\ break :blk val1; -+ \\}; -+ \\ -+ \\test "main" { -+ \\ @compileLog("comptime in main"); -+ \\ -+ \\ print("Runtime in main, num1 = {}.\n", .{num1}); -+ \\} -+ \\``` -+ \\ -+ \\will output: -+ \\ -+ \\If all `@compileLog` calls are removed or not encountered by analysis, the program compiles successfully and the generated executable prints:</p> {#code_begin|test|without_compileLog#} const print = @import("std").debug.print; const num1 = blk: { var val1: i32 = 99; val1 = val1 + 1; break :blk val1; }; test "main" { print("Runtime in main, num1 = {}.\n", .{num1}); }` -+ , -+ .arguments = &.{ -+ "args: ...", -+ }, -+ }, -+ .{ -+ .name = "@ctz", -+ .signature = "@ctz(comptime T: type, operand: T)", -+ .snippet = "@ctz(${1:comptime T: type}, ${2:operand: T})", -+ .documentation = -+ \\`T` must be an integer type. -+ \\ -+ \\`operand` may be an [integer](https://ziglang.org/documentation/0.9.1/#Integers) or [vector](https://ziglang.org/documentation/0.9.1/#Vectors). -+ \\ -+ \\This function counts the number of least-significant (trailing in a big-Endian sense) zeroes in an integer. -+ \\ -+ \\If `operand` is a [comptime](https://ziglang.org/documentation/0.9.1/#comptime)-known integer, the return type is `comptime_int`. Otherwise, the return type is an unsigned integer or vector of unsigned integers with the minimum number of bits that can represent the bit count of the integer type. -+ \\ -+ \\If `operand` is zero, `@ctz` returns the bit width of integer type `T`. -+ , -+ .arguments = &.{ -+ "comptime T: type", -+ "operand: T", -+ }, -+ }, -+ .{ -+ .name = "@cUndef", -+ .signature = "@cUndef(comptime name: []u8)", -+ .snippet = "@cUndef(${1:comptime name: []u8})", -+ .documentation = -+ \\This function can only occur inside `@cImport`. -+ \\ -+ \\This appends `#undef $name` to the `@cImport` temporary buffer. -+ , -+ .arguments = &.{ -+ "comptime name: []u8", -+ }, -+ }, -+ .{ -+ .name = "@divExact", -+ .signature = "@divExact(numerator: T, denominator: T) T", -+ .snippet = "@divExact(${1:numerator: T}, ${2:denominator: T})", -+ .documentation = -+ \\Exact division. Caller guarantees `denominator != 0` and `@divTrunc(numerator, denominator) * denominator == numerator`. -+ \\ - `@divExact(6, 3) == 2` -+ \\ - `@divExact(a, b) * b == a` -+ \\ -+ \\For a function that returns a possible error code, use `@import("std").math.divExact`. -+ , -+ .arguments = &.{ -+ "numerator: T", -+ "denominator: T", -+ }, -+ }, -+ .{ -+ .name = "@divFloor", -+ .signature = "@divFloor(numerator: T, denominator: T) T", -+ .snippet = "@divFloor(${1:numerator: T}, ${2:denominator: T})", -+ .documentation = -+ \\Floored division. Rounds toward negative infinity. For unsigned integers it is the same as `numerator / denominator`. Caller guarantees `denominator != 0` and `!(@typeInfo(T) == .Int and T.is_signed and numerator == std.math.minInt(T) and denominator == -1)`. -+ \\ - `@divFloor(-5, 3) == -2` -+ \\ - `(@divFloor(a, b) * b) + @mod(a, b) == a` -+ \\ -+ \\For a function that returns a possible error code, use `@import("std").math.divFloor`. -+ , -+ .arguments = &.{ -+ "numerator: T", -+ "denominator: T", -+ }, -+ }, -+ .{ -+ .name = "@divTrunc", -+ .signature = "@divTrunc(numerator: T, denominator: T) T", -+ .snippet = "@divTrunc(${1:numerator: T}, ${2:denominator: T})", -+ .documentation = -+ \\Truncated division. Rounds toward zero. For unsigned integers it is the same as `numerator / denominator`. Caller guarantees `denominator != 0` and `!(@typeInfo(T) == .Int and T.is_signed and numerator == std.math.minInt(T) and denominator == -1)`. -+ \\ - `@divTrunc(-5, 3) == -1` -+ \\ - `(@divTrunc(a, b) * b) + @rem(a, b) == a` -+ \\ -+ \\For a function that returns a possible error code, use `@import("std").math.divTrunc`. -+ , -+ .arguments = &.{ -+ "numerator: T", -+ "denominator: T", -+ }, -+ }, -+ .{ -+ .name = "@embedFile", -+ .signature = "@embedFile(comptime path: []const u8) *const [N:0]u8", -+ .snippet = "@embedFile(${1:comptime path: []const u8})", -+ .documentation = -+ \\This function returns a compile time constant pointer to null-terminated, fixed-size array with length equal to the byte count of the file given by `path`. The contents of the array are the contents of the file. This is equivalent to a [string literal](https://ziglang.org/documentation/0.9.1/#String-Literals-and-Unicode-Code-Point-Literals) with the file contents. -+ \\ -+ \\`path` is absolute or relative to the current file, just like `@import`. -+ , -+ .arguments = &.{ -+ "comptime path: []const u8", -+ }, -+ }, -+ .{ -+ .name = "@enumToInt", -+ .signature = "@enumToInt(enum_or_tagged_union: anytype) anytype", -+ .snippet = "@enumToInt(${1:enum_or_tagged_union: anytype})", -+ .documentation = -+ \\Converts an enumeration value into its integer tag type. When a tagged union is passed, the tag value is used as the enumeration value. -+ \\ -+ \\If there is only one possible enum value, the result is a `comptime_int` known at [comptime](https://ziglang.org/documentation/0.9.1/#comptime). -+ , -+ .arguments = &.{ -+ "enum_or_tagged_union: anytype", -+ }, -+ }, -+ .{ -+ .name = "@errorName", -+ .signature = "@errorName(err: anyerror) [:0]const u8", -+ .snippet = "@errorName(${1:err: anyerror})", -+ .documentation = -+ \\This function returns the string representation of an error. The string representation of `error.OutOfMem` is `"OutOfMem"`. -+ \\ -+ \\If there are no calls to `@errorName` in an entire application, or all calls have a compile-time known value for `err`, then no error name table will be generated. -+ , -+ .arguments = &.{ -+ "err: anyerror", -+ }, -+ }, -+ .{ -+ .name = "@errorReturnTrace", -+ .signature = "@errorReturnTrace() ?*builtin.StackTrace", -+ .snippet = "@errorReturnTrace()", -+ .documentation = -+ \\If the binary is built with error return tracing, and this function is invoked in a function that calls a function with an error or error union return type, returns a stack trace object. Otherwise returns [null](https://ziglang.org/documentation/0.9.1/#null). -+ , -+ .arguments = &.{}, -+ }, -+ .{ -+ .name = "@errorToInt", -+ .signature = "@errorToInt(err: anytype) std.meta.Int(.unsigned, @sizeOf(anyerror) * 8)", -+ .snippet = "@errorToInt(${1:err: anytype})", -+ .documentation = -+ \\Supports the following types: -+ \\ - [The Global Error Set](https://ziglang.org/documentation/0.9.1/#The-Global-Error-Set) -+ \\ - [Error Set Type](https://ziglang.org/documentation/0.9.1/#Error-Set-Type) -+ \\ - [Error Union Type](https://ziglang.org/documentation/0.9.1/#Error-Union-Type) -+ \\ -+ \\Converts an error to the integer representation of an error. -+ \\ -+ \\It is generally recommended to avoid this cast, as the integer representation of an error is not stable across source code changes. -+ , -+ .arguments = &.{ -+ "err: anytype", -+ }, -+ }, -+ .{ -+ .name = "@errSetCast", -+ .signature = "@errSetCast(comptime T: DestType, value: anytype) DestType", -+ .snippet = "@errSetCast(${1:comptime T: DestType}, ${2:value: anytype})", -+ .documentation = -+ \\Converts an error value from one error set to another error set. Attempting to convert an error which is not in the destination error set results in safety-protected [Undefined Behavior](https://ziglang.org/documentation/0.9.1/#Undefined-Behavior). -+ , -+ .arguments = &.{ -+ "comptime T: DestType", -+ "value: anytype", -+ }, -+ }, -+ .{ -+ .name = "@export", -+ .signature = "@export(declaration, comptime options: std.builtin.ExportOptions) void", -+ .snippet = "@export(${1:declaration}, ${2:comptime options: std.builtin.ExportOptions})", -+ .documentation = -+ \\Creates a symbol in the output object file. -+ \\ -+ \\`declaration` must be one of two things: -+ \\ - An identifier (`x`) identifying a [function](https://ziglang.org/documentation/0.9.1/#Functions) or a [variable](https://ziglang.org/documentation/0.9.1/#Container-Level-Variables). -+ \\ - Field access (`x.y`) looking up a [function](https://ziglang.org/documentation/0.9.1/#Functions) or a [variable](https://ziglang.org/documentation/0.9.1/#Container-Level-Variables). -+ \\ -+ \\This builtin can be called from a [comptime](https://ziglang.org/documentation/0.9.1/#comptime) block to conditionally export symbols. When `declaration` is a function with the C calling convention and `options.linkage` is `Strong`, this is equivalent to the `export` keyword used on a function: -+ \\ -+ \\```zig -+ \\comptime { -+ \\ @export(internalName, .{ .name = "foo", .linkage = .Strong }); -+ \\} -+ \\ -+ \\fn internalName() callconv(.C) void {} -+ \\``` -+ \\ -+ \\This is equivalent to: -+ \\ -+ \\```zig -+ \\export fn foo() void {} -+ \\``` -+ \\ -+ \\Note that even when using `export`, the `@"foo"` syntax for [identifiers](https://ziglang.org/documentation/0.9.1/#Identifiers) can be used to choose any string for the symbol name: -+ \\ -+ \\```zig -+ \\export fn @"A function name that is a complete sentence."() void {} -+ \\``` -+ \\ -+ \\When looking at the resulting object, you can see the symbol is used verbatim: -+ \\ -+ \\```zig -+ \\00000000000001f0 T A function name that is a complete sentence. -+ \\``` -+ , -+ .arguments = &.{ -+ "declaration", -+ "comptime options: std.builtin.ExportOptions", -+ }, -+ }, -+ .{ -+ .name = "@extern", -+ .signature = "@extern(T: type, comptime options: std.builtin.ExternOptions) *T", -+ .snippet = "@extern(${1:T: type}, ${2:comptime options: std.builtin.ExternOptions})", -+ .documentation = -+ \\Creates a reference to an external symbol in the output object file. -+ , -+ .arguments = &.{ -+ "T: type", -+ "comptime options: std.builtin.ExternOptions", -+ }, -+ }, -+ .{ -+ .name = "@fence", -+ .signature = "@fence(order: AtomicOrder)", -+ .snippet = "@fence(${1:order: AtomicOrder})", -+ .documentation = -+ \\The `fence` function is used to introduce happens-before edges between operations. -+ \\ -+ \\`AtomicOrder` can be found with `@import("std").builtin.AtomicOrder`. -+ , -+ .arguments = &.{ -+ "order: AtomicOrder", -+ }, -+ }, -+ .{ -+ .name = "@field", -+ .signature = "@field(lhs: anytype, comptime field_name: []const u8) (field)", -+ .snippet = "@field(${1:lhs: anytype}, ${2:comptime field_name: []const u8})", -+ .documentation = -+ \\Performs field access by a compile-time string. Works on both fields and declarations.</p> {#code_begin|test|field_decl_access_by_string#} const std = @import("std"); const Point = struct { x: u32, y: u32, pub var z: u32 = 1; }; test "field access by string" { const expect = std.testing.expect; var p = Point{ .x = 0, .y = 0 }; @field(p, "x") = 4; @field(p, "y") = @field(p, "x") + 1; try expect(@field(p, "x") == 4); try expect(@field(p, "y") == 5); } test "decl access by string" { const expect = std.testing.expect; try expect(@field(Point, "z") == 1); @field(Point, "z") = 2; try expect(@field(Point, "z") == 2); }` -+ , -+ .arguments = &.{ -+ "lhs: anytype", -+ "comptime field_name: []const u8", -+ }, -+ }, -+ .{ -+ .name = "@fieldParentPtr", -+ .signature = "@fieldParentPtr(comptime ParentType: type, comptime field_name: []const u8, field_ptr: *T) *ParentType", -+ .snippet = "@fieldParentPtr(${1:comptime ParentType: type}, ${2:comptime field_name: []const u8}, ${3:field_ptr: *T})", -+ .documentation = -+ \\Given a pointer to a field, returns the base pointer of a struct. -+ , -+ .arguments = &.{ -+ "comptime ParentType: type", -+ "comptime field_name: []const u8", -+ "field_ptr: *T", -+ }, -+ }, -+ .{ -+ .name = "@floatCast", -+ .signature = "@floatCast(comptime DestType: type, value: anytype) DestType", -+ .snippet = "@floatCast(${1:comptime DestType: type}, ${2:value: anytype})", -+ .documentation = -+ \\Convert from one float type to another. This cast is safe, but may cause the numeric value to lose precision. -+ , -+ .arguments = &.{ -+ "comptime DestType: type", -+ "value: anytype", -+ }, -+ }, -+ .{ -+ .name = "@floatToInt", -+ .signature = "@floatToInt(comptime DestType: type, float: anytype) DestType", -+ .snippet = "@floatToInt(${1:comptime DestType: type}, ${2:float: anytype})", -+ .documentation = -+ \\Converts the integer part of a floating point number to the destination type. -+ \\ -+ \\If the integer part of the floating point number cannot fit in the destination type, it invokes safety-checked [Undefined Behavior](https://ziglang.org/documentation/0.9.1/#Undefined-Behavior). -+ , -+ .arguments = &.{ -+ "comptime DestType: type", -+ "float: anytype", -+ }, -+ }, -+ .{ -+ .name = "@frame", -+ .signature = "@frame() *@Frame(func)", -+ .snippet = "@frame()", -+ .documentation = -+ \\This function returns a pointer to the frame for a given function. This type can be [coerced](https://ziglang.org/documentation/0.9.1/#Type-Coercion) to `anyframe->T` and to `anyframe`, where `T` is the return type of the function in scope. -+ \\ -+ \\This function does not mark a suspension point, but it does cause the function in scope to become an [async function](https://ziglang.org/documentation/0.9.1/#Async-Functions). -+ , -+ .arguments = &.{}, -+ }, -+ .{ -+ .name = "@Frame", -+ .signature = "@Frame(func: anytype) type", -+ .snippet = "@Frame(${1:func: anytype})", -+ .documentation = -+ \\This function returns the frame type of a function. This works for [Async Functions](https://ziglang.org/documentation/0.9.1/#Async-Functions) as well as any function without a specific calling convention. -+ \\ -+ \\This type is suitable to be used as the return type of [async](https://ziglang.org/documentation/0.9.1/#Async-and-Await) which allows one to, for example, heap-allocate an async function frame:</p> {#code_begin|test|heap_allocated_frame#} const std = @import("std"); test "heap allocated frame" { const frame = try std.heap.page_allocator.create(@Frame(func)); frame.* = async func(); } fn func() void { suspend {} }` -+ , -+ .arguments = &.{ -+ "func: anytype", -+ }, -+ }, -+ .{ -+ .name = "@frameAddress", -+ .signature = "@frameAddress() usize", -+ .snippet = "@frameAddress()", -+ .documentation = -+ \\This function returns the base pointer of the current stack frame. -+ \\ -+ \\The implications of this are target specific and not consistent across all platforms. The frame address may not be available in release mode due to aggressive optimizations. -+ \\ -+ \\This function is only valid within function scope. -+ , -+ .arguments = &.{}, -+ }, -+ .{ -+ .name = "@frameSize", -+ .signature = "@frameSize() usize", -+ .snippet = "@frameSize()", -+ .documentation = -+ \\This is the same as `@sizeOf(@Frame(func))`, where `func` may be runtime-known. -+ \\ -+ \\This function is typically used in conjunction with [@asyncCall](https://ziglang.org/documentation/0.9.1/#asyncCall). -+ , -+ .arguments = &.{}, -+ }, -+ .{ -+ .name = "@hasDecl", -+ .signature = "@hasDecl(comptime Container: type, comptime name: []const u8) bool", -+ .snippet = "@hasDecl(${1:comptime Container: type}, ${2:comptime name: []const u8})", -+ .documentation = -+ \\Returns whether or not a [struct](https://ziglang.org/documentation/0.9.1/#struct), [enum](https://ziglang.org/documentation/0.9.1/#enum), or [union](https://ziglang.org/documentation/0.9.1/#union) has a declaration matching `name`.</p> {#code_begin|test|hasDecl#} const std = @import("std"); const expect = std.testing.expect; const Foo = struct { nope: i32, pub var blah = "xxx"; const hi = 1; }; test "@hasDecl" { try expect(@hasDecl(Foo, "blah")); // Even though `hi` is private, @hasDecl returns true because this test is // in the same file scope as Foo. It would return false if Foo was declared // in a different file. try expect(@hasDecl(Foo, "hi")); // @hasDecl is for declarations; not fields. try expect(!@hasDecl(Foo, "nope")); try expect(!@hasDecl(Foo, "nope1234")); }` -+ , -+ .arguments = &.{ -+ "comptime Container: type", -+ "comptime name: []const u8", -+ }, -+ }, -+ .{ -+ .name = "@hasField", -+ .signature = "@hasField(comptime Container: type, comptime name: []const u8) bool", -+ .snippet = "@hasField(${1:comptime Container: type}, ${2:comptime name: []const u8})", -+ .documentation = -+ \\Returns whether the field name of a struct, union, or enum exists. -+ \\ -+ \\The result is a compile time constant. -+ \\ -+ \\It does not include functions, variables, or constants. -+ , -+ .arguments = &.{ -+ "comptime Container: type", -+ "comptime name: []const u8", -+ }, -+ }, -+ .{ -+ .name = "@import", -+ .signature = "@import(comptime path: []u8) type", -+ .snippet = "@import(${1:comptime path: []u8})", -+ .documentation = -+ \\This function finds a zig file corresponding to `path` and adds it to the build, if it is not already added. -+ \\ -+ \\Zig source files are implicitly structs, with a name equal to the file's basename with the extension truncated. `@import` returns the struct type corresponding to the file. -+ \\ -+ \\Declarations which have the `pub` keyword may be referenced from a different source file than the one they are declared in. -+ \\ -+ \\`path` can be a relative path or it can be the name of a package. If it is a relative path, it is relative to the file that contains the `@import` function call. -+ \\ -+ \\The following packages are always available: -+ \\ - `@import("std")` - Zig Standard Library -+ \\ - `@import("builtin")` - Target-specific information The command `zig build-exe --show-builtin` outputs the source to stdout for reference. -+ \\ - `@import("root")` - Points to the root source file This is usually `src/main.zig` but it depends on what file is chosen to be built. -+ , -+ .arguments = &.{ -+ "comptime path: []u8", -+ }, -+ }, -+ .{ -+ .name = "@intCast", -+ .signature = "@intCast(comptime DestType: type, int: anytype) DestType", -+ .snippet = "@intCast(${1:comptime DestType: type}, ${2:int: anytype})", -+ .documentation = -+ \\Converts an integer to another integer while keeping the same numerical value. Attempting to convert a number which is out of range of the destination type results in safety-protected [Undefined Behavior](https://ziglang.org/documentation/0.9.1/#Undefined-Behavior). -+ \\ -+ \\```zig -+ \\test "integer cast panic" { -+ \\ var a: u16 = 0xabcd; -+ \\ var b: u8 = @intCast(u8, a); -+ \\ _ = b; -+ \\} -+ \\``` -+ \\ -+ \\To truncate the significant bits of a number out of range of the destination type, use [@truncate](https://ziglang.org/documentation/0.9.1/#truncate). -+ \\ -+ \\If `T` is `comptime_int`, then this is semantically equivalent to [Type Coercion](https://ziglang.org/documentation/0.9.1/#Type-Coercion). -+ , -+ .arguments = &.{ -+ "comptime DestType: type", -+ "int: anytype", -+ }, -+ }, -+ .{ -+ .name = "@intToEnum", -+ .signature = "@intToEnum(comptime DestType: type, integer: anytype) DestType", -+ .snippet = "@intToEnum(${1:comptime DestType: type}, ${2:integer: anytype})", -+ .documentation = -+ \\Converts an integer into an [enum](https://ziglang.org/documentation/0.9.1/#enum) value. -+ \\ -+ \\Attempting to convert an integer which represents no value in the chosen enum type invokes safety-checked [Undefined Behavior](https://ziglang.org/documentation/0.9.1/#Undefined-Behavior). -+ , -+ .arguments = &.{ -+ "comptime DestType: type", -+ "integer: anytype", -+ }, -+ }, -+ .{ -+ .name = "@intToError", -+ .signature = "@intToError(value: std.meta.Int(.unsigned, @sizeOf(anyerror) * 8)) anyerror", -+ .snippet = "@intToError(${1:value: std.meta.Int(.unsigned, @sizeOf(anyerror) * 8)})", -+ .documentation = -+ \\Converts from the integer representation of an error into [The Global Error Set](https://ziglang.org/documentation/0.9.1/#The-Global-Error-Set) type. -+ \\ -+ \\It is generally recommended to avoid this cast, as the integer representation of an error is not stable across source code changes. -+ \\ -+ \\Attempting to convert an integer that does not correspond to any error results in safety-protected [Undefined Behavior](https://ziglang.org/documentation/0.9.1/#Undefined-Behavior). -+ , -+ .arguments = &.{ -+ "value: std.meta.Int(.unsigned, @sizeOf(anyerror) * 8)", -+ }, -+ }, -+ .{ -+ .name = "@intToFloat", -+ .signature = "@intToFloat(comptime DestType: type, int: anytype) DestType", -+ .snippet = "@intToFloat(${1:comptime DestType: type}, ${2:int: anytype})", -+ .documentation = -+ \\Converts an integer to the closest floating point representation. To convert the other way, use [@floatToInt](https://ziglang.org/documentation/0.9.1/#floatToInt). This cast is always safe. -+ , -+ .arguments = &.{ -+ "comptime DestType: type", -+ "int: anytype", -+ }, -+ }, -+ .{ -+ .name = "@intToPtr", -+ .signature = "@intToPtr(comptime DestType: type, address: usize) DestType", -+ .snippet = "@intToPtr(${1:comptime DestType: type}, ${2:address: usize})", -+ .documentation = -+ \\Converts an integer to a [pointer](https://ziglang.org/documentation/0.9.1/#Pointers). To convert the other way, use [@ptrToInt](https://ziglang.org/documentation/0.9.1/#ptrToInt). Casting an address of 0 to a destination type which in not [optional](https://ziglang.org/documentation/0.9.1/#Optional-Pointers) and does not have the `allowzero` attribute will result in a [Pointer Cast Invalid Null](https://ziglang.org/documentation/0.9.1/#Pointer-Cast-Invalid-Null) panic when runtime safety checks are enabled. -+ \\ -+ \\If the destination pointer type does not allow address zero and `address` is zero, this invokes safety-checked [Undefined Behavior](https://ziglang.org/documentation/0.9.1/#Undefined-Behavior). -+ , -+ .arguments = &.{ -+ "comptime DestType: type", -+ "address: usize", -+ }, -+ }, -+ .{ -+ .name = "@maximum", -+ .signature = "@maximum(a: T, b: T) T", -+ .snippet = "@maximum(${1:a: T}, ${2:b: T})", -+ .documentation = -+ \\Returns the maximum value of `a` and `b`. This builtin accepts integers, floats, and vectors of either. In the latter case, the operation is performed element wise. -+ \\ -+ \\NaNs are handled as follows: if one of the operands of a (pairwise) operation is NaN, the other operand is returned. If both operands are NaN, NaN is returned. -+ , -+ .arguments = &.{ -+ "a: T", -+ "b: T", -+ }, -+ }, -+ .{ -+ .name = "@memcpy", -+ .signature = "@memcpy(noalias dest: [*]u8, noalias source: [*]const u8, byte_count: usize)", -+ .snippet = "@memcpy(${1:noalias dest: [*]u8}, ${2:noalias source: [*]const u8}, ${3:byte_count: usize})", -+ .documentation = -+ \\This function copies bytes from one region of memory to another. `dest` and `source` are both pointers and must not overlap. -+ \\ -+ \\This function is a low level intrinsic with no safety mechanisms. Most code should not use this function, instead using something like this: -+ \\ -+ \\```zig -+ \\for (source[0..byte_count]) |b, i| dest[i] = b; -+ \\``` -+ \\ -+ \\The optimizer is intelligent enough to turn the above snippet into a memcpy. -+ \\ -+ \\There is also a standard library function for this: -+ \\ -+ \\```zig -+ \\const mem = @import("std").mem; -+ \\mem.copy(u8, dest[0..byte_count], source[0..byte_count]); -+ \\``` -+ , -+ .arguments = &.{ -+ "noalias dest: [*]u8", -+ "noalias source: [*]const u8", -+ "byte_count: usize", -+ }, -+ }, -+ .{ -+ .name = "@memset", -+ .signature = "@memset(dest: [*]u8, c: u8, byte_count: usize)", -+ .snippet = "@memset(${1:dest: [*]u8}, ${2:c: u8}, ${3:byte_count: usize})", -+ .documentation = -+ \\This function sets a region of memory to `c`. `dest` is a pointer. -+ \\ -+ \\This function is a low level intrinsic with no safety mechanisms. Most code should not use this function, instead using something like this: -+ \\ -+ \\```zig -+ \\for (dest[0..byte_count]) |*b| b.* = c; -+ \\``` -+ \\ -+ \\The optimizer is intelligent enough to turn the above snippet into a memset. -+ \\ -+ \\There is also a standard library function for this: -+ \\ -+ \\```zig -+ \\const mem = @import("std").mem; -+ \\mem.set(u8, dest, c); -+ \\``` -+ , -+ .arguments = &.{ -+ "dest: [*]u8", -+ "c: u8", -+ "byte_count: usize", -+ }, -+ }, -+ .{ -+ .name = "@minimum", -+ .signature = "@minimum(a: T, b: T) T", -+ .snippet = "@minimum(${1:a: T}, ${2:b: T})", -+ .documentation = -+ \\Returns the minimum value of `a` and `b`. This builtin accepts integers, floats, and vectors of either. In the latter case, the operation is performed element wise. -+ \\ -+ \\NaNs are handled as follows: if one of the operands of a (pairwise) operation is NaN, the other operand is returned. If both operands are NaN, NaN is returned. -+ , -+ .arguments = &.{ -+ "a: T", -+ "b: T", -+ }, -+ }, -+ .{ -+ .name = "@wasmMemorySize", -+ .signature = "@wasmMemorySize(index: u32) u32", -+ .snippet = "@wasmMemorySize(${1:index: u32})", -+ .documentation = -+ \\This function returns the size of the Wasm memory identified by `index` as an unsigned value in units of Wasm pages. Note that each Wasm page is 64KB in size. -+ \\ -+ \\This function is a low level intrinsic with no safety mechanisms usually useful for allocator designers targeting Wasm. So unless you are writing a new allocator from scratch, you should use something like `@import("std").heap.WasmPageAllocator`. -+ , -+ .arguments = &.{ -+ "index: u32", -+ }, -+ }, -+ .{ -+ .name = "@wasmMemoryGrow", -+ .signature = "@wasmMemoryGrow(index: u32, delta: u32) i32", -+ .snippet = "@wasmMemoryGrow(${1:index: u32}, ${2:delta: u32})", -+ .documentation = -+ \\This function increases the size of the Wasm memory identified by `index` by `delta` in units of unsigned number of Wasm pages. Note that each Wasm page is 64KB in size. On success, returns previous memory size; on failure, if the allocation fails, returns -1. -+ \\ -+ \\This function is a low level intrinsic with no safety mechanisms usually useful for allocator designers targeting Wasm. So unless you are writing a new allocator from scratch, you should use something like `@import("std").heap.WasmPageAllocator`.</p> {#code_begin|test|wasmMemoryGrow#} const std = @import("std"); const native_arch = @import("builtin").target.cpu.arch; const expect = std.testing.expect; test "@wasmMemoryGrow" { if (native_arch != .wasm32) return error.SkipZigTest; var prev = @wasmMemorySize(0); try expect(prev == @wasmMemoryGrow(0, 1)); try expect(prev + 1 == @wasmMemorySize(0)); }` -+ , -+ .arguments = &.{ -+ "index: u32", -+ "delta: u32", -+ }, -+ }, -+ .{ -+ .name = "@mod", -+ .signature = "@mod(numerator: T, denominator: T) T", -+ .snippet = "@mod(${1:numerator: T}, ${2:denominator: T})", -+ .documentation = -+ \\Modulus division. For unsigned integers this is the same as `numerator % denominator`. Caller guarantees `denominator > 0`, otherwise the operation will result in a [Remainder Division by Zero](https://ziglang.org/documentation/0.9.1/#Remainder-Division-by-Zero) when runtime safety checks are enabled. -+ \\ - `@mod(-5, 3) == 1` -+ \\ - `(@divFloor(a, b) * b) + @mod(a, b) == a` -+ \\ -+ \\For a function that returns an error code, see `@import("std").math.mod`. -+ , -+ .arguments = &.{ -+ "numerator: T", -+ "denominator: T", -+ }, -+ }, -+ .{ -+ .name = "@mulWithOverflow", -+ .signature = "@mulWithOverflow(comptime T: type, a: T, b: T, result: *T) bool", -+ .snippet = "@mulWithOverflow(${1:comptime T: type}, ${2:a: T}, ${3:b: T}, ${4:result: *T})", -+ .documentation = -+ \\Performs `result.* = a * b`. If overflow or underflow occurs, stores the overflowed bits in `result` and returns `true`. If no overflow or underflow occurs, returns `false`. -+ , -+ .arguments = &.{ -+ "comptime T: type", -+ "a: T", -+ "b: T", -+ "result: *T", -+ }, -+ }, -+ .{ -+ .name = "@panic", -+ .signature = "@panic(message: []const u8) noreturn", -+ .snippet = "@panic(${1:message: []const u8})", -+ .documentation = -+ \\Invokes the panic handler function. By default the panic handler function calls the public `panic` function exposed in the root source file, or if there is not one specified, the `std.builtin.default_panic` function from `std/builtin.zig`. -+ \\ -+ \\Generally it is better to use `@import("std").debug.panic`. However, `@panic` can be useful for 2 scenarios: -+ \\ - From library code, calling the programmer's panic function if they exposed one in the root source file. -+ \\ - When mixing C and Zig code, calling the canonical panic implementation across multiple .o files. -+ , -+ .arguments = &.{ -+ "message: []const u8", -+ }, -+ }, -+ .{ -+ .name = "@popCount", -+ .signature = "@popCount(comptime T: type, operand: T)", -+ .snippet = "@popCount(${1:comptime T: type}, ${2:operand: T})", -+ .documentation = -+ \\`T` must be an integer type. -+ \\ -+ \\`operand` may be an [integer](https://ziglang.org/documentation/0.9.1/#Integers) or [vector](https://ziglang.org/documentation/0.9.1/#Vectors). -+ \\ -+ \\Counts the number of bits set in an integer. -+ \\ -+ \\If `operand` is a [comptime](https://ziglang.org/documentation/0.9.1/#comptime)-known integer, the return type is `comptime_int`. Otherwise, the return type is an unsigned integer or vector of unsigned integers with the minimum number of bits that can represent the bit count of the integer type. -+ , -+ .arguments = &.{ -+ "comptime T: type", -+ "operand: T", -+ }, -+ }, -+ .{ -+ .name = "@prefetch", -+ .signature = "@prefetch(ptr: anytype, comptime options: std.builtin.PrefetchOptions)", -+ .snippet = "@prefetch(${1:ptr: anytype}, ${2:comptime options: std.builtin.PrefetchOptions})", -+ .documentation = -+ \\This builtin tells the compiler to emit a prefetch instruction if supported by the target CPU. If the target CPU does not support the requested prefetch instruction, this builtin is a noop. This function has no effect on the behavior of the program, only on the performance characteristics. -+ \\ -+ \\The `ptr` argument may be any pointer type and determines the memory address to prefetch. This function does not dereference the pointer, it is perfectly legal to pass a pointer to invalid memory to this function and no illegal behavior will result. -+ \\ -+ \\The `options` argument is the following struct:</p> {#code_begin|syntax|builtin#} /// This data structure is used by the Zig language code generation and /// therefore must be kept in sync with the compiler implementation. pub const PrefetchOptions = struct { /// Whether the prefetch should prepare for a read or a write. rw: Rw = .read, /// 0 means no temporal locality. That is, the data can be immediately /// dropped from the cache after it is accessed. /// /// 3 means high temporal locality. That is, the data should be kept in /// the cache as it is likely to be accessed again soon. locality: u2 = 3, /// The cache that the prefetch should be preformed on. cache: Cache = .data, pub const Rw = enum { read, write, }; pub const Cache = enum { instruction, data, }; };` -+ , -+ .arguments = &.{ -+ "ptr: anytype", -+ "comptime options: std.builtin.PrefetchOptions", -+ }, -+ }, -+ .{ -+ .name = "@ptrCast", -+ .signature = "@ptrCast(comptime DestType: type, value: anytype) DestType", -+ .snippet = "@ptrCast(${1:comptime DestType: type}, ${2:value: anytype})", -+ .documentation = -+ \\Converts a pointer of one type to a pointer of another type. -+ \\ -+ \\[Optional Pointers](https://ziglang.org/documentation/0.9.1/#Optional-Pointers) are allowed. Casting an optional pointer which is [null](https://ziglang.org/documentation/0.9.1/#null) to a non-optional pointer invokes safety-checked [Undefined Behavior](https://ziglang.org/documentation/0.9.1/#Undefined-Behavior). -+ , -+ .arguments = &.{ -+ "comptime DestType: type", -+ "value: anytype", -+ }, -+ }, -+ .{ -+ .name = "@ptrToInt", -+ .signature = "@ptrToInt(value: anytype) usize", -+ .snippet = "@ptrToInt(${1:value: anytype})", -+ .documentation = -+ \\Converts `value` to a `usize` which is the address of the pointer. `value` can be one of these types: -+ \\ - `*T` -+ \\ - `?*T` -+ \\ - `fn()` -+ \\ - `?fn()` -+ \\ -+ \\To convert the other way, use [@intToPtr](https://ziglang.org/documentation/0.9.1/#intToPtr) -+ , -+ .arguments = &.{ -+ "value: anytype", -+ }, -+ }, -+ .{ -+ .name = "@rem", -+ .signature = "@rem(numerator: T, denominator: T) T", -+ .snippet = "@rem(${1:numerator: T}, ${2:denominator: T})", -+ .documentation = -+ \\Remainder division. For unsigned integers this is the same as `numerator % denominator`. Caller guarantees `denominator > 0`, otherwise the operation will result in a [Remainder Division by Zero](https://ziglang.org/documentation/0.9.1/#Remainder-Division-by-Zero) when runtime safety checks are enabled. -+ \\ - `@rem(-5, 3) == -2` -+ \\ - `(@divTrunc(a, b) * b) + @rem(a, b) == a` -+ \\ -+ \\For a function that returns an error code, see `@import("std").math.rem`. -+ , -+ .arguments = &.{ -+ "numerator: T", -+ "denominator: T", -+ }, -+ }, -+ .{ -+ .name = "@returnAddress", -+ .signature = "@returnAddress() usize", -+ .snippet = "@returnAddress()", -+ .documentation = -+ \\This function returns the address of the next machine code instruction that will be executed when the current function returns. -+ \\ -+ \\The implications of this are target specific and not consistent across all platforms. -+ \\ -+ \\This function is only valid within function scope. If the function gets inlined into a calling function, the returned address will apply to the calling function. -+ , -+ .arguments = &.{}, -+ }, -+ .{ -+ .name = "@select", -+ .signature = "@select(comptime T: type, pred: std.meta.Vector(len, bool), a: std.meta.Vector(len, T), b: std.meta.Vector(len, T)) std.meta.Vector(len, T)", -+ .snippet = "@select(${1:comptime T: type}, ${2:pred: std.meta.Vector(len, bool)}, ${3:a: std.meta.Vector(len, T)}, ${4:b: std.meta.Vector(len, T)})", -+ .documentation = -+ \\Selects values element-wise from `a` or `b` based on `pred`. If `pred[i]` is `true`, the corresponding element in the result will be `a[i]` and otherwise `b[i]`. -+ , -+ .arguments = &.{ -+ "comptime T: type", -+ "pred: std.meta.Vector(len, bool)", -+ "a: std.meta.Vector(len, T)", -+ "b: std.meta.Vector(len, T)", -+ }, -+ }, -+ .{ -+ .name = "@setAlignStack", -+ .signature = "@setAlignStack(comptime alignment: u29)", -+ .snippet = "@setAlignStack(${1:comptime alignment: u29})", -+ .documentation = -+ \\Ensures that a function will have a stack alignment of at least `alignment` bytes. -+ , -+ .arguments = &.{ -+ "comptime alignment: u29", -+ }, -+ }, -+ .{ -+ .name = "@setCold", -+ .signature = "@setCold(comptime is_cold: bool)", -+ .snippet = "@setCold(${1:comptime is_cold: bool})", -+ .documentation = -+ \\Tells the optimizer that a function is rarely called. -+ , -+ .arguments = &.{ -+ "comptime is_cold: bool", -+ }, -+ }, -+ .{ -+ .name = "@setEvalBranchQuota", -+ .signature = "@setEvalBranchQuota(comptime new_quota: u32)", -+ .snippet = "@setEvalBranchQuota(${1:comptime new_quota: u32})", -+ .documentation = -+ \\Changes the maximum number of backwards branches that compile-time code execution can use before giving up and making a compile error. -+ \\ -+ \\If the `new_quota` is smaller than the default quota (`1000`) or a previously explicitly set quota, it is ignored. -+ \\ -+ \\Example: -+ \\ -+ \\```zig -+ \\test "foo" { -+ \\ comptime { -+ \\ var i = 0; -+ \\ while (i < 1001) : (i += 1) {} -+ \\ } -+ \\} -+ \\``` -+ \\ -+ \\Now we use `@setEvalBranchQuota`:</p> {#code_begin|test|setEvalBranchQuota#} test "foo" { comptime { @setEvalBranchQuota(1001); var i = 0; while (i < 1001) : (i += 1) {} } }` -+ , -+ .arguments = &.{ -+ "comptime new_quota: u32", -+ }, -+ }, -+ .{ -+ .name = "@setFloatMode", -+ .signature = "@setFloatMode(comptime mode: @import(\"std\").builtin.FloatMode)", -+ .snippet = "@setFloatMode(${1:comptime mode: @import(\"std\").builtin.FloatMode})", -+ .documentation = -+ \\Sets the floating point mode of the current scope. Possible values are: -+ \\ -+ \\```zig -+ \\pub const FloatMode = enum { -+ \\ Strict, -+ \\ Optimized, -+ \\}; -+ \\``` -+ \\ -+ \\ - `Strict` (default) - Floating point operations follow strict IEEE compliance. -+ \\ - `Optimized` - Floating point operations may do all of the following: <ul> -+ \\ - Assume the arguments and result are not NaN. Optimizations are required to retain defined behavior over NaNs, but the value of the result is undefined. -+ \\ - Assume the arguments and result are not +/-Inf. Optimizations are required to retain defined behavior over +/-Inf, but the value of the result is undefined. -+ \\ - Treat the sign of a zero argument or result as insignificant. -+ \\ - Use the reciprocal of an argument rather than perform division. -+ \\ - Perform floating-point contraction (e.g. fusing a multiply followed by an addition into a fused multiply-and-add). -+ \\ - Perform algebraically equivalent transformations that may change results in floating point (e.g. reassociate). This is equivalent to `-ffast-math` in GCC.</ul> -+ \\ -+ \\The floating point mode is inherited by child scopes, and can be overridden in any scope. You can set the floating point mode in a struct or module scope by using a comptime block. -+ , -+ .arguments = &.{ -+ "comptime mode: @import(\"std\").builtin.FloatMode", -+ }, -+ }, -+ .{ -+ .name = "@setRuntimeSafety", -+ .signature = "@setRuntimeSafety(comptime safety_on: bool) void", -+ .snippet = "@setRuntimeSafety(${1:comptime safety_on: bool})", -+ .documentation = -+ \\Sets whether runtime safety checks are enabled for the scope that contains the function call. -+ \\ -+ \\```zig -+ \\test "@setRuntimeSafety" { -+ \\ // The builtin applies to the scope that it is called in. So here, integer overflow -+ \\ // will not be caught in ReleaseFast and ReleaseSmall modes: -+ \\ // var x: u8 = 255; -+ \\ // x += 1; // undefined behavior in ReleaseFast/ReleaseSmall modes. -+ \\ { -+ \\ // However this block has safety enabled, so safety checks happen here, -+ \\ // even in ReleaseFast and ReleaseSmall modes. -+ \\ @setRuntimeSafety(true); -+ \\ var x: u8 = 255; -+ \\ x += 1; -+ \\ -+ \\ { -+ \\ // The value can be overridden at any scope. So here integer overflow -+ \\ // would not be caught in any build mode. -+ \\ @setRuntimeSafety(false); -+ \\ // var x: u8 = 255; -+ \\ // x += 1; // undefined behavior in all build modes. -+ \\ } -+ \\ } -+ \\} -+ \\``` -+ \\ -+ \\Note: it is [planned](https://github.com/ziglang/zig/issues/978) to replace `@setRuntimeSafety` with `@optimizeFor` -+ , -+ .arguments = &.{ -+ "comptime safety_on: bool", -+ }, -+ }, -+ .{ -+ .name = "@shlExact", -+ .signature = "@shlExact(value: T, shift_amt: Log2T) T", -+ .snippet = "@shlExact(${1:value: T}, ${2:shift_amt: Log2T})", -+ .documentation = -+ \\Performs the left shift operation (`<<`). For unsigned integers, the result is [undefined](https://ziglang.org/documentation/0.9.1/#undefined) if any 1 bits are shifted out. For signed integers, the result is [undefined](https://ziglang.org/documentation/0.9.1/#undefined) if any bits that disagree with the resultant sign bit are shifted out. -+ \\ -+ \\The type of `shift_amt` is an unsigned integer with `log2(T.bit_count)` bits. This is because `shift_amt >= T.bit_count` is undefined behavior. -+ , -+ .arguments = &.{ -+ "value: T", -+ "shift_amt: Log2T", -+ }, -+ }, -+ .{ -+ .name = "@shlWithOverflow", -+ .signature = "@shlWithOverflow(comptime T: type, a: T, shift_amt: Log2T, result: *T) bool", -+ .snippet = "@shlWithOverflow(${1:comptime T: type}, ${2:a: T}, ${3:shift_amt: Log2T}, ${4:result: *T})", -+ .documentation = -+ \\Performs `result.* = a << b`. If overflow or underflow occurs, stores the overflowed bits in `result` and returns `true`. If no overflow or underflow occurs, returns `false`. -+ \\ -+ \\The type of `shift_amt` is an unsigned integer with `log2(T.bit_count)` bits. This is because `shift_amt >= T.bit_count` is undefined behavior. -+ , -+ .arguments = &.{ -+ "comptime T: type", -+ "a: T", -+ "shift_amt: Log2T", -+ "result: *T", -+ }, -+ }, -+ .{ -+ .name = "@shrExact", -+ .signature = "@shrExact(value: T, shift_amt: Log2T) T", -+ .snippet = "@shrExact(${1:value: T}, ${2:shift_amt: Log2T})", -+ .documentation = -+ \\Performs the right shift operation (`>>`). Caller guarantees that the shift will not shift any 1 bits out. -+ \\ -+ \\The type of `shift_amt` is an unsigned integer with `log2(T.bit_count)` bits. This is because `shift_amt >= T.bit_count` is undefined behavior. -+ , -+ .arguments = &.{ -+ "value: T", -+ "shift_amt: Log2T", -+ }, -+ }, -+ .{ -+ .name = "@shuffle", -+ .signature = "@shuffle(comptime E: type, a: std.meta.Vector(a_len, E), b: std.meta.Vector(b_len, E), comptime mask: std.meta.Vector(mask_len, i32)) std.meta.Vector(mask_len, E)", -+ .snippet = "@shuffle(${1:comptime E: type}, ${2:a: std.meta.Vector(a_len, E)}, ${3:b: std.meta.Vector(b_len, E)}, ${4:comptime mask: std.meta.Vector(mask_len, i32)})", -+ .documentation = -+ \\Constructs a new [vector](https://ziglang.org/documentation/0.9.1/#Vectors) by selecting elements from `a` and `b` based on `mask`. -+ \\ -+ \\Each element in `mask` selects an element from either `a` or `b`. Positive numbers select from `a` starting at 0. Negative values select from `b`, starting at `-1` and going down. It is recommended to use the `~` operator from indexes from `b` so that both indexes can start from `0` (i.e. `~@as(i32, 0)` is `-1`). -+ \\ -+ \\For each element of `mask`, if it or the selected value from `a` or `b` is `undefined`, then the resulting element is `undefined`. -+ \\ -+ \\`a_len` and `b_len` may differ in length. Out-of-bounds element indexes in `mask` result in compile errors. -+ \\ -+ \\If `a` or `b` is `undefined`, it is equivalent to a vector of all `undefined` with the same length as the other vector. If both vectors are `undefined`, `@shuffle` returns a vector with all elements `undefined`. -+ \\ -+ \\`E` must be an [integer](https://ziglang.org/documentation/0.9.1/#Integers), [float](https://ziglang.org/documentation/0.9.1/#Floats), [pointer](https://ziglang.org/documentation/0.9.1/#Pointers), or `bool`. The mask may be any vector length, and its length determines the result length.</p> {#code_begin|test|vector_shuffle#} const std = @import("std"); const Vector = std.meta.Vector; const expect = std.testing.expect; test "vector @shuffle" { const a: Vector(7, u8) = [_]u8{ 'o', 'l', 'h', 'e', 'r', 'z', 'w' }; const b: Vector(4, u8) = [_]u8{ 'w', 'd', '!', 'x' }; // To shuffle within a single vector, pass undefined as the second argument. // Notice that we can re-order, duplicate, or omit elements of the input vector const mask1: Vector(5, i32) = [_]i32{ 2, 3, 1, 1, 0 }; const res1: Vector(5, u8) = @shuffle(u8, a, undefined, mask1); try expect(std.mem.eql(u8, &@as([5]u8, res1), "hello")); // Combining two vectors const mask2: Vector(6, i32) = [_]i32{ -1, 0, 4, 1, -2, -3 }; const res2: Vector(6, u8) = @shuffle(u8, a, b, mask2); try expect(std.mem.eql(u8, &@as([6]u8, res2), "world!")); }` -+ , -+ .arguments = &.{ -+ "comptime E: type", -+ "a: std.meta.Vector(a_len, E)", -+ "b: std.meta.Vector(b_len, E)", -+ "comptime mask: std.meta.Vector(mask_len, i32)", -+ }, -+ }, -+ .{ -+ .name = "@sizeOf", -+ .signature = "@sizeOf(comptime T: type) comptime_int", -+ .snippet = "@sizeOf(${1:comptime T: type})", -+ .documentation = -+ \\This function returns the number of bytes it takes to store `T` in memory. The result is a target-specific compile time constant. -+ \\ -+ \\This size may contain padding bytes. If there were two consecutive T in memory, this would be the offset in bytes between element at index 0 and the element at index 1. For [integer](https://ziglang.org/documentation/0.9.1/#Integers), consider whether you want to use `@sizeOf(T)` or `@typeInfo(T).Int.bits`. -+ \\ -+ \\This function measures the size at runtime. For types that are disallowed at runtime, such as `comptime_int` and `type`, the result is `0`. -+ , -+ .arguments = &.{ -+ "comptime T: type", -+ }, -+ }, -+ .{ -+ .name = "@splat", -+ .signature = "@splat(comptime len: u32, scalar: anytype) std.meta.Vector(len, @TypeOf(scalar))", -+ .snippet = "@splat(${1:comptime len: u32}, ${2:scalar: anytype})", -+ .documentation = -+ \\Produces a vector of length `len` where each element is the value `scalar`:</p> {#code_begin|test|vector_splat#} const std = @import("std"); const expect = std.testing.expect; test "vector @splat" { const scalar: u32 = 5; const result = @splat(4, scalar); comptime try expect(@TypeOf(result) == std.meta.Vector(4, u32)); try expect(std.mem.eql(u32, &@as([4]u32, result), &[_]u32{ 5, 5, 5, 5 })); }` -+ \\ -+ \\`scalar` must be an [integer](https://ziglang.org/documentation/0.9.1/#Integers), [bool](https://ziglang.org/documentation/0.9.1/#Primitive-Types), [float](https://ziglang.org/documentation/0.9.1/#Floats), or [pointer](https://ziglang.org/documentation/0.9.1/#Pointers). -+ , -+ .arguments = &.{ -+ "comptime len: u32", -+ "scalar: anytype", -+ }, -+ }, -+ .{ -+ .name = "@reduce", -+ .signature = "@reduce(comptime op: std.builtin.ReduceOp, value: anytype) std.meta.Child(value)", -+ .snippet = "@reduce(${1:comptime op: std.builtin.ReduceOp}, ${2:value: anytype})", -+ .documentation = -+ \\Transforms a [vector](https://ziglang.org/documentation/0.9.1/#Vectors) into a scalar value by performing a sequential horizontal reduction of its elements using the specified operator `op`. -+ \\ -+ \\Not every operator is available for every vector element type: -+ \\ - `.And`, `.Or`, `.Xor` are available for `bool` vectors, -+ \\ - `.Min`, `.Max`, `.Add`, `.Mul` are available for [floating point](https://ziglang.org/documentation/0.9.1/#Floats) vectors, -+ \\ - Every operator is available for [integer](https://ziglang.org/documentation/0.9.1/#Integers) vectors. -+ \\ -+ \\Note that `.Add` and `.Mul` reductions on integral types are wrapping; when applied on floating point types the operation associativity is preserved, unless the float mode is set to `Optimized`.</p> {#code_begin|test|vector_reduce#} const std = @import("std"); const expect = std.testing.expect; test "vector @reduce" { const value: std.meta.Vector(4, i32) = [_]i32{ 1, -1, 1, -1 }; const result = value > @splat(4, @as(i32, 0)); // result is { true, false, true, false }; comptime try expect(@TypeOf(result) == std.meta.Vector(4, bool)); const is_all_true = @reduce(.And, result); comptime try expect(@TypeOf(is_all_true) == bool); try expect(is_all_true == false); }` -+ , -+ .arguments = &.{ -+ "comptime op: std.builtin.ReduceOp", -+ "value: anytype", -+ }, -+ }, -+ .{ -+ .name = "@src", -+ .signature = "@src() std.builtin.SourceLocation", -+ .snippet = "@src()", -+ .documentation = -+ \\Returns a `SourceLocation` struct representing the function's name and location in the source code. This must be called in a function.</p> {#code_begin|test|source_location#} const std = @import("std"); const expect = std.testing.expect; test "@src" { try doTheTest(); } fn doTheTest() !void { const src = @src(); try expect(src.line == 9); try expect(src.column == 17); try expect(std.mem.endsWith(u8, src.fn_name, "doTheTest")); try expect(std.mem.endsWith(u8, src.file, "source_location.zig")); }` -+ , -+ .arguments = &.{}, -+ }, -+ .{ -+ .name = "@sqrt", -+ .signature = "@sqrt(value: anytype) @TypeOf(value)", -+ .snippet = "@sqrt(${1:value: anytype})", -+ .documentation = -+ \\Performs the square root of a floating point number. Uses a dedicated hardware instruction when available. -+ \\ -+ \\Supports [Floats](https://ziglang.org/documentation/0.9.1/#Floats) and [Vectors](https://ziglang.org/documentation/0.9.1/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026). -+ , -+ .arguments = &.{ -+ "value: anytype", -+ }, -+ }, -+ .{ -+ .name = "@sin", -+ .signature = "@sin(value: anytype) @TypeOf(value)", -+ .snippet = "@sin(${1:value: anytype})", -+ .documentation = -+ \\Sine trigonometric function on a floating point number. Uses a dedicated hardware instruction when available. -+ \\ -+ \\Supports [Floats](https://ziglang.org/documentation/0.9.1/#Floats) and [Vectors](https://ziglang.org/documentation/0.9.1/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026). -+ , -+ .arguments = &.{ -+ "value: anytype", -+ }, -+ }, -+ .{ -+ .name = "@cos", -+ .signature = "@cos(value: anytype) @TypeOf(value)", -+ .snippet = "@cos(${1:value: anytype})", -+ .documentation = -+ \\Cosine trigonometric function on a floating point number. Uses a dedicated hardware instruction when available. -+ \\ -+ \\Supports [Floats](https://ziglang.org/documentation/0.9.1/#Floats) and [Vectors](https://ziglang.org/documentation/0.9.1/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026). -+ , -+ .arguments = &.{ -+ "value: anytype", -+ }, -+ }, -+ .{ -+ .name = "@exp", -+ .signature = "@exp(value: anytype) @TypeOf(value)", -+ .snippet = "@exp(${1:value: anytype})", -+ .documentation = -+ \\Base-e exponential function on a floating point number. Uses a dedicated hardware instruction when available. -+ \\ -+ \\Supports [Floats](https://ziglang.org/documentation/0.9.1/#Floats) and [Vectors](https://ziglang.org/documentation/0.9.1/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026). -+ , -+ .arguments = &.{ -+ "value: anytype", -+ }, -+ }, -+ .{ -+ .name = "@exp2", -+ .signature = "@exp2(value: anytype) @TypeOf(value)", -+ .snippet = "@exp2(${1:value: anytype})", -+ .documentation = -+ \\Base-2 exponential function on a floating point number. Uses a dedicated hardware instruction when available. -+ \\ -+ \\Supports [Floats](https://ziglang.org/documentation/0.9.1/#Floats) and [Vectors](https://ziglang.org/documentation/0.9.1/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026). -+ , -+ .arguments = &.{ -+ "value: anytype", -+ }, -+ }, -+ .{ -+ .name = "@log", -+ .signature = "@log(value: anytype) @TypeOf(value)", -+ .snippet = "@log(${1:value: anytype})", -+ .documentation = -+ \\Returns the natural logarithm of a floating point number. Uses a dedicated hardware instruction when available. -+ \\ -+ \\Supports [Floats](https://ziglang.org/documentation/0.9.1/#Floats) and [Vectors](https://ziglang.org/documentation/0.9.1/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026). -+ , -+ .arguments = &.{ -+ "value: anytype", -+ }, -+ }, -+ .{ -+ .name = "@log2", -+ .signature = "@log2(value: anytype) @TypeOf(value)", -+ .snippet = "@log2(${1:value: anytype})", -+ .documentation = -+ \\Returns the logarithm to the base 2 of a floating point number. Uses a dedicated hardware instruction when available. -+ \\ -+ \\Supports [Floats](https://ziglang.org/documentation/0.9.1/#Floats) and [Vectors](https://ziglang.org/documentation/0.9.1/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026). -+ , -+ .arguments = &.{ -+ "value: anytype", -+ }, -+ }, -+ .{ -+ .name = "@log10", -+ .signature = "@log10(value: anytype) @TypeOf(value)", -+ .snippet = "@log10(${1:value: anytype})", -+ .documentation = -+ \\Returns the logarithm to the base 10 of a floating point number. Uses a dedicated hardware instruction when available. -+ \\ -+ \\Supports [Floats](https://ziglang.org/documentation/0.9.1/#Floats) and [Vectors](https://ziglang.org/documentation/0.9.1/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026). -+ , -+ .arguments = &.{ -+ "value: anytype", -+ }, -+ }, -+ .{ -+ .name = "@fabs", -+ .signature = "@fabs(value: anytype) @TypeOf(value)", -+ .snippet = "@fabs(${1:value: anytype})", -+ .documentation = -+ \\Returns the absolute value of a floating point number. Uses a dedicated hardware instruction when available. -+ \\ -+ \\Supports [Floats](https://ziglang.org/documentation/0.9.1/#Floats) and [Vectors](https://ziglang.org/documentation/0.9.1/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026). -+ , -+ .arguments = &.{ -+ "value: anytype", -+ }, -+ }, -+ .{ -+ .name = "@floor", -+ .signature = "@floor(value: anytype) @TypeOf(value)", -+ .snippet = "@floor(${1:value: anytype})", -+ .documentation = -+ \\Returns the largest integral value not greater than the given floating point number. Uses a dedicated hardware instruction when available. -+ \\ -+ \\Supports [Floats](https://ziglang.org/documentation/0.9.1/#Floats) and [Vectors](https://ziglang.org/documentation/0.9.1/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026). -+ , -+ .arguments = &.{ -+ "value: anytype", -+ }, -+ }, -+ .{ -+ .name = "@ceil", -+ .signature = "@ceil(value: anytype) @TypeOf(value)", -+ .snippet = "@ceil(${1:value: anytype})", -+ .documentation = -+ \\Returns the smallest integral value not less than the given floating point number. Uses a dedicated hardware instruction when available. -+ \\ -+ \\Supports [Floats](https://ziglang.org/documentation/0.9.1/#Floats) and [Vectors](https://ziglang.org/documentation/0.9.1/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026). -+ , -+ .arguments = &.{ -+ "value: anytype", -+ }, -+ }, -+ .{ -+ .name = "@trunc", -+ .signature = "@trunc(value: anytype) @TypeOf(value)", -+ .snippet = "@trunc(${1:value: anytype})", -+ .documentation = -+ \\Rounds the given floating point number to an integer, towards zero. Uses a dedicated hardware instruction when available. -+ \\ -+ \\Supports [Floats](https://ziglang.org/documentation/0.9.1/#Floats) and [Vectors](https://ziglang.org/documentation/0.9.1/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026). -+ , -+ .arguments = &.{ -+ "value: anytype", -+ }, -+ }, -+ .{ -+ .name = "@round", -+ .signature = "@round(value: anytype) @TypeOf(value)", -+ .snippet = "@round(${1:value: anytype})", -+ .documentation = -+ \\Rounds the given floating point number to an integer, away from zero. Uses a dedicated hardware instruction when available. -+ \\ -+ \\Supports [Floats](https://ziglang.org/documentation/0.9.1/#Floats) and [Vectors](https://ziglang.org/documentation/0.9.1/#Vectors) of floats, with the caveat that [some float operations are not yet implemented for all float types](https://github.com/ziglang/zig/issues/4026). -+ , -+ .arguments = &.{ -+ "value: anytype", -+ }, -+ }, -+ .{ -+ .name = "@subWithOverflow", -+ .signature = "@subWithOverflow(comptime T: type, a: T, b: T, result: *T) bool", -+ .snippet = "@subWithOverflow(${1:comptime T: type}, ${2:a: T}, ${3:b: T}, ${4:result: *T})", -+ .documentation = -+ \\Performs `result.* = a - b`. If overflow or underflow occurs, stores the overflowed bits in `result` and returns `true`. If no overflow or underflow occurs, returns `false`. -+ , -+ .arguments = &.{ -+ "comptime T: type", -+ "a: T", -+ "b: T", -+ "result: *T", -+ }, -+ }, -+ .{ -+ .name = "@tagName", -+ .signature = "@tagName(value: anytype) [:0]const u8", -+ .snippet = "@tagName(${1:value: anytype})", -+ .documentation = -+ \\Converts an enum value or union value to a string literal representing the name. -+ \\ -+ \\If the enum is non-exhaustive and the tag value does not map to a name, it invokes safety-checked [Undefined Behavior](https://ziglang.org/documentation/0.9.1/#Undefined-Behavior). -+ , -+ .arguments = &.{ -+ "value: anytype", -+ }, -+ }, -+ .{ -+ .name = "@This", -+ .signature = "@This() type", -+ .snippet = "@This()", -+ .documentation = -+ \\Returns the innermost struct, enum, or union that this function call is inside. This can be useful for an anonymous struct that needs to refer to itself:</p> {#code_begin|test|this_innermost#} const std = @import("std"); const expect = std.testing.expect; test "@This()" { var items = [_]i32{ 1, 2, 3, 4 }; const list = List(i32){ .items = items[0..] }; try expect(list.length() == 4); } fn List(comptime T: type) type { return struct { const Self = @This(); items: []T, fn length(self: Self) usize { return self.items.len; } }; }` -+ \\ -+ \\When `@This()` is used at file scope, it returns a reference to the struct that corresponds to the current file. -+ , -+ .arguments = &.{}, -+ }, -+ .{ -+ .name = "@truncate", -+ .signature = "@truncate(comptime T: type, integer: anytype) T", -+ .snippet = "@truncate(${1:comptime T: type}, ${2:integer: anytype})", -+ .documentation = -+ \\This function truncates bits from an integer type, resulting in a smaller or same-sized integer type. -+ \\ -+ \\This function always truncates the significant bits of the integer, regardless of endianness on the target platform. -+ \\ -+ \\Calling `@truncate` on a number out of range of the destination type is well defined and working code: -+ \\ -+ \\```zig -+ \\const std = @import("std"); -+ \\const expect = std.testing.expect; -+ \\ -+ \\test "integer truncation" { -+ \\ var a: u16 = 0xabcd; -+ \\ var b: u8 = @truncate(u8, a); -+ \\ try expect(b == 0xcd); -+ \\} -+ \\``` -+ \\ -+ \\Use [@intCast](https://ziglang.org/documentation/0.9.1/#intCast) to convert numbers guaranteed to fit the destination type. -+ , -+ .arguments = &.{ -+ "comptime T: type", -+ "integer: anytype", -+ }, -+ }, -+ .{ -+ .name = "@Type", -+ .signature = "@Type(comptime info: std.builtin.TypeInfo) type", -+ .snippet = "@Type(${1:comptime info: std.builtin.TypeInfo})", -+ .documentation = -+ \\This function is the inverse of [@typeInfo](https://ziglang.org/documentation/0.9.1/#typeInfo). It reifies type information into a `type`. -+ \\ -+ \\It is available for the following types: -+ \\ - `type` -+ \\ - `noreturn` -+ \\ - `void` -+ \\ - `bool` -+ \\ - [Integers](https://ziglang.org/documentation/0.9.1/#Integers) - The maximum bit count for an integer type is `65535`. -+ \\ - [Floats](https://ziglang.org/documentation/0.9.1/#Floats) -+ \\ - [Pointers](https://ziglang.org/documentation/0.9.1/#Pointers) -+ \\ - `comptime_int` -+ \\ - `comptime_float` -+ \\ - `@TypeOf(undefined)` -+ \\ - `@TypeOf(null)` -+ \\ - [Arrays](https://ziglang.org/documentation/0.9.1/#Arrays) -+ \\ - [Optionals](https://ziglang.org/documentation/0.9.1/#Optionals) -+ \\ - [Error Set Type](https://ziglang.org/documentation/0.9.1/#Error-Set-Type) -+ \\ - [Error Union Type](https://ziglang.org/documentation/0.9.1/#Error-Union-Type) -+ \\ - [Vectors](https://ziglang.org/documentation/0.9.1/#Vectors) -+ \\ - [opaque](https://ziglang.org/documentation/0.9.1/#opaque) -+ \\ - [@Frame](https://ziglang.org/documentation/0.9.1/#Frame) -+ \\ - `anyframe` -+ \\ - [struct](https://ziglang.org/documentation/0.9.1/#struct) -+ \\ - [enum](https://ziglang.org/documentation/0.9.1/#enum) -+ \\ - [Enum Literals](https://ziglang.org/documentation/0.9.1/#Enum-Literals) -+ \\ - [union](https://ziglang.org/documentation/0.9.1/#union) -+ \\ -+ \\For these types, `@Type` is not available: -+ \\ - [Functions](https://ziglang.org/documentation/0.9.1/#Functions) -+ \\ - BoundFn -+ , -+ .arguments = &.{ -+ "comptime info: std.builtin.TypeInfo", -+ }, -+ }, -+ .{ -+ .name = "@typeInfo", -+ .signature = "@typeInfo(comptime T: type) std.builtin.TypeInfo", -+ .snippet = "@typeInfo(${1:comptime T: type})", -+ .documentation = -+ \\Provides type reflection. -+ \\ -+ \\Type information of [structs](https://ziglang.org/documentation/0.9.1/#struct), [unions](https://ziglang.org/documentation/0.9.1/#union), [enums](https://ziglang.org/documentation/0.9.1/#enum), and [error sets](https://ziglang.org/documentation/0.9.1/#Error-Set-Type) has fields which are are guaranteed to be in the same order as appearance in the source file. -+ \\ -+ \\Type information of [structs](https://ziglang.org/documentation/0.9.1/#struct), [unions](https://ziglang.org/documentation/0.9.1/#union), [enums](https://ziglang.org/documentation/0.9.1/#enum), and [opaques](https://ziglang.org/documentation/0.9.1/#opaque) has declarations, which are also guaranteed to be in the same order as appearance in the source file. -+ , -+ .arguments = &.{ -+ "comptime T: type", -+ }, -+ }, -+ .{ -+ .name = "@typeName", -+ .signature = "@typeName(T: type) *const [N:0]u8", -+ .snippet = "@typeName(${1:T: type})", -+ .documentation = -+ \\This function returns the string representation of a type, as an array. It is equivalent to a string literal of the type name. -+ , -+ .arguments = &.{ -+ "T: type", -+ }, -+ }, -+ .{ -+ .name = "@TypeOf", -+ .signature = "@TypeOf(...) type", -+ .snippet = "@TypeOf(${1:...})", -+ .documentation = -+ \\`@TypeOf` is a special builtin function that takes any (nonzero) number of expressions as parameters and returns the type of the result, using [Peer Type Resolution](https://ziglang.org/documentation/0.9.1/#Peer-Type-Resolution). -+ \\ -+ \\The expressions are evaluated, however they are guaranteed to have no *runtime* side-effects:</p> {#code_begin|test|no_runtime_side_effects#} const std = @import("std"); const expect = std.testing.expect; test "no runtime side effects" { var data: i32 = 0; const T = @TypeOf(foo(i32, &data)); comptime try expect(T == i32); try expect(data == 0); } fn foo(comptime T: type, ptr: *T) T { ptr.* += 1; return ptr.*; }` -+ , -+ .arguments = &.{ -+ "...", -+ }, -+ }, -+ .{ -+ .name = "@unionInit", -+ .signature = "@unionInit(comptime Union: type, comptime active_field_name: []const u8, init_expr) Union", -+ .snippet = "@unionInit(${1:comptime Union: type}, ${2:comptime active_field_name: []const u8}, ${3:init_expr})", -+ .documentation = -+ \\This is the same thing as [union](https://ziglang.org/documentation/0.9.1/#union) initialization syntax, except that the field name is a [comptime](https://ziglang.org/documentation/0.9.1/#comptime)-known value rather than an identifier token. -+ \\ -+ \\`@unionInit` forwards its [result location](https://ziglang.org/documentation/0.9.1/#Result-Location-Semantics) to `init_expr`. -+ , -+ .arguments = &.{ -+ "comptime Union: type", -+ "comptime active_field_name: []const u8", -+ "init_expr", -+ }, -+ }, -+}; -diff --git a/src/data/data.zig b/src/data/data.zig -index f6e3b049..21257bfe 100644 ---- a/src/data/data.zig -+++ b/src/data/data.zig -@@ -7,4 +7,6 @@ pub usingnamespace switch (build_options.data_version) { - .@"0.8.0" => @import("0.8.0.zig"), - .@"0.8.1" => @import("0.8.1.zig"), - .@"0.9.0" => @import("0.9.0.zig"), -+ .@"0.9.1" => @import("0.9.1.zig"), -+ .@"0.10.0" => @import("0.10.0.zig"), - }; -diff --git a/src/data/master.zig b/src/data/master.zig -index 917d3fe2..9eacf7b5 100644 ---- a/src/data/master.zig -+++ b/src/data/master.zig -@@ -7,6 +7,18 @@ const Builtin = struct { - }; - - pub const builtins = [_]Builtin{ -+ .{ -+ .name = "@addrSpaceCast", -+ .signature = "@addrSpaceCast(comptime addrspace: std.builtin.AddressSpace, ptr: anytype) anytype", -+ .snippet = "@addrSpaceCast(${1:comptime addrspace: std.builtin.AddressSpace}, ${2:ptr: anytype})", -+ .documentation = -+ \\Converts a pointer from one address space to another. Depending on the current target and address spaces, this cast may be a no-op, a complex operation, or illegal. If the cast is legal, then the resulting pointer points to the same memory location as the pointer operand. It is always valid to cast a pointer between the same address spaces. -+ , -+ .arguments = &.{ -+ "comptime addrspace: std.builtin.AddressSpace", -+ "ptr: anytype", -+ }, -+ }, - .{ - .name = "@addWithOverflow", - .signature = "@addWithOverflow(comptime T: type, a: T, b: T, result: *T) bool", -@@ -26,7 +38,7 @@ pub const builtins = [_]Builtin{ - .signature = "@alignCast(comptime alignment: u29, ptr: anytype) anytype", - .snippet = "@alignCast(${1:comptime alignment: u29}, ${2:ptr: anytype})", - .documentation = -- \\`ptr` can be `*T`, `fn()`, `?*T`, `?fn()`, or `[]T`. It returns the same type as `ptr` except with the alignment adjusted to the new value. -+ \\`ptr` can be `*T`, `?*T`, or `[]T`. It returns the same type as `ptr` except with the alignment adjusted to the new value. - \\ - \\A [pointer alignment safety check](https://ziglang.org/documentation/master/#Incorrect-Pointer-Alignment) is added to the generated code to make sure the pointer is aligned as promised. - , -@@ -222,7 +234,7 @@ pub const builtins = [_]Builtin{ - .signature = "@mulAdd(comptime T: type, a: T, b: T, c: T) T", - .snippet = "@mulAdd(${1:comptime T: type}, ${2:a: T}, ${3:b: T}, ${4:c: T})", - .documentation = -- \\Fused multiply add, similar to `(a * b) + c`, except only rounds once, and is thus more accurate. -+ \\Fused multiply-add, similar to `(a * b) + c`, except only rounds once, and is thus more accurate. - \\ - \\Supports [Floats](https://ziglang.org/documentation/master/#Floats) and [Vectors](https://ziglang.org/documentation/master/#Vectors) of floats. - , -@@ -474,8 +486,6 @@ pub const builtins = [_]Builtin{ - \\} - \\``` - \\ -- \\will output: -- \\ - \\If all `@compileLog` calls are removed or not encountered by analysis, the program compiles successfully and the generated executable prints:</p> {#code_begin|test|without_compileLog#} const print = @import("std").debug.print; const num1 = blk: { var val1: i32 = 99; val1 = val1 + 1; break :blk val1; }; test "main" { print("Runtime in main, num1 = {}.\n", .{num1}); }` - , - .arguments = &.{ -@@ -791,7 +801,7 @@ pub const builtins = [_]Builtin{ - .documentation = - \\This function returns the base pointer of the current stack frame. - \\ -- \\The implications of this are target specific and not consistent across all platforms. The frame address may not be available in release mode due to aggressive optimizations. -+ \\The implications of this are target-specific and not consistent across all platforms. The frame address may not be available in release mode due to aggressive optimizations. - \\ - \\This function is only valid within function scope. - , -@@ -853,8 +863,8 @@ pub const builtins = [_]Builtin{ - \\ - \\The following packages are always available: - \\ - `@import("std")` - Zig Standard Library -- \\ - `@import("builtin")` - Target-specific information The command `zig build-exe --show-builtin` outputs the source to stdout for reference. -- \\ - `@import("root")` - Points to the root source file This is usually `src/main.zig` but it depends on what file is chosen to be built. -+ \\ - `@import("builtin")` - Target-specific information. The command `zig build-exe --show-builtin` outputs the source to stdout for reference. -+ \\ - `@import("root")` - Points to the root source file. This is usually `src/main.zig` but it depends on what file is chosen to be built. - , - .arguments = &.{ - "comptime path: []u8", -@@ -1117,7 +1127,7 @@ pub const builtins = [_]Builtin{ - .signature = "@prefetch(ptr: anytype, comptime options: std.builtin.PrefetchOptions)", - .snippet = "@prefetch(${1:ptr: anytype}, ${2:comptime options: std.builtin.PrefetchOptions})", - .documentation = -- \\This builtin tells the compiler to emit a prefetch instruction if supported by the target CPU. If the target CPU does not support the requested prefetch instruction, this builtin is a noop. This function has no effect on the behavior of the program, only on the performance characteristics. -+ \\This builtin tells the compiler to emit a prefetch instruction if supported by the target CPU. If the target CPU does not support the requested prefetch instruction, this builtin is a no-op. This function has no effect on the behavior of the program, only on the performance characteristics. - \\ - \\The `ptr` argument may be any pointer type and determines the memory address to prefetch. This function does not dereference the pointer, it is perfectly legal to pass a pointer to invalid memory to this function and no illegal behavior will result. - \\ -@@ -1147,11 +1157,7 @@ pub const builtins = [_]Builtin{ - .signature = "@ptrToInt(value: anytype) usize", - .snippet = "@ptrToInt(${1:value: anytype})", - .documentation = -- \\Converts `value` to a `usize` which is the address of the pointer. `value` can be one of these types: -- \\ - `*T` -- \\ - `?*T` -- \\ - `fn()` -- \\ - `?fn()` -+ \\Converts `value` to a `usize` which is the address of the pointer. `value` can be `*T` or `?*T`. - \\ - \\To convert the other way, use [@intToPtr](https://ziglang.org/documentation/master/#intToPtr) - , -@@ -1182,7 +1188,7 @@ pub const builtins = [_]Builtin{ - .documentation = - \\This function returns the address of the next machine code instruction that will be executed when the current function returns. - \\ -- \\The implications of this are target specific and not consistent across all platforms. -+ \\The implications of this are target-specific and not consistent across all platforms. - \\ - \\This function is only valid within function scope. If the function gets inlined into a calling function, the returned address will apply to the calling function. - , -@@ -1270,7 +1276,7 @@ pub const builtins = [_]Builtin{ - \\ - Assume the arguments and result are not +/-Inf. Optimizations are required to retain defined behavior over +/-Inf, but the value of the result is undefined. - \\ - Treat the sign of a zero argument or result as insignificant. - \\ - Use the reciprocal of an argument rather than perform division. -- \\ - Perform floating-point contraction (e.g. fusing a multiply followed by an addition into a fused multiply-and-add). -+ \\ - Perform floating-point contraction (e.g. fusing a multiply followed by an addition into a fused multiply-add). - \\ - Perform algebraically equivalent transformations that may change results in floating point (e.g. reassociate). This is equivalent to `-ffast-math` in GCC.</ul> - \\ - \\The floating point mode is inherited by child scopes, and can be overridden in any scope. You can set the floating point mode in a struct or module scope by using a comptime block. -@@ -1367,7 +1373,7 @@ pub const builtins = [_]Builtin{ - .documentation = - \\Constructs a new [vector](https://ziglang.org/documentation/master/#Vectors) by selecting elements from `a` and `b` based on `mask`. - \\ -- \\Each element in `mask` selects an element from either `a` or `b`. Positive numbers select from `a` starting at 0. Negative values select from `b`, starting at `-1` and going down. It is recommended to use the `~` operator from indexes from `b` so that both indexes can start from `0` (i.e. `~@as(i32, 0)` is `-1`). -+ \\Each element in `mask` selects an element from either `a` or `b`. Positive numbers select from `a` starting at 0. Negative values select from `b`, starting at `-1` and going down. It is recommended to use the `~` operator for indexes from `b` so that both indexes can start from `0` (i.e. `~@as(i32, 0)` is `-1`). - \\ - \\For each element of `mask`, if it or the selected value from `a` or `b` is `undefined`, then the resulting element is `undefined`. - \\ -@@ -1737,7 +1743,7 @@ pub const builtins = [_]Builtin{ - .documentation = - \\Provides type reflection. - \\ -- \\Type information of [structs](https://ziglang.org/documentation/master/#struct), [unions](https://ziglang.org/documentation/master/#union), [enums](https://ziglang.org/documentation/master/#enum), and [error sets](https://ziglang.org/documentation/master/#Error-Set-Type) has fields which are are guaranteed to be in the same order as appearance in the source file. -+ \\Type information of [structs](https://ziglang.org/documentation/master/#struct), [unions](https://ziglang.org/documentation/master/#union), [enums](https://ziglang.org/documentation/master/#enum), and [error sets](https://ziglang.org/documentation/master/#Error-Set-Type) has fields which are guaranteed to be in the same order as appearance in the source file. - \\ - \\Type information of [structs](https://ziglang.org/documentation/master/#struct), [unions](https://ziglang.org/documentation/master/#union), [enums](https://ziglang.org/documentation/master/#enum), and [opaques](https://ziglang.org/documentation/master/#opaque) has declarations, which are also guaranteed to be in the same order as appearance in the source file. - , -diff --git a/src/shared.zig b/src/shared.zig -index 25212203..fac7994a 100644 ---- a/src/shared.zig -+++ b/src/shared.zig -@@ -7,4 +7,6 @@ pub const ZigVersion = enum { - @"0.8.0", - @"0.8.1", - @"0.9.0", -+ @"0.9.1", -+ @"0.10.0", - }; diff --git a/dev-zig/zls/zls-0.10.0-r1.ebuild b/dev-zig/zls/zls-0.10.0-r1.ebuild deleted file mode 100644 index da659404c..000000000 --- a/dev-zig/zls/zls-0.10.0-r1.ebuild +++ /dev/null @@ -1,141 +0,0 @@ -# Copyright 2022-2023 Gentoo Authors -# Distributed under the terms of the GNU General Public License v2 - -EAPI=8 - -inherit edo - -DESCRIPTION="The officially unofficial Ziglang language server" -HOMEPAGE="https://github.com/zigtools/zls" - -KNOWN_FOLDERS_COMMIT="24845b0103e611c108d6bc334231c464e699742c" -TRACY_COMMIT="f493d4aa8ba8141d9680473fad007d8a6348628e" -SRC_URI=" - https://github.com/ziglibs/known-folders/archive/${KNOWN_FOLDERS_COMMIT}.tar.gz -> known-folders-${KNOWN_FOLDERS_COMMIT}.tar.gz - https://github.com/wolfpld/tracy/archive/${TRACY_COMMIT}.tar.gz -> tracy-${TRACY_COMMIT}.tar.gz - https://github.com/zigtools/zls/archive/refs/tags/${PV}.tar.gz -> zls-${PV}.tar.gz -" - -LICENSE="MIT" -SLOT="0" -KEYWORDS="~amd64" - -EZIG_MIN="0.10" -EZIG_MAX_EXCLUSIVE="0.11" - -DEPEND="|| ( dev-lang/zig:${EZIG_MIN} dev-lang/zig-bin:${EZIG_MIN} )" -RDEPEND="${DEPEND}" - -# see https://github.com/ziglang/zig/issues/3382 -# For now, Zig Build System doesn't support CFLAGS/LDFLAGS/etc. -QA_FLAGS_IGNORED="usr/bin/zls" - -PATCHES=( - "${FILESDIR}/zls-0.10.0-add-builtin-data-for-new-zig-versions.patch" -) - -# : copied from sys-fs/ncdu : -# Many thanks to Florian Schmaus (Flowdalic)! -# Adapted from https://github.com/gentoo/gentoo/pull/28986 -# Set the EZIG environment variable. -zig-set_EZIG() { - [[ -n ${EZIG} ]] && return - - if [[ -n ${EZIG_OVERWRITE} ]]; then - export EZIG="${EZIG_OVERWRITE}" - return - fi - - local candidates candidate selected selected_ver - - candidates=$(compgen -c zig-) - - for candidate in ${candidates}; do - if [[ ! ${candidate} =~ zig(-bin)?-([.0-9]+) ]]; then - continue - fi - - local ver - if (( ${#BASH_REMATCH[@]} == 3 )); then - ver="${BASH_REMATCH[2]}" - else - ver="${BASH_REMATCH[1]}" - fi - - if [[ -n ${EZIG_EXACT_VER} ]]; then - ver_test "${ver}" -ne "${EZIG_EXACT_VER}" && continue - - selected="${candidate}" - selected_ver="${ver}" - break - fi - - if [[ -n ${EZIG_MIN} ]] \ - && ver_test "${ver}" -lt "${EZIG_MIN}"; then - # Candidate does not satisfy EZIG_MIN condition. - continue - fi - - if [[ -n ${EZIG_MAX_EXCLUSIVE} ]] \ - && ver_test "${ver}" -ge "${EZIG_MAX_EXCLUSIVE}"; then - # Candidate does not satisfy EZIG_MAX_EXCLUSIVE condition. - continue - fi - - if [[ -n ${selected_ver} ]] \ - && ver_test "${selected_ver}" -gt "${ver}"; then - # Candidate is older than the currently selected candidate. - continue - fi - - selected="${candidate}" - selected_ver="${ver}" - done - - if [[ -z ${selected} ]]; then - die "Could not find (suitable) zig installation in PATH" - fi - - export EZIG="${selected}" - export EZIG_VER="${ver}" -} - -# Invoke zig with the optionally provided arguments. -ezig() { - zig-set_EZIG - - # Unfortunately, we cannot add more args here, since syntax is different - # for every subcommands. Yes, even target/cpu :( f.i. : - # -target/-mcpu for zig build-exe vs -Dtarget/-Dcpu for zig build- - # -OReleaseSafe for zig build-exe vs -DReleaseSafe for zig build - # (or even none, if hardcoded by upstream so choice is -Drelease=true/false) - # Ofc we can patch this, but still... - - edo "${EZIG}" "${@}" -} - -src_prepare() { - rm -r src/known-folders || die - mv "../known-folders-${KNOWN_FOLDERS_COMMIT}" src/known-folders || die - rm -r src/tracy || die - mv "../tracy-${TRACY_COMMIT}" src/zinput || die - - default -} - -src_compile() { - ezig build -Drelease-safe -Ddata_version=0.10.0 --verbose || die -} - -src_test() { - ezig build test -Drelease-safe -Ddata_version=0.10.0 --verbose || die -} - -src_install() { - DESTDIR="${ED}" ezig build install --prefix /usr -Drelease-safe -Ddata_version=0.10.0 --verbose || die - dodoc README.md -} - -pkg_postinst() { - elog "You can find more information about options here https://github.com/zigtools/zls#configuration-options" -} |