0001    //
0002    //  JSONParser.swift
0003    //  Freddy
0004    //
0005    //  Created by John Gallagher on 4/18/15.
0006    //  Copyright © 2015 Big Nerd Ranch. Licensed under MIT.
0007    //
0008    
0009    import Foundation
0010    
0011    private struct LiteralJSONParser.swift:119             case Literal.LEFT_BRACKET:
JSONParser.swift:124             case Literal.LEFT_BRACE:
JSONParser.swift:129             case Literal.DOUBLE_QUOTE:
JSONParser.swift:132             case Literal.f:
JSONParser.swift:135             case Literal.n:
JSONParser.swift:138             case Literal.t:
JSONParser.swift:141             case Literal.MINUS:
JSONParser.swift:144             case Literal.zero:
JSONParser.swift:147             case Literal.one...Literal.nine:
JSONParser.swift:147             case Literal.one...Literal.nine:
JSONParser.swift:150             case Literal.SPACE, Literal.TAB, Literal.RETURN, Literal.NEWLINE:
JSONParser.swift:150             case Literal.SPACE, Literal.TAB, Literal.RETURN, Literal.NEWLINE:
JSONParser.swift:150             case Literal.SPACE, Literal.TAB, Literal.RETURN, Literal.NEWLINE:
JSONParser.swift:150             case Literal.SPACE, Literal.TAB, Literal.RETURN, Literal.NEWLINE:
JSONParser.swift:164             case Literal.SPACE, Literal.TAB, Literal.RETURN, Literal.NEWLINE:
JSONParser.swift:164             case Literal.SPACE, Literal.TAB, Literal.RETURN, Literal.NEWLINE:
JSONParser.swift:164             case Literal.SPACE, Literal.TAB, Literal.RETURN, Literal.NEWLINE:
JSONParser.swift:164             case Literal.SPACE, Literal.TAB, Literal.RETURN, Literal.NEWLINE:
JSONParser.swift:187         if     input[loc+1] != Literal.u
JSONParser.swift:188             || input[loc+2] != Literal.l
JSONParser.swift:189             || input[loc+3] != Literal.l {
JSONParser.swift:202         if     input[loc+1] != Literal.r
JSONParser.swift:203             || input[loc+2] != Literal.u
JSONParser.swift:204             || input[loc+3] != Literal.e {
JSONParser.swift:217         if     input[loc+1] != Literal.a
JSONParser.swift:218             || input[loc+2] != Literal.l
JSONParser.swift:219             || input[loc+3] != Literal.s
JSONParser.swift:220             || input[loc+4] != Literal.e {
JSONParser.swift:235             case Literal.BACKSLASH:
JSONParser.swift:238                 case Literal.DOUBLE_QUOTE: stringDecodingBuffer.append(Literal.DOUBLE_QUOTE)
JSONParser.swift:238                 case Literal.DOUBLE_QUOTE: stringDecodingBuffer.append(Literal.DOUBLE_QUOTE)
JSONParser.swift:239                 case Literal.BACKSLASH:    stringDecodingBuffer.append(Literal.BACKSLASH)
JSONParser.swift:239                 case Literal.BACKSLASH:    stringDecodingBuffer.append(Literal.BACKSLASH)
JSONParser.swift:240                 case Literal.SLASH:        stringDecodingBuffer.append(Literal.SLASH)
JSONParser.swift:240                 case Literal.SLASH:        stringDecodingBuffer.append(Literal.SLASH)
JSONParser.swift:241                 case Literal.b:            stringDecodingBuffer.append(Literal.BACKSPACE)
JSONParser.swift:241                 case Literal.b:            stringDecodingBuffer.append(Literal.BACKSPACE)
JSONParser.swift:242                 case Literal.f:            stringDecodingBuffer.append(Literal.FORMFEED)
JSONParser.swift:242                 case Literal.f:            stringDecodingBuffer.append(Literal.FORMFEED)
JSONParser.swift:243                 case Literal.r:            stringDecodingBuffer.append(Literal.RETURN)
JSONParser.swift:243                 case Literal.r:            stringDecodingBuffer.append(Literal.RETURN)
JSONParser.swift:244                 case Literal.t:            stringDecodingBuffer.append(Literal.TAB)
JSONParser.swift:244                 case Literal.t:            stringDecodingBuffer.append(Literal.TAB)
JSONParser.swift:245                 case Literal.n:            stringDecodingBuffer.append(Literal.NEWLINE)
JSONParser.swift:245                 case Literal.n:            stringDecodingBuffer.append(Literal.NEWLINE)
JSONParser.swift:246                 case Literal.u:
JSONParser.swift:259             case Literal.DOUBLE_QUOTE:
JSONParser.swift:289             case Literal.zero...Literal.nine:
JSONParser.swift:289             case Literal.zero...Literal.nine:
JSONParser.swift:290                 nibble = UInt16(c - Literal.zero)
JSONParser.swift:292             case Literal.a...Literal.f:
JSONParser.swift:292             case Literal.a...Literal.f:
JSONParser.swift:293                 nibble = 10 + UInt16(c - Literal.a)
JSONParser.swift:295             case Literal.A...Literal.F:
JSONParser.swift:295             case Literal.A...Literal.F:
JSONParser.swift:296                 nibble = 10 + UInt16(c - Literal.A)
JSONParser.swift:318             guard loc + 6 <= input.count && input[loc] == Literal.BACKSLASH && input[loc+1] == Literal.u else {
JSONParser.swift:318             guard loc + 6 <= input.count && input[loc] == Literal.BACKSLASH && input[loc+1] == Literal.u else {
JSONParser.swift:348             if loc < input.count && input[loc] == Literal.RIGHT_BRACKET {
JSONParser.swift:354                 guard loc < input.count && input[loc] == Literal.COMMA else {
JSONParser.swift:400             if loc < input.count && input[loc] == Literal.RIGHT_BRACE {
JSONParser.swift:411                 guard loc < input.count && input[loc] == Literal.COMMA else {
JSONParser.swift:419             guard loc < input.count && input[loc] == Literal.DOUBLE_QUOTE else {
JSONParser.swift:426             guard loc < input.count && input[loc] == Literal.COLON else {
JSONParser.swift:444         case Literal.zero:
JSONParser.swift:447         case Literal.one...Literal.nine:
JSONParser.swift:447         case Literal.one...Literal.nine:
JSONParser.swift:462         case (Literal.PERIOD, _):
JSONParser.swift:479             case Literal.zero...Literal.nine:
JSONParser.swift:479             case Literal.zero...Literal.nine:
JSONParser.swift:480                 value = 10 * value + Int(c - Literal.zero)
JSONParser.swift:483             case Literal.PERIOD:
JSONParser.swift:486             case Literal.e, Literal.E:
JSONParser.swift:486             case Literal.e, Literal.E:
JSONParser.swift:504         case Literal.zero...Literal.nine:
JSONParser.swift:504         case Literal.zero...Literal.nine:
JSONParser.swift:519             case Literal.zero...Literal.nine:
JSONParser.swift:519             case Literal.zero...Literal.nine:
JSONParser.swift:520                 value += position * Double(c - Literal.zero)
JSONParser.swift:524             case Literal.e, Literal.E:
JSONParser.swift:524             case Literal.e, Literal.E:
JSONParser.swift:542         case Literal.zero...Literal.nine:
JSONParser.swift:542         case Literal.zero...Literal.nine:
JSONParser.swift:545         case Literal.PLUS:
JSONParser.swift:548         case Literal.MINUS:
JSONParser.swift:563         case Literal.zero...Literal.nine:
JSONParser.swift:563         case Literal.zero...Literal.nine:
JSONParser.swift:577             case Literal.zero...Literal.nine:
JSONParser.swift:577             case Literal.zero...Literal.nine:
JSONParser.swift:578                 exponent = exponent * 10 + Double(c - Literal.zero) {
0012        static let BACKSLASHJSONParser.swift:235             case Literal.BACKSLASH:
JSONParser.swift:239                 case Literal.BACKSLASH:    stringDecodingBuffer.append(Literal.BACKSLASH)
JSONParser.swift:239                 case Literal.BACKSLASH:    stringDecodingBuffer.append(Literal.BACKSLASH)
JSONParser.swift:318             guard loc + 6 <= input.count && input[loc] == Literal.BACKSLASH && input[loc+1] == Literal.u else {     = UInt8(ascii: "\\")
0013        static let BACKSPACEJSONParser.swift:241                 case Literal.b:            stringDecodingBuffer.append(Literal.BACKSPACE)     = UInt8(ascii: "\u{0008}")
0014        static let COLONJSONParser.swift:426             guard loc < input.count && input[loc] == Literal.COLON else {         = UInt8(ascii: ":")
0015        static let COMMAJSONParser.swift:354                 guard loc < input.count && input[loc] == Literal.COMMA else {
JSONParser.swift:411                 guard loc < input.count && input[loc] == Literal.COMMA else {         = UInt8(ascii: ",")
0016        static let DOUBLE_QUOTEJSONParser.swift:129             case Literal.DOUBLE_QUOTE:
JSONParser.swift:238                 case Literal.DOUBLE_QUOTE: stringDecodingBuffer.append(Literal.DOUBLE_QUOTE)
JSONParser.swift:238                 case Literal.DOUBLE_QUOTE: stringDecodingBuffer.append(Literal.DOUBLE_QUOTE)
JSONParser.swift:259             case Literal.DOUBLE_QUOTE:
JSONParser.swift:419             guard loc < input.count && input[loc] == Literal.DOUBLE_QUOTE else {  = UInt8(ascii: "\"")
0017        static let FORMFEEDJSONParser.swift:242                 case Literal.f:            stringDecodingBuffer.append(Literal.FORMFEED)      = UInt8(ascii: "\u{000c}")
0018        static let LEFT_BRACEJSONParser.swift:124             case Literal.LEFT_BRACE:    = UInt8(ascii: "{")
0019        static let LEFT_BRACKETJSONParser.swift:119             case Literal.LEFT_BRACKET:  = UInt8(ascii: "[")
0020        static let MINUSJSONParser.swift:141             case Literal.MINUS:
JSONParser.swift:548         case Literal.MINUS:         = UInt8(ascii: "-")
0021        static let NEWLINEJSONParser.swift:150             case Literal.SPACE, Literal.TAB, Literal.RETURN, Literal.NEWLINE:
JSONParser.swift:164             case Literal.SPACE, Literal.TAB, Literal.RETURN, Literal.NEWLINE:
JSONParser.swift:245                 case Literal.n:            stringDecodingBuffer.append(Literal.NEWLINE)       = UInt8(ascii: "\n")
0022        static let PERIODJSONParser.swift:462         case (Literal.PERIOD, _):
JSONParser.swift:483             case Literal.PERIOD:        = UInt8(ascii: ".")
0023        static let PLUSJSONParser.swift:545         case Literal.PLUS:          = UInt8(ascii: "+")
0024        static let RETURNJSONParser.swift:150             case Literal.SPACE, Literal.TAB, Literal.RETURN, Literal.NEWLINE:
JSONParser.swift:164             case Literal.SPACE, Literal.TAB, Literal.RETURN, Literal.NEWLINE:
JSONParser.swift:243                 case Literal.r:            stringDecodingBuffer.append(Literal.RETURN)        = UInt8(ascii: "\r")
0025        static let RIGHT_BRACEJSONParser.swift:400             if loc < input.count && input[loc] == Literal.RIGHT_BRACE {   = UInt8(ascii: "}")
0026        static let RIGHT_BRACKETJSONParser.swift:348             if loc < input.count && input[loc] == Literal.RIGHT_BRACKET { = UInt8(ascii: "]")
0027        static let SLASHJSONParser.swift:240                 case Literal.SLASH:        stringDecodingBuffer.append(Literal.SLASH)
JSONParser.swift:240                 case Literal.SLASH:        stringDecodingBuffer.append(Literal.SLASH)         = UInt8(ascii: "/")
0028        static let SPACEJSONParser.swift:150             case Literal.SPACE, Literal.TAB, Literal.RETURN, Literal.NEWLINE:
JSONParser.swift:164             case Literal.SPACE, Literal.TAB, Literal.RETURN, Literal.NEWLINE:         = UInt8(ascii: " ")
0029        static let TABJSONParser.swift:150             case Literal.SPACE, Literal.TAB, Literal.RETURN, Literal.NEWLINE:
JSONParser.swift:164             case Literal.SPACE, Literal.TAB, Literal.RETURN, Literal.NEWLINE:
JSONParser.swift:244                 case Literal.t:            stringDecodingBuffer.append(Literal.TAB)           = UInt8(ascii: "\t")
0030    
0031        static let aJSONParser.swift:217         if     input[loc+1] != Literal.a
JSONParser.swift:292             case Literal.a...Literal.f:
JSONParser.swift:293                 nibble = 10 + UInt16(c - Literal.a) = UInt8(ascii: "a")
0032        static let bJSONParser.swift:241                 case Literal.b:            stringDecodingBuffer.append(Literal.BACKSPACE) = UInt8(ascii: "b")
0033        static let c = UInt8(ascii: "c")
0034        static let d = UInt8(ascii: "d")
0035        static let eJSONParser.swift:204             || input[loc+3] != Literal.e {
JSONParser.swift:220             || input[loc+4] != Literal.e {
JSONParser.swift:486             case Literal.e, Literal.E:
JSONParser.swift:524             case Literal.e, Literal.E: = UInt8(ascii: "e")
0036        static let fJSONParser.swift:132             case Literal.f:
JSONParser.swift:242                 case Literal.f:            stringDecodingBuffer.append(Literal.FORMFEED)
JSONParser.swift:292             case Literal.a...Literal.f: = UInt8(ascii: "f")
0037        static let lJSONParser.swift:188             || input[loc+2] != Literal.l
JSONParser.swift:189             || input[loc+3] != Literal.l {
JSONParser.swift:218             || input[loc+2] != Literal.l = UInt8(ascii: "l")
0038        static let nJSONParser.swift:135             case Literal.n:
JSONParser.swift:245                 case Literal.n:            stringDecodingBuffer.append(Literal.NEWLINE) = UInt8(ascii: "n")
0039        static let rJSONParser.swift:202         if     input[loc+1] != Literal.r
JSONParser.swift:243                 case Literal.r:            stringDecodingBuffer.append(Literal.RETURN) = UInt8(ascii: "r")
0040        static let sJSONParser.swift:219             || input[loc+3] != Literal.s = UInt8(ascii: "s")
0041        static let tJSONParser.swift:138             case Literal.t:
JSONParser.swift:244                 case Literal.t:            stringDecodingBuffer.append(Literal.TAB) = UInt8(ascii: "t")
0042        static let uJSONParser.swift:187         if     input[loc+1] != Literal.u
JSONParser.swift:203             || input[loc+2] != Literal.u
JSONParser.swift:246                 case Literal.u:
JSONParser.swift:318             guard loc + 6 <= input.count && input[loc] == Literal.BACKSLASH && input[loc+1] == Literal.u else { = UInt8(ascii: "u")
0043    
0044        static let AJSONParser.swift:295             case Literal.A...Literal.F:
JSONParser.swift:296                 nibble = 10 + UInt16(c - Literal.A) = UInt8(ascii: "A")
0045        static let B = UInt8(ascii: "B")
0046        static let C = UInt8(ascii: "C")
0047        static let D = UInt8(ascii: "D")
0048        static let EJSONParser.swift:486             case Literal.e, Literal.E:
JSONParser.swift:524             case Literal.e, Literal.E: = UInt8(ascii: "E")
0049        static let FJSONParser.swift:295             case Literal.A...Literal.F: = UInt8(ascii: "F")
0050    
0051        static let zeroJSONParser.swift:144             case Literal.zero:
JSONParser.swift:289             case Literal.zero...Literal.nine:
JSONParser.swift:290                 nibble = UInt16(c - Literal.zero)
JSONParser.swift:444         case Literal.zero:
JSONParser.swift:479             case Literal.zero...Literal.nine:
JSONParser.swift:480                 value = 10 * value + Int(c - Literal.zero)
JSONParser.swift:504         case Literal.zero...Literal.nine:
JSONParser.swift:519             case Literal.zero...Literal.nine:
JSONParser.swift:520                 value += position * Double(c - Literal.zero)
JSONParser.swift:542         case Literal.zero...Literal.nine:
JSONParser.swift:563         case Literal.zero...Literal.nine:
JSONParser.swift:577             case Literal.zero...Literal.nine:
JSONParser.swift:578                 exponent = exponent * 10 + Double(c - Literal.zero)  = UInt8(ascii: "0")
0052        static let oneJSONParser.swift:147             case Literal.one...Literal.nine:
JSONParser.swift:447         case Literal.one...Literal.nine:   = UInt8(ascii: "1")
0053        static let two   = UInt8(ascii: "2")
0054        static let three = UInt8(ascii: "3")
0055        static let four  = UInt8(ascii: "4")
0056        static let five  = UInt8(ascii: "5")
0057        static let six   = UInt8(ascii: "6")
0058        static let seven = UInt8(ascii: "7")
0059        static let eight = UInt8(ascii: "8")
0060        static let nineJSONParser.swift:147             case Literal.one...Literal.nine:
JSONParser.swift:289             case Literal.zero...Literal.nine:
JSONParser.swift:447         case Literal.one...Literal.nine:
JSONParser.swift:479             case Literal.zero...Literal.nine:
JSONParser.swift:504         case Literal.zero...Literal.nine:
JSONParser.swift:519             case Literal.zero...Literal.nine:
JSONParser.swift:542         case Literal.zero...Literal.nine:
JSONParser.swift:563         case Literal.zero...Literal.nine:
JSONParser.swift:577             case Literal.zero...Literal.nine:  = UInt8(ascii: "9")
0061    }
0062    
0063    private let ParserMaximumDepthJSONParser.swift:109         guard depth <= ParserMaximumDepth else { = 512
0064    
0065    
0066    /// A pure Swift JSON parser. This parser is much faster than the
0067    /// `NSJSONSerialization`-based parser (due to the overhead of having to
0068    /// dynamically cast the Objective-C objects to determine their type); however,
0069    /// it is much newer and has restrictions that the `NSJSONSerialization` parser
0070    /// does not. Two restrictions in particular are that it requires UTF-8 data as
0071    /// input and it does not allow trailing commas in arrays or dictionaries.
0072    public struct JSONParserJSONParser.swift:590 public extension JSONParser {
JSONParser.swift:616 extension JSONParser: JSONParserType {
JSONParser.swift:623         var parser = JSONParser(utf8Data: data)
JSONParser.swift:631 extension JSONParser {
JSONParsing.swift:28     public init(data: NSData, usingParser parser: JSONParserType.Type = JSONParser.self) throws {
JSONParsing.swift:33     public init(jsonString: Swift.String, usingParser parser: JSONParserType.Type = JSONParser.self) throws { {
0073    
0074        private enum SignJSONParser.swift:455     private mutating func decodeNumberLeadingZero(start: Int, sign: Sign = .Positive) throws -> JSON {
JSONParser.swift:473     private mutating func decodeNumberPreDecimalDigits(start: Int, sign: Sign = .Positive) throws -> JSON {
JSONParser.swift:497     private mutating func decodeNumberDecimal(start: Int, sign: Sign, value: Double) throws -> JSON {
JSONParser.swift:512     private mutating func decodeNumberPostDecimalDigits(start: Int, sign: Sign, value inValue: Double) throws -> JSON {
JSONParser.swift:535     private mutating func decodeNumberExponent(start: Int, sign: Sign, value: Double) throws -> JSON {
JSONParser.swift:556     private mutating func decodeNumberExponentSign(start: Int, sign: Sign, value: Double, expSign: Sign) throws -> JSON {
JSONParser.swift:556     private mutating func decodeNumberExponentSign(start: Int, sign: Sign, value: Double, expSign: Sign) throws -> JSON {
JSONParser.swift:571     private mutating func decodeNumberExponentDigits(start: Int, sign: Sign, value: Double, expSign: Sign) throws -> JSON {
JSONParser.swift:571     private mutating func decodeNumberExponentDigits(start: Int, sign: Sign, value: Double, expSign: Sign) throws -> JSON {: Int {
0075            case PositiveJSONParser.swift:455     private mutating func decodeNumberLeadingZero(start: Int, sign: Sign = .Positive) throws -> JSON {
JSONParser.swift:473     private mutating func decodeNumberPreDecimalDigits(start: Int, sign: Sign = .Positive) throws -> JSON {
JSONParser.swift:543             return try decodeNumberExponentDigits(start, sign: sign, value: value, expSign: .Positive)
JSONParser.swift:546             return try decodeNumberExponentSign(start, sign: sign, value: value, expSign: .Positive) = 1
0076            case NegativeJSONParser.swift:445             return try decodeNumberLeadingZero(start, sign: .Negative)
JSONParser.swift:448             return try decodeNumberPreDecimalDigits(start, sign: .Negative)
JSONParser.swift:465         case (_, .Negative):
JSONParser.swift:549             return try decodeNumberExponentSign(start, sign: sign, value: value, expSign: .Negative) = -1
0077        }
0078    
0079        private let inputJSONParser.swift:85         self.input = buffer
JSONParser.swift:102         guard loc == input.count else {
JSONParser.swift:113         guard input.count > 0 else {
JSONParser.swift:117         advancing: while loc < input.count {
JSONParser.swift:118             switch input[loc] {
JSONParser.swift:158         throw Error.ValueInvalid(offset: loc, character: UnicodeScalar(input[loc]))
JSONParser.swift:162         while loc < input.count {
JSONParser.swift:163             switch input[loc] {
JSONParser.swift:174         let header = input.prefix(4)
JSONParser.swift:183         guard loc.advancedBy(3, limit: input.count) != input.count else {
JSONParser.swift:183         guard loc.advancedBy(3, limit: input.count) != input.count else {
JSONParser.swift:187         if     input[loc+1] != Literal.u
JSONParser.swift:188             || input[loc+2] != Literal.l
JSONParser.swift:189             || input[loc+3] != Literal.l {
JSONParser.swift:198         guard loc.advancedBy(3, limit: input.count) != input.count else {
JSONParser.swift:198         guard loc.advancedBy(3, limit: input.count) != input.count else {
JSONParser.swift:202         if     input[loc+1] != Literal.r
JSONParser.swift:203             || input[loc+2] != Literal.u
JSONParser.swift:204             || input[loc+3] != Literal.e {
JSONParser.swift:213         guard loc.advancedBy(4, limit: input.count) != input.count else {
JSONParser.swift:213         guard loc.advancedBy(4, limit: input.count) != input.count else {
JSONParser.swift:217         if     input[loc+1] != Literal.a
JSONParser.swift:218             || input[loc+2] != Literal.l
JSONParser.swift:219             || input[loc+3] != Literal.s
JSONParser.swift:220             || input[loc+4] != Literal.e {
JSONParser.swift:233         while loc < input.count {
JSONParser.swift:234             switch input[loc] {
JSONParser.swift:237                 switch input[loc] {
JSONParser.swift:281         guard loc + 4 <= input.count else {
JSONParser.swift:285         for c in input[loc..<loc+4] {
JSONParser.swift:318             guard loc + 6 <= input.count && input[loc] == Literal.BACKSLASH && input[loc+1] == Literal.u else {
JSONParser.swift:318             guard loc + 6 <= input.count && input[loc] == Literal.BACKSLASH && input[loc+1] == Literal.u else {
JSONParser.swift:318             guard loc + 6 <= input.count && input[loc] == Literal.BACKSLASH && input[loc+1] == Literal.u else {
JSONParser.swift:345         while loc < input.count {
JSONParser.swift:348             if loc < input.count && input[loc] == Literal.RIGHT_BRACKET {
JSONParser.swift:348             if loc < input.count && input[loc] == Literal.RIGHT_BRACKET {
JSONParser.swift:354                 guard loc < input.count && input[loc] == Literal.COMMA else {
JSONParser.swift:354                 guard loc < input.count && input[loc] == Literal.COMMA else {
JSONParser.swift:397         while loc < input.count {
JSONParser.swift:400             if loc < input.count && input[loc] == Literal.RIGHT_BRACE {
JSONParser.swift:400             if loc < input.count && input[loc] == Literal.RIGHT_BRACE {
JSONParser.swift:411                 guard loc < input.count && input[loc] == Literal.COMMA else {
JSONParser.swift:411                 guard loc < input.count && input[loc] == Literal.COMMA else {
JSONParser.swift:419             guard loc < input.count && input[loc] == Literal.DOUBLE_QUOTE else {
JSONParser.swift:419             guard loc < input.count && input[loc] == Literal.DOUBLE_QUOTE else {
JSONParser.swift:426             guard loc < input.count && input[loc] == Literal.COLON else {
JSONParser.swift:426             guard loc < input.count && input[loc] == Literal.COLON else {
JSONParser.swift:439         guard loc < input.count else {
JSONParser.swift:443         switch input[loc] {
JSONParser.swift:457         guard loc < input.count else {
JSONParser.swift:461         switch (input[loc], sign) {
JSONParser.swift:476         advancing: while loc < input.count {
JSONParser.swift:477             let c = input[loc]
JSONParser.swift:499         guard loc < input.count else {
JSONParser.swift:503         switch input[loc] {
JSONParser.swift:516         advancing: while loc < input.count {
JSONParser.swift:517             let c = input[loc]
JSONParser.swift:537         guard loc < input.count else {
JSONParser.swift:541         switch input[loc] {
JSONParser.swift:558         guard loc < input.count else {
JSONParser.swift:562         switch input[loc] {
JSONParser.swift:574         advancing: while loc < input.count {
JSONParser.swift:575             let c = input[loc]: UnsafeBufferPointer<UInt8>
0080        private let ownerJSONParser.swift:86         self.owner = owner: Any?
0081        private var locJSONParser.swift:102         guard loc == input.count else {
JSONParser.swift:103             throw Error.EndOfStreamGarbage(offset: loc)
JSONParser.swift:110             throw Error.ExceededNestingLimit(offset: loc)
JSONParser.swift:117         advancing: while loc < input.count {
JSONParser.swift:118             switch input[loc] {
JSONParser.swift:142                 return try decodeNumberNegative(loc)
JSONParser.swift:145                 return try decodeNumberLeadingZero(loc)
JSONParser.swift:148                 return try decodeNumberPreDecimalDigits(loc)
JSONParser.swift:151                 loc = loc.successor()
JSONParser.swift:151                 loc = loc.successor()
JSONParser.swift:158         throw Error.ValueInvalid(offset: loc, character: UnicodeScalar(input[loc]))
JSONParser.swift:158         throw Error.ValueInvalid(offset: loc, character: UnicodeScalar(input[loc]))
JSONParser.swift:162         while loc < input.count {
JSONParser.swift:163             switch input[loc] {
JSONParser.swift:165                 loc = loc.successor()
JSONParser.swift:165                 loc = loc.successor()
JSONParser.swift:179         loc = loc.advancedBy(encodingPrefixInformation.byteOrderMarkLength)
JSONParser.swift:179         loc = loc.advancedBy(encodingPrefixInformation.byteOrderMarkLength)
JSONParser.swift:183         guard loc.advancedBy(3, limit: input.count) != input.count else {
JSONParser.swift:184             throw Error.LiteralNilMisspelled(offset: loc)
JSONParser.swift:187         if     input[loc+1] != Literal.u
JSONParser.swift:188             || input[loc+2] != Literal.l
JSONParser.swift:189             || input[loc+3] != Literal.l {
JSONParser.swift:190                 throw Error.LiteralNilMisspelled(offset: loc)
JSONParser.swift:193         loc += 4
JSONParser.swift:198         guard loc.advancedBy(3, limit: input.count) != input.count else {
JSONParser.swift:199             throw Error.LiteralTrueMisspelled(offset: loc)
JSONParser.swift:202         if     input[loc+1] != Literal.r
JSONParser.swift:203             || input[loc+2] != Literal.u
JSONParser.swift:204             || input[loc+3] != Literal.e {
JSONParser.swift:205             throw Error.LiteralTrueMisspelled(offset: loc)
JSONParser.swift:208         loc += 4
JSONParser.swift:213         guard loc.advancedBy(4, limit: input.count) != input.count else {
JSONParser.swift:214             throw Error.LiteralFalseMisspelled(offset: loc)
JSONParser.swift:217         if     input[loc+1] != Literal.a
JSONParser.swift:218             || input[loc+2] != Literal.l
JSONParser.swift:219             || input[loc+3] != Literal.s
JSONParser.swift:220             || input[loc+4] != Literal.e {
JSONParser.swift:221             throw Error.LiteralFalseMisspelled(offset: loc)
JSONParser.swift:224         loc += 5
JSONParser.swift:230         let start = loc
JSONParser.swift:231         loc = loc.successor()
JSONParser.swift:231         loc = loc.successor()
JSONParser.swift:233         while loc < input.count {
JSONParser.swift:234             switch input[loc] {
JSONParser.swift:236                 loc = loc.successor()
JSONParser.swift:236                 loc = loc.successor()
JSONParser.swift:237                 switch input[loc] {
JSONParser.swift:247                     loc = loc.successor()
JSONParser.swift:247                     loc = loc.successor()
JSONParser.swift:248                     try readUnicodeEscape(start: loc - 2)
JSONParser.swift:255                     throw Error.ControlCharacterUnrecognized(offset: loc)
JSONParser.swift:257                 loc = loc.successor()
JSONParser.swift:257                 loc = loc.successor()
JSONParser.swift:260                 loc = loc.successor()
JSONParser.swift:260                 loc = loc.successor()
JSONParser.swift:273                 loc = loc.successor()
JSONParser.swift:273                 loc = loc.successor()
JSONParser.swift:281         guard loc + 4 <= input.count else {
JSONParser.swift:285         for c in input[loc..<loc+4] {
JSONParser.swift:285         for c in input[loc..<loc+4] {
JSONParser.swift:303         loc += 4
JSONParser.swift:318             guard loc + 6 <= input.count && input[loc] == Literal.BACKSLASH && input[loc+1] == Literal.u else {
JSONParser.swift:318             guard loc + 6 <= input.count && input[loc] == Literal.BACKSLASH && input[loc+1] == Literal.u else {
JSONParser.swift:318             guard loc + 6 <= input.count && input[loc] == Literal.BACKSLASH && input[loc+1] == Literal.u else {
JSONParser.swift:321             loc += 2
JSONParser.swift:341         let start = loc
JSONParser.swift:342         loc = loc.successor()
JSONParser.swift:342         loc = loc.successor()
JSONParser.swift:345         while loc < input.count {
JSONParser.swift:348             if loc < input.count && input[loc] == Literal.RIGHT_BRACKET {
JSONParser.swift:348             if loc < input.count && input[loc] == Literal.RIGHT_BRACKET {
JSONParser.swift:349                 loc = loc.successor()
JSONParser.swift:349                 loc = loc.successor()
JSONParser.swift:354                 guard loc < input.count && input[loc] == Literal.COMMA else {
JSONParser.swift:354                 guard loc < input.count && input[loc] == Literal.COMMA else {
JSONParser.swift:357                 loc = loc.successor()
JSONParser.swift:357                 loc = loc.successor()
JSONParser.swift:393         let start = loc
JSONParser.swift:394         loc = loc.successor()
JSONParser.swift:394         loc = loc.successor()
JSONParser.swift:397         while loc < input.count {
JSONParser.swift:400             if loc < input.count && input[loc] == Literal.RIGHT_BRACE {
JSONParser.swift:400             if loc < input.count && input[loc] == Literal.RIGHT_BRACE {
JSONParser.swift:401                 loc = loc.successor()
JSONParser.swift:401                 loc = loc.successor()
JSONParser.swift:411                 guard loc < input.count && input[loc] == Literal.COMMA else {
JSONParser.swift:411                 guard loc < input.count && input[loc] == Literal.COMMA else {
JSONParser.swift:414                 loc = loc.successor()
JSONParser.swift:414                 loc = loc.successor()
JSONParser.swift:419             guard loc < input.count && input[loc] == Literal.DOUBLE_QUOTE else {
JSONParser.swift:419             guard loc < input.count && input[loc] == Literal.DOUBLE_QUOTE else {
JSONParser.swift:426             guard loc < input.count && input[loc] == Literal.COLON else {
JSONParser.swift:426             guard loc < input.count && input[loc] == Literal.COLON else {
JSONParser.swift:429             loc = loc.successor()
JSONParser.swift:429             loc = loc.successor()
JSONParser.swift:438         loc = loc.successor()
JSONParser.swift:438         loc = loc.successor()
JSONParser.swift:439         guard loc < input.count else {
JSONParser.swift:443         switch input[loc] {
JSONParser.swift:456         loc = loc.successor()
JSONParser.swift:456         loc = loc.successor()
JSONParser.swift:457         guard loc < input.count else {
JSONParser.swift:461         switch (input[loc], sign) {
JSONParser.swift:476         advancing: while loc < input.count {
JSONParser.swift:477             let c = input[loc]
JSONParser.swift:481                 loc = loc.successor()
JSONParser.swift:481                 loc = loc.successor()
JSONParser.swift:498         loc = loc.successor()
JSONParser.swift:498         loc = loc.successor()
JSONParser.swift:499         guard loc < input.count else {
JSONParser.swift:503         switch input[loc] {
JSONParser.swift:516         advancing: while loc < input.count {
JSONParser.swift:517             let c = input[loc]
JSONParser.swift:522                 loc = loc.successor()
JSONParser.swift:522                 loc = loc.successor()
JSONParser.swift:536         loc = loc.successor()
JSONParser.swift:536         loc = loc.successor()
JSONParser.swift:537         guard loc < input.count else {
JSONParser.swift:541         switch input[loc] {
JSONParser.swift:557         loc = loc.successor()
JSONParser.swift:557         loc = loc.successor()
JSONParser.swift:558         guard loc < input.count else {
JSONParser.swift:562         switch input[loc] {
JSONParser.swift:574         advancing: while loc < input.count {
JSONParser.swift:575             let c = input[loc]
JSONParser.swift:579                 loc = loc.successor()
JSONParser.swift:579                 loc = loc.successor() = 0
0082        private var depthJSONParser.swift:109         guard depth <= ParserMaximumDepth else {
JSONParser.swift:120                 depth += 1
JSONParser.swift:121                 defer { depth -= 1 }
JSONParser.swift:125                 depth += 1
JSONParser.swift:126                 defer { depth -= 1 } = 0
0083    
0084        private initJSONParser.swift:599         self.init(buffer: buffer, owner: data)
JSONParser.swift:611         self.init(buffer: buffer, owner: codePoints)<T>(buffer: UnsafeBufferPointer<UInt8>, owner: T) {
0085            self.input = buffer
0086            self.owner = owner
0087        }
0088    
0089        /// Decode the root element of the `JSON` stream. This may be any fragment
0090        /// or a structural element, per RFC 7159.
0091        ///
0092        /// The beginning bytes are used to determine the stream's encoding.
0093        /// `JSONParser` currently only supports UTF-8 encoding, with or without
0094        /// a byte-order mark.
0095        ///
0096        /// - throws: `JSONParser.Error` for any decoding failures, including a
0097        ///   source location if needed.
0098        public mutating func parseJSONParser.swift:624         return try parser.parse()() throws -> JSON {
0099            try guardAgainstUnsupportedEncodings()
0100            let value = try parseValue()
0101            skipWhitespace()
0102            guard loc == input.count else {
0103                throw Error.EndOfStreamGarbage(offset: loc)
0104            }
0105            return value
0106        }
0107    
0108        private mutating func parseValueJSONParser.swift:100         let value = try parseValue()
JSONParser.swift:360             items.append(try parseValue())
JSONParser.swift:431             pairs.append((key, try parseValue()))() throws -> JSON {
0109            guard depth <= ParserMaximumDepth else {
0110                throw Error.ExceededNestingLimit(offset: loc)
0111            }
0112            
0113            guard input.count > 0 else {
0114                throw Error.EndOfStreamUnexpected
0115            }
0116    
0117            advancing: while loc < input.count {
0118                switch input[loc] {
0119                case Literal.LEFT_BRACKET:
0120                    depth += 1
0121                    defer { depth -= 1 }
0122                    return try decodeArray()
0123    
0124                case Literal.LEFT_BRACE:
0125                    depth += 1
0126                    defer { depth -= 1 }
0127                    return try decodeObject()
0128    
0129                case Literal.DOUBLE_QUOTE:
0130                    return try decodeString()
0131    
0132                case Literal.f:
0133                    return try decodeFalse()
0134    
0135                case Literal.n:
0136                    return try decodeNull()
0137    
0138                case Literal.t:
0139                    return try decodeTrue()
0140    
0141                case Literal.MINUS:
0142                    return try decodeNumberNegative(loc)
0143    
0144                case Literal.zero:
0145                    return try decodeNumberLeadingZero(loc)
0146    
0147                case Literal.one...Literal.nine:
0148                    return try decodeNumberPreDecimalDigits(loc)
0149    
0150                case Literal.SPACE, Literal.TAB, Literal.RETURN, Literal.NEWLINE:
0151                    loc = loc.successor()
0152    
0153                default:
0154                    break advancing
0155                }
0156            }
0157            
0158            throw Error.ValueInvalid(offset: loc, character: UnicodeScalar(input[loc]))
0159        }
0160    
0161        private mutating func skipWhitespaceJSONParser.swift:101         skipWhitespace()
JSONParser.swift:346             skipWhitespace()
JSONParser.swift:398             skipWhitespace()
JSONParser.swift:416                 skipWhitespace()
JSONParser.swift:424             skipWhitespace()() {
0162            while loc < input.count {
0163                switch input[loc] {
0164                case Literal.SPACE, Literal.TAB, Literal.RETURN, Literal.NEWLINE:
0165                    loc = loc.successor()
0166    
0167                default:
0168                    return
0169                }
0170            }
0171        }
0172    
0173        private mutating func guardAgainstUnsupportedEncodingsJSONParser.swift:99         try guardAgainstUnsupportedEncodings()() throws {
0174            let header = input.prefix(4)
0175            let encodingPrefixInformation = JSONEncodingDetector.detectEncoding(header)
0176            guard JSONEncodingDetector.supportedEncodings.contains(encodingPrefixInformation.encoding) else {
0177                throw Error.InvalidUnicodeStreamEncoding(detectedEncoding: encodingPrefixInformation.encoding)
0178            }
0179            loc = loc.advancedBy(encodingPrefixInformation.byteOrderMarkLength)
0180        }
0181    
0182        private mutating func decodeNullJSONParser.swift:136                 return try decodeNull()() throws -> JSON {
0183            guard loc.advancedBy(3, limit: input.count) != input.count else {
0184                throw Error.LiteralNilMisspelled(offset: loc)
0185            }
0186    
0187            if     input[loc+1] != Literal.u
0188                || input[loc+2] != Literal.l
0189                || input[loc+3] != Literal.l {
0190                    throw Error.LiteralNilMisspelled(offset: loc)
0191            }
0192    
0193            loc += 4
0194            return .Null
0195        }
0196    
0197        private mutating func decodeTrueJSONParser.swift:139                 return try decodeTrue()() throws -> JSON {
0198            guard loc.advancedBy(3, limit: input.count) != input.count else {
0199                throw Error.LiteralTrueMisspelled(offset: loc)
0200            }
0201    
0202            if     input[loc+1] != Literal.r
0203                || input[loc+2] != Literal.u
0204                || input[loc+3] != Literal.e {
0205                throw Error.LiteralTrueMisspelled(offset: loc)
0206            }
0207    
0208            loc += 4
0209            return .Bool(true)
0210        }
0211    
0212        private mutating func decodeFalseJSONParser.swift:133                 return try decodeFalse()() throws -> JSON {
0213            guard loc.advancedBy(4, limit: input.count) != input.count else {
0214                throw Error.LiteralFalseMisspelled(offset: loc)
0215            }
0216    
0217            if     input[loc+1] != Literal.a
0218                || input[loc+2] != Literal.l
0219                || input[loc+3] != Literal.s
0220                || input[loc+4] != Literal.e {
0221                throw Error.LiteralFalseMisspelled(offset: loc)
0222            }
0223    
0224            loc += 5
0225            return .Bool(false)
0226        }
0227    
0228        private var stringDecodingBufferJSONParser.swift:232         stringDecodingBuffer.removeAll(keepCapacity: true)
JSONParser.swift:238                 case Literal.DOUBLE_QUOTE: stringDecodingBuffer.append(Literal.DOUBLE_QUOTE)
JSONParser.swift:239                 case Literal.BACKSLASH:    stringDecodingBuffer.append(Literal.BACKSLASH)
JSONParser.swift:240                 case Literal.SLASH:        stringDecodingBuffer.append(Literal.SLASH)
JSONParser.swift:241                 case Literal.b:            stringDecodingBuffer.append(Literal.BACKSPACE)
JSONParser.swift:242                 case Literal.f:            stringDecodingBuffer.append(Literal.FORMFEED)
JSONParser.swift:243                 case Literal.r:            stringDecodingBuffer.append(Literal.RETURN)
JSONParser.swift:244                 case Literal.t:            stringDecodingBuffer.append(Literal.TAB)
JSONParser.swift:245                 case Literal.n:            stringDecodingBuffer.append(Literal.NEWLINE)
JSONParser.swift:261                 stringDecodingBuffer.append(0)
JSONParser.swift:263                 guard let string = (stringDecodingBuffer.withUnsafeBufferPointer {
JSONParser.swift:272                 stringDecodingBuffer.append(other)
JSONParser.swift:333         let transcodeHadError = transcode(UTF16.self, UTF8.self, codeUnits.generate(), { self.stringDecodingBuffer.append($0) }, stopOnError: true) = [UInt8]()
0229        private mutating func decodeStringJSONParser.swift:130                 return try decodeString()
JSONParser.swift:423             let key = try decodeString().string()() throws -> JSON {
0230            let start = loc
0231            loc = loc.successor()
0232            stringDecodingBuffer.removeAll(keepCapacity: true)
0233            while loc < input.count {
0234                switch input[loc] {
0235                case Literal.BACKSLASH:
0236                    loc = loc.successor()
0237                    switch input[loc] {
0238                    case Literal.DOUBLE_QUOTE: stringDecodingBuffer.append(Literal.DOUBLE_QUOTE)
0239                    case Literal.BACKSLASH:    stringDecodingBuffer.append(Literal.BACKSLASH)
0240                    case Literal.SLASH:        stringDecodingBuffer.append(Literal.SLASH)
0241                    case Literal.b:            stringDecodingBuffer.append(Literal.BACKSPACE)
0242                    case Literal.f:            stringDecodingBuffer.append(Literal.FORMFEED)
0243                    case Literal.r:            stringDecodingBuffer.append(Literal.RETURN)
0244                    case Literal.t:            stringDecodingBuffer.append(Literal.TAB)
0245                    case Literal.n:            stringDecodingBuffer.append(Literal.NEWLINE)
0246                    case Literal.u:
0247                        loc = loc.successor()
0248                        try readUnicodeEscape(start: loc - 2)
0249    
0250                        // readUnicodeEscape() advances loc on its own, so we'll `continue` now
0251                        // to skip the typical "advance past this character" for all the other escapes
0252                        continue
0253    
0254                    default:
0255                        throw Error.ControlCharacterUnrecognized(offset: loc)
0256                    }
0257                    loc = loc.successor()
0258    
0259                case Literal.DOUBLE_QUOTE:
0260                    loc = loc.successor()
0261                    stringDecodingBuffer.append(0)
0262    
0263                    guard let string = (stringDecodingBuffer.withUnsafeBufferPointer {
0264                        String.fromCString(UnsafePointer($0.baseAddress))
0265                    }) else {
0266                        throw Error.UnicodeEscapeInvalid(offset: start)
0267                    }
0268    
0269                    return .String(string)
0270    
0271                case let other:
0272                    stringDecodingBuffer.append(other)
0273                    loc = loc.successor()
0274                }
0275            }
0276    
0277            throw Error.EndOfStreamUnexpected
0278        }
0279    
0280        private mutating func readCodeUnitJSONParser.swift:308         guard let codeUnit = readCodeUnit() else {
JSONParser.swift:324             guard let secondCodeUnit = readCodeUnit() where UTF16.isTrailSurrogate(secondCodeUnit) else {() -> UInt16? {
0281            guard loc + 4 <= input.count else {
0282                return nil
0283            }
0284            var codeUnit: UInt16 = 0
0285            for c in input[loc..<loc+4] {
0286                let nibble: UInt16
0287    
0288                switch c {
0289                case Literal.zero...Literal.nine:
0290                    nibble = UInt16(c - Literal.zero)
0291    
0292                case Literal.a...Literal.f:
0293                    nibble = 10 + UInt16(c - Literal.a)
0294    
0295                case Literal.A...Literal.F:
0296                    nibble = 10 + UInt16(c - Literal.A)
0297    
0298                default:
0299                    return nil
0300                }
0301                codeUnit = (codeUnit << 4) | nibble
0302            }
0303            loc += 4
0304            return codeUnit
0305        }
0306    
0307        private mutating func readUnicodeEscapeJSONParser.swift:248                     try readUnicodeEscape(start: loc - 2)(start start: Int) throws {
0308            guard let codeUnit = readCodeUnit() else {
0309                throw Error.UnicodeEscapeInvalid(offset: start)
0310            }
0311    
0312            let codeUnits: [UInt16]
0313    
0314            if UTF16.isLeadSurrogate(codeUnit) {
0315                // First half of a UTF16 surrogate pair - we must parse another code unit and combine them
0316    
0317                // First confirm and skip over that we have another "\u"
0318                guard loc + 6 <= input.count && input[loc] == Literal.BACKSLASH && input[loc+1] == Literal.u else {
0319                    throw Error.UnicodeEscapeInvalid(offset: start)
0320                }
0321                loc += 2
0322    
0323                // Ensure the second code unit is valid for the surrogate pair
0324                guard let secondCodeUnit = readCodeUnit() where UTF16.isTrailSurrogate(secondCodeUnit) else {
0325                    throw Error.UnicodeEscapeInvalid(offset: start)
0326                }
0327    
0328                codeUnits = [codeUnit, secondCodeUnit]
0329            } else {
0330                codeUnits = [codeUnit]
0331            }
0332    
0333            let transcodeHadError = transcode(UTF16.self, UTF8.self, codeUnits.generate(), { self.stringDecodingBuffer.append($0) }, stopOnError: true)
0334    
0335            if transcodeHadError {
0336                throw Error.UnicodeEscapeInvalid(offset: start)
0337            }
0338        }
0339    
0340        private mutating func decodeArrayJSONParser.swift:122                 return try decodeArray()() throws -> JSON {
0341            let start = loc
0342            loc = loc.successor()
0343            var items = [JSON]()
0344    
0345            while loc < input.count {
0346                skipWhitespace()
0347    
0348                if loc < input.count && input[loc] == Literal.RIGHT_BRACKET {
0349                    loc = loc.successor()
0350                    return .Array(items)
0351                }
0352    
0353                if !items.isEmpty {
0354                    guard loc < input.count && input[loc] == Literal.COMMA else {
0355                        throw Error.CollectionMissingSeparator(offset: start)
0356                    }
0357                    loc = loc.successor()
0358                }
0359    
0360                items.append(try parseValue())
0361            }
0362    
0363            throw Error.EndOfStreamUnexpected
0364        }
0365    
0366        // Decoding objects can be recursive, so we have to keep more than one
0367        // buffer around for building up key/value pairs (to reduce allocations
0368        // when parsing large JSON documents).
0369        //
0370        // Rough estimate of the difference between this and using a fresh
0371        // [(String,JSON)] for the `pairs` variable in decodeObject() below is
0372        // about 12% on an iPhone 5.
0373        private struct DecodeObjectBuffersJSONParser.swift:390     private var decodeObjectBuffers = DecodeObjectBuffers() {
0374            var buffersJSONParser.swift:377             if !buffers.isEmpty {
JSONParser.swift:378                 var buffer = buffers.removeLast()
JSONParser.swift:386             buffers.append(buffer) = [[(String,JSON)]]()
0375    
0376            mutating func getBufferJSONParser.swift:395         var pairs = decodeObjectBuffers.getBuffer()() -> [(String,JSON)] {
0377                if !buffers.isEmpty {
0378                    var buffer = buffers.removeLast()
0379                    buffer.removeAll(keepCapacity: true)
0380                    return buffer
0381                }
0382                return [(String,JSON)]()
0383            }
0384    
0385            mutating func putBufferJSONParser.swift:406                 decodeObjectBuffers.putBuffer(pairs)(buffer: [(String,JSON)]) {
0386                buffers.append(buffer)
0387            }
0388        }
0389    
0390        private var decodeObjectBuffersJSONParser.swift:395         var pairs = decodeObjectBuffers.getBuffer()
JSONParser.swift:406                 decodeObjectBuffers.putBuffer(pairs) = DecodeObjectBuffers()
0391    
0392        private mutating func decodeObjectJSONParser.swift:127                 return try decodeObject()() throws -> JSON {
0393            let start = loc
0394            loc = loc.successor()
0395            var pairs = decodeObjectBuffers.getBuffer()
0396    
0397            while loc < input.count {
0398                skipWhitespace()
0399    
0400                if loc < input.count && input[loc] == Literal.RIGHT_BRACE {
0401                    loc = loc.successor()
0402                    var obj = [String:JSON](minimumCapacity: pairs.count)
0403                    for (k, v) in pairs {
0404                        obj[k] = v
0405                    }
0406                    decodeObjectBuffers.putBuffer(pairs)
0407                    return .Dictionary(obj)
0408                }
0409    
0410                if !pairs.isEmpty {
0411                    guard loc < input.count && input[loc] == Literal.COMMA else {
0412                        throw Error.CollectionMissingSeparator(offset: start)
0413                    }
0414                    loc = loc.successor()
0415    
0416                    skipWhitespace()
0417                }
0418    
0419                guard loc < input.count && input[loc] == Literal.DOUBLE_QUOTE else {
0420                    throw Error.DictionaryMissingKey(offset: start)
0421                }
0422    
0423                let key = try decodeString().string()
0424                skipWhitespace()
0425    
0426                guard loc < input.count && input[loc] == Literal.COLON else {
0427                    throw Error.CollectionMissingSeparator(offset: start)
0428                }
0429                loc = loc.successor()
0430    
0431                pairs.append((key, try parseValue()))
0432            }
0433    
0434            throw Error.EndOfStreamUnexpected
0435        }
0436    
0437        private mutating func decodeNumberNegativeJSONParser.swift:142                 return try decodeNumberNegative(loc)(start: Int) throws -> JSON {
0438            loc = loc.successor()
0439            guard loc < input.count else {
0440                throw Error.EndOfStreamUnexpected
0441            }
0442    
0443            switch input[loc] {
0444            case Literal.zero:
0445                return try decodeNumberLeadingZero(start, sign: .Negative)
0446    
0447            case Literal.one...Literal.nine:
0448                return try decodeNumberPreDecimalDigits(start, sign: .Negative)
0449    
0450            default:
0451                throw Error.NumberSymbolMissingDigits(offset: start)
0452            }
0453        }
0454    
0455        private mutating func decodeNumberLeadingZeroJSONParser.swift:145                 return try decodeNumberLeadingZero(loc)
JSONParser.swift:445             return try decodeNumberLeadingZero(start, sign: .Negative)(start: Int, sign: Sign = .Positive) throws -> JSON {
0456            loc = loc.successor()
0457            guard loc < input.count else {
0458                return .Int(0)
0459            }
0460    
0461            switch (input[loc], sign) {
0462            case (Literal.PERIOD, _):
0463                return try decodeNumberDecimal(start, sign: sign, value: 0)
0464    
0465            case (_, .Negative):
0466                return .Double(-0.0)
0467    
0468            default:
0469                return .Int(0)
0470            }
0471        }
0472    
0473        private mutating func decodeNumberPreDecimalDigitsJSONParser.swift:148                 return try decodeNumberPreDecimalDigits(loc)
JSONParser.swift:448             return try decodeNumberPreDecimalDigits(start, sign: .Negative)(start: Int, sign: Sign = .Positive) throws -> JSON {
0474            var value = 0
0475    
0476            advancing: while loc < input.count {
0477                let c = input[loc]
0478                switch c {
0479                case Literal.zero...Literal.nine:
0480                    value = 10 * value + Int(c - Literal.zero)
0481                    loc = loc.successor()
0482    
0483                case Literal.PERIOD:
0484                    return try decodeNumberDecimal(start, sign: sign, value: Double(value))
0485    
0486                case Literal.e, Literal.E:
0487                    return try decodeNumberExponent(start, sign: sign, value: Double(value))
0488    
0489                default:
0490                    break advancing
0491                }
0492            }
0493    
0494            return .Int(sign.rawValue * value)
0495        }
0496    
0497        private mutating func decodeNumberDecimalJSONParser.swift:463             return try decodeNumberDecimal(start, sign: sign, value: 0)
JSONParser.swift:484                 return try decodeNumberDecimal(start, sign: sign, value: Double(value))(start: Int, sign: Sign, value: Double) throws -> JSON {
0498            loc = loc.successor()
0499            guard loc < input.count else {
0500                throw Error.EndOfStreamUnexpected
0501            }
0502    
0503            switch input[loc] {
0504            case Literal.zero...Literal.nine:
0505                return try decodeNumberPostDecimalDigits(start, sign: sign, value: value)
0506    
0507            default:
0508                throw Error.NumberMissingFractionalDigits(offset: start)
0509            }
0510        }
0511    
0512        private mutating func decodeNumberPostDecimalDigitsJSONParser.swift:505             return try decodeNumberPostDecimalDigits(start, sign: sign, value: value)(start: Int, sign: Sign, value inValue: Double) throws -> JSON {
0513            var value = inValue
0514            var position = 0.1
0515    
0516            advancing: while loc < input.count {
0517                let c = input[loc]
0518                switch c {
0519                case Literal.zero...Literal.nine:
0520                    value += position * Double(c - Literal.zero)
0521                    position /= 10
0522                    loc = loc.successor()
0523    
0524                case Literal.e, Literal.E:
0525                    return try decodeNumberExponent(start, sign: sign, value: value)
0526    
0527                default:
0528                    break advancing
0529                }
0530            }
0531    
0532            return .Double(Double(sign.rawValue) * value)
0533        }
0534    
0535        private mutating func decodeNumberExponentJSONParser.swift:487                 return try decodeNumberExponent(start, sign: sign, value: Double(value))
JSONParser.swift:525                 return try decodeNumberExponent(start, sign: sign, value: value)(start: Int, sign: Sign, value: Double) throws -> JSON {
0536            loc = loc.successor()
0537            guard loc < input.count else {
0538                throw Error.EndOfStreamUnexpected
0539            }
0540    
0541            switch input[loc] {
0542            case Literal.zero...Literal.nine:
0543                return try decodeNumberExponentDigits(start, sign: sign, value: value, expSign: .Positive)
0544    
0545            case Literal.PLUS:
0546                return try decodeNumberExponentSign(start, sign: sign, value: value, expSign: .Positive)
0547    
0548            case Literal.MINUS:
0549                return try decodeNumberExponentSign(start, sign: sign, value: value, expSign: .Negative)
0550    
0551            default:
0552                throw Error.NumberSymbolMissingDigits(offset: start)
0553            }
0554        }
0555    
0556        private mutating func decodeNumberExponentSignJSONParser.swift:546             return try decodeNumberExponentSign(start, sign: sign, value: value, expSign: .Positive)
JSONParser.swift:549             return try decodeNumberExponentSign(start, sign: sign, value: value, expSign: .Negative)(start: Int, sign: Sign, value: Double, expSign: Sign) throws -> JSON {
0557            loc = loc.successor()
0558            guard loc < input.count else {
0559                throw Error.EndOfStreamUnexpected
0560            }
0561    
0562            switch input[loc] {
0563            case Literal.zero...Literal.nine:
0564                return try decodeNumberExponentDigits(start, sign: sign, value: value, expSign: expSign)
0565    
0566            default:
0567                throw Error.NumberSymbolMissingDigits(offset: start)
0568            }
0569        }
0570    
0571        private mutating func decodeNumberExponentDigitsJSONParser.swift:543             return try decodeNumberExponentDigits(start, sign: sign, value: value, expSign: .Positive)
JSONParser.swift:564             return try decodeNumberExponentDigits(start, sign: sign, value: value, expSign: expSign)(start: Int, sign: Sign, value: Double, expSign: Sign) throws -> JSON {
0572            var exponent: Double = 0
0573    
0574            advancing: while loc < input.count {
0575                let c = input[loc]
0576                switch c {
0577                case Literal.zero...Literal.nine:
0578                    exponent = exponent * 10 + Double(c - Literal.zero)
0579                    loc = loc.successor()
0580    
0581                default:
0582                    break advancing
0583                }
0584            }
0585    
0586            return .Double(Double(sign.rawValue) * value * pow(10, Double(expSign.rawValue) * exponent))
0587        }
0588    }
0589    
0590    public extension JSONParser {
0591    
0592        /// Creates a `JSONParser` ready to parse UTF-8 encoded `NSData`.
0593        ///
0594        /// If the data is mutable, it is copied before parsing. The data's lifetime
0595        /// is extended for the duration of parsing.
0596        initJSONParser.swift:623         var parser = JSONParser(utf8Data: data)(utf8Data inData: NSData) {
0597            let data = inData.copy() as! NSData
0598            let buffer = UnsafeBufferPointer(start: UnsafePointer<UInt8>(data.bytes), count: data.length)
0599            self.init(buffer: buffer, owner: data)
0600        }
0601    
0602        /// Creates a `JSONParser` from the code units represented by the `string`.
0603        ///
0604        /// The synthesized string is lifetime-extended for the duration of parsing.
0605        init(string: String) {
0606            let codePoints = string.nulTerminatedUTF8
0607            let buffer = codePoints.withUnsafeBufferPointer { nulTerminatedBuffer in
0608                // don't want to include the nul termination in the buffer - trim it off
0609                UnsafeBufferPointer(start: nulTerminatedBuffer.baseAddress, count: nulTerminatedBuffer.count - 1)
0610            }
0611            self.init(buffer: buffer, owner: codePoints)
0612        }
0613    
0614    }
0615    
0616    extension JSONParser: JSONParserType {
0617    
0618        /// Creates an instance of `JSON` from UTF-8 encoded `NSData`.
0619        /// - parameter data: An instance of `NSData` to parse `JSON` from.
0620        /// - throws: Any `JSONParser.Error` that arises during decoding.
0621        /// - seealso: JSONParser.parse()
0622        public static func createJSONFromData(data: NSData) throws -> JSON {
0623            var parser = JSONParser(utf8Data: data)
0624            return try parser.parse()
0625        }
0626    
0627    }
0628    
0629    // MARK: - Errors
0630    
0631    extension JSONParser {
0632    
0633        /// Enumeration describing possible errors that occur while parsing a JSON
0634        /// document. Most errors include an associated `offset`, representing the
0635        /// offset into the UTF-8 characters making up the document where the error
0636        /// occurred.
0637        public enum ErrorJSONParser.swift:103             throw Error.EndOfStreamGarbage(offset: loc)
JSONParser.swift:110             throw Error.ExceededNestingLimit(offset: loc)
JSONParser.swift:114             throw Error.EndOfStreamUnexpected
JSONParser.swift:158         throw Error.ValueInvalid(offset: loc, character: UnicodeScalar(input[loc]))
JSONParser.swift:177             throw Error.InvalidUnicodeStreamEncoding(detectedEncoding: encodingPrefixInformation.encoding)
JSONParser.swift:184             throw Error.LiteralNilMisspelled(offset: loc)
JSONParser.swift:190                 throw Error.LiteralNilMisspelled(offset: loc)
JSONParser.swift:199             throw Error.LiteralTrueMisspelled(offset: loc)
JSONParser.swift:205             throw Error.LiteralTrueMisspelled(offset: loc)
JSONParser.swift:214             throw Error.LiteralFalseMisspelled(offset: loc)
JSONParser.swift:221             throw Error.LiteralFalseMisspelled(offset: loc)
JSONParser.swift:255                     throw Error.ControlCharacterUnrecognized(offset: loc)
JSONParser.swift:266                     throw Error.UnicodeEscapeInvalid(offset: start)
JSONParser.swift:277         throw Error.EndOfStreamUnexpected
JSONParser.swift:309             throw Error.UnicodeEscapeInvalid(offset: start)
JSONParser.swift:319                 throw Error.UnicodeEscapeInvalid(offset: start)
JSONParser.swift:325                 throw Error.UnicodeEscapeInvalid(offset: start)
JSONParser.swift:336             throw Error.UnicodeEscapeInvalid(offset: start)
JSONParser.swift:355                     throw Error.CollectionMissingSeparator(offset: start)
JSONParser.swift:363         throw Error.EndOfStreamUnexpected
JSONParser.swift:412                     throw Error.CollectionMissingSeparator(offset: start)
JSONParser.swift:420                 throw Error.DictionaryMissingKey(offset: start)
JSONParser.swift:427                 throw Error.CollectionMissingSeparator(offset: start)
JSONParser.swift:434         throw Error.EndOfStreamUnexpected
JSONParser.swift:440             throw Error.EndOfStreamUnexpected
JSONParser.swift:451             throw Error.NumberSymbolMissingDigits(offset: start)
JSONParser.swift:500             throw Error.EndOfStreamUnexpected
JSONParser.swift:508             throw Error.NumberMissingFractionalDigits(offset: start)
JSONParser.swift:538             throw Error.EndOfStreamUnexpected
JSONParser.swift:552             throw Error.NumberSymbolMissingDigits(offset: start)
JSONParser.swift:559             throw Error.EndOfStreamUnexpected
JSONParser.swift:567             throw Error.NumberSymbolMissingDigits(offset: start): ErrorType {
0638            /// The parser ran out of data prematurely. This usually means a value
0639            /// was not escaped, such as a string literal not ending with a double
0640            /// quote.
0641            case EndOfStreamUnexpectedJSONParser.swift:114             throw Error.EndOfStreamUnexpected
JSONParser.swift:277         throw Error.EndOfStreamUnexpected
JSONParser.swift:363         throw Error.EndOfStreamUnexpected
JSONParser.swift:434         throw Error.EndOfStreamUnexpected
JSONParser.swift:440             throw Error.EndOfStreamUnexpected
JSONParser.swift:500             throw Error.EndOfStreamUnexpected
JSONParser.swift:538             throw Error.EndOfStreamUnexpected
JSONParser.swift:559             throw Error.EndOfStreamUnexpected
0642            
0643            /// Unexpected non-whitespace data was left around `offset` after
0644            /// parsing all valid JSON.
0645            case EndOfStreamGarbageJSONParser.swift:103             throw Error.EndOfStreamGarbage(offset: loc)(offset: Int)
0646            
0647            /// Too many nested objects or arrays occured at the literal started
0648            /// around `offset`.
0649            case ExceededNestingLimitJSONParser.swift:110             throw Error.ExceededNestingLimit(offset: loc)(offset: Int)
0650            
0651            /// A `character` was not a valid start of a value around `offset`.
0652            case ValueInvalidJSONParser.swift:158         throw Error.ValueInvalid(offset: loc, character: UnicodeScalar(input[loc]))(offset: Int, character: UnicodeScalar)
0653            
0654            /// Badly-formed Unicode escape sequence at `offset`. A Unicode escape
0655            /// uses the text "\u" followed by 4 hex digits, such as "\uF09F\uA684"
0656            /// to represent U+1F984, "UNICORN FACE".
0657            case UnicodeEscapeInvalidJSONParser.swift:266                     throw Error.UnicodeEscapeInvalid(offset: start)
JSONParser.swift:309             throw Error.UnicodeEscapeInvalid(offset: start)
JSONParser.swift:319                 throw Error.UnicodeEscapeInvalid(offset: start)
JSONParser.swift:325                 throw Error.UnicodeEscapeInvalid(offset: start)
JSONParser.swift:336             throw Error.UnicodeEscapeInvalid(offset: start)(offset: Int)
0658            
0659            /// Badly-formed control character around `offset`. JSON supports
0660            /// backslash-escaped double quotes, slashes, whitespace control codes,
0661            /// and Unicode escape sequences.
0662            case ControlCharacterUnrecognizedJSONParser.swift:255                     throw Error.ControlCharacterUnrecognized(offset: loc)(offset: Int)
0663            
0664            /// Invalid token, expected `null` around `offset`
0665            case LiteralNilMisspelledJSONParser.swift:184             throw Error.LiteralNilMisspelled(offset: loc)
JSONParser.swift:190                 throw Error.LiteralNilMisspelled(offset: loc)(offset: Int)
0666            
0667            /// Invalid token, expected `true` around `offset`
0668            case LiteralTrueMisspelledJSONParser.swift:199             throw Error.LiteralTrueMisspelled(offset: loc)
JSONParser.swift:205             throw Error.LiteralTrueMisspelled(offset: loc)(offset: Int)
0669            
0670            /// Invalid token, expected `false` around `offset`
0671            case LiteralFalseMisspelledJSONParser.swift:214             throw Error.LiteralFalseMisspelled(offset: loc)
JSONParser.swift:221             throw Error.LiteralFalseMisspelled(offset: loc)(offset: Int)
0672            
0673            /// Badly-formed collection at given `offset`, expected `,` or `:`
0674            case CollectionMissingSeparatorJSONParser.swift:355                     throw Error.CollectionMissingSeparator(offset: start)
JSONParser.swift:412                     throw Error.CollectionMissingSeparator(offset: start)
JSONParser.swift:427                 throw Error.CollectionMissingSeparator(offset: start)(offset: Int)
0675            
0676            /// While parsing an object literal, a value was found without a key
0677            /// around `offset`. The start of a string literal was expected.
0678            case DictionaryMissingKeyJSONParser.swift:420                 throw Error.DictionaryMissingKey(offset: start)(offset: Int)
0679            
0680            /// Badly-formed number with no digits around `offset`. After a decimal
0681            /// point, a number must include some number of digits.
0682            case NumberMissingFractionalDigitsJSONParser.swift:508             throw Error.NumberMissingFractionalDigits(offset: start)(offset: Int)
0683            
0684            /// Badly-formed number with symbols ("-" or "e") but no following
0685            /// digits around `offset`.
0686            case NumberSymbolMissingDigitsJSONParser.swift:451             throw Error.NumberSymbolMissingDigits(offset: start)
JSONParser.swift:552             throw Error.NumberSymbolMissingDigits(offset: start)
JSONParser.swift:567             throw Error.NumberSymbolMissingDigits(offset: start)(offset: Int)
0687    
0688            /// Supplied data is encoded in an unsupported format.
0689            case InvalidUnicodeStreamEncodingJSONParser.swift:177             throw Error.InvalidUnicodeStreamEncoding(detectedEncoding: encodingPrefixInformation.encoding)(detectedEncoding: JSONEncodingDetector.Encoding)
0690        }
0691    
0692    }
0693

JSONParser.swift:119	case Literal.LEFT_BRACKET:
JSONParser.swift:124	case Literal.LEFT_BRACE:
JSONParser.swift:129	case Literal.DOUBLE_QUOTE:
JSONParser.swift:132	case Literal.f:
JSONParser.swift:135	case Literal.n:
JSONParser.swift:138	case Literal.t:
JSONParser.swift:141	case Literal.MINUS:
JSONParser.swift:144	case Literal.zero:
JSONParser.swift:147	case Literal.one...Literal.nine:
JSONParser.swift:147	case Literal.one...Literal.nine:
JSONParser.swift:150	case Literal.SPACE, Literal.TAB, Literal.RETURN, Literal.NEWLINE:
JSONParser.swift:150	case Literal.SPACE, Literal.TAB, Literal.RETURN, Literal.NEWLINE:
JSONParser.swift:150	case Literal.SPACE, Literal.TAB, Literal.RETURN, Literal.NEWLINE:
JSONParser.swift:150	case Literal.SPACE, Literal.TAB, Literal.RETURN, Literal.NEWLINE:
JSONParser.swift:164	case Literal.SPACE, Literal.TAB, Literal.RETURN, Literal.NEWLINE:
JSONParser.swift:164	case Literal.SPACE, Literal.TAB, Literal.RETURN, Literal.NEWLINE:
JSONParser.swift:164	case Literal.SPACE, Literal.TAB, Literal.RETURN, Literal.NEWLINE:
JSONParser.swift:164	case Literal.SPACE, Literal.TAB, Literal.RETURN, Literal.NEWLINE:
JSONParser.swift:187	if input[loc+1] != Literal.u
JSONParser.swift:188	\|\| input[loc+2] != Literal.l
JSONParser.swift:189	\|\| input[loc+3] != Literal.l {
JSONParser.swift:202	if input[loc+1] != Literal.r
JSONParser.swift:203	\|\| input[loc+2] != Literal.u
JSONParser.swift:204	\|\| input[loc+3] != Literal.e {
JSONParser.swift:217	if input[loc+1] != Literal.a
JSONParser.swift:218	\|\| input[loc+2] != Literal.l
JSONParser.swift:219	\|\| input[loc+3] != Literal.s
JSONParser.swift:220	\|\| input[loc+4] != Literal.e {
JSONParser.swift:235	case Literal.BACKSLASH:
JSONParser.swift:238	case Literal.DOUBLE_QUOTE: stringDecodingBuffer.append(Literal.DOUBLE_QUOTE)
JSONParser.swift:238	case Literal.DOUBLE_QUOTE: stringDecodingBuffer.append(Literal.DOUBLE_QUOTE)
JSONParser.swift:239	case Literal.BACKSLASH: stringDecodingBuffer.append(Literal.BACKSLASH)
JSONParser.swift:239	case Literal.BACKSLASH: stringDecodingBuffer.append(Literal.BACKSLASH)
JSONParser.swift:240	case Literal.SLASH: stringDecodingBuffer.append(Literal.SLASH)
JSONParser.swift:240	case Literal.SLASH: stringDecodingBuffer.append(Literal.SLASH)
JSONParser.swift:241	case Literal.b: stringDecodingBuffer.append(Literal.BACKSPACE)
JSONParser.swift:241	case Literal.b: stringDecodingBuffer.append(Literal.BACKSPACE)
JSONParser.swift:242	case Literal.f: stringDecodingBuffer.append(Literal.FORMFEED)
JSONParser.swift:242	case Literal.f: stringDecodingBuffer.append(Literal.FORMFEED)
JSONParser.swift:243	case Literal.r: stringDecodingBuffer.append(Literal.RETURN)
JSONParser.swift:243	case Literal.r: stringDecodingBuffer.append(Literal.RETURN)
JSONParser.swift:244	case Literal.t: stringDecodingBuffer.append(Literal.TAB)
JSONParser.swift:244	case Literal.t: stringDecodingBuffer.append(Literal.TAB)
JSONParser.swift:245	case Literal.n: stringDecodingBuffer.append(Literal.NEWLINE)
JSONParser.swift:245	case Literal.n: stringDecodingBuffer.append(Literal.NEWLINE)
JSONParser.swift:246	case Literal.u:
JSONParser.swift:259	case Literal.DOUBLE_QUOTE:
JSONParser.swift:289	case Literal.zero...Literal.nine:
JSONParser.swift:289	case Literal.zero...Literal.nine:
JSONParser.swift:290	nibble = UInt16(c - Literal.zero)
JSONParser.swift:292	case Literal.a...Literal.f:
JSONParser.swift:292	case Literal.a...Literal.f:
JSONParser.swift:293	nibble = 10 + UInt16(c - Literal.a)
JSONParser.swift:295	case Literal.A...Literal.F:
JSONParser.swift:295	case Literal.A...Literal.F:
JSONParser.swift:296	nibble = 10 + UInt16(c - Literal.A)
JSONParser.swift:318	guard loc + 6 <= input.count && input[loc] == Literal.BACKSLASH && input[loc+1] == Literal.u else {
JSONParser.swift:318	guard loc + 6 <= input.count && input[loc] == Literal.BACKSLASH && input[loc+1] == Literal.u else {
JSONParser.swift:348	if loc < input.count && input[loc] == Literal.RIGHT_BRACKET {
JSONParser.swift:354	guard loc < input.count && input[loc] == Literal.COMMA else {
JSONParser.swift:400	if loc < input.count && input[loc] == Literal.RIGHT_BRACE {
JSONParser.swift:411	guard loc < input.count && input[loc] == Literal.COMMA else {
JSONParser.swift:419	guard loc < input.count && input[loc] == Literal.DOUBLE_QUOTE else {
JSONParser.swift:426	guard loc < input.count && input[loc] == Literal.COLON else {
JSONParser.swift:444	case Literal.zero:
JSONParser.swift:447	case Literal.one...Literal.nine:
JSONParser.swift:447	case Literal.one...Literal.nine:
JSONParser.swift:462	case (Literal.PERIOD, _):
JSONParser.swift:479	case Literal.zero...Literal.nine:
JSONParser.swift:479	case Literal.zero...Literal.nine:
JSONParser.swift:480	value = 10 * value + Int(c - Literal.zero)
JSONParser.swift:483	case Literal.PERIOD:
JSONParser.swift:486	case Literal.e, Literal.E:
JSONParser.swift:486	case Literal.e, Literal.E:
JSONParser.swift:504	case Literal.zero...Literal.nine:
JSONParser.swift:504	case Literal.zero...Literal.nine:
JSONParser.swift:519	case Literal.zero...Literal.nine:
JSONParser.swift:519	case Literal.zero...Literal.nine:
JSONParser.swift:520	value += position * Double(c - Literal.zero)
JSONParser.swift:524	case Literal.e, Literal.E:
JSONParser.swift:524	case Literal.e, Literal.E:
JSONParser.swift:542	case Literal.zero...Literal.nine:
JSONParser.swift:542	case Literal.zero...Literal.nine:
JSONParser.swift:545	case Literal.PLUS:
JSONParser.swift:548	case Literal.MINUS:
JSONParser.swift:563	case Literal.zero...Literal.nine:
JSONParser.swift:563	case Literal.zero...Literal.nine:
JSONParser.swift:577	case Literal.zero...Literal.nine:
JSONParser.swift:577	case Literal.zero...Literal.nine:
JSONParser.swift:578	exponent = exponent * 10 + Double(c - Literal.zero)

JSONParser.swift:235	case Literal.BACKSLASH:
JSONParser.swift:239	case Literal.BACKSLASH: stringDecodingBuffer.append(Literal.BACKSLASH)
JSONParser.swift:239	case Literal.BACKSLASH: stringDecodingBuffer.append(Literal.BACKSLASH)
JSONParser.swift:318	guard loc + 6 <= input.count && input[loc] == Literal.BACKSLASH && input[loc+1] == Literal.u else {

JSONParser.swift:129	case Literal.DOUBLE_QUOTE:
JSONParser.swift:238	case Literal.DOUBLE_QUOTE: stringDecodingBuffer.append(Literal.DOUBLE_QUOTE)
JSONParser.swift:238	case Literal.DOUBLE_QUOTE: stringDecodingBuffer.append(Literal.DOUBLE_QUOTE)
JSONParser.swift:259	case Literal.DOUBLE_QUOTE:
JSONParser.swift:419	guard loc < input.count && input[loc] == Literal.DOUBLE_QUOTE else {

JSONParser.swift:141	case Literal.MINUS:
JSONParser.swift:548	case Literal.MINUS:

JSONParser.swift:462	case (Literal.PERIOD, _):
JSONParser.swift:483	case Literal.PERIOD:

JSONParser.swift:217	if input[loc+1] != Literal.a
JSONParser.swift:292	case Literal.a...Literal.f:
JSONParser.swift:293	nibble = 10 + UInt16(c - Literal.a)

JSONParser.swift:204	\|\| input[loc+3] != Literal.e {
JSONParser.swift:220	\|\| input[loc+4] != Literal.e {
JSONParser.swift:486	case Literal.e, Literal.E:
JSONParser.swift:524	case Literal.e, Literal.E:

JSONParser.swift:132	case Literal.f:
JSONParser.swift:242	case Literal.f: stringDecodingBuffer.append(Literal.FORMFEED)
JSONParser.swift:292	case Literal.a...Literal.f:

JSONParser.swift:188	\|\| input[loc+2] != Literal.l
JSONParser.swift:189	\|\| input[loc+3] != Literal.l {
JSONParser.swift:218	\|\| input[loc+2] != Literal.l

JSONParser.swift:135	case Literal.n:
JSONParser.swift:245	case Literal.n: stringDecodingBuffer.append(Literal.NEWLINE)

JSONParser.swift:202	if input[loc+1] != Literal.r
JSONParser.swift:243	case Literal.r: stringDecodingBuffer.append(Literal.RETURN)

JSONParser.swift:138	case Literal.t:
JSONParser.swift:244	case Literal.t: stringDecodingBuffer.append(Literal.TAB)

JSONParser.swift:187	if input[loc+1] != Literal.u
JSONParser.swift:203	\|\| input[loc+2] != Literal.u
JSONParser.swift:246	case Literal.u:
JSONParser.swift:318	guard loc + 6 <= input.count && input[loc] == Literal.BACKSLASH && input[loc+1] == Literal.u else {

JSONParser.swift:144	case Literal.zero:
JSONParser.swift:289	case Literal.zero...Literal.nine:
JSONParser.swift:290	nibble = UInt16(c - Literal.zero)
JSONParser.swift:444	case Literal.zero:
JSONParser.swift:479	case Literal.zero...Literal.nine:
JSONParser.swift:480	value = 10 * value + Int(c - Literal.zero)
JSONParser.swift:504	case Literal.zero...Literal.nine:
JSONParser.swift:519	case Literal.zero...Literal.nine:
JSONParser.swift:520	value += position * Double(c - Literal.zero)
JSONParser.swift:542	case Literal.zero...Literal.nine:
JSONParser.swift:563	case Literal.zero...Literal.nine:
JSONParser.swift:577	case Literal.zero...Literal.nine:
JSONParser.swift:578	exponent = exponent * 10 + Double(c - Literal.zero)

JSONParser.swift:590	public extension JSONParser {
JSONParser.swift:616	extension JSONParser: JSONParserType {
JSONParser.swift:623	var parser = JSONParser(utf8Data: data)
JSONParser.swift:631	extension JSONParser {
JSONParsing.swift:28	public init(data: NSData, usingParser parser: JSONParserType.Type = JSONParser.self) throws {
JSONParsing.swift:33	public init(jsonString: Swift.String, usingParser parser: JSONParserType.Type = JSONParser.self) throws {

JSONParser.swift:455	private mutating func decodeNumberLeadingZero(start: Int, sign: Sign = .Positive) throws -> JSON {
JSONParser.swift:473	private mutating func decodeNumberPreDecimalDigits(start: Int, sign: Sign = .Positive) throws -> JSON {
JSONParser.swift:497	private mutating func decodeNumberDecimal(start: Int, sign: Sign, value: Double) throws -> JSON {
JSONParser.swift:512	private mutating func decodeNumberPostDecimalDigits(start: Int, sign: Sign, value inValue: Double) throws -> JSON {
JSONParser.swift:535	private mutating func decodeNumberExponent(start: Int, sign: Sign, value: Double) throws -> JSON {
JSONParser.swift:556	private mutating func decodeNumberExponentSign(start: Int, sign: Sign, value: Double, expSign: Sign) throws -> JSON {
JSONParser.swift:556	private mutating func decodeNumberExponentSign(start: Int, sign: Sign, value: Double, expSign: Sign) throws -> JSON {
JSONParser.swift:571	private mutating func decodeNumberExponentDigits(start: Int, sign: Sign, value: Double, expSign: Sign) throws -> JSON {
JSONParser.swift:571	private mutating func decodeNumberExponentDigits(start: Int, sign: Sign, value: Double, expSign: Sign) throws -> JSON {

JSONParser.swift:445	return try decodeNumberLeadingZero(start, sign: .Negative)
JSONParser.swift:448	return try decodeNumberPreDecimalDigits(start, sign: .Negative)
JSONParser.swift:465	case (_, .Negative):
JSONParser.swift:549	return try decodeNumberExponentSign(start, sign: sign, value: value, expSign: .Negative)

JSONParser.swift:85	self.input = buffer
JSONParser.swift:102	guard loc == input.count else {
JSONParser.swift:113	guard input.count > 0 else {
JSONParser.swift:117	advancing: while loc < input.count {
JSONParser.swift:118	switch input[loc] {
JSONParser.swift:158	throw Error.ValueInvalid(offset: loc, character: UnicodeScalar(input[loc]))
JSONParser.swift:162	while loc < input.count {
JSONParser.swift:163	switch input[loc] {
JSONParser.swift:174	let header = input.prefix(4)
JSONParser.swift:183	guard loc.advancedBy(3, limit: input.count) != input.count else {
JSONParser.swift:183	guard loc.advancedBy(3, limit: input.count) != input.count else {
JSONParser.swift:187	if input[loc+1] != Literal.u
JSONParser.swift:188	\|\| input[loc+2] != Literal.l
JSONParser.swift:189	\|\| input[loc+3] != Literal.l {
JSONParser.swift:198	guard loc.advancedBy(3, limit: input.count) != input.count else {
JSONParser.swift:198	guard loc.advancedBy(3, limit: input.count) != input.count else {
JSONParser.swift:202	if input[loc+1] != Literal.r
JSONParser.swift:203	\|\| input[loc+2] != Literal.u
JSONParser.swift:204	\|\| input[loc+3] != Literal.e {
JSONParser.swift:213	guard loc.advancedBy(4, limit: input.count) != input.count else {
JSONParser.swift:213	guard loc.advancedBy(4, limit: input.count) != input.count else {
JSONParser.swift:217	if input[loc+1] != Literal.a
JSONParser.swift:218	\|\| input[loc+2] != Literal.l
JSONParser.swift:219	\|\| input[loc+3] != Literal.s
JSONParser.swift:220	\|\| input[loc+4] != Literal.e {
JSONParser.swift:233	while loc < input.count {
JSONParser.swift:234	switch input[loc] {
JSONParser.swift:237	switch input[loc] {
JSONParser.swift:281	guard loc + 4 <= input.count else {
JSONParser.swift:285	for c in input[loc..<loc+4] {
JSONParser.swift:318	guard loc + 6 <= input.count && input[loc] == Literal.BACKSLASH && input[loc+1] == Literal.u else {
JSONParser.swift:318	guard loc + 6 <= input.count && input[loc] == Literal.BACKSLASH && input[loc+1] == Literal.u else {
JSONParser.swift:318	guard loc + 6 <= input.count && input[loc] == Literal.BACKSLASH && input[loc+1] == Literal.u else {
JSONParser.swift:345	while loc < input.count {
JSONParser.swift:348	if loc < input.count && input[loc] == Literal.RIGHT_BRACKET {
JSONParser.swift:348	if loc < input.count && input[loc] == Literal.RIGHT_BRACKET {
JSONParser.swift:354	guard loc < input.count && input[loc] == Literal.COMMA else {
JSONParser.swift:354	guard loc < input.count && input[loc] == Literal.COMMA else {
JSONParser.swift:397	while loc < input.count {
JSONParser.swift:400	if loc < input.count && input[loc] == Literal.RIGHT_BRACE {
JSONParser.swift:400	if loc < input.count && input[loc] == Literal.RIGHT_BRACE {
JSONParser.swift:411	guard loc < input.count && input[loc] == Literal.COMMA else {
JSONParser.swift:411	guard loc < input.count && input[loc] == Literal.COMMA else {
JSONParser.swift:419	guard loc < input.count && input[loc] == Literal.DOUBLE_QUOTE else {
JSONParser.swift:419	guard loc < input.count && input[loc] == Literal.DOUBLE_QUOTE else {
JSONParser.swift:426	guard loc < input.count && input[loc] == Literal.COLON else {
JSONParser.swift:426	guard loc < input.count && input[loc] == Literal.COLON else {
JSONParser.swift:439	guard loc < input.count else {
JSONParser.swift:443	switch input[loc] {
JSONParser.swift:457	guard loc < input.count else {
JSONParser.swift:461	switch (input[loc], sign) {
JSONParser.swift:476	advancing: while loc < input.count {
JSONParser.swift:477	let c = input[loc]
JSONParser.swift:499	guard loc < input.count else {
JSONParser.swift:503	switch input[loc] {
JSONParser.swift:516	advancing: while loc < input.count {
JSONParser.swift:517	let c = input[loc]
JSONParser.swift:537	guard loc < input.count else {
JSONParser.swift:541	switch input[loc] {
JSONParser.swift:558	guard loc < input.count else {
JSONParser.swift:562	switch input[loc] {
JSONParser.swift:574	advancing: while loc < input.count {
JSONParser.swift:575	let c = input[loc]

JSONParser.swift:102	guard loc == input.count else {
JSONParser.swift:103	throw Error.EndOfStreamGarbage(offset: loc)
JSONParser.swift:110	throw Error.ExceededNestingLimit(offset: loc)
JSONParser.swift:117	advancing: while loc < input.count {
JSONParser.swift:118	switch input[loc] {
JSONParser.swift:142	return try decodeNumberNegative(loc)
JSONParser.swift:145	return try decodeNumberLeadingZero(loc)
JSONParser.swift:148	return try decodeNumberPreDecimalDigits(loc)
JSONParser.swift:151	loc = loc.successor()
JSONParser.swift:151	loc = loc.successor()
JSONParser.swift:158	throw Error.ValueInvalid(offset: loc, character: UnicodeScalar(input[loc]))
JSONParser.swift:158	throw Error.ValueInvalid(offset: loc, character: UnicodeScalar(input[loc]))
JSONParser.swift:162	while loc < input.count {
JSONParser.swift:163	switch input[loc] {
JSONParser.swift:165	loc = loc.successor()
JSONParser.swift:165	loc = loc.successor()
JSONParser.swift:179	loc = loc.advancedBy(encodingPrefixInformation.byteOrderMarkLength)
JSONParser.swift:179	loc = loc.advancedBy(encodingPrefixInformation.byteOrderMarkLength)
JSONParser.swift:183	guard loc.advancedBy(3, limit: input.count) != input.count else {
JSONParser.swift:184	throw Error.LiteralNilMisspelled(offset: loc)
JSONParser.swift:187	if input[loc+1] != Literal.u
JSONParser.swift:188	\|\| input[loc+2] != Literal.l
JSONParser.swift:189	\|\| input[loc+3] != Literal.l {
JSONParser.swift:190	throw Error.LiteralNilMisspelled(offset: loc)
JSONParser.swift:193	loc += 4
JSONParser.swift:198	guard loc.advancedBy(3, limit: input.count) != input.count else {
JSONParser.swift:199	throw Error.LiteralTrueMisspelled(offset: loc)
JSONParser.swift:202	if input[loc+1] != Literal.r
JSONParser.swift:203	\|\| input[loc+2] != Literal.u
JSONParser.swift:204	\|\| input[loc+3] != Literal.e {
JSONParser.swift:205	throw Error.LiteralTrueMisspelled(offset: loc)
JSONParser.swift:208	loc += 4
JSONParser.swift:213	guard loc.advancedBy(4, limit: input.count) != input.count else {
JSONParser.swift:214	throw Error.LiteralFalseMisspelled(offset: loc)
JSONParser.swift:217	if input[loc+1] != Literal.a
JSONParser.swift:218	\|\| input[loc+2] != Literal.l
JSONParser.swift:219	\|\| input[loc+3] != Literal.s
JSONParser.swift:220	\|\| input[loc+4] != Literal.e {
JSONParser.swift:221	throw Error.LiteralFalseMisspelled(offset: loc)
JSONParser.swift:224	loc += 5
JSONParser.swift:230	let start = loc
JSONParser.swift:231	loc = loc.successor()
JSONParser.swift:231	loc = loc.successor()
JSONParser.swift:233	while loc < input.count {
JSONParser.swift:234	switch input[loc] {
JSONParser.swift:236	loc = loc.successor()
JSONParser.swift:236	loc = loc.successor()
JSONParser.swift:237	switch input[loc] {
JSONParser.swift:247	loc = loc.successor()
JSONParser.swift:247	loc = loc.successor()
JSONParser.swift:248	try readUnicodeEscape(start: loc - 2)
JSONParser.swift:255	throw Error.ControlCharacterUnrecognized(offset: loc)
JSONParser.swift:257	loc = loc.successor()
JSONParser.swift:257	loc = loc.successor()
JSONParser.swift:260	loc = loc.successor()
JSONParser.swift:260	loc = loc.successor()
JSONParser.swift:273	loc = loc.successor()
JSONParser.swift:273	loc = loc.successor()
JSONParser.swift:281	guard loc + 4 <= input.count else {
JSONParser.swift:285	for c in input[loc..<loc+4] {
JSONParser.swift:285	for c in input[loc..<loc+4] {
JSONParser.swift:303	loc += 4
JSONParser.swift:318	guard loc + 6 <= input.count && input[loc] == Literal.BACKSLASH && input[loc+1] == Literal.u else {
JSONParser.swift:318	guard loc + 6 <= input.count && input[loc] == Literal.BACKSLASH && input[loc+1] == Literal.u else {
JSONParser.swift:318	guard loc + 6 <= input.count && input[loc] == Literal.BACKSLASH && input[loc+1] == Literal.u else {
JSONParser.swift:321	loc += 2
JSONParser.swift:341	let start = loc
JSONParser.swift:342	loc = loc.successor()
JSONParser.swift:342	loc = loc.successor()
JSONParser.swift:345	while loc < input.count {
JSONParser.swift:348	if loc < input.count && input[loc] == Literal.RIGHT_BRACKET {
JSONParser.swift:348	if loc < input.count && input[loc] == Literal.RIGHT_BRACKET {
JSONParser.swift:349	loc = loc.successor()
JSONParser.swift:349	loc = loc.successor()
JSONParser.swift:354	guard loc < input.count && input[loc] == Literal.COMMA else {
JSONParser.swift:354	guard loc < input.count && input[loc] == Literal.COMMA else {
JSONParser.swift:357	loc = loc.successor()
JSONParser.swift:357	loc = loc.successor()
JSONParser.swift:393	let start = loc
JSONParser.swift:394	loc = loc.successor()
JSONParser.swift:394	loc = loc.successor()
JSONParser.swift:397	while loc < input.count {
JSONParser.swift:400	if loc < input.count && input[loc] == Literal.RIGHT_BRACE {
JSONParser.swift:400	if loc < input.count && input[loc] == Literal.RIGHT_BRACE {
JSONParser.swift:401	loc = loc.successor()
JSONParser.swift:401	loc = loc.successor()
JSONParser.swift:411	guard loc < input.count && input[loc] == Literal.COMMA else {
JSONParser.swift:411	guard loc < input.count && input[loc] == Literal.COMMA else {
JSONParser.swift:414	loc = loc.successor()
JSONParser.swift:414	loc = loc.successor()
JSONParser.swift:419	guard loc < input.count && input[loc] == Literal.DOUBLE_QUOTE else {
JSONParser.swift:419	guard loc < input.count && input[loc] == Literal.DOUBLE_QUOTE else {
JSONParser.swift:426	guard loc < input.count && input[loc] == Literal.COLON else {
JSONParser.swift:426	guard loc < input.count && input[loc] == Literal.COLON else {
JSONParser.swift:429	loc = loc.successor()
JSONParser.swift:429	loc = loc.successor()
JSONParser.swift:438	loc = loc.successor()
JSONParser.swift:438	loc = loc.successor()
JSONParser.swift:439	guard loc < input.count else {
JSONParser.swift:443	switch input[loc] {
JSONParser.swift:456	loc = loc.successor()
JSONParser.swift:456	loc = loc.successor()
JSONParser.swift:457	guard loc < input.count else {
JSONParser.swift:461	switch (input[loc], sign) {
JSONParser.swift:476	advancing: while loc < input.count {
JSONParser.swift:477	let c = input[loc]
JSONParser.swift:481	loc = loc.successor()
JSONParser.swift:481	loc = loc.successor()
JSONParser.swift:498	loc = loc.successor()
JSONParser.swift:498	loc = loc.successor()
JSONParser.swift:499	guard loc < input.count else {
JSONParser.swift:503	switch input[loc] {
JSONParser.swift:516	advancing: while loc < input.count {
JSONParser.swift:517	let c = input[loc]
JSONParser.swift:522	loc = loc.successor()
JSONParser.swift:522	loc = loc.successor()
JSONParser.swift:536	loc = loc.successor()
JSONParser.swift:536	loc = loc.successor()
JSONParser.swift:537	guard loc < input.count else {
JSONParser.swift:541	switch input[loc] {
JSONParser.swift:557	loc = loc.successor()
JSONParser.swift:557	loc = loc.successor()
JSONParser.swift:558	guard loc < input.count else {
JSONParser.swift:562	switch input[loc] {
JSONParser.swift:574	advancing: while loc < input.count {
JSONParser.swift:575	let c = input[loc]
JSONParser.swift:579	loc = loc.successor()
JSONParser.swift:579	loc = loc.successor()

JSONParser.swift:109	guard depth <= ParserMaximumDepth else {
JSONParser.swift:120	depth += 1
JSONParser.swift:121	defer { depth -= 1 }
JSONParser.swift:125	depth += 1
JSONParser.swift:126	defer { depth -= 1 }

JSONParser.swift:599	self.init(buffer: buffer, owner: data)
JSONParser.swift:611	self.init(buffer: buffer, owner: codePoints)

JSONParser.swift:100	let value = try parseValue()
JSONParser.swift:360	items.append(try parseValue())
JSONParser.swift:431	pairs.append((key, try parseValue()))

JSONParser.swift:101	skipWhitespace()
JSONParser.swift:346	skipWhitespace()
JSONParser.swift:398	skipWhitespace()
JSONParser.swift:416	skipWhitespace()
JSONParser.swift:424	skipWhitespace()

JSONParser.swift:232	stringDecodingBuffer.removeAll(keepCapacity: true)
JSONParser.swift:238	case Literal.DOUBLE_QUOTE: stringDecodingBuffer.append(Literal.DOUBLE_QUOTE)
JSONParser.swift:239	case Literal.BACKSLASH: stringDecodingBuffer.append(Literal.BACKSLASH)
JSONParser.swift:240	case Literal.SLASH: stringDecodingBuffer.append(Literal.SLASH)
JSONParser.swift:241	case Literal.b: stringDecodingBuffer.append(Literal.BACKSPACE)
JSONParser.swift:242	case Literal.f: stringDecodingBuffer.append(Literal.FORMFEED)
JSONParser.swift:243	case Literal.r: stringDecodingBuffer.append(Literal.RETURN)
JSONParser.swift:244	case Literal.t: stringDecodingBuffer.append(Literal.TAB)
JSONParser.swift:245	case Literal.n: stringDecodingBuffer.append(Literal.NEWLINE)
JSONParser.swift:261	stringDecodingBuffer.append(0)
JSONParser.swift:263	guard let string = (stringDecodingBuffer.withUnsafeBufferPointer {
JSONParser.swift:272	stringDecodingBuffer.append(other)
JSONParser.swift:333	let transcodeHadError = transcode(UTF16.self, UTF8.self, codeUnits.generate(), { self.stringDecodingBuffer.append($0) }, stopOnError: true)

JSONParser.swift:130	return try decodeString()
JSONParser.swift:423	let key = try decodeString().string()

JSONParser.swift:308	guard let codeUnit = readCodeUnit() else {
JSONParser.swift:324	guard let secondCodeUnit = readCodeUnit() where UTF16.isTrailSurrogate(secondCodeUnit) else {

JSONParser.swift:377	if !buffers.isEmpty {
JSONParser.swift:378	var buffer = buffers.removeLast()
JSONParser.swift:386	buffers.append(buffer)

JSONParser.swift:395	var pairs = decodeObjectBuffers.getBuffer()
JSONParser.swift:406	decodeObjectBuffers.putBuffer(pairs)

JSONParser.swift:145	return try decodeNumberLeadingZero(loc)
JSONParser.swift:445	return try decodeNumberLeadingZero(start, sign: .Negative)

JSONParser.swift:148	return try decodeNumberPreDecimalDigits(loc)
JSONParser.swift:448	return try decodeNumberPreDecimalDigits(start, sign: .Negative)