How to Parse Zon like Json during Runtime?

Help
,
1

At Runtime, I only know that:
There are keys named:

  1. name
  2. version
  3. dependencies.

I just want to get the values like:

const parsed = parse_my_zon(runtime_string);

std.debug.print("{s}", parsed.name);

for (parsed.dependencies) |dependency| {
    std.debug.print("{s}", dependency.key_name);
    std.debug.print("{s}", dependency.url);
    std.debug.print("{s}", dependency.hash);
}

.{
    .name = .foo,
    .version = "0.0.0",
    .fingerprint = 0x1879e3171df18555,
    .minimum_zig_version = "0.15.1",
    .dependencies = .{
        .capy = .{
            .url = "git+https://github.com/capy-ui/capy#bb12dab974a310b737acbaa6649cc2f2f8f8455f",
            .hash = "capy-0.4.1-kru7R1I2ZQS55Kk-HN_p8YDKCdkgGhmJe8f0Gq0djDfd",
        },
    },
    .paths = .{
        "build.zig",
        "build.zig.zon",
        "src",
    },
}
3

Based on this post:

I changed the fields of Dependency to optionals so that later code still has the info whether the field was present:

var zondata: [:0]const u8 =
    \\.{
    \\    .name = .foo,
    \\    .version = "0.0.0",
    \\    .fingerprint = 0x1879e3171df18555,
    \\    .minimum_zig_version = "0.15.1",
    \\    .dependencies = .{
    \\        .capy = .{
    \\            .url = "git+https://github.com/capy-ui/capy#bb12dab974a310b737acbaa6649cc2f2f8f8455f",
    \\            .hash = "capy-0.4.1-kru7R1I2ZQS55Kk-HN_p8YDKCdkgGhmJe8f0Gq0djDfd",
    \\        },
    \\    },
    \\    .paths = .{
    \\        "build.zig",
    \\        "build.zig.zon",
    \\        "src",
    \\    },
    \\}
;

pub fn main() !void {
    var gpa = std.heap.DebugAllocator(.{}){};
    defer _ = gpa.deinit();
    const allocator = gpa.allocator();

    var arena: std.heap.ArenaAllocator = .init(allocator);
    defer arena.deinit();

    const parsed = try parseBuildZigZon(arena.allocator(), zondata);

    std.debug.print("{?s}\n", .{parsed.name});

    var it = parsed.dependencies.iterator();
    while (it.next()) |dependency| {
        std.debug.print("{s}\n", .{dependency.key_ptr.*});
        std.debug.print("{?s}\n", .{dependency.value_ptr.url});
        std.debug.print("{?s}\n", .{dependency.value_ptr.hash});
        std.debug.print("{?s}\n", .{dependency.value_ptr.path});
        std.debug.print("{?}\n", .{dependency.value_ptr.lazy});
    }
}

const BuildZigZon = struct {
    name: ?[]const u8 = null,
    version: ?[]const u8 = null,
    dependencies: std.StringArrayHashMapUnmanaged(Dependency) = .empty,

    const Dependency = struct {
        url: ?[]const u8 = null,
        hash: ?[]const u8 = null,
        path: ?[]const u8 = null,
        lazy: ?bool = null,
    };
};

fn parseBuildZigZon(arena: std.mem.Allocator, content: [:0]const u8) !BuildZigZon {
    const ast = try std.zig.Ast.parse(arena, content, .zon);
    const zoir = try std.zig.ZonGen.generate(arena, ast, .{ .parse_str_lits = true });

    const root = std.zig.Zoir.Node.Index.root.get(zoir);
    const root_struct = if (root == .struct_literal) root.struct_literal else return error.Parse;

    var result: BuildZigZon = .{};

    for (root_struct.names, 0..root_struct.vals.len) |name_node, index| {
        const value = root_struct.vals.at(@intCast(index));
        const name = name_node.get(zoir);

        if (std.mem.eql(u8, name, "name")) {
            result.name = try arena.dupe(u8, value.get(zoir).enum_literal.get(zoir));
        }

        if (std.mem.eql(u8, name, "version")) {
            result.version = try arena.dupe(u8, value.get(zoir).string_literal);
        }

        if (std.mem.eql(u8, name, "dependencies")) dep: {
            switch (value.get(zoir)) {
                .struct_literal => |sl| {
                    for (sl.names, 0..sl.vals.len) |dep_name, dep_index| {
                        const node = sl.vals.at(@intCast(dep_index));
                        const dep_body = try std.zon.parse.fromZoirNode(BuildZigZon.Dependency, arena, ast, zoir, node, null, .{});

                        try result.dependencies.put(arena, try arena.dupe(u8, dep_name.get(zoir)), dep_body);
                    }
                },
                .empty_literal => {
                    break :dep;
                },
                else => return error.Parse,
            }
        }
    }

    return result;
}

const std = @import("std");

I didn’t see a compelling reason (was too lazy) to change the StringArrayHashMap to a slice, so that is left as an exercise for the reader.

3 Likes
4

Thanks a lot! :slightly_smiling_face:

1 Like
5

Hi,

regarding the name field:
i have an open PR to support parsing enum literals as strings: std.zon.parse: add parsing of enum literals as string by dasimmet · Pull Request #23261 · ziglang/zig · GitHub

And the dependencies struct:
I have another version of the zon.parse file here that allows parsing the dependencies struct into a StringHashMapUnmanaged:

That avoids dealing with Zoir in the application code, but probably should be behind a parser option, like the enums as strings

2 Likes
6

How can we make this work in a way that it doesn’t omit comments, like the, after parsing the file, when I write it back, the comments are gone.