reorganize and add parsing diagnostics
This commit is contained in:
parent
1ecfb41d55
commit
cdf2ec5a23
SSH Key Fingerprint:
SHA256:nCrXefBNo6EbjNSQhv0nXmEg/VuNq3sMF5b8zETw3Tk
@ -9,7 +9,7 @@ pub fn build(b: *std.Build) void {
|
||||
const optimize = b.standardOptimizeOption(.{});
|
||||
|
||||
const yaml_zig = b.addModule("libyaml", .{
|
||||
.source_file = .{ .path = "src/libyaml.zig" },
|
||||
.source_file = .{ .path = "src/yaml.zig" },
|
||||
});
|
||||
// yaml_zig.addIncludePath(.{ .path = b.getInstallPath(.header, "") });
|
||||
// _ = yaml_zig;
|
||||
|
||||
923
src/libyaml.zig
923
src/libyaml.zig
@ -1,567 +1,388 @@
|
||||
const std = @import("std");
|
||||
pub const Encoding = enum(c_int) {
|
||||
any,
|
||||
utf8,
|
||||
utf16le,
|
||||
utf16be,
|
||||
};
|
||||
|
||||
pub const Scalar = []const u8;
|
||||
pub const List = []Value;
|
||||
pub const Map = std.StringArrayHashMapUnmanaged(Value);
|
||||
pub const VersionDirective = extern struct {
|
||||
major: c_int,
|
||||
minor: c_int,
|
||||
};
|
||||
|
||||
pub fn Owned(comptime T: type) type {
|
||||
return struct {
|
||||
root: T,
|
||||
allocator: *std.heap.ArenaAllocator,
|
||||
pub const TagDirective = extern struct {
|
||||
handle: ?[*:0]u8,
|
||||
prefix: ?[*:0]u8,
|
||||
};
|
||||
|
||||
pub fn deinit(self: @This()) void {
|
||||
const child = self.allocator.child_allocator;
|
||||
self.allocator.deinit();
|
||||
child.destroy(self.allocator);
|
||||
}
|
||||
};
|
||||
}
|
||||
pub const LineBreak = enum(c_int) {
|
||||
any,
|
||||
cr,
|
||||
lf,
|
||||
crlf,
|
||||
};
|
||||
|
||||
pub const Value = union(enum) {
|
||||
scalar: Scalar,
|
||||
list: List,
|
||||
map: Map,
|
||||
pub const ErrorType = enum(c_int) {
|
||||
okay,
|
||||
alloc_error,
|
||||
read_error,
|
||||
scanner_error,
|
||||
parser_error,
|
||||
composer_error,
|
||||
writer_error,
|
||||
emitter_error,
|
||||
};
|
||||
|
||||
pub fn fromString(allocator: std.mem.Allocator, data: []const u8) !Owned(Value) {
|
||||
var parser = try libyaml.Parser.init();
|
||||
defer parser.deinit();
|
||||
pub const Mark = extern struct {
|
||||
index: usize,
|
||||
line: usize,
|
||||
column: usize,
|
||||
};
|
||||
|
||||
parser.setInputString(data);
|
||||
pub const ScalarStyle = enum(c_int) {
|
||||
any,
|
||||
plain,
|
||||
single_quoted,
|
||||
double_quoted,
|
||||
literal,
|
||||
folded,
|
||||
};
|
||||
|
||||
var builder = try Builder.init(allocator);
|
||||
errdefer builder.deinit();
|
||||
pub const SequenceStyle = enum(c_int) {
|
||||
any,
|
||||
block,
|
||||
flow,
|
||||
};
|
||||
|
||||
var docseen = false;
|
||||
while (true) {
|
||||
var event: libyaml.Event = undefined;
|
||||
parser.parse(&event) catch {
|
||||
std.debug.print(
|
||||
"parser failed: {s}, {s}, line {d}, col: {d}\n",
|
||||
.{ @tagName(parser.@"error"), parser.problem.?, parser.problem_mark.line, parser.problem_mark.column },
|
||||
);
|
||||
return error.Failed;
|
||||
};
|
||||
defer event.deinit();
|
||||
pub const MappingStyle = enum(c_int) {
|
||||
any,
|
||||
block,
|
||||
flow,
|
||||
};
|
||||
|
||||
std.debug.print("event: {s}\n", .{@tagName(event.type)});
|
||||
pub const TokenType = enum(c_int) {
|
||||
none,
|
||||
stream_start,
|
||||
stream_end,
|
||||
version_directive,
|
||||
tag_directive,
|
||||
document_start,
|
||||
document_end,
|
||||
block_sequence_start,
|
||||
block_mapping_start,
|
||||
block_end,
|
||||
flow_sequence_start,
|
||||
flow_sequence_end,
|
||||
flow_mapping_start,
|
||||
flow_mapping_end,
|
||||
block_entry,
|
||||
flow_entry,
|
||||
key,
|
||||
value,
|
||||
alias,
|
||||
anchor,
|
||||
tag,
|
||||
scalar,
|
||||
};
|
||||
|
||||
switch (event.type) {
|
||||
.empty => return error.Failed,
|
||||
.stream_start => {},
|
||||
.stream_end => break,
|
||||
.document_start => {},
|
||||
.document_end => docseen = if (docseen) return error.Failed else true,
|
||||
.alias => return error.Failed,
|
||||
.scalar => try builder.pushScalar(event.data.scalar.value[0..event.data.scalar.length]),
|
||||
.sequence_start => try builder.startList(),
|
||||
.sequence_end => try builder.endList(),
|
||||
.mapping_start => try builder.startMap(),
|
||||
.mapping_end => try builder.endMap(),
|
||||
}
|
||||
}
|
||||
pub const Token = extern struct {
|
||||
type: TokenType,
|
||||
data: extern union {
|
||||
stream_start: extern struct {
|
||||
encoding: Encoding,
|
||||
},
|
||||
alias: extern struct {
|
||||
value: ?[*:0]u8,
|
||||
},
|
||||
anchor: extern struct {
|
||||
value: ?[*:0]u8,
|
||||
},
|
||||
tag: extern struct {
|
||||
handle: ?[*:0]u8,
|
||||
suffix: ?[*:0]u8,
|
||||
},
|
||||
scalar: extern struct {
|
||||
value: [*]u8,
|
||||
length: usize,
|
||||
style: ScalarStyle,
|
||||
},
|
||||
version_directive: VersionDirective,
|
||||
tag_directive: TagDirective,
|
||||
},
|
||||
start_mark: Mark,
|
||||
end_mark: Mark,
|
||||
};
|
||||
|
||||
return builder.disown();
|
||||
pub const EventType = enum(c_int) {
|
||||
empty,
|
||||
stream_start,
|
||||
stream_end,
|
||||
document_start,
|
||||
document_end,
|
||||
alias,
|
||||
scalar,
|
||||
sequence_start,
|
||||
sequence_end,
|
||||
mapping_start,
|
||||
mapping_end,
|
||||
};
|
||||
|
||||
pub const Event = extern struct {
|
||||
type: EventType,
|
||||
data: extern union {
|
||||
stream_start: extern struct {
|
||||
encoding: Encoding,
|
||||
},
|
||||
document_start: extern struct {
|
||||
version_directive: ?*VersionDirective,
|
||||
tag_directives: extern struct {
|
||||
start: ?*TagDirective,
|
||||
end: ?*TagDirective,
|
||||
},
|
||||
implicit: c_int,
|
||||
},
|
||||
document_end: extern struct { implicit: c_int },
|
||||
alias: extern struct { anchor: [*:0]u8 },
|
||||
scalar: extern struct {
|
||||
anchor: ?[*:0]u8,
|
||||
tag: ?[*:0]u8,
|
||||
value: [*]u8,
|
||||
length: usize,
|
||||
plain_implicit: c_int,
|
||||
quoted_implicit: c_int,
|
||||
style: ScalarStyle,
|
||||
},
|
||||
sequence_start: extern struct {
|
||||
anchor: ?[*:0]u8,
|
||||
tag: ?[*:0]u8,
|
||||
implicit: c_int,
|
||||
style: SequenceStyle,
|
||||
},
|
||||
mapping_start: extern struct {
|
||||
anchor: ?[*:0]u8,
|
||||
tag: ?[*:0]u8,
|
||||
implicit: c_int,
|
||||
style: MappingStyle,
|
||||
},
|
||||
},
|
||||
start_mark: Mark,
|
||||
end_mark: Mark,
|
||||
|
||||
pub fn deinit(self: *Event) void {
|
||||
yaml_event_delete(self);
|
||||
}
|
||||
|
||||
pub const Builder = struct {
|
||||
pub const Stack = union(enum) {
|
||||
root,
|
||||
list: std.ArrayListUnmanaged(Value),
|
||||
map: struct {
|
||||
lastkey: ?Scalar = null,
|
||||
map: Map,
|
||||
},
|
||||
};
|
||||
|
||||
allocator: std.mem.Allocator,
|
||||
container_stack: std.ArrayListUnmanaged(Stack),
|
||||
root: Value,
|
||||
|
||||
pub fn init(child_allocator: std.mem.Allocator) std.mem.Allocator.Error!Builder {
|
||||
const arena = try child_allocator.create(std.heap.ArenaAllocator);
|
||||
arena.* = std.heap.ArenaAllocator.init(child_allocator);
|
||||
const allocator = arena.allocator();
|
||||
|
||||
var stack = try std.ArrayListUnmanaged(Stack).initCapacity(allocator, 1);
|
||||
stack.appendAssumeCapacity(.root);
|
||||
|
||||
return .{
|
||||
.allocator = allocator,
|
||||
.container_stack = stack,
|
||||
.root = .{ .scalar = "" },
|
||||
};
|
||||
}
|
||||
|
||||
// this should only be run on failure.
|
||||
pub fn deinit(self: Builder) void {
|
||||
const arena: *std.heap.ArenaAllocator = @ptrCast(@alignCast(self.allocator.ptr));
|
||||
const alloc = arena.child_allocator;
|
||||
arena.deinit();
|
||||
alloc.destroy(arena);
|
||||
}
|
||||
|
||||
pub fn disown(self: *Builder) Owned(Value) {
|
||||
return .{
|
||||
.root = self.root,
|
||||
.allocator = @ptrCast(@alignCast(self.allocator.ptr)),
|
||||
};
|
||||
}
|
||||
|
||||
fn pushScalar(self: *Builder, value: Scalar) !void {
|
||||
switch (self.container_stack.items[self.container_stack.items.len - 1]) {
|
||||
.root => {
|
||||
self.root = .{ .scalar = try self.allocator.dupe(u8, value) };
|
||||
},
|
||||
.list => |*builder| try builder.append(
|
||||
self.allocator,
|
||||
.{ .scalar = try self.allocator.dupe(u8, value) },
|
||||
),
|
||||
.map => |*builder| {
|
||||
if (builder.lastkey) |key| {
|
||||
try builder.map.put(self.allocator, key, .{ .scalar = try self.allocator.dupe(u8, value) });
|
||||
builder.lastkey = null;
|
||||
} else {
|
||||
const duped = try self.allocator.dupe(u8, value);
|
||||
try builder.map.put(self.allocator, duped, undefined);
|
||||
builder.lastkey = duped;
|
||||
}
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
fn startList(self: *Builder) !void {
|
||||
try self.container_stack.append(self.allocator, .{ .list = .{} });
|
||||
}
|
||||
|
||||
fn endList(self: *Builder) !void {
|
||||
var top = self.container_stack.pop();
|
||||
|
||||
switch (self.container_stack.items[self.container_stack.items.len - 1]) {
|
||||
.root => self.root = .{ .list = try top.list.toOwnedSlice(self.allocator) },
|
||||
.list => |*builder| try builder.append(
|
||||
self.allocator,
|
||||
.{ .list = try top.list.toOwnedSlice(self.allocator) },
|
||||
),
|
||||
.map => |*builder| {
|
||||
if (builder.lastkey) |key| {
|
||||
try builder.map.put(self.allocator, key, .{ .list = try top.list.toOwnedSlice(self.allocator) });
|
||||
builder.lastkey = null;
|
||||
} else return error.Failed;
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
fn startMap(self: *Builder) !void {
|
||||
try self.container_stack.append(self.allocator, .{ .map = .{ .map = .{} } });
|
||||
}
|
||||
|
||||
fn endMap(self: *Builder) !void {
|
||||
var top = self.container_stack.pop();
|
||||
|
||||
switch (self.container_stack.items[self.container_stack.items.len - 1]) {
|
||||
.root => self.root = .{ .map = top.map.map },
|
||||
.list => |*builder| try builder.append(
|
||||
self.allocator,
|
||||
.{ .map = top.map.map },
|
||||
),
|
||||
.map => |*builder| {
|
||||
if (builder.lastkey) |key| {
|
||||
try builder.map.put(self.allocator, key, .{ .map = top.map.map });
|
||||
builder.lastkey = null;
|
||||
} else return error.Failed;
|
||||
},
|
||||
}
|
||||
}
|
||||
};
|
||||
pub extern fn yaml_event_delete(event: *Event) void;
|
||||
};
|
||||
|
||||
pub const libyaml = struct {
|
||||
pub const Encoding = enum(c_int) {
|
||||
any,
|
||||
utf8,
|
||||
utf16le,
|
||||
utf16be,
|
||||
};
|
||||
|
||||
pub const VersionDirective = extern struct {
|
||||
major: c_int,
|
||||
minor: c_int,
|
||||
};
|
||||
|
||||
pub const TagDirective = extern struct {
|
||||
handle: ?[*:0]u8,
|
||||
prefix: ?[*:0]u8,
|
||||
};
|
||||
|
||||
pub const LineBreak = enum(c_int) {
|
||||
any,
|
||||
cr,
|
||||
lf,
|
||||
crlf,
|
||||
};
|
||||
|
||||
pub const ErrorType = enum(c_int) {
|
||||
okay,
|
||||
alloc_error,
|
||||
read_error,
|
||||
scanner_error,
|
||||
parser_error,
|
||||
composer_error,
|
||||
writer_error,
|
||||
emitter_error,
|
||||
};
|
||||
|
||||
pub const Mark = extern struct {
|
||||
index: usize,
|
||||
line: usize,
|
||||
column: usize,
|
||||
};
|
||||
|
||||
pub const ScalarStyle = enum(c_int) {
|
||||
any,
|
||||
plain,
|
||||
single_quoted,
|
||||
double_quoted,
|
||||
literal,
|
||||
folded,
|
||||
};
|
||||
|
||||
pub const SequenceStyle = enum(c_int) {
|
||||
any,
|
||||
block,
|
||||
flow,
|
||||
};
|
||||
|
||||
pub const MappingStyle = enum(c_int) {
|
||||
any,
|
||||
block,
|
||||
flow,
|
||||
};
|
||||
|
||||
pub const TokenType = enum(c_int) {
|
||||
none,
|
||||
stream_start,
|
||||
stream_end,
|
||||
version_directive,
|
||||
tag_directive,
|
||||
document_start,
|
||||
document_end,
|
||||
block_sequence_start,
|
||||
block_mapping_start,
|
||||
block_end,
|
||||
flow_sequence_start,
|
||||
flow_sequence_end,
|
||||
flow_mapping_start,
|
||||
flow_mapping_end,
|
||||
block_entry,
|
||||
flow_entry,
|
||||
key,
|
||||
value,
|
||||
alias,
|
||||
anchor,
|
||||
tag,
|
||||
scalar,
|
||||
};
|
||||
|
||||
pub const Token = extern struct {
|
||||
type: TokenType,
|
||||
data: extern union {
|
||||
stream_start: extern struct {
|
||||
encoding: Encoding,
|
||||
},
|
||||
alias: extern struct {
|
||||
value: ?[*:0]u8,
|
||||
},
|
||||
anchor: extern struct {
|
||||
value: ?[*:0]u8,
|
||||
},
|
||||
tag: extern struct {
|
||||
handle: ?[*:0]u8,
|
||||
suffix: ?[*:0]u8,
|
||||
},
|
||||
scalar: extern struct {
|
||||
value: [*]u8,
|
||||
length: usize,
|
||||
style: ScalarStyle,
|
||||
},
|
||||
version_directive: VersionDirective,
|
||||
tag_directive: TagDirective,
|
||||
},
|
||||
start_mark: Mark,
|
||||
end_mark: Mark,
|
||||
};
|
||||
|
||||
pub const EventType = enum(c_int) {
|
||||
empty,
|
||||
stream_start,
|
||||
stream_end,
|
||||
document_start,
|
||||
document_end,
|
||||
alias,
|
||||
scalar,
|
||||
sequence_start,
|
||||
sequence_end,
|
||||
mapping_start,
|
||||
mapping_end,
|
||||
};
|
||||
|
||||
pub const Event = extern struct {
|
||||
type: EventType,
|
||||
data: extern union {
|
||||
stream_start: extern struct {
|
||||
encoding: Encoding,
|
||||
},
|
||||
document_start: extern struct {
|
||||
version_directive: ?*VersionDirective,
|
||||
tag_directives: extern struct {
|
||||
start: ?*TagDirective,
|
||||
end: ?*TagDirective,
|
||||
},
|
||||
implicit: c_int,
|
||||
},
|
||||
document_end: extern struct { implicit: c_int },
|
||||
alias: extern struct { anchor: [*:0]u8 },
|
||||
scalar: extern struct {
|
||||
anchor: ?[*:0]u8,
|
||||
tag: ?[*:0]u8,
|
||||
value: [*]u8,
|
||||
length: usize,
|
||||
plain_implicit: c_int,
|
||||
quoted_implicit: c_int,
|
||||
style: ScalarStyle,
|
||||
},
|
||||
sequence_start: extern struct {
|
||||
anchor: ?[*:0]u8,
|
||||
tag: ?[*:0]u8,
|
||||
implicit: c_int,
|
||||
style: SequenceStyle,
|
||||
},
|
||||
mapping_start: extern struct {
|
||||
anchor: ?[*:0]u8,
|
||||
tag: ?[*:0]u8,
|
||||
implicit: c_int,
|
||||
style: MappingStyle,
|
||||
},
|
||||
},
|
||||
start_mark: Mark,
|
||||
end_mark: Mark,
|
||||
|
||||
pub fn deinit(self: *Event) void {
|
||||
yaml_event_delete(self);
|
||||
}
|
||||
|
||||
pub extern fn yaml_event_delete(event: *Event) void;
|
||||
};
|
||||
|
||||
pub const SimpleKey = extern struct {
|
||||
possible: c_int,
|
||||
required: c_int,
|
||||
token_number: usize,
|
||||
mark: Mark,
|
||||
};
|
||||
|
||||
pub const NodeType = enum(c_int) {
|
||||
none,
|
||||
scalar,
|
||||
sequence,
|
||||
mapping,
|
||||
};
|
||||
|
||||
pub const NodeItem = c_int;
|
||||
|
||||
pub const NodePair = extern struct {
|
||||
key: c_int,
|
||||
value: c_int,
|
||||
};
|
||||
|
||||
pub const Node = extern struct {
|
||||
type: NodeType,
|
||||
tag: ?[*:0]u8,
|
||||
data: extern union {
|
||||
scalar: extern struct {
|
||||
value: ?[*:0]u8,
|
||||
length: usize,
|
||||
style: ScalarStyle,
|
||||
},
|
||||
sequence: extern struct {
|
||||
items: extern struct {
|
||||
start: ?*NodeItem,
|
||||
end: ?*NodeItem,
|
||||
top: ?*NodeItem,
|
||||
},
|
||||
style: SequenceStyle,
|
||||
},
|
||||
mapping: extern struct {
|
||||
pairs: extern struct {
|
||||
start: ?*NodePair,
|
||||
end: ?*NodePair,
|
||||
top: ?*NodePair,
|
||||
},
|
||||
style: MappingStyle,
|
||||
},
|
||||
},
|
||||
start_mark: Mark,
|
||||
end_mark: Mark,
|
||||
};
|
||||
|
||||
pub const Document = extern struct {
|
||||
nodes: extern struct {
|
||||
start: ?*Node,
|
||||
end: ?*Node,
|
||||
top: ?*Node,
|
||||
},
|
||||
version_directive: ?*VersionDirective,
|
||||
tag_directives: extern struct {
|
||||
start: ?*TagDirective,
|
||||
end: ?*TagDirective,
|
||||
},
|
||||
start_implicit: c_int,
|
||||
end_implicit: c_int,
|
||||
start_mark: Mark,
|
||||
end_mark: Mark,
|
||||
};
|
||||
|
||||
pub const AliasData = extern struct {
|
||||
anchor: ?[*]u8,
|
||||
index: c_int,
|
||||
mark: Mark,
|
||||
};
|
||||
|
||||
pub const ReadHandler = *const fn (ctx: ?*anyopaque, buffer: [*]u8, buffer_size: usize, bytes_read: *usize) callconv(.C) c_int;
|
||||
|
||||
pub const ParserState = enum(c_int) {
|
||||
stream_start,
|
||||
implicit_document_start,
|
||||
document_start,
|
||||
document_content,
|
||||
document_end,
|
||||
block_node,
|
||||
block_node_or_indentless_sequence,
|
||||
flow_node,
|
||||
block_sequence_first_entry,
|
||||
block_sequence_entry,
|
||||
indentless_sequence_entry,
|
||||
block_mapping_first_key,
|
||||
block_mapping_key,
|
||||
block_mapping_value,
|
||||
flow_sequence_first_entry,
|
||||
flow_sequence_entry,
|
||||
flow_sequence_entry_mapping_key,
|
||||
flow_sequence_entry_mapping_value,
|
||||
flow_sequence_entry_mapping_end,
|
||||
flow_mapping_first_key,
|
||||
flow_mapping_key,
|
||||
flow_mapping_value,
|
||||
flow_mapping_empty_value,
|
||||
end,
|
||||
};
|
||||
|
||||
pub const Parser = extern struct {
|
||||
@"error": ErrorType,
|
||||
problem: ?[*:0]const u8,
|
||||
problem_offset: usize,
|
||||
problem_value: c_int,
|
||||
problem_mark: Mark,
|
||||
context: ?[*:0]const u8,
|
||||
context_mark: Mark,
|
||||
read_handler: ?ReadHandler,
|
||||
read_handler_data: ?*anyopaque,
|
||||
input: extern union {
|
||||
string: extern struct {
|
||||
start: ?[*]const u8,
|
||||
end: ?[*]const u8,
|
||||
current: ?[*]const u8,
|
||||
},
|
||||
file: ?*anyopaque,
|
||||
},
|
||||
eof: c_int,
|
||||
buffer: extern struct {
|
||||
start: ?[*]u8,
|
||||
end: ?[*]u8,
|
||||
pointer: ?[*]u8,
|
||||
last: ?[*]u8,
|
||||
},
|
||||
unread: usize,
|
||||
raw_buffer: extern struct {
|
||||
start: ?[*]u8,
|
||||
end: ?[*]u8,
|
||||
pointer: ?[*]u8,
|
||||
last: ?[*]u8,
|
||||
},
|
||||
encoding: Encoding,
|
||||
offset: usize,
|
||||
mark: Mark,
|
||||
stream_start_produced: c_int,
|
||||
stream_end_produced: c_int,
|
||||
flow_level: c_int,
|
||||
tokens: extern struct {
|
||||
start: ?*Token,
|
||||
end: ?*Token,
|
||||
head: ?*Token,
|
||||
tail: ?*Token,
|
||||
},
|
||||
tokens_parsed: usize,
|
||||
token_available: c_int,
|
||||
indents: extern struct {
|
||||
start: ?*c_int,
|
||||
end: ?*c_int,
|
||||
top: ?*c_int,
|
||||
},
|
||||
indent: c_int,
|
||||
simple_key_allowed: c_int,
|
||||
simple_keys: extern struct {
|
||||
start: ?*SimpleKey,
|
||||
end: ?*SimpleKey,
|
||||
top: ?*SimpleKey,
|
||||
},
|
||||
states: extern struct {
|
||||
start: ?*SimpleKey,
|
||||
end: ?*SimpleKey,
|
||||
top: ?*SimpleKey,
|
||||
},
|
||||
state: ParserState,
|
||||
marks: extern struct {
|
||||
start: ?*Mark,
|
||||
end: ?*Mark,
|
||||
top: ?*Mark,
|
||||
},
|
||||
tag_directives: extern struct {
|
||||
start: ?*TagDirective,
|
||||
end: ?*TagDirective,
|
||||
top: ?*TagDirective,
|
||||
},
|
||||
aliases: extern struct {
|
||||
start: ?*AliasData,
|
||||
end: ?*AliasData,
|
||||
top: ?*AliasData,
|
||||
},
|
||||
document: ?*Document,
|
||||
|
||||
pub fn init() !Parser {
|
||||
var parser: Parser = undefined;
|
||||
if (yaml_parser_initialize(&parser) == 0) return error.Failed;
|
||||
return parser;
|
||||
}
|
||||
|
||||
pub fn deinit(self: *Parser) void {
|
||||
yaml_parser_delete(self);
|
||||
}
|
||||
|
||||
pub fn setInputString(self: *Parser, input: []const u8) void {
|
||||
yaml_parser_set_input_string(self, input.ptr, input.len);
|
||||
}
|
||||
|
||||
pub fn parse(self: *Parser, event: *Event) !void {
|
||||
if (yaml_parser_parse(self, event) == 0) return error.Failed;
|
||||
}
|
||||
|
||||
pub extern fn yaml_parser_initialize(parser: *Parser) c_int;
|
||||
pub extern fn yaml_parser_delete(parser: *Parser) void;
|
||||
pub extern fn yaml_parser_set_input_string(parser: *Parser, input: [*]const u8, size: usize) void;
|
||||
pub extern fn yaml_parser_set_input(parser: *Parser, handler: ReadHandler, data: ?*anyopaque) void;
|
||||
pub extern fn yaml_parser_set_encoding(parser: *Parser, encoding: Encoding) void;
|
||||
pub extern fn yaml_parser_scan(parser: *Parser, token: *Token) c_int;
|
||||
pub extern fn yaml_parser_parse(parser: *Parser, event: *Event) c_int;
|
||||
pub extern fn yaml_parser_load(parser: *Parser, document: *Document) c_int;
|
||||
};
|
||||
pub const SimpleKey = extern struct {
|
||||
possible: c_int,
|
||||
required: c_int,
|
||||
token_number: usize,
|
||||
mark: Mark,
|
||||
};
|
||||
|
||||
pub const NodeType = enum(c_int) {
|
||||
none,
|
||||
scalar,
|
||||
sequence,
|
||||
mapping,
|
||||
};
|
||||
|
||||
pub const NodeItem = c_int;
|
||||
|
||||
pub const NodePair = extern struct {
|
||||
key: c_int,
|
||||
value: c_int,
|
||||
};
|
||||
|
||||
pub const Node = extern struct {
|
||||
type: NodeType,
|
||||
tag: ?[*:0]u8,
|
||||
data: extern union {
|
||||
scalar: extern struct {
|
||||
value: ?[*:0]u8,
|
||||
length: usize,
|
||||
style: ScalarStyle,
|
||||
},
|
||||
sequence: extern struct {
|
||||
items: extern struct {
|
||||
start: ?*NodeItem,
|
||||
end: ?*NodeItem,
|
||||
top: ?*NodeItem,
|
||||
},
|
||||
style: SequenceStyle,
|
||||
},
|
||||
mapping: extern struct {
|
||||
pairs: extern struct {
|
||||
start: ?*NodePair,
|
||||
end: ?*NodePair,
|
||||
top: ?*NodePair,
|
||||
},
|
||||
style: MappingStyle,
|
||||
},
|
||||
},
|
||||
start_mark: Mark,
|
||||
end_mark: Mark,
|
||||
};
|
||||
|
||||
pub const Document = extern struct {
|
||||
nodes: extern struct {
|
||||
start: ?*Node,
|
||||
end: ?*Node,
|
||||
top: ?*Node,
|
||||
},
|
||||
version_directive: ?*VersionDirective,
|
||||
tag_directives: extern struct {
|
||||
start: ?*TagDirective,
|
||||
end: ?*TagDirective,
|
||||
},
|
||||
start_implicit: c_int,
|
||||
end_implicit: c_int,
|
||||
start_mark: Mark,
|
||||
end_mark: Mark,
|
||||
};
|
||||
|
||||
pub const AliasData = extern struct {
|
||||
anchor: ?[*]u8,
|
||||
index: c_int,
|
||||
mark: Mark,
|
||||
};
|
||||
|
||||
pub const ReadHandler = *const fn (ctx: ?*anyopaque, buffer: [*]u8, buffer_size: usize, bytes_read: *usize) callconv(.C) c_int;
|
||||
|
||||
pub const ParserState = enum(c_int) {
|
||||
stream_start,
|
||||
implicit_document_start,
|
||||
document_start,
|
||||
document_content,
|
||||
document_end,
|
||||
block_node,
|
||||
block_node_or_indentless_sequence,
|
||||
flow_node,
|
||||
block_sequence_first_entry,
|
||||
block_sequence_entry,
|
||||
indentless_sequence_entry,
|
||||
block_mapping_first_key,
|
||||
block_mapping_key,
|
||||
block_mapping_value,
|
||||
flow_sequence_first_entry,
|
||||
flow_sequence_entry,
|
||||
flow_sequence_entry_mapping_key,
|
||||
flow_sequence_entry_mapping_value,
|
||||
flow_sequence_entry_mapping_end,
|
||||
flow_mapping_first_key,
|
||||
flow_mapping_key,
|
||||
flow_mapping_value,
|
||||
flow_mapping_empty_value,
|
||||
end,
|
||||
};
|
||||
|
||||
pub const Parser = extern struct {
|
||||
@"error": ErrorType,
|
||||
problem: ?[*:0]const u8,
|
||||
problem_offset: usize,
|
||||
problem_value: c_int,
|
||||
problem_mark: Mark,
|
||||
context: ?[*:0]const u8,
|
||||
context_mark: Mark,
|
||||
read_handler: ?ReadHandler,
|
||||
read_handler_data: ?*anyopaque,
|
||||
input: extern union {
|
||||
string: extern struct {
|
||||
start: ?[*]const u8,
|
||||
end: ?[*]const u8,
|
||||
current: ?[*]const u8,
|
||||
},
|
||||
file: ?*anyopaque,
|
||||
},
|
||||
eof: c_int,
|
||||
buffer: extern struct {
|
||||
start: ?[*]u8,
|
||||
end: ?[*]u8,
|
||||
pointer: ?[*]u8,
|
||||
last: ?[*]u8,
|
||||
},
|
||||
unread: usize,
|
||||
raw_buffer: extern struct {
|
||||
start: ?[*]u8,
|
||||
end: ?[*]u8,
|
||||
pointer: ?[*]u8,
|
||||
last: ?[*]u8,
|
||||
},
|
||||
encoding: Encoding,
|
||||
offset: usize,
|
||||
mark: Mark,
|
||||
stream_start_produced: c_int,
|
||||
stream_end_produced: c_int,
|
||||
flow_level: c_int,
|
||||
tokens: extern struct {
|
||||
start: ?*Token,
|
||||
end: ?*Token,
|
||||
head: ?*Token,
|
||||
tail: ?*Token,
|
||||
},
|
||||
tokens_parsed: usize,
|
||||
token_available: c_int,
|
||||
indents: extern struct {
|
||||
start: ?*c_int,
|
||||
end: ?*c_int,
|
||||
top: ?*c_int,
|
||||
},
|
||||
indent: c_int,
|
||||
simple_key_allowed: c_int,
|
||||
simple_keys: extern struct {
|
||||
start: ?*SimpleKey,
|
||||
end: ?*SimpleKey,
|
||||
top: ?*SimpleKey,
|
||||
},
|
||||
states: extern struct {
|
||||
start: ?*SimpleKey,
|
||||
end: ?*SimpleKey,
|
||||
top: ?*SimpleKey,
|
||||
},
|
||||
state: ParserState,
|
||||
marks: extern struct {
|
||||
start: ?*Mark,
|
||||
end: ?*Mark,
|
||||
top: ?*Mark,
|
||||
},
|
||||
tag_directives: extern struct {
|
||||
start: ?*TagDirective,
|
||||
end: ?*TagDirective,
|
||||
top: ?*TagDirective,
|
||||
},
|
||||
aliases: extern struct {
|
||||
start: ?*AliasData,
|
||||
end: ?*AliasData,
|
||||
top: ?*AliasData,
|
||||
},
|
||||
document: ?*Document,
|
||||
|
||||
pub fn init() !Parser {
|
||||
var parser: Parser = undefined;
|
||||
if (yaml_parser_initialize(&parser) == 0) return error.Failed;
|
||||
return parser;
|
||||
}
|
||||
|
||||
pub fn deinit(self: *Parser) void {
|
||||
yaml_parser_delete(self);
|
||||
}
|
||||
|
||||
pub fn setInputString(self: *Parser, input: []const u8) void {
|
||||
yaml_parser_set_input_string(self, input.ptr, input.len);
|
||||
}
|
||||
|
||||
pub fn parse(self: *Parser, event: *Event) !void {
|
||||
if (yaml_parser_parse(self, event) == 0) return error.Failed;
|
||||
}
|
||||
|
||||
pub extern fn yaml_parser_initialize(parser: *Parser) c_int;
|
||||
pub extern fn yaml_parser_delete(parser: *Parser) void;
|
||||
pub extern fn yaml_parser_set_input_string(parser: *Parser, input: [*]const u8, size: usize) void;
|
||||
pub extern fn yaml_parser_set_input(parser: *Parser, handler: ReadHandler, data: ?*anyopaque) void;
|
||||
pub extern fn yaml_parser_set_encoding(parser: *Parser, encoding: Encoding) void;
|
||||
pub extern fn yaml_parser_scan(parser: *Parser, token: *Token) c_int;
|
||||
pub extern fn yaml_parser_parse(parser: *Parser, event: *Event) c_int;
|
||||
pub extern fn yaml_parser_load(parser: *Parser, document: *Document) c_int;
|
||||
};
|
||||
|
||||
@ -14,7 +14,14 @@ pub fn main() !void {
|
||||
);
|
||||
defer allocator.free(slurp);
|
||||
|
||||
const doc = try yaml.Value.fromString(allocator, slurp);
|
||||
var diag = yaml.ParseDiagnostic{ .message = "?????" };
|
||||
const doc = yaml.Document.fromString(allocator, slurp, &diag) catch |err| {
|
||||
std.debug.print(
|
||||
"Failed to parse line: {d}, col: {d}: {s}\n",
|
||||
.{ diag.line, diag.col, diag.message },
|
||||
);
|
||||
return err;
|
||||
};
|
||||
defer doc.deinit();
|
||||
|
||||
std.debug.print("\n-----\n\n", .{});
|
||||
|
||||
300
src/yaml.zig
Normal file
300
src/yaml.zig
Normal file
@ -0,0 +1,300 @@
|
||||
const std = @import("std");
|
||||
|
||||
pub const libyaml = @import("./libyaml.zig");
|
||||
|
||||
pub const Scalar = []const u8;
|
||||
pub const List = []Value;
|
||||
pub const Map = std.StringArrayHashMapUnmanaged(Value);
|
||||
|
||||
pub const ParseDiagnostic = struct {
|
||||
message: []const u8,
|
||||
line: usize = 0,
|
||||
col: usize = 0,
|
||||
|
||||
pub fn set(self: *ParseDiagnostic, mark: libyaml.Mark, message: []const u8) void {
|
||||
self.line = mark.line + 1;
|
||||
self.col = mark.column;
|
||||
self.message = message;
|
||||
}
|
||||
|
||||
pub fn setMark(self: *ParseDiagnostic, mark: libyaml.Mark) void {
|
||||
self.line = mark.line + 1;
|
||||
self.col = mark.column;
|
||||
}
|
||||
|
||||
pub fn setMessage(self: *ParseDiagnostic, message: []const u8) void {
|
||||
self.message = message;
|
||||
}
|
||||
};
|
||||
|
||||
pub const Document = struct {
|
||||
root: Value,
|
||||
allocator: *std.heap.ArenaAllocator,
|
||||
|
||||
pub fn fromString(allocator: std.mem.Allocator, data: []const u8, diag: *ParseDiagnostic) !Document {
|
||||
var parser = libyaml.Parser.init() catch {
|
||||
diag.setMessage("could not initialize libyaml parser");
|
||||
return error.Failed;
|
||||
};
|
||||
defer parser.deinit();
|
||||
|
||||
parser.setInputString(data);
|
||||
|
||||
var builder = Value.Builder.init(allocator) catch {
|
||||
diag.setMessage("could not initialize value builder: out of memory");
|
||||
return error.Failed;
|
||||
};
|
||||
errdefer builder.deinit();
|
||||
|
||||
var docseen = false;
|
||||
while (true) {
|
||||
var event: libyaml.Event = undefined;
|
||||
parser.parse(&event) catch {
|
||||
diag.set(
|
||||
parser.problem_mark,
|
||||
if (parser.problem) |problem|
|
||||
std.mem.span(problem)
|
||||
else
|
||||
"parsing failed without a description",
|
||||
);
|
||||
return error.Failed;
|
||||
};
|
||||
defer event.deinit();
|
||||
|
||||
switch (event.type) {
|
||||
.empty => {
|
||||
diag.set(event.start_mark, "an empty event was generated (???)");
|
||||
return error.Failed;
|
||||
},
|
||||
.alias => {
|
||||
diag.set(event.start_mark, "an alias node was encountered (these are not supported)");
|
||||
return error.Failed;
|
||||
},
|
||||
.document_start => {
|
||||
if (docseen) {
|
||||
diag.set(event.start_mark, "A second YAML document was found");
|
||||
return error.Failed;
|
||||
}
|
||||
docseen = true;
|
||||
},
|
||||
.scalar => builder.pushScalar(event.data.scalar.value[0..event.data.scalar.length], diag) catch {
|
||||
diag.setMark(event.start_mark);
|
||||
return error.Failed;
|
||||
},
|
||||
.sequence_start => builder.startList(diag) catch {
|
||||
diag.setMark(event.start_mark);
|
||||
return error.Failed;
|
||||
},
|
||||
.sequence_end => builder.endList(diag) catch {
|
||||
diag.setMark(event.start_mark);
|
||||
return error.Failed;
|
||||
},
|
||||
.mapping_start => builder.startMap(diag) catch {
|
||||
diag.setMark(event.start_mark);
|
||||
return error.Failed;
|
||||
},
|
||||
.mapping_end => builder.endMap(diag) catch {
|
||||
diag.setMark(event.start_mark);
|
||||
return error.Failed;
|
||||
},
|
||||
.stream_start, .document_end => {},
|
||||
.stream_end => break,
|
||||
}
|
||||
}
|
||||
|
||||
return builder.document() catch {
|
||||
diag.setMessage("The value builder container stack is not empty, somehow?");
|
||||
return error.Failed;
|
||||
};
|
||||
}
|
||||
|
||||
pub fn deinit(self: Document) void {
|
||||
const child = self.allocator.child_allocator;
|
||||
self.allocator.deinit();
|
||||
child.destroy(self.allocator);
|
||||
}
|
||||
};
|
||||
|
||||
pub const Value = union(enum) {
|
||||
scalar: Scalar,
|
||||
list: List,
|
||||
map: Map,
|
||||
|
||||
pub const Builder = struct {
|
||||
pub const Stack = union(enum) {
|
||||
root,
|
||||
list: std.ArrayListUnmanaged(Value),
|
||||
map: struct {
|
||||
lastkey: ?Scalar = null,
|
||||
map: Map,
|
||||
},
|
||||
};
|
||||
|
||||
allocator: std.mem.Allocator,
|
||||
container_stack: std.ArrayListUnmanaged(Stack),
|
||||
root: Value,
|
||||
|
||||
pub fn init(child_allocator: std.mem.Allocator) std.mem.Allocator.Error!Builder {
|
||||
const arena = try child_allocator.create(std.heap.ArenaAllocator);
|
||||
arena.* = std.heap.ArenaAllocator.init(child_allocator);
|
||||
const allocator = arena.allocator();
|
||||
|
||||
var stack = try std.ArrayListUnmanaged(Stack).initCapacity(allocator, 1);
|
||||
stack.appendAssumeCapacity(.root);
|
||||
|
||||
return .{
|
||||
.allocator = allocator,
|
||||
.container_stack = stack,
|
||||
.root = .{ .scalar = "" },
|
||||
};
|
||||
}
|
||||
|
||||
// this should only be run on failure.
|
||||
pub fn deinit(self: Builder) void {
|
||||
const arena: *std.heap.ArenaAllocator = @ptrCast(@alignCast(self.allocator.ptr));
|
||||
const alloc = arena.child_allocator;
|
||||
arena.deinit();
|
||||
alloc.destroy(arena);
|
||||
}
|
||||
|
||||
pub fn document(self: *Builder) !Document {
|
||||
if (self.container_stack.getLast() != .root)
|
||||
return error.Failed;
|
||||
|
||||
return .{
|
||||
.root = self.root,
|
||||
.allocator = @ptrCast(@alignCast(self.allocator.ptr)),
|
||||
};
|
||||
}
|
||||
|
||||
fn pushScalar(self: *Builder, value: Scalar, diag: *ParseDiagnostic) !void {
|
||||
switch (self.container_stack.items[self.container_stack.items.len - 1]) {
|
||||
.root => {
|
||||
self.root = .{ .scalar = try self.allocator.dupe(u8, value) };
|
||||
},
|
||||
.list => |*builder| builder.append(self.allocator, .{
|
||||
.scalar = self.allocator.dupe(u8, value) catch {
|
||||
diag.setMessage("could not duplicate scalar (out of memory)");
|
||||
return error.Failed;
|
||||
},
|
||||
}) catch {
|
||||
diag.setMessage("could not append scalar to list (out of memory)");
|
||||
return error.Failed;
|
||||
},
|
||||
.map => |*builder| {
|
||||
if (builder.lastkey) |key| {
|
||||
builder.map.put(self.allocator, key, .{
|
||||
.scalar = self.allocator.dupe(u8, value) catch {
|
||||
diag.setMessage("could not duplicate scalar (out of memory)");
|
||||
return error.Failed;
|
||||
},
|
||||
}) catch {
|
||||
diag.setMessage("could not set map value (out of memory)");
|
||||
return error.Failed;
|
||||
};
|
||||
builder.lastkey = null;
|
||||
} else {
|
||||
const duped = self.allocator.dupe(u8, value) catch {
|
||||
diag.setMessage("could not duplicate scalar (out of memory)");
|
||||
return error.Failed;
|
||||
};
|
||||
builder.map.put(self.allocator, duped, undefined) catch {
|
||||
diag.setMessage("could not set map key (out of memory)");
|
||||
return error.Failed;
|
||||
};
|
||||
builder.lastkey = duped;
|
||||
}
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
fn startList(self: *Builder, diag: *ParseDiagnostic) !void {
|
||||
self.container_stack.append(self.allocator, .{ .list = .{} }) catch {
|
||||
diag.setMessage("could not add list to stack: out of memory");
|
||||
return error.Failed;
|
||||
};
|
||||
}
|
||||
|
||||
fn endList(self: *Builder, diag: *ParseDiagnostic) !void {
|
||||
var top = self.container_stack.pop();
|
||||
if (top != .list) {
|
||||
diag.setMessage("list ended when a list was not the top container");
|
||||
return error.Failed;
|
||||
}
|
||||
|
||||
switch (self.container_stack.items[self.container_stack.items.len - 1]) {
|
||||
.root => self.root = .{
|
||||
.list = top.list.toOwnedSlice(self.allocator) catch {
|
||||
diag.setMessage("could not take ownership of list");
|
||||
return error.Failed;
|
||||
},
|
||||
},
|
||||
.list => |*builder| builder.append(self.allocator, .{
|
||||
.list = top.list.toOwnedSlice(self.allocator) catch {
|
||||
diag.setMessage("could not take ownership of list");
|
||||
return error.Failed;
|
||||
},
|
||||
}) catch {
|
||||
diag.setMessage("could not append list to list");
|
||||
return error.Failed;
|
||||
},
|
||||
.map => |*builder| {
|
||||
if (builder.lastkey) |key| {
|
||||
builder.map.put(self.allocator, key, .{
|
||||
.list = top.list.toOwnedSlice(self.allocator) catch {
|
||||
diag.setMessage("could not take ownership of list");
|
||||
return error.Failed;
|
||||
},
|
||||
}) catch {
|
||||
diag.setMessage("could not put list in map");
|
||||
return error.Failed;
|
||||
};
|
||||
builder.lastkey = null;
|
||||
} else {
|
||||
diag.setMessage("found a list masquerading as a map key (only scalar keys are supported)");
|
||||
return error.Failed;
|
||||
}
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
fn startMap(self: *Builder, diag: *ParseDiagnostic) !void {
|
||||
self.container_stack.append(self.allocator, .{ .map = .{ .map = .{} } }) catch {
|
||||
diag.setMessage("could not add map to stack: out of memory");
|
||||
return error.Failed;
|
||||
};
|
||||
}
|
||||
|
||||
fn endMap(self: *Builder, diag: *ParseDiagnostic) !void {
|
||||
var top = self.container_stack.pop();
|
||||
|
||||
if (top != .map) {
|
||||
diag.setMessage("map ended when a map was not the top container");
|
||||
return error.Failed;
|
||||
}
|
||||
|
||||
switch (self.container_stack.items[self.container_stack.items.len - 1]) {
|
||||
.root => self.root = .{ .map = top.map.map },
|
||||
.list => |*builder| builder.append(
|
||||
self.allocator,
|
||||
.{ .map = top.map.map },
|
||||
) catch {
|
||||
diag.setMessage("could not append map to list");
|
||||
return error.Failed;
|
||||
},
|
||||
.map => |*builder| {
|
||||
if (builder.lastkey) |key| {
|
||||
builder.map.put(self.allocator, key, .{ .map = top.map.map }) catch {
|
||||
diag.setMessage("could not put map in map");
|
||||
return error.Failed;
|
||||
};
|
||||
builder.lastkey = null;
|
||||
} else {
|
||||
diag.setMessage("found a map masquerading as a map key (only scalar keys are supported)");
|
||||
return error.Failed;
|
||||
}
|
||||
},
|
||||
}
|
||||
}
|
||||
};
|
||||
};
|
||||
Loading…
x
Reference in New Issue
Block a user