| ... | @@ -765,10 +765,16 @@ fn buildOutputType( | ... | @@ -765,10 +765,16 @@ fn buildOutputType( |
| 765 | } | 765 | } |
| 766 | | 766 | |
| 767 | soname = .yes_default_value; | 767 | soname = .yes_default_value; |
| 768 | const args = all_args[2..]; | 768 | var process_args_iter = try process.argsWithAllocator(arena); |
| 769 | var i: usize = 0; | 769 | _ = process_args_iter.skip(); // "zig" |
| 770 | args_loop: while (i < args.len) : (i += 1) { | 770 | _ = process_args_iter.skip(); // e.g. "build-lib" |
| 771 | const arg = args[i]; | 771 | |
| | 772 | args_loop: while (process_args_iter.next()) |arg| { |
| | 773 | var args_index = process_args_iter.inner.index; |
| | 774 | if (resp_file_args_iter) |iter| { |
| | 775 | args_index = iter.index; |
| | 776 | } |
| | 777 | |
| 772 | if (mem.startsWith(u8, arg, "-")) { | 778 | if (mem.startsWith(u8, arg, "-")) { |
| 773 | if (mem.eql(u8, arg, "-h") or mem.eql(u8, arg, "--help")) { | 779 | if (mem.eql(u8, arg, "-h") or mem.eql(u8, arg, "--help")) { |
| 774 | try io.getStdOut().writeAll(usage_build_generic); | 780 | try io.getStdOut().writeAll(usage_build_generic); |
| ... | @@ -777,73 +783,68 @@ fn buildOutputType( | ... | @@ -777,73 +783,68 @@ fn buildOutputType( |
| 777 | if (arg_mode == .run) { | 783 | if (arg_mode == .run) { |
| 778 | // The index refers to all_args so skip `zig` `run` | 784 | // The index refers to all_args so skip `zig` `run` |
| 779 | // and `--` | 785 | // and `--` |
| 780 | runtime_args_start = i + 3; | 786 | runtime_args_start = args_index + 3; |
| 781 | break :args_loop; | 787 | break :args_loop; |
| 782 | } else { | 788 | } else { |
| 783 | fatal("unexpected end-of-parameter mark: --", .{}); | 789 | fatal("unexpected end-of-parameter mark: --", .{}); |
| 784 | } | 790 | } |
| 785 | } else if (mem.eql(u8, arg, "--pkg-begin")) { | 791 | } else if (mem.eql(u8, arg, "--pkg-begin")) { |
| 786 | if (i + 2 >= args.len) fatal("Expected 2 arguments after {s}", .{arg}); | 792 | const pkg_name = process_args_iter.next(); |
| 787 | i += 1; | 793 | const pkg_path = process_args_iter.next(); |
| 788 | const pkg_name = args[i]; | 794 | if (pkg_name == null or pkg_path == null) fatal("Expected 2 arguments after {s}", .{arg}); |
| 789 | i += 1; | | |
| 790 | const pkg_path = args[i]; | | |
| 791 | | 795 | |
| 792 | const new_cur_pkg = Package.create( | 796 | const new_cur_pkg = Package.create( |
| 793 | gpa, | 797 | gpa, |
| 794 | fs.path.dirname(pkg_path), | 798 | fs.path.dirname(pkg_path.?), |
| 795 | fs.path.basename(pkg_path), | 799 | fs.path.basename(pkg_path.?), |
| 796 | ) catch |err| { | 800 | ) catch |err| { |
| 797 | fatal("Failed to add package at path {s}: {s}", .{ pkg_path, @errorName(err) }); | 801 | fatal("Failed to add package at path {s}: {s}", .{ pkg_path.?, @errorName(err) }); |
| 798 | }; | 802 | }; |
| 799 | try cur_pkg.addAndAdopt(gpa, pkg_name, new_cur_pkg); | 803 | try cur_pkg.addAndAdopt(gpa, pkg_name.?, new_cur_pkg); |
| 800 | cur_pkg = new_cur_pkg; | 804 | cur_pkg = new_cur_pkg; |
| 801 | } else if (mem.eql(u8, arg, "--pkg-end")) { | 805 | } else if (mem.eql(u8, arg, "--pkg-end")) { |
| 802 | cur_pkg = cur_pkg.parent orelse | 806 | cur_pkg = cur_pkg.parent orelse |
| 803 | fatal("encountered --pkg-end with no matching --pkg-begin", .{}); | 807 | fatal("encountered --pkg-end with no matching --pkg-begin", .{}); |
| 804 | } else if (mem.eql(u8, arg, "--main-pkg-path")) { | 808 | } else if (mem.eql(u8, arg, "--main-pkg-path")) { |
| 805 | if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg}); | 809 | const next_arg = process_args_iter.next(); |
| 806 | i += 1; | 810 | if (next_arg == null) fatal("expected parameter after {s}", .{arg}); |
| 807 | main_pkg_path = args[i]; | 811 | main_pkg_path = next_arg.?; |
| 808 | } else if (mem.eql(u8, arg, "-cflags")) { | 812 | } else if (mem.eql(u8, arg, "-cflags")) { |
| 809 | extra_cflags.shrinkRetainingCapacity(0); | 813 | extra_cflags.shrinkRetainingCapacity(0); |
| 810 | while (true) { | 814 | while (true) { |
| 811 | i += 1; | 815 | const next_arg = process_args_iter.next(); |
| 812 | if (i >= args.len) fatal("expected -- after -cflags", .{}); | 816 | if (next_arg == null) fatal("expected -- after -cflags", .{}); |
| 813 | if (mem.eql(u8, args[i], "--")) break; | 817 | if (mem.eql(u8, next_arg.?, "--")) break; |
| 814 | try extra_cflags.append(args[i]); | 818 | try extra_cflags.append(next_arg.?); |
| 815 | } | 819 | } |
| 816 | } else if (mem.eql(u8, arg, "--color")) { | 820 | } else if (mem.eql(u8, arg, "--color")) { |
| 817 | if (i + 1 >= args.len) { | 821 | const next_arg = process_args_iter.next(); |
| 818 | fatal("expected [auto|on|off] after --color", .{}); | 822 | if (next_arg == null) fatal("expected [auto|on|off] after --color", .{}); |
| 819 | } | 823 | color = std.meta.stringToEnum(Color, next_arg.?) orelse { |
| 820 | i += 1; | 824 | fatal("expected [auto|on|off] after --color, found '{s}'", .{next_arg.?}); |
| 821 | const next_arg = args[i]; | | |
| 822 | color = std.meta.stringToEnum(Color, next_arg) orelse { | | |
| 823 | fatal("expected [auto|on|off] after --color, found '{s}'", .{next_arg}); | | |
| 824 | }; | 825 | }; |
| 825 | } else if (mem.eql(u8, arg, "--subsystem")) { | 826 | } else if (mem.eql(u8, arg, "--subsystem")) { |
| 826 | if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg}); | 827 | const next_arg = process_args_iter.next(); |
| 827 | i += 1; | 828 | if (next_arg == null) fatal("expected parameter after {s}", .{arg}); |
| 828 | if (mem.eql(u8, args[i], "console")) { | 829 | if (mem.eql(u8, next_arg.?, "console")) { |
| 829 | subsystem = .Console; | 830 | subsystem = .Console; |
| 830 | } else if (mem.eql(u8, args[i], "windows")) { | 831 | } else if (mem.eql(u8, next_arg.?, "windows")) { |
| 831 | subsystem = .Windows; | 832 | subsystem = .Windows; |
| 832 | } else if (mem.eql(u8, args[i], "posix")) { | 833 | } else if (mem.eql(u8, next_arg.?, "posix")) { |
| 833 | subsystem = .Posix; | 834 | subsystem = .Posix; |
| 834 | } else if (mem.eql(u8, args[i], "native")) { | 835 | } else if (mem.eql(u8, next_arg.?, "native")) { |
| 835 | subsystem = .Native; | 836 | subsystem = .Native; |
| 836 | } else if (mem.eql(u8, args[i], "efi_application")) { | 837 | } else if (mem.eql(u8, next_arg.?, "efi_application")) { |
| 837 | subsystem = .EfiApplication; | 838 | subsystem = .EfiApplication; |
| 838 | } else if (mem.eql(u8, args[i], "efi_boot_service_driver")) { | 839 | } else if (mem.eql(u8, next_arg.?, "efi_boot_service_driver")) { |
| 839 | subsystem = .EfiBootServiceDriver; | 840 | subsystem = .EfiBootServiceDriver; |
| 840 | } else if (mem.eql(u8, args[i], "efi_rom")) { | 841 | } else if (mem.eql(u8, next_arg.?, "efi_rom")) { |
| 841 | subsystem = .EfiRom; | 842 | subsystem = .EfiRom; |
| 842 | } else if (mem.eql(u8, args[i], "efi_runtime_driver")) { | 843 | } else if (mem.eql(u8, next_arg.?, "efi_runtime_driver")) { |
| 843 | subsystem = .EfiRuntimeDriver; | 844 | subsystem = .EfiRuntimeDriver; |
| 844 | } else { | 845 | } else { |
| 845 | fatal("invalid: --subsystem: '{s}'. Options are:\n{s}", .{ | 846 | fatal("invalid: --subsystem: '{s}'. Options are:\n{s}", .{ |
| 846 | args[i], | 847 | next_arg.?, |
| 847 | \\ console | 848 | \\ console |
| 848 | \\ windows | 849 | \\ windows |
| 849 | \\ posix | 850 | \\ posix |
| ... | @@ -856,67 +857,67 @@ fn buildOutputType( | ... | @@ -856,67 +857,67 @@ fn buildOutputType( |
| 856 | }); | 857 | }); |
| 857 | } | 858 | } |
| 858 | } else if (mem.eql(u8, arg, "-O")) { | 859 | } else if (mem.eql(u8, arg, "-O")) { |
| 859 | if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg}); | 860 | const next_arg = process_args_iter.next(); |
| 860 | i += 1; | 861 | if (next_arg == null) fatal("expected parameter after {s}", .{arg}); |
| 861 | optimize_mode_string = args[i]; | 862 | optimize_mode_string = next_arg.?; |
| 862 | } else if (mem.eql(u8, arg, "--entry")) { | 863 | } else if (mem.eql(u8, arg, "--entry")) { |
| 863 | if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg}); | 864 | const next_arg = process_args_iter.next(); |
| 864 | i += 1; | 865 | if (next_arg == null) fatal("expected parameter after {s}", .{arg}); |
| 865 | entry = args[i]; | 866 | entry = next_arg.?; |
| 866 | } else if (mem.eql(u8, arg, "--stack")) { | 867 | } else if (mem.eql(u8, arg, "--stack")) { |
| 867 | if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg}); | 868 | const next_arg = process_args_iter.next(); |
| 868 | i += 1; | 869 | if (next_arg == null) fatal("expected parameter after {s}", .{arg}); |
| 869 | stack_size_override = std.fmt.parseUnsigned(u64, args[i], 0) catch |err| { | 870 | stack_size_override = std.fmt.parseUnsigned(u64, next_arg.?, 0) catch |err| { |
| 870 | fatal("unable to parse '{s}': {s}", .{ arg, @errorName(err) }); | 871 | fatal("unable to parse '{s}': {s}", .{ arg, @errorName(err) }); |
| 871 | }; | 872 | }; |
| 872 | } else if (mem.eql(u8, arg, "--image-base")) { | 873 | } else if (mem.eql(u8, arg, "--image-base")) { |
| 873 | if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg}); | 874 | const next_arg = process_args_iter.next(); |
| 874 | i += 1; | 875 | if (next_arg == null) fatal("expected parameter after {s}", .{arg}); |
| 875 | image_base_override = std.fmt.parseUnsigned(u64, args[i], 0) catch |err| { | 876 | image_base_override = std.fmt.parseUnsigned(u64, next_arg.?, 0) catch |err| { |
| 876 | fatal("unable to parse '{s}': {s}", .{ arg, @errorName(err) }); | 877 | fatal("unable to parse '{s}': {s}", .{ arg, @errorName(err) }); |
| 877 | }; | 878 | }; |
| 878 | } else if (mem.eql(u8, arg, "--name")) { | 879 | } else if (mem.eql(u8, arg, "--name")) { |
| 879 | if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg}); | 880 | const next_arg = process_args_iter.next(); |
| 880 | i += 1; | 881 | if (next_arg == null) fatal("expected parameter after {s}", .{arg}); |
| 881 | provided_name = args[i]; | 882 | provided_name = next_arg.?; |
| 882 | } else if (mem.eql(u8, arg, "-rpath")) { | 883 | } else if (mem.eql(u8, arg, "-rpath")) { |
| 883 | if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg}); | 884 | const next_arg = process_args_iter.next(); |
| 884 | i += 1; | 885 | if (next_arg == null) fatal("expected parameter after {s}", .{arg}); |
| 885 | try rpath_list.append(args[i]); | 886 | try rpath_list.append(next_arg.?); |
| 886 | } else if (mem.eql(u8, arg, "--library-directory") or mem.eql(u8, arg, "-L")) { | 887 | } else if (mem.eql(u8, arg, "--library-directory") or mem.eql(u8, arg, "-L")) { |
| 887 | if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg}); | 888 | const next_arg = process_args_iter.next(); |
| 888 | i += 1; | 889 | if (next_arg == null) fatal("expected parameter after {s}", .{arg}); |
| 889 | try lib_dirs.append(args[i]); | 890 | try lib_dirs.append(next_arg.?); |
| 890 | } else if (mem.eql(u8, arg, "-F")) { | 891 | } else if (mem.eql(u8, arg, "-F")) { |
| 891 | if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg}); | 892 | const next_arg = process_args_iter.next(); |
| 892 | i += 1; | 893 | if (next_arg == null) fatal("expected parameter after {s}", .{arg}); |
| 893 | try framework_dirs.append(args[i]); | 894 | try framework_dirs.append(next_arg.?); |
| 894 | } else if (mem.eql(u8, arg, "-framework")) { | 895 | } else if (mem.eql(u8, arg, "-framework")) { |
| 895 | if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg}); | 896 | const next_arg = process_args_iter.next(); |
| 896 | i += 1; | 897 | if (next_arg == null) fatal("expected parameter after {s}", .{arg}); |
| 897 | try frameworks.append(args[i]); | 898 | try frameworks.append(next_arg.?); |
| 898 | } else if (mem.eql(u8, arg, "-install_name")) { | 899 | } else if (mem.eql(u8, arg, "-install_name")) { |
| 899 | if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg}); | 900 | const next_arg = process_args_iter.next(); |
| 900 | i += 1; | 901 | if (next_arg == null) fatal("expected parameter after {s}", .{arg}); |
| 901 | install_name = args[i]; | 902 | install_name = next_arg.?; |
| 902 | } else if (mem.eql(u8, arg, "-T") or mem.eql(u8, arg, "--script")) { | 903 | } else if (mem.eql(u8, arg, "-T") or mem.eql(u8, arg, "--script")) { |
| 903 | if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg}); | 904 | const next_arg = process_args_iter.next(); |
| 904 | i += 1; | 905 | if (next_arg == null) fatal("expected parameter after {s}", .{arg}); |
| 905 | linker_script = args[i]; | 906 | linker_script = next_arg.?; |
| 906 | } else if (mem.eql(u8, arg, "--version-script")) { | 907 | } else if (mem.eql(u8, arg, "--version-script")) { |
| 907 | if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg}); | 908 | const next_arg = process_args_iter.next(); |
| 908 | i += 1; | 909 | if (next_arg == null) fatal("expected parameter after {s}", .{arg}); |
| 909 | version_script = args[i]; | 910 | version_script = next_arg.?; |
| 910 | } else if (mem.eql(u8, arg, "--library") or mem.eql(u8, arg, "-l")) { | 911 | } else if (mem.eql(u8, arg, "--library") or mem.eql(u8, arg, "-l")) { |
| 911 | if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg}); | 912 | const next_arg = process_args_iter.next(); |
| | 913 | if (next_arg == null) fatal("expected parameter after {s}", .{arg}); |
| 912 | // We don't know whether this library is part of libc or libc++ until | 914 | // We don't know whether this library is part of libc or libc++ until |
| 913 | // we resolve the target, so we simply append to the list for now. | 915 | // we resolve the target, so we simply append to the list for now. |
| 914 | i += 1; | 916 | try system_libs.put(next_arg.?, .{ .needed = false }); |
| 915 | try system_libs.put(args[i], .{ .needed = false }); | | |
| 916 | } else if (mem.eql(u8, arg, "--needed-library") or mem.eql(u8, arg, "-needed-l")) { | 917 | } else if (mem.eql(u8, arg, "--needed-library") or mem.eql(u8, arg, "-needed-l")) { |
| 917 | if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg}); | 918 | const next_arg = process_args_iter.next(); |
| 918 | i += 1; | 919 | if (next_arg == null) fatal("expected parameter after {s}", .{arg}); |
| 919 | try system_libs.put(args[i], .{ .needed = true }); | 920 | try system_libs.put(next_arg.?, .{ .needed = true }); |
| 920 | } else if (mem.eql(u8, arg, "-D") or | 921 | } else if (mem.eql(u8, arg, "-D") or |
| 921 | mem.eql(u8, arg, "-isystem") or | 922 | mem.eql(u8, arg, "-isystem") or |
| 922 | mem.eql(u8, arg, "-I") or | 923 | mem.eql(u8, arg, "-I") or |
| ... | @@ -925,31 +926,29 @@ fn buildOutputType( | ... | @@ -925,31 +926,29 @@ fn buildOutputType( |
| 925 | mem.eql(u8, arg, "-iframework") or | 926 | mem.eql(u8, arg, "-iframework") or |
| 926 | mem.eql(u8, arg, "-iframeworkwithsysroot")) | 927 | mem.eql(u8, arg, "-iframeworkwithsysroot")) |
| 927 | { | 928 | { |
| 928 | if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg}); | 929 | const next_arg = process_args_iter.next(); |
| 929 | i += 1; | 930 | if (next_arg == null) fatal("expected parameter after {s}", .{arg}); |
| 930 | try clang_argv.append(arg); | 931 | try clang_argv.append(arg); |
| 931 | try clang_argv.append(args[i]); | 932 | try clang_argv.append(next_arg.?); |
| 932 | } else if (mem.eql(u8, arg, "--version")) { | 933 | } else if (mem.eql(u8, arg, "--version")) { |
| 933 | if (i + 1 >= args.len) { | 934 | const next_arg = process_args_iter.next(); |
| 934 | fatal("expected parameter after --version", .{}); | 935 | if (next_arg == null) fatal("expected parameter after --version", .{}); |
| 935 | } | 936 | version = std.builtin.Version.parse(next_arg.?) catch |err| { |
| 936 | i += 1; | 937 | fatal("unable to parse --version '{s}': {s}", .{ next_arg.?, @errorName(err) }); |
| 937 | version = std.builtin.Version.parse(args[i]) catch |err| { | | |
| 938 | fatal("unable to parse --version '{s}': {s}", .{ args[i], @errorName(err) }); | | |
| 939 | }; | 938 | }; |
| 940 | have_version = true; | 939 | have_version = true; |
| 941 | } else if (mem.eql(u8, arg, "-target")) { | 940 | } else if (mem.eql(u8, arg, "-target")) { |
| 942 | if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg}); | 941 | const next_arg = process_args_iter.next(); |
| 943 | i += 1; | 942 | if (next_arg == null) fatal("expected parameter after {s}", .{arg}); |
| 944 | target_arch_os_abi = args[i]; | 943 | target_arch_os_abi = next_arg.?; |
| 945 | } else if (mem.eql(u8, arg, "-mcpu")) { | 944 | } else if (mem.eql(u8, arg, "-mcpu")) { |
| 946 | if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg}); | 945 | const next_arg = process_args_iter.next(); |
| 947 | i += 1; | 946 | if (next_arg == null) fatal("expected parameter after {s}", .{arg}); |
| 948 | target_mcpu = args[i]; | 947 | target_mcpu = next_arg.?; |
| 949 | } else if (mem.eql(u8, arg, "-mcmodel")) { | 948 | } else if (mem.eql(u8, arg, "-mcmodel")) { |
| 950 | if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg}); | 949 | const next_arg = process_args_iter.next(); |
| 951 | i += 1; | 950 | if (next_arg == null) fatal("expected parameter after {s}", .{arg}); |
| 952 | machine_code_model = parseCodeModel(args[i]); | 951 | machine_code_model = parseCodeModel(next_arg.?); |
| 953 | } else if (mem.startsWith(u8, arg, "-ofmt=")) { | 952 | } else if (mem.startsWith(u8, arg, "-ofmt=")) { |
| 954 | target_ofmt = arg["-ofmt=".len..]; | 953 | target_ofmt = arg["-ofmt=".len..]; |
| 955 | } else if (mem.startsWith(u8, arg, "-mcpu=")) { | 954 | } else if (mem.startsWith(u8, arg, "-mcpu=")) { |
| ... | @@ -959,50 +958,50 @@ fn buildOutputType( | ... | @@ -959,50 +958,50 @@ fn buildOutputType( |
| 959 | } else if (mem.startsWith(u8, arg, "-O")) { | 958 | } else if (mem.startsWith(u8, arg, "-O")) { |
| 960 | optimize_mode_string = arg["-O".len..]; | 959 | optimize_mode_string = arg["-O".len..]; |
| 961 | } else if (mem.eql(u8, arg, "--dynamic-linker")) { | 960 | } else if (mem.eql(u8, arg, "--dynamic-linker")) { |
| 962 | if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg}); | 961 | const next_arg = process_args_iter.next(); |
| 963 | i += 1; | 962 | if (next_arg == null) fatal("expected parameter after {s}", .{arg}); |
| 964 | target_dynamic_linker = args[i]; | 963 | target_dynamic_linker = next_arg.?; |
| 965 | } else if (mem.eql(u8, arg, "--sysroot")) { | 964 | } else if (mem.eql(u8, arg, "--sysroot")) { |
| 966 | if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg}); | 965 | const next_arg = process_args_iter.next(); |
| 967 | i += 1; | 966 | if (next_arg == null) fatal("expected parameter after {s}", .{arg}); |
| 968 | sysroot = args[i]; | 967 | sysroot = next_arg.?; |
| 969 | try clang_argv.append("-isysroot"); | 968 | try clang_argv.append("-isysroot"); |
| 970 | try clang_argv.append(args[i]); | 969 | try clang_argv.append(next_arg.?); |
| 971 | } else if (mem.eql(u8, arg, "--libc")) { | 970 | } else if (mem.eql(u8, arg, "--libc")) { |
| 972 | if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg}); | 971 | const next_arg = process_args_iter.next(); |
| 973 | i += 1; | 972 | if (next_arg == null) fatal("expected parameter after {s}", .{arg}); |
| 974 | libc_paths_file = args[i]; | 973 | libc_paths_file = next_arg.?; |
| 975 | } else if (mem.eql(u8, arg, "--test-filter")) { | 974 | } else if (mem.eql(u8, arg, "--test-filter")) { |
| 976 | if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg}); | 975 | const next_arg = process_args_iter.next(); |
| 977 | i += 1; | 976 | if (next_arg == null) fatal("expected parameter after {s}", .{arg}); |
| 978 | test_filter = args[i]; | 977 | test_filter = next_arg.?; |
| 979 | } else if (mem.eql(u8, arg, "--test-name-prefix")) { | 978 | } else if (mem.eql(u8, arg, "--test-name-prefix")) { |
| 980 | if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg}); | 979 | const next_arg = process_args_iter.next(); |
| 981 | i += 1; | 980 | if (next_arg == null) fatal("expected parameter after {s}", .{arg}); |
| 982 | test_name_prefix = args[i]; | 981 | test_name_prefix = next_arg.?; |
| 983 | } else if (mem.eql(u8, arg, "--test-cmd")) { | 982 | } else if (mem.eql(u8, arg, "--test-cmd")) { |
| 984 | if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg}); | 983 | const next_arg = process_args_iter.next(); |
| 985 | i += 1; | 984 | if (next_arg == null) fatal("expected parameter after {s}", .{arg}); |
| 986 | try test_exec_args.append(args[i]); | 985 | try test_exec_args.append(next_arg.?); |
| 987 | } else if (mem.eql(u8, arg, "--cache-dir")) { | 986 | } else if (mem.eql(u8, arg, "--cache-dir")) { |
| 988 | if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg}); | 987 | const next_arg = process_args_iter.next(); |
| 989 | i += 1; | 988 | if (next_arg == null) fatal("expected parameter after {s}", .{arg}); |
| 990 | override_local_cache_dir = args[i]; | 989 | override_local_cache_dir = next_arg.?; |
| 991 | } else if (mem.eql(u8, arg, "--global-cache-dir")) { | 990 | } else if (mem.eql(u8, arg, "--global-cache-dir")) { |
| 992 | if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg}); | 991 | const next_arg = process_args_iter.next(); |
| 993 | i += 1; | 992 | if (next_arg == null) fatal("expected parameter after {s}", .{arg}); |
| 994 | override_global_cache_dir = args[i]; | 993 | override_global_cache_dir = next_arg.?; |
| 995 | } else if (mem.eql(u8, arg, "--zig-lib-dir")) { | 994 | } else if (mem.eql(u8, arg, "--zig-lib-dir")) { |
| 996 | if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg}); | 995 | const next_arg = process_args_iter.next(); |
| 997 | i += 1; | 996 | if (next_arg == null) fatal("expected parameter after {s}", .{arg}); |
| 998 | override_lib_dir = args[i]; | 997 | override_lib_dir = next_arg.?; |
| 999 | } else if (mem.eql(u8, arg, "--debug-log")) { | 998 | } else if (mem.eql(u8, arg, "--debug-log")) { |
| 1000 | if (i + 1 >= args.len) fatal("expected parameter after {s}", .{arg}); | 999 | const next_arg = process_args_iter.next(); |
| 1001 | i += 1; | 1000 | if (next_arg == null) fatal("expected parameter after {s}", .{arg}); |
| 1002 | if (!build_options.enable_logging) { | 1001 | if (!build_options.enable_logging) { |
| 1003 | std.log.warn("Zig was compiled without logging enabled (-Dlog). --debug-log has no effect.", .{}); | 1002 | std.log.warn("Zig was compiled without logging enabled (-Dlog). --debug-log has no effect.", .{}); |
| 1004 | } else { | 1003 | } else { |
| 1005 | try log_scopes.append(gpa, args[i]); | 1004 | try log_scopes.append(gpa, next_arg.?); |
| 1006 | } | 1005 | } |
| 1007 | } else if (mem.eql(u8, arg, "--debug-link-snapshot")) { | 1006 | } else if (mem.eql(u8, arg, "--debug-link-snapshot")) { |
| 1008 | if (!build_options.enable_link_snapshots) { | 1007 | if (!build_options.enable_link_snapshots) { |
| ... | @@ -1175,11 +1174,9 @@ fn buildOutputType( | ... | @@ -1175,11 +1174,9 @@ fn buildOutputType( |
| 1175 | } else if (mem.eql(u8, arg, "-fno-allow-shlib-undefined")) { | 1174 | } else if (mem.eql(u8, arg, "-fno-allow-shlib-undefined")) { |
| 1176 | linker_allow_shlib_undefined = false; | 1175 | linker_allow_shlib_undefined = false; |
| 1177 | } else if (mem.eql(u8, arg, "-z")) { | 1176 | } else if (mem.eql(u8, arg, "-z")) { |
| 1178 | i += 1; | 1177 | const next_arg = process_args_iter.next(); |
| 1179 | if (i >= args.len) { | 1178 | if (next_arg == null) fatal("expected linker extension flag after '{s}'", .{arg}); |
| 1180 | fatal("expected linker extension flag after '{s}'", .{arg}); | 1179 | const z_arg = next_arg.?; |
| 1181 | } | | |
| 1182 | const z_arg = args[i]; | | |
| 1183 | if (mem.eql(u8, z_arg, "nodelete")) { | 1180 | if (mem.eql(u8, z_arg, "nodelete")) { |
| 1184 | linker_z_nodelete = true; | 1181 | linker_z_nodelete = true; |
| 1185 | } else if (mem.eql(u8, z_arg, "notext")) { | 1182 | } else if (mem.eql(u8, z_arg, "notext")) { |
| ... | @@ -4265,6 +4262,17 @@ pub fn lldMain( | ... | @@ -4265,6 +4262,17 @@ pub fn lldMain( |
| 4265 | return @bitCast(u8, @truncate(i8, exit_code)); | 4262 | return @bitCast(u8, @truncate(i8, exit_code)); |
| 4266 | } | 4263 | } |
| 4267 | | 4264 | |
| | 4265 | const ArgIteratorResponseFile = process.ArgIteratorGeneral(.{ .comments = true, .single_quotes = true }); |
| | 4266 | |
| | 4267 | /// Initialize the arguments from a Response File. "*.rsp" |
| | 4268 | fn initArgIteratorResponseFile(allocator: Allocator, resp_file_path: []const u8) !ArgIteratorResponseFile { |
| | 4269 | const max_bytes = 10 * 1024 * 1024; // 10 MiB of command line arguments is a reasonable limit |
| | 4270 | var cmd_line = try fs.cwd().readFileAlloc(allocator, resp_file_path, max_bytes); |
| | 4271 | errdefer allocator.free(cmd_line); |
| | 4272 | |
| | 4273 | return ArgIteratorResponseFile.initTakeOwnership(allocator, cmd_line); |
| | 4274 | } |
| | 4275 | |
| 4268 | const clang_args = @import("clang_options.zig").list; | 4276 | const clang_args = @import("clang_options.zig").list; |
| 4269 | | 4277 | |
| 4270 | pub const ClangArgIterator = struct { | 4278 | pub const ClangArgIterator = struct { |
| ... | @@ -4354,17 +4362,6 @@ pub const ClangArgIterator = struct { | ... | @@ -4354,17 +4362,6 @@ pub const ClangArgIterator = struct { |
| 4354 | }; | 4362 | }; |
| 4355 | } | 4363 | } |
| 4356 | | 4364 | |
| 4357 | const ArgIteratorResponseFile = process.ArgIteratorGeneral(.{ .comments = true, .single_quotes = true }); | | |
| 4358 | | | |
| 4359 | /// Initialize the arguments from a Response File. "*.rsp" | | |
| 4360 | fn initArgIteratorResponseFile(allocator: Allocator, resp_file_path: []const u8) !ArgIteratorResponseFile { | | |
| 4361 | const max_bytes = 10 * 1024 * 1024; // 10 MiB of command line arguments is a reasonable limit | | |
| 4362 | var cmd_line = try fs.cwd().readFileAlloc(allocator, resp_file_path, max_bytes); | | |
| 4363 | errdefer allocator.free(cmd_line); | | |
| 4364 | | | |
| 4365 | return ArgIteratorResponseFile.initTakeOwnership(allocator, cmd_line); | | |
| 4366 | } | | |
| 4367 | | | |
| 4368 | fn next(self: *ClangArgIterator) !void { | 4365 | fn next(self: *ClangArgIterator) !void { |
| 4369 | assert(self.has_next); | 4366 | assert(self.has_next); |
| 4370 | assert(self.next_index < self.argv.len); | 4367 | assert(self.next_index < self.argv.len); |
Stephen Gutekanst <stephen@hexops.com> 2022-02-19 23:28:54-07:00
src