Merge pull request #13865 from ziglang/std-build-reorg

std.build: extract steps to separate files

lib/std/build/InstallArtifactStep.zig

@@ -0,0 +1,88 @@
+const std = @import("../std.zig");
+const build = @import("../build.zig");
+const Step = build.Step;
+const Builder = build.Builder;
+const LibExeObjStep = std.build.LibExeObjStep;
+const InstallDir = std.build.InstallDir;
+
+pub const base_id = .install_artifact;
+
+step: Step,
+builder: *Builder,
+artifact: *LibExeObjStep,
+dest_dir: InstallDir,
+pdb_dir: ?InstallDir,
+h_dir: ?InstallDir,
+
+const Self = @This();
+
+pub fn create(builder: *Builder, artifact: *LibExeObjStep) *Self {
+    if (artifact.install_step) |s| return s;
+
+    const self = builder.allocator.create(Self) catch unreachable;
+    self.* = Self{
+        .builder = builder,
+        .step = Step.init(.install_artifact, builder.fmt("install {s}", .{artifact.step.name}), builder.allocator, make),
+        .artifact = artifact,
+        .dest_dir = artifact.override_dest_dir orelse switch (artifact.kind) {
+            .obj => @panic("Cannot install a .obj build artifact."),
+            .@"test" => @panic("Cannot install a test build artifact, use addTestExe instead."),
+            .exe, .test_exe => InstallDir{ .bin = {} },
+            .lib => InstallDir{ .lib = {} },
+        },
+        .pdb_dir = if (artifact.producesPdbFile()) blk: {
+            if (artifact.kind == .exe or artifact.kind == .test_exe) {
+                break :blk InstallDir{ .bin = {} };
+            } else {
+                break :blk InstallDir{ .lib = {} };
+            }
+        } else null,
+        .h_dir = if (artifact.kind == .lib and artifact.emit_h) .header else null,
+    };
+    self.step.dependOn(&artifact.step);
+    artifact.install_step = self;
+
+    builder.pushInstalledFile(self.dest_dir, artifact.out_filename);
+    if (self.artifact.isDynamicLibrary()) {
+        if (artifact.major_only_filename) |name| {
+            builder.pushInstalledFile(.lib, name);
+        }
+        if (artifact.name_only_filename) |name| {
+            builder.pushInstalledFile(.lib, name);
+        }
+        if (self.artifact.target.isWindows()) {
+            builder.pushInstalledFile(.lib, artifact.out_lib_filename);
+        }
+    }
+    if (self.pdb_dir) |pdb_dir| {
+        builder.pushInstalledFile(pdb_dir, artifact.out_pdb_filename);
+    }
+    if (self.h_dir) |h_dir| {
+        builder.pushInstalledFile(h_dir, artifact.out_h_filename);
+    }
+    return self;
+}
+
+fn make(step: *Step) !void {
+    const self = @fieldParentPtr(Self, "step", step);
+    const builder = self.builder;
+
+    const full_dest_path = builder.getInstallPath(self.dest_dir, self.artifact.out_filename);
+    try builder.updateFile(self.artifact.getOutputSource().getPath(builder), full_dest_path);
+    if (self.artifact.isDynamicLibrary() and self.artifact.version != null and self.artifact.target.wantSharedLibSymLinks()) {
+        try LibExeObjStep.doAtomicSymLinks(builder.allocator, full_dest_path, self.artifact.major_only_filename.?, self.artifact.name_only_filename.?);
+    }
+    if (self.artifact.isDynamicLibrary() and self.artifact.target.isWindows() and self.artifact.emit_implib != .no_emit) {
+        const full_implib_path = builder.getInstallPath(self.dest_dir, self.artifact.out_lib_filename);
+        try builder.updateFile(self.artifact.getOutputLibSource().getPath(builder), full_implib_path);
+    }
+    if (self.pdb_dir) |pdb_dir| {
+        const full_pdb_path = builder.getInstallPath(pdb_dir, self.artifact.out_pdb_filename);
+        try builder.updateFile(self.artifact.getOutputPdbSource().getPath(builder), full_pdb_path);
+    }
+    if (self.h_dir) |h_dir| {
+        const full_pdb_path = builder.getInstallPath(h_dir, self.artifact.out_h_filename);
+        try builder.updateFile(self.artifact.getOutputHSource().getPath(builder), full_pdb_path);
+    }
+    self.artifact.installed_path = full_dest_path;
+}

lib/std/build/InstallDirStep.zig

@@ -0,0 +1,90 @@
+const std = @import("../std.zig");
+const mem = std.mem;
+const fs = std.fs;
+const build = @import("../build.zig");
+const Step = build.Step;
+const Builder = build.Builder;
+const InstallDir = std.build.InstallDir;
+const InstallDirStep = @This();
+
+step: Step,
+builder: *Builder,
+options: Options,
+
+pub const base_id = .install_dir;
+
+pub const Options = struct {
+    source_dir: []const u8,
+    install_dir: InstallDir,
+    install_subdir: []const u8,
+    /// File paths which end in any of these suffixes will be excluded
+    /// from being installed.
+    exclude_extensions: []const []const u8 = &.{},
+    /// File paths which end in any of these suffixes will result in
+    /// empty files being installed. This is mainly intended for large
+    /// test.zig files in order to prevent needless installation bloat.
+    /// However if the files were not present at all, then
+    /// `@import("test.zig")` would be a compile error.
+    blank_extensions: []const []const u8 = &.{},
+
+    fn dupe(self: Options, b: *Builder) Options {
+        return .{
+            .source_dir = b.dupe(self.source_dir),
+            .install_dir = self.install_dir.dupe(b),
+            .install_subdir = b.dupe(self.install_subdir),
+            .exclude_extensions = b.dupeStrings(self.exclude_extensions),
+            .blank_extensions = b.dupeStrings(self.blank_extensions),
+        };
+    }
+};
+
+pub fn init(
+    builder: *Builder,
+    options: Options,
+) InstallDirStep {
+    builder.pushInstalledFile(options.install_dir, options.install_subdir);
+    return InstallDirStep{
+        .builder = builder,
+        .step = Step.init(.install_dir, builder.fmt("install {s}/", .{options.source_dir}), builder.allocator, make),
+        .options = options.dupe(builder),
+    };
+}
+
+fn make(step: *Step) !void {
+    const self = @fieldParentPtr(InstallDirStep, "step", step);
+    const dest_prefix = self.builder.getInstallPath(self.options.install_dir, self.options.install_subdir);
+    const full_src_dir = self.builder.pathFromRoot(self.options.source_dir);
+    var src_dir = try std.fs.cwd().openIterableDir(full_src_dir, .{});
+    defer src_dir.close();
+    var it = try src_dir.walk(self.builder.allocator);
+    next_entry: while (try it.next()) |entry| {
+        for (self.options.exclude_extensions) |ext| {
+            if (mem.endsWith(u8, entry.path, ext)) {
+                continue :next_entry;
+            }
+        }
+
+        const full_path = self.builder.pathJoin(&.{
+            full_src_dir, entry.path,
+        });
+
+        const dest_path = self.builder.pathJoin(&.{
+            dest_prefix, entry.path,
+        });
+
+        switch (entry.kind) {
+            .Directory => try fs.cwd().makePath(dest_path),
+            .File => {
+                for (self.options.blank_extensions) |ext| {
+                    if (mem.endsWith(u8, entry.path, ext)) {
+                        try self.builder.truncateFile(dest_path);
+                        continue :next_entry;
+                    }
+                }
+
+                try self.builder.updateFile(full_path, dest_path);
+            },
+            else => continue,
+        }
+    }
+}

lib/std/build/InstallFileStep.zig

@@ -0,0 +1,38 @@
+const std = @import("../std.zig");
+const build = @import("../build.zig");
+const Step = build.Step;
+const Builder = build.Builder;
+const FileSource = std.build.FileSource;
+const InstallDir = std.build.InstallDir;
+const InstallFileStep = @This();
+
+pub const base_id = .install_file;
+
+step: Step,
+builder: *Builder,
+source: FileSource,
+dir: InstallDir,
+dest_rel_path: []const u8,
+
+pub fn init(
+    builder: *Builder,
+    source: FileSource,
+    dir: InstallDir,
+    dest_rel_path: []const u8,
+) InstallFileStep {
+    builder.pushInstalledFile(dir, dest_rel_path);
+    return InstallFileStep{
+        .builder = builder,
+        .step = Step.init(.install_file, builder.fmt("install {s} to {s}", .{ source.getDisplayName(), dest_rel_path }), builder.allocator, make),
+        .source = source.dupe(builder),
+        .dir = dir.dupe(builder),
+        .dest_rel_path = builder.dupePath(dest_rel_path),
+    };
+}
+
+fn make(step: *Step) !void {
+    const self = @fieldParentPtr(InstallFileStep, "step", step);
+    const full_dest_path = self.builder.getInstallPath(self.dir, self.dest_rel_path);
+    const full_src_path = self.source.getPath(self.builder);
+    try self.builder.updateFile(full_src_path, full_dest_path);
+}

lib/std/build/InstallRawStep.zig

@@ -26,7 +26,7 @@ const BinaryElfSegment = struct {
     virtualAddress: u64,
     elfOffset: u64,
     binaryOffset: u64,
-    fileSize: usize,
+    fileSize: u64,
     firstSection: ?*BinaryElfSection,
 };
 
@@ -69,7 +69,7 @@ const BinaryElfOutput = struct {
 
             const shstrtab_shdr = (try section_headers.next()).?;
 
-            const buffer = try allocator.alloc(u8, shstrtab_shdr.sh_size);
+            const buffer = try allocator.alloc(u8, @intCast(usize, shstrtab_shdr.sh_size));
             errdefer allocator.free(buffer);
 
             const num_read = try elf_file.preadAll(buffer, shstrtab_shdr.sh_offset);
@@ -301,7 +301,7 @@ const HexWriter = struct {
             const row_address = @intCast(u32, segment.physicalAddress + bytes_read);
 
             const remaining = segment.fileSize - bytes_read;
-            const to_read = @min(remaining, MAX_PAYLOAD_LEN);
+            const to_read = @intCast(usize, @min(remaining, MAX_PAYLOAD_LEN));
             const did_read = try elf_file.preadAll(buf[0..to_read], segment.elfOffset + bytes_read);
             if (did_read < to_read) return error.UnexpectedEOF;