0001    // JSONParser.swift
0002    //
0003    // The MIT License (MIT)
0004    //
0005    // Copyright (c) 2015 Zewo
0006    //
0007    // Permission is hereby granted, free of charge, to any person obtaining a copy
0008    // of this software and associated documentation files (the "Software"), to deal
0009    // in the Software without restriction, including without limitation the rights
0010    // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
0011    // copies of the Software, and to permit persons to whom the Software is
0012    // furnished to do so, subject to the following conditions:
0013    //
0014    // The above copyright notice and this permission notice shall be included in all
0015    // copies or substantial portions of the Software.
0016    //
0017    // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
0018    // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
0019    // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
0020    // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
0021    // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
0022    // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
0023    // SOFTWARE.
0024    //
0025    // This file has been modified from its original project Swift-JsonSerializer
0026    
0027    #if os(Linux)
0028        import Glibc
0029    #else
0030        import Darwin.C
0031    #endif
0032    
0033    public struct JSONParser {
0034        public static func parse(source: String) throws -> JSON {
0035            return try GenericJSONParser(source.utf8).parse()
0036        }
0037    
0038        public static func parse
JSONParser.swift:43
        return try parse(source.map({UInt8(bitPattern: $0)}))
(source: [UInt8]) throws -> JSON {
0039            return try GenericJSONParser(source).parse()
0040        }
0041    
0042        public static func parse(source: [Int8]) throws -> JSON {
0043            return try parse(source.map({UInt8(bitPattern: $0)}))
0044        }
0045    }
0046    
0047    public class GenericJSONParser
JSONParser.swift:35
        return try GenericJSONParser(source.utf8).parse()
JSONParser.swift:39
        return try GenericJSONParser(source).parse()
JSONParser.swift:81
extension GenericJSONParser {
<ByteSequence
JSONParser.swift:48
    public typealias Source = ByteSequence
: CollectionType where ByteSequence.Generator.Element == UInt8> {
0048        public typealias Source
JSONParser.swift:49
    typealias Char = Source.Generator.Element
JSONParser.swift:51
    let source: Source
JSONParser.swift:52
    var cur: Source.Index
JSONParser.swift:53
    let end: Source.Index
JSONParser.swift:58
    public init(_ source: Source) {
 = ByteSequence
0049        typealias Char
JSONParser.swift:93
        case Char(ascii: "n"): return try parseSymbol("null", JSON.NullValue)
JSONParser.swift:94
        case Char(ascii: "t"): return try parseSymbol("true", JSON.BooleanValue(true))
JSONParser.swift:95
        case Char(ascii: "f"): return try parseSymbol("false", JSON.BooleanValue(false))
JSONParser.swift:96
        case Char(ascii: "-"), Char(ascii: "0") ... Char(ascii: "9"): return try parseNumber()
JSONParser.swift:96
        case Char(ascii: "-"), Char(ascii: "0") ... Char(ascii: "9"): return try parseNumber()
JSONParser.swift:96
        case Char(ascii: "-"), Char(ascii: "0") ... Char(ascii: "9"): return try parseNumber()
JSONParser.swift:97
        case Char(ascii: "\""): return try parseString()
JSONParser.swift:98
        case Char(ascii: "{"): return try parseObject()
JSONParser.swift:99
        case Char(ascii: "["): return try parseArray()
JSONParser.swift:108
    private var currentChar: Char {
JSONParser.swift:112
    private var nextChar: Char {
JSONParser.swift:133
        assert(currentChar == Char(ascii: "\""), "points a double quote")
JSONParser.swift:139
            case Char(ascii: "\\"):
JSONParser.swift:160
            case Char(ascii: "\""): break LOOP
JSONParser.swift:213
        case Char(ascii: "0"): advance()
JSONParser.swift:214
        case Char(ascii: "1") ... Char(ascii: "9"):
JSONParser.swift:214
        case Char(ascii: "1") ... Char(ascii: "9"):
JSONParser.swift:302
        assert(currentChar == Char(ascii: "{"), "points \"{\"")
JSONParser.swift:351
        assert(currentChar == Char(ascii: "["), "points \"[\"")
JSONParser.swift:415
    private func isIdentifier(char: Char) -> Bool {
JSONParser.swift:417
        case Char(ascii: "a") ... Char(ascii: "z"):
JSONParser.swift:417
        case Char(ascii: "a") ... Char(ascii: "z"):
JSONParser.swift:431
            case Char(ascii: "\n"):
JSONParser.swift:444
            case Char(ascii: " "), Char(ascii: "\t"), Char(ascii: "\r"), Char(ascii: "\n"):
JSONParser.swift:444
            case Char(ascii: " "), Char(ascii: "\t"), Char(ascii: "\r"), Char(ascii: "\n"):
JSONParser.swift:444
            case Char(ascii: " "), Char(ascii: "\t"), Char(ascii: "\r"), Char(ascii: "\n"):
JSONParser.swift:444
            case Char(ascii: " "), Char(ascii: "\t"), Char(ascii: "\r"), Char(ascii: "\n"):
 = Source.Generator.Element
0050    
0051        let source
JSONParser.swift:59
        self.source = source
JSONParser.swift:109
        return source[cur]
JSONParser.swift:113
        return source[cur.successor()]
: Source
0052        var cur
JSONParser.swift:60
        self.cur = source.startIndex
JSONParser.swift:67
        if (cur == end) {
JSONParser.swift:84
        if cur == end {
JSONParser.swift:109
        return source[cur]
JSONParser.swift:113
        return source[cur.successor()]
JSONParser.swift:137
        LOOP: while cur != end {
JSONParser.swift:141
                if (cur == end) {
JSONParser.swift:215
            while cur != end {
JSONParser.swift:245
            while cur != end {
JSONParser.swift:277
            while cur != end {
JSONParser.swift:307
        LOOP: while cur != end && !expect("}") {
JSONParser.swift:357
        LOOP: while cur != end && !expect("]") {
JSONParser.swift:380
        if cur == end {
JSONParser.swift:393
        let start = cur
JSONParser.swift:402
                cur = start
JSONParser.swift:425
        assert(cur != end, "out of range")
JSONParser.swift:426
        cur++
JSONParser.swift:428
        if cur != end {
JSONParser.swift:442
        while cur != end {
: Source.Index
0053        let end
JSONParser.swift:61
        self.end = source.endIndex
JSONParser.swift:67
        if (cur == end) {
JSONParser.swift:84
        if cur == end {
JSONParser.swift:137
        LOOP: while cur != end {
JSONParser.swift:141
                if (cur == end) {
JSONParser.swift:215
            while cur != end {
JSONParser.swift:245
            while cur != end {
JSONParser.swift:277
            while cur != end {
JSONParser.swift:307
        LOOP: while cur != end && !expect("}") {
JSONParser.swift:357
        LOOP: while cur != end && !expect("]") {
JSONParser.swift:380
        if cur == end {
JSONParser.swift:425
        assert(cur != end, "out of range")
JSONParser.swift:428
        if cur != end {
JSONParser.swift:442
        while cur != end {
: Source.Index
0054    
0055        public var lineNumber
JSONParser.swift:72
                lineNumber: lineNumber,
JSONParser.swift:87
                lineNumber: lineNumber,
JSONParser.swift:102
            lineNumber: lineNumber,
JSONParser.swift:126
                lineNumber: lineNumber,
JSONParser.swift:144
                        lineNumber: lineNumber,
JSONParser.swift:156
                        lineNumber: lineNumber,
JSONParser.swift:169
                lineNumber: lineNumber,
JSONParser.swift:226
                lineNumber: lineNumber,
JSONParser.swift:234
                lineNumber: lineNumber,
JSONParser.swift:259
                    lineNumber: lineNumber,
JSONParser.swift:290
                    lineNumber: lineNumber,
JSONParser.swift:317
                        lineNumber: lineNumber,
JSONParser.swift:334
                        lineNumber: lineNumber,
JSONParser.swift:341
                    lineNumber: lineNumber,
JSONParser.swift:369
                    lineNumber: lineNumber,
JSONParser.swift:394
        let l = lineNumber
JSONParser.swift:403
                lineNumber = l
JSONParser.swift:432
                lineNumber++
 = 1
0056        public var columnNumber
JSONParser.swift:73
                columnNumber: columnNumber
JSONParser.swift:88
                columnNumber: columnNumber
JSONParser.swift:103
            columnNumber: columnNumber
JSONParser.swift:127
                columnNumber: columnNumber
JSONParser.swift:145
                        columnNumber: columnNumber
JSONParser.swift:157
                        columnNumber: columnNumber
JSONParser.swift:170
                columnNumber: columnNumber
JSONParser.swift:227
                columnNumber: columnNumber
JSONParser.swift:235
                columnNumber: columnNumber
JSONParser.swift:260
                    columnNumber: columnNumber
JSONParser.swift:291
                    columnNumber: columnNumber
JSONParser.swift:318
                        columnNumber: columnNumber
JSONParser.swift:335
                        columnNumber: columnNumber
JSONParser.swift:342
                    columnNumber: columnNumber
JSONParser.swift:370
                    columnNumber: columnNumber
JSONParser.swift:395
        let c = columnNumber
JSONParser.swift:404
                columnNumber = c
JSONParser.swift:433
                columnNumber = 1
JSONParser.swift:436
                columnNumber++
 = 1
0057    
0058        public init
JSONParser.swift:35
        return try GenericJSONParser(source.utf8).parse()
JSONParser.swift:39
        return try GenericJSONParser(source).parse()
(_ source: Source) {
0059            self.source = source
0060            self.cur = source.startIndex
0061            self.end = source.endIndex
0062        }
0063    
0064        public func parse
JSONParser.swift:35
        return try GenericJSONParser(source.utf8).parse()
JSONParser.swift:39
        return try GenericJSONParser(source).parse()
() throws -> JSON {
0065            let JSON = try parseValue()
0066            skipWhitespaces()
0067            if (cur == end) {
0068                return JSON
0069            } else {
0070                throw JSONParseError.ExtraTokenError(
0071                    reason: "extra tokens found",
0072                    lineNumber: lineNumber,
0073                    columnNumber: columnNumber
0074                )
0075            }
0076        }
0077    }
0078    
0079    // MARK: - Private
0080    
0081    extension GenericJSONParser {
0082        private func parseValue
JSONParser.swift:65
        let JSON = try parseValue()
JSONParser.swift:308
            let keyValue = try parseValue()
JSONParser.swift:323
                let value = try parseValue()
JSONParser.swift:358
            let JSON = try parseValue()
() throws -> JSON {
0083            skipWhitespaces()
0084            if cur == end {
0085                throw JSONParseError.InsufficientTokenError(
0086                    reason: "unexpected end of tokens",
0087                    lineNumber: lineNumber,
0088                    columnNumber: columnNumber
0089                )
0090            }
0091    
0092            switch currentChar {
0093            case Char(ascii: "n"): return try parseSymbol("null", JSON.NullValue)
0094            case Char(ascii: "t"): return try parseSymbol("true", JSON.BooleanValue(true))
0095            case Char(ascii: "f"): return try parseSymbol("false", JSON.BooleanValue(false))
0096            case Char(ascii: "-"), Char(ascii: "0") ... Char(ascii: "9"): return try parseNumber()
0097            case Char(ascii: "\""): return try parseString()
0098            case Char(ascii: "{"): return try parseObject()
0099            case Char(ascii: "["): return try parseArray()
0100            case (let c): throw JSONParseError.UnexpectedTokenError(
0101                reason: "unexpected token: \(c)",
0102                lineNumber: lineNumber,
0103                columnNumber: columnNumber
0104            )
0105            }
0106        }
0107    
0108        private var currentChar
JSONParser.swift:92
        switch currentChar {
JSONParser.swift:117
        return Character(UnicodeScalar(currentChar))
JSONParser.swift:133
        assert(currentChar == Char(ascii: "\""), "points a double quote")
JSONParser.swift:138
            switch currentChar {
JSONParser.swift:161
            default: buffer.append(CChar(bitPattern: currentChar))
JSONParser.swift:180
        let c = UnicodeScalar(currentChar)
JSONParser.swift:203
            let c = UnicodeScalar(currentChar)
JSONParser.swift:212
        switch currentChar {
JSONParser.swift:216
                if let value = digitToInt(currentChar) {
JSONParser.swift:246
                if let value = digitToInt(currentChar) {
JSONParser.swift:278
                if let value = digitToInt(currentChar) {
JSONParser.swift:302
        assert(currentChar == Char(ascii: "{"), "points \"{\"")
JSONParser.swift:351
        assert(currentChar == Char(ascii: "["), "points \"[\"")
JSONParser.swift:385
            if target.utf8Start.memory == currentChar {
JSONParser.swift:401
            if p.memory != currentChar {
JSONParser.swift:429
            switch currentChar {
JSONParser.swift:443
            switch currentChar {
: Char {
0109            return source[cur]
0110        }
0111    
0112        private var nextChar
JSONParser.swift:186
            while let d = hexToDigit(nextChar) {
: Char {
0113            return source[cur.successor()]
0114        }
0115    
0116        private var currentSymbol
JSONParser.swift:125
                reason: "expected \"\(target)\" but \(currentSymbol)",
JSONParser.swift:368
                    reason: "missing comma (,) (token: \(currentSymbol))",
: Character {
0117            return Character(UnicodeScalar(currentChar))
0118        }
0119    
0120        private func parseSymbol
JSONParser.swift:93
        case Char(ascii: "n"): return try parseSymbol("null", JSON.NullValue)
JSONParser.swift:94
        case Char(ascii: "t"): return try parseSymbol("true", JSON.BooleanValue(true))
JSONParser.swift:95
        case Char(ascii: "f"): return try parseSymbol("false", JSON.BooleanValue(false))
(target: StaticString, @autoclosure _ iftrue: Void -> JSON) throws -> JSON {
0121            if expect(target) {
0122                return iftrue()
0123            } else {
0124                throw JSONParseError.UnexpectedTokenError(
0125                    reason: "expected \"\(target)\" but \(currentSymbol)",
0126                    lineNumber: lineNumber,
0127                    columnNumber: columnNumber
0128                )
0129            }
0130        }
0131    
0132        private func parseString
JSONParser.swift:97
        case Char(ascii: "\""): return try parseString()
() throws -> JSON {
0133            assert(currentChar == Char(ascii: "\""), "points a double quote")
0134            advance()
0135            var buffer: [CChar] = []
0136    
0137            LOOP: while cur != end {
0138                switch currentChar {
0139                case Char(ascii: "\\"):
0140                    advance()
0141                    if (cur == end) {
0142                        throw JSONParseError.InvalidStringError(
0143                            reason: "unexpected end of a string literal",
0144                            lineNumber: lineNumber,
0145                            columnNumber: columnNumber
0146                        )
0147                    }
0148    
0149                    if let c = parseEscapedChar() {
0150                        for u in String(c).utf8 {
0151                            buffer.append(CChar(bitPattern: u))
0152                        }
0153                    } else {
0154                        throw JSONParseError.InvalidStringError(
0155                            reason: "invalid escape sequence",
0156                            lineNumber: lineNumber,
0157                            columnNumber: columnNumber
0158                        )
0159                    }
0160                case Char(ascii: "\""): break LOOP
0161                default: buffer.append(CChar(bitPattern: currentChar))
0162                }
0163                advance()
0164            }
0165    
0166            if !expect("\"") {
0167                throw JSONParseError.InvalidStringError(
0168                    reason: "missing double quote",
0169                    lineNumber: lineNumber,
0170                    columnNumber: columnNumber
0171                )
0172            }
0173    
0174            buffer.append(0)
0175            let s = String.fromCString(buffer)!
0176            return .StringValue(s)
0177        }
0178    
0179        private func parseEscapedChar
JSONParser.swift:149
                if let c = parseEscapedChar() {
() -> UnicodeScalar? {
0180            let c = UnicodeScalar(currentChar)
0181    
0182            if c == "u" {
0183                var length = 0
0184                var value: UInt32 = 0
0185    
0186                while let d = hexToDigit(nextChar) {
0187                    advance()
0188                    length++
0189    
0190                    if length > 8 {
0191                        break
0192                    }
0193    
0194                    value = (value << 4) | d
0195                }
0196    
0197                if length < 2 {
0198                    return nil
0199                }
0200    
0201                return UnicodeScalar(value)
0202            } else {
0203                let c = UnicodeScalar(currentChar)
0204                return unescapeMapping[c] ?? c
0205            }
0206        }
0207    
0208        private func parseNumber
JSONParser.swift:96
        case Char(ascii: "-"), Char(ascii: "0") ... Char(ascii: "9"): return try parseNumber()
() throws -> JSON {
0209            let sign = expect("-") ? -1.0 : 1.0
0210            var integer: Int64 = 0
0211    
0212            switch currentChar {
0213            case Char(ascii: "0"): advance()
0214            case Char(ascii: "1") ... Char(ascii: "9"):
0215                while cur != end {
0216                    if let value = digitToInt(currentChar) {
0217                        integer = (integer * 10) + Int64(value)
0218                    } else {
0219                        break
0220                    }
0221                    advance()
0222                }
0223            default:
0224                throw JSONParseError.InvalidStringError(
0225                    reason: "missing double quote",
0226                    lineNumber: lineNumber,
0227                    columnNumber: columnNumber
0228                )
0229            }
0230    
0231            if integer != Int64(Double(integer)) {
0232                throw JSONParseError.InvalidNumberError(
0233                    reason: "too large number",
0234                    lineNumber: lineNumber,
0235                    columnNumber: columnNumber
0236                )
0237            }
0238    
0239            var fraction: Double = 0.0
0240    
0241            if expect(".") {
0242                var factor = 0.1
0243                var fractionLength = 0
0244    
0245                while cur != end {
0246                    if let value = digitToInt(currentChar) {
0247                        fraction += (Double(value) * factor)
0248                        factor /= 10
0249                        fractionLength++
0250                    } else {
0251                        break
0252                    }
0253                    advance()
0254                }
0255    
0256                if fractionLength == 0 {
0257                    throw JSONParseError.InvalidNumberError(
0258                        reason: "insufficient fraction part in number",
0259                        lineNumber: lineNumber,
0260                        columnNumber: columnNumber
0261                    )
0262                }
0263            }
0264    
0265            var exponent: Int64 = 0
0266    
0267            if expect("e") || expect("E") {
0268                var expSign: Int64 = 1
0269    
0270                if expect("-") {
0271                    expSign = -1
0272                } else if expect("+") {}
0273    
0274                exponent = 0
0275                var exponentLength = 0
0276    
0277                while cur != end {
0278                    if let value = digitToInt(currentChar) {
0279                        exponent = (exponent * 10) + Int64(value)
0280                        exponentLength++
0281                    } else {
0282                        break
0283                    }
0284                    advance()
0285                }
0286    
0287                if exponentLength == 0 {
0288                    throw JSONParseError.InvalidNumberError(
0289                        reason: "insufficient exponent part in number",
0290                        lineNumber: lineNumber,
0291                        columnNumber: columnNumber
0292                    )
0293                }
0294    
0295                exponent *= expSign
0296            }
0297    
0298            return .NumberValue(sign * (Double(integer) + fraction) * pow(10, Double(exponent)))
0299        }
0300    
0301        private func parseObject
JSONParser.swift:98
        case Char(ascii: "{"): return try parseObject()
() throws -> JSON {
0302            assert(currentChar == Char(ascii: "{"), "points \"{\"")
0303            advance()
0304            skipWhitespaces()
0305            var object: [String: JSON] = [:]
0306    
0307            LOOP: while cur != end && !expect("}") {
0308                let keyValue = try parseValue()
0309    
0310                switch keyValue {
0311                case .StringValue(let key):
0312                    skipWhitespaces()
0313    
0314                    if !expect(":") {
0315                        throw JSONParseError.UnexpectedTokenError(
0316                            reason: "missing colon (:)",
0317                            lineNumber: lineNumber,
0318                            columnNumber: columnNumber
0319                        )
0320                    }
0321    
0322                    skipWhitespaces()
0323                    let value = try parseValue()
0324                    object[key] = value
0325                    skipWhitespaces()
0326    
0327                    if expect(",") {
0328                        break
0329                    } else if expect("}") {
0330                        break LOOP
0331                    } else {
0332                        throw JSONParseError.UnexpectedTokenError(
0333                            reason: "missing comma (,)",
0334                            lineNumber: lineNumber,
0335                            columnNumber: columnNumber
0336                        )
0337                    }
0338                default:
0339                    throw JSONParseError.NonStringKeyError(
0340                        reason: "unexpected value for object key",
0341                        lineNumber: lineNumber,
0342                        columnNumber: columnNumber
0343                    )
0344                }
0345            }
0346    
0347            return .ObjectValue(object)
0348        }
0349    
0350        private func parseArray
JSONParser.swift:99
        case Char(ascii: "["): return try parseArray()
() throws -> JSON {
0351            assert(currentChar == Char(ascii: "["), "points \"[\"")
0352            advance()
0353            skipWhitespaces()
0354    
0355            var array: [JSON] = []
0356    
0357            LOOP: while cur != end && !expect("]") {
0358                let JSON = try parseValue()
0359                skipWhitespaces()
0360                array.append(JSON)
0361                
0362                if expect(",") {
0363                    continue
0364                } else if expect("]") {
0365                    break LOOP
0366                } else {
0367                    throw JSONParseError.UnexpectedTokenError(
0368                        reason: "missing comma (,) (token: \(currentSymbol))",
0369                        lineNumber: lineNumber,
0370                        columnNumber: columnNumber
0371                    )
0372                }
0373            }
0374            
0375            return .ArrayValue(array)
0376        }
0377        
0378        
0379        private func expect
JSONParser.swift:121
        if expect(target) {
JSONParser.swift:166
        if !expect("\"") {
JSONParser.swift:209
        let sign = expect("-") ? -1.0 : 1.0
JSONParser.swift:241
        if expect(".") {
JSONParser.swift:267
        if expect("e") || expect("E") {
JSONParser.swift:267
        if expect("e") || expect("E") {
JSONParser.swift:270
            if expect("-") {
JSONParser.swift:272
            } else if expect("+") {}
JSONParser.swift:307
        LOOP: while cur != end && !expect("}") {
JSONParser.swift:314
                if !expect(":") {
JSONParser.swift:327
                if expect(",") {
JSONParser.swift:329
                } else if expect("}") {
JSONParser.swift:357
        LOOP: while cur != end && !expect("]") {
JSONParser.swift:362
            if expect(",") {
JSONParser.swift:364
            } else if expect("]") {
(target: StaticString) -> Bool {
0380            if cur == end {
0381                return false
0382            }
0383            
0384            if !isIdentifier(target.utf8Start.memory) {
0385                if target.utf8Start.memory == currentChar {
0386                    advance()
0387                    return true
0388                } else {
0389                    return false
0390                }
0391            }
0392            
0393            let start = cur
0394            let l = lineNumber
0395            let c = columnNumber
0396            
0397            var p = target.utf8Start
0398            let endp = p.advancedBy(Int(target.byteSize))
0399            
0400            while p != endp {
0401                if p.memory != currentChar {
0402                    cur = start
0403                    lineNumber = l
0404                    columnNumber = c
0405                    return false
0406                }
0407                p += 1
0408                advance()
0409            }
0410            
0411            return true
0412        }
0413        
0414        // only "true", "false", "null" are identifiers
0415        private func isIdentifier
JSONParser.swift:384
        if !isIdentifier(target.utf8Start.memory) {
(char: Char) -> Bool {
0416            switch char {
0417            case Char(ascii: "a") ... Char(ascii: "z"):
0418                return true
0419            default:
0420                return false
0421            }
0422        }
0423        
0424        private func advance
JSONParser.swift:134
        advance()
JSONParser.swift:140
                advance()
JSONParser.swift:163
            advance()
JSONParser.swift:187
                advance()
JSONParser.swift:213
        case Char(ascii: "0"): advance()
JSONParser.swift:221
                advance()
JSONParser.swift:253
                advance()
JSONParser.swift:284
                advance()
JSONParser.swift:303
        advance()
JSONParser.swift:352
        advance()
JSONParser.swift:386
                advance()
JSONParser.swift:408
            advance()
JSONParser.swift:449
            advance()
() {
0425            assert(cur != end, "out of range")
0426            cur++
0427            
0428            if cur != end {
0429                switch currentChar {
0430                    
0431                case Char(ascii: "\n"):
0432                    lineNumber++
0433                    columnNumber = 1
0434                    
0435                default:
0436                    columnNumber++
0437                }
0438            }
0439        }
0440        
0441        private func skipWhitespaces
JSONParser.swift:66
        skipWhitespaces()
JSONParser.swift:83
        skipWhitespaces()
JSONParser.swift:304
        skipWhitespaces()
JSONParser.swift:312
                skipWhitespaces()
JSONParser.swift:322
                skipWhitespaces()
JSONParser.swift:325
                skipWhitespaces()
JSONParser.swift:353
        skipWhitespaces()
JSONParser.swift:359
            skipWhitespaces()
() {
0442            while cur != end {
0443                switch currentChar {
0444                case Char(ascii: " "), Char(ascii: "\t"), Char(ascii: "\r"), Char(ascii: "\n"):
0445                    break
0446                default:
0447                    return
0448                }
0449                advance()
0450            }
0451        }
0452    }
0453    
0454    let unescapeMapping
JSONParser.swift:204
            return unescapeMapping[c] ?? c
: [UnicodeScalar: UnicodeScalar] = [
0455        "t": "\t",
0456        "r": "\r",
0457        "n": "\n"
0458    ]
0459    
0460    let escapeMapping
JSONParser.swift:509
        if let escapedSymbol = escapeMapping[c] {
: [Character: String] = [
0461        "\r": "\\r",
0462        "\n": "\\n",
0463        "\t": "\\t",
0464        "\\": "\\\\",
0465        "\"": "\\\"",
0466    
0467        "\u{2028}": "\\u2028",
0468        "\u{2029}": "\\u2029",
0469    
0470        "\r\n": "\\r\\n"
0471    ]
0472    
0473    let hexMapping
JSONParser.swift:526
    return hexMapping[UnicodeScalar(byte)]
: [UnicodeScalar: UInt32] = [
0474        "0": 0x0,
0475        "1": 0x1,
0476        "2": 0x2,
0477        "3": 0x3,
0478        "4": 0x4,
0479        "5": 0x5,
0480        "6": 0x6,
0481        "7": 0x7,
0482        "8": 0x8,
0483        "9": 0x9,
0484        "a": 0xA, "A": 0xA,
0485        "b": 0xB, "B": 0xB,
0486        "c": 0xC, "C": 0xC,
0487        "d": 0xD, "D": 0xD,
0488        "e": 0xE, "E": 0xE,
0489        "f": 0xF, "F": 0xF
0490    ]
0491    
0492    let digitMapping
JSONParser.swift:522
    return digitMapping[UnicodeScalar(byte)]
: [UnicodeScalar:Int] = [
0493        "0": 0,
0494        "1": 1,
0495        "2": 2,
0496        "3": 3,
0497        "4": 4,
0498        "5": 5,
0499        "6": 6,
0500        "7": 7,
0501        "8": 8,
0502        "9": 9
0503    ]
0504    
0505    public func escapeAsJSONString
JSONSerializer.swift:39
        case .StringValue(let s): return escapeAsJSONString(s)
JSONSerializer.swift:72
            s += "\(escapeAsJSONString(entry.0)):\(entry.1.serialize(self))"
JSONSerializer.swift:114
            s += "\(escapeAsJSONString(key)): \(o[key]!.serialize(self))"
(source : String) -> String {
0506        var s = "\""
0507    
0508        for c in source.characters {
0509            if let escapedSymbol = escapeMapping[c] {
0510                s.appendContentsOf(escapedSymbol)
0511            } else {
0512                s.append(c)
0513            }
0514        }
0515    
0516        s.appendContentsOf("\"")
0517    
0518        return s
0519    }
0520    
0521    func digitToInt
JSONParser.swift:216
                if let value = digitToInt(currentChar) {
JSONParser.swift:246
                if let value = digitToInt(currentChar) {
JSONParser.swift:278
                if let value = digitToInt(currentChar) {
(byte: UInt8) -> Int? {
0522        return digitMapping[UnicodeScalar(byte)]
0523    }
0524    
0525    func hexToDigit
JSONParser.swift:186
            while let d = hexToDigit(nextChar) {
(byte: UInt8) -> UInt32? {
0526        return hexMapping[UnicodeScalar(byte)]
0527    }