dymokomi/luce-xml
Source of release 0.3.0
0.3.0 / src / xml / declarations.lucb
#==============================================================================================
#
# xml/declarations - ENTITY, ATTLIST, ELEMENT and NOTATION declarations
#
# DESCRIPTION:
# The markup declarations of the DTD (§3.2, §3.3, §4.2, §4.7). Each is checked
# against its grammar in full; what a non-validating parser needs is kept: entities
# (their replacement texts built as §4.5 says), attribute types and defaults, and
# notations. Element declarations are checked and dropped. The first declaration of
# an entity or of an element's attribute binds; later ones are ignored.
#
#==============================================================================================
# mark: Entities ==============================================================================
## An entity declaration ([70]), `<!ENTITY` at the position.
func read_entity_declaration(reader: Reader*) -> !:
let floor = reader.top()
reader.advance(8)
try require_space(reader, floor, "the entity's name")
var parameter = false
if reader.peek() == '%':
reader.advance(1)
try require_space(reader, floor, "the parameter entity's name")
parameter = true
let name = try expect_name(reader, "the entity's name")
if reader.options.namespaces and has_byte(name, ':'):
error(malformed, try reader.complain(f"the entity name '{name}' contains a colon"))
try require_space(reader, floor, "the entity's value")
var entity = Entity(name = name, parameter = parameter, outside = reader.top() > 0)
let quote = reader.peek()
if quote == '"' or quote == '\'':
entity.value = try read_entity_value(reader)
elif reader.looking_at("SYSTEM") or reader.looking_at("PUBLIC"):
let (public_id, system_id) = try read_external_id(reader, floor, false)
entity.external = true
entity.public_id = public_id
entity.system_id = system_id else ""
entity.base = external_base(reader)
let spaced = try dtd_space(reader, floor)
if reader.looking_at("NDATA"):
if parameter:
error(malformed, try reader.complain("a parameter entity cannot be unparsed (NDATA)"))
if not spaced:
error(malformed, try reader.complain("expected white space before NDATA"))
reader.advance(5)
try require_space(reader, floor, "the notation's name")
entity.notation = try expect_name(reader, "the notation's name")
else:
error(malformed, try reader.complain(f"expected the value or external identifier of the entity '{name}'"))
try end_declaration(reader, floor, "entity")
if not processing(reader):
return
var table = &reader.parameters if parameter else &reader.general
if table.find(name) != none:
return
try table.insert(name, (u32)reader.entities.used)
try reader.entities.push(entity)
## The system identifier of the external entity the reader is in ("" for the document).
func external_base(reader: const Reader*) -> str:
var index = reader.frames.used
while index > 0:
index -= 1
if reader.frames.items[index].external:
return reader.frames.items[index].system_id
return ""
## An entity's quoted value ([9]) at the position; answers its replacement text (§4.5):
## character references and parameter entities replaced, general entity references
## left as they are.
func read_entity_value(reader: Reader*) -> str!:
let quote = reader.peek()
reader.advance(1)
reader.literal.clear()
try read_entity_value_text(reader, quote)
return try reader.arena.store(reader.literal.items[..<reader.literal.used])
## The text of an entity value from the top frame into `Reader.literal`, up to `quote`,
## or to the frame's end (a parameter entity's text) when `quote` is 0.
func read_entity_value_text(reader: Reader*, quote: u8) -> !:
while true:
if reader.at_end():
if quote == 0:
return
error(malformed, try reader.complain("the entity's value is not closed"))
let byte = reader.peek()
if byte == quote:
reader.advance(1)
return
if byte == '%':
if not reader.frames.items[reader.top()].in_external:
error(malformed, try reader.complain("a parameter-entity reference cannot stand in an entity value in the internal subset"))
if try enter_parameter(reader):
try read_entity_value_text(reader, 0)
end_parameter_entity(reader)
elif byte == '&':
if reader.peek_at(1) == '#':
try reader.literal.add_scalar(try read_char_reference(reader))
else:
let start = reader.position()
_ = try read_entity_name(reader)
try reader.literal.add_all(reader.since(start).bytes)
else:
try reader.literal.add(byte)
reader.advance(1)
# mark: Attribute lists =======================================================================
## An attribute-list declaration ([52]), `<!ATTLIST` at the position.
func read_attribute_list(reader: Reader*) -> !:
let floor = reader.top()
reader.advance(9)
try require_space(reader, floor, "the element's name")
let element = try expect_name(reader, "the element's name")
while true:
let spaced = try dtd_space(reader, floor)
if reader.accept(">"):
return
if not spaced:
error(malformed, try reader.complain("expected white space before the attribute's definition"))
let name = try expect_name(reader, "an attribute name or '>'")
try require_space(reader, floor, "the attribute's type")
let cdata = try read_attribute_type(reader, floor)
try require_space(reader, floor, "the attribute's default")
var value: str? = none
if reader.accept("#REQUIRED") or reader.accept("#IMPLIED"):
value = none
else:
if reader.accept("#FIXED"):
try require_space(reader, floor, "the fixed value")
value = try read_default_value(reader, name, cdata)
if processing(reader):
try declare_attribute(reader, element, AttributeDecl(name = name, cdata = cdata, value = value))
## An attribute type ([54]); answers whether it is CDATA.
func read_attribute_type(reader: Reader*, floor: usize) -> bool!:
if reader.accept("CDATA"):
return true
for keyword in ["IDREFS", "IDREF", "ID", "ENTITIES", "ENTITY", "NMTOKENS", "NMTOKEN"]:
if reader.accept(keyword):
return false
var notation = false
if reader.accept("NOTATION"):
try require_space(reader, floor, "the notation names")
notation = true
if not reader.accept("("):
error(malformed, try reader.complain("expected an attribute type"))
while true:
_ = try dtd_space(reader, floor)
let token = reader.scan_name() if notation else reader.scan_nmtoken()
if token.length == 0:
error(malformed, try reader.complain("expected a name in the enumeration"))
_ = try dtd_space(reader, floor)
if reader.accept(")"):
return false
if not reader.accept("|"):
error(malformed, try reader.complain("expected '|' or ')' in the enumeration"))
## An attribute's default value ([10]), normalised as a value of its type, kept in the
## arena.
func read_default_value(reader: Reader*, name: str, cdata: bool) -> str!:
let quote = reader.peek()
if quote != '"' and quote != '\'':
error(malformed, try reader.complain(f"expected #REQUIRED, #IMPLIED or a quoted default for '{name}'"))
reader.advance(1)
reader.values.clear()
try read_value_text(reader, quote, name)
var value = reader.values.view()
if not cdata:
value = try collapse_text(reader, value)
return try reader.arena.store(value.bytes)
## Add `declared` to `element`'s attributes, unless the element has it already.
func declare_attribute(reader: Reader*, element: str, declared: AttributeDecl) -> !:
let key = try reader.arena.reserve(element.length + 1 + declared.name.length)
memory.copy(key, element.bytes, element.length)
key[element.length] = ' '
memory.copy(key[element.length + 1..], declared.name.bytes, declared.name.length)
if reader.attribute_names.find((str)key) != none:
return
let index = (u32)reader.declared.used
try reader.attribute_names.insert((str)key, index)
try reader.declared.push(declared)
if let found = reader.element_types.find(element):
let list = &reader.attribute_lists.items[(usize)found]
reader.declared.items[list.last - 1].next = index + 1
list.last = index + 1
return
try reader.element_types.insert(element, (u32)reader.attribute_lists.used)
try reader.attribute_lists.push(AttributeList(first = index + 1, last = index + 1))
# mark: Element types =========================================================================
## An element type declaration ([45]), `<!ELEMENT` at the position; checked, not kept.
func read_element_declaration(reader: Reader*) -> !:
let floor = reader.top()
reader.advance(9)
try require_space(reader, floor, "the element's name")
_ = try expect_name(reader, "the element's name")
try require_space(reader, floor, "the content specification")
if reader.accept("EMPTY") or reader.accept("ANY"):
try end_declaration(reader, floor, "element")
return
if not reader.accept("("):
error(malformed, try reader.complain("expected EMPTY, ANY or a content model in '('"))
_ = try dtd_space(reader, floor)
if reader.accept("#PCDATA"):
try read_mixed(reader, floor)
else:
try read_group(reader, floor, 1)
try end_declaration(reader, floor, "element")
## The rest of mixed content ([51]) after `(#PCDATA`.
func read_mixed(reader: Reader*, floor: usize) -> !:
var names = false
while true:
_ = try dtd_space(reader, floor)
if reader.accept(")"):
if names and not reader.accept("*"):
error(malformed, try reader.complain("mixed content with element names must end with ')*'"))
if not names:
_ = reader.accept("*")
return
if not reader.accept("|"):
error(malformed, try reader.complain("expected '|' or ')' in mixed content"))
_ = try dtd_space(reader, floor)
_ = try expect_name(reader, "an element name")
names = true
## The rest of a choice or sequence ([49], [50]) after its `(`; `depth` counts groups.
func read_group(reader: Reader*, floor: usize, depth: usize) -> !:
if depth > reader.options.max_depth:
error(limit, try reader.report(limit, "the content model nests too deeply"))
try read_particle(reader, floor, depth)
var separator: u8 = 0
while true:
_ = try dtd_space(reader, floor)
if reader.accept(")"):
break
let byte = reader.peek()
if byte != '|' and byte != ',':
error(malformed, try reader.complain("expected '|', ',' or ')' in the content model"))
if separator != 0 and separator != byte:
error(malformed, try reader.complain("a content model group cannot mix '|' and ','"))
separator = byte
reader.advance(1)
_ = try dtd_space(reader, floor)
try read_particle(reader, floor, depth)
read_occurrence(reader)
## A content particle ([48]): a name or a group, with its occurrence.
func read_particle(reader: Reader*, floor: usize, depth: usize) -> !:
if reader.accept("("):
_ = try dtd_space(reader, floor)
try read_group(reader, floor, depth + 1)
return
_ = try expect_name(reader, "an element name or '(' in the content model")
read_occurrence(reader)
## `?`, `*` or `+` after a particle, if there.
func read_occurrence(reader: Reader*):
let byte = reader.peek()
if byte == '?' or byte == '*' or byte == '+':
reader.advance(1)
# mark: Notations =============================================================================
## A notation declaration ([82]), `<!NOTATION` at the position.
func read_notation(reader: Reader*) -> !:
let floor = reader.top()
reader.advance(10)
try require_space(reader, floor, "the notation's name")
let name = try expect_name(reader, "the notation's name")
if reader.options.namespaces and has_byte(name, ':'):
error(malformed, try reader.complain(f"the notation name '{name}' contains a colon"))
try require_space(reader, floor, "the notation's identifier")
let (public_id, system_id) = try read_external_id(reader, floor, true)
try end_declaration(reader, floor, "notation")
if reader.notation_names.find(name) != none:
return
try reader.notation_names.insert(name, (u32)reader.notations.used)
try reader.notations.push(Notation(name = name, public_id = public_id, system_id = system_id))