| ... | ... | @@ -765,30 +765,30 @@ fn buildOutputType( |
| 765 | 765 | } |
| 766 | 766 | |
| 767 | 767 | soname = .yes_default_value; |
| 768 | | var process_args_iter = try process.argsWithAllocator(arena); |
| 769 | | _ = process_args_iter.skip(); // "zig" |
| 770 | | _ = process_args_iter.skip(); // e.g. "build-lib" |
| 771 | | var resp_file_args_iter: ?ArgIteratorResponseFile = null; |
| 772 | | |
| 773 | | const getNextArg = (struct { |
| 774 | | pub fn getNextArg(_process_args_iter: *process.ArgIterator, maybe_resp_file_args_iter: *?ArgIteratorResponseFile) ?[:0]const u8 { |
| 775 | | if (_process_args_iter.next()) |proc_arg| return proc_arg; |
| 776 | | if (maybe_resp_file_args_iter.*) |*iter| return iter.next(); |
| 777 | | return null; |
| 778 | | } |
| 779 | | }).getNextArg; |
| 780 | 768 | |
| 781 | | args_loop: while (getNextArg(&process_args_iter, &resp_file_args_iter)) |arg| { |
| 782 | | var args_index = process_args_iter.inner.index; |
| 783 | | if (resp_file_args_iter) |iter| { |
| 784 | | args_index = iter.index; |
| 769 | const Iterator = struct { |
| 770 | resp_file: ?ArgIteratorResponseFile = null, |
| 771 | args: []const []const u8, |
| 772 | i: usize = 0, |
| 773 | fn next(it: *@This()) ?[]const u8 { |
| 774 | if (it.i >= it.args.len) { |
| 775 | if (it.resp_file) |*resp| return if (resp.next()) |sentinel| std.mem.span(sentinel) else null; |
| 776 | return null; |
| 777 | } |
| 778 | defer it.i += 1; |
| 779 | return it.args[it.i]; |
| 785 | 780 | } |
| 781 | }; |
| 782 | var args_iter = Iterator{ |
| 783 | .args = all_args[2..], |
| 784 | }; |
| 786 | 785 | |
| 786 | args_loop: while (args_iter.next()) |arg| { |
| 787 | 787 | if (mem.startsWith(u8, arg, "@")) { |
| 788 | 788 | // This is a "compiler response file". We must parse the file and treat its |
| 789 | 789 | // contents as command line parameters. |
| 790 | 790 | const resp_file_path = arg[1..]; |
| 791 | | resp_file_args_iter = initArgIteratorResponseFile(arena, resp_file_path) catch |err| { |
| 791 | args_iter.resp_file = initArgIteratorResponseFile(arena, resp_file_path) catch |err| { |
| 792 | 792 | fatal("unable to read response file '{s}': {s}", .{ resp_file_path, @errorName(err) }); |
| 793 | 793 | }; |
| 794 | 794 | } else if (mem.startsWith(u8, arg, "-")) { |
| ... | ... | @@ -799,14 +799,14 @@ fn buildOutputType( |
| 799 | 799 | if (arg_mode == .run) { |
| 800 | 800 | // The index refers to all_args so skip `zig` `run` |
| 801 | 801 | // and `--` |
| 802 | | runtime_args_start = args_index + 3; |
| 802 | runtime_args_start = args_iter.i + 3; |
| 803 | 803 | break :args_loop; |
| 804 | 804 | } else { |
| 805 | 805 | fatal("unexpected end-of-parameter mark: --", .{}); |
| 806 | 806 | } |
| 807 | 807 | } else if (mem.eql(u8, arg, "--pkg-begin")) { |
| 808 | | const pkg_name = getNextArg(&process_args_iter, &resp_file_args_iter); |
| 809 | | const pkg_path = getNextArg(&process_args_iter, &resp_file_args_iter); |
| 808 | const pkg_name = args_iter.next(); |
| 809 | const pkg_path = args_iter.next(); |
| 810 | 810 | if (pkg_name == null or pkg_path == null) fatal("Expected 2 arguments after {s}", .{arg}); |
| 811 | 811 | |
| 812 | 812 | const new_cur_pkg = Package.create( |
| ... | ... | @@ -822,28 +822,28 @@ fn buildOutputType( |
| 822 | 822 | cur_pkg = cur_pkg.parent orelse |
| 823 | 823 | fatal("encountered --pkg-end with no matching --pkg-begin", .{}); |
| 824 | 824 | } else if (mem.eql(u8, arg, "--main-pkg-path")) { |
| 825 | | const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse { |
| 825 | const next_arg = args_iter.next() orelse { |
| 826 | 826 | fatal("expected parameter after {s}", .{arg}); |
| 827 | 827 | }; |
| 828 | 828 | main_pkg_path = next_arg; |
| 829 | 829 | } else if (mem.eql(u8, arg, "-cflags")) { |
| 830 | 830 | extra_cflags.shrinkRetainingCapacity(0); |
| 831 | 831 | while (true) { |
| 832 | | const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse { |
| 832 | const next_arg = args_iter.next() orelse { |
| 833 | 833 | fatal("expected -- after -cflags", .{}); |
| 834 | 834 | }; |
| 835 | 835 | if (mem.eql(u8, next_arg, "--")) break; |
| 836 | 836 | try extra_cflags.append(next_arg); |
| 837 | 837 | } |
| 838 | 838 | } else if (mem.eql(u8, arg, "--color")) { |
| 839 | | const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse { |
| 839 | const next_arg = args_iter.next() orelse { |
| 840 | 840 | fatal("expected [auto|on|off] after --color", .{}); |
| 841 | 841 | }; |
| 842 | 842 | color = std.meta.stringToEnum(Color, next_arg) orelse { |
| 843 | 843 | fatal("expected [auto|on|off] after --color, found '{s}'", .{next_arg}); |
| 844 | 844 | }; |
| 845 | 845 | } else if (mem.eql(u8, arg, "--subsystem")) { |
| 846 | | const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse { |
| 846 | const next_arg = args_iter.next() orelse { |
| 847 | 847 | fatal("expected parameter after {s}", .{arg}); |
| 848 | 848 | }; |
| 849 | 849 | if (mem.eql(u8, next_arg, "console")) { |
| ... | ... | @@ -877,78 +877,78 @@ fn buildOutputType( |
| 877 | 877 | }); |
| 878 | 878 | } |
| 879 | 879 | } else if (mem.eql(u8, arg, "-O")) { |
| 880 | | const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse { |
| 880 | const next_arg = args_iter.next() orelse { |
| 881 | 881 | fatal("expected parameter after {s}", .{arg}); |
| 882 | 882 | }; |
| 883 | 883 | optimize_mode_string = next_arg; |
| 884 | 884 | } else if (mem.eql(u8, arg, "--entry")) { |
| 885 | | const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse { |
| 885 | const next_arg = args_iter.next() orelse { |
| 886 | 886 | fatal("expected parameter after {s}", .{arg}); |
| 887 | 887 | }; |
| 888 | 888 | entry = next_arg; |
| 889 | 889 | } else if (mem.eql(u8, arg, "--stack")) { |
| 890 | | const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse { |
| 890 | const next_arg = args_iter.next() orelse { |
| 891 | 891 | fatal("expected parameter after {s}", .{arg}); |
| 892 | 892 | }; |
| 893 | 893 | stack_size_override = std.fmt.parseUnsigned(u64, next_arg, 0) catch |err| { |
| 894 | 894 | fatal("unable to parse '{s}': {s}", .{ arg, @errorName(err) }); |
| 895 | 895 | }; |
| 896 | 896 | } else if (mem.eql(u8, arg, "--image-base")) { |
| 897 | | const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse { |
| 897 | const next_arg = args_iter.next() orelse { |
| 898 | 898 | fatal("expected parameter after {s}", .{arg}); |
| 899 | 899 | }; |
| 900 | 900 | image_base_override = std.fmt.parseUnsigned(u64, next_arg, 0) catch |err| { |
| 901 | 901 | fatal("unable to parse '{s}': {s}", .{ arg, @errorName(err) }); |
| 902 | 902 | }; |
| 903 | 903 | } else if (mem.eql(u8, arg, "--name")) { |
| 904 | | const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse { |
| 904 | const next_arg = args_iter.next() orelse { |
| 905 | 905 | fatal("expected parameter after {s}", .{arg}); |
| 906 | 906 | }; |
| 907 | 907 | provided_name = next_arg; |
| 908 | 908 | } else if (mem.eql(u8, arg, "-rpath")) { |
| 909 | | const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse { |
| 909 | const next_arg = args_iter.next() orelse { |
| 910 | 910 | fatal("expected parameter after {s}", .{arg}); |
| 911 | 911 | }; |
| 912 | 912 | try rpath_list.append(next_arg); |
| 913 | 913 | } else if (mem.eql(u8, arg, "--library-directory") or mem.eql(u8, arg, "-L")) { |
| 914 | | const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse { |
| 914 | const next_arg = args_iter.next() orelse { |
| 915 | 915 | fatal("expected parameter after {s}", .{arg}); |
| 916 | 916 | }; |
| 917 | 917 | try lib_dirs.append(next_arg); |
| 918 | 918 | } else if (mem.eql(u8, arg, "-F")) { |
| 919 | | const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse { |
| 919 | const next_arg = args_iter.next() orelse { |
| 920 | 920 | fatal("expected parameter after {s}", .{arg}); |
| 921 | 921 | }; |
| 922 | 922 | try framework_dirs.append(next_arg); |
| 923 | 923 | } else if (mem.eql(u8, arg, "-framework")) { |
| 924 | | const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse { |
| 924 | const next_arg = args_iter.next() orelse { |
| 925 | 925 | fatal("expected parameter after {s}", .{arg}); |
| 926 | 926 | }; |
| 927 | 927 | try frameworks.append(next_arg); |
| 928 | 928 | } else if (mem.eql(u8, arg, "-install_name")) { |
| 929 | | const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse { |
| 929 | const next_arg = args_iter.next() orelse { |
| 930 | 930 | fatal("expected parameter after {s}", .{arg}); |
| 931 | 931 | }; |
| 932 | 932 | install_name = next_arg; |
| 933 | 933 | } else if (mem.eql(u8, arg, "-T") or mem.eql(u8, arg, "--script")) { |
| 934 | | const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse { |
| 934 | const next_arg = args_iter.next() orelse { |
| 935 | 935 | fatal("expected parameter after {s}", .{arg}); |
| 936 | 936 | }; |
| 937 | 937 | linker_script = next_arg; |
| 938 | 938 | } else if (mem.eql(u8, arg, "--version-script")) { |
| 939 | | const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse { |
| 939 | const next_arg = args_iter.next() orelse { |
| 940 | 940 | fatal("expected parameter after {s}", .{arg}); |
| 941 | 941 | }; |
| 942 | 942 | version_script = next_arg; |
| 943 | 943 | } else if (mem.eql(u8, arg, "--library") or mem.eql(u8, arg, "-l")) { |
| 944 | | const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse { |
| 944 | const next_arg = args_iter.next() orelse { |
| 945 | 945 | fatal("expected parameter after {s}", .{arg}); |
| 946 | 946 | }; |
| 947 | 947 | // We don't know whether this library is part of libc or libc++ until |
| 948 | 948 | // we resolve the target, so we simply append to the list for now. |
| 949 | 949 | try system_libs.put(next_arg, .{ .needed = false }); |
| 950 | 950 | } else if (mem.eql(u8, arg, "--needed-library") or mem.eql(u8, arg, "-needed-l")) { |
| 951 | | const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse { |
| 951 | const next_arg = args_iter.next() orelse { |
| 952 | 952 | fatal("expected parameter after {s}", .{arg}); |
| 953 | 953 | }; |
| 954 | 954 | try system_libs.put(next_arg, .{ .needed = true }); |
| ... | ... | @@ -960,13 +960,13 @@ fn buildOutputType( |
| 960 | 960 | mem.eql(u8, arg, "-iframework") or |
| 961 | 961 | mem.eql(u8, arg, "-iframeworkwithsysroot")) |
| 962 | 962 | { |
| 963 | | const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse { |
| 963 | const next_arg = args_iter.next() orelse { |
| 964 | 964 | fatal("expected parameter after {s}", .{arg}); |
| 965 | 965 | }; |
| 966 | 966 | try clang_argv.append(arg); |
| 967 | 967 | try clang_argv.append(next_arg); |
| 968 | 968 | } else if (mem.eql(u8, arg, "--version")) { |
| 969 | | const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse { |
| 969 | const next_arg = args_iter.next() orelse { |
| 970 | 970 | fatal("expected parameter after {s}", .{arg}); |
| 971 | 971 | }; |
| 972 | 972 | version = std.builtin.Version.parse(next_arg) catch |err| { |
| ... | ... | @@ -974,17 +974,17 @@ fn buildOutputType( |
| 974 | 974 | }; |
| 975 | 975 | have_version = true; |
| 976 | 976 | } else if (mem.eql(u8, arg, "-target")) { |
| 977 | | const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse { |
| 977 | const next_arg = args_iter.next() orelse { |
| 978 | 978 | fatal("expected parameter after {s}", .{arg}); |
| 979 | 979 | }; |
| 980 | 980 | target_arch_os_abi = next_arg; |
| 981 | 981 | } else if (mem.eql(u8, arg, "-mcpu")) { |
| 982 | | const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse { |
| 982 | const next_arg = args_iter.next() orelse { |
| 983 | 983 | fatal("expected parameter after {s}", .{arg}); |
| 984 | 984 | }; |
| 985 | 985 | target_mcpu = next_arg; |
| 986 | 986 | } else if (mem.eql(u8, arg, "-mcmodel")) { |
| 987 | | const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse { |
| 987 | const next_arg = args_iter.next() orelse { |
| 988 | 988 | fatal("expected parameter after {s}", .{arg}); |
| 989 | 989 | }; |
| 990 | 990 | machine_code_model = parseCodeModel(next_arg); |
| ... | ... | @@ -997,54 +997,54 @@ fn buildOutputType( |
| 997 | 997 | } else if (mem.startsWith(u8, arg, "-O")) { |
| 998 | 998 | optimize_mode_string = arg["-O".len..]; |
| 999 | 999 | } else if (mem.eql(u8, arg, "--dynamic-linker")) { |
| 1000 | | const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse { |
| 1000 | const next_arg = args_iter.next() orelse { |
| 1001 | 1001 | fatal("expected parameter after {s}", .{arg}); |
| 1002 | 1002 | }; |
| 1003 | 1003 | target_dynamic_linker = next_arg; |
| 1004 | 1004 | } else if (mem.eql(u8, arg, "--sysroot")) { |
| 1005 | | const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse { |
| 1005 | const next_arg = args_iter.next() orelse { |
| 1006 | 1006 | fatal("expected parameter after {s}", .{arg}); |
| 1007 | 1007 | }; |
| 1008 | 1008 | sysroot = next_arg; |
| 1009 | 1009 | try clang_argv.append("-isysroot"); |
| 1010 | 1010 | try clang_argv.append(next_arg); |
| 1011 | 1011 | } else if (mem.eql(u8, arg, "--libc")) { |
| 1012 | | const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse { |
| 1012 | const next_arg = args_iter.next() orelse { |
| 1013 | 1013 | fatal("expected parameter after {s}", .{arg}); |
| 1014 | 1014 | }; |
| 1015 | 1015 | libc_paths_file = next_arg; |
| 1016 | 1016 | } else if (mem.eql(u8, arg, "--test-filter")) { |
| 1017 | | const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse { |
| 1017 | const next_arg = args_iter.next() orelse { |
| 1018 | 1018 | fatal("expected parameter after {s}", .{arg}); |
| 1019 | 1019 | }; |
| 1020 | 1020 | test_filter = next_arg; |
| 1021 | 1021 | } else if (mem.eql(u8, arg, "--test-name-prefix")) { |
| 1022 | | const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse { |
| 1022 | const next_arg = args_iter.next() orelse { |
| 1023 | 1023 | fatal("expected parameter after {s}", .{arg}); |
| 1024 | 1024 | }; |
| 1025 | 1025 | test_name_prefix = next_arg; |
| 1026 | 1026 | } else if (mem.eql(u8, arg, "--test-cmd")) { |
| 1027 | | const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse { |
| 1027 | const next_arg = args_iter.next() orelse { |
| 1028 | 1028 | fatal("expected parameter after {s}", .{arg}); |
| 1029 | 1029 | }; |
| 1030 | 1030 | try test_exec_args.append(next_arg); |
| 1031 | 1031 | } else if (mem.eql(u8, arg, "--cache-dir")) { |
| 1032 | | const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse { |
| 1032 | const next_arg = args_iter.next() orelse { |
| 1033 | 1033 | fatal("expected parameter after {s}", .{arg}); |
| 1034 | 1034 | }; |
| 1035 | 1035 | override_local_cache_dir = next_arg; |
| 1036 | 1036 | } else if (mem.eql(u8, arg, "--global-cache-dir")) { |
| 1037 | | const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse { |
| 1037 | const next_arg = args_iter.next() orelse { |
| 1038 | 1038 | fatal("expected parameter after {s}", .{arg}); |
| 1039 | 1039 | }; |
| 1040 | 1040 | override_global_cache_dir = next_arg; |
| 1041 | 1041 | } else if (mem.eql(u8, arg, "--zig-lib-dir")) { |
| 1042 | | const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse { |
| 1042 | const next_arg = args_iter.next() orelse { |
| 1043 | 1043 | fatal("expected parameter after {s}", .{arg}); |
| 1044 | 1044 | }; |
| 1045 | 1045 | override_lib_dir = next_arg; |
| 1046 | 1046 | } else if (mem.eql(u8, arg, "--debug-log")) { |
| 1047 | | const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse { |
| 1047 | const next_arg = args_iter.next() orelse { |
| 1048 | 1048 | fatal("expected parameter after {s}", .{arg}); |
| 1049 | 1049 | }; |
| 1050 | 1050 | if (!build_options.enable_logging) { |
| ... | ... | @@ -1223,7 +1223,7 @@ fn buildOutputType( |
| 1223 | 1223 | } else if (mem.eql(u8, arg, "-fno-allow-shlib-undefined")) { |
| 1224 | 1224 | linker_allow_shlib_undefined = false; |
| 1225 | 1225 | } else if (mem.eql(u8, arg, "-z")) { |
| 1226 | | const next_arg = getNextArg(&process_args_iter, &resp_file_args_iter) orelse { |
| 1226 | const next_arg = args_iter.next() orelse { |
| 1227 | 1227 | fatal("expected parameter after {s}", .{arg}); |
| 1228 | 1228 | }; |
| 1229 | 1229 | const z_arg = next_arg; |
Stephen Gutekanst <stephen@hexops.com> 2022-02-21 14:18:15-07:00