aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--lib/std/crypto.zig2
-rw-r--r--lib/std/crypto/aegis.zig447
-rw-r--r--lib/std/crypto/aes/aesni.zig26
-rw-r--r--lib/std/crypto/aes/soft.zig30
-rw-r--r--lib/std/crypto/benchmark.zig4
-rw-r--r--lib/std/crypto/gimli.zig56
-rw-r--r--lib/std/event/future.zig2
-rw-r--r--lib/std/event/lock.zig205
-rw-r--r--lib/std/fs/test.zig23
-rw-r--r--lib/std/meta.zig111
-rw-r--r--lib/std/os/windows.zig18
-rw-r--r--lib/std/zig/tokenizer.zig9
-rw-r--r--src/tokenizer.cpp6
13 files changed, 794 insertions, 145 deletions
diff --git a/lib/std/crypto.zig b/lib/std/crypto.zig
index 5763348729..fa69d51d4d 100644
--- a/lib/std/crypto.zig
+++ b/lib/std/crypto.zig
@@ -28,6 +28,8 @@ pub const aead = struct {
pub const Gimli = @import("crypto/gimli.zig").Aead;
pub const ChaCha20Poly1305 = chacha20.Chacha20Poly1305;
pub const XChaCha20Poly1305 = chacha20.XChacha20Poly1305;
+ pub const AEGIS128L = @import("crypto/aegis.zig").AEGIS128L;
+ pub const AEGIS256 = @import("crypto/aegis.zig").AEGIS256;
};
/// MAC functions requiring single-use secret keys.
diff --git a/lib/std/crypto/aegis.zig b/lib/std/crypto/aegis.zig
new file mode 100644
index 0000000000..cb9e4cabe9
--- /dev/null
+++ b/lib/std/crypto/aegis.zig
@@ -0,0 +1,447 @@
+const std = @import("std");
+const mem = std.mem;
+const assert = std.debug.assert;
+const AESBlock = std.crypto.core.aes.Block;
+
+const State128L = struct {
+ blocks: [8]AESBlock,
+
+ fn init(key: [16]u8, nonce: [16]u8) State128L {
+ const c1 = AESBlock.fromBytes(&[16]u8{ 0xdb, 0x3d, 0x18, 0x55, 0x6d, 0xc2, 0x2f, 0xf1, 0x20, 0x11, 0x31, 0x42, 0x73, 0xb5, 0x28, 0xdd });
+ const c2 = AESBlock.fromBytes(&[16]u8{ 0x0, 0x1, 0x01, 0x02, 0x03, 0x05, 0x08, 0x0d, 0x15, 0x22, 0x37, 0x59, 0x90, 0xe9, 0x79, 0x62 });
+ const key_block = AESBlock.fromBytes(&key);
+ const nonce_block = AESBlock.fromBytes(&nonce);
+ const blocks = [8]AESBlock{
+ key_block.xorBlocks(nonce_block),
+ c1,
+ c2,
+ c1,
+ key_block.xorBlocks(nonce_block),
+ key_block.xorBlocks(c2),
+ key_block.xorBlocks(c1),
+ key_block.xorBlocks(c2),
+ };
+ var state = State128L{ .blocks = blocks };
+ var i: usize = 0;
+ while (i < 10) : (i += 1) {
+ state.update(nonce_block, key_block);
+ }
+ return state;
+ }
+
+ inline fn update(state: *State128L, d1: AESBlock, d2: AESBlock) void {
+ const blocks = &state.blocks;
+ const tmp = blocks[7];
+ comptime var i: usize = 7;
+ inline while (i > 0) : (i -= 1) {
+ blocks[i] = blocks[i - 1].encrypt(blocks[i]);
+ }
+ blocks[0] = tmp.encrypt(blocks[0]);
+ blocks[0] = blocks[0].xorBlocks(d1);
+ blocks[4] = blocks[4].xorBlocks(d2);
+ }
+
+ fn enc(state: *State128L, dst: *[32]u8, src: *const [32]u8) void {
+ const blocks = &state.blocks;
+ const msg0 = AESBlock.fromBytes(src[0..16]);
+ const msg1 = AESBlock.fromBytes(src[16..32]);
+ var tmp0 = msg0.xorBlocks(blocks[6]).xorBlocks(blocks[1]);
+ var tmp1 = msg1.xorBlocks(blocks[2]).xorBlocks(blocks[5]);
+ tmp0 = tmp0.xorBlocks(blocks[2].andBlocks(blocks[3]));
+ tmp1 = tmp1.xorBlocks(blocks[6].andBlocks(blocks[7]));
+ dst[0..16].* = tmp0.toBytes();
+ dst[16..32].* = tmp1.toBytes();
+ state.update(msg0, msg1);
+ }
+
+ fn dec(state: *State128L, dst: *[32]u8, src: *const [32]u8) void {
+ const blocks = &state.blocks;
+ var msg0 = AESBlock.fromBytes(src[0..16]).xorBlocks(blocks[6]).xorBlocks(blocks[1]);
+ var msg1 = AESBlock.fromBytes(src[16..32]).xorBlocks(blocks[2]).xorBlocks(blocks[5]);
+ msg0 = msg0.xorBlocks(blocks[2].andBlocks(blocks[3]));
+ msg1 = msg1.xorBlocks(blocks[6].andBlocks(blocks[7]));
+ dst[0..16].* = msg0.toBytes();
+ dst[16..32].* = msg1.toBytes();
+ state.update(msg0, msg1);
+ }
+
+ fn mac(state: *State128L, adlen: usize, mlen: usize) [16]u8 {
+ const blocks = &state.blocks;
+ var sizes: [16]u8 = undefined;
+ mem.writeIntLittle(u64, sizes[0..8], adlen * 8);
+ mem.writeIntLittle(u64, sizes[8..16], mlen * 8);
+ const tmp = AESBlock.fromBytes(&sizes).xorBlocks(blocks[2]);
+ var i: usize = 0;
+ while (i < 7) : (i += 1) {
+ state.update(tmp, tmp);
+ }
+ return blocks[0].xorBlocks(blocks[1]).xorBlocks(blocks[2]).xorBlocks(blocks[3]).xorBlocks(blocks[4]).
+ xorBlocks(blocks[5]).xorBlocks(blocks[6]).toBytes();
+ }
+};
+
+/// AEGIS is a very fast authenticated encryption system built on top of the core AES function.
+///
+/// The 128L variant of AEGIS has a 128 bit key, a 128 bit nonce, and processes 256 bit message blocks.
+/// It was designed to fully exploit the parallelism and built-in AES support of recent Intel and ARM CPUs.
+///
+/// https://competitions.cr.yp.to/round3/aegisv11.pdf
+pub const AEGIS128L = struct {
+ pub const tag_length = 16;
+ pub const nonce_length = 16;
+ pub const key_length = 16;
+
+ /// c: ciphertext: output buffer should be of size m.len
+ /// tag: authentication tag: output MAC
+ /// m: message
+ /// ad: Associated Data
+ /// npub: public nonce
+ /// k: private key
+ pub fn encrypt(c: []u8, tag: *[tag_length]u8, m: []const u8, ad: []const u8, npub: [nonce_length]u8, key: [key_length]u8) void {
+ assert(c.len == m.len);
+ var state = State128L.init(key, npub);
+ var src: [32]u8 align(16) = undefined;
+ var dst: [32]u8 align(16) = undefined;
+ var i: usize = 0;
+ while (i + 32 <= ad.len) : (i += 32) {
+ state.enc(&dst, ad[i..][0..32]);
+ }
+ if (ad.len % 32 != 0) {
+ mem.set(u8, src[0..], 0);
+ mem.copy(u8, src[0 .. ad.len % 32], ad[i .. i + ad.len % 32]);
+ state.enc(&dst, &src);
+ }
+ i = 0;
+ while (i + 32 <= m.len) : (i += 32) {
+ state.enc(c[i..][0..32], m[i..][0..32]);
+ }
+ if (m.len % 32 != 0) {
+ mem.set(u8, src[0..], 0);
+ mem.copy(u8, src[0 .. m.len % 32], m[i .. i + m.len % 32]);
+ state.enc(&dst, &src);
+ mem.copy(u8, c[i .. i + m.len % 32], dst[0 .. m.len % 32]);
+ }
+ tag.* = state.mac(ad.len, m.len);
+ }
+
+ /// m: message: output buffer should be of size c.len
+ /// c: ciphertext
+ /// tag: authentication tag
+ /// ad: Associated Data
+ /// npub: public nonce
+ /// k: private key
+ pub fn decrypt(m: []u8, c: []const u8, tag: [tag_length]u8, ad: []const u8, npub: [nonce_length]u8, key: [key_length]u8) !void {
+ assert(c.len == m.len);
+ var state = State128L.init(key, npub);
+ var src: [32]u8 align(16) = undefined;
+ var dst: [32]u8 align(16) = undefined;
+ var i: usize = 0;
+ while (i + 32 <= ad.len) : (i += 32) {
+ state.enc(&dst, ad[i..][0..32]);
+ }
+ if (ad.len % 32 != 0) {
+ mem.set(u8, src[0..], 0);
+ mem.copy(u8, src[0 .. ad.len % 32], ad[i .. i + ad.len % 32]);
+ state.enc(&dst, &src);
+ }
+ i = 0;
+ while (i + 32 <= m.len) : (i += 32) {
+ state.dec(m[i..][0..32], c[i..][0..32]);
+ }
+ if (m.len % 32 != 0) {
+ mem.set(u8, src[0..], 0);
+ mem.copy(u8, src[0 .. m.len % 32], c[i .. i + m.len % 32]);
+ state.dec(&dst, &src);
+ mem.copy(u8, m[i .. i + m.len % 32], dst[0 .. m.len % 32]);
+ mem.set(u8, dst[0 .. m.len % 32], 0);
+ const blocks = &state.blocks;
+ blocks[0] = blocks[0].xorBlocks(AESBlock.fromBytes(dst[0..16]));
+ blocks[4] = blocks[4].xorBlocks(AESBlock.fromBytes(dst[16..32]));
+ }
+ const computed_tag = state.mac(ad.len, m.len);
+ var acc: u8 = 0;
+ for (computed_tag) |_, j| {
+ acc |= (computed_tag[j] ^ tag[j]);
+ }
+ if (acc != 0) {
+ mem.set(u8, m, 0xaa);
+ return error.AuthenticationFailed;
+ }
+ }
+};
+
+const State256 = struct {
+ blocks: [6]AESBlock,
+
+ fn init(key: [32]u8, nonce: [32]u8) State256 {
+ const c1 = AESBlock.fromBytes(&[16]u8{ 0xdb, 0x3d, 0x18, 0x55, 0x6d, 0xc2, 0x2f, 0xf1, 0x20, 0x11, 0x31, 0x42, 0x73, 0xb5, 0x28, 0xdd });
+ const c2 = AESBlock.fromBytes(&[16]u8{ 0x0, 0x1, 0x01, 0x02, 0x03, 0x05, 0x08, 0x0d, 0x15, 0x22, 0x37, 0x59, 0x90, 0xe9, 0x79, 0x62 });
+ const key_block1 = AESBlock.fromBytes(key[0..16]);
+ const key_block2 = AESBlock.fromBytes(key[16..32]);
+ const nonce_block1 = AESBlock.fromBytes(nonce[0..16]);
+ const nonce_block2 = AESBlock.fromBytes(nonce[16..32]);
+ const kxn1 = key_block1.xorBlocks(nonce_block1);
+ const kxn2 = key_block2.xorBlocks(nonce_block2);
+ const blocks = [6]AESBlock{
+ kxn1,
+ kxn2,
+ c1,
+ c2,
+ key_block1.xorBlocks(c2),
+ key_block2.xorBlocks(c1),
+ };
+ var state = State256{ .blocks = blocks };
+ var i: usize = 0;
+ while (i < 4) : (i += 1) {
+ state.update(key_block1);
+ state.update(key_block2);
+ state.update(kxn1);
+ state.update(kxn2);
+ }
+ return state;
+ }
+
+ inline fn update(state: *State256, d: AESBlock) void {
+ const blocks = &state.blocks;
+ const tmp = blocks[5].encrypt(blocks[0]);
+ comptime var i: usize = 5;
+ inline while (i > 0) : (i -= 1) {
+ blocks[i] = blocks[i - 1].encrypt(blocks[i]);
+ }
+ blocks[0] = tmp.xorBlocks(d);
+ }
+
+ fn enc(state: *State256, dst: *[16]u8, src: *const [16]u8) void {
+ const blocks = &state.blocks;
+ const msg = AESBlock.fromBytes(src);
+ var tmp = msg.xorBlocks(blocks[5]).xorBlocks(blocks[4]).xorBlocks(blocks[1]);
+ tmp = tmp.xorBlocks(blocks[2].andBlocks(blocks[3]));
+ dst.* = tmp.toBytes();
+ state.update(msg);
+ }
+
+ fn dec(state: *State256, dst: *[16]u8, src: *const [16]u8) void {
+ const blocks = &state.blocks;
+ var msg = AESBlock.fromBytes(src).xorBlocks(blocks[5]).xorBlocks(blocks[4]).xorBlocks(blocks[1]);
+ msg = msg.xorBlocks(blocks[2].andBlocks(blocks[3]));
+ dst.* = msg.toBytes();
+ state.update(msg);
+ }
+
+ fn mac(state: *State256, adlen: usize, mlen: usize) [16]u8 {
+ const blocks = &state.blocks;
+ var sizes: [16]u8 = undefined;
+ mem.writeIntLittle(u64, sizes[0..8], adlen * 8);
+ mem.writeIntLittle(u64, sizes[8..16], mlen * 8);
+ const tmp = AESBlock.fromBytes(&sizes).xorBlocks(blocks[3]);
+ var i: usize = 0;
+ while (i < 7) : (i += 1) {
+ state.update(tmp);
+ }
+ return blocks[0].xorBlocks(blocks[1]).xorBlocks(blocks[2]).xorBlocks(blocks[3]).xorBlocks(blocks[4]).
+ xorBlocks(blocks[5]).toBytes();
+ }
+};
+
+/// AEGIS is a very fast authenticated encryption system built on top of the core AES function.
+///
+/// The 256 bit variant of AEGIS has a 256 bit key, a 256 bit nonce, and processes 128 bit message blocks.
+///
+/// https://competitions.cr.yp.to/round3/aegisv11.pdf
+pub const AEGIS256 = struct {
+ pub const tag_length = 16;
+ pub const nonce_length = 32;
+ pub const key_length = 32;
+
+ /// c: ciphertext: output buffer should be of size m.len
+ /// tag: authentication tag: output MAC
+ /// m: message
+ /// ad: Associated Data
+ /// npub: public nonce
+ /// k: private key
+ pub fn encrypt(c: []u8, tag: *[tag_length]u8, m: []const u8, ad: []const u8, npub: [nonce_length]u8, key: [key_length]u8) void {
+ assert(c.len == m.len);
+ var state = State256.init(key, npub);
+ var src: [16]u8 align(16) = undefined;
+ var dst: [16]u8 align(16) = undefined;
+ var i: usize = 0;
+ while (i + 16 <= ad.len) : (i += 16) {
+ state.enc(&dst, ad[i..][0..16]);
+ }
+ if (ad.len % 16 != 0) {
+ mem.set(u8, src[0..], 0);
+ mem.copy(u8, src[0 .. ad.len % 16], ad[i .. i + ad.len % 16]);
+ state.enc(&dst, &src);
+ }
+ i = 0;
+ while (i + 16 <= m.len) : (i += 16) {
+ state.enc(c[i..][0..16], m[i..][0..16]);
+ }
+ if (m.len % 16 != 0) {
+ mem.set(u8, src[0..], 0);
+ mem.copy(u8, src[0 .. m.len % 16], m[i .. i + m.len % 16]);
+ state.enc(&dst, &src);
+ mem.copy(u8, c[i .. i + m.len % 16], dst[0 .. m.len % 16]);
+ }
+ tag.* = state.mac(ad.len, m.len);
+ }
+
+ /// m: message: output buffer should be of size c.len
+ /// c: ciphertext
+ /// tag: authentication tag
+ /// ad: Associated Data
+ /// npub: public nonce
+ /// k: private key
+ pub fn decrypt(m: []u8, c: []const u8, tag: [tag_length]u8, ad: []const u8, npub: [nonce_length]u8, key: [key_length]u8) !void {
+ assert(c.len == m.len);
+ var state = State256.init(key, npub);
+ var src: [16]u8 align(16) = undefined;
+ var dst: [16]u8 align(16) = undefined;
+ var i: usize = 0;
+ while (i + 16 <= ad.len) : (i += 16) {
+ state.enc(&dst, ad[i..][0..16]);
+ }
+ if (ad.len % 16 != 0) {
+ mem.set(u8, src[0..], 0);
+ mem.copy(u8, src[0 .. ad.len % 16], ad[i .. i + ad.len % 16]);
+ state.enc(&dst, &src);
+ }
+ i = 0;
+ while (i + 16 <= m.len) : (i += 16) {
+ state.dec(m[i..][0..16], c[i..][0..16]);
+ }
+ if (m.len % 16 != 0) {
+ mem.set(u8, src[0..], 0);
+ mem.copy(u8, src[0 .. m.len % 16], c[i .. i + m.len % 16]);
+ state.dec(&dst, &src);
+ mem.copy(u8, m[i .. i + m.len % 16], dst[0 .. m.len % 16]);
+ mem.set(u8, dst[0 .. m.len % 16], 0);
+ const blocks = &state.blocks;
+ blocks[0] = blocks[0].xorBlocks(AESBlock.fromBytes(&dst));
+ }
+ const computed_tag = state.mac(ad.len, m.len);
+ var acc: u8 = 0;
+ for (computed_tag) |_, j| {
+ acc |= (computed_tag[j] ^ tag[j]);
+ }
+ if (acc != 0) {
+ mem.set(u8, m, 0xaa);
+ return error.AuthenticationFailed;
+ }
+ }
+};
+
+const htest = @import("test.zig");
+const testing = std.testing;
+
+test "AEGIS128L test vector 1" {
+ const key: [AEGIS128L.key_length]u8 = [_]u8{ 0x10, 0x01 } ++ [_]u8{0x00} ** 14;
+ const nonce: [AEGIS128L.nonce_length]u8 = [_]u8{ 0x10, 0x00, 0x02 } ++ [_]u8{0x00} ** 13;
+ const ad = [8]u8{ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 };
+ const m = [32]u8{ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f };
+ var c: [m.len]u8 = undefined;
+ var m2: [m.len]u8 = undefined;
+ var tag: [AEGIS128L.tag_length]u8 = undefined;
+
+ AEGIS128L.encrypt(&c, &tag, &m, &ad, nonce, key);
+ try AEGIS128L.decrypt(&m2, &c, tag, &ad, nonce, key);
+ testing.expectEqualSlices(u8, &m, &m2);
+
+ htest.assertEqual("79d94593d8c2119d7e8fd9b8fc77845c5c077a05b2528b6ac54b563aed8efe84", &c);
+ htest.assertEqual("cc6f3372f6aa1bb82388d695c3962d9a", &tag);
+
+ c[0] +%= 1;
+ testing.expectError(error.AuthenticationFailed, AEGIS128L.decrypt(&m2, &c, tag, &ad, nonce, key));
+ c[0] -%= 1;
+ tag[0] +%= 1;
+ testing.expectError(error.AuthenticationFailed, AEGIS128L.decrypt(&m2, &c, tag, &ad, nonce, key));
+}
+
+test "AEGIS128L test vector 2" {
+ const key: [AEGIS128L.key_length]u8 = [_]u8{0x00} ** 16;
+ const nonce: [AEGIS128L.nonce_length]u8 = [_]u8{0x00} ** 16;
+ const ad = [_]u8{};
+ const m = [_]u8{0x00} ** 16;
+ var c: [m.len]u8 = undefined;
+ var m2: [m.len]u8 = undefined;
+ var tag: [AEGIS128L.tag_length]u8 = undefined;
+
+ AEGIS128L.encrypt(&c, &tag, &m, &ad, nonce, key);
+ try AEGIS128L.decrypt(&m2, &c, tag, &ad, nonce, key);
+ testing.expectEqualSlices(u8, &m, &m2);
+
+ htest.assertEqual("41de9000a7b5e40e2d68bb64d99ebb19", &c);
+ htest.assertEqual("f4d997cc9b94227ada4fe4165422b1c8", &tag);
+}
+
+test "AEGIS128L test vector 3" {
+ const key: [AEGIS128L.key_length]u8 = [_]u8{0x00} ** 16;
+ const nonce: [AEGIS128L.nonce_length]u8 = [_]u8{0x00} ** 16;
+ const ad = [_]u8{};
+ const m = [_]u8{};
+ var c: [m.len]u8 = undefined;
+ var m2: [m.len]u8 = undefined;
+ var tag: [AEGIS128L.tag_length]u8 = undefined;
+
+ AEGIS128L.encrypt(&c, &tag, &m, &ad, nonce, key);
+ try AEGIS128L.decrypt(&m2, &c, tag, &ad, nonce, key);
+ testing.expectEqualSlices(u8, &m, &m2);
+
+ htest.assertEqual("83cc600dc4e3e7e62d4055826174f149", &tag);
+}
+
+test "AEGIS256 test vector 1" {
+ const key: [AEGIS256.key_length]u8 = [_]u8{ 0x10, 0x01 } ++ [_]u8{0x00} ** 30;
+ const nonce: [AEGIS256.nonce_length]u8 = [_]u8{ 0x10, 0x00, 0x02 } ++ [_]u8{0x00} ** 29;
+ const ad = [8]u8{ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 };
+ const m = [32]u8{ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f };
+ var c: [m.len]u8 = undefined;
+ var m2: [m.len]u8 = undefined;
+ var tag: [AEGIS256.tag_length]u8 = undefined;
+
+ AEGIS256.encrypt(&c, &tag, &m, &ad, nonce, key);
+ try AEGIS256.decrypt(&m2, &c, tag, &ad, nonce, key);
+ testing.expectEqualSlices(u8, &m, &m2);
+
+ htest.assertEqual("f373079ed84b2709faee373584585d60accd191db310ef5d8b11833df9dec711", &c);
+ htest.assertEqual("8d86f91ee606e9ff26a01b64ccbdd91d", &tag);
+
+ c[0] +%= 1;
+ testing.expectError(error.AuthenticationFailed, AEGIS256.decrypt(&m2, &c, tag, &ad, nonce, key));
+ c[0] -%= 1;
+ tag[0] +%= 1;
+ testing.expectError(error.AuthenticationFailed, AEGIS256.decrypt(&m2, &c, tag, &ad, nonce, key));
+}
+
+test "AEGIS256 test vector 2" {
+ const key: [AEGIS256.key_length]u8 = [_]u8{0x00} ** 32;
+ const nonce: [AEGIS256.nonce_length]u8 = [_]u8{0x00} ** 32;
+ const ad = [_]u8{};
+ const m = [_]u8{0x00} ** 16;
+ var c: [m.len]u8 = undefined;
+ var m2: [m.len]u8 = undefined;
+ var tag: [AEGIS256.tag_length]u8 = undefined;
+
+ AEGIS256.encrypt(&c, &tag, &m, &ad, nonce, key);
+ try AEGIS256.decrypt(&m2, &c, tag, &ad, nonce, key);
+ testing.expectEqualSlices(u8, &m, &m2);
+
+ htest.assertEqual("b98f03a947807713d75a4fff9fc277a6", &c);
+ htest.assertEqual("478f3b50dc478ef7d5cf2d0f7cc13180", &tag);
+}
+
+test "AEGIS256 test vector 3" {
+ const key: [AEGIS256.key_length]u8 = [_]u8{0x00} ** 32;
+ const nonce: [AEGIS256.nonce_length]u8 = [_]u8{0x00} ** 32;
+ const ad = [_]u8{};
+ const m = [_]u8{};
+ var c: [m.len]u8 = undefined;
+ var m2: [m.len]u8 = undefined;
+ var tag: [AEGIS256.tag_length]u8 = undefined;
+
+ AEGIS256.encrypt(&c, &tag, &m, &ad, nonce, key);
+ try AEGIS256.decrypt(&m2, &c, tag, &ad, nonce, key);
+ testing.expectEqualSlices(u8, &m, &m2);
+
+ htest.assertEqual("f7a0878f68bd083e8065354071fc27c3", &tag);
+}
diff --git a/lib/std/crypto/aes/aesni.zig b/lib/std/crypto/aes/aesni.zig
index f13a4a581c..47dd029bec 100644
--- a/lib/std/crypto/aes/aesni.zig
+++ b/lib/std/crypto/aes/aesni.zig
@@ -84,11 +84,21 @@ pub const Block = struct {
};
}
- /// XOR the content of two blocks.
- pub inline fn xor(block1: Block, block2: Block) Block {
+ /// Apply the bitwise XOR operation to the content of two blocks.
+ pub inline fn xorBlocks(block1: Block, block2: Block) Block {
return Block{ .repr = block1.repr ^ block2.repr };
}
+ /// Apply the bitwise AND operation to the content of two blocks.
+ pub inline fn andBlocks(block1: Block, block2: Block) Block {
+ return Block{ .repr = block1.repr & block2.repr };
+ }
+
+ /// Apply the bitwise OR operation to the content of two blocks.
+ pub inline fn orBlocks(block1: Block, block2: Block) Block {
+ return Block{ .repr = block1.repr | block2.repr };
+ }
+
/// Perform operations on multiple blocks in parallel.
pub const parallel = struct {
/// The recommended number of AES encryption/decryption to perform in parallel for the chosen implementation.
@@ -261,7 +271,7 @@ pub fn AESEncryptCtx(comptime AES: type) type {
/// Encrypt a single block.
pub fn encrypt(ctx: Self, dst: *[16]u8, src: *const [16]u8) void {
const round_keys = ctx.key_schedule.round_keys;
- var t = Block.fromBytes(src).xor(round_keys[0]);
+ var t = Block.fromBytes(src).xorBlocks(round_keys[0]);
comptime var i = 1;
inline while (i < rounds) : (i += 1) {
t = t.encrypt(round_keys[i]);
@@ -273,7 +283,7 @@ pub fn AESEncryptCtx(comptime AES: type) type {
/// Encrypt+XOR a single block.
pub fn xor(ctx: Self, dst: *[16]u8, src: *const [16]u8, counter: [16]u8) void {
const round_keys = ctx.key_schedule.round_keys;
- var t = Block.fromBytes(&counter).xor(round_keys[0]);
+ var t = Block.fromBytes(&counter).xorBlocks(round_keys[0]);
comptime var i = 1;
inline while (i < rounds) : (i += 1) {
t = t.encrypt(round_keys[i]);
@@ -288,7 +298,7 @@ pub fn AESEncryptCtx(comptime AES: type) type {
var ts: [count]Block = undefined;
comptime var j = 0;
inline while (j < count) : (j += 1) {
- ts[j] = Block.fromBytes(src[j * 16 .. j * 16 + 16][0..16]).xor(round_keys[0]);
+ ts[j] = Block.fromBytes(src[j * 16 .. j * 16 + 16][0..16]).xorBlocks(round_keys[0]);
}
comptime var i = 1;
inline while (i < rounds) : (i += 1) {
@@ -310,7 +320,7 @@ pub fn AESEncryptCtx(comptime AES: type) type {
var ts: [count]Block = undefined;
comptime var j = 0;
inline while (j < count) : (j += 1) {
- ts[j] = Block.fromBytes(counters[j * 16 .. j * 16 + 16][0..16]).xor(round_keys[0]);
+ ts[j] = Block.fromBytes(counters[j * 16 .. j * 16 + 16][0..16]).xorBlocks(round_keys[0]);
}
comptime var i = 1;
inline while (i < rounds) : (i += 1) {
@@ -352,7 +362,7 @@ pub fn AESDecryptCtx(comptime AES: type) type {
/// Decrypt a single block.
pub fn decrypt(ctx: Self, dst: *[16]u8, src: *const [16]u8) void {
const inv_round_keys = ctx.key_schedule.round_keys;
- var t = Block.fromBytes(src).xor(inv_round_keys[0]);
+ var t = Block.fromBytes(src).xorBlocks(inv_round_keys[0]);
comptime var i = 1;
inline while (i < rounds) : (i += 1) {
t = t.decrypt(inv_round_keys[i]);
@@ -367,7 +377,7 @@ pub fn AESDecryptCtx(comptime AES: type) type {
var ts: [count]Block = undefined;
comptime var j = 0;
inline while (j < count) : (j += 1) {
- ts[j] = Block.fromBytes(src[j * 16 .. j * 16 + 16][0..16]).xor(inv_round_keys[0]);
+ ts[j] = Block.fromBytes(src[j * 16 .. j * 16 + 16][0..16]).xorBlocks(inv_round_keys[0]);
}
comptime var i = 1;
inline while (i < rounds) : (i += 1) {
diff --git a/lib/std/crypto/aes/soft.zig b/lib/std/crypto/aes/soft.zig
index c32662fbc5..5f66f3499e 100644
--- a/lib/std/crypto/aes/soft.zig
+++ b/lib/std/crypto/aes/soft.zig
@@ -125,8 +125,8 @@ pub const Block = struct {
return Block{ .repr = BlockVec{ s0, s1, s2, s3 } };
}
- /// XOR the content of two blocks.
- pub inline fn xor(block1: Block, block2: Block) Block {
+ /// Apply the bitwise XOR operation to the content of two blocks.
+ pub inline fn xorBlocks(block1: Block, block2: Block) Block {
var x: BlockVec = undefined;
comptime var i = 0;
inline while (i < 4) : (i += 1) {
@@ -135,6 +135,26 @@ pub const Block = struct {
return Block{ .repr = x };
}
+ /// Apply the bitwise AND operation to the content of two blocks.
+ pub inline fn andBlocks(block1: Block, block2: Block) Block {
+ var x: BlockVec = undefined;
+ comptime var i = 0;
+ inline while (i < 4) : (i += 1) {
+ x[i] = block1.repr[i] & block2.repr[i];
+ }
+ return Block{ .repr = x };
+ }
+
+ /// Apply the bitwise OR operation to the content of two blocks.
+ pub inline fn orBlocks(block1: Block, block2: Block) Block {
+ var x: BlockVec = undefined;
+ comptime var i = 0;
+ inline while (i < 4) : (i += 1) {
+ x[i] = block1.repr[i] | block2.repr[i];
+ }
+ return Block{ .repr = x };
+ }
+
/// Perform operations on multiple blocks in parallel.
pub const parallel = struct {
/// The recommended number of AES encryption/decryption to perform in parallel for the chosen implementation.
@@ -283,7 +303,7 @@ pub fn AESEncryptCtx(comptime AES: type) type {
/// Encrypt a single block.
pub fn encrypt(ctx: Self, dst: *[16]u8, src: *const [16]u8) void {
const round_keys = ctx.key_schedule.round_keys;
- var t = Block.fromBytes(src).xor(round_keys[0]);
+ var t = Block.fromBytes(src).xorBlocks(round_keys[0]);
comptime var i = 1;
inline while (i < rounds) : (i += 1) {
t = t.encrypt(round_keys[i]);
@@ -295,7 +315,7 @@ pub fn AESEncryptCtx(comptime AES: type) type {
/// Encrypt+XOR a single block.
pub fn xor(ctx: Self, dst: *[16]u8, src: *const [16]u8, counter: [16]u8) void {
const round_keys = ctx.key_schedule.round_keys;
- var t = Block.fromBytes(&counter).xor(round_keys[0]);
+ var t = Block.fromBytes(&counter).xorBlocks(round_keys[0]);
comptime var i = 1;
inline while (i < rounds) : (i += 1) {
t = t.encrypt(round_keys[i]);
@@ -349,7 +369,7 @@ pub fn AESDecryptCtx(comptime AES: type) type {
/// Decrypt a single block.
pub fn decrypt(ctx: Self, dst: *[16]u8, src: *const [16]u8) void {
const inv_round_keys = ctx.key_schedule.round_keys;
- var t = Block.fromBytes(src).xor(inv_round_keys[0]);
+ var t = Block.fromBytes(src).xorBlocks(inv_round_keys[0]);
comptime var i = 1;
inline while (i < rounds) : (i += 1) {
t = t.decrypt(inv_round_keys[i]);
diff --git a/lib/std/crypto/benchmark.zig b/lib/std/crypto/benchmark.zig
index 860f1269f0..3c7e3445a2 100644
--- a/lib/std/crypto/benchmark.zig
+++ b/lib/std/crypto/benchmark.zig
@@ -149,6 +149,8 @@ const aeads = [_]Crypto{
Crypto{ .ty = crypto.aead.ChaCha20Poly1305, .name = "chacha20Poly1305" },
Crypto{ .ty = crypto.aead.XChaCha20Poly1305, .name = "xchacha20Poly1305" },
Crypto{ .ty = crypto.aead.Gimli, .name = "gimli-aead" },
+ Crypto{ .ty = crypto.aead.AEGIS128L, .name = "aegis-128l" },
+ Crypto{ .ty = crypto.aead.AEGIS256, .name = "aegis-256" },
};
pub fn benchmarkAead(comptime Aead: anytype, comptime bytes: comptime_int) !u64 {
@@ -168,7 +170,7 @@ pub fn benchmarkAead(comptime Aead: anytype, comptime bytes: comptime_int) !u64
const start = timer.lap();
while (offset < bytes) : (offset += in.len) {
Aead.encrypt(in[0..], tag[0..], in[0..], &[_]u8{}, nonce, key);
- Aead.decrypt(in[0..], in[0..], tag, &[_]u8{}, nonce, key) catch unreachable;
+ try Aead.decrypt(in[0..], in[0..], tag, &[_]u8{}, nonce, key);
}
mem.doNotOptimizeAway(&in);
const end = timer.read();
diff --git a/lib/std/crypto/gimli.zig b/lib/std/crypto/gimli.zig
index 5b572aad7d..10e8a7dff0 100644
--- a/lib/std/crypto/gimli.zig
+++ b/lib/std/crypto/gimli.zig
@@ -38,7 +38,35 @@ pub const State = struct {
return mem.sliceAsBytes(self.data[0..]);
}
- pub fn permute(self: *Self) void {
+ fn permute_unrolled(self: *Self) void {
+ const state = &self.data;
+ comptime var round = @as(u32, 24);
+ inline while (round > 0) : (round -= 1) {
+ var column = @as(usize, 0);
+ while (column < 4) : (column += 1) {
+ const x = math.rotl(u32, state[column], 24);
+ const y = math.rotl(u32, state[4 + column], 9);
+ const z = state[8 + column];
+ state[8 + column] = ((x ^ (z << 1)) ^ ((y & z) << 2));
+ state[4 + column] = ((y ^ x) ^ ((x | z) << 1));
+ state[column] = ((z ^ y) ^ ((x & y) << 3));
+ }
+ switch (round & 3) {
+ 0 => {
+ mem.swap(u32, &state[0], &state[1]);
+ mem.swap(u32, &state[2], &state[3]);
+ state[0] ^= round | 0x9e377900;
+ },
+ 2 => {
+ mem.swap(u32, &state[0], &state[2]);
+ mem.swap(u32, &state[1], &state[3]);
+ },
+ else => {},
+ }
+ }
+ }
+
+ fn permute_small(self: *Self) void {
const state = &self.data;
var round = @as(u32, 24);
while (round > 0) : (round -= 1) {
@@ -66,6 +94,8 @@ pub const State = struct {
}
}
+ pub const permute = if (std.builtin.mode == .ReleaseSmall) permute_small else permute_unrolled;
+
pub fn squeeze(self: *Self, out: []u8) void {
var i = @as(usize, 0);
while (i + RATE <= out.len) : (i += RATE) {
@@ -249,15 +279,15 @@ pub const Aead = struct {
in = in[State.RATE..];
out = out[State.RATE..];
}) {
- for (buf[0..State.RATE]) |*p, i| {
- p.* ^= in[i];
- out[i] = p.*;
+ for (in[0..State.RATE]) |v, i| {
+ buf[i] ^= v;
}
+ mem.copy(u8, out[0..State.RATE], buf[0..State.RATE]);
state.permute();
}
- for (buf[0..in.len]) |*p, i| {
- p.* ^= in[i];
- out[i] = p.*;
+ for (in[0..]) |v, i| {
+ buf[i] ^= v;
+ out[i] = buf[i];
}
// XOR 1 into the next byte of the state
@@ -291,15 +321,17 @@ pub const Aead = struct {
in = in[State.RATE..];
out = out[State.RATE..];
}) {
- for (buf[0..State.RATE]) |*p, i| {
- out[i] = p.* ^ in[i];
- p.* = in[i];
+ const d = in[0..State.RATE].*;
+ for (d) |v, i| {
+ out[i] = buf[i] ^ v;
}
+ mem.copy(u8, buf[0..State.RATE], d[0..State.RATE]);
state.permute();
}
for (buf[0..in.len]) |*p, i| {
- out[i] = p.* ^ in[i];
- p.* = in[i];
+ const d = in[i];
+ out[i] = p.* ^ d;
+ p.* = d;
}
// XOR 1 into the next byte of the state
diff --git a/lib/std/event/future.zig b/lib/std/event/future.zig
index c9777288e4..40c7845d53 100644
--- a/lib/std/event/future.zig
+++ b/lib/std/event/future.zig
@@ -95,7 +95,7 @@ test "std.event.Future" {
// TODO provide a way to run tests in evented I/O mode
if (!std.io.is_async) return error.SkipZigTest;
- const handle = async testFuture();
+ testFuture();
}
fn testFuture() void {
diff --git a/lib/std/event/lock.zig b/lib/std/event/lock.zig
index d27a12aef8..6819e413d2 100644
--- a/lib/std/event/lock.zig
+++ b/lib/std/event/lock.zig
@@ -16,107 +16,111 @@ const Loop = std.event.Loop;
/// Allows only one actor to hold the lock.
/// TODO: make this API also work in blocking I/O mode.
pub const Lock = struct {
- shared: bool,
- queue: Queue,
- queue_empty: bool,
+ mutex: std.Mutex = std.Mutex{},
+ head: usize = UNLOCKED,
- const Queue = std.atomic.Queue(anyframe);
+ const UNLOCKED = 0;
+ const LOCKED = 1;
const global_event_loop = Loop.instance orelse
@compileError("std.event.Lock currently only works with event-based I/O");
- pub const Held = struct {
- lock: *Lock,
-
- pub fn release(self: Held) void {
- // Resume the next item from the queue.
- if (self.lock.queue.get()) |node| {
- global_event_loop.onNextTick(node);
- return;
- }
-
- // We need to release the lock.
- @atomicStore(bool, &self.lock.queue_empty, true, .SeqCst);
- @atomicStore(bool, &self.lock.shared, false, .SeqCst);
-
- // There might be a queue item. If we know the queue is empty, we can be done,
- // because the other actor will try to obtain the lock.
- // But if there's a queue item, we are the actor which must loop and attempt
- // to grab the lock again.
- if (@atomicLoad(bool, &self.lock.queue_empty, .SeqCst)) {
- return;
- }
-
- while (true) {
- if (@atomicRmw(bool, &self.lock.shared, .Xchg, true, .SeqCst)) {
- // We did not obtain the lock. Great, the queue is someone else's problem.
- return;
- }
-
- // Resume the next item from the queue.
- if (self.lock.queue.get()) |node| {
- global_event_loop.onNextTick(node);
- return;
- }
+ const Waiter = struct {
+ // forced Waiter alignment to ensure it doesn't clash with LOCKED
+ next: ?*Waiter align(2),
+ tail: *Waiter,
+ node: Loop.NextTickNode,
+ };
- // Release the lock again.
- @atomicStore(bool, &self.lock.queue_empty, true, .SeqCst);
- @atomicStore(bool, &self.lock.shared, false, .SeqCst);
+ pub fn initLocked() Lock {
+ return Lock{ .head = LOCKED };
+ }
- // Find out if we can be done.
- if (@atomicLoad(bool, &self.lock.queue_empty, .SeqCst)) {
- return;
- }
- }
+ pub fn acquire(self: *Lock) Held {
+ const held = self.mutex.acquire();
+
+ // self.head transitions from multiple stages depending on the value:
+ // UNLOCKED -> LOCKED:
+ // acquire Lock ownership when theres no waiters
+ // LOCKED -> <Waiter head ptr>:
+ // Lock is already owned, enqueue first Waiter
+ // <head ptr> -> <head ptr>:
+ // Lock is owned with pending waiters. Push our waiter to the queue.
+
+ if (self.head == UNLOCKED) {
+ self.head = LOCKED;
+ held.release();
+ return Held{ .lock = self };
}
- };
- pub fn init() Lock {
- return Lock{
- .shared = false,
- .queue = Queue.init(),
- .queue_empty = true,
- };
- }
+ var waiter: Waiter = undefined;
+ waiter.next = null;
+ waiter.tail = &waiter;
- pub fn initLocked() Lock {
- return Lock{
- .shared = true,
- .queue = Queue.init(),
- .queue_empty = true,
+ const head = switch (self.head) {
+ UNLOCKED => unreachable,
+ LOCKED => null,
+ else => @intToPtr(*Waiter, self.head),
};
- }
- /// Must be called when not locked. Not thread safe.
- /// All calls to acquire() and release() must complete before calling deinit().
- pub fn deinit(self: *Lock) void {
- assert(!self.shared);
- while (self.queue.get()) |node| resume node.data;
- }
-
- pub fn acquire(self: *Lock) callconv(.Async) Held {
- var my_tick_node = Loop.NextTickNode.init(@frame());
+ if (head) |h| {
+ h.tail.next = &waiter;
+ h.tail = &waiter;
+ } else {
+ self.head = @ptrToInt(&waiter);
+ }
- errdefer _ = self.queue.remove(&my_tick_node); // TODO test canceling an acquire
suspend {
- self.queue.put(&my_tick_node);
+ waiter.node = Loop.NextTickNode{
+ .prev = undefined,
+ .next = undefined,
+ .data = @frame(),
+ };
+ held.release();
+ }
- // At this point, we are in the queue, so we might have already been resumed.
+ return Held{ .lock = self };
+ }
- // We set this bit so that later we can rely on the fact, that if queue_empty == true, some actor
- // will attempt to grab the lock.
- @atomicStore(bool, &self.queue_empty, false, .SeqCst);
+ pub const Held = struct {
+ lock: *Lock,
- if (!@atomicRmw(bool, &self.shared, .Xchg, true, .SeqCst)) {
- if (self.queue.get()) |node| {
- // Whether this node is us or someone else, we tail resume it.
- resume node.data;
+ pub fn release(self: Held) void {
+ const waiter = blk: {
+ const held = self.lock.mutex.acquire();
+ defer held.release();
+
+ // self.head goes through the reverse transition from acquire():
+ // <head ptr> -> <new head ptr>:
+ // pop a waiter from the queue to give Lock ownership when theres still others pending
+ // <head ptr> -> LOCKED:
+ // pop the laster waiter from the queue, while also giving it lock ownership when awaken
+ // LOCKED -> UNLOCKED:
+ // last lock owner releases lock while no one else is waiting for it
+
+ switch (self.lock.head) {
+ UNLOCKED => {
+ unreachable; // Lock unlocked while unlocking
+ },
+ LOCKED => {
+ self.lock.head = UNLOCKED;
+ break :blk null;
+ },
+ else => {
+ const waiter = @intToPtr(*Waiter, self.lock.head);
+ self.lock.head = if (waiter.next == null) LOCKED else @ptrToInt(waiter.next);
+ if (waiter.next) |next|
+ next.tail = waiter.tail;
+ break :blk waiter;
+ },
}
+ };
+
+ if (waiter) |w| {
+ global_event_loop.onNextTick(&w.node);
}
}
-
- return Held{ .lock = self };
- }
+ };
};
test "std.event.Lock" {
@@ -128,41 +132,16 @@ test "std.event.Lock" {
// TODO https://github.com/ziglang/zig/issues/3251
if (builtin.os.tag == .freebsd) return error.SkipZigTest;
- // TODO this file has bit-rotted. repair it
- if (true) return error.SkipZigTest;
-
- var lock = Lock.init();
- defer lock.deinit();
-
- _ = async testLock(&lock);
+ var lock = Lock{};
+ testLock(&lock);
const expected_result = [1]i32{3 * @intCast(i32, shared_test_data.len)} ** shared_test_data.len;
testing.expectEqualSlices(i32, &expected_result, &shared_test_data);
}
-fn testLock(lock: *Lock) callconv(.Async) void {
+fn testLock(lock: *Lock) void {
var handle1 = async lockRunner(lock);
- var tick_node1 = Loop.NextTickNode{
- .prev = undefined,
- .next = undefined,
- .data = &handle1,
- };
- Loop.instance.?.onNextTick(&tick_node1);
-
var handle2 = async lockRunner(lock);
- var tick_node2 = Loop.NextTickNode{
- .prev = undefined,
- .next = undefined,
- .data = &handle2,
- };
- Loop.instance.?.onNextTick(&tick_node2);
-
var handle3 = async lockRunner(lock);
- var tick_node3 = Loop.NextTickNode{
- .prev = undefined,
- .next = undefined,
- .data = &handle3,
- };
- Loop.instance.?.onNextTick(&tick_node3);
await handle1;
await handle2;
@@ -171,13 +150,13 @@ fn testLock(lock: *Lock) callconv(.Async) void {
var shared_test_data = [1]i32{0} ** 10;
var shared_test_index: usize = 0;
-fn lockRunner(lock: *Lock) callconv(.Async) void {
- suspend; // resumed by onNextTick
+
+fn lockRunner(lock: *Lock) void {
+ Lock.global_event_loop.yield();
var i: usize = 0;
while (i < shared_test_data.len) : (i += 1) {
- var lock_frame = async lock.acquire();
- const handle = await lock_frame;
+ const handle = lock.acquire();
defer handle.release();
shared_test_index = 0;
diff --git a/lib/std/fs/test.zig b/lib/std/fs/test.zig
index b3cc1fe569..8d7ef5172e 100644
--- a/lib/std/fs/test.zig
+++ b/lib/std/fs/test.zig
@@ -813,3 +813,26 @@ fn run_lock_file_test(contexts: []FileLockTestContext) !void {
try threads.append(try std.Thread.spawn(ctx, FileLockTestContext.run));
}
}
+
+test "deleteDir" {
+ var tmp_dir = tmpDir(.{});
+ defer tmp_dir.cleanup();
+
+ // deleting a non-existent directory
+ testing.expectError(error.FileNotFound, tmp_dir.dir.deleteDir("test_dir"));
+
+ var dir = try tmp_dir.dir.makeOpenPath("test_dir", .{});
+ var file = try dir.createFile("test_file", .{});
+ file.close();
+ dir.close();
+
+ // deleting a non-empty directory
+ testing.expectError(error.DirNotEmpty, tmp_dir.dir.deleteDir("test_dir"));
+
+ dir = try tmp_dir.dir.openDir("test_dir", .{});
+ try dir.deleteFile("test_file");
+ dir.close();
+
+ // deleting an empty directory
+ try tmp_dir.dir.deleteDir("test_dir");
+}
diff --git a/lib/std/meta.zig b/lib/std/meta.zig
index 1507aa9de8..492e497ff4 100644
--- a/lib/std/meta.zig
+++ b/lib/std/meta.zig
@@ -807,7 +807,7 @@ pub fn sizeof(target: anytype) usize {
// TODO to get the correct result we have to translate
// `1073741824 * 4` as `int(1073741824) *% int(4)` since
// sizeof(1073741824 * 4) != sizeof(4294967296).
-
+
// TODO test if target fits in int, long or long long
return @sizeOf(c_int);
},
@@ -826,3 +826,112 @@ test "sizeof" {
testing.expect(sizeof(E.One) == @sizeOf(c_int));
testing.expect(sizeof(S) == 4);
}
+
+/// For a given function type, returns a tuple type which fields will
+/// correspond to the argument types.
+///
+/// Examples:
+/// - `ArgsTuple(fn() void)` ⇒ `tuple { }`
+/// - `ArgsTuple(fn(a: u32) u32)` ⇒ `tuple { u32 }`
+/// - `ArgsTuple(fn(a: u32, b: f16) noreturn)` ⇒ `tuple { u32, f16 }`
+pub fn ArgsTuple(comptime Function: type) type {
+ const info = @typeInfo(Function);
+ if (info != .Fn)
+ @compileError("ArgsTuple expects a function type");
+
+ const function_info = info.Fn;
+ if (function_info.is_generic)
+ @compileError("Cannot create ArgsTuple for generic function");
+ if (function_info.is_var_args)
+ @compileError("Cannot create ArgsTuple for variadic function");
+
+ var argument_field_list: [function_info.args.len]std.builtin.TypeInfo.StructField = undefined;
+ inline for (function_info.args) |arg, i| {
+ @setEvalBranchQuota(10_000);
+ var num_buf: [128]u8 = undefined;
+ argument_field_list[i] = std.builtin.TypeInfo.StructField{
+ .name = std.fmt.bufPrint(&num_buf, "{d}", .{i}) catch unreachable,
+ .field_type = arg.arg_type.?,
+ .default_value = @as(?(arg.arg_type.?), null),
+ .is_comptime = false,
+ };
+ }
+
+ return @Type(std.builtin.TypeInfo{
+ .Struct = std.builtin.TypeInfo.Struct{
+ .is_tuple = true,
+ .layout = .Auto,
+ .decls = &[_]std.builtin.TypeInfo.Declaration{},
+ .fields = &argument_field_list,
+ },
+ });
+}
+
+/// For a given anonymous list of types, returns a new tuple type
+/// with those types as fields.
+///
+/// Examples:
+/// - `Tuple(&[_]type {})` ⇒ `tuple { }`
+/// - `Tuple(&[_]type {f32})` ⇒ `tuple { f32 }`
+/// - `Tuple(&[_]type {f32,u32})` ⇒ `tuple { f32, u32 }`
+pub fn Tuple(comptime types: []const type) type {
+ var tuple_fields: [types.len]std.builtin.TypeInfo.StructField = undefined;
+ inline for (types) |T, i| {
+ @setEvalBranchQuota(10_000);
+ var num_buf: [128]u8 = undefined;
+ tuple_fields[i] = std.builtin.TypeInfo.StructField{
+ .name = std.fmt.bufPrint(&num_buf, "{d}", .{i}) catch unreachable,
+ .field_type = T,
+ .default_value = @as(?T, null),
+ .is_comptime = false,
+ };
+ }
+
+ return @Type(std.builtin.TypeInfo{
+ .Struct = std.builtin.TypeInfo.Struct{
+ .is_tuple = true,
+ .layout = .Auto,
+ .decls = &[_]std.builtin.TypeInfo.Declaration{},
+ .fields = &tuple_fields,
+ },
+ });
+}
+
+const TupleTester = struct {
+ fn assertTypeEqual(comptime Expected: type, comptime Actual: type) void {
+ if (Expected != Actual)
+ @compileError("Expected type " ++ @typeName(Expected) ++ ", but got type " ++ @typeName(Actual));
+ }
+
+ fn assertTuple(comptime expected: anytype, comptime Actual: type) void {
+ const info = @typeInfo(Actual);
+ if (info != .Struct)
+ @compileError("Expected struct type");
+ if (!info.Struct.is_tuple)
+ @compileError("Struct type must be a tuple type");
+
+ const fields_list = std.meta.fields(Actual);
+ if (expected.len != fields_list.len)
+ @compileError("Argument count mismatch");
+
+ inline for (fields_list) |fld, i| {
+ if (expected[i] != fld.field_type) {
+ @compileError("Field " ++ fld.name ++ " expected to be type " ++ @typeName(expected[i]) ++ ", but was type " ++ @typeName(fld.field_type));
+ }
+ }
+ }
+};
+
+test "ArgsTuple" {
+ TupleTester.assertTuple(.{}, ArgsTuple(fn () void));
+ TupleTester.assertTuple(.{u32}, ArgsTuple(fn (a: u32) []const u8));
+ TupleTester.assertTuple(.{ u32, f16 }, ArgsTuple(fn (a: u32, b: f16) noreturn));
+ TupleTester.assertTuple(.{ u32, f16, []const u8 }, ArgsTuple(fn (a: u32, b: f16, c: []const u8) noreturn));
+}
+
+test "Tuple" {
+ TupleTester.assertTuple(.{}, Tuple(&[_]type{}));
+ TupleTester.assertTuple(.{u32}, Tuple(&[_]type{u32}));
+ TupleTester.assertTuple(.{ u32, f16 }, Tuple(&[_]type{ u32, f16 }));
+ TupleTester.assertTuple(.{ u32, f16, []const u8 }, Tuple(&[_]type{ u32, f16, []const u8 }));
+}
diff --git a/lib/std/os/windows.zig b/lib/std/os/windows.zig
index de0d0ea45f..2aa222414f 100644
--- a/lib/std/os/windows.zig
+++ b/lib/std/os/windows.zig
@@ -764,6 +764,7 @@ pub const DeleteFileError = error{
Unexpected,
NotDir,
IsDir,
+ DirNotEmpty,
};
pub const DeleteFileOptions = struct {
@@ -818,7 +819,7 @@ pub fn DeleteFile(sub_path_w: []const u16, options: DeleteFileOptions) DeleteFil
0,
);
switch (rc) {
- .SUCCESS => return CloseHandle(tmp_handle),
+ .SUCCESS => CloseHandle(tmp_handle),
.OBJECT_NAME_INVALID => unreachable,
.OBJECT_NAME_NOT_FOUND => return error.FileNotFound,
.INVALID_PARAMETER => unreachable,
@@ -826,6 +827,21 @@ pub fn DeleteFile(sub_path_w: []const u16, options: DeleteFileOptions) DeleteFil
.NOT_A_DIRECTORY => return error.NotDir,
else => return unexpectedStatus(rc),
}
+
+ // If a directory fails to be deleted, CloseHandle will still report success
+ // Check if the directory still exists and return error.DirNotEmpty if true
+ if (options.remove_dir) {
+ var basic_info: FILE_BASIC_INFORMATION = undefined;
+ switch (ntdll.NtQueryAttributesFile(&attr, &basic_info)) {
+ .SUCCESS => return error.DirNotEmpty,
+ .OBJECT_NAME_NOT_FOUND => return,
+ .OBJECT_PATH_NOT_FOUND => return,
+ .INVALID_PARAMETER => unreachable,
+ .ACCESS_DENIED => return error.AccessDenied,
+ .OBJECT_PATH_SYNTAX_BAD => unreachable,
+ else => |urc| return unexpectedStatus(urc),
+ }
+ }
}
pub const MoveFileError = error{ FileNotFound, Unexpected };
diff --git a/lib/std/zig/tokenizer.zig b/lib/std/zig/tokenizer.zig
index 86968c73b2..e40483c022 100644
--- a/lib/std/zig/tokenizer.zig
+++ b/lib/std/zig/tokenizer.zig
@@ -1195,6 +1195,7 @@ pub const Tokenizer = struct {
},
.num_dot_hex => switch (c) {
'.' => {
+ result.id = .IntegerLiteral;
self.index -= 1;
state = .start;
break;
@@ -1758,6 +1759,14 @@ test "correctly parse pointer assignment" {
});
}
+test "tokenizer - range literals" {
+ testTokenize("0...9", &[_]Token.Id{ .IntegerLiteral, .Ellipsis3, .IntegerLiteral });
+ testTokenize("'0'...'9'", &[_]Token.Id{ .CharLiteral, .Ellipsis3, .CharLiteral });
+ testTokenize("0x00...0x09", &[_]Token.Id{ .IntegerLiteral, .Ellipsis3, .IntegerLiteral });
+ testTokenize("0b00...0b11", &[_]Token.Id{ .IntegerLiteral, .Ellipsis3, .IntegerLiteral });
+ testTokenize("0o00...0o11", &[_]Token.Id{ .IntegerLiteral, .Ellipsis3, .IntegerLiteral });
+}
+
test "tokenizer - number literals decimal" {
testTokenize("0", &[_]Token.Id{.IntegerLiteral});
testTokenize("1", &[_]Token.Id{.IntegerLiteral});
diff --git a/src/tokenizer.cpp b/src/tokenizer.cpp
index 4415bdf431..fa14dd40fa 100644
--- a/src/tokenizer.cpp
+++ b/src/tokenizer.cpp
@@ -1225,9 +1225,6 @@ void tokenize(Buf *buf, Tokenization *out) {
invalid_char_error(&t, c);
break;
}
- if (t.radix != 16 && t.radix != 10) {
- invalid_char_error(&t, c);
- }
t.state = TokenizeStateNumberDot;
break;
}
@@ -1281,6 +1278,9 @@ void tokenize(Buf *buf, Tokenization *out) {
t.state = TokenizeStateStart;
continue;
}
+ if (t.radix != 16 && t.radix != 10) {
+ invalid_char_error(&t, c);
+ }
t.pos -= 1;
t.state = TokenizeStateFloatFractionNoUnderscore;
assert(t.cur_tok->id == TokenIdIntLiteral);
generated by cgit v1.2.3 (git 2.39.1) at 2025-12-27 22:04:06 +0000