1//! An abstract tree representation of a Markdown document.
2
3const std = @import("std");
4const builtin = @import("builtin");
5const assert = std.debug.assert;
6const Allocator = std.mem.Allocator;
7const Renderer = @import("renderer.zig").Renderer;
8
9nodes: Node.List.Slice,
10extra: []u32,
11string_bytes: []u8,
12
13const Document = @This();
14
15pub const Node = struct {
16 tag: Tag,
17 data: Data,
18
19 pub const Index = enum(u32) {
20 root = 0,
21 _,
22 };
23 pub const List = std.MultiArrayList(Node);
24
25 pub const Tag = enum {
26 /// Data is `container`.
27 root,
28
29 // Blocks
30 /// Data is `list`.
31 list,
32 /// Data is `list_item`.
33 list_item,
34 /// Data is `container`.
35 table,
36 /// Data is `container`.
37 table_row,
38 /// Data is `table_cell`.
39 table_cell,
40 /// Data is `heading`.
41 heading,
42 /// Data is `code_block`.
43 code_block,
44 /// Data is `container`.
45 blockquote,
46 /// Data is `container`.
47 paragraph,
48 /// Data is `none`.
49 thematic_break,
50
51 // Inlines
52 /// Data is `link`.
53 link,
54 /// Data is `text`.
55 autolink,
56 /// Data is `link`.
57 image,
58 /// Data is `container`.
59 strong,
60 /// Data is `container`.
61 emphasis,
62 /// Data is `text`.
63 code_span,
64 /// Data is `text`.
65 text,
66 /// Data is `none`.
67 line_break,
68 };
69
70 pub const Data = union {
71 none: void,
72 container: struct {
73 children: ExtraIndex,
74 },
75 text: struct {
76 content: StringIndex,
77 },
78 list: struct {
79 start: ListStart,
80 children: ExtraIndex,
81 },
82 list_item: struct {
83 tight: bool,
84 children: ExtraIndex,
85 },
86 table_cell: struct {
87 info: packed struct {
88 alignment: TableCellAlignment,
89 header: bool,
90 },
91 children: ExtraIndex,
92 },
93 heading: struct {
94 /// Between 1 and 6, inclusive.
95 level: u3,
96 children: ExtraIndex,
97 },
98 code_block: struct {
99 tag: StringIndex,
100 content: StringIndex,
101 },
102 link: struct {
103 target: StringIndex,
104 children: ExtraIndex,
105 },
106
107 comptime {
108 // In Debug and ReleaseSafe builds, there may be hidden extra fields
109 // included for safety checks. Without such safety checks enabled,
110 // we always want this union to be 8 bytes.
111 if (builtin.mode != .debug and builtin.mode != .safe) {
112 assert(@sizeOf(Data) == 8);
113 }
114 }
115 };
116
117 /// The starting number of a list. This is either a number between 0 and
118 /// 999,999,999, inclusive, or `unordered` to indicate an unordered list.
119 pub const ListStart = enum(u30) {
120 // When https://github.com/ziglang/zig/issues/104 is implemented, this
121 // type can be more naturally expressed as ?u30. As it is, we want
122 // values to fit within 4 bytes, so ?u30 does not yet suffice for
123 // storage.
124 unordered = std.math.maxInt(u30),
125 _,
126
127 pub fn asNumber(start: ListStart) ?u30 {
128 if (start == .unordered) return null;
129 assert(@backingInt(start) <= 999_999_999);
130 return @backingInt(start);
131 }
132 };
133
134 pub const TableCellAlignment = enum(u2) {
135 unset,
136 left,
137 center,
138 right,
139 };
140
141 /// Trailing: `len` times `Node.Index`
142 pub const Children = struct {
143 len: u32,
144 };
145};
146
147pub const ExtraIndex = enum(u32) { _ };
148
149/// The index of a null-terminated string in `string_bytes`.
150pub const StringIndex = enum(u32) {
151 empty = 0,
152 _,
153};
154
155pub fn deinit(doc: *Document, allocator: Allocator) void {
156 doc.nodes.deinit(allocator);
157 allocator.free(doc.extra);
158 allocator.free(doc.string_bytes);
159 doc.* = undefined;
160}
161
162/// Renders a document directly to a writer using the default renderer.
163pub fn render(doc: Document, writer: anytype) @TypeOf(writer).Error!void {
164 const renderer: Renderer(@TypeOf(writer), void) = .{ .context = {} };
165 try renderer.render(doc, writer);
166}
167
168pub fn ExtraData(comptime T: type) type {
169 return struct { data: T, end: usize };
170}
171
172pub fn extraData(doc: Document, comptime T: type, index: ExtraIndex) ExtraData(T) {
173 const info = @typeInfo(T).@"struct";
174 var i: usize = @backingInt(index);
175 var result: T = undefined;
176 inline for (info.field_names, info.field_types) |field_name, field_type| {
177 @field(result, field_name) = switch (field_type) {
178 u32 => doc.extra[i],
179 else => @compileError("bad field type"),
180 };
181 i += 1;
182 }
183 return .{ .data = result, .end = i };
184}
185
186pub fn extraChildren(doc: Document, index: ExtraIndex) []const Node.Index {
187 const children = doc.extraData(Node.Children, index);
188 return @ptrCast(doc.extra[children.end..][0..children.data.len]);
189}
190
191pub fn string(doc: Document, index: StringIndex) [:0]const u8 {
192 const start = @backingInt(index);
193 return std.mem.span(@as([*:0]u8, @ptrCast(doc.string_bytes[start..].ptr)));
194}