@zigc/lib 0.17.0-dev.690 → 0.17.0-dev.702

package/compiler/Maker/ScannedConfig.zig

@@ -350,6 +350,7 @@ pub fn printUsage(sc: *const ScannedConfig, graph: *Graph, w: *Writer) !void {
         \\      disallowed               Panics when cache would be poisoned
         \\      ignored                  A little poison never hurt anybody
         \\  --print-configuration        Render configuration as .zon to stdout
+        \\  --print-configuration-path   Print the path to the binary configuration file to stdout
         \\  --build-id[=style]           At a minor link-time expense, embeds a build ID in binaries
         \\      fast                     8-byte non-cryptographic hash (COFF, ELF, WASM)
         \\      sha1, tree               20-byte cryptographic hash (ELF, WASM)

package/compiler/Maker.zig

@@ -1843,10 +1843,10 @@ pub fn relativePath(maker: *const Maker, arena: Allocator, relative: Configurati
             .root_dir = graph.zig_lib_directory,
             .sub_path = sub_path,
         },
-        .install_prefix => maker.install_paths.prefix,
-        .install_lib => maker.install_paths.lib,
-        .install_bin => maker.install_paths.bin,
-        .install_include => maker.install_paths.include,
+        .install_prefix => try maker.install_paths.prefix.join(arena, sub_path),
+        .install_lib => try maker.install_paths.lib.join(arena, sub_path),
+        .install_bin => try maker.install_paths.bin.join(arena, sub_path),
+        .install_include => try maker.install_paths.include.join(arena, sub_path),
     };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zigc/lib",
-  "version": "0.17.0-dev.690",
+  "version": "0.17.0-dev.702",
   "description": "Zig standard library and libc headers (shared across all platforms)",
   "repository": {
     "type": "git",

package/std/Io/Reader.zig

@@ -242,11 +242,10 @@ pub fn streamExactPreserve(r: *Reader, w: *Writer, preserve_len: usize, n: usize
         remaining -= try r.stream(w, .limited(remaining - preserve_len));
         if (w.end + remaining <= w.buffer.len) return streamExact(r, w, remaining);
     }
-    // All the next bytes received must be preserved.
-    if (preserve_len < w.end) {
-        @memmove(w.buffer[0..preserve_len], w.buffer[w.end - preserve_len ..][0..preserve_len]);
-        w.end = preserve_len;
-    }
+    // Offset the amount preserved by the amount we have left to stream
+    // since the remaining bytes are always going to be part of that
+    // preservation.
+    try w.rebase(preserve_len -| remaining, remaining);
     return streamExact(r, w, remaining);
 }
 
@@ -2300,6 +2299,50 @@ fn testLeb128(comptime T: type, encoded: []const u8) !T {
     return result;
 }
 
+test streamExactPreserve {
+    try testStreamExactPreserve(.{ .buf_len = 10, .fill_len = 5, .preserve = 5, .stream_len = 5 });
+    try testStreamExactPreserve(.{ .buf_len = 10, .fill_len = 9, .preserve = 5, .stream_len = 2 });
+    try testStreamExactPreserve(.{ .buf_len = 10, .fill_len = 5, .preserve = 5, .stream_len = 6 });
+    try testStreamExactPreserve(.{ .buf_len = 10, .fill_len = 5, .preserve = 6, .stream_len = 6 });
+    try testStreamExactPreserve(.{ .buf_len = 10, .fill_len = 5, .preserve = 5, .stream_len = 10 });
+    try testStreamExactPreserve(.{ .buf_len = 10, .fill_len = 5, .preserve = 6, .stream_len = 10 });
+    try testStreamExactPreserve(.{ .buf_len = 10, .fill_len = 5, .preserve = 6, .stream_len = 11 });
+    try testStreamExactPreserve(.{ .buf_len = 10, .fill_len = 5, .preserve = 6, .stream_len = 80 });
+    try testStreamExactPreserve(.{ .buf_len = 10, .fill_len = 5, .preserve = 6, .stream_len = 85 });
+    try testStreamExactPreserve(.{ .buf_len = 10, .fill_len = 5, .preserve = 10, .stream_len = 6 });
+    try testStreamExactPreserve(.{ .buf_len = 10, .fill_len = 5, .preserve = 10, .stream_len = 11 });
+    try testStreamExactPreserve(.{ .buf_len = 10, .fill_len = 5, .preserve = 10, .stream_len = 80 });
+    try testStreamExactPreserve(.{ .buf_len = 10, .fill_len = 5, .preserve = 10, .stream_len = 85 });
+}
+
+fn testStreamExactPreserve(options: struct { buf_len: u4, fill_len: u4, preserve: u4, stream_len: u8 }) !void {
+    assert(options.fill_len <= options.buf_len);
+    assert(options.preserve <= options.buf_len);
+
+    var input: [256]u8 = undefined;
+    for (&input, 0..) |*val, i| {
+        val.* = @as(u8, @intCast(i % 26)) + 'a';
+    }
+    const expected_out = input[0 .. options.fill_len + options.stream_len];
+    const expected_preserved = expected_out[expected_out.len -| options.preserve..];
+
+    var r: Reader = .fixed(&input);
+    var out_buf: [256]u8 = undefined;
+    var fw: Writer = .fixed(&out_buf);
+    var indirect_buffer: [16]u8 = undefined;
+    var twi: std.testing.WriterIndirect = .init(&fw, indirect_buffer[0..options.buf_len]);
+    const w = &twi.interface;
+
+    try r.streamExact(w, options.fill_len);
+    try r.streamExactPreserve(w, options.preserve, options.stream_len);
+
+    try std.testing.expectEqualStrings(expected_preserved, w.buffer[w.end -| options.preserve..w.end]);
+
+    try w.flush();
+
+    try std.testing.expectEqualStrings(expected_out, fw.buffered());
+}
+
 test {
     _ = Limited;
 }

package/std/array_hash_map.zig

@@ -57,8 +57,7 @@ pub const ArrayHashMap = Custom;
 /// the (well defined) behavior when mixing insertions and deletions with iteration.
 ///
 /// This type does not store an `Allocator` field - the `Allocator` must be passed in
-/// with each function call that requires it. See `ArrayHashMap` for a type that stores
-/// an `Allocator` field for convenience.
+/// with each function call that requires it.
 ///
 /// Can be initialized directly using the default field values.
 ///