PureXML/Sources/Parsing/DTDAttListGrammar.swift
Mihaela Mihaljevic 32d42410b9 feat(parsing): entity replacement-text well-formedness, fifth suite pass
Implement the replacement-text constraint at the point of reference: when a
general entity is included, its replacement (character references expanded
as at declaration time) must reparse as balanced content in isolation, via a
new EntityReplacementGrammar mini-parser. This rejects a bare or incomplete
reference ('&', '&#9' unterminated), tags spanning the entity boundary
('</foo><foo>'), a raw '<' or incomplete reference inside an embedded
attribute value, '<' followed by a non-name character, and a reserved-target
PI in the replacement, exactly the suite's semantics, including that an
UNREFERENCED entity may carry any value and that only the first declaration
of a name binds. Attribute-list defaults must reference already-declared
internal (not external/unparsed/forward-declared) entities with a
non-recursive chain. A CDATA section inside replacement text now shields its
content from reference expansion, fixing the last valid-side case.

W3C xmltest final standing: valid/sa 119/119, not-wf/sa 180/186, with the
six remaining deviations all deliberate and documented in the baseline:
internal-subset conditional/CDATA sections (063, 107) and parameter-entity
references (160-162) are features this package supports, and 141 expects the
1998 suite's name-character classes where this package implements XML 1.0
Fifth Edition's. Zero false positives across all 846 tests at every step.

Closes #120
2026-06-10 05:47:42 +02:00

172 lines
6.1 KiB
Swift

extension PureXML.Parsing {
/// Validates an `<!ATTLIST>` declaration body (everything after the element
/// name) against the XML 1.0 grammar (productions 52-60): each definition is
/// `S Name S AttType S DefaultDecl`, where the type is `CDATA`, a tokenized
/// type, `NOTATION` with a name group, or an enumeration, and the default is
/// `#REQUIRED`, `#IMPLIED`, or an optionally-`#FIXED` quoted value. The
/// lenient `AttributeListParser` still drives behavior; this strict check
/// runs at DTD scan time.
enum DTDAttListGrammar {
private static let tokenizedTypes: Set<String> = [
"CDATA", "ID", "IDREF", "IDREFS", "ENTITY", "ENTITIES", "NMTOKEN", "NMTOKENS",
]
static func isValid(_ body: String) -> Bool {
defaultValues(body) != nil
}
/// The quoted default values of a valid body, or nil when the body does
/// not match the grammar. The values feed the entity-reference checks
/// the spec puts on attribute defaults.
static func defaultValues(_ body: String) -> [String]? {
var defaults: [String] = []
var scanner = AttListScanner(body)
while !scanner.isAtEnd {
// Each definition starts with required whitespace (the body begins
// right after the element name).
guard scanner.requiredSpace() else { return nil }
if scanner.isAtEnd { return defaults } // trailing whitespace
guard scanner.name() else { return nil }
guard scanner.requiredSpace() else { return nil }
guard attType(&scanner) else { return nil }
guard scanner.requiredSpace() else { return nil }
guard let value = defaultDecl(&scanner) else { return nil }
if let value { defaults.append(value) }
}
return defaults
}
private static func attType(_ scanner: inout AttListScanner) -> Bool {
if scanner.peek() == "(" {
return scanner.nameGroup(nmtokens: true)
}
guard let keyword = scanner.keyword() else { return false }
if tokenizedTypes.contains(keyword) { return true }
if keyword == "NOTATION" {
guard scanner.requiredSpace() else { return false }
return scanner.nameGroup(nmtokens: false)
}
return false
}
/// nil = malformed; .some(nil) = #REQUIRED/#IMPLIED; .some(value) = a
/// (possibly #FIXED) quoted default.
private static func defaultDecl(_ scanner: inout AttListScanner) -> String?? {
if scanner.consumeLiteral("#REQUIRED") || scanner.consumeLiteral("#IMPLIED") {
return .some(nil)
}
if scanner.consumeLiteral("#FIXED") {
guard scanner.requiredSpace() else { return nil }
}
guard let value = scanner.quotedValue() else { return nil }
return .some(value)
}
}
}
/// A tiny scanner over one attribute-list body.
private struct AttListScanner {
private let characters: [Character]
private var index = 0
init(_ text: String) {
characters = Array(text)
}
var isAtEnd: Bool {
index >= characters.count
}
func peek() -> Character? {
index < characters.count ? characters[index] : nil
}
/// Consumes at least one whitespace character.
mutating func requiredSpace() -> Bool {
let start = index
while let character = peek(), character.isWhitespace {
index += 1
}
return index > start
}
mutating func name() -> Bool {
guard let first = peek(), first.unicodeScalars.allSatisfy(PureXML.Parsing.XMLCharacter.isNameStart) else {
return false
}
index += 1
while let next = peek(), next.unicodeScalars.allSatisfy(PureXML.Parsing.XMLCharacter.isNameChar) {
index += 1
}
return true
}
/// An NMTOKEN: one or more name characters (the start may be any name char).
private mutating func nmtoken() -> Bool {
let start = index
while let next = peek(), next.unicodeScalars.allSatisfy(PureXML.Parsing.XMLCharacter.isNameChar) {
index += 1
}
return index > start
}
/// An uppercase keyword run (`CDATA`, `NOTATION`, ...).
mutating func keyword() -> String? {
let start = index
while let next = peek(), next.isLetter {
index += 1
}
guard index > start else { return nil }
return String(characters[start ..< index])
}
/// `'(' S? token (S? '|' S? token)* S? ')'` with names or nmtokens.
mutating func nameGroup(nmtokens: Bool) -> Bool {
guard consume("(") else { return false }
skipSpace()
guard nmtokens ? nmtoken() : name() else { return false }
skipSpace()
while !consume(")") {
guard consume("|") else { return false }
skipSpace()
guard nmtokens ? nmtoken() : name() else { return false }
skipSpace()
}
return true
}
mutating func quotedValue() -> String? {
guard let quote = peek(), quote == "\"" || quote == "'" else { return nil }
index += 1
var value = ""
while let next = peek(), next != quote {
value.append(next)
index += 1
}
return consume(quote) ? value : nil
}
mutating func consumeLiteral(_ literal: String) -> Bool {
let count = literal.count
guard index + count <= characters.count,
String(characters[index ..< index + count]) == literal
else { return false }
index += count
return true
}
private mutating func consume(_ character: Character) -> Bool {
if peek() == character {
index += 1
return true
}
return false
}
private mutating func skipSpace() {
while let character = peek(), character.isWhitespace {
index += 1
}
}
}