srctree

pub const Directory = struct {

/// This field is redundant for operations that can act on the open directory handle

/// directly, but it is needed when passing the directory to a child process.

/// `null` means cwd.

path: ?[]const u8,

handle: fs.Dir,

 

pub fn clone(d: Directory, arena: Allocator) Allocator.Error!Directory {

return .{

.path = if (d.path) |p| try arena.dupe(u8, p) else null,

.handle = d.handle,

};

}

 

pub fn cwd() Directory {

return .{

.path = null,

.handle = fs.cwd(),

};

}

 

pub fn join(self: Directory, allocator: Allocator, paths: []const []const u8) ![]u8 {

if (self.path) |p| {

// TODO clean way to do this with only 1 allocation

const part2 = try fs.path.join(allocator, paths);

defer allocator.free(part2);

return fs.path.join(allocator, &[_][]const u8{ p, part2 });

} else {

return fs.path.join(allocator, paths);

}

}

 

pub fn joinZ(self: Directory, allocator: Allocator, paths: []const []const u8) ![:0]u8 {

if (self.path) |p| {

// TODO clean way to do this with only 1 allocation

const part2 = try fs.path.join(allocator, paths);

defer allocator.free(part2);

return fs.path.joinZ(allocator, &[_][]const u8{ p, part2 });

} else {

return fs.path.joinZ(allocator, paths);

}

}

 

/// Whether or not the handle should be closed, or the path should be freed

/// is determined by usage, however this function is provided for convenience

/// if it happens to be what the caller needs.

pub fn closeAndFree(self: *Directory, gpa: Allocator) void {

self.handle.close();

if (self.path) |p| gpa.free(p);

self.* = undefined;

}

 

pub fn format(

self: Directory,

comptime fmt_string: []const u8,

options: fmt.FormatOptions,

writer: anytype,

) !void {

_ = options;

if (fmt_string.len != 0) fmt.invalidFmtError(fmt_string, self);

if (self.path) |p| {

try writer.writeAll(p);

try writer.writeAll(fs.path.sep_str);

}

}

 

pub fn eql(self: Directory, other: Directory) bool {

return self.handle.fd == other.handle.fd;

}

};

 

sub_path: []u8,

const manifest_file_size_max = 50 * 1024 * 1024;

prefixed_path: ?PrefixedPath,

if (self.prefixed_path) |pp| {

gpa.free(pp.sub_path);

self.prefixed_path = null;

}

files: std.ArrayListUnmanaged(File) = .{},

/// var file_contents = cache_hash.files.items[file_index].contents.?;

self.files.addOneAssumeCapacity().* = .{

return self.files.items.len - 1;

const input_file_count = self.files.items.len;

const ch_file = &self.files.items[idx];

const cache_hash_file = if (idx < input_file_count) &self.files.items[idx] else blk: {

const new = try self.files.addOne(gpa);

new.* = .{

.prefixed_path = null,

.contents = null,

.max_file_size = null,

.stat = undefined,

.bin_digest = undefined,

};

break :blk new;

};

 

cache_hash_file.stat.size = fmt.parseInt(u64, size, 10) catch return error.InvalidFormat;

cache_hash_file.stat.inode = fmt.parseInt(fs.File.INode, inode, 10) catch return error.InvalidFormat;

cache_hash_file.stat.mtime = fmt.parseInt(i64, mtime_nsec_str, 10) catch return error.InvalidFormat;

_ = fmt.hexToBytes(&cache_hash_file.bin_digest, digest_str) catch return error.InvalidFormat;

if (file_path.len == 0) {

return error.InvalidFormat;

}

if (cache_hash_file.prefixed_path) |pp| {

if (pp.prefix != prefix or !mem.eql(u8, file_path, pp.sub_path)) {

return error.InvalidFormat;

}

}

if (cache_hash_file.prefixed_path == null) {

cache_hash_file.prefixed_path = .{

.sub_path = try gpa.dupe(u8, file_path),

}

const pp = cache_hash_file.prefixed_path.?;

const ch_file = &self.files.items[idx];

for (self.files.items[input_file_count..]) |*file| {

for (self.files.items) |file| {

const pp = ch_file.prefixed_path.?;

errdefer self.files.shrinkRetainingCapacity(self.files.items.len - 1);

/// calculated. This is useful for processes that don't know the all the files that

/// are depended on ahead of time. For example, a source file that can import other files

/// will need to be recompiled if the imported file is changed.

const new_ch_file = try self.files.addOne(gpa);

new_ch_file.* = .{

errdefer self.files.shrinkRetainingCapacity(self.files.items.len - 1);

try self.populateFileHash(new_ch_file);

const ch_file = try self.files.addOne(gpa);

errdefer self.files.shrinkRetainingCapacity(self.files.items.len - 1);

 

ch_file.* = .{

if (self.isProblematicTimestamp(ch_file.stat.mtime)) {

ch_file.stat.mtime = 0;

ch_file.stat.inode = 0;

hasher.final(&ch_file.bin_digest);

self.hash.hasher.update(&ch_file.bin_digest);

for (self.files.items) |file| {

file.prefixed_path.?.prefix,

file.prefixed_path.?.sub_path,

for (self.files.items) |*file| {

try testing.expect(mem.eql(u8, original_temp_file_contents, ch.files.items[temp_file_idx].contents.?));

try testing.expect(ch.files.items[temp_file_idx].contents == null);

const pp = man.files.items[i].prefixed_path orelse return err;

/// An ArrayHashMap with default hash and equal functions.

/// See AutoContext for a description of the hash and equal implementations.

/// An ArrayHashMapUnmanaged with default hash and equal functions.

/// See AutoContext for a description of the hash and equal implementations.

/// Builtin hashmap for strings as keys.

/// Insertion order is preserved.

/// Deletions perform a "swap removal" on the entries list.

/// For a hash map that can be initialized directly that does not store an Allocator

/// field, see `ArrayHashMapUnmanaged`.

/// When `store_hash` is `false`, this data structure is biased towards cheap `eql`

/// functions. It does not store each item's hash in the table. Setting `store_hash`

/// to `true` incurs slightly more memory cost by storing each key's hash in the table

/// but only has to call `eql` for hash collisions.

/// If typical operations (except iteration over entries) need to be faster, prefer

/// the alternative `std.HashMap`.

/// Context must be a struct type with two member functions:

/// hash(self, K) u32

/// eql(self, K, K, usize) bool

/// Adapted variants of many functions are provided. These variants

/// take a pseudo key instead of a key. Their context must have the functions:

/// hash(self, PseudoKey) u32

/// eql(self, PseudoKey, K, usize) bool

/// General purpose hash table.

/// Insertion order is preserved.

/// Deletions perform a "swap removal" on the entries list.

/// This type does not store an Allocator field - the Allocator must be passed in

/// an Allocator field for convenience.

/// When `store_hash` is `false`, this data structure is biased towards cheap `eql`

/// functions. It does not store each item's hash in the table. Setting `store_hash`

/// to `true` incurs slightly more memory cost by storing each key's hash in the table

/// but guarantees only one call to `eql` per insertion/deletion.

/// Context must be a struct type with two member functions:

/// hash(self, K) u32

/// eql(self, K, K) bool

/// Adapted variants of many functions are provided. These variants

/// take a pseudo key instead of a key. Their context must have the functions:

/// hash(self, PseudoKey) u32

/// eql(self, PseudoKey, K) bool

comptime {

std.hash_map.verifyContext(Context, K, K, u32, true);

}

 

inline fn checkedHash(ctx: anytype, key: anytype) u32 {

comptime std.hash_map.verifyContext(@TypeOf(ctx), @TypeOf(key), K, u32, true);

const hash = ctx.hash(key);

if (@TypeOf(hash) != u32) {

@compileError("Context " ++ @typeName(@TypeOf(ctx)) ++ " has a generic hash function that returns the wrong type!\n" ++

@typeName(u32) ++ " was expected, but found " ++ @typeName(@TypeOf(hash)));

}

return hash;

inline fn checkedEql(ctx: anytype, a: anytype, b: K, b_index: usize) bool {

comptime std.hash_map.verifyContext(@TypeOf(ctx), @TypeOf(a), K, u32, true);

const eql = ctx.eql(a, b, b_index);

if (@TypeOf(eql) != bool) {

@compileError("Context " ++ @typeName(@TypeOf(ctx)) ++ " has a generic eql function that returns the wrong type!\n" ++

@typeName(bool) ++ " was expected, but found " ++ @typeName(@TypeOf(eql)));

}

return eql;

const pp = man.files.items[i].prefixed_path orelse return err;

if (man.files.items.len == 0) {

 

pub const Path = struct {

root_dir: Cache.Directory,

/// The path, relative to the root dir, that this `Path` represents.

/// Empty string means the root_dir is the path.

sub_path: []const u8 = "",

 

pub fn clone(p: Path, arena: Allocator) Allocator.Error!Path {

return .{

.root_dir = try p.root_dir.clone(arena),

.sub_path = try arena.dupe(u8, p.sub_path),

};

}

 

pub fn cwd() Path {

return .{ .root_dir = Cache.Directory.cwd() };

}

 

pub fn join(p: Path, arena: Allocator, sub_path: []const u8) Allocator.Error!Path {

if (sub_path.len == 0) return p;

const parts: []const []const u8 =

if (p.sub_path.len == 0) &.{sub_path} else &.{ p.sub_path, sub_path };

return .{

.root_dir = p.root_dir,

.sub_path = try fs.path.join(arena, parts),

};

}

 

pub fn resolvePosix(p: Path, arena: Allocator, sub_path: []const u8) Allocator.Error!Path {

if (sub_path.len == 0) return p;

return .{

.root_dir = p.root_dir,

.sub_path = try fs.path.resolvePosix(arena, &.{ p.sub_path, sub_path }),

};

}

 

pub fn joinString(p: Path, allocator: Allocator, sub_path: []const u8) Allocator.Error![]u8 {

const parts: []const []const u8 =

if (p.sub_path.len == 0) &.{sub_path} else &.{ p.sub_path, sub_path };

return p.root_dir.join(allocator, parts);

}

 

pub fn joinStringZ(p: Path, allocator: Allocator, sub_path: []const u8) Allocator.Error![:0]u8 {

const parts: []const []const u8 =

if (p.sub_path.len == 0) &.{sub_path} else &.{ p.sub_path, sub_path };

return p.root_dir.joinZ(allocator, parts);

}

 

pub fn openFile(

p: Path,

sub_path: []const u8,

flags: fs.File.OpenFlags,

) !fs.File {

var buf: [fs.MAX_PATH_BYTES]u8 = undefined;

const joined_path = if (p.sub_path.len == 0) sub_path else p: {

break :p std.fmt.bufPrint(&buf, "{s}" ++ fs.path.sep_str ++ "{s}", .{

p.sub_path, sub_path,

}) catch return error.NameTooLong;

};

return p.root_dir.handle.openFile(joined_path, flags);

}

 

pub fn makeOpenPath(p: Path, sub_path: []const u8, opts: fs.OpenDirOptions) !fs.Dir {

var buf: [fs.MAX_PATH_BYTES]u8 = undefined;

const joined_path = if (p.sub_path.len == 0) sub_path else p: {

break :p std.fmt.bufPrint(&buf, "{s}" ++ fs.path.sep_str ++ "{s}", .{

p.sub_path, sub_path,

}) catch return error.NameTooLong;

};

return p.root_dir.handle.makeOpenPath(joined_path, opts);

}

 

pub fn statFile(p: Path, sub_path: []const u8) !fs.Dir.Stat {

var buf: [fs.MAX_PATH_BYTES]u8 = undefined;

const joined_path = if (p.sub_path.len == 0) sub_path else p: {

break :p std.fmt.bufPrint(&buf, "{s}" ++ fs.path.sep_str ++ "{s}", .{

p.sub_path, sub_path,

}) catch return error.NameTooLong;

};

return p.root_dir.handle.statFile(joined_path);

}

 

pub fn atomicFile(

p: Path,

sub_path: []const u8,

options: fs.Dir.AtomicFileOptions,

buf: *[fs.MAX_PATH_BYTES]u8,

) !fs.AtomicFile {

const joined_path = if (p.sub_path.len == 0) sub_path else p: {

break :p std.fmt.bufPrint(buf, "{s}" ++ fs.path.sep_str ++ "{s}", .{

p.sub_path, sub_path,

}) catch return error.NameTooLong;

};

return p.root_dir.handle.atomicFile(joined_path, options);

}

 

pub fn access(p: Path, sub_path: []const u8, flags: fs.File.OpenFlags) !void {

var buf: [fs.MAX_PATH_BYTES]u8 = undefined;

const joined_path = if (p.sub_path.len == 0) sub_path else p: {

break :p std.fmt.bufPrint(&buf, "{s}" ++ fs.path.sep_str ++ "{s}", .{

p.sub_path, sub_path,

}) catch return error.NameTooLong;

};

return p.root_dir.handle.access(joined_path, flags);

}

 

pub fn makePath(p: Path, sub_path: []const u8) !void {

var buf: [fs.MAX_PATH_BYTES]u8 = undefined;

const joined_path = if (p.sub_path.len == 0) sub_path else p: {

break :p std.fmt.bufPrint(&buf, "{s}" ++ fs.path.sep_str ++ "{s}", .{

p.sub_path, sub_path,

}) catch return error.NameTooLong;

};

return p.root_dir.handle.makePath(joined_path);

}

 

pub fn format(

self: Path,

comptime fmt_string: []const u8,

options: std.fmt.FormatOptions,

writer: anytype,

) !void {

if (fmt_string.len == 1) {

// Quote-escape the string.

const stringEscape = std.zig.stringEscape;

const f = switch (fmt_string[0]) {

'q' => "",

'\'' => '\'',

else => @compileError("unsupported format string: " ++ fmt_string),

};

if (self.root_dir.path) |p| {

try stringEscape(p, f, options, writer);

if (self.sub_path.len > 0) try stringEscape(fs.path.sep_str, f, options, writer);

}

if (self.sub_path.len > 0) {

try stringEscape(self.sub_path, f, options, writer);

}

return;

}

if (fmt_string.len > 0)

std.fmt.invalidFmtError(fmt_string, self);

if (self.root_dir.path) |p| {

try writer.writeAll(p);

try writer.writeAll(fs.path.sep_str);

}

if (self.sub_path.len > 0) {

try writer.writeAll(self.sub_path);

try writer.writeAll(fs.path.sep_str);

}

}

};

 

const Package = @This();

const builtin = @import("builtin");

const std = @import("std");

const fs = std.fs;

const Allocator = std.mem.Allocator;

const assert = std.debug.assert;

const Cache = std.Build.Cache;

parent_package_root: Package.Path,

package_root: Package.Path,

relative_path: Package.Path,

fn loadManifest(f: *Fetch, pkg_root: Package.Path) RunError!void {

pkg_root: Package.Path,

pkg_root: Package.Path,

root: Package.Path,

root: Package.Path,

root: Package.Path,

const abilists_contents = man.files.items[abilists_index].contents.?;

.root = Package.Path.cwd(),

.root = Package.Path.cwd(),