Commit 6c2f3745564aefa669b336e249888bb7390b3a3f | zig

lib/std/fmt.zig+49-49

...	...	@@ -748,7 +748,7 @@ pub fn formatIntValue(
748	748	options: FormatOptions,
749	749	writer: anytype,
750	750	) !void {
751		comptime var radix = 10;
	751	comptime var base = 10;
752	752	comptime var case: Case = .lower;
753	753
754	754	const int_value = if (@TypeOf(value) == comptime_int) blk: {
...	...	@@ -757,7 +757,7 @@ pub fn formatIntValue(
757	757	} else value;
758	758
759	759	if (fmt.len == 0 or comptime std.mem.eql(u8, fmt, "d")) {
760		radix = 10;
	760	base = 10;
761	761	case = .lower;
762	762	} else if (comptime std.mem.eql(u8, fmt, "c")) {
763	763	if (@typeInfo(@TypeOf(int_value)).Int.bits <= 8) {
...	...	@@ -772,22 +772,22 @@ pub fn formatIntValue(
772	772	@compileError("cannot print integer that is larger than 21 bits as an UTF-8 sequence");
773	773	}
774	774	} else if (comptime std.mem.eql(u8, fmt, "b")) {
775		radix = 2;
	775	base = 2;
776	776	case = .lower;
777	777	} else if (comptime std.mem.eql(u8, fmt, "x")) {
778		radix = 16;
	778	base = 16;
779	779	case = .lower;
780	780	} else if (comptime std.mem.eql(u8, fmt, "X")) {
781		radix = 16;
	781	base = 16;
782	782	case = .upper;
783	783	} else if (comptime std.mem.eql(u8, fmt, "o")) {
784		radix = 8;
	784	base = 8;
785	785	case = .lower;
786	786	} else {
787	787	invalidFmtError(fmt, value);
788	788	}
789	789
790		return formatInt(int_value, radix, case, options, writer);
	790	return formatInt(int_value, base, case, options, writer);
791	791	}
792	792
793	793	fn formatFloatValue(
...	...	@@ -906,7 +906,7 @@ pub fn fmtSliceEscapeUpper(bytes: []const u8) std.fmt.Formatter(formatSliceEscap
906	906	return .{ .data = bytes };
907	907	}
908	908
909		fn formatSizeImpl(comptime radix: comptime_int) type {
	909	fn formatSizeImpl(comptime base: comptime_int) type {
910	910	return struct {
911	911	fn formatSizeImpl(
912	912	value: u64,
...	...	@@ -926,13 +926,13 @@ fn formatSizeImpl(comptime radix: comptime_int) type {
926	926	const mags_iec = " KMGTPEZY";
927	927
928	928	const log2 = math.log2(value);
929		const magnitude = switch (radix) {
	929	const magnitude = switch (base) {
930	930	1000 => math.min(log2 / comptime math.log2(1000), mags_si.len - 1),
931	931	1024 => math.min(log2 / 10, mags_iec.len - 1),
932	932	else => unreachable,
933	933	};
934		const new_value = lossyCast(f64, value) / math.pow(f64, lossyCast(f64, radix), lossyCast(f64, magnitude));
935		const suffix = switch (radix) {
	934	const new_value = lossyCast(f64, value) / math.pow(f64, lossyCast(f64, base), lossyCast(f64, magnitude));
	935	const suffix = switch (base) {
936	936	1000 => mags_si[magnitude],
937	937	1024 => mags_iec[magnitude],
938	938	else => unreachable,
...	...	@@ -944,7 +944,7 @@ fn formatSizeImpl(comptime radix: comptime_int) type {
944	944
945	945	bufstream.writer().writeAll(if (suffix == ' ')
946	946	"B"
947		else switch (radix) {
	947	else switch (base) {
948	948	1000 => &[_]u8{ suffix, 'B' },
949	949	1024 => &[_]u8{ suffix, 'i', 'B' },
950	950	else => unreachable,
...	...	@@ -1730,21 +1730,21 @@ pub fn Formatter(comptime format_fn: anytype) type {
1730	1730	}
1731	1731
1732	1732	/// Parses the string `buf` as signed or unsigned representation in the
1733		/// specified radix of an integral value of type `T`.
	1733	/// specified base of an integral value of type `T`.
1734	1734	///
1735		/// When `radix` is zero the string prefix is examined to detect the true radix:
1736		/// * A prefix of "0b" implies radix=2,
1737		/// * A prefix of "0o" implies radix=8,
1738		/// * A prefix of "0x" implies radix=16,
1739		/// * Otherwise radix=10 is assumed.
	1735	/// When `base` is zero the string prefix is examined to detect the true base:
	1736	/// * A prefix of "0b" implies base=2,
	1737	/// * A prefix of "0o" implies base=8,
	1738	/// * A prefix of "0x" implies base=16,
	1739	/// * Otherwise base=10 is assumed.
1740	1740	///
1741	1741	/// Ignores '_' character in `buf`.
1742	1742	/// See also `parseUnsigned`.
1743		pub fn parseInt(comptime T: type, buf: []const u8, radix: u8) ParseIntError!T {
	1743	pub fn parseInt(comptime T: type, buf: []const u8, base: u8) ParseIntError!T {
1744	1744	if (buf.len == 0) return error.InvalidCharacter;
1745		if (buf[0] == '+') return parseWithSign(T, buf[1..], radix, .pos);
1746		if (buf[0] == '-') return parseWithSign(T, buf[1..], radix, .neg);
1747		return parseWithSign(T, buf, radix, .pos);
	1745	if (buf[0] == '+') return parseWithSign(T, buf[1..], base, .pos);
	1746	if (buf[0] == '-') return parseWithSign(T, buf[1..], base, .neg);
	1747	return parseWithSign(T, buf, base, .pos);
1748	1748	}
1749	1749
1750	1750	test "parseInt" {
...	...	@@ -1777,7 +1777,7 @@ test "parseInt" {
1777	1777	try std.testing.expectError(error.InvalidCharacter, parseInt(u32, "-", 10));
1778	1778	try std.testing.expectError(error.InvalidCharacter, parseInt(i32, "-", 10));
1779	1779
1780		// autodectect the radix
	1780	// autodectect the base
1781	1781	try std.testing.expect((try parseInt(i32, "111", 0)) == 111);
1782	1782	try std.testing.expect((try parseInt(i32, "1_1_1", 0)) == 111);
1783	1783	try std.testing.expect((try parseInt(i32, "1_1_1", 0)) == 111);
...	...	@@ -1804,29 +1804,29 @@ test "parseInt" {
1804	1804	fn parseWithSign(
1805	1805	comptime T: type,
1806	1806	buf: []const u8,
1807		radix: u8,
	1807	base: u8,
1808	1808	comptime sign: enum { pos, neg },
1809	1809	) ParseIntError!T {
1810	1810	if (buf.len == 0) return error.InvalidCharacter;
1811	1811
1812		var buf_radix = radix;
	1812	var buf_base = base;
1813	1813	var buf_start = buf;
1814		if (radix == 0) {
	1814	if (base == 0) {
1815	1815	// Treat is as a decimal number by default.
1816		buf_radix = 10;
1817		// Detect the radix by looking at buf prefix.
	1816	buf_base = 10;
	1817	// Detect the base by looking at buf prefix.
1818	1818	if (buf.len > 2 and buf[0] == '0') {
1819	1819	switch (std.ascii.toLower(buf[1])) {
1820	1820	'b' => {
1821		buf_radix = 2;
	1821	buf_base = 2;
1822	1822	buf_start = buf[2..];
1823	1823	},
1824	1824	'o' => {
1825		buf_radix = 8;
	1825	buf_base = 8;
1826	1826	buf_start = buf[2..];
1827	1827	},
1828	1828	'x' => {
1829		buf_radix = 16;
	1829	buf_base = 16;
1830	1830	buf_start = buf[2..];
1831	1831	},
1832	1832	else => {},
...	...	@@ -1845,28 +1845,28 @@ fn parseWithSign(
1845	1845
1846	1846	for (buf_start) \|c\| {
1847	1847	if (c == '_') continue;
1848		const digit = try charToDigit(c, buf_radix);
	1848	const digit = try charToDigit(c, buf_base);
1849	1849
1850		if (x != 0) x = try math.mul(T, x, math.cast(T, buf_radix) orelse return error.Overflow);
	1850	if (x != 0) x = try math.mul(T, x, math.cast(T, buf_base) orelse return error.Overflow);
1851	1851	x = try add(T, x, math.cast(T, digit) orelse return error.Overflow);
1852	1852	}
1853	1853
1854	1854	return x;
1855	1855	}
1856	1856
1857		/// Parses the string `buf` as unsigned representation in the specified radix
	1857	/// Parses the string `buf` as unsigned representation in the specified base
1858	1858	/// of an integral value of type `T`.
1859	1859	///
1860		/// When `radix` is zero the string prefix is examined to detect the true radix:
1861		/// * A prefix of "0b" implies radix=2,
1862		/// * A prefix of "0o" implies radix=8,
1863		/// * A prefix of "0x" implies radix=16,
1864		/// * Otherwise radix=10 is assumed.
	1860	/// When `base` is zero the string prefix is examined to detect the true base:
	1861	/// * A prefix of "0b" implies base=2,
	1862	/// * A prefix of "0o" implies base=8,
	1863	/// * A prefix of "0x" implies base=16,
	1864	/// * Otherwise base=10 is assumed.
1865	1865	///
1866	1866	/// Ignores '_' character in `buf`.
1867	1867	/// See also `parseInt`.
1868		pub fn parseUnsigned(comptime T: type, buf: []const u8, radix: u8) ParseIntError!T {
1869		return parseWithSign(T, buf, radix, .pos);
	1868	pub fn parseUnsigned(comptime T: type, buf: []const u8, base: u8) ParseIntError!T {
	1869	return parseWithSign(T, buf, base, .pos);
1870	1870	}
1871	1871
1872	1872	test "parseUnsigned" {
...	...	@@ -1889,7 +1889,7 @@ test "parseUnsigned" {
1889	1889
1890	1890	try std.testing.expect((try parseUnsigned(u32, "NUMBER", 36)) == 1442151747);
1891	1891
1892		// these numbers should fit even though the radix itself doesn't fit in the destination type
	1892	// these numbers should fit even though the base itself doesn't fit in the destination type
1893	1893	try std.testing.expect((try parseUnsigned(u1, "0", 10)) == 0);
1894	1894	try std.testing.expect((try parseUnsigned(u1, "1", 10)) == 1);
1895	1895	try std.testing.expectError(error.Overflow, parseUnsigned(u1, "2", 10));
...	...	@@ -1906,14 +1906,14 @@ test "parseUnsigned" {
1906	1906	}
1907	1907
1908	1908	/// Parses a number like '2G', '2Gi', or '2GiB'.
1909		pub fn parseIntSizeSuffix(buf: []const u8, radix: u8) ParseIntError!usize {
	1909	pub fn parseIntSizeSuffix(buf: []const u8, digit_base: u8) ParseIntError!usize {
1910	1910	var without_B = buf;
1911	1911	if (mem.endsWith(u8, buf, "B")) without_B.len -= 1;
1912	1912	var without_i = without_B;
1913		var base: usize = 1000;
	1913	var magnitude_base: usize = 1000;
1914	1914	if (mem.endsWith(u8, without_B, "i")) {
1915	1915	without_i.len -= 1;
1916		base = 1024;
	1916	magnitude_base = 1024;
1917	1917	}
1918	1918	if (without_i.len == 0) return error.InvalidCharacter;
1919	1919	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 {
1935	1935	} else if (without_i.len != without_B.len) {
1936	1936	return error.InvalidCharacter;
1937	1937	}
1938		const multiplier = math.powi(usize, base, orders_of_magnitude) catch \|err\| switch (err) {
	1938	const multiplier = math.powi(usize, magnitude_base, orders_of_magnitude) catch \|err\| switch (err) {
1939	1939	error.Underflow => unreachable,
1940	1940	error.Overflow => return error.Overflow,
1941	1941	};
1942		const number = try std.fmt.parseInt(usize, without_suffix, radix);
	1942	const number = try std.fmt.parseInt(usize, without_suffix, digit_base);
1943	1943	return math.mul(usize, number, multiplier);
1944	1944	}
1945	1945
...	...	@@ -1962,7 +1962,7 @@ test {
1962	1962	_ = &parseFloat;
1963	1963	}
1964	1964
1965		pub fn charToDigit(c: u8, radix: u8) (error{InvalidCharacter}!u8) {
	1965	pub fn charToDigit(c: u8, base: u8) (error{InvalidCharacter}!u8) {
1966	1966	const value = switch (c) {
1967	1967	'0'...'9' => c - '0',
1968	1968	'A'...'Z' => c - 'A' + 10,
...	...	@@ -1970,7 +1970,7 @@ pub fn charToDigit(c: u8, radix: u8) (error{InvalidCharacter}!u8) {
1970	1970	else => return error.InvalidCharacter,
1971	1971	};
1972	1972
1973		if (value >= radix) return error.InvalidCharacter;
	1973	if (value >= base) return error.InvalidCharacter;
1974	1974
1975	1975	return value;
1976	1976	}

lib/std/fmt/parse_float/decimal.zig+2-2

...	...	@@ -34,13 +34,13 @@ pub fn Decimal(comptime T: type) type {
34	34	/// For a double-precision IEEE-754 float, this required 767 digits,
35	35	/// so we store the max digits + 1.
36	36	///
37		/// We can exactly represent a float in radix `b` from radix 2 if
	37	/// We can exactly represent a float in base `b` from base 2 if
38	38	/// `b` is divisible by 2. This function calculates the exact number of
39	39	/// digits required to exactly represent that float.
40	40	///
41	41	/// According to the "Handbook of Floating Point Arithmetic",
42	42	/// for IEEE754, with emin being the min exponent, p2 being the
43		/// precision, and b being the radix, the number of digits follows as:
	43	/// precision, and b being the base, the number of digits follows as:
44	44	///
45	45	/// `−emin + p2 + ⌊(emin + 1) log(2, b) − log(1 − 2^(−p2), b)⌋`
46	46	///

lib/std/math/big/int.zig+8-8

...	...	@@ -1627,7 +1627,7 @@ pub const Mutable = struct {
1627	1627	// while x >= y * b^(n - t):
1628	1628	// x -= y * b^(n - t)
1629	1629	// q[n - t] += 1
1630		// Note, this algorithm is performed only once if y[t] > radix/2 and y is even, which we
	1630	// Note, this algorithm is performed only once if y[t] > base/2 and y is even, which we
1631	1631	// enforced in step 0. This means we can replace the while with an if.
1632	1632	// Note, multiplication by b^(n - t) comes down to shifting to the right by n - t limbs.
1633	1633	// 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 {
2206	2206	out_stream: anytype,
2207	2207	) !void {
2208	2208	_ = options;
2209		comptime var radix = 10;
	2209	comptime var base = 10;
2210	2210	comptime var case: std.fmt.Case = .lower;
2211	2211
2212	2212	if (fmt.len == 0 or comptime mem.eql(u8, fmt, "d")) {
2213		radix = 10;
	2213	base = 10;
2214	2214	case = .lower;
2215	2215	} else if (comptime mem.eql(u8, fmt, "b")) {
2216		radix = 2;
	2216	base = 2;
2217	2217	case = .lower;
2218	2218	} else if (comptime mem.eql(u8, fmt, "x")) {
2219		radix = 16;
	2219	base = 16;
2220	2220	case = .lower;
2221	2221	} else if (comptime mem.eql(u8, fmt, "X")) {
2222		radix = 16;
	2222	base = 16;
2223	2223	case = .upper;
2224	2224	} else {
2225	2225	std.fmt.invalidFmtError(fmt, self);
...	...	@@ -2237,8 +2237,8 @@ pub const Const = struct {
2237	2237	.limbs = &([1]Limb{comptime math.maxInt(Limb)} ** available_len),
2238	2238	.positive = false,
2239	2239	};
2240		var buf: [biggest.sizeInBaseUpperBound(radix)]u8 = undefined;
2241		const len = self.toString(&buf, radix, case, &limbs);
	2240	var buf: [biggest.sizeInBaseUpperBound(base)]u8 = undefined;
	2241	const len = self.toString(&buf, base, case, &limbs);
2242	2242	return out_stream.writeAll(buf[0..len]);
2243	2243	}
2244	2244

lib/std/math/scalbn.zig+2-2

...	...	@@ -3,11 +3,11 @@ const expect = std.testing.expect;
3	3
4	4	/// Returns a * FLT_RADIX ^ exp.
5	5	///
6		/// Zig only supports binary radix IEEE-754 floats. Hence FLT_RADIX=2, and this is an alias for ldexp.
	6	/// Zig only supports binary base IEEE-754 floats. Hence FLT_RADIX=2, and this is an alias for ldexp.
7	7	pub const scalbn = @import("ldexp.zig").ldexp;
8	8
9	9	test "math.scalbn" {
10		// Verify we are using radix 2.
	10	// Verify we are using base 2.
11	11	try expect(scalbn(@as(f16, 1.5), 4) == 24.0);
12	12	try expect(scalbn(@as(f32, 1.5), 4) == 24.0);
13	13	try expect(scalbn(@as(f64, 1.5), 4) == 24.0);

lib/std/zig/c_translation.zig+8-5

...	...	@@ -262,16 +262,19 @@ test "sizeof" {
262	262	try testing.expect(sizeof(anyopaque) == 1);
263	263	}
264	264
265		pub const CIntLiteralRadix = enum { decimal, octal, hexadecimal };
	265	pub const CIntLiteralBase = enum { decimal, octal, hexadecimal };
266	266
267		fn PromoteIntLiteralReturnType(comptime SuffixType: type, comptime number: comptime_int, comptime radix: CIntLiteralRadix) type {
	267	/// Deprecated: use `CIntLiteralBase`
	268	pub const CIntLiteralRadix = CIntLiteralBase;
	269
	270	fn PromoteIntLiteralReturnType(comptime SuffixType: type, comptime number: comptime_int, comptime base: CIntLiteralBase) type {
268	271	const signed_decimal = [_]type{ c_int, c_long, c_longlong, c_ulonglong };
269	272	const signed_oct_hex = [_]type{ c_int, c_uint, c_long, c_ulong, c_longlong, c_ulonglong };
270	273	const unsigned = [_]type{ c_uint, c_ulong, c_ulonglong };
271	274
272	275	const list: []const type = if (@typeInfo(SuffixType).Int.signedness == .unsigned)
273	276	&unsigned
274		else if (radix == .decimal)
	277	else if (base == .decimal)
275	278	&signed_decimal
276	279	else
277	280	&signed_oct_hex;
...	...	@@ -290,8 +293,8 @@ fn PromoteIntLiteralReturnType(comptime SuffixType: type, comptime number: compt
290	293	pub fn promoteIntLiteral(
291	294	comptime SuffixType: type,
292	295	comptime number: comptime_int,
293		comptime radix: CIntLiteralRadix,
294		) PromoteIntLiteralReturnType(SuffixType, number, radix) {
	296	comptime base: CIntLiteralBase,
	297	) PromoteIntLiteralReturnType(SuffixType, number, base) {
295	298	return number;
296	299	}
297	300

src/main.zig+4-4

...	...	@@ -5786,12 +5786,12 @@ pub fn cmdChangelist(
5786	5786	try bw.flush();
5787	5787	}
5788	5788
5789		fn eatIntPrefix(arg: []const u8, radix: u8) []const u8 {
	5789	fn eatIntPrefix(arg: []const u8, base: u8) []const u8 {
5790	5790	if (arg.len > 2 and arg[0] == '0') {
5791	5791	switch (std.ascii.toLower(arg[1])) {
5792		'b' => if (radix == 2) return arg[2..],
5793		'o' => if (radix == 8) return arg[2..],
5794		'x' => if (radix == 16) return arg[2..],
	5792	'b' => if (base == 2) return arg[2..],
	5793	'o' => if (base == 8) return arg[2..],
	5794	'x' => if (base == 16) return arg[2..],
5795	5795	else => {},
5796	5796	}
5797	5797	}

src/translate_c.zig+5-5

...	...	@@ -5735,21 +5735,21 @@ fn parseCNumLit(c: Context, m: MacroCtx) ParseError!Node {
5735	5735
5736	5736	switch (m.list[m.i].id) {
5737	5737	.IntegerLiteral => \|suffix\| {
5738		var radix: []const u8 = "decimal";
	5738	var base: []const u8 = "decimal";
5739	5739	if (lit_bytes.len >= 2 and lit_bytes[0] == '0') {
5740	5740	switch (lit_bytes[1]) {
5741	5741	'0'...'7' => {
5742	5742	// Octal
5743	5743	lit_bytes = try std.fmt.allocPrint(c.arena, "0o{s}", .{lit_bytes[1..]});
5744		radix = "octal";
	5744	base = "octal";
5745	5745	},
5746	5746	'X' => {
5747	5747	// Hexadecimal with capital X, valid in C but not in Zig
5748	5748	lit_bytes = try std.fmt.allocPrint(c.arena, "0x{s}", .{lit_bytes[2..]});
5749		radix = "hexadecimal";
	5749	base = "hexadecimal";
5750	5750	},
5751	5751	'x' => {
5752		radix = "hexadecimal";
	5752	base = "hexadecimal";
5753	5753	},
5754	5754	else => {},
5755	5755	}
...	...	@@ -5794,7 +5794,7 @@ fn parseCNumLit(c: Context, m: MacroCtx) ParseError!Node {
5794	5794	return Tag.helpers_promoteIntLiteral.create(c.arena, .{
5795	5795	.type = type_node,
5796	5796	.value = literal_node,
5797		.radix = try Tag.enum_literal.create(c.arena, radix),
	5797	.base = try Tag.enum_literal.create(c.arena, base),
5798	5798	});
5799	5799	}
5800	5800	},

src/translate_c/ast.zig+3-3

...	...	@@ -120,7 +120,7 @@ pub const Node = extern union {
120	120	std_math_Log2Int,
121	121	/// @intCast(lhs, rhs)
122	122	int_cast,
123		/// @import("std").zig.c_translation.promoteIntLiteral(value, type, radix)
	123	/// @import("std").zig.c_translation.promoteIntLiteral(value, type, base)
124	124	helpers_promoteIntLiteral,
125	125	/// @import("std").meta.alignment(value)
126	126	std_meta_alignment,
...	...	@@ -699,7 +699,7 @@ pub const Payload = struct {
699	699	data: struct {
700	700	value: Node,
701	701	type: Node,
702		radix: Node,
	702	base: Node,
703	703	},
704	704	};
705	705
...	...	@@ -898,7 +898,7 @@ fn renderNode(c: *Context, node: Node) Allocator.Error!NodeIndex {
898	898	.helpers_promoteIntLiteral => {
899	899	const payload = node.castTag(.helpers_promoteIntLiteral).?.data;
900	900	const import_node = try renderStdImport(c, &.{ "zig", "c_translation", "promoteIntLiteral" });
901		return renderCall(c, import_node, &.{ payload.type, payload.value, payload.radix });
	901	return renderCall(c, import_node, &.{ payload.type, payload.value, payload.base });
902	902	},
903	903	.std_meta_alignment => {
904	904	const payload = node.castTag(.std_meta_alignment).?.data;

author	Evin Yulo <yujiri@disroot.org> 2023-05-20 20:58:28-04:00
committer	Veikka Tuominen <git@vexu.eu> 2023-06-01 00:02:16+03:00
log	6c2f3745564aefa669b336e249888bb7390b3a3f
tree	ecbd6f6ee28bc681bd935a979af22c704cc46528
parent	3085e2af4197193f08ea95d80afb2cf982227334

Use the word 'base' consistently instead of 'radix'