Commit 5c60558796715c109ddbe12472fe5692029736b2 | zig

author	antlilja <liljaanton2001@gmail.com> 2020-12-07 18:04:24+01:00
committer	Andrew Kelley <andrew@ziglang.org> 2020-12-07 16:38:52-05:00
log	5c60558796715c109ddbe12472fe5692029736b2
tree	dd2891f5f6ff5c1157ff44f261a4ce8cd374fdc9
parent	85dc039632f8b7fec2c7e87aed7271daccf46aee

Utilize std.fmt.parseUnsigned in main.zig.

* Remove function parseAnyBaseInt.
* Replace calls to parseAnyBaseInt to calls to std.fmt.parseUnsigned
with radix 0.
* Replace calls to parseInt where the type is unsigned with calls to
parseUnsigned. Note that the functionality of these arguments haven't
changed, they still retain the original radix specified.

1 files changed, 14 insertions(+), 21 deletions(-)

src
- main.zig

src/main.zig+14-21

 @@ -688,11 +688,15 @@ fn buildOutputType(
                     } else if (mem.eql(u8, arg, "--stack")) {
                         if (i + 1 >= args.len) fatal("expected parameter after {}", .{arg});
                         i += 1;
-                        stack_size_override = parseAnyBaseInt(args[i]);
+                        stack_size_override = std.fmt.parseUnsigned(u64, args[i], 0) catch |err| {
+                            fatal("unable to parse '{}': {}", .{ arg, @errorName(err) });
+                        };
                     } else if (mem.eql(u8, arg, "--image-base")) {
                         if (i + 1 >= args.len) fatal("expected parameter after {}", .{arg});
                         i += 1;
-                        image_base_override = parseAnyBaseInt(args[i]);
+                        image_base_override = std.fmt.parseUnsigned(u64, args[i], 0) catch |err| {
+                            fatal("unable to parse '{}': {}", .{ arg, @errorName(err) });
+                        };
                     } else if (mem.eql(u8, arg, "--name")) {
                         if (i + 1 >= args.len) fatal("expected parameter after {}", .{arg});
                         i += 1;
 @@ -1225,7 +1229,7 @@ fn buildOutputType(
                     if (i >= linker_args.items.len) {
                         fatal("expected linker arg after '{}'", .{arg});
                     }
-                    version.major = std.fmt.parseInt(u32, linker_args.items[i], 10) catch |err| {
+                    version.major = std.fmt.parseUnsigned(u32, linker_args.items[i], 10) catch |err| {
                         fatal("unable to parse '{}': {}", .{ arg, @errorName(err) });
                     };
                     have_version = true;
 @@ -1234,7 +1238,7 @@ fn buildOutputType(
                     if (i >= linker_args.items.len) {
                         fatal("expected linker arg after '{}'", .{arg});
                     }
-                    version.minor = std.fmt.parseInt(u32, linker_args.items[i], 10) catch |err| {
+                    version.minor = std.fmt.parseUnsigned(u32, linker_args.items[i], 10) catch |err| {
                         fatal("unable to parse '{}': {}", .{ arg, @errorName(err) });
                     };
                     have_version = true;
 @@ -1243,13 +1247,17 @@ fn buildOutputType(
                     if (i >= linker_args.items.len) {
                         fatal("expected linker arg after '{}'", .{arg});
                     }
-                    stack_size_override = parseAnyBaseInt(linker_args.items[i]);
+                    stack_size_override = std.fmt.parseUnsigned(u64, linker_args.items[i], 0) catch |err| {
+                        fatal("unable to parse '{}': {}", .{ arg, @errorName(err) });
+                    };
                 } else if (mem.eql(u8, arg, "--image-base")) {
                     i += 1;
                     if (i >= linker_args.items.len) {
                         fatal("expected linker arg after '{}'", .{arg});
                     }
-                    image_base_override = parseAnyBaseInt(linker_args.items[i]);
+                    image_base_override = std.fmt.parseUnsigned(u64, linker_args.items[i], 0) catch |err| {
+                        fatal("unable to parse '{}': {}", .{ arg, @errorName(err) });
+                    };
                 } else {
                     warn("unsupported linker arg: {}", .{arg});
                 }
 @@ -3188,18 +3196,3 @@ pub fn cleanExit() void {
         process.exit(0);
     }
 }
-fn parseAnyBaseInt(prefixed_bytes: []const u8) u64 {
-    const base: u8 = if (mem.startsWith(u8, prefixed_bytes, "0x"))
-        16
-    else if (mem.startsWith(u8, prefixed_bytes, "0o"))
-        8
-    else if (mem.startsWith(u8, prefixed_bytes, "0b"))
-        2
-    else
-        @as(u8, 10);
-    const bytes = if (base == 10) prefixed_bytes else prefixed_bytes[2..];
-    return std.fmt.parseInt(u64, bytes, base) catch |err| {
-        fatal("unable to parse '{}': {}", .{ prefixed_bytes, @errorName(err) });
-    };
-}