/// The strict XML 1.0 grammar for `` declarations, external /// identifiers, and public-identifier literals, split from the scanner body to /// keep it under the length caps. The scan is one well-formedness gate: any /// deviation throws a located `ParseError`. extension DTDScanner { mutating func scanEntityDeclaration(_ reader: inout Reader) throws { let mark = reader.mark reader.consume("'`. private mutating func scanInternalEntityTail(_ reader: inout Reader, name: String, value: String, isParameter: Bool, at mark: Mark) throws { try validateEntityLiteral(value, at: mark) reader.skipSpace() guard reader.peek() == ">" else { throw ParseError.invalidEntityDeclaration(mark) } skip(&reader, until: ">") // The replacement-text well-formedness constraint binds at reference // time (an unreferenced entity may carry a bad value), so the reparse // happens in EntityDecoder when the entity is first included. storeEntity(name: name, value: expandParameterReferences(value), isParameter: isParameter) } /// The tail of an external entity: the identifier, an optional `S NDATA Name` /// (general entities only), then `S? '>'`. private mutating func scanExternalEntityTail(_ reader: inout Reader, name: String, isParameter: Bool, at mark: Mark) throws { guard let id = try parseStrictExternalID(&reader, requireSystem: true, at: mark) else { throw ParseError.invalidEntityDeclaration(mark) } var notation: String? if reader.peek()?.isWhitespace == true { reader.skipSpace() if reader.consume("NDATA") { // NDATA is for unparsed general entities only. guard !isParameter else { throw ParseError.invalidEntityDeclaration(mark) } notation = notationName(&reader) } } else if reader.peek() != ">" { throw ParseError.invalidEntityDeclaration(mark) } reader.skipSpace() guard reader.peek() == ">" else { throw ParseError.invalidEntityDeclaration(mark) } skip(&reader, until: ">") storeExternalEntity(name: name, id: id, isParameter: isParameter, notation: notation) } /// Validates an entity value literal: every character must be an XML Char, /// and every `&` must begin a complete reference (`&name;` or a character /// reference); a bare ampersand is not well-formed. func validateEntityLiteral(_ value: String, at mark: Mark) throws { let characters = Array(value) var index = 0 while index < characters.count { let character = characters[index] guard character.unicodeScalars.allSatisfy(PureXML.Parsing.XMLCharacter.isChar) else { throw ParseError.invalidCharacter(mark) } if character == "&" { var probe = index + 1 if probe < characters.count, characters[probe] == "#" { probe += 1 } let bodyStart = probe while probe < characters.count, characters[probe] != ";", !characters[probe].isWhitespace, characters[probe] != "&" { probe += 1 } guard probe > bodyStart, probe < characters.count, characters[probe] == ";" else { throw ParseError.invalidReference("&", mark) } index = probe } index += 1 } } /// Parses an external identifier strictly: `SYSTEM S literal`, or /// `PUBLIC S pubid-literal S system-literal` (the system literal is required /// when `requireSystem` is true, as for entities and the DOCTYPE itself). /// Public identifiers are checked against the `PubidChar` set. func parseStrictExternalID(_ reader: inout Reader, requireSystem: Bool, at mark: Mark) throws -> ExternalID? { if reader.consume("SYSTEM") { guard reader.peek()?.isWhitespace == true else { throw ParseError.invalidEntityDeclaration(mark) } reader.skipSpace() guard let systemID = scanLiteral(&reader) else { throw ParseError.invalidEntityDeclaration(mark) } return ExternalID(systemID: systemID) } if reader.consume("PUBLIC") { return try parsePublicID(&reader, requireSystem: requireSystem, at: mark) } return nil } /// `PUBLIC S PubidLiteral (S SystemLiteral)` with the system literal /// required for entities and the DOCTYPE, optional for notations. private func parsePublicID(_ reader: inout Reader, requireSystem: Bool, at mark: Mark) throws -> ExternalID { guard reader.peek()?.isWhitespace == true else { throw ParseError.invalidEntityDeclaration(mark) } reader.skipSpace() guard let publicID = scanLiteral(&reader) else { throw ParseError.invalidEntityDeclaration(mark) } try validatePublicID(publicID, at: mark) if requireSystem { guard reader.peek()?.isWhitespace == true else { throw ParseError.invalidEntityDeclaration(mark) } reader.skipSpace() guard let systemID = scanLiteral(&reader) else { throw ParseError.invalidEntityDeclaration(mark) } return ExternalID(publicID: publicID, systemID: systemID) } // Notations may carry a public identifier alone. var systemID = "" if reader.peek()?.isWhitespace == true { reader.skipSpace() if let literal = scanLiteral(&reader) { systemID = literal } } return ExternalID(publicID: publicID, systemID: systemID) } /// `PubidChar ::= #x20 | #xD | #xA | [a-zA-Z0-9] | [-'()+,./:=?;!*#@$_%]` func validatePublicID(_ publicID: String, at mark: Mark) throws { let allowed = Set("-'()+,./:=?;!*#@$_%") for character in publicID { let valid = character == " " || character == "\r" || character == "\n" || (character.isASCII && (character.isLetter || character.isNumber)) || allowed.contains(character) guard valid else { throw ParseError.invalidPublicIdentifier(mark) } } } /// A default attribute value may reference only general entities that are /// already declared and internal: an undeclared, forward-declared, external, /// or unparsed entity in a default is not well-formed, and the referenced /// chain must not recurse. func validateDefaultValueReferences(_ value: String, at mark: Mark) throws { try walkDefaultReferences(value, visiting: [], at: mark) } func walkDefaultReferences(_ value: String, visiting: Set, at mark: Mark) throws { let predefined: Set = ["amp", "lt", "gt", "quot", "apos"] let characters = Array(value) var index = 0 while index < characters.count { guard characters[index] == "&" else { index += 1 continue } var probe = index + 1 if probe < characters.count, characters[probe] == "#" { while probe < characters.count, characters[probe] != ";" { probe += 1 } index = probe + 1 continue } var name = "" while probe < characters.count, characters[probe] != ";" { name.append(characters[probe]) probe += 1 } index = probe + 1 guard !predefined.contains(name) else { continue } guard !visiting.contains(name) else { throw ParseError.recursiveEntity(name: name, mark) } guard doctype.unparsedEntities[name] == nil, doctype.externalEntities[name] == nil else { throw ParseError.invalidAttributeListDeclaration(mark) } guard let replacement = doctype.entities[name] else { throw ParseError.undefinedEntity(name: name, mark) } try walkDefaultReferences(replacement, visiting: visiting.union([name]), at: mark) } } }