tiny.choir.ir.dialects.registry

1const std = @import("std");2const core = @import("../root.zig");34const Type = core.Type;5const Operation = core.Operation;6const Context = core.Context;7const interfaces = core.interfaces;89pub const DialectLoaderFn = *const fn (ctx: *Context) anyerror!void;1011pub const DialectExtensionFn = *const fn (ctx: *Context) anyerror!void;1213pub const DialectRegistryEntry = struct {14    name: []const u8,15    load: DialectLoaderFn,16};1718pub const DialectRegistrySpec = struct {19    entries: []const DialectRegistryEntry,20};2122pub const OpInterfaceFallbackFn = *const fn (op: *const Operation) ?*const anyopaque;2324pub const OpInterfaceFallbackEntry = struct {25    id: interfaces.InterfaceId,26    fallback: OpInterfaceFallbackFn,27};2829pub const TypeInterfaceFallbackFn = *const fn (ctx: *const Context, typ: Type) ?*const anyopaque;3031pub const TypeInterfaceFallbackEntry = struct {32    id: interfaces.InterfaceId,33    fallback: TypeInterfaceFallbackFn,34};3536pub fn InterfaceFallbackRegistry(comptime FallbackFn: type) type {37    return struct {38        groups: std.ArrayListUnmanaged(Group) = .empty,3940        const Self = @This();4142        const Entry = struct {43            dialect_name: []const u8,44            fallback: FallbackFn,45        };4647        pub const Lookup = struct {48            entries: []const Entry,4950            pub fn get(self: Lookup, dialect_name: []const u8) ?FallbackFn {51                for (self.entries) |entry| {52                    if (std.mem.eql(u8, entry.dialect_name, dialect_name)) return entry.fallback;53                }54                return null;55            }56        };5758        const Group = struct {59            id: interfaces.InterfaceId,60            entries: std.ArrayListUnmanaged(Entry),61        };6263        pub fn deinit(self: *Self, allocator: std.mem.Allocator) void {64            for (self.groups.items) |*group| {65                group.entries.deinit(allocator);66            }67            self.groups.deinit(allocator);68        }6970        pub fn register(71            self: *Self,72            allocator: std.mem.Allocator,73            dialect_name: []const u8,74            id: interfaces.InterfaceId,75            fallback: FallbackFn,76        ) (error{DuplicateInterface} || std.mem.Allocator.Error)!void {77            const index = self.lowerBound(id);78            if (index < self.groups.items.len and self.groups.items[index].id == id) {79                const group = &self.groups.items[index];80                for (group.entries.items) |entry| {81                    if (std.mem.eql(u8, entry.dialect_name, dialect_name)) {82                        return error.DuplicateInterface;83                    }84                }85                try group.entries.append(allocator, .{ .dialect_name = dialect_name, .fallback = fallback });86                return;87            }8889            var entries: std.ArrayListUnmanaged(Entry) = .empty;90            errdefer entries.deinit(allocator);91            try entries.append(allocator, .{ .dialect_name = dialect_name, .fallback = fallback });92            try self.groups.insert(allocator, index, .{ .id = id, .entries = entries });93        }9495        pub fn get(self: *const Self, dialect_name: []const u8, id: interfaces.InterfaceId) ?FallbackFn {96            const candidates = self.lookup(id) orelse return null;97            return candidates.get(dialect_name);98        }99100        pub fn lookup(self: *const Self, id: interfaces.InterfaceId) ?Lookup {101            const index = self.lowerBound(id);102            if (index == self.groups.items.len or self.groups.items[index].id != id) return null;103            return .{ .entries = self.groups.items[index].entries.items };104        }105106        fn lowerBound(self: *const Self, id: interfaces.InterfaceId) usize {107            var left: usize = 0;108            var right = self.groups.items.len;109            while (left < right) {110                const mid = left + (right - left) / 2;111                if (self.groups.items[mid].id < id) {112                    left = mid + 1;113                } else {114                    right = mid;115                }116            }117            return left;118        }119    };120}121122pub const DialectLoadState = enum {123    loading,124    loaded,125};126127pub const Dialect = struct {128    name: []const u8,129    context: *Context,130131    pub fn init(name: []const u8, context: *Context) Dialect {132        return .{133            .name = name,134            .context = context,135        };136    }137};138139pub const DialectRegistry = struct {140    names: std.StringHashMapUnmanaged(void),141142    loaded: std.StringHashMap(*Dialect),143144    loaders: std.StringHashMapUnmanaged(DialectLoaderFn),145146    load_state: std.StringHashMapUnmanaged(DialectLoadState),147148    pending_extensions: std.StringHashMapUnmanaged(std.ArrayListUnmanaged(DialectExtensionFn)),149150    interfaces: std.StringHashMapUnmanaged(std.ArrayListUnmanaged(interfaces.InterfaceEntry)),151152    op_interface_fallbacks: InterfaceFallbackRegistry(OpInterfaceFallbackFn),153154    type_interface_fallbacks: InterfaceFallbackRegistry(TypeInterfaceFallbackFn),155156    backend_names: std.StringHashMapUnmanaged(void),157158    operation_registry: interfaces.OperationRegistry,159160    allow_unregistered: bool,161162    pub fn init(163        table_allocator: std.mem.Allocator,164        interface_allocator: std.mem.Allocator,165    ) DialectRegistry {166        return .{167            .names = .{},168            .loaded = std.StringHashMap(*Dialect).init(table_allocator),169            .loaders = .{},170            .load_state = .{},171            .pending_extensions = .{},172            .interfaces = .{},173            .op_interface_fallbacks = .{},174            .type_interface_fallbacks = .{},175            .backend_names = .{},176            .operation_registry = interfaces.OperationRegistry.init(interface_allocator),177            .allow_unregistered = false,178        };179    }180181    pub fn deinit(182        self: *DialectRegistry,183        table_allocator: std.mem.Allocator,184        name_allocator: std.mem.Allocator,185        interface_allocator: std.mem.Allocator,186    ) void {187        var dialect_iter = self.loaded.valueIterator();188        while (dialect_iter.next()) |dialect| {189            table_allocator.destroy(dialect.*);190        }191        self.loaded.deinit();192193        self.loaders.deinit(table_allocator);194195        self.load_state.deinit(table_allocator);196197        var ext_iter = self.pending_extensions.valueIterator();198        while (ext_iter.next()) |ext_list| {199            ext_list.deinit(interface_allocator);200        }201        self.pending_extensions.deinit(interface_allocator);202203        var di_iter = self.interfaces.valueIterator();204        while (di_iter.next()) |iface_list| {205            iface_list.deinit(interface_allocator);206        }207        self.interfaces.deinit(interface_allocator);208209        self.op_interface_fallbacks.deinit(interface_allocator);210211        self.type_interface_fallbacks.deinit(interface_allocator);212213        self.backend_names.deinit(table_allocator);214215        var name_iter = self.names.keyIterator();216        while (name_iter.next()) |name_ptr| {217            name_allocator.free(name_ptr.*);218        }219        self.names.deinit(table_allocator);220221        self.operation_registry.deinit();222    }223224    pub fn internDialectName(225        self: *DialectRegistry,226        table_allocator: std.mem.Allocator,227        name_allocator: std.mem.Allocator,228        name: []const u8,229    ) ![]const u8 {230        if (self.names.getKeyPtr(name)) |key_ptr| {231            return key_ptr.*;232        }233        const copy = try name_allocator.dupe(u8, name);234        errdefer name_allocator.free(copy);235        try self.names.putNoClobber(table_allocator, copy, {});236        return copy;237    }238};239240test "interface fallback registry survives allocation failures" {241    const testing = std.testing;242    const Harness = struct {243        const FallbackFn = *const fn () void;244245        fn fallback() void {}246247        fn run(allocator: std.mem.Allocator) !void {248            var registry: InterfaceFallbackRegistry(FallbackFn) = .{};249            defer registry.deinit(allocator);250251            try registry.register(allocator, "beta", 17, fallback);252            try registry.register(allocator, "alpha", 3, fallback);253            try registry.register(allocator, "alpha", 17, fallback);254            const id_17 = registry.lookup(17).?;255            try testing.expect(id_17.get("alpha") != null);256            try testing.expect(id_17.get("beta") != null);257            try testing.expectEqual(@as(?FallbackFn, null), id_17.get("missing"));258            try testing.expectEqual(@as(?InterfaceFallbackRegistry(FallbackFn).Lookup, null), registry.lookup(19));259            try testing.expect(registry.get("alpha", 3) != null);260            try testing.expect(registry.get("alpha", 17) != null);261            try testing.expect(registry.get("beta", 17) != null);262        }263    };264265    try testing.checkAllAllocationFailures(testing.allocator, Harness.run, .{});266}267268test {269    @import("std").testing.refAllDecls(@This());270}

1pub const registry = @import("registry.zig");