extension PureYAML.Parsing.Parser { func scalarStyle(_ text: String) -> PureYAML.Parsing.ScalarStyle { if text.hasPrefix("\"") { return .doubleQuoted } if text.hasPrefix("'") { return .singleQuoted } return .plain } func parseScalar( _ text: String, line: Int, ) throws -> PureYAML.Model.Value { let value = trim(text) switch value { case "", "~", "null", "Null", "NULL": return .null default: break } if let bool = parseBool(value) { return .bool(bool) } if value.hasPrefix("\"") { return try .string(parseDoubleQuoted(value, line: line)) } if value.hasPrefix("'") { return try .string(parseSingleQuoted(value, line: line)) } if let int = parseInteger(value), !value.contains(".") { return .int(int) } if value.contains(".") || value.contains("e") || value.contains("E") { if let double = parseDouble(value) { return .double(double) } } return .string(value) } func parseBool(_ text: String) -> Bool? { switch text { case "true", "True", "TRUE", "yes", "Yes", "YES", "on", "On", "ON": true case "false", "False", "FALSE", "no", "No", "NO", "off", "Off", "OFF": false default: nil } } func parseInteger(_ text: String) -> Int? { let value = removingNumericSeparators(from: text) let negative = value.hasPrefix("-") let hasSign = negative || value.hasPrefix("+") let unsigned = hasSign ? String(value.dropFirst()) : value guard !unsigned.isEmpty else { return nil } guard unsigned != "0" else { return 0 } let radixPrefixes: [(prefix: String, radix: Int)] = [ ("0x", 16), ("0X", 16), ("0b", 2), ("0B", 2), ("0o", 8), ("0O", 8), ("0", 8), ] for radixPrefix in radixPrefixes where unsigned.hasPrefix(radixPrefix.prefix) { let digits = String(unsigned.dropFirst(radixPrefix.prefix.count)) guard !digits.isEmpty, let magnitude = Int(digits, radix: radixPrefix.radix) else { return nil } return negative ? -magnitude : magnitude } return Int(value) } func parseDouble(_ text: String) -> Double? { switch text { case ".inf", ".Inf", ".INF", "+.inf", "+.Inf", "+.INF": .infinity case "-.inf", "-.Inf", "-.INF": -.infinity case ".nan", ".NaN", ".NAN", "+.nan", "+.NaN", "+.NAN", "-.nan", "-.NaN", "-.NAN": .nan default: Double(removingNumericSeparators(from: text)) } } func removingNumericSeparators(from text: String) -> String { text.filter { $0 != "_" } } func parseSingleQuoted( _ text: String, line: Int, ) throws -> String { guard text.count >= 2, text.last == "'" else { throw PureYAML.Parsing.ParseError.unterminatedQuotedString(line: line) } let inner = Array(text.dropFirst().dropLast()) return foldFlowScalar(inner, single: true) } func parseDoubleQuoted( _ text: String, line: Int, ) throws -> String { guard text.count >= 2, text.last == "\"" else { throw PureYAML.Parsing.ParseError.unterminatedQuotedString(line: line) } let inner = Array(text.dropFirst().dropLast()) return foldFlowScalar(inner, single: false) } /// Flow (quoted) scalar line folding, mirroring libyaml's /// yaml_parser_scan_flow_scalar (single and double quoted). Trailing /// whitespace before a break is dropped, leading whitespace on a /// continuation line is dropped, a single break between non-empty lines /// folds to one space, and N consecutive breaks yield N-1 line feeds. /// For double quoted scalars a backslash at end of line suppresses the /// break entirely. func foldFlowScalar( _ inner: [Character], single: Bool, ) -> String { var state = FlowFoldState() let count = inner.count while state.index < count { state.leadingBlanks = false consumeFlowContent(inner, single: single, state: &state) consumeFlowBlanks(inner, state: &state) joinFlowFold(state: &state) } return state.output } /// Mutable accumulators for flow scalar folding, matching the C reference's /// string / leading_break / trailing_breaks / whitespaces buffers. struct FlowFoldState { var output = "" var whitespaces = "" var leadingBreak = "" var trailingBreaks = "" var leadingBlanks = false var index = 0 } /// Consume the run of non-blank characters at `state.index`, decoding /// escapes. A double quoted backslash at end of line sets `leadingBlanks` /// and stops, so the following break is suppressed during folding. func consumeFlowContent( _ inner: [Character], single: Bool, state: inout FlowFoldState, ) { let count = inner.count while state.index < count, !isFlowBlank(inner[state.index]), !isFlowBreak(inner[state.index]) { if single, inner[state.index] == "'" { state.output.append("'") let isEscapedQuote = state.index + 1 < count && inner[state.index + 1] == "'" state.index += isEscapedQuote ? 2 : 1 continue } if !single, inner[state.index] == "\\" { if state.index + 1 < count, isFlowBreak(inner[state.index + 1]) { state.index += 2 state.leadingBlanks = true break } state.index += 1 appendDoubleQuotedEscape(inner, index: &state.index, to: &state.output) continue } state.output.append(inner[state.index]) state.index += 1 } } /// Consume the run of blanks and line breaks at `state.index`, sorting them /// into the whitespace / leading-break / trailing-break buffers. func consumeFlowBlanks( _ inner: [Character], state: inout FlowFoldState, ) { let count = inner.count while state.index < count, isFlowBlank(inner[state.index]) || isFlowBreak(inner[state.index]) { if isFlowBlank(inner[state.index]) { if !state.leadingBlanks { state.whitespaces.append(inner[state.index]) } } else if !state.leadingBlanks { state.whitespaces = "" state.leadingBreak = "\n" state.leadingBlanks = true } else { state.trailingBreaks.append("\n") } state.index += 1 } } /// Join the captured whitespace or fold the captured line breaks into the /// output, per YAML 1.2 flow folding. func joinFlowFold(state: inout FlowFoldState) { guard state.leadingBlanks else { state.output.append(state.whitespaces) state.whitespaces = "" return } if state.leadingBreak.first == "\n" { if state.trailingBreaks.isEmpty { state.output.append(" ") } else { state.output.append(state.trailingBreaks) state.trailingBreaks = "" } state.leadingBreak = "" } else { state.output.append(state.leadingBreak) state.output.append(state.trailingBreaks) state.leadingBreak = "" state.trailingBreaks = "" } } func isFlowBlank(_ character: Character) -> Bool { character == " " || character == "\t" } func isFlowBreak(_ character: Character) -> Bool { character == "\n" || character == "\r" || character == "\r\n" } /// Decode a double quoted escape. On entry index points at the escape /// character (the position just after the backslash). On return index has /// advanced past every character the escape consumed. The escape set /// mirrors libyaml's yaml_parser_scan_flow_scalar. func appendDoubleQuotedEscape( _ text: [Character], index: inout Int, to output: inout String, ) { guard index < text.count else { output.append("\\") return } let character = text[index] if let simple = Self.simpleDoubleQuotedEscapes[character] { output.append(simple) index += 1 return } switch character { case "x": index += 1 appendHexEscape(text, index: &index, digits: 2, marker: "x", to: &output) case "u": index += 1 appendUnicodeEscape(text, index: &index, to: &output) case "U": index += 1 appendHexEscape(text, index: &index, digits: 8, marker: "U", to: &output) default: output.append(character) index += 1 } } /// Single character double quoted escapes, matching libyaml's escape table. static let simpleDoubleQuotedEscapes: [Character: Character] = [ "0": "\u{00}", "a": "\u{07}", "b": "\u{08}", "t": "\t", "\t": "\t", "n": "\n", "v": "\u{0B}", "f": "\u{0C}", "r": "\r", "e": "\u{1B}", " ": " ", "\"": "\"", "/": "/", "\\": "\\", "N": "\u{85}", "_": "\u{A0}", "L": "\u{2028}", "P": "\u{2029}", ] /// Decode \xXX or \UXXXXXXXX. On entry index points at the first hex digit. func appendHexEscape( _ text: [Character], index: inout Int, digits: Int, marker: Character, to output: inout String, ) { guard let value = readHex(text, index: &index, digits: digits) else { output.append(marker) return } if let scalar = UnicodeScalar(value) { output.unicodeScalars.append(scalar) } else { output.append(marker) } } /// Decode \uXXXX, including surrogate pairs. On entry index points at the /// first hex digit. func appendUnicodeEscape( _ text: [Character], index: inout Int, to output: inout String, ) { let start = index guard let codeUnit = readHex(text, index: &index, digits: 4) else { output.append("u") index = start return } if isHighSurrogate(codeUnit), let scalar = readSurrogatePair(high: codeUnit, text: text, index: &index) { output.unicodeScalars.append(scalar) } else if let scalar = UnicodeScalar(codeUnit) { output.unicodeScalars.append(scalar) } else { output.append("u") } } func readSurrogatePair( high: UInt32, text: [Character], index: inout Int, ) -> UnicodeScalar? { var probe = index guard probe + 1 < text.count, text[probe] == "\\", text[probe + 1] == "u" else { return nil } probe += 2 guard let low = readHex(text, index: &probe, digits: 4), isLowSurrogate(low) else { return nil } index = probe let value = 0x10000 + ((high - 0xD800) << 10) + (low - 0xDC00) return UnicodeScalar(value) } /// Read exactly `digits` hex characters starting at index. On success index /// advances past them, otherwise index is left unchanged. func readHex( _ text: [Character], index: inout Int, digits: Int, ) -> UInt32? { guard index + digits <= text.count else { return nil } var value: UInt32 = 0 for offset in 0 ..< digits { guard let digit = text[index + offset].hexDigitValue else { return nil } value = (value << 4) + UInt32(digit) } index += digits return value } func isHighSurrogate(_ value: UInt32) -> Bool { (0xD800 ... 0xDBFF).contains(value) } func isLowSurrogate(_ value: UInt32) -> Bool { (0xDC00 ... 0xDFFF).contains(value) } }