跳转到内容
标准库Zig 0.17.1官方原文
源码std/leb128.zig

第 1 行

std.leb128.builtin

常量

第 1 行

std.leb128.std

别名

第 2 行

别名目标 std

std.leb128.testing

别名

第 3 行

别名目标 std.testing

std.leb128.writeSignedFixed

函数

第 68 行

这是一个“高级”函数,允许使用固定内存大小存储 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

函数

第 18 行

与 writeUnsignedFixed 相同,但长度在运行时确定。 断言 slice.len > 0。

pub fn writeUnsignedExtended(slice: []u8, arg: anytype) void

参数

slice: []u8

std.leb128.writeUnsignedFixed

函数

第 12 行

这是“高级”函数,允许使用固定大小的内存保存 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));
    }
}