Commit ba2f2e139306618b8beaa8e833b1f9845309df73 | zig

author	Veikka Tuominen <git@vexu.eu> 2020-12-23 00:00:37+02:00
committer	GitHub <noreply@github.com> 2020-12-23 00:00:37+02:00
log	ba2f2e139306618b8beaa8e833b1f9845309df73
tree	a0d0d184a7a3070bca4161d2760e66a57a4256b1
parent	ccdb81fb31f3fa1384b44b74ecdae345457bd0b5
parent	fa09c3a5e7ab855026ae10f9e1f61b05611a2275
signature	Signed by PGP key 4AEE18F83AFDEB23

Merge pull request #7476 from ifreund/pkgs

stage2: free Package resources, print package path on --pkg-begin failure

2 files changed, 61 insertions(+), 57 deletions(-)

src
- Package.zig
- main.zig

src/Package.zig+34-22

...	@@ -1,3 +1,12 @@	...	@@ -1,3 +1,12 @@
		1	const Package = @This();
		2
		3	const std = @import("std");
		4	const fs = std.fs;
		5	const mem = std.mem;
		6	const Allocator = mem.Allocator;
		7
		8	const Compilation = @import("Compilation.zig");
		9
1	pub const Table = std.StringHashMapUnmanaged(*Package);	10	pub const Table = std.StringHashMapUnmanaged(*Package);
2		11
3	root_src_directory: Compilation.Directory,	12	root_src_directory: Compilation.Directory,
...	@@ -6,57 +15,60 @@ root_src_path: []const u8,	...	@@ -6,57 +15,60 @@ root_src_path: []const u8,
6	table: Table = .{},	15	table: Table = .{},
7	parent: ?*Package = null,	16	parent: ?*Package = null,
8		17
9	const std = @import("std");	18	/// Allocate a Package. No references to the slices passed are kept.
10	const mem = std.mem;
11	const Allocator = std.mem.Allocator;
12	const assert = std.debug.assert;
13	const Package = @This();
14	const Compilation = @import("Compilation.zig");
15
16	/// No references to `root_src_dir` and `root_src_path` are kept.
17	pub fn create(	19	pub fn create(
18	gpa: *Allocator,	20	gpa: *Allocator,
19	base_directory: Compilation.Directory,	21	/// Null indicates the current working directory
20	/// Relative to `base_directory`.	22	root_src_dir_path: ?[]const u8,
21	root_src_dir: []const u8,	23	/// Relative to root_src_dir_path
22	/// Relative to `root_src_dir`.
23	root_src_path: []const u8,	24	root_src_path: []const u8,
24	) !*Package {	25	) !*Package {
25	const ptr = try gpa.create(Package);	26	const ptr = try gpa.create(Package);
26	errdefer gpa.destroy(ptr);	27	errdefer gpa.destroy(ptr);
27		28
28	const root_src_dir_path = try base_directory.join(gpa, &[_][]const u8{root_src_dir});	29	const owned_dir_path = if (root_src_dir_path) \|p\| try gpa.dupe(u8, p) else null;
29	errdefer gpa.free(root_src_dir_path);	30	errdefer if (owned_dir_path) \|p\| gpa.free(p);
30		31
31	const root_src_path_dupe = try mem.dupe(gpa, u8, root_src_path);	32	const owned_src_path = try gpa.dupe(u8, root_src_path);
32	errdefer gpa.free(root_src_path_dupe);	33	errdefer gpa.free(owned_src_path);
33		34
34	ptr.* = .{	35	ptr.* = .{
35	.root_src_directory = .{	36	.root_src_directory = .{
36	.path = root_src_dir_path,	37	.path = owned_dir_path,
37	.handle = try base_directory.handle.openDir(root_src_dir, .{}),	38	.handle = if (owned_dir_path) \|p\| try fs.cwd().openDir(p, .{}) else fs.cwd(),
38	},	39	},
39	.root_src_path = root_src_path_dupe,	40	.root_src_path = owned_src_path,
40	};	41	};
		42
41	return ptr;	43	return ptr;
42	}	44	}
43		45
		46	/// Free all memory associated with this package and recursively call destroy
		47	/// on all packages in its table
44	pub fn destroy(pkg: Package, gpa: Allocator) void {	48	pub fn destroy(pkg: Package, gpa: Allocator) void {
45	pkg.root_src_directory.handle.close();
46	gpa.free(pkg.root_src_path);	49	gpa.free(pkg.root_src_path);
47	if (pkg.root_src_directory.path) \|p\| gpa.free(p);	50
		51	// If root_src_directory.path is null then the handle is the cwd()
		52	// which shouldn't be closed.
		53	if (pkg.root_src_directory.path) \|p\| {
		54	gpa.free(p);
		55	pkg.root_src_directory.handle.close();
		56	}
		57
48	{	58	{
49	var it = pkg.table.iterator();	59	var it = pkg.table.iterator();
50	while (it.next()) \|kv\| {	60	while (it.next()) \|kv\| {
		61	kv.value.destroy(gpa);
51	gpa.free(kv.key);	62	gpa.free(kv.key);
52	}	63	}
53	}	64	}
		65
54	pkg.table.deinit(gpa);	66	pkg.table.deinit(gpa);
55	gpa.destroy(pkg);	67	gpa.destroy(pkg);
56	}	68	}
57		69
58	pub fn add(pkg: Package, gpa: Allocator, name: []const u8, package: *Package) !void {	70	pub fn add(pkg: Package, gpa: Allocator, name: []const u8, package: *Package) !void {
59	try pkg.table.ensureCapacity(gpa, pkg.table.items().len + 1);	71	try pkg.table.ensureCapacity(gpa, pkg.table.count() + 1);
60	const name_dupe = try mem.dupe(gpa, u8, name);	72	const name_dupe = try mem.dupe(gpa, u8, name);
61	pkg.table.putAssumeCapacityNoClobber(name_dupe, package);	73	pkg.table.putAssumeCapacityNoClobber(name_dupe, package);
62	}	74	}

src/main.zig+27-35

 @@ -568,12 +568,15 @@ fn buildOutputType(
     var test_exec_args = std.ArrayList(?[]const u8).init(gpa);
     defer test_exec_args.deinit();
-    var root_pkg_memory: Package = .{
+    const pkg_tree_root = try gpa.create(Package);
-        .root_src_directory = undefined,
+    // This package only exists to clean up the code parsing --pkg-begin and
-        .root_src_path = undefined,
+    // --pkg-end flags. Use dummy values that are safe for the destroy call.
+    pkg_tree_root.* = .{
+        .root_src_directory = .{ .path = null, .handle = fs.cwd() },
+        .root_src_path = &[0]u8{},
     };
-    defer root_pkg_memory.table.deinit(gpa);
+    defer pkg_tree_root.destroy(gpa);
-    var cur_pkg: *Package = &root_pkg_memory;
+    var cur_pkg: *Package = pkg_tree_root;
     switch (arg_mode) {
         .build, .translate_c, .zig_test, .run => {
 @@ -627,22 +630,15 @@ fn buildOutputType(
                         i += 1;
                         const pkg_path = args[i];
-                        const new_cur_pkg = try arena.create(Package);
+                        const new_cur_pkg = Package.create(
-                        new_cur_pkg.* = .{
+                            gpa,
-                            .root_src_directory = if (fs.path.dirname(pkg_path)) |dirname|
+                            fs.path.dirname(pkg_path),
-                                .{
+                            fs.path.basename(pkg_path),
-                                    .path = dirname,
+                        ) catch |err| {
-                                    .handle = try fs.cwd().openDir(dirname, .{}), // TODO close this fd
+                            fatal("Failed to add package at path {}: {}", .{ pkg_path, @errorName(err) });
-                                }
-                            else
-                                .{
-                                    .path = null,
-                                    .handle = fs.cwd(),
-                                },
-                            .root_src_path = fs.path.basename(pkg_path),
-                            .parent = cur_pkg,
                         };
-                        try cur_pkg.table.put(gpa, pkg_name, new_cur_pkg);
+                        new_cur_pkg.parent = cur_pkg;
+                        try cur_pkg.add(gpa, pkg_name, new_cur_pkg);
                         cur_pkg = new_cur_pkg;
                     } else if (mem.eql(u8, arg, "--pkg-end")) {
                         cur_pkg = cur_pkg.parent orelse
 @@ -1600,26 +1596,22 @@ fn buildOutputType(
         .yes => |p| p,
     };
-    var cleanup_root_dir: ?fs.Dir = null;
-    defer if (cleanup_root_dir) |*dir| dir.close();
     const root_pkg: ?*Package = if (root_src_file) |src_path| blk: {
         if (main_pkg_path) |p| {
-            const dir = try fs.cwd().openDir(p, .{});
+            const rel_src_path = try fs.path.relative(gpa, p, src_path);
-            cleanup_root_dir = dir;
+            defer gpa.free(rel_src_path);
-            root_pkg_memory.root_src_directory = .{ .path = p, .handle = dir };
+            break :blk try Package.create(gpa, p, rel_src_path);
-            root_pkg_memory.root_src_path = try fs.path.relative(arena, p, src_path);
-        } else if (fs.path.dirname(src_path)) |p| {
-            const dir = try fs.cwd().openDir(p, .{});
-            cleanup_root_dir = dir;
-            root_pkg_memory.root_src_directory = .{ .path = p, .handle = dir };
-            root_pkg_memory.root_src_path = fs.path.basename(src_path);
         } else {
-            root_pkg_memory.root_src_directory = .{ .path = null, .handle = fs.cwd() };
+            break :blk try Package.create(gpa, fs.path.dirname(src_path), fs.path.basename(src_path));
-            root_pkg_memory.root_src_path = src_path;
         }
-        break :blk &root_pkg_memory;
     } else null;
+    defer if (root_pkg) |p| p.destroy(gpa);
+    // Transfer packages added with --pkg-begin/--pkg-end to the root package
+    if (root_pkg) |pkg| {
+        pkg.table = pkg_tree_root.table;
+        pkg_tree_root.table = .{};
+    }
     const self_exe_path = try fs.selfExePathAlloc(arena);
     var zig_lib_directory: Compilation.Directory = if (override_lib_dir) |lib_dir|