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

第 1 行

Zig 对象中间表示。 用于 ZON(Zig 对象表示法)格式的简化 AST。 ZonGen 将 Ast 转换为 Zoir。

字段

nodes: std.MultiArrayList(Node.Repr).Slice
extra: []u32
limbs: []std.math.big.Limb
string_bytes: []u8
compile_errors: []Zoir.CompileError
error_notes: []Zoir.CompileError.Note

std.zig.Zoir.Allocator

别名

第 9 行

别名目标 std.mem.Allocator

std.zig.Zoir.assert

别名

第 8 行

别名目标 std.debug.assert

std.zig.Zoir.Ast

别名

第 10 行

别名目标 std.zig.Ast

std.zig.Zoir.CompileError

容器

第 236 行

字段

msg: NullTerminatedString
token: Ast.OptionalTokenIndex
node_or_offset: u32

如果 token == .none,则此值为 Ast.Node.Index。 否则,此值为 token 中的字节偏移量。

first_note: u32

note_count == 0 时忽略。

note_count: u32

std.zig.Zoir.CompileError.getNotes

函数

第 247 行

pub fn getNotes(err: CompileError, zoir: *const Zoir) []const Note

参数

err: CompileError
zoir: *const Zoir

std.zig.Zoir.CompileError.Note

容器

第 251 行

字段

msg: NullTerminatedString
token: Ast.OptionalTokenIndex
node_or_offset: u32

如果 token == .none,则此值为 Ast.Node.Index。 否则,此值为 token 中的字节偏移量。

std.zig.Zoir.deinit

函数

第 57 行

pub fn deinit(zoir: *const Zoir, gpa: Allocator) void

参数

zoir: *const Zoir
gpa: Allocator

std.zig.Zoir.hasCompileErrors

函数

第 45 行

pub fn hasCompileErrors(zoir: *const Zoir) bool

参数

zoir: *const Zoir

std.zig.Zoir.Header

容器

第 21 行

将 ZOIR 存入文件时,位于字节偏移 0 的数据。

字段

nodes_len: u32
extra_len: u32
limbs_len: u32
string_bytes_len: u32
compile_errors_len: u32
error_notes_len: u32
unused: u64 = 0

这里可以保留为填充区,但这会触发 Valgrind 警告,因为 我们会向文件系统读写未定义的字节。这虽无害,但 在此使用零值字段几乎没有代价,还可消除警告, 从而使后续 Valgrind 警告更有可能得到认真处理。

stat_inode: Io.File.INode
stat_size: u64
stat_mtime: i128

std.zig.Zoir.Io

别名

第 7 行

别名目标 std.Io

std.zig.Zoir.Node

容器

第 68 行

字段

true

字面量 true 值。

false

字面量 false 值。

null

字面量 null 值。

pos_inf

字面量 inf 值。

neg_inf

字面量 -inf 值。

nan

字面量 nan 值。

int_literal: union(enum) {
    small: i32,
    big: std.math.big.int.Const,
}

整数字面量。

float_literal: f128

浮点数字面量。

char_literal: u21

Unicode 码点字面量。

enum_literal: NullTerminatedString

枚举字面量。字符串为字面量本身,例如 .foo 对应 foo。

string_literal: []const u8

字符串字面量。

empty_literal

空结构体或数组字面量,即 .{}。

array_literal: Node.Index.Range

数组字面量。Range 给出该数组字面量的元素。

struct_literal: struct {
    names: []const NullTerminatedString,
    vals: Node.Index.Range,
}

结构体字面量。names.len 始终等于 vals.len。

std.zig.Zoir.Node.Index

容器

第 104 行

字段

root = 0
_

std.zig.Zoir.Node.Index.get

函数

第 108 行

pub fn get(idx: Index, zoir: *const Zoir) Node

参数

idx: Index
zoir: *const Zoir

std.zig.Zoir.Node.Index.getAstNode

函数

第 154 行

pub fn getAstNode(idx: Index, zoir: *const Zoir) std.zig.Ast.Node.Index

参数

idx: Index
zoir: *const Zoir

std.zig.Zoir.Node.Index.Range

容器

第 158 行

字段

start: Index
len: u32

std.zig.Zoir.Node.Index.Range.at

函数

第 162 行

pub fn at(r: Range, i: u32) Index

参数

r: Range
i: u32

std.zig.Zoir.Node.Repr

容器

第 169 行

字段

tag: Tag
data: u32
ast_node: std.zig.Ast.Node.Index

std.zig.Zoir.Node.Repr.Tag

容器

第 174 行

字段

true

忽略 data。

false

忽略 data。

null

忽略 data。

pos_inf

忽略 data。

neg_inf

忽略 data。

nan

忽略 data。

int_literal_small

data 是 i32 值。

int_literal_pos

data 是 extra 中以下内容的索引:

  • limb_count: u32
  • limbs_idx: u32
int_literal_neg

与 int_literal_pos 相同,但值为负数。

float_literal_small

data 是 f32 值。

float_literal

data 是 extra 中 4 个元素的索引,这些元素为按位转换的 f128。

char_literal

data 是 u32 值。

enum_literal
string_literal

data 是 extra 中以下数据的索引:

  • start: u32
  • len: u32
string_literal_null

以空字符结尾的字符串字面量, data 为 NullTerminatedString。

empty_literal

空结构体/数组字面量 .{}。 忽略 data。

array_literal

data 是 extra 中以下内容的索引:

  • elem_count: u32
  • first_elem: Node.Index 节点 first_elem .. first_elem + elem_count 是子节点。
struct_literal

data 是以下数据在 extra 中的索引:

  • elem_count: u32
  • first_elem: Node.Index
  • 每个 elem_count 对应一个 field_name: NullTerminatedString 节点 first_elem .. first_elem + elem_count 是子节点。

std.zig.Zoir.NullTerminatedString

容器

第 228 行

字段

_

std.zig.Zoir.NullTerminatedString.get

函数

第 230 行

pub fn get(nts: NullTerminatedString, zoir: *const Zoir) [:0]const u8

参数

nts: NullTerminatedString
zoir: *const Zoir

std.zig.Zoir.std

别名

第 6 行

别名目标 std

std.zig.Zoir.Zoir

别名

第 4 行

别名目标 std.zig.Zoir

源码

std/zig/Zoir.zig

//! Zig 对象中间表示。
//! 用于 ZON(Zig 对象表示法)格式的简化 AST。
//! `ZonGen` 将 `Ast` 转换为 `Zoir`。
const Zoir = @This();

const std = @import("std");
const Io = std.Io;
const assert = std.debug.assert;
const Allocator = std.mem.Allocator;
const Ast = std.zig.Ast;

nodes: std.MultiArrayList(Node.Repr).Slice,
extra: []u32,
limbs: []std.math.big.Limb,
string_bytes: []u8,

compile_errors: []Zoir.CompileError,
error_notes: []Zoir.CompileError.Note,

/// 将 ZOIR 存入文件时,位于字节偏移 0 的数据。
pub const Header = extern struct {
    nodes_len: u32,
    extra_len: u32,
    limbs_len: u32,
    string_bytes_len: u32,
    compile_errors_len: u32,
    error_notes_len: u32,

    /// 这里可以保留为填充区,但这会触发 Valgrind 警告,因为
    /// 我们会向文件系统读写未定义的字节。这虽无害,但
    /// 在此使用零值字段几乎没有代价,还可消除警告,
    /// 从而使后续 Valgrind 警告更有可能得到认真处理。
    unused: u64 = 0,

    stat_inode: Io.File.INode,
    stat_size: u64,
    stat_mtime: i128,

    comptime {
        // 检查 `unused` 是否按预期工作
        assert(std.meta.hasUniqueRepresentation(Header));
    }
};

pub fn hasCompileErrors(zoir: *const Zoir) bool {
    if (zoir.compile_errors.len > 0) {
        assert(zoir.nodes.len == 0);
        assert(zoir.extra.len == 0);
        assert(zoir.limbs.len == 0);
        return true;
    } else {
        assert(zoir.error_notes.len == 0);
        return false;
    }
}

pub fn deinit(zoir: *const Zoir, gpa: Allocator) void {
    var nodes = zoir.nodes;
    nodes.deinit(gpa);

    gpa.free(zoir.extra);
    gpa.free(zoir.limbs);
    gpa.free(zoir.string_bytes);
    gpa.free(zoir.compile_errors);
    gpa.free(zoir.error_notes);
}

pub const Node = union(enum) {
    /// 字面量 `true` 值。
    true,
    /// 字面量 `false` 值。
    false,
    /// 字面量 `null` 值。
    null,
    /// 字面量 `inf` 值。
    pos_inf,
    /// 字面量 `-inf` 值。
    neg_inf,
    /// 字面量 `nan` 值。
    nan,
    /// 整数字面量。
    int_literal: union(enum) {
        small: i32,
        big: std.math.big.int.Const,
    },
    /// 浮点数字面量。
    float_literal: f128,
    /// Unicode 码点字面量。
    char_literal: u21,
    /// 枚举字面量。字符串为字面量本身,例如 `.foo` 对应 `foo`。
    enum_literal: NullTerminatedString,
    /// 字符串字面量。
    string_literal: []const u8,
    /// 空结构体或数组字面量,即 `.{}`。
    empty_literal,
    /// 数组字面量。`Range` 给出该数组字面量的元素。
    array_literal: Node.Index.Range,
    /// 结构体字面量。`names.len` 始终等于 `vals.len`。
    struct_literal: struct {
        names: []const NullTerminatedString,
        vals: Node.Index.Range,
    },

    pub const Index = enum(u32) {
        root = 0,
        _,

        pub fn get(idx: Index, zoir: *const Zoir) Node {
            const repr = zoir.nodes.get(@backingInt(idx));
            return switch (repr.tag) {
                .true => .true,
                .false => .false,
                .null => .null,
                .pos_inf => .pos_inf,
                .neg_inf => .neg_inf,
                .nan => .nan,
                .int_literal_small => .{ .int_literal = .{ .small = @bitCast(repr.data) } },
                .int_literal_pos, .int_literal_neg => .{ .int_literal = .{ .big = .{
                    .limbs = l: {
                        const limb_count, const limbs_idx = zoir.extra[repr.data..][0..2].*;
                        break :l zoir.limbs[limbs_idx..][0..limb_count];
                    },
                    .positive = switch (repr.tag) {
                        .int_literal_pos => true,
                        .int_literal_neg => false,
                        else => unreachable,
                    },
                } } },
                .float_literal_small => .{ .float_literal = @as(f32, @bitCast(repr.data)) },
                .float_literal => .{ .float_literal = @bitCast(zoir.extra[repr.data..][0..4].*) },
                .char_literal => .{ .char_literal = @intCast(repr.data) },
                .enum_literal => .{ .enum_literal = @fromBackingInt(@intCast(repr.data)) },
                .string_literal => .{ .string_literal = s: {
                    const start, const len = zoir.extra[repr.data..][0..2].*;
                    break :s zoir.string_bytes[start..][0..len];
                } },
                .string_literal_null => .{ .string_literal = NullTerminatedString.get(@fromBackingInt(@intCast(repr.data)), zoir) },
                .empty_literal => .empty_literal,
                .array_literal => .{ .array_literal = a: {
                    const elem_count, const first_elem = zoir.extra[repr.data..][0..2].*;
                    break :a .{ .start = @fromBackingInt(@intCast(first_elem)), .len = elem_count };
                } },
                .struct_literal => .{ .struct_literal = s: {
                    const elem_count, const first_elem = zoir.extra[repr.data..][0..2].*;
                    const field_names = zoir.extra[repr.data + 2 ..][0..elem_count];
                    break :s .{
                        .names = @ptrCast(field_names),
                        .vals = .{ .start = @fromBackingInt(@intCast(first_elem)), .len = elem_count },
                    };
                } },
            };
        }

        pub fn getAstNode(idx: Index, zoir: *const Zoir) std.zig.Ast.Node.Index {
            return zoir.nodes.items(.ast_node)[@backingInt(idx)];
        }

        pub const Range = struct {
            start: Index,
            len: u32,

            pub fn at(r: Range, i: u32) Index {
                assert(i < r.len);
                return @fromBackingInt(@intCast(@backingInt(r.start) + i));
            }
        };
    };

    pub const Repr = struct {
        tag: Tag,
        data: u32,
        ast_node: std.zig.Ast.Node.Index,

        pub const Tag = enum(u8) {
            /// 忽略 `data`。
            true,
            /// 忽略 `data`。
            false,
            /// 忽略 `data`。
            null,
            /// 忽略 `data`。
            pos_inf,
            /// 忽略 `data`。
            neg_inf,
            /// 忽略 `data`。
            nan,
            /// `data` 是 `i32` 值。
            int_literal_small,
            /// `data` 是 `extra` 中以下内容的索引:
            /// * `limb_count: u32`
            /// * `limbs_idx: u32`
            int_literal_pos,
            /// 与 `int_literal_pos` 相同,但值为负数。
            int_literal_neg,
            /// `data` 是 `f32` 值。
            float_literal_small,
            /// `data` 是 `extra` 中 4 个元素的索引,这些元素为按位转换的 `f128`。
            float_literal,
            /// `data` 是 `u32` 值。
            char_literal,
            /// `data` 是 `NullTerminatedString`。
            enum_literal,
            /// `data` 是 `extra` 中以下数据的索引:
            /// * `start: u32`
            /// * `len: u32`
            string_literal,
            /// 以空字符结尾的字符串字面量,
            /// `data` 为 `NullTerminatedString`。
            string_literal_null,
            /// 空结构体/数组字面量 `.{}`。
            /// 忽略 `data`。
            empty_literal,
            /// `data` 是 `extra` 中以下内容的索引:
            /// * `elem_count: u32`
            /// * `first_elem: Node.Index`
            /// 节点 `first_elem .. first_elem + elem_count` 是子节点。
            array_literal,
            /// `data` 是以下数据在 `extra` 中的索引:
            /// * `elem_count: u32`
            /// * `first_elem: Node.Index`
            /// * 每个 `elem_count` 对应一个 `field_name: NullTerminatedString`
            /// 节点 `first_elem .. first_elem + elem_count` 是子节点。
            struct_literal,
        };
    };
};

pub const NullTerminatedString = enum(u32) {
    _,
    pub fn get(nts: NullTerminatedString, zoir: *const Zoir) [:0]const u8 {
        const idx = std.mem.findScalar(u8, zoir.string_bytes[@backingInt(nts)..], 0).?;
        return zoir.string_bytes[@backingInt(nts)..][0..idx :0];
    }
};

pub const CompileError = extern struct {
    msg: NullTerminatedString,
    token: Ast.OptionalTokenIndex,
    /// 如果 `token == .none`,则此值为 `Ast.Node.Index`。
    /// 否则,此值为 `token` 中的字节偏移量。
    node_or_offset: u32,

    /// `note_count == 0` 时忽略。
    first_note: u32,
    note_count: u32,

    pub fn getNotes(err: CompileError, zoir: *const Zoir) []const Note {
        return zoir.error_notes[err.first_note..][0..err.note_count];
    }

    pub const Note = extern struct {
        msg: NullTerminatedString,
        token: Ast.OptionalTokenIndex,
        /// 如果 `token == .none`,则此值为 `Ast.Node.Index`。
        /// 否则,此值为 `token` 中的字节偏移量。
        node_or_offset: u32,
    };

    comptime {
        assert(std.meta.hasUniqueRepresentation(CompileError));
        assert(std.meta.hasUniqueRepresentation(Note));
    }
};