tiny.choir.ir.context

1pub const Tracker = struct {2    next_value_id: u32,3    next_operation_id: u31,4    operation_head: ?*Operation,5    operation_count: usize,67    pub fn init() Tracker {8        return .{9            .next_value_id = 0,10            .next_operation_id = 0,11            .operation_head = null,12            .operation_count = 0,13        };14    }1516    pub fn deinit(self: *Tracker) void {17        var current = self.operation_head;18        var remaining = self.operation_count;19        while (remaining > 0) : (remaining -|= 1) {20            const op = current.?;21            op.dropAllReferences();22            current = op.tracking_next;23        }2425        while (self.operation_head) |op| {26            std.debug.assert(op.hasNoUses());27            const removed = self.removeOperation(op);28            std.debug.assert(removed);29            op.destroy();30        }31        std.debug.assert(self.operation_count == 0);32    }3334    fn containsOperation(self: *const Tracker, expected: *const Operation) bool {35        var current = self.operation_head;36        var remaining = self.operation_count;37        while (remaining > 0) : (remaining -|= 1) {38            const op = current.?;39            if (op == expected) return true;40            current = op.tracking_next;41        }42        return false;43    }4445    fn appendOperation(self: *Tracker, op: *Operation) void {46        std.debug.assert(op.tracking_prev == null);47        std.debug.assert(op.tracking_next == null);48        std.debug.assert(self.next_operation_id < std.math.maxInt(u31));49        std.debug.assert(self.operation_count < std.math.maxInt(usize));5051        op.setCreationId(self.next_operation_id);52        self.next_operation_id = std.math.add(u31, self.next_operation_id, 1) catch unreachable;5354        if (self.operation_head) |head| {55            const tail = head.tracking_prev.?;56            op.tracking_prev = tail;57            op.tracking_next = head;58            tail.tracking_next = op;59            head.tracking_prev = op;60        } else {61            op.tracking_prev = op;62            op.tracking_next = op;63            self.operation_head = op;64        }65        self.operation_count = std.math.add(usize, self.operation_count, 1) catch unreachable;66    }6768    fn removeOperation(self: *Tracker, op: *Operation) bool {69        const previous = op.tracking_prev orelse {70            std.debug.assert(op.tracking_next == null);71            return false;72        };73        const next = op.tracking_next.?;74        std.debug.assert(self.operation_count > 0);7576        if (previous == op) {77            std.debug.assert(next == op);78            std.debug.assert(self.operation_head == op);79            std.debug.assert(self.operation_count == 1);80            self.operation_head = null;81        } else {82            std.debug.assert(next != op);83            previous.tracking_next = next;84            next.tracking_prev = previous;85            if (self.operation_head == op) self.operation_head = next;86        }8788        op.tracking_prev = null;89        op.tracking_next = null;90        self.operation_count = std.math.sub(usize, self.operation_count, 1) catch unreachable;91        return true;92    }93};

1const std = @import("std");2const lifecycle = @import("lifecycle.zig");3const memory = @import("memory.zig");4const core = @import("../root.zig");5const resources = @import("resources.zig");67pub const DialectLoaderFn = core.dialects.DialectLoaderFn;8pub const DialectExtensionFn = core.dialects.DialectExtensionFn;9pub const DialectRegistryEntry = core.dialects.DialectRegistryEntry;10pub const DialectRegistrySpec = core.dialects.DialectRegistrySpec;11pub const DialectLoadState = core.dialects.DialectLoadState;12pub const OpInterfaceFallbackFn = core.dialects.OpInterfaceFallbackFn;13pub const OpInterfaceFallbackEntry = core.dialects.OpInterfaceFallbackEntry;14pub const TypeInterfaceFallbackFn = core.dialects.TypeInterfaceFallbackFn;15pub const TypeInterfaceFallbackEntry = core.dialects.TypeInterfaceFallbackEntry;16pub const Dialect = core.dialects.Dialect;17pub const TypeStorage = core.types.TypeStorage;18pub const AttrStorage = core.attrs.AttrStorage;19pub const DialectAttrKey = core.attrs.DialectAttrKey;20pub const IntegerAttrKey = core.attrs.IntegerAttrKey;21pub const FloatAttrKey = core.attrs.FloatAttrKey;22pub const StringAttrKey = core.attrs.StringAttrKey;23pub const SymbolRefAttrKey = core.attrs.SymbolRefAttrKey;24pub const StringListAttrKey = core.attrs.StringListAttrKey;25pub const TypeInterner = core.types.TypeInterner;26pub const AttributeInterner = core.attrs.AttributeInterner;27pub const DialectRegistry = core.dialects.DialectRegistry;28pub const ResourceTracker = resources.Tracker;29pub const ThreadingExecutionGuard = core.ThreadingExecutionGuard;30pub const Context = lifecycle.Context;3132pub fn configurationTableAllocator(context: *Context) std.mem.Allocator {33    return memory.configurationTableAllocator(context.memory);34}3536pub fn configurationNameAllocator(context: *Context) std.mem.Allocator {37    return memory.configurationNameAllocator(context.memory);38}3940pub fn configurationInterfaceAllocator(context: *Context) std.mem.Allocator {41    return memory.configurationInterfaceAllocator(context.memory);42}4344pub fn configurationTransactionAllocator(context: *Context) std.mem.Allocator {45    return memory.configurationTransactionAllocator(context.memory);46}4748pub fn initRegion(context: *Context) core.Region {49    return core.Region.init(memory.operationNestedAllocator(context.memory));50}5152pub fn transientAllocator(context: *Context) std.mem.Allocator {53    return memory.transientAllocator(context.memory);54}5556pub fn operationAllocator(context: *Context) std.mem.Allocator {57    return memory.operationNestedAllocator(context.memory);58}5960pub fn fixedOperationAllocator(context: *Context) std.mem.Allocator {61    return lifecycle.operationStorageAllocator(context).allocator();62}6364pub fn typeTableAllocator(context: *Context) std.mem.Allocator {65    return memory.typeTableAllocator(context.memory);66}6768pub fn typeKeyAllocator(context: *Context) std.mem.Allocator {69    return memory.typeKeyAllocator(context.memory);70}7172pub fn typePayloadAllocator(context: *Context) std.mem.Allocator {73    return memory.typePayloadAllocator(context.memory);74}7576pub fn attributeTableAllocator(context: *Context) std.mem.Allocator {77    return memory.attributeTableAllocator(context.memory);78}7980pub fn attributePayloadAllocator(context: *Context) std.mem.Allocator {81    return memory.attributePayloadAllocator(context.memory);82}8384pub fn diagnosticHandlerAllocator(context: *Context) std.mem.Allocator {85    return memory.diagnosticHandlerAllocator(context.memory);86}8788pub fn diagnosticPayloadAllocator(context: *Context) std.mem.Allocator {89    return memory.diagnosticPayloadAllocator(context.memory);90}

1pub const context = @import("context/root.zig");