tiny.syn.State

1/// The continuation state: what the last scanned line left open. A caller keeps one for each2/// document and passes it to every `highlightLine` call for that document. The value `.{}` is the3/// fresh state for the start of a document. The struct holds no pointers and needs no cleanup. The4/// state records no document, so a caller that moves to another document calls `reset`.5pub const State = struct {6    /// The open mode with its owning language, or null when nothing is open. The package changes it7    /// only through `reset`, `rebind` and `retain`, which keep the mode admitted by its language.8    continuation: ?Continuation = null,910    /// Clears the state, so nothing is open, for a caller starting a new document.11    pub fn reset(self: *State) void {12        self.* = .{};13    }1415    /// Keeps the open mode when `language` owns it, and clears the state otherwise, for16    /// `highlightLine` at the start of each line so an open comment or string from another language17    /// never reaches this one. The call asserts that a stored mode is admitted by its owning18    /// language.19    pub fn rebind(self: *State, language: Language) void {20        const continuation = self.continuation orelse return;21        std.debug.assert(continuation.mode.admittedBy(22            continuation.language,23        ));24        if (continuation.language != language) self.reset();25    }2627    /// Stores `next_mode` with `language` as its owner, or clears the state when `next_mode` is28    /// null, for `highlightLine` after scanning a line to store what the line left open. The call29    /// asserts that `language` admits `next_mode`.30    pub fn retain(31        self: *State,32        language: Language,33        next_mode: ?Mode,34    ) void {35        if (next_mode) |actual| {36            std.debug.assert(actual.admittedBy(language));37        }38        self.continuation = if (next_mode) |actual|39            .{ .language = language, .mode = actual }40        else41            null;42    }4344    /// Returns the owning language, or null when nothing is open, for a caller or a test reading45    /// which language left something open.46    pub fn owner(self: *const State) ?Language {47        const continuation = self.continuation orelse return null;48        return continuation.language;49    }5051    /// Returns the open mode, or null when nothing is open, for a caller or a test reading which52    /// comment or string is open after a line.53    pub fn mode(self: *const State) ?Mode {54        const continuation = self.continuation orelse return null;55        return continuation.mode;56    }57};

1pub const State = state.State;