yaml-z

static.zig (12623B)

---

 const std = @import("std");
 
 const Scanner = @import("Scanner.zig");
 const AllocWhen = Scanner.AllocWhen;
 const Token = Scanner.Token;
 const default_max_value_len = Scanner.default_max_value_len;
 
 /// Controls how to deal with various inconsistencies between the YAML
 /// document and the Zig struct type passed in.
 /// For unknown fields, set options in this struct.
 /// For missing fields, give the Zig struct fields default values.
 pub const ParseOptions = struct {
     /// If false, finding an unknown field returns `error.UnknownField`
     ignore_unknown_fields: bool = false,
 
     /// Passed to `yaml.Scanner.nextAllocMax`.
     /// The default for `parseFromSlice` or `parseFromTokenSource` with a
     /// `*yaml.Scanner` input is the length of the input slice, which means
     /// `error.ValueTooLong` will never be returned.
     max_value_len: ?usize = null,
 
     /// This determines whether strings should always be copied, or if a
     /// reference to the given buffer should be preferred if possible.
     /// The default for `parseFromSlice` or `parseFromTokenSource` with a
     /// `*yaml.Scanner` input is `.alloc_if_needed`.
     allocate: ?AllocWhen = null,
 
     /// When parsing to a `yaml.Value`, set this option to false to always
     /// emit YAML numbers as unparsed `yaml.Value.number_string`. Otherwise,
     /// YAML numbers are parsed as either `yaml.Value.integer`,
     /// `yaml.Value.float`, or left unparsed as `yaml.Value.number_string`.
     /// When this option is true, YAML numbers encoded as floats may lose
     /// precision when being parsed into `yaml.Value.float`.
     parse_numbers: bool = true,
 };
 
 pub fn Parsed(comptime T: type) type {
     return struct{
         arena: *std.heap.ArenaAllocator,
         value: T,
 
         pub fn deinit(self: @This()) void {
             const allocator = self.arena.child_allocator;
             self.arena.deinit();
             allocator.destroy(self.arena);
         }
     };
 }
 
 pub fn parseFromSlice(
     comptime T: type,
     allocator: std.mem.Allocator,
     s: []const u8,
     options: ParseOptions,
 ) !Parsed(T) {
     var scanner = Scanner.initCompleteInput(s);
     //defer scanner.deinit();
 
     return parseFromTokenSource(T, allocator, &scanner, options);
 }
 
 pub fn parseFromTokenSource(
     comptime T: type,
     allocator: std.mem.Allocator,
     scanner_or_reader: anytype,
     options: ParseOptions,
 ) !Parsed(T) {
     var parsed = Parsed(T){
         .arena = try allocator.create(std.heap.ArenaAllocator),
         .value = undefined,
     };
     errdefer allocator.destroy(parsed.arena);
     parsed.arena.* = std.heap.ArenaAllocator.init(allocator);
     errdefer parsed.arena.deinit();
 
     parsed.value = try parseFromTokenSourceLeaky(
         T,
         parsed.arena.allocator(),
         scanner_or_reader,
         options,
     );
 
     return parsed;
 }
 
 pub fn parseFromTokenSourceLeaky(
     comptime T: type,
     allocator: std.mem.Allocator,
     scanner_or_reader: anytype,
     options: ParseOptions,
 ) !T {
     //if (@TypeOf(scanner_or_reader.*) == Scanner) {
     //    std.debug.assert(scanner_or_reader.is_end_of_input);
     //}
     var resolved_options = options;
     if (resolved_options.max_value_len == null) {
         if (@TypeOf(scanner_or_reader.*) == Scanner) {
             resolved_options.max_value_len = scanner_or_reader.input.len;
         } else {
             resolved_options.max_value_len = default_max_value_len;
         }
     }
     if (resolved_options.allocate == null) {
         if (@TypeOf(scanner_or_reader.*) == Scanner) {
             resolved_options.allocate = .alloc_if_needed;
         } else {
             resolved_options.allocate = .alloc_always;
         }
     }
 
     const value = try innerParse(
         T,
         allocator,
         scanner_or_reader,
         resolved_options,
     );
 
     std.debug.assert(try scanner_or_reader.next() == .document_end);
 
     return value;
 }
 
 /// This is an internal function called recursively during the implementation
 /// of `parseFromTokenSourceLeaky` and similar.
 /// It is exposed primarily to enable custom `yamlParse()` methods to call
 /// back into the `parseFrom*` system such as if you're implementing a custom
 /// container of type `T`; you can call `innerParse(T, ...)` for each of the
 /// container's items. Note that `null` fields are not allowed on the
 /// `options` when calling this function. (The `options` you get in your
 /// `yamlParse` method has no `null` fields.)
 pub fn innerParse(
     comptime T: type,
     allocator: std.mem.Allocator,
     source: anytype,
     options: ParseOptions,
 ) !T {
     switch (@typeInfo(T)) {
         .bool => {
             return switch (try source.next()) {
                 .true => true,
                 .false => false,
                 else => error.UnexpectedToken,
             };
         },
         .optional => |optional_info| {
             switch (try source.peekNextTokenType()) {
                 .null => {
                     _ = try source.next();
                     return null;
                 },
                 else => {
                     return try innerParse(
                         optional_info.child,
                         allocator,
                         source,
                         options,
                     );
                 },
             }
         },
         .@"enum" => {
             if (std.meta.hasFn(T, "yamlParse")) {
                 return T.yamlParse(allocator, source, options);
             }
 
             // Default parsing
             const token = try source.nextAllocMax(
                 allocator,
                 .alloc_if_needed,
                 options.max_value_len.?,
             );
             defer freeIfAlloc(allocator, token);
             // defer free
             const slice = switch (token) {
                 inline
                     .number,
                     .allocated_number,
                     .string,
                     .allocated_string => |slice| slice,
                 else => return error.UnexpectedToken,
             };
             return sliceToEnum(T, slice);
         },
         .@"union" => |union_info| {
             if (std.meta.hasFn(T, "yamlParse")) {
                 return T.yamlParse(allocator, source, options);
             }
             if (union_info.tag_type == null) {
                 @compileError(
                     "Unable to parse into untagged union '" ++ @typeName(T) ++ "'"
                 );
             }
 
             var result: ?T = null;
             const name_token = try source.nextAllocMax(
                 allocator,
                 .alloc_if_needed,
                 options.max_value_len.?,
             );
             defer freeIfAlloc(allocator, name_token);
 
             const field_name = switch(name_token.?) {
                 inline .string, .allocated_string => |slice| slice,
                 else => return error.UnexpectedToken,
             };
 
             inline for (union_info.fields) |field| {
                 if (std.mem.eql(u8, field.name, field_name)) {
                     if (field.type == void) {
                         result = @unionInit(T, field.name, {});
                     } else {
                         // Recurse
                         const token = try innerParse(
                             field.type,
                             allocator,
                             source,
                             options,
                         );
                         result = @unionInit(
                             T,
                             field.name,
                             token,
                         );
                     }
                     break;
                 }
             } else {
                 // Didn't match anything
                 return error.UnknownField;
             }
 
             return result.?;
         },
         .@"struct" => |struct_info| {
             if (struct_info.is_tuple) {
                 return error.Unimplemented;
             }
             if (std.meta.hasFn(T, "yamlParse")) {
                 return T.yamlParse(allocator, source, options);
             }
 
             var result: T = undefined;
             var fields_seen = [_]bool{false} ** struct_info.fields.len;
 
             while (true) {
                 const name_token = try source.nextAllocMax(
                     allocator,
                     .alloc_if_needed,
                     options.max_value_len.?,
                 );
                 defer freeIfAlloc(allocator, name_token);
                 const field_name = switch(name_token) {
                     inline .string, .allocated_string => |slice| slice,
                     else => return error.UnexpectedToken,
                 };
                 inline for (struct_info.fields, 0..) |field, i| {
                     if (field.is_comptime) {
                         @compileError(
                             "comptile fields are not supported: " ++ @typeName(T) ++ "." ++ field.name
                         );
                     }
                     if (std.mem.eql(u8, field.name, field_name)) {
                         if (fields_seen[i]) return error.DuplicateField;
                         @field(result, field.name) = try innerParse(
                             field.type,
                             allocator,
                             source,
                             options,
                         );
                         fields_seen[i] = true;
                         break;
                     }
                 } else {
                     // Didn't match anything
                     return error.UnknownField;
                 }
             }
         },
         .array => |array_info| {
             switch (try source.peek()) {
                 .string => {
                     if (array_info.child != u8) return error.UnexpectedToken;
                     // Fixed-length string
                 },
                 else => return error.Unimplemented,
             }
         },
         .pointer => |ptr_info| {
             switch (ptr_info.size) {
                 .one => {
                     const result = try allocator.create(ptr_info.child);
                     result.* = try innerParse(
                         ptr_info.child,
                         allocator,
                         source,
                         options,
                     );
                     return result;
                 },
                 .slice => {
                     switch (try source.peek()) {
                         .string,
                         .partial_string,
                         .partial_string_escaped_1 => {
                             if (ptr_info.child != u8) {
                                 return error.UnexpectedToken;
                             }
                             // Dynamic-length string
                             if (ptr_info.sentinel()) |_| {
                                 // Use our own array list so we can append
                                 // the sentinel.
                                 return error.Unimplemented;
                             }
                             var alloc = options.allocate.?;
                             if (!ptr_info.is_const) {
                                 // Have to allocate to get a mutable copy
                                 alloc = .alloc_always;
                             }
                             const result = try source.nextAllocMax(
                                 allocator,
                                 alloc,
                                 options.max_value_len.?,
                             );
                             return switch (result) {
                                 inline
                                     .string,
                                     .allocated_string => |slice| slice,
                                 else => unreachable
                             };
                         },
                         else => return error.UnexpectedToken,
                     }
                 },
             }
         },
         else => return error.Unimplemented,
     }
 }
 
 fn sliceToEnum(comptime T: type, slice: []const u8) !T {
     if (std.meta.stringToEnum(T, slice)) |value| return value;
     const n = std.fmt.parseInt(
         @typeInfo(T).@"enum".tag_type,
         slice,
         10
     ) catch return error.InvalidEnumTag;
     return std.enums.fromInt(T, n) orelse return error.InvalidEnumTag;
 }
 
 fn freeIfAlloc(allocator: std.mem.Allocator, token: Token) void {
     switch (token) {
         inline .allocated_number, .allocated_string => |slice| {
             allocator.free(slice);
         },
         else => {},
     }
 }