The %YAML directive takes exactly one parameter, the version, and at most one may appear per document. The scanner checked only that a valid version was present: it ignored any further tokens, so '%YAML 1.2 foo' was accepted, and it did not track that a %YAML directive had already been seen, so a repeated directive was accepted too. It now rejects an extra parameter (allowing only a trailing comment) and a second %YAML directive, resetting the per-document flag at each document boundary. A well-formed directive, with or without a trailing comment, is unaffected. Measured against the official YAML test-suite, parse-level conformance rises from 251/333 (75.4%) to 253/333 (76.0%) with no regression.
110 lines
4.4 KiB
Swift
110 lines
4.4 KiB
Swift
extension PureYAML.Parsing.Scanner {
|
|
func scanDirectiveOrDocumentMarker(_ state: inout State) throws -> Bool {
|
|
guard state.indentation.last == 0 else {
|
|
return false
|
|
}
|
|
if state.reader.peek() == "%" {
|
|
try scanDirective(&state)
|
|
return true
|
|
}
|
|
if state.reader.peek() == "#" {
|
|
return false
|
|
}
|
|
if startsWith("---", state.reader), isIndicatorBoundary(state.reader.peek(offset: 3)) {
|
|
scanDocumentMarker(.documentStart, state: &state)
|
|
resetForDocumentStart(&state)
|
|
return true
|
|
}
|
|
if startsWith("...", state.reader), isIndicatorBoundary(state.reader.peek(offset: 3)) {
|
|
guard !state.isDocumentClosed else {
|
|
throw PureYAML.Parsing.ParseError.unsupportedMultiDocumentStream(line: state.reader.mark.line)
|
|
}
|
|
scanDocumentMarker(.documentEnd, state: &state)
|
|
resetForDocumentEnd(&state)
|
|
return true
|
|
}
|
|
guard !state.isDocumentClosed else {
|
|
throw PureYAML.Parsing.ParseError.unsupportedMultiDocumentStream(line: state.reader.mark.line)
|
|
}
|
|
return false
|
|
}
|
|
|
|
func scanDocumentMarker(
|
|
_ kind: PureYAML.Parsing.TokenKind,
|
|
state: inout State,
|
|
) {
|
|
let start = state.reader.mark
|
|
state.reader.advance()
|
|
state.reader.advance()
|
|
state.reader.advance()
|
|
state.append(kind, mark: start, endMark: state.reader.mark)
|
|
// The document's root node may begin on the marker's own line (e.g. `--- >`, `--- foo`,
|
|
// `--- {a: 1}`, `--- !!str x`). After a document start, skip only the spaces and leave any
|
|
// real content for the main loop to scan; an empty rest-of-line or a comment is consumed.
|
|
// A document end (`...`) takes no same-line node, so its line is always skipped.
|
|
if case .documentStart = kind {
|
|
while state.reader.peek() == " " {
|
|
state.reader.advance()
|
|
}
|
|
if let next = state.reader.peek(), !isLineBreak(next), next != "#" {
|
|
state.isAtLineStart = false
|
|
return
|
|
}
|
|
}
|
|
skipLine(&state)
|
|
}
|
|
|
|
func resetForDocumentStart(_ state: inout State) {
|
|
state.hasDocumentContent = false
|
|
state.hasDocumentStartMarker = true
|
|
state.isDocumentClosed = false
|
|
state.hasYAMLDirective = false
|
|
}
|
|
|
|
func resetForDocumentEnd(_ state: inout State) {
|
|
state.hasDocumentContent = false
|
|
state.hasDocumentStartMarker = false
|
|
state.isDocumentClosed = true
|
|
state.hasYAMLDirective = false
|
|
}
|
|
|
|
func scanDirective(_ state: inout State) throws {
|
|
let start = state.reader.mark
|
|
let line = state.reader.consume { character in
|
|
!isLineBreak(character)
|
|
}
|
|
let parts = line.split(separator: " ").map(String.init)
|
|
guard let name = parts.first else {
|
|
return
|
|
}
|
|
guard !state.hasDocumentContent, !state.hasDocumentStartMarker, !state.isDocumentClosed else {
|
|
throw PureYAML.Parsing.ParseError.unsupportedDirective(name: name, line: start.line)
|
|
}
|
|
switch name {
|
|
case "%YAML":
|
|
guard parts.indices.contains(1), parts[1] == "1.1" || parts[1] == "1.2" else {
|
|
throw PureYAML.Parsing.ParseError.incompatibleYAMLDirective(line: start.line)
|
|
}
|
|
// `%YAML` takes exactly one parameter, the version; only a comment may follow it.
|
|
guard parts.count == 2 || parts[2].hasPrefix("#") else {
|
|
throw PureYAML.Parsing.ParseError.malformedDirective(name: name, line: start.line)
|
|
}
|
|
// At most one `%YAML` directive is allowed per document.
|
|
guard !state.hasYAMLDirective else {
|
|
throw PureYAML.Parsing.ParseError.duplicateDirective(name: name, line: start.line)
|
|
}
|
|
state.hasYAMLDirective = true
|
|
case "%TAG":
|
|
guard parts.count >= 3 else {
|
|
return
|
|
}
|
|
state.tagHandles[parts[1]] = parts[2]
|
|
default:
|
|
// A YAML processor ignores a directive it does not recognize (the spec calls for a
|
|
// warning and otherwise no effect), rather than rejecting the document. The line has
|
|
// already been consumed, so there is nothing more to do.
|
|
return
|
|
}
|
|
}
|
|
}
|