Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-xml

Source of release 0.3.0

0.3.0 / src / xml / reader.lucb

#==============================================================================================
#
#   xml/reader - The reader's state, its input frames and error reporting
#
#   DESCRIPTION:
#       One parse is one `Reader`. Its input is a stack of `Frame`s: the document's text
#       at the bottom, and above it the replacement text of each entity being expanded
#       (an external one decoded and normalised when it is loaded). Scanning always
#       reads the top frame; a construct never spans two (a start tag cannot end in a
#       different entity than it began), so the frame's end is simply the end of the
#       input to the scanning functions here, which answer 0 there (NUL is never an XML
#       character). The reader also holds the DTD's declarations, the open elements and
#       namespace bindings, and the scratch buffers events are built in.
#
#       `complain` turns a broken constraint into a `ParseError`: it finds the frame that
#       is a text of its own (the document or an external entity), works out the line and
#       column there, and writes the message into the parser's storage, so it outlives
#       the reader.
#
#==============================================================================================

# mark: Input frames ==========================================================================

## A text being read: the document, or an entity's replacement text.
struct Frame:
    var text: str
    var pos: usize = 0
    ## 1 + the index of the entity whose text this is; 0 for the document.
    var entity: u32 = 0
    ## The text of an external entity or the external subset: errors report positions in
    ## it, under `system_id`.
    var external: bool = false
    ## Inside the external subset or an external parameter entity, where the DTD's rules
    ## are looser (parameter-entity references may stand inside declarations).
    var in_external: bool = false
    ## Elements open when the frame began; content in it must close the ones it opens.
    var depth: usize = 0
    var system_id: str = ""

## A declared entity.
struct Entity:
    var name: str = ""
    var parameter: bool = false
    ## The replacement text: an internal entity's from its declaration, an external
    ## one's once loaded.
    var value: str = ""
    var external: bool = false
    var public_id: str? = none
    var system_id: str = ""
    ## The system identifier of the entity the declaration is in ("" for the document).
    var base: str = ""
    ## The notation of an unparsed entity; "" for a parsed one.
    var notation: str = ""
    ## Declared in the external subset or in a parameter entity, which a standalone
    ## document may not rely on.
    var outside: bool = false
    var loaded: bool = false
    var unavailable: bool = false
    ## Being expanded now: a reference to it from its own text is recursion.
    var expanding: bool = false

## An attribute an ATTLIST declares.
struct AttributeDecl:
    var name: str = ""
    ## Of type CDATA: its values are not collapsed.
    var cdata: bool = true
    ## The default, normalised; none for #REQUIRED and #IMPLIED.
    var value: str? = none
    ## 1 + the index of the next attribute declared for the same element; 0 for none.
    var next: u32 = 0

## The attributes declared for one element type, as a chain through `AttributeDecl.next`.
struct AttributeList:
    var first: u32 = 0
    var last: u32 = 0

## An element whose end tag has not been read.
struct Open:
    var name: Name = Name()
    ## The frame its start tag was in; its end tag must be in the same one.
    var frame: usize = 0
    ## `Reader.bindings.used` before its namespace declarations.
    var bindings: usize = 0

## A namespace prefix in scope ("" for the default namespace; a "" `uri` undeclares it).
## `Reader.prefixes` maps each prefix to its innermost binding; `shadowed` is the one
## it replaced there, restored when this one goes out of scope.
struct Binding:
    var prefix: str = ""
    var uri: str = ""
    var shadowed: u32 = unbound

## An attribute of the start tag being read, before its value is placed: `value` is a
## view of the input, or (when `built`) bytes `start..<end` of `Reader.values`.
struct RawAttribute:
    var name: str = ""
    var value: str = ""
    var built: bool = false
    var start: usize = 0
    var end: usize = 0
    var specified: bool = true

# mark: The reader ============================================================================

## The state of one parse.
struct Reader:
    var listener: Listener
    var options: Options
    var parser: Parser*
    var arena: Arena = Arena()
    var frames: List[Frame] = List[Frame]()
    var entities: List[Entity] = List[Entity]()
    var general: Table = Table()
    var parameters: Table = Table()
    var notations: List[Notation] = List[Notation]()
    var notation_names: Table = Table()
    var attribute_lists: List[AttributeList] = List[AttributeList]()
    var element_types: Table = Table()
    ## `element attribute` for every attribute declared, to keep the first declaration.
    var attribute_names: Table = Table()
    var declared: List[AttributeDecl] = List[AttributeDecl]()
    var open: List[Open] = List[Open]()
    var bindings: List[Binding] = List[Binding]()
    var prefixes: Table = Table()
    var uris: Table = Table()
    var interned: List[str] = List[str]()
    var raw: List[RawAttribute] = List[RawAttribute]()
    var attributes: List[Attribute] = List[Attribute]()
    var seen: Table = Table()
    var values: Bytes = Bytes()
    var scratch: Bytes = Bytes()
    ## An entity value's replacement text, as it is built.
    var literal: Bytes = Bytes()
    ## Character data waiting to be sent: a view `run_start..<run_end` of frame
    ## `run_frame`, or (when `run_built`) the bytes of `text`.
    var text: Bytes = Bytes()
    var run_pending: bool = false
    var run_built: bool = false
    var run_frame: usize = 0
    var run_start: usize = 0
    var run_end: usize = 0
    ## The document: its normalised text, the bytes its byte order mark took, and where
    ## line-end normalisation dropped a CR (for byte offsets in the original).
    var document: str = ""
    var origin: usize = 0
    var collapsed: List[usize] = List[usize]()
    var declaration: Declaration = Declaration()
    var doctype: Doctype = Doctype()
    var has_doctype: bool = false
    var standalone: bool = false
    var external_subset: bool = false
    ## A parameter-entity reference was seen in the DTD.
    var pe_references: bool = false
    ## A parameter entity was not read: later ENTITY and ATTLIST declarations are not
    ## processed (XML 1.0 ยง5.1).
    var skipped: bool = false
    ## INCLUDE sections open in the external subset.
    var includes: usize = 0
    ## Bytes entity references have expanded to so far.
    var expanded: usize = 0

    ## Free everything the reader allocated.
    func release():
        self.arena.release()
        self.frames.release()
        self.entities.release()
        self.general.release()
        self.parameters.release()
        self.notations.release()
        self.notation_names.release()
        self.attribute_lists.release()
        self.element_types.release()
        self.attribute_names.release()
        self.declared.release()
        self.open.release()
        self.bindings.release()
        self.prefixes.release()
        self.uris.release()
        self.interned.release()
        self.raw.release()
        self.attributes.release()
        self.seen.release()
        self.values.release()
        self.scratch.release()
        self.literal.release()
        self.text.release()
        self.collapsed.release()

    # mark: Scanning the top frame ============================================================

    ## The index of the top frame.
    func top() -> usize:
        return self.frames.used - 1

    ## The byte at the top frame's position, or 0 at its end.
    func peek() -> u8:
        let frame = &self.frames.items[self.frames.used - 1]
        return frame.text.bytes[frame.pos] if frame.pos < frame.text.length else 0

    ## The byte `ahead` bytes past the position, or 0 past the end.
    func peek_at(ahead: usize) -> u8:
        let frame = &self.frames.items[self.frames.used - 1]
        let index = frame.pos + ahead
        return frame.text.bytes[index] if index < frame.text.length else 0

    ## Whether the top frame continues with `expected`.
    func looking_at(expected: str) -> bool:
        let frame = &self.frames.items[self.frames.used - 1]
        if frame.pos + expected.length > frame.text.length:
            return false
        for index in 0..<expected.length:
            if frame.text.bytes[frame.pos + index] != expected.bytes[index]:
                return false
        return true

    func at_end() -> bool:
        let frame = &self.frames.items[self.frames.used - 1]
        return frame.pos >= frame.text.length

    func advance(count: usize):
        self.frames.items[self.frames.used - 1].pos += count

    ## The top frame's position.
    func position() -> usize:
        return self.frames.items[self.frames.used - 1].pos

    ## Move the top frame's position back to `pos` (for an error's position).
    func rewind(pos: usize):
        self.frames.items[self.frames.used - 1].pos = pos

    ## The top frame's text from `start` to the position.
    func since(start: usize) -> str:
        let frame = &self.frames.items[self.frames.used - 1]
        return (str)frame.text.bytes[start..<frame.pos]

    ## Skip white space; answer whether there was any.
    func skip_spaces() -> bool:
        let frame = &self.frames.items[self.frames.used - 1]
        let start = frame.pos
        while frame.pos < frame.text.length and is_space(frame.text.bytes[frame.pos]):
            frame.pos += 1
        return frame.pos > start

    ## Step over `expected` if the top frame continues with it.
    func accept(expected: str) -> bool:
        if self.looking_at(expected):
            self.advance(expected.length)
            return true
        return false

    ## The scalar at the position and its length; (0, 0) at the end.
    func scalar() -> (u32, usize):
        let frame = &self.frames.items[self.frames.used - 1]
        if frame.pos >= frame.text.length:
            return (0, 0)
        return decode_utf8(frame.text.bytes, frame.pos)

    ## A `Name` ([5]) at the position, or "" if none starts there.
    func scan_name() -> str:
        let start = self.position()
        let (first, first_size) = self.scalar()
        if first_size == 0 or not is_name_start(first):
            return ""
        self.advance(first_size)
        while true:
            let (next, size) = self.scalar()
            if size == 0 or not is_name_char(next):
                break
            self.advance(size)
        return self.since(start)

    ## An `Nmtoken` ([7]) at the position, or "" if none starts there.
    func scan_nmtoken() -> str:
        let start = self.position()
        while true:
            let (next, size) = self.scalar()
            if size == 0 or not is_name_char(next):
                break
            self.advance(size)
        return self.since(start)

    # mark: Errors ============================================================================

    ## Record a well-formedness error at the position and answer its message, for
    ## `error(malformed, ...)`.
    func complain(message: fmt) -> str!:
        return try self.report(malformed, message)

    ## Record an error with `code` at the position and answer its message.
    func report(code: ErrorCode, message: fmt, encoding: str = "") -> str!:
        var index = self.frames.used - 1
        while index > 0 and not self.frames.items[index].external:
            index -= 1
        let frame = self.frames.items[index]
        var position = locate(frame.text.bytes, frame.pos)
        if index == 0:
            position.offset += self.origin
            for dropped in self.collapsed.view():
                if dropped <= frame.pos:
                    position.offset += 1
        var storage = &self.parser.storage
        storage.clear()
        try storage.add_all(encoding.bytes)
        let encoding_end = storage.used
        try storage.add_all(frame.system_id.bytes)
        let entity_end = storage.used
        _ = try storage.write(f"{position.line}:{position.column}: ")
        let message_start = storage.used
        _ = try storage.write(message)
        let all = storage.view()
        self.parser.failure = ParseError(code = code, position = position, message = (str)all.bytes[message_start..],
                                         entity = (str)all.bytes[encoding_end..<entity_end], encoding = (str)all.bytes[..<encoding_end])
        return (str)all.bytes[entity_end..]

## Where byte `offset` of `text` is: its line and column (in characters), both from 1.
func locate(text: const u8[], offset: usize) -> Position:
    var line: usize = 1
    var column: usize = 1
    var index: usize = 0
    let end = offset if offset < text.length else text.length
    while index < end:
        let byte = text[index]
        if byte == '\n' or (byte == '\r' and not (index + 1 < text.length and text[index + 1] == '\n')):
            line += 1
            column = 1
        elif (byte & 0xC0) != 0x80 and byte != '\r':
            column += 1
        index += 1
    return Position(line = line, column = column, offset = offset)