Commit 6c2f374556
Changed files (8)
lib
std
src
lib/std/fmt/parse_float/decimal.zig
@@ -34,13 +34,13 @@ pub fn Decimal(comptime T: type) type {
/// For a double-precision IEEE-754 float, this required 767 digits,
/// so we store the max digits + 1.
///
- /// We can exactly represent a float in radix `b` from radix 2 if
+ /// We can exactly represent a float in base `b` from base 2 if
/// `b` is divisible by 2. This function calculates the exact number of
/// digits required to exactly represent that float.
///
/// According to the "Handbook of Floating Point Arithmetic",
/// for IEEE754, with emin being the min exponent, p2 being the
- /// precision, and b being the radix, the number of digits follows as:
+ /// precision, and b being the base, the number of digits follows as:
///
/// `−emin + p2 + ⌊(emin + 1) log(2, b) − log(1 − 2^(−p2), b)⌋`
///
lib/std/math/big/int.zig
@@ -1627,7 +1627,7 @@ pub const Mutable = struct {
// while x >= y * b^(n - t):
// x -= y * b^(n - t)
// q[n - t] += 1
- // Note, this algorithm is performed only once if y[t] > radix/2 and y is even, which we
+ // Note, this algorithm is performed only once if y[t] > base/2 and y is even, which we
// enforced in step 0. This means we can replace the while with an if.
// Note, multiplication by b^(n - t) comes down to shifting to the right by n - t limbs.
// We can also replace x >= y * b^(n - t) by x/b^(n - t) >= y, and use shifts for that.
@@ -2206,20 +2206,20 @@ pub const Const = struct {
out_stream: anytype,
) !void {
_ = options;
- comptime var radix = 10;
+ comptime var base = 10;
comptime var case: std.fmt.Case = .lower;
if (fmt.len == 0 or comptime mem.eql(u8, fmt, "d")) {
- radix = 10;
+ base = 10;
case = .lower;
} else if (comptime mem.eql(u8, fmt, "b")) {
- radix = 2;
+ base = 2;
case = .lower;
} else if (comptime mem.eql(u8, fmt, "x")) {
- radix = 16;
+ base = 16;
case = .lower;
} else if (comptime mem.eql(u8, fmt, "X")) {
- radix = 16;
+ base = 16;
case = .upper;
} else {
std.fmt.invalidFmtError(fmt, self);
@@ -2237,8 +2237,8 @@ pub const Const = struct {
.limbs = &([1]Limb{comptime math.maxInt(Limb)} ** available_len),
.positive = false,
};
- var buf: [biggest.sizeInBaseUpperBound(radix)]u8 = undefined;
- const len = self.toString(&buf, radix, case, &limbs);
+ var buf: [biggest.sizeInBaseUpperBound(base)]u8 = undefined;
+ const len = self.toString(&buf, base, case, &limbs);
return out_stream.writeAll(buf[0..len]);
}
lib/std/math/scalbn.zig
@@ -3,11 +3,11 @@ const expect = std.testing.expect;
/// Returns a * FLT_RADIX ^ exp.
///
-/// Zig only supports binary radix IEEE-754 floats. Hence FLT_RADIX=2, and this is an alias for ldexp.
+/// Zig only supports binary base IEEE-754 floats. Hence FLT_RADIX=2, and this is an alias for ldexp.
pub const scalbn = @import("ldexp.zig").ldexp;
test "math.scalbn" {
- // Verify we are using radix 2.
+ // Verify we are using base 2.
try expect(scalbn(@as(f16, 1.5), 4) == 24.0);
try expect(scalbn(@as(f32, 1.5), 4) == 24.0);
try expect(scalbn(@as(f64, 1.5), 4) == 24.0);
lib/std/zig/c_translation.zig
@@ -262,16 +262,19 @@ test "sizeof" {
try testing.expect(sizeof(anyopaque) == 1);
}
-pub const CIntLiteralRadix = enum { decimal, octal, hexadecimal };
+pub const CIntLiteralBase = enum { decimal, octal, hexadecimal };
-fn PromoteIntLiteralReturnType(comptime SuffixType: type, comptime number: comptime_int, comptime radix: CIntLiteralRadix) type {
+/// Deprecated: use `CIntLiteralBase`
+pub const CIntLiteralRadix = CIntLiteralBase;
+
+fn PromoteIntLiteralReturnType(comptime SuffixType: type, comptime number: comptime_int, comptime base: CIntLiteralBase) type {
const signed_decimal = [_]type{ c_int, c_long, c_longlong, c_ulonglong };
const signed_oct_hex = [_]type{ c_int, c_uint, c_long, c_ulong, c_longlong, c_ulonglong };
const unsigned = [_]type{ c_uint, c_ulong, c_ulonglong };
const list: []const type = if (@typeInfo(SuffixType).Int.signedness == .unsigned)
&unsigned
- else if (radix == .decimal)
+ else if (base == .decimal)
&signed_decimal
else
&signed_oct_hex;
@@ -290,8 +293,8 @@ fn PromoteIntLiteralReturnType(comptime SuffixType: type, comptime number: compt
pub fn promoteIntLiteral(
comptime SuffixType: type,
comptime number: comptime_int,
- comptime radix: CIntLiteralRadix,
-) PromoteIntLiteralReturnType(SuffixType, number, radix) {
+ comptime base: CIntLiteralBase,
+) PromoteIntLiteralReturnType(SuffixType, number, base) {
return number;
}
lib/std/fmt.zig
@@ -748,7 +748,7 @@ pub fn formatIntValue(
options: FormatOptions,
writer: anytype,
) !void {
- comptime var radix = 10;
+ comptime var base = 10;
comptime var case: Case = .lower;
const int_value = if (@TypeOf(value) == comptime_int) blk: {
@@ -757,7 +757,7 @@ pub fn formatIntValue(
} else value;
if (fmt.len == 0 or comptime std.mem.eql(u8, fmt, "d")) {
- radix = 10;
+ base = 10;
case = .lower;
} else if (comptime std.mem.eql(u8, fmt, "c")) {
if (@typeInfo(@TypeOf(int_value)).Int.bits <= 8) {
@@ -772,22 +772,22 @@ pub fn formatIntValue(
@compileError("cannot print integer that is larger than 21 bits as an UTF-8 sequence");
}
} else if (comptime std.mem.eql(u8, fmt, "b")) {
- radix = 2;
+ base = 2;
case = .lower;
} else if (comptime std.mem.eql(u8, fmt, "x")) {
- radix = 16;
+ base = 16;
case = .lower;
} else if (comptime std.mem.eql(u8, fmt, "X")) {
- radix = 16;
+ base = 16;
case = .upper;
} else if (comptime std.mem.eql(u8, fmt, "o")) {
- radix = 8;
+ base = 8;
case = .lower;
} else {
invalidFmtError(fmt, value);
}
- return formatInt(int_value, radix, case, options, writer);
+ return formatInt(int_value, base, case, options, writer);
}
fn formatFloatValue(
@@ -906,7 +906,7 @@ pub fn fmtSliceEscapeUpper(bytes: []const u8) std.fmt.Formatter(formatSliceEscap
return .{ .data = bytes };
}
-fn formatSizeImpl(comptime radix: comptime_int) type {
+fn formatSizeImpl(comptime base: comptime_int) type {
return struct {
fn formatSizeImpl(
value: u64,
@@ -926,13 +926,13 @@ fn formatSizeImpl(comptime radix: comptime_int) type {
const mags_iec = " KMGTPEZY";
const log2 = math.log2(value);
- const magnitude = switch (radix) {
+ const magnitude = switch (base) {
1000 => math.min(log2 / comptime math.log2(1000), mags_si.len - 1),
1024 => math.min(log2 / 10, mags_iec.len - 1),
else => unreachable,
};
- const new_value = lossyCast(f64, value) / math.pow(f64, lossyCast(f64, radix), lossyCast(f64, magnitude));
- const suffix = switch (radix) {
+ const new_value = lossyCast(f64, value) / math.pow(f64, lossyCast(f64, base), lossyCast(f64, magnitude));
+ const suffix = switch (base) {
1000 => mags_si[magnitude],
1024 => mags_iec[magnitude],
else => unreachable,
@@ -944,7 +944,7 @@ fn formatSizeImpl(comptime radix: comptime_int) type {
bufstream.writer().writeAll(if (suffix == ' ')
"B"
- else switch (radix) {
+ else switch (base) {
1000 => &[_]u8{ suffix, 'B' },
1024 => &[_]u8{ suffix, 'i', 'B' },
else => unreachable,
@@ -1730,21 +1730,21 @@ pub fn Formatter(comptime format_fn: anytype) type {
}
/// Parses the string `buf` as signed or unsigned representation in the
-/// specified radix of an integral value of type `T`.
+/// specified base of an integral value of type `T`.
///
-/// When `radix` is zero the string prefix is examined to detect the true radix:
-/// * A prefix of "0b" implies radix=2,
-/// * A prefix of "0o" implies radix=8,
-/// * A prefix of "0x" implies radix=16,
-/// * Otherwise radix=10 is assumed.
+/// When `base` is zero the string prefix is examined to detect the true base:
+/// * A prefix of "0b" implies base=2,
+/// * A prefix of "0o" implies base=8,
+/// * A prefix of "0x" implies base=16,
+/// * Otherwise base=10 is assumed.
///
/// Ignores '_' character in `buf`.
/// See also `parseUnsigned`.
-pub fn parseInt(comptime T: type, buf: []const u8, radix: u8) ParseIntError!T {
+pub fn parseInt(comptime T: type, buf: []const u8, base: u8) ParseIntError!T {
if (buf.len == 0) return error.InvalidCharacter;
- if (buf[0] == '+') return parseWithSign(T, buf[1..], radix, .pos);
- if (buf[0] == '-') return parseWithSign(T, buf[1..], radix, .neg);
- return parseWithSign(T, buf, radix, .pos);
+ if (buf[0] == '+') return parseWithSign(T, buf[1..], base, .pos);
+ if (buf[0] == '-') return parseWithSign(T, buf[1..], base, .neg);
+ return parseWithSign(T, buf, base, .pos);
}
test "parseInt" {
@@ -1777,7 +1777,7 @@ test "parseInt" {
try std.testing.expectError(error.InvalidCharacter, parseInt(u32, "-", 10));
try std.testing.expectError(error.InvalidCharacter, parseInt(i32, "-", 10));
- // autodectect the radix
+ // autodectect the base
try std.testing.expect((try parseInt(i32, "111", 0)) == 111);
try std.testing.expect((try parseInt(i32, "1_1_1", 0)) == 111);
try std.testing.expect((try parseInt(i32, "1_1_1", 0)) == 111);
@@ -1804,29 +1804,29 @@ test "parseInt" {
fn parseWithSign(
comptime T: type,
buf: []const u8,
- radix: u8,
+ base: u8,
comptime sign: enum { pos, neg },
) ParseIntError!T {
if (buf.len == 0) return error.InvalidCharacter;
- var buf_radix = radix;
+ var buf_base = base;
var buf_start = buf;
- if (radix == 0) {
+ if (base == 0) {
// Treat is as a decimal number by default.
- buf_radix = 10;
- // Detect the radix by looking at buf prefix.
+ buf_base = 10;
+ // Detect the base by looking at buf prefix.
if (buf.len > 2 and buf[0] == '0') {
switch (std.ascii.toLower(buf[1])) {
'b' => {
- buf_radix = 2;
+ buf_base = 2;
buf_start = buf[2..];
},
'o' => {
- buf_radix = 8;
+ buf_base = 8;
buf_start = buf[2..];
},
'x' => {
- buf_radix = 16;
+ buf_base = 16;
buf_start = buf[2..];
},
else => {},
@@ -1845,28 +1845,28 @@ fn parseWithSign(
for (buf_start) |c| {
if (c == '_') continue;
- const digit = try charToDigit(c, buf_radix);
+ const digit = try charToDigit(c, buf_base);
- if (x != 0) x = try math.mul(T, x, math.cast(T, buf_radix) orelse return error.Overflow);
+ if (x != 0) x = try math.mul(T, x, math.cast(T, buf_base) orelse return error.Overflow);
x = try add(T, x, math.cast(T, digit) orelse return error.Overflow);
}
return x;
}
-/// Parses the string `buf` as unsigned representation in the specified radix
+/// Parses the string `buf` as unsigned representation in the specified base
/// of an integral value of type `T`.
///
-/// When `radix` is zero the string prefix is examined to detect the true radix:
-/// * A prefix of "0b" implies radix=2,
-/// * A prefix of "0o" implies radix=8,
-/// * A prefix of "0x" implies radix=16,
-/// * Otherwise radix=10 is assumed.
+/// When `base` is zero the string prefix is examined to detect the true base:
+/// * A prefix of "0b" implies base=2,
+/// * A prefix of "0o" implies base=8,
+/// * A prefix of "0x" implies base=16,
+/// * Otherwise base=10 is assumed.
///
/// Ignores '_' character in `buf`.
/// See also `parseInt`.
-pub fn parseUnsigned(comptime T: type, buf: []const u8, radix: u8) ParseIntError!T {
- return parseWithSign(T, buf, radix, .pos);
+pub fn parseUnsigned(comptime T: type, buf: []const u8, base: u8) ParseIntError!T {
+ return parseWithSign(T, buf, base, .pos);
}
test "parseUnsigned" {
@@ -1889,7 +1889,7 @@ test "parseUnsigned" {
try std.testing.expect((try parseUnsigned(u32, "NUMBER", 36)) == 1442151747);
- // these numbers should fit even though the radix itself doesn't fit in the destination type
+ // these numbers should fit even though the base itself doesn't fit in the destination type
try std.testing.expect((try parseUnsigned(u1, "0", 10)) == 0);
try std.testing.expect((try parseUnsigned(u1, "1", 10)) == 1);
try std.testing.expectError(error.Overflow, parseUnsigned(u1, "2", 10));
@@ -1906,14 +1906,14 @@ test "parseUnsigned" {
}
/// Parses a number like '2G', '2Gi', or '2GiB'.
-pub fn parseIntSizeSuffix(buf: []const u8, radix: u8) ParseIntError!usize {
+pub fn parseIntSizeSuffix(buf: []const u8, digit_base: u8) ParseIntError!usize {
var without_B = buf;
if (mem.endsWith(u8, buf, "B")) without_B.len -= 1;
var without_i = without_B;
- var base: usize = 1000;
+ var magnitude_base: usize = 1000;
if (mem.endsWith(u8, without_B, "i")) {
without_i.len -= 1;
- base = 1024;
+ magnitude_base = 1024;
}
if (without_i.len == 0) return error.InvalidCharacter;
const orders_of_magnitude: usize = switch (without_i[without_i.len - 1]) {
@@ -1935,11 +1935,11 @@ pub fn parseIntSizeSuffix(buf: []const u8, radix: u8) ParseIntError!usize {
} else if (without_i.len != without_B.len) {
return error.InvalidCharacter;
}
- const multiplier = math.powi(usize, base, orders_of_magnitude) catch |err| switch (err) {
+ const multiplier = math.powi(usize, magnitude_base, orders_of_magnitude) catch |err| switch (err) {
error.Underflow => unreachable,
error.Overflow => return error.Overflow,
};
- const number = try std.fmt.parseInt(usize, without_suffix, radix);
+ const number = try std.fmt.parseInt(usize, without_suffix, digit_base);
return math.mul(usize, number, multiplier);
}
@@ -1962,7 +1962,7 @@ test {
_ = &parseFloat;
}
-pub fn charToDigit(c: u8, radix: u8) (error{InvalidCharacter}!u8) {
+pub fn charToDigit(c: u8, base: u8) (error{InvalidCharacter}!u8) {
const value = switch (c) {
'0'...'9' => c - '0',
'A'...'Z' => c - 'A' + 10,
@@ -1970,7 +1970,7 @@ pub fn charToDigit(c: u8, radix: u8) (error{InvalidCharacter}!u8) {
else => return error.InvalidCharacter,
};
- if (value >= radix) return error.InvalidCharacter;
+ if (value >= base) return error.InvalidCharacter;
return value;
}
src/translate_c/ast.zig
@@ -120,7 +120,7 @@ pub const Node = extern union {
std_math_Log2Int,
/// @intCast(lhs, rhs)
int_cast,
- /// @import("std").zig.c_translation.promoteIntLiteral(value, type, radix)
+ /// @import("std").zig.c_translation.promoteIntLiteral(value, type, base)
helpers_promoteIntLiteral,
/// @import("std").meta.alignment(value)
std_meta_alignment,
@@ -699,7 +699,7 @@ pub const Payload = struct {
data: struct {
value: Node,
type: Node,
- radix: Node,
+ base: Node,
},
};
@@ -898,7 +898,7 @@ fn renderNode(c: *Context, node: Node) Allocator.Error!NodeIndex {
.helpers_promoteIntLiteral => {
const payload = node.castTag(.helpers_promoteIntLiteral).?.data;
const import_node = try renderStdImport(c, &.{ "zig", "c_translation", "promoteIntLiteral" });
- return renderCall(c, import_node, &.{ payload.type, payload.value, payload.radix });
+ return renderCall(c, import_node, &.{ payload.type, payload.value, payload.base });
},
.std_meta_alignment => {
const payload = node.castTag(.std_meta_alignment).?.data;
src/main.zig
@@ -5786,12 +5786,12 @@ pub fn cmdChangelist(
try bw.flush();
}
-fn eatIntPrefix(arg: []const u8, radix: u8) []const u8 {
+fn eatIntPrefix(arg: []const u8, base: u8) []const u8 {
if (arg.len > 2 and arg[0] == '0') {
switch (std.ascii.toLower(arg[1])) {
- 'b' => if (radix == 2) return arg[2..],
- 'o' => if (radix == 8) return arg[2..],
- 'x' => if (radix == 16) return arg[2..],
+ 'b' => if (base == 2) return arg[2..],
+ 'o' => if (base == 8) return arg[2..],
+ 'x' => if (base == 16) return arg[2..],
else => {},
}
}
src/translate_c.zig
@@ -5735,21 +5735,21 @@ fn parseCNumLit(c: *Context, m: *MacroCtx) ParseError!Node {
switch (m.list[m.i].id) {
.IntegerLiteral => |suffix| {
- var radix: []const u8 = "decimal";
+ var base: []const u8 = "decimal";
if (lit_bytes.len >= 2 and lit_bytes[0] == '0') {
switch (lit_bytes[1]) {
'0'...'7' => {
// Octal
lit_bytes = try std.fmt.allocPrint(c.arena, "0o{s}", .{lit_bytes[1..]});
- radix = "octal";
+ base = "octal";
},
'X' => {
// Hexadecimal with capital X, valid in C but not in Zig
lit_bytes = try std.fmt.allocPrint(c.arena, "0x{s}", .{lit_bytes[2..]});
- radix = "hexadecimal";
+ base = "hexadecimal";
},
'x' => {
- radix = "hexadecimal";
+ base = "hexadecimal";
},
else => {},
}
@@ -5794,7 +5794,7 @@ fn parseCNumLit(c: *Context, m: *MacroCtx) ParseError!Node {
return Tag.helpers_promoteIntLiteral.create(c.arena, .{
.type = type_node,
.value = literal_node,
- .radix = try Tag.enum_literal.create(c.arena, radix),
+ .base = try Tag.enum_literal.create(c.arena, base),
});
}
},