std.leb128.builtin
常量
std.leb128.std
别名
别名目标 std
std.leb128.testing
别名
别名目标 std.testing
std.leb128.writeSignedFixed
函数
这是一个“高级”函数,允许使用固定内存大小存储 ILEB128。这违背了采用该编码的初衷:较小的数不再 占用较少的字节。固定宽度的优点是字段大小 可预测,因此在某些使用场景下,这种权衡可能值得。 例如生成 DWARF 信息时,希望使 ILEB128 字段 “可重定位”,即之后可以回头将该数字修补为 另一个值,而无需移动所有后续代码。
pub fn writeSignedFixed(comptime l: usize, ptr: *[l]u8, int: @Int(.signed, l * 7)) void
参数
l: usize
ptr: *[l]u8
int: @Int(.signed, l * 7)
用法示例
test writeSignedFixed {
{
var buf: [4]u8 = undefined;
writeSignedFixed(4, &buf, 0);
var reader: std.Io.Reader = .fixed(&buf);
try testing.expectEqual(0, try reader.takeLeb128(i64));
}
{
var buf: [4]u8 = undefined;
writeSignedFixed(4, &buf, 1);
var reader: std.Io.Reader = .fixed(&buf);
try testing.expectEqual(1, try reader.takeLeb128(i64));
}
{
var buf: [4]u8 = undefined;
writeSignedFixed(4, &buf, -1);
var reader: std.Io.Reader = .fixed(&buf);
try testing.expectEqual(-1, try reader.takeLeb128(i64));
}
{
var buf: [4]u8 = undefined;
writeSignedFixed(4, &buf, 1000);
var reader: std.Io.Reader = .fixed(&buf);
try testing.expectEqual(1000, try reader.takeLeb128(i64));
}
{
var buf: [4]u8 = undefined;
writeSignedFixed(4, &buf, -1000);
var reader: std.Io.Reader = .fixed(&buf);
try testing.expectEqual(-1000, try reader.takeLeb128(i64));
}
{
var buf: [4]u8 = undefined;
writeSignedFixed(4, &buf, -10000000);
var reader: std.Io.Reader = .fixed(&buf);
try testing.expectEqual(-10000000, try reader.takeLeb128(i64));
}
{
var buf: [4]u8 = undefined;
writeSignedFixed(4, &buf, 10000000);
var reader: std.Io.Reader = .fixed(&buf);
try testing.expectEqual(10000000, try reader.takeLeb128(i64));
}
}
std.leb128.writeUnsignedExtended
函数
与 writeUnsignedFixed 相同,但长度在运行时确定。
断言 slice.len > 0。
pub fn writeUnsignedExtended(slice: []u8, arg: anytype) void
参数
slice: []u8
std.leb128.writeUnsignedFixed
函数
这是“高级”函数,允许使用固定大小的内存保存 ULEB128。这违背了使用此数据编码的初衷:较小的数不再占用 更少字节。固定宽度的优点是使字段大小 可预测,因此在某些用例中,这种折中可能值得。 例如,生成 DWARF 信息时,希望让 ULEB128 字段 “可重定位”,即以后可以回到该位置将数值修补为 另一个值,而无需移动后续全部代码。
pub fn writeUnsignedFixed(comptime l: usize, ptr: *[l]u8, int: @Int(.unsigned, l * 7)) void
参数
l: usize
ptr: *[l]u8
int: @Int(.unsigned, l * 7)
用法示例
test writeUnsignedFixed {
{
var buf: [4]u8 = undefined;
writeUnsignedFixed(4, &buf, 0);
var reader: std.Io.Reader = .fixed(&buf);
try testing.expectEqual(0, try reader.takeLeb128(u64));
}
{
var buf: [4]u8 = undefined;
writeUnsignedFixed(4, &buf, 1);
var reader: std.Io.Reader = .fixed(&buf);
try testing.expectEqual(1, try reader.takeLeb128(u64));
}
{
var buf: [4]u8 = undefined;
writeUnsignedFixed(4, &buf, 1000);
var reader: std.Io.Reader = .fixed(&buf);
try testing.expectEqual(1000, try reader.takeLeb128(u64));
}
{
var buf: [4]u8 = undefined;
writeUnsignedFixed(4, &buf, 10000000);
var reader: std.Io.Reader = .fixed(&buf);
try testing.expectEqual(10000000, try reader.takeLeb128(u64));
}
}
源码
std/leb128.zig
const builtin = @import("builtin");
const std = @import("std");
const testing = std.testing;
/// 这是“高级”函数,允许使用固定大小的内存保存
/// ULEB128。这违背了使用此数据编码的初衷:较小的数不再占用
/// 更少字节。固定宽度的优点是使字段大小
/// 可预测,因此在某些用例中,这种折中可能值得。
/// 例如,生成 DWARF 信息时,希望让 ULEB128 字段
/// “可重定位”,即以后可以回到该位置将数值修补为
/// 另一个值,而无需移动后续全部代码。
pub fn writeUnsignedFixed(comptime l: usize, ptr: *[l]u8, int: @Int(.unsigned, l * 7)) void {
writeUnsignedExtended(ptr, int);
}
/// 与 `writeUnsignedFixed` 相同,但长度在运行时确定。
/// 断言 `slice.len > 0`。
pub fn writeUnsignedExtended(slice: []u8, arg: anytype) void {
const Arg = @TypeOf(arg);
const Int = switch (Arg) {
comptime_int => std.math.IntFittingRange(arg, arg),
else => Arg,
};
const Value = if (@typeInfo(Int).int.bits < 8) u8 else Int;
var value: Value = arg;
for (slice[0 .. slice.len - 1]) |*byte| {
byte.* = @truncate(0x80 | value);
value >>= 7;
}
slice[slice.len - 1] = @as(u7, @intCast(value));
}
test writeUnsignedFixed {
{
var buf: [4]u8 = undefined;
writeUnsignedFixed(4, &buf, 0);
var reader: std.Io.Reader = .fixed(&buf);
try testing.expectEqual(0, try reader.takeLeb128(u64));
}
{
var buf: [4]u8 = undefined;
writeUnsignedFixed(4, &buf, 1);
var reader: std.Io.Reader = .fixed(&buf);
try testing.expectEqual(1, try reader.takeLeb128(u64));
}
{
var buf: [4]u8 = undefined;
writeUnsignedFixed(4, &buf, 1000);
var reader: std.Io.Reader = .fixed(&buf);
try testing.expectEqual(1000, try reader.takeLeb128(u64));
}
{
var buf: [4]u8 = undefined;
writeUnsignedFixed(4, &buf, 10000000);
var reader: std.Io.Reader = .fixed(&buf);
try testing.expectEqual(10000000, try reader.takeLeb128(u64));
}
}
/// 这是一个“高级”函数,允许使用固定内存大小存储
/// ILEB128。这违背了采用该编码的初衷:较小的数不再
/// 占用较少的字节。固定宽度的优点是字段大小
/// 可预测,因此在某些使用场景下,这种权衡可能值得。
/// 例如生成 DWARF 信息时,希望使 ILEB128 字段
/// “可重定位”,即之后可以回头将该数字修补为
/// 另一个值,而无需移动所有后续代码。
pub fn writeSignedFixed(comptime l: usize, ptr: *[l]u8, int: @Int(.signed, l * 7)) void {
const T = @TypeOf(int);
const U = if (@typeInfo(T).int.bits < 8) u8 else T;
var value: U = @intCast(int);
comptime var i = 0;
inline while (i < (l - 1)) : (i += 1) {
const byte: u8 = @bitCast(@as(i8, @truncate(value)) | -0b1000_0000);
value >>= 7;
ptr[i] = byte;
}
ptr[i] = @as(u7, @bitCast(@as(i7, @truncate(value))));
}
test writeSignedFixed {
{
var buf: [4]u8 = undefined;
writeSignedFixed(4, &buf, 0);
var reader: std.Io.Reader = .fixed(&buf);
try testing.expectEqual(0, try reader.takeLeb128(i64));
}
{
var buf: [4]u8 = undefined;
writeSignedFixed(4, &buf, 1);
var reader: std.Io.Reader = .fixed(&buf);
try testing.expectEqual(1, try reader.takeLeb128(i64));
}
{
var buf: [4]u8 = undefined;
writeSignedFixed(4, &buf, -1);
var reader: std.Io.Reader = .fixed(&buf);
try testing.expectEqual(-1, try reader.takeLeb128(i64));
}
{
var buf: [4]u8 = undefined;
writeSignedFixed(4, &buf, 1000);
var reader: std.Io.Reader = .fixed(&buf);
try testing.expectEqual(1000, try reader.takeLeb128(i64));
}
{
var buf: [4]u8 = undefined;
writeSignedFixed(4, &buf, -1000);
var reader: std.Io.Reader = .fixed(&buf);
try testing.expectEqual(-1000, try reader.takeLeb128(i64));
}
{
var buf: [4]u8 = undefined;
writeSignedFixed(4, &buf, -10000000);
var reader: std.Io.Reader = .fixed(&buf);
try testing.expectEqual(-10000000, try reader.takeLeb128(i64));
}
{
var buf: [4]u8 = undefined;
writeSignedFixed(4, &buf, 10000000);
var reader: std.Io.Reader = .fixed(&buf);
try testing.expectEqual(10000000, try reader.takeLeb128(i64));
}
}