Mihaela M
d4ba594012
Port the located value tree onto the hand-rolled engine, reusing the
engine-agnostic located layer (Model.LocatedValue, LocatedPair,
SourcePosition, SourceRange, and the located composer helper) authored
on the conformance branch. The streaming composer now builds a parallel
located tree behind an opt-in tracksLocations flag, exposed as
parseLocated / parseStreamLocated; the plain Value path stays
byte-identical, gated behind the flag.
The scalar event carries the scanner token's end mark, so a located
scalar spans the whole token (end exclusive, one past the last
character) rather than being start-anchored. The hand-rolled scanner
already tracked token end marks, so this surfaces information the engine
was already computing.
Also stop emitting a spurious null document for a comment-only or empty
stream: YAML 1.2 gives such a stream zero documents, while the
single-document value API still maps it to null, so parse("") is
unchanged.
A whole-suite test proves the located projection equals a plain parse
for every passing case; the value, event-dump, and conformance suites
stay green (507 tests).
104 lines
3.3 KiB
Swift
104 lines
3.3 KiB
Swift
extension PureYAML.Parsing {
|
|
enum Event: Equatable, CustomStringConvertible {
|
|
case streamStart(mark: Mark)
|
|
case streamEnd(mark: Mark)
|
|
case documentStart(mark: Mark)
|
|
case documentEnd(mark: Mark)
|
|
case sequenceStart(anchor: String?, tag: String?, style: CollectionStyle, mark: Mark)
|
|
case sequenceEnd(mark: Mark)
|
|
case mappingStart(anchor: String?, tag: String?, style: CollectionStyle, mark: Mark)
|
|
case mappingEnd(mark: Mark)
|
|
case scalar(value: String, anchor: String?, tag: String?, style: ScalarStyle, mark: Mark, endMark: Mark)
|
|
case alias(anchor: String, mark: Mark)
|
|
|
|
var description: String {
|
|
switch self {
|
|
case let .streamStart(mark):
|
|
"streamStart @\(mark)"
|
|
case let .streamEnd(mark):
|
|
"streamEnd @\(mark)"
|
|
case let .documentStart(mark):
|
|
"documentStart @\(mark)"
|
|
case let .documentEnd(mark):
|
|
"documentEnd @\(mark)"
|
|
case let .sequenceStart(anchor, tag, style, mark):
|
|
"sequenceStart anchor=\(describe(anchor)) tag=\(describe(tag)) style=\(style) @\(mark)"
|
|
case let .sequenceEnd(mark):
|
|
"sequenceEnd @\(mark)"
|
|
case let .mappingStart(anchor, tag, style, mark):
|
|
"mappingStart anchor=\(describe(anchor)) tag=\(describe(tag)) style=\(style) @\(mark)"
|
|
case let .mappingEnd(mark):
|
|
"mappingEnd @\(mark)"
|
|
case let .scalar(value, anchor, tag, style, mark, _):
|
|
"scalar value=\"\(escape(value))\" anchor=\(describe(anchor)) tag=\(describe(tag)) style=\(style) @\(mark)"
|
|
case let .alias(anchor, mark):
|
|
"alias anchor=\(anchor) @\(mark)"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
extension PureYAML.Parsing.Event {
|
|
var isMappingEnd: Bool {
|
|
if case .mappingEnd = self {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
var isSequenceEnd: Bool {
|
|
if case .sequenceEnd = self {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
var isStreamEnd: Bool {
|
|
if case .streamEnd = self {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
var mark: PureYAML.Parsing.Mark {
|
|
switch self {
|
|
case let .alias(_, mark),
|
|
let .documentEnd(mark),
|
|
let .documentStart(mark),
|
|
let .mappingEnd(mark),
|
|
let .mappingStart(_, _, _, mark),
|
|
let .scalar(_, _, _, _, mark, _),
|
|
let .sequenceEnd(mark),
|
|
let .sequenceStart(_, _, _, mark),
|
|
let .streamEnd(mark),
|
|
let .streamStart(mark):
|
|
mark
|
|
}
|
|
}
|
|
|
|
private func describe(_ value: String?) -> String {
|
|
value ?? "-"
|
|
}
|
|
|
|
private func escape(_ value: String) -> String {
|
|
var output = ""
|
|
for character in value {
|
|
switch character {
|
|
case "\\":
|
|
output += "\\\\"
|
|
case "\"":
|
|
output += "\\\""
|
|
case "\n":
|
|
output += "\\n"
|
|
case "\r":
|
|
output += "\\r"
|
|
case "\t":
|
|
output += "\\t"
|
|
default:
|
|
output.append(character)
|
|
}
|
|
}
|
|
return output
|
|
}
|
|
}
|