authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2022-02-24 12:11:11-07:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2022-02-24 12:11:11-07:00
log5ab5e2e6731a9f1198df6c53134545ccc6a6bbd3
tree7b1e8bdc0fb357036d6827639d17f1a043d50e6d
parent6249a24e81b9b3df3d5ca99b57f22470b9ac486c

Revert "Merge pull request #10950 from hexops/sg/responsefiles"

This reverts commit 136a43934bc08dc3aee85f1182904b97456601d3, reversing changes made to 9dd839b7ed15d1191f3303d069cffe0473e03e83. This broke the behavior of `zig run`.

2 files changed, 144 insertions(+), 202 deletions(-)

lib/std/build.zig-36
......@@ -17,7 +17,6 @@ const fmt_lib = std.fmt;
1717const File = std.fs.File;
1818const CrossTarget = std.zig.CrossTarget;
1919const NativeTargetInfo = std.zig.system.NativeTargetInfo;
20const Sha256 = std.crypto.hash.sha2.Sha256;
2120
2221pub const FmtStep = @import("build/FmtStep.zig");
2322pub const TranslateCStep = @import("build/TranslateCStep.zig");
......@@ -2893,41 +2892,6 @@ pub const LibExeObjStep = struct {
28932892
28942893 try zig_args.append("--enable-cache");
28952894
2896 // Windows has an argument length limit of 32,766 characters, macOS 262,144 and Linux
2897 // 2,097,152. If our args exceed 30 KiB, we instead write them to a "response file" and
2898 // pass that to zig, e.g. via 'zig build-lib @args.rsp'
2899 var args_length: usize = 0;
2900 for (zig_args.items) |arg| {
2901 args_length += arg.len + 1; // +1 to account for null terminator
2902 }
2903 if (args_length >= 30 * 1024) {
2904 const args_dir = try fs.path.join(
2905 builder.allocator,
2906 &[_][]const u8{ builder.pathFromRoot("zig-cache"), "args" },
2907 );
2908 try std.fs.cwd().makePath(args_dir);
2909
2910 // Write the args to zig-cache/args/<SHA256 hash of args> to avoid conflicts with
2911 // other zig build commands running in parallel.
2912 const partially_quoted = try std.mem.join(builder.allocator, "\" \"", zig_args.items[2..]);
2913 const args = try std.mem.concat(builder.allocator, u8, &[_][]const u8{ "\"", partially_quoted, "\"" });
2914
2915 var args_hash: [Sha256.digest_length]u8 = undefined;
2916 Sha256.hash(args, &args_hash, .{});
2917 var args_hex_hash: [Sha256.digest_length * 2]u8 = undefined;
2918 _ = try std.fmt.bufPrint(
2919 &args_hex_hash,
2920 "{s}",
2921 .{std.fmt.fmtSliceHexLower(&args_hash)},
2922 );
2923
2924 const args_file = try fs.path.join(builder.allocator, &[_][]const u8{ args_dir, args_hex_hash[0..] });
2925 try std.fs.cwd().writeFile(args_file, args);
2926
2927 zig_args.shrinkRetainingCapacity(2);
2928 try zig_args.append(try std.mem.concat(builder.allocator, u8, &[_][]const u8{ "@", args_file }));
2929 }
2930
29312895 const output_dir_nl = try builder.execFromStep(zig_args.items, &self.step);
29322896 const build_output_dir = mem.trimRight(u8, output_dir_nl, "\r\n");
29332897
src/main.zig+144-166
......@@ -767,33 +767,11 @@ fn buildOutputType(
767767 }
768768
769769 soname = .yes_default_value;
770
771 const Iterator = struct {
772 resp_file: ?ArgIteratorResponseFile = null,
773 args: []const []const u8,
774 i: usize = 0,
775 fn next(it: *@This()) ?[]const u8 {
776 if (it.i >= it.args.len) {
777 if (it.resp_file) |*resp| return if (resp.next()) |sentinel| std.mem.span(sentinel) else null;
778 return null;
779 }
780 defer it.i += 1;
781 return it.args[it.i];
782 }
783 };
784 var args_iter = Iterator{
785 .args = all_args[2..],
786 };
787
788 args_loop: while (args_iter.next()) |arg| {
789 if (mem.startsWith(u8, arg, "@")) {
790 // This is a "compiler response file". We must parse the file and treat its
791 // contents as command line parameters.
792 const resp_file_path = arg[1..];
793 args_iter.resp_file = initArgIteratorResponseFile(arena, resp_file_path) catch |err| {
794 fatal("unable to read response file '{s}': {s}", .{ resp_file_path, @errorName(err) });
795 };
796 } else if (mem.startsWith(u8, arg, "-")) {
770 const args = all_args[2..];
771 var i: usize = 0;
772 args_loop: while (i < args.len) : (i += 1) {
773 const arg = args[i];
774 if (mem.startsWith(u8, arg, "-")) {
797775 if (mem.eql(u8, arg, "-h") or mem.eql(u8, arg, "--help")) {
798776 try io.getStdOut().writeAll(usage_build_generic);
799777 return cleanExit();
......@@ -801,71 +779,73 @@ fn buildOutputType(
801779 if (arg_mode == .run) {
802780 // The index refers to all_args so skip `zig` `run`
803781 // and `--`
804 runtime_args_start = args_iter.i + 3;
782 runtime_args_start = i + 3;
805783 break :args_loop;
806784 } else {
807785 fatal("unexpected end-of-parameter mark: --", .{});
808786 }
809787 } else if (mem.eql(u8, arg, "--pkg-begin")) {
810 const pkg_name = args_iter.next();
811 const pkg_path = args_iter.next();
812 if (pkg_name == null or pkg_path == null) fatal("Expected 2 arguments after {s}", .{arg});
788 if (i + 2 >= args.len) fatal("Expected 2 arguments after {s}", .{arg});
789 i += 1;
790 const pkg_name = args[i];
791 i += 1;
792 const pkg_path = args[i];
813793
814794 const new_cur_pkg = Package.create(
815795 gpa,
816 fs.path.dirname(pkg_path.?),
817 fs.path.basename(pkg_path.?),
796 fs.path.dirname(pkg_path),
797 fs.path.basename(pkg_path),
818798 ) catch |err| {
819 fatal("Failed to add package at path {s}: {s}", .{ pkg_path.?, @errorName(err) });
799 fatal("Failed to add package at path {s}: {s}", .{ pkg_path, @errorName(err) });
820800 };
821 try cur_pkg.addAndAdopt(gpa, pkg_name.?, new_cur_pkg);
801 try cur_pkg.addAndAdopt(gpa, pkg_name, new_cur_pkg);
822802 cur_pkg = new_cur_pkg;
823803 } else if (mem.eql(u8, arg, "--pkg-end")) {
824804 cur_pkg = cur_pkg.parent orelse
825805 fatal("encountered --pkg-end with no matching --pkg-begin", .{});
826806 } else if (mem.eql(u8, arg, "--main-pkg-path")) {
827 main_pkg_path = args_iter.next() orelse {
828 fatal("expected parameter after {s}", .{arg});
829 };
807 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
808 i += 1;
809 main_pkg_path = args[i];
830810 } else if (mem.eql(u8, arg, "-cflags")) {
831811 extra_cflags.shrinkRetainingCapacity(0);
832812 while (true) {
833 const next_arg = args_iter.next() orelse {
834 fatal("expected -- after -cflags", .{});
835 };
836 if (mem.eql(u8, next_arg, "--")) break;
837 try extra_cflags.append(next_arg);
813 i += 1;
814 if (i >= args.len) fatal("expected -- after -cflags", .{});
815 if (mem.eql(u8, args[i], "--")) break;
816 try extra_cflags.append(args[i]);
838817 }
839818 } else if (mem.eql(u8, arg, "--color")) {
840 const next_arg = args_iter.next() orelse {
819 if (i + 1 >= args.len) {
841820 fatal("expected [auto|on|off] after --color", .{});
842 };
821 }
822 i += 1;
823 const next_arg = args[i];
843824 color = std.meta.stringToEnum(Color, next_arg) orelse {
844825 fatal("expected [auto|on|off] after --color, found '{s}'", .{next_arg});
845826 };
846827 } else if (mem.eql(u8, arg, "--subsystem")) {
847 const next_arg = args_iter.next() orelse {
848 fatal("expected parameter after {s}", .{arg});
849 };
850 if (mem.eql(u8, next_arg, "console")) {
828 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
829 i += 1;
830 if (mem.eql(u8, args[i], "console")) {
851831 subsystem = .Console;
852 } else if (mem.eql(u8, next_arg, "windows")) {
832 } else if (mem.eql(u8, args[i], "windows")) {
853833 subsystem = .Windows;
854 } else if (mem.eql(u8, next_arg, "posix")) {
834 } else if (mem.eql(u8, args[i], "posix")) {
855835 subsystem = .Posix;
856 } else if (mem.eql(u8, next_arg, "native")) {
836 } else if (mem.eql(u8, args[i], "native")) {
857837 subsystem = .Native;
858 } else if (mem.eql(u8, next_arg, "efi_application")) {
838 } else if (mem.eql(u8, args[i], "efi_application")) {
859839 subsystem = .EfiApplication;
860 } else if (mem.eql(u8, next_arg, "efi_boot_service_driver")) {
840 } else if (mem.eql(u8, args[i], "efi_boot_service_driver")) {
861841 subsystem = .EfiBootServiceDriver;
862 } else if (mem.eql(u8, next_arg, "efi_rom")) {
842 } else if (mem.eql(u8, args[i], "efi_rom")) {
863843 subsystem = .EfiRom;
864 } else if (mem.eql(u8, next_arg, "efi_runtime_driver")) {
844 } else if (mem.eql(u8, args[i], "efi_runtime_driver")) {
865845 subsystem = .EfiRuntimeDriver;
866846 } else {
867847 fatal("invalid: --subsystem: '{s}'. Options are:\n{s}", .{
868 next_arg,
848 args[i],
869849 \\ console
870850 \\ windows
871851 \\ posix
......@@ -878,71 +858,67 @@ fn buildOutputType(
878858 });
879859 }
880860 } else if (mem.eql(u8, arg, "-O")) {
881 optimize_mode_string = args_iter.next() orelse {
882 fatal("expected parameter after {s}", .{arg});
883 };
861 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
862 i += 1;
863 optimize_mode_string = args[i];
884864 } else if (mem.eql(u8, arg, "--entry")) {
885 entry = args_iter.next() orelse {
886 fatal("expected parameter after {s}", .{arg});
887 };
865 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
866 i += 1;
867 entry = args[i];
888868 } else if (mem.eql(u8, arg, "--stack")) {
889 const next_arg = args_iter.next() orelse {
890 fatal("expected parameter after {s}", .{arg});
891 };
892 stack_size_override = std.fmt.parseUnsigned(u64, next_arg, 0) catch |err| {
869 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
870 i += 1;
871 stack_size_override = std.fmt.parseUnsigned(u64, args[i], 0) catch |err| {
893872 fatal("unable to parse '{s}': {s}", .{ arg, @errorName(err) });
894873 };
895874 } else if (mem.eql(u8, arg, "--image-base")) {
896 const next_arg = args_iter.next() orelse {
897 fatal("expected parameter after {s}", .{arg});
898 };
899 image_base_override = std.fmt.parseUnsigned(u64, next_arg, 0) catch |err| {
875 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
876 i += 1;
877 image_base_override = std.fmt.parseUnsigned(u64, args[i], 0) catch |err| {
900878 fatal("unable to parse '{s}': {s}", .{ arg, @errorName(err) });
901879 };
902880 } else if (mem.eql(u8, arg, "--name")) {
903 provided_name = args_iter.next() orelse {
904 fatal("expected parameter after {s}", .{arg});
905 };
881 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
882 i += 1;
883 provided_name = args[i];
906884 } else if (mem.eql(u8, arg, "-rpath")) {
907 try rpath_list.append(args_iter.next() orelse {
908 fatal("expected parameter after {s}", .{arg});
909 });
885 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
886 i += 1;
887 try rpath_list.append(args[i]);
910888 } else if (mem.eql(u8, arg, "--library-directory") or mem.eql(u8, arg, "-L")) {
911 try lib_dirs.append(args_iter.next() orelse {
912 fatal("expected parameter after {s}", .{arg});
913 });
889 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
890 i += 1;
891 try lib_dirs.append(args[i]);
914892 } else if (mem.eql(u8, arg, "-F")) {
915 try framework_dirs.append(args_iter.next() orelse {
916 fatal("expected parameter after {s}", .{arg});
917 });
893 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
894 i += 1;
895 try framework_dirs.append(args[i]);
918896 } else if (mem.eql(u8, arg, "-framework")) {
919 try frameworks.append(args_iter.next() orelse {
920 fatal("expected parameter after {s}", .{arg});
921 });
897 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
898 i += 1;
899 try frameworks.append(args[i]);
922900 } else if (mem.eql(u8, arg, "-install_name")) {
923 install_name = args_iter.next() orelse {
924 fatal("expected parameter after {s}", .{arg});
925 };
901 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
902 i += 1;
903 install_name = args[i];
926904 } else if (mem.eql(u8, arg, "-T") or mem.eql(u8, arg, "--script")) {
927 linker_script = args_iter.next() orelse {
928 fatal("expected parameter after {s}", .{arg});
929 };
905 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
906 i += 1;
907 linker_script = args[i];
930908 } else if (mem.eql(u8, arg, "--version-script")) {
931 version_script = args_iter.next() orelse {
932 fatal("expected parameter after {s}", .{arg});
933 };
909 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
910 i += 1;
911 version_script = args[i];
934912 } else if (mem.eql(u8, arg, "--library") or mem.eql(u8, arg, "-l")) {
935 const next_arg = args_iter.next() orelse {
936 fatal("expected parameter after {s}", .{arg});
937 };
913 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
938914 // We don't know whether this library is part of libc or libc++ until
939915 // we resolve the target, so we simply append to the list for now.
940 try system_libs.put(next_arg, .{ .needed = false });
916 i += 1;
917 try system_libs.put(args[i], .{ .needed = false });
941918 } else if (mem.eql(u8, arg, "--needed-library") or mem.eql(u8, arg, "-needed-l")) {
942 const next_arg = args_iter.next() orelse {
943 fatal("expected parameter after {s}", .{arg});
944 };
945 try system_libs.put(next_arg, .{ .needed = true });
919 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
920 i += 1;
921 try system_libs.put(args[i], .{ .needed = true });
946922 } else if (mem.eql(u8, arg, "-D") or
947923 mem.eql(u8, arg, "-isystem") or
948924 mem.eql(u8, arg, "-I") or
......@@ -951,30 +927,31 @@ fn buildOutputType(
951927 mem.eql(u8, arg, "-iframework") or
952928 mem.eql(u8, arg, "-iframeworkwithsysroot"))
953929 {
930 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
931 i += 1;
954932 try clang_argv.append(arg);
955 try clang_argv.append(args_iter.next() orelse {
956 fatal("expected parameter after {s}", .{arg});
957 });
933 try clang_argv.append(args[i]);
958934 } else if (mem.eql(u8, arg, "--version")) {
959 const next_arg = args_iter.next() orelse {
960 fatal("expected parameter after {s}", .{arg});
961 };
962 version = std.builtin.Version.parse(next_arg) catch |err| {
963 fatal("unable to parse --version '{s}': {s}", .{ next_arg, @errorName(err) });
935 if (i + 1 >= args.len) {
936 fatal("expected parameter after --version", .{});
937 }
938 i += 1;
939 version = std.builtin.Version.parse(args[i]) catch |err| {
940 fatal("unable to parse --version '{s}': {s}", .{ args[i], @errorName(err) });
964941 };
965942 have_version = true;
966943 } else if (mem.eql(u8, arg, "-target")) {
967 target_arch_os_abi = args_iter.next() orelse {
968 fatal("expected parameter after {s}", .{arg});
969 };
944 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
945 i += 1;
946 target_arch_os_abi = args[i];
970947 } else if (mem.eql(u8, arg, "-mcpu")) {
971 target_mcpu = args_iter.next() orelse {
972 fatal("expected parameter after {s}", .{arg});
973 };
948 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
949 i += 1;
950 target_mcpu = args[i];
974951 } else if (mem.eql(u8, arg, "-mcmodel")) {
975 machine_code_model = parseCodeModel(args_iter.next() orelse {
976 fatal("expected parameter after {s}", .{arg});
977 });
952 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
953 i += 1;
954 machine_code_model = parseCodeModel(args[i]);
978955 } else if (mem.startsWith(u8, arg, "-ofmt=")) {
979956 target_ofmt = arg["-ofmt=".len..];
980957 } else if (mem.startsWith(u8, arg, "-mcpu=")) {
......@@ -984,51 +961,50 @@ fn buildOutputType(
984961 } else if (mem.startsWith(u8, arg, "-O")) {
985962 optimize_mode_string = arg["-O".len..];
986963 } else if (mem.eql(u8, arg, "--dynamic-linker")) {
987 target_dynamic_linker = args_iter.next() orelse {
988 fatal("expected parameter after {s}", .{arg});
989 };
964 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
965 i += 1;
966 target_dynamic_linker = args[i];
990967 } else if (mem.eql(u8, arg, "--sysroot")) {
991 sysroot = args_iter.next() orelse {
992 fatal("expected parameter after {s}", .{arg});
993 };
968 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
969 i += 1;
970 sysroot = args[i];
994971 try clang_argv.append("-isysroot");
995 try clang_argv.append(sysroot.?);
972 try clang_argv.append(args[i]);
996973 } else if (mem.eql(u8, arg, "--libc")) {
997 libc_paths_file = args_iter.next() orelse {
998 fatal("expected parameter after {s}", .{arg});
999 };
974 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
975 i += 1;
976 libc_paths_file = args[i];
1000977 } else if (mem.eql(u8, arg, "--test-filter")) {
1001 test_filter = args_iter.next() orelse {
1002 fatal("expected parameter after {s}", .{arg});
1003 };
978 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
979 i += 1;
980 test_filter = args[i];
1004981 } else if (mem.eql(u8, arg, "--test-name-prefix")) {
1005 test_name_prefix = args_iter.next() orelse {
1006 fatal("expected parameter after {s}", .{arg});
1007 };
982 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
983 i += 1;
984 test_name_prefix = args[i];
1008985 } else if (mem.eql(u8, arg, "--test-cmd")) {
1009 try test_exec_args.append(args_iter.next() orelse {
1010 fatal("expected parameter after {s}", .{arg});
1011 });
986 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
987 i += 1;
988 try test_exec_args.append(args[i]);
1012989 } else if (mem.eql(u8, arg, "--cache-dir")) {
1013 override_local_cache_dir = args_iter.next() orelse {
1014 fatal("expected parameter after {s}", .{arg});
1015 };
990 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
991 i += 1;
992 override_local_cache_dir = args[i];
1016993 } else if (mem.eql(u8, arg, "--global-cache-dir")) {
1017 override_global_cache_dir = args_iter.next() orelse {
1018 fatal("expected parameter after {s}", .{arg});
1019 };
994 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
995 i += 1;
996 override_global_cache_dir = args[i];
1020997 } else if (mem.eql(u8, arg, "--zig-lib-dir")) {
1021 override_lib_dir = args_iter.next() orelse {
1022 fatal("expected parameter after {s}", .{arg});
1023 };
998 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
999 i += 1;
1000 override_lib_dir = args[i];
10241001 } else if (mem.eql(u8, arg, "--debug-log")) {
1025 const next_arg = args_iter.next() orelse {
1026 fatal("expected parameter after {s}", .{arg});
1027 };
1002 if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg});
1003 i += 1;
10281004 if (!build_options.enable_logging) {
10291005 std.log.warn("Zig was compiled without logging enabled (-Dlog). --debug-log has no effect.", .{});
10301006 } else {
1031 try log_scopes.append(gpa, next_arg);
1007 try log_scopes.append(gpa, args[i]);
10321008 }
10331009 } else if (mem.eql(u8, arg, "--debug-link-snapshot")) {
10341010 if (!build_options.enable_link_snapshots) {
......@@ -1201,9 +1177,11 @@ fn buildOutputType(
12011177 } else if (mem.eql(u8, arg, "-fno-allow-shlib-undefined")) {
12021178 linker_allow_shlib_undefined = false;
12031179 } else if (mem.eql(u8, arg, "-z")) {
1204 const z_arg = args_iter.next() orelse {
1205 fatal("expected parameter after {s}", .{arg});
1206 };
1180 i += 1;
1181 if (i >= args.len) {
1182 fatal("expected linker extension flag after '{s}'", .{arg});
1183 }
1184 const z_arg = args[i];
12071185 if (mem.eql(u8, z_arg, "nodelete")) {
12081186 linker_z_nodelete = true;
12091187 } else if (mem.eql(u8, z_arg, "notext")) {
......@@ -4311,17 +4289,6 @@ pub fn lldMain(
43114289 return @bitCast(u8, @truncate(i8, exit_code));
43124290}
43134291
4314const ArgIteratorResponseFile = process.ArgIteratorGeneral(.{ .comments = true, .single_quotes = true });
4315
4316/// Initialize the arguments from a Response File. "*.rsp"
4317fn initArgIteratorResponseFile(allocator: Allocator, resp_file_path: []const u8) !ArgIteratorResponseFile {
4318 const max_bytes = 10 * 1024 * 1024; // 10 MiB of command line arguments is a reasonable limit
4319 var cmd_line = try fs.cwd().readFileAlloc(allocator, resp_file_path, max_bytes);
4320 errdefer allocator.free(cmd_line);
4321
4322 return ArgIteratorResponseFile.initTakeOwnership(allocator, cmd_line);
4323}
4324
43254292const clang_args = @import("clang_options.zig").list;
43264293
43274294pub const ClangArgIterator = struct {
......@@ -4411,6 +4378,17 @@ pub const ClangArgIterator = struct {
44114378 };
44124379 }
44134380
4381 const ArgIteratorResponseFile = process.ArgIteratorGeneral(.{ .comments = true, .single_quotes = true });
4382
4383 /// Initialize the arguments from a Response File. "*.rsp"
4384 fn initArgIteratorResponseFile(allocator: Allocator, resp_file_path: []const u8) !ArgIteratorResponseFile {
4385 const max_bytes = 10 * 1024 * 1024; // 10 MiB of command line arguments is a reasonable limit
4386 var cmd_line = try fs.cwd().readFileAlloc(allocator, resp_file_path, max_bytes);
4387 errdefer allocator.free(cmd_line);
4388
4389 return ArgIteratorResponseFile.initTakeOwnership(allocator, cmd_line);
4390 }
4391
44144392 fn next(self: *ClangArgIterator) !void {
44154393 assert(self.has_next);
44164394 assert(self.next_index < self.argv.len);