zig-zon 0.0.3__tar.gz

zig_zon-0.0.3/CPython.zig

@@ -0,0 +1,195 @@
+const std = @import("std");
+const builtin = @import("builtin");
+const Build = std.Build;
+const fs = std.fs;
+const mem = std.mem;
+
+pub const CPython = @This();
+
+exe: Build.LazyPath,
+
+/// adds a `python` option to the build. if not provided, tries to find `python` in PATH
+pub fn findAddOption(b: *Build) @This() {
+    return .{
+        .exe = b.option(
+            Build.LazyPath,
+            "python",
+            "path to the cpython interpreter executable",
+        ) orelse {
+            return find(b);
+        },
+    };
+}
+
+pub fn find(b: *Build) @This() {
+    return .{
+        .exe = .{
+            .cwd_relative = FindExeWindowsCompat.findProgram(b, &.{
+                "python",
+                "python3",
+            }, &.{}) catch {
+                const err_wf = b.addWriteFiles();
+                const err_step = b.addFail("finding python failed. please provide a path to the exe using -Dpython=");
+                err_wf.step.dependOn(&err_step.step);
+                return .{ .exe = err_wf.getDirectory() };
+            },
+        },
+    };
+}
+
+pub const LinkOptions = struct {
+    /// library to link against libpython
+    lib: *std.Build.Step.Compile,
+    macros: []const [2][]const u8 = &default_macros,
+    pub const default_macros = .{
+        .{ "Py_LIMITED_API", "0x03060500" }, // use the limited api from 3.6.5
+    };
+};
+
+pub fn generateIncludeDir(self: @This(), b: *Build) Build.LazyPath {
+    const extract_link_info = Build.Step.Run.create(b, "python header extraction run");
+    extract_link_info.addFileArg(self.exe);
+    extract_link_info.addFileArg(b.path("src/extract_link_info.py"));
+    return extract_link_info.addOutputDirectoryArg("include");
+}
+
+pub fn installExtLib(b: *Build, lib: *Build.Step.Compile) void {
+    const ext_lib_name = lib_ext_name(b, lib);
+    const lib_install = b.addInstallLibFile(lib.getEmittedBin(), ext_lib_name);
+    b.getInstallStep().dependOn(&lib_install.step);
+}
+
+pub fn link(self: @This(), b: *Build, opt: LinkOptions) void {
+    const target = Build.ResolvedTarget{
+        .query = .{},
+        .result = opt.lib.rootModuleTarget(),
+    };
+
+    const python_inc = self.generateIncludeDir(b);
+
+    const cpython = b.addTranslateC(.{
+        .root_source_file = python_inc.path(b, "Zig_Python_With_Hexver.h"),
+        .optimize = opt.lib.root_module.optimize orelse .ReleaseSafe,
+        .target = target,
+        .link_libc = true,
+    });
+    for (opt.macros) |macro| {
+        cpython.defineCMacro(macro[0], macro[1]);
+    }
+
+    cpython.addIncludePath(python_inc);
+
+    if (target.result.os.tag == .windows) {
+        opt.lib.root_module.addLibraryPath(python_inc);
+        opt.lib.linkSystemLibrary("python");
+    }
+    opt.lib.root_module.addImport(
+        "cpython",
+        cpython.createModule(),
+    );
+}
+
+pub fn lib_ext_name(b: *Build, lib: *Build.Step.Compile) []const u8 {
+    const target = lib.rootModuleTarget();
+    return if (target.os.tag == .windows)
+        b.fmt("{s}.pyd", .{lib.name})
+    else
+        b.fmt("{s}.so", .{lib.name});
+}
+
+pub fn run_test(
+    self: @This(),
+    b: *Build,
+    lib: *Build.Step.Compile,
+    test_py_file: Build.LazyPath,
+) *Build.Step.Run {
+    const runner = b.addExecutable(.{
+        .name = "python-runner",
+        .root_module = b.createModule(.{
+            .root_source_file = b.path("src/python-runner.zig"),
+            .target = b.graph.host,
+            .optimize = .ReleaseSmall,
+        }),
+    });
+    const run_step = b.addRunArtifact(runner);
+    const python_ext = writeExtFile(b, lib);
+    run_step.addFileArg(self.exe);
+    run_step.addDirectoryArg(python_ext.dirname());
+    run_step.addFileArg(test_py_file);
+    run_step.has_side_effects = true;
+    return run_step;
+}
+
+pub fn writeExtFile(b: *Build, lib: *Build.Step.Compile) Build.LazyPath {
+    const ext_lib_name = lib_ext_name(b, lib);
+    const wf = b.addWriteFiles();
+    return wf.addCopyFile(lib.getEmittedBin(), ext_lib_name);
+}
+
+const FindExeWindowsCompat = struct {
+    fn tryFindProgram(b: *Build, full_path: []const u8) ?[]const u8 {
+        if (fs.realpathAlloc(b.allocator, full_path)) |p| {
+            return p;
+        } else |err| switch (err) {
+            error.OutOfMemory => @panic("OOM"),
+            else => {},
+        }
+
+        if (builtin.os.tag == .windows) {
+            if (b.graph.env_map.get("PATHEXT")) |PATHEXT| {
+                var it = mem.tokenizeScalar(u8, PATHEXT, fs.path.delimiter);
+
+                while (it.next()) |ext| {
+                    if (!supportedWindowsProgramExtension(ext)) continue;
+                    const exe_path = mem.join(b.allocator, "", &.{ full_path, ext }) catch @panic("OOM");
+                    fs.accessAbsolute(exe_path, .{ .mode = .read_only }) catch {
+                        b.allocator.free(exe_path);
+                        continue;
+                    };
+                    return exe_path;
+                }
+            }
+        }
+
+        return null;
+    }
+
+    pub fn findProgram(b: *Build, names: []const []const u8, paths: []const []const u8) error{FileNotFound}![]const u8 {
+        // TODO report error for ambiguous situations
+        for (b.search_prefixes.items) |search_prefix| {
+            for (names) |name| {
+                if (fs.path.isAbsolute(name)) {
+                    return name;
+                }
+                return tryFindProgram(b, b.pathJoin(&.{ search_prefix, "bin", name })) orelse continue;
+            }
+        }
+        if (b.graph.env_map.get("PATH")) |PATH| {
+            for (names) |name| {
+                if (fs.path.isAbsolute(name)) {
+                    return name;
+                }
+                var it = mem.tokenizeScalar(u8, PATH, fs.path.delimiter);
+                while (it.next()) |p| {
+                    return tryFindProgram(b, b.pathJoin(&.{ p, name })) orelse continue;
+                }
+            }
+        }
+        for (names) |name| {
+            if (fs.path.isAbsolute(name)) {
+                return name;
+            }
+            for (paths) |p| {
+                return tryFindProgram(b, b.pathJoin(&.{ p, name })) orelse continue;
+            }
+        }
+        return error.FileNotFound;
+    }
+
+    fn supportedWindowsProgramExtension(ext: []const u8) bool {
+        inline for (@typeInfo(std.process.Child.WindowsExtension).@"enum".fields) |field| {
+            if (std.ascii.eqlIgnoreCase(ext, "." ++ field.name)) return true;
+        }
+        return false;
+    }
+};

zig_zon-0.0.3/MANIFEST.in

@@ -0,0 +1,2 @@
+exclude .gitlab-ci.yml
+exclude .gitignore

zig_zon-0.0.3/PKG-INFO

@@ -0,0 +1,30 @@
+Metadata-Version: 2.4
+Name: zig-zon
+Version: 0.0.3
+Summary: My package description
+Author-email: Tobias Simetsreiter <dasimmet@gmail.com>
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# Python Zig Zon Parser
+
+A native python extension built with zig to parse zig-object-notation strings
+into python objects.
+
+# Usage (so far only linux)
+
+install:
+
+```bash
+python3 -m pip install git+https://gitlab.com/dasimmet/python-zig-zon.git
+```
+
+running:
+
+```python
+import zig_zon
+parsed = zig_zon.parse('.{.allyourcode = .are_belong_to_us, .asd = 123}')
+print(parsed)
+```
+
+or, look at the [test](test.py)

zig_zon-0.0.3/README.md

@@ -0,0 +1,22 @@
+# Python Zig Zon Parser
+
+A native python extension built with zig to parse zig-object-notation strings
+into python objects.
+
+# Usage (so far only linux)
+
+install:
+
+```bash
+python3 -m pip install git+https://gitlab.com/dasimmet/python-zig-zon.git
+```
+
+running:
+
+```python
+import zig_zon
+parsed = zig_zon.parse('.{.allyourcode = .are_belong_to_us, .asd = 123}')
+print(parsed)
+```
+
+or, look at the [test](test.py)

zig_zon-0.0.3/build.zig

@@ -0,0 +1,48 @@
+const std = @import("std");
+const Build = std.Build;
+
+pub const CPython = @import("CPython.zig");
+
+pub fn build(b: *Build) void {
+    const target = b.standardTargetOptions(.{});
+    const optimize = b.standardOptimizeOption(.{});
+    const python = CPython.findAddOption(b);
+
+    const exe = b.addExecutable(.{
+        .name = "zigwheeler",
+        .root_module = b.addModule("zigwheeler", .{
+            .root_source_file = b.path("src/zigwheeler.zig"),
+            .target = target,
+            .optimize = optimize,
+        }),
+    });
+    b.installArtifact(exe);
+
+    const lib = b.addLibrary(.{
+        .name = "zig_zon",
+        .root_module = b.addModule("zig_zon", .{
+            .root_source_file = b.path("src/zig_zon.zig"),
+            .target = target,
+            .optimize = optimize,
+        }),
+        .linkage = .dynamic,
+        .use_llvm = true,
+    });
+    CPython.installExtLib(b, lib);
+
+    python.link(b, .{
+        .lib = lib,
+    });
+
+    const install_test = b.addInstallFile(b.path("src/test_zig_zon.py"), "lib/test_zig_zon.py");
+    b.default_step.dependOn(&install_test.step);
+    const run = b.addRunArtifact(exe);
+    if (b.args) |args| {
+        run.addArgs(args);
+    }
+    b.step("run", "run the wheeler").dependOn(&run.step);
+
+    const test_run = python.run_test(b, lib, b.path("src/test_zig_zon.py"));
+
+    b.step("test", "run the python test script").dependOn(&test_run.step);
+}

zig_zon-0.0.3/build.zig.zon

@@ -0,0 +1,17 @@
+.{
+    .name = .python_zig_zon,
+    .fingerprint = 0x3d332656a3644fc9,
+    .version = "0.0.3",
+    .minimum_zig_version = "0.15.1",
+    .dependencies = .{},
+    .paths = .{
+        "src",
+        "build.zig",
+        "build.zig.zon",
+        "CPython.zig",
+        "LICENSE",
+        "README.md",
+        "setup.py",
+        "pyproject.toml",
+    },
+}

zig_zon-0.0.3/pyproject.toml

@@ -0,0 +1,13 @@
+[project]
+name = "zig-zon"
+authors = [{ name = "Tobias Simetsreiter", email = "dasimmet@gmail.com" }]
+description = "My package description"
+readme = "README.md"
+requires-python = ">=3.8"
+dynamic = ["version"]
+
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools_scm]

zig_zon-0.0.3/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

zig_zon-0.0.3/setup.py

@@ -0,0 +1,28 @@
+from setuptools import Extension
+from setuptools import setup
+import sys
+import os
+
+# In this package the setuptools_zig_build cannot be imported as a dependency.
+# on another package zig_build should be passed to setup()
+sys.path.insert(0, os.path.normpath(os.path.join(__file__, '..')))  # nopep8
+from setuptools_zig_build import ZigBuildExtension  # nopep8
+
+zig_build = {
+    "use_zig_python_package": True,
+    "optimize": "ReleaseSmall",
+    'test_step': 'test',  # this is failing on windows for now ;-/
+    'extra_args': [],
+}
+
+setup(
+    name='zig-zon',
+    cmdclass={
+        'build_ext': ZigBuildExtension(zig_build),
+    },
+    ext_modules=[Extension('zig_zon', [])],
+    setup_requires=[
+        "setuptools-scm",
+        "ziglang==0.15.1",
+    ],
+)

zig_zon-0.0.3/setuptools_zig_build.py

@@ -0,0 +1,108 @@
+# coding: utf-8
+
+import sys
+import os
+from subprocess import run
+from pathlib import Path
+import shlex
+
+from setuptools import Extension
+from distutils.dist import Distribution
+from setuptools.command.build_ext import build_ext as SetupToolsBuildExt
+
+
+class ZigCompilerError(Exception):
+    """Some compile/link operation failed."""
+
+
+class BuildExt(SetupToolsBuildExt):
+    def __init__(self, dist, zig_value):
+        self._zig_value = zig_value
+        super().__init__(dist)
+
+    def build_extension(self, ext):
+        ext: Extension
+        if not self._zig_value:
+            return super().build_extension(ext)
+
+        build_zig_dir = "."
+        if len(ext.sources) == 1:
+            build_zig_dir = ext.sources[0]
+        elif len(ext.sources) > 1:
+            raise ZigCompilerError(
+                "sources should only point to build.zig directory")
+
+        target = Path(self.get_ext_fullpath(ext.name))
+
+        output_ext = os.path.splitext(self.get_ext_filename(ext.name))[1]
+
+        zig_out = Path(self.build_temp) / "zig-out"
+
+        bld_cmd = [os.environ.get('PY_ZIG', 'zig'), 'build', 'install',
+                   '-Dpython={}'.format(sys.executable), '--prefix', str(zig_out.absolute())]
+
+        if isinstance(self._zig_value, dict):
+            if 'use_zig_python_package' in self._zig_value and self._zig_value['use_zig_python_package'] == True:
+                import ziglang
+                bld_cmd[0] = os.path.join(
+                    os.path.dirname(ziglang.__file__), "zig")
+
+            if 'test_step' in self._zig_value:
+                bld_cmd.append(self._zig_value['test_step'])
+
+            if 'optimize' in self._zig_value:
+                assert isinstance(self._zig_value['optimize'], str)
+                assert self._zig_value['optimize'] in [
+                    "Debug",
+                    "ReleaseSafe",
+                    "ReleaseFast",
+                    "ReleaseSmall",
+                ]
+                bld_cmd.append(
+                    '-Doptimize={}'.format(self._zig_value['optimize']))
+
+            if 'extra_args' in self._zig_value:
+                assert isinstance(self._zig_value['extra_args'], list)
+                for arg in self._zig_value['extra_args']:
+                    assert isinstance(arg, str)
+                    bld_cmd.append(arg)
+
+        os.makedirs(self.build_temp, exist_ok=True)
+        print('\ncmd', shlex.join(bld_cmd))
+        sys.stdout.flush()
+        run(bld_cmd, check=True, cwd=build_zig_dir)
+
+        output = None
+        for subpath in ['', 'lib', 'bin/', 'lib/', 'bin/lib', 'lib/lib']:
+            zig_output = zig_out / (subpath + ext.name + output_ext)
+            if zig_output.exists():
+                output = zig_output.absolute()
+                break
+            print('missing:', str(zig_output.absolute()), file=sys.stderr)
+
+        if output == None:
+            raise ZigCompilerError(f'expected output does not exist')
+
+        print('found output:', str(output.absolute()),
+              str(target), file=sys.stderr)
+
+        if target.exists():
+            target.unlink()
+        else:
+            target.parent.mkdir(exist_ok=True, parents=True)
+        output.rename(target)
+
+
+class ZigBuildExtension:
+    def __init__(self, value):
+        self._value = value
+
+    def __call__(self, dist):
+        return BuildExt(dist, zig_value=self._value)
+
+
+def setup_build_zig(dist, keyword, value):
+    assert isinstance(dist, Distribution)
+    assert keyword == 'build_zig'
+    be = dist.cmdclass.get('build_ext')
+    dist.cmdclass['build_ext'] = ZigBuildExtension(value)

zig_zon-0.0.3/src/extract_link_info.py

@@ -0,0 +1,65 @@
+#!/usr/bin/env python3
+
+import sysconfig
+import sys
+import shutil
+import os
+
+output_dir = sys.argv[1]
+syspath = sysconfig.get_paths()
+
+lib_filename = 'python{}{}.lib'.format(
+    sys.version_info.major, sys.version_info.minor)
+
+print("syspath:", syspath, file=sys.stderr)
+print("include:", syspath['include'], file=sys.stderr)
+print("data:", syspath['data'], file=sys.stderr)
+
+os.makedirs(output_dir, exist_ok=True)
+shutil.copytree(syspath['include'], output_dir, dirs_exist_ok=True)
+
+found_lib = False
+lib_paths = []
+for k, v in sysconfig.get_config_vars().items():
+    if not isinstance(v, str):
+        continue
+    vf = os.path.join(v, lib_filename)
+    if os.path.exists(vf):
+        try:
+            shutil.copyfile(vf, os.path.join(output_dir, 'python.lib'))
+            found_lib = True
+            break
+        except:
+            lib_paths += vf
+    else:
+        lib_paths += vf
+
+    vfl = os.path.join(v, 'libs', lib_filename)
+    if os.path.exists(vfl):
+        try:
+            shutil.copyfile(vfl, os.path.join(output_dir, 'python.lib'))
+            found_lib = True
+            break
+        except:
+            lib_paths += vfl
+    else:
+        lib_paths += vfl
+
+if sys.platform == 'windows' and not found_lib:
+    print("Did not find", lib_filename, "in:")
+    print(lib_paths)
+
+
+with open(os.path.join(output_dir, 'Zig_Python_With_Hexver.h'), 'w') as fd:
+    fd.write('''
+#ifndef PY_SSIZE_T_CLEAN
+#define PY_SSIZE_T_CLEAN
+#endif
+
+#ifndef PYHEXVER
+#define PYHEXVER {}
+#endif
+
+#include "Python.h"
+'''.format(sys.hexversion))
+    print('OK:', os.path.join(output_dir, 'Zig_Python_With_Hexver.h'))

zig_zon-0.0.3/src/python-runner.zig

@@ -0,0 +1,49 @@
+const std = @import("std");
+
+pub fn main() !void {
+    var gpa_impl = std.heap.DebugAllocator(.{}).init;
+    defer _ = gpa_impl.deinit();
+    const gpa = gpa_impl.allocator();
+
+    const args = try std.process.argsAlloc(gpa);
+    defer std.process.argsFree(gpa, args);
+
+    if (args.len != 4) {
+        std.log.err("expected n args, got: {d}", .{args.len});
+        return error.Expected4Arguments;
+    }
+
+    const python = args[1];
+    const pythonpath = args[2];
+    const test_file = args[3];
+
+    const pythonpath_abs = if (std.fs.path.isAbsolute(pythonpath)) try gpa.dupe(u8, pythonpath) else blk: {
+        const cwd = try std.process.getCwdAlloc(gpa);
+        defer gpa.free(cwd);
+        break :blk try std.fs.path.join(gpa, &.{ cwd, pythonpath });
+    };
+    defer gpa.free(pythonpath_abs);
+
+    std.log.info("PYTHONPATH={s} {s} {s}", .{
+        pythonpath_abs,
+        python,
+        test_file,
+    });
+
+    const argv: []const []const u8 = &.{
+        python,
+        test_file,
+    };
+
+    var env = try std.process.getEnvMap(gpa);
+    defer env.deinit();
+    try env.put("PYTHONPATH", pythonpath_abs);
+
+    var proc: std.process.Child = .init(argv, gpa);
+    proc.env_map = &env;
+    proc.stderr_behavior = .Inherit;
+    proc.stdin_behavior = .Inherit;
+    proc.stdout_behavior = .Inherit;
+    const res = try proc.spawnAndWait();
+    std.process.exit(res.Exited);
+}

zig_zon-0.0.3/src/test_zig_zon.py

@@ -0,0 +1,32 @@
+#!/usr/bin/env python3
+
+from pprint import pprint
+
+import zig_zon
+print('zig_zon module:', zig_zon)
+
+teststr = """
+.{
+    .asdf = "ccc",
+    .my_bool = true,
+    .my_float = 1.23,
+    .my_hex_int = 0xdeadbeef,
+    .my_negative_int = -432_123_111,
+    .my_negative_big_int = -4611686018427387904,
+    .my_optional = null,
+}"""
+
+testzon = zig_zon.parse(teststr)
+print('teststr:')
+pprint(testzon)
+
+assert testzon['asdf'] == "ccc"
+assert testzon['my_float'] == 1.23
+assert testzon['my_hex_int'] == 0xdeadbeef
+assert testzon['my_negative_int'] == -432_123_111
+assert testzon['my_negative_big_int'] == -4611686018427387904
+assert testzon['my_optional'] == None
+
+print('build.zig.zon:')
+with open('build.zig.zon') as fd:
+    pprint(zig_zon.parse(fd.read()))

zig_zon-0.0.3/src/zig_zon.egg-info/PKG-INFO

@@ -0,0 +1,30 @@
+Metadata-Version: 2.4
+Name: zig-zon
+Version: 0.0.3
+Summary: My package description
+Author-email: Tobias Simetsreiter <dasimmet@gmail.com>
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# Python Zig Zon Parser
+
+A native python extension built with zig to parse zig-object-notation strings
+into python objects.
+
+# Usage (so far only linux)
+
+install:
+
+```bash
+python3 -m pip install git+https://gitlab.com/dasimmet/python-zig-zon.git
+```
+
+running:
+
+```python
+import zig_zon
+parsed = zig_zon.parse('.{.allyourcode = .are_belong_to_us, .asd = 123}')
+print(parsed)
+```
+
+or, look at the [test](test.py)

zig_zon-0.0.3/src/zig_zon.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+CPython.zig
+MANIFEST.in
+README.md
+build.zig
+build.zig.zon
+pyproject.toml
+setup.py
+setuptools_zig_build.py
+src/extract_link_info.py
+src/python-runner.zig
+src/test_zig_zon.py
+src/zig_zon.zig
+src/zigwheeler.zig
+src/zig_zon.egg-info/PKG-INFO
+src/zig_zon.egg-info/SOURCES.txt
+src/zig_zon.egg-info/dependency_links.txt
+src/zig_zon.egg-info/top_level.txt

zig_zon-0.0.3/src/zig_zon.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

zig_zon-0.0.3/src/zig_zon.egg-info/top_level.txt

@@ -0,0 +1,3 @@
+extract_link_info
+test_zig_zon
+zig_zon

zig_zon-0.0.3/src/zig_zon.zig

@@ -0,0 +1,276 @@
+const std = @import("std");
+const Ast = std.zig.Ast;
+const Allocator = std.mem.Allocator;
+const assert = std.debug.assert;
+const ZonGen = std.zig.ZonGen;
+
+const c = @import("cpython");
+const PyObject = c.PyObject;
+
+const PyModuleDef_Base = extern struct {
+    ob_base: PyObject,
+    // m_init: ?fn () callconv(.C) [*c]PyObject = null,
+    m_init: ?*const fn () callconv(.c) [*c]PyObject = null,
+    m_index: c.Py_ssize_t = 0,
+    m_copy: [*c]PyObject = null,
+};
+
+const PyModuleDef_HEAD_INIT = PyModuleDef_Base{ .ob_base = PyObject{
+    .unnamed_0 = .{
+        .ob_refcnt = 1,
+    },
+    .ob_type = null,
+} };
+
+pub var methods = [_]c.PyMethodDef{
+    c.PyMethodDef{
+        .ml_name = "parse",
+        .ml_meth = @ptrCast(@alignCast(&parse)),
+        .ml_flags = @as(c_int, 1),
+        .ml_doc = "parse a zon literal to a python object",
+    },
+    c.PyMethodDef{},
+};
+
+pub var zigmodule = c.PyModuleDef{
+    .m_name = "zig_zon",
+    .m_methods = &methods,
+};
+
+pub export fn PyInit_zig_zon() [*c]c.PyObject {
+    return c.PyModule_Create(&zigmodule);
+}
+
+pub fn parse(self: [*]PyObject, args: [*]PyObject) callconv(.c) [*c]PyObject {
+    _ = self;
+    var zon_txt: [*c]u8 = undefined;
+    if (!(c.PyArg_ParseTuple(args, "s", &zon_txt) != 0)) return null;
+
+    var arena_instance = std.heap.ArenaAllocator.init(std.heap.c_allocator);
+    defer arena_instance.deinit();
+    const arena = arena_instance.allocator();
+
+    const ast = Ast.parse(arena, std.mem.sliceTo(zon_txt, 0), .zon) catch |err| {
+        const errstr = std.fmt.allocPrintSentinel(
+            arena,
+            "zig-zon ast error: {s}",
+            .{@errorName(err)},
+            0,
+        ) catch "";
+        c.PyErr_SetString(c.PyExc_Exception, errstr.ptr);
+        return null;
+    };
+
+    // TODO: use zoir instead of AST maybe?
+    // this is unused for now and instead i walk the AST, but i keep it in as a sanity check for now.
+    var zoir = ZonGen.generate(arena, ast, .{ .parse_str_lits = false }) catch |err| {
+        const errstr = std.fmt.allocPrintSentinel(
+            arena,
+            "zig-zon zoir error: {s}",
+            .{@errorName(err)},
+            0,
+        ) catch "";
+        c.PyErr_SetString(c.PyExc_Exception, errstr.ptr);
+        return null;
+    };
+    defer zoir.deinit(arena);
+
+    const main_node_index = ast.nodeData(.root).node;
+
+    return parseZon(arena, ast, main_node_index) catch |err| {
+        const errstr = std.fmt.allocPrintSentinel(
+            arena,
+            "zig-zon parse error: {s}",
+            .{@errorName(err)},
+            0,
+        ) catch "";
+        c.PyErr_SetString(c.PyExc_Exception, errstr.ptr);
+        return null;
+    };
+}
+
+const ZonError = error{
+    StructExpected,
+    StructIdentifierExpected,
+    NotImplemented,
+    ZonArrayError,
+} || IdentifierError || NumberLiteralError;
+
+fn parseZon(arena: Allocator, tree: Ast, node: Ast.Node.Index) ZonError!*c.PyObject {
+    const node_tag = tree.nodeTag(node);
+    switch (node_tag) {
+        .struct_init_comma,
+        .struct_init_dot_comma,
+        .struct_init_dot_two_comma,
+        .struct_init_dot_two,
+        .struct_init_dot,
+        .struct_init_one_comma,
+        .struct_init_one,
+        .struct_init,
+        => return parseZonStruct(arena, tree, node),
+        .array_init_comma,
+        .array_init_dot_comma,
+        .array_init_dot_two_comma,
+        .array_init_dot_two,
+        .array_init_dot,
+        .array_init_one_comma,
+        .array_init_one,
+        .array_init,
+        => return parseZonArray(arena, tree, node),
+        .enum_literal => {
+            const name_token = tree.firstToken(node);
+            const enum_name = tree.tokenSlice(name_token + 1);
+            if (std.mem.startsWith(u8, enum_name, "@")) {
+                std.log.err("non bare enum literals not implemented: {s}", .{enum_name});
+                return error.NotImplemented;
+            }
+
+            return c.Py_BuildValue("s#", enum_name.ptr, enum_name.len);
+        },
+        .string_literal => {
+            const name_token = tree.firstToken(node);
+            const name = tree.tokenSlice(name_token);
+            var buf = std.ArrayListUnmanaged(u8).empty;
+            try parseStrLit(arena, &buf, name, 0);
+            return c.Py_BuildValue("s#", buf.items.ptr, buf.items.len);
+        },
+        .negation => return parseNumberLiteral(arena, tree, node, true),
+        .number_literal => return parseNumberLiteral(arena, tree, node, false),
+        .identifier => {
+            const token_slice = tree.tokenSlice(tree.firstToken(node));
+            if (std.mem.eql(u8, token_slice, "true")) {
+                return c.PyBool_FromLong(@as(c_long, 1));
+            } else if (std.mem.eql(u8, token_slice, "false")) {
+                return c.PyBool_FromLong(@as(c_long, 0));
+            } else if (std.mem.eql(u8, token_slice, "null")) {
+                return c.Py_BuildValue(""); // c.Py_None()
+            } else {
+                if (@errorReturnTrace()) |et| {
+                    std.debug.dumpStackTrace(et.*);
+                    std.debug.dumpCurrentStackTrace(null);
+                }
+                std.log.err("not implemented: {any} '{s}'", .{ node_tag, token_slice });
+                return error.NotImplemented;
+            }
+        },
+        else => {
+            if (@errorReturnTrace()) |et| {
+                std.debug.dumpStackTrace(et.*);
+                std.debug.dumpCurrentStackTrace(null);
+            }
+            const token_slice = tree.tokenSlice(tree.firstToken(node));
+            std.log.err("not implemented: {any} '{s}'", .{ node_tag, token_slice });
+            return error.NotImplemented;
+        },
+    }
+}
+
+const NumberLiteralError = error{
+    BigIntNotImplemented,
+    InvalidCharacter,
+    HexFloatNotImplemented,
+    NumberLiteralFail,
+};
+
+fn parseNumberLiteral(arena: Allocator, tree: Ast, node: Ast.Node.Index, negated: bool) NumberLiteralError!*c.PyObject {
+    _ = arena;
+    const num_token = tree.lastToken(node);
+    const token_bytes = tree.tokenSlice(num_token);
+    const parsed = std.zig.parseNumberLiteral(token_bytes);
+    switch (parsed) {
+        .int => |n| {
+            const factor: i64 = if (negated) -1 else 1;
+            return c.Py_BuildValue("n", factor * @as(i64, @bitCast(n)));
+        },
+        .big_int => return error.BigIntNotImplemented,
+        .float => |n| {
+            const float_payload = switch (n) {
+                .decimal => token_bytes,
+                .hex => return error.HexFloatNotImplemented,
+            };
+            const float = try std.fmt.parseFloat(f64, float_payload);
+            const factor: f64 = if (negated) -1 else 1;
+
+            return c.Py_BuildValue("f", factor * float);
+        },
+        .failure => |err| {
+            std.log.err("number literal: {} bytes: {s}", .{ err, token_bytes });
+            return error.NumberLiteralFail;
+        },
+    }
+}
+
+fn parseZonStruct(arena: Allocator, tree: Ast, node: Ast.Node.Index) ZonError!*c.PyObject {
+    var buf: [2]Ast.Node.Index = undefined;
+    const struct_init = tree.fullStructInit(&buf, node) orelse return error.StructExpected;
+
+    const ret = c.PyDict_New();
+
+    for (struct_init.ast.fields) |field_init| {
+        const name_token = tree.firstToken(field_init) - 2;
+        const field_name = try identifierTokenString(arena, tree, name_token);
+        const field_obj = try parseZon(arena, tree, field_init);
+        const set_result = c.PyDict_SetItemString(ret, field_name, field_obj);
+        assert(set_result >= 0);
+    }
+    return ret;
+}
+
+fn parseZonArray(arena: Allocator, tree: Ast, node: Ast.Node.Index) !*c.PyObject {
+    // ret.* = c.Py_BuildValue("l", @as(u64, 1));
+    var buf: [2]Ast.Node.Index = undefined;
+    const array_init = tree.fullArrayInit(&buf, node) orelse {
+        const tok = tree.nodeMainToken(node);
+        std.log.err("expected paths expression to be a list of strings, got: {d}", .{tok});
+        return error.ZonArrayError;
+    };
+
+    const ret = c.PyList_New(0);
+
+    for (array_init.ast.elements) |elem_node| {
+        const field_ret = try parseZon(arena, tree, elem_node);
+        assert(c.PyList_Append(ret, field_ret) >= 0);
+    }
+    return ret;
+}
+
+const IdentifierError = error{OutOfMemory} || StringLiteralError;
+
+fn identifierTokenString(arena: Allocator, ast: Ast, token: Ast.TokenIndex) IdentifierError![:0]const u8 {
+    std.debug.assert(ast.tokenTag(token) == .identifier);
+    const ident_name = ast.tokenSlice(token);
+    if (!std.mem.startsWith(u8, ident_name, "@")) {
+        return try arena.dupeZ(u8, ident_name);
+    }
+
+    var buf = std.ArrayListUnmanaged(u8).empty;
+    try parseStrLit(arena, &buf, ident_name, 1);
+    try buf.append(arena, 0);
+    return @ptrCast(buf.items);
+}
+
+const StringLiteralError = error{
+    StringLiteralFail,
+    WriteFailed,
+};
+
+fn parseStrLit(
+    arena: Allocator,
+    buf: *std.ArrayListUnmanaged(u8),
+    bytes: []const u8,
+    offset: u32,
+) StringLiteralError!void {
+    const raw_string = bytes[offset..];
+    const result = r: {
+        var aw: std.Io.Writer.Allocating = .fromArrayList(arena, buf);
+        defer buf.* = aw.toArrayList();
+        break :r try std.zig.string_literal.parseWrite(&aw.writer, raw_string);
+    };
+    switch (result) {
+        .success => {},
+        .failure => |err| {
+            std.log.err("StringLiteralFail: {}", .{err});
+            return error.StringLiteralFail;
+        },
+    }
+}

zig_zon-0.0.3/src/zigwheeler.zig

@@ -0,0 +1,5 @@
+const std = @import("std");
+
+pub fn main() !void {
+    std.log.info("Hello World", .{});
+}