字段
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
别名
别名目标 std.mem.Allocator
std.zig.Zoir.assert
别名
别名目标 std.debug.assert
std.zig.Zoir.Ast
别名
别名目标 std.zig.Ast
std.zig.Zoir.CompileError
容器
字段
msg: NullTerminatedString
token: Ast.OptionalTokenIndex
node_or_offset: u32如果 token == .none,则此值为 Ast.Node.Index。
否则,此值为 token 中的字节偏移量。
first_note: u32note_count == 0 时忽略。
note_count: u32
std.zig.Zoir.CompileError.getNotes
函数
pub fn getNotes(err: CompileError, zoir: *const Zoir) []const Note
参数
err: CompileError
zoir: *const Zoir
std.zig.Zoir.CompileError.Note
容器
字段
msg: NullTerminatedString
token: Ast.OptionalTokenIndex
node_or_offset: u32如果 token == .none,则此值为 Ast.Node.Index。
否则,此值为 token 中的字节偏移量。
std.zig.Zoir.deinit
函数
pub fn deinit(zoir: *const Zoir, gpa: Allocator) void
参数
std.zig.Zoir.hasCompileErrors
函数
pub fn hasCompileErrors(zoir: *const Zoir) bool
参数
zoir: *const Zoir
std.zig.Zoir.Header
容器
将 ZOIR 存入文件时,位于字节偏移 0 的数据。
字段
std.zig.Zoir.Io
别名
别名目标 std.Io
std.zig.Zoir.Node
容器
字段
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: u21Unicode 码点字面量。
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
容器
字段
root = 0
_
std.zig.Zoir.Node.Index.get
函数
pub fn get(idx: Index, zoir: *const Zoir) Node
参数
std.zig.Zoir.Node.Index.getAstNode
函数
pub fn getAstNode(idx: Index, zoir: *const Zoir) std.zig.Ast.Node.Index
参数
std.zig.Zoir.Node.Index.Range
容器
字段
start: Index
len: u32
std.zig.Zoir.Node.Index.Range.at
函数
pub fn at(r: Range, i: u32) Index
参数
r: Range
i: u32
std.zig.Zoir.Node.Repr
容器
字段
std.zig.Zoir.Node.Repr.Tag
容器
字段
true忽略 data。
false忽略 data。
null忽略 data。
pos_inf忽略 data。
neg_inf忽略 data。
nan忽略 data。
int_literal_smalldata 是 i32 值。
int_literal_posdata 是 extra 中以下内容的索引:
limb_count: u32limbs_idx: u32
int_literal_neg与 int_literal_pos 相同,但值为负数。
float_literal_smalldata 是 f32 值。
float_literaldata 是 extra 中 4 个元素的索引,这些元素为按位转换的 f128。
char_literaldata 是 u32 值。
enum_literaldata 是 NullTerminatedString。
string_literaldata 是 extra 中以下数据的索引:
start: u32len: u32
string_literal_null以空字符结尾的字符串字面量,
data 为 NullTerminatedString。
empty_literal空结构体/数组字面量 .{}。
忽略 data。
array_literaldata 是 extra 中以下内容的索引:
elem_count: u32first_elem: Node.Index节点first_elem .. first_elem + elem_count是子节点。
struct_literaldata 是以下数据在 extra 中的索引:
elem_count: u32first_elem: Node.Index- 每个
elem_count对应一个field_name: NullTerminatedString节点first_elem .. first_elem + elem_count是子节点。
std.zig.Zoir.NullTerminatedString
容器
字段
_
std.zig.Zoir.NullTerminatedString.get
函数
pub fn get(nts: NullTerminatedString, zoir: *const Zoir) [:0]const u8
参数
nts: NullTerminatedString
zoir: *const Zoir
std.zig.Zoir.std
别名
别名目标 std
std.zig.Zoir.Zoir
别名
别名目标 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));
}
};