Improved code clearity: parseFromStream also parsed from Data.

Fixed: Malloc errors were unchecked.
Fixed: Out of memory when creating context was ignored.
Improved: Parsing from data allocated memory that was never used.
Fixed: Parsing from InputStream ignored the parser return value.
Fixed: Reading the BOM returned an error if the BOM is not returned in
       one chunck from InputStream, e.g. when InputStreams returns one byte
       after the other on read.

Author: dhoepfl

Sources/FoundationXML/XMLParser.swift

@@ -1,6 +1,6 @@
 // This source file is part of the Swift.org open source project
 //
-// Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors
+// Copyright (c) 2014 - 2020 Apple Inc. and the Swift project authors
 // Licensed under Apache License v2.0 with Runtime Library Exception
 //
 // See http://swift.org/LICENSE.txt for license information
@@ -504,7 +504,7 @@ open class XMLParser : NSObject {
             // If we have not received 4 bytes, save the bomChunk for next pass
             if bomChunk.count < 4 {
                 _bomChunk = bomChunk
-                return false
+                return true
             }
             // Prepare options (substitute entities, recover on errors)
             var options = _kCFXMLInterfaceRecover | _kCFXMLInterfaceNoEnt
@@ -520,6 +520,12 @@ open class XMLParser : NSObject {
                 let bytes = rawBuffer.baseAddress!.assumingMemoryBound(to: CChar.self)
                 _parserContext = _CFXMLInterfaceCreatePushParserCtxt(handler, interface, bytes, 4, nil)
             }
+            guard _parserContext != nil else {
+                if _parserError == nil {
+                    _parserError = NSError(domain: XMLParser.errorDomain, code: ErrorCode.outOfMemoryError.rawValue)
+                }
+                return false
+            };
             _CFXMLInterfaceCtxtUseOptions(_parserContext, options)
             // Prepare the remaining data for parsing
             let dataRange = bomChunk.indices
@@ -540,49 +546,46 @@ open class XMLParser : NSObject {
         return result
     }
 
-    internal func parseFromStream() -> Bool {
+    internal func parseFrom(_ stream : InputStream) -> Bool {
         var result = true
-        XMLParser.setCurrentParser(self)
-        defer { XMLParser.setCurrentParser(nil) }
-        if let stream = _stream {
-            stream.open()
-            defer { stream.close() }
-            let buffer = malloc(_chunkSize)!.bindMemory(to: UInt8.self, capacity: _chunkSize)
-            defer { free(buffer) }
-            var len = stream.read(buffer, maxLength: _chunkSize)
-            if len != -1 {
-                while len > 0 {
-                    let data = Data(bytesNoCopy: buffer, count: len, deallocator: .none)
-                    result = parseData(data)
-                    len = stream.read(buffer, maxLength: _chunkSize)
-                }
-            } else {
+
+        guard let buffer = malloc(_chunkSize)?.bindMemory(to: UInt8.self, capacity: _chunkSize) else { return false }
+        defer { free(buffer) }
+
+        stream.open()
+        defer { stream.close() }
+        parseLoop: while result {
+            switch stream.read(buffer, maxLength: _chunkSize) {
+            case let len where len > 0:
+                let data = Data(bytesNoCopy: buffer, count: len, deallocator: .none)
+                result = parseData(data)
+            case 0:
+                break parseLoop
+            default: // See SR-13516, should be `case ..<0:`
                 result = false
-            }
-        } else if var data = _data {
-            let buffer = malloc(_chunkSize)!.bindMemory(to: UInt8.self, capacity: _chunkSize)
-            defer { free(buffer) }
-            var range = NSRange(location: 0, length: min(_chunkSize, data.count))
-            while result {
-                let chunk = data.withUnsafeMutableBytes { (rawBuffer: UnsafeMutableRawBufferPointer) -> Data in
-                    let ptr = rawBuffer.baseAddress!.advanced(by: range.location)
-                    return Data(bytesNoCopy: ptr, count: range.length, deallocator: .none)
-                }
-                result = parseData(chunk)
-                if range.location + range.length >= data.count {
-                    break
+                if _parserError == nil {
+                    _parserError = stream.streamError
                 }
-                range = NSRange(location: range.location + range.length, length: min(_chunkSize, data.count - (range.location + range.length)))
+
+                break parseLoop
             }
-        } else {
-            result = false
         }
+
         return result
     }
 
     // called to start the event-driven parse. Returns YES in the event of a successful parse, and NO in case of error.
     open func parse() -> Bool {
-        return parseFromStream()
+        XMLParser.setCurrentParser(self)
+        defer { XMLParser.setCurrentParser(nil) }
+
+        if _stream != nil {
+            return parseFrom(_stream!)
+        } else if _data != nil {
+            return parseData(_data!)
+        }
+
+        return false
     }
 
     // called by the delegate to stop the parse. The delegate will get an error message sent to it.