IntegerParsing.swift

//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//

/// Returns c as a UTF16.CodeUnit. Meant to be used as _ascii16("x").
@inlinable
internalfunc _ascii16(_ c:Unicode.Scalar)->UTF16.CodeUnit{
_internalInvariant(c.value >=0 && c.value <=0x7F,"not ASCII")
returnUTF16.CodeUnit(c.value)
}

@inlinable
@inline(__always)
internalfunc _asciiDigit<CodeUnit:UnsignedInteger, Result:BinaryInteger>(
 codeUnit u_:CodeUnit, radix:Result
)->Result?{
letdigit=_ascii16("0")..._ascii16("9")
letlower=_ascii16("a")..._ascii16("z")
letupper=_ascii16("A")..._ascii16("Z")

letu=UInt16(truncatingIfNeeded: u_)
letd:UInt16
if_fastPath(digit ~= u){ d = u &- digit.lowerBound }
elseif_fastPath(upper ~= u){ d = u &- upper.lowerBound &+10}
elseif_fastPath(lower ~= u){ d = u &- lower.lowerBound &+10}
else{returnnil}
guard_fastPath(d < radix)else{returnnil}
returnResult(truncatingIfNeeded: d)
}

@inlinable
@inline(__always)
internalfunc _parseUnsignedASCII<
 Rest:IteratorProtocol, Result:FixedWidthInteger
>(
 first:Rest.Element, rest:inoutRest, radix:Result, positive:Bool
)->Result?
where Rest.Element:UnsignedInteger{
letr0=_asciiDigit(codeUnit: first, radix: radix)
guard_fastPath(r0 !=nil),var result = r0 else{returnnil}
if !positive {
let(result0, overflow0)
=(0asResult).subtractingReportingOverflow(result)
guard_fastPath(!overflow0)else{returnnil}
 result = result0
}

whilelet u = rest.next(){
letd0=_asciiDigit(codeUnit: u, radix: radix)
guard_fastPath(d0 !=nil),let d = d0 else{returnnil}
let(result1, overflow1)= result.multipliedReportingOverflow(by: radix)
let(result2, overflow2)= positive
? result1.addingReportingOverflow(d)
: result1.subtractingReportingOverflow(d)
guard_fastPath(!overflow1 && !overflow2)
else{returnnil}
 result = result2
}
return result
}

//
// TODO (TODO: JIRA): This needs to be completely rewritten. It's about 20KB of
// always-inline code, most of which are MOV instructions.
//

@inlinable
@inline(__always)
internalfunc _parseASCII<
 CodeUnits:IteratorProtocol, Result:FixedWidthInteger
>(
 codeUnits:inoutCodeUnits, radix:Result
)->Result?
where CodeUnits.Element:UnsignedInteger{
letc0_= codeUnits.next()
guard_fastPath(c0_ !=nil),let c0 = c0_ else{returnnil}
if_fastPath(c0 !=_ascii16("+") && c0 !=_ascii16("-")){
return_parseUnsignedASCII(
 first: c0, rest:&codeUnits, radix: radix, positive:true)
}
letc1_= codeUnits.next()
guard_fastPath(c1_ !=nil),let c1 = c1_ else{returnnil}
if_fastPath(c0 ==_ascii16("-")){
return_parseUnsignedASCII(
 first: c1, rest:&codeUnits, radix: radix, positive:false)
}
else{
return_parseUnsignedASCII(
 first: c1, rest:&codeUnits, radix: radix, positive:true)
}
}

extensionFixedWidthInteger{
 // _parseASCII function thunk that prevents inlining used as an implementation
 // detail for FixedWidthInteger.init(_: radix:) on the slow path to save code
 // size.
@_semantics("optimize.sil.specialize.generic.partial.never")
@inline(never)
@usableFromInline
internalstaticfunc _parseASCIISlowPath<
 CodeUnits:IteratorProtocol, Result:FixedWidthInteger
>(
 codeUnits:inoutCodeUnits, radix:Result
)->Result?
where CodeUnits.Element:UnsignedInteger{
return_parseASCII(codeUnits:&codeUnits, radix: radix)
}

 /// Creates a new integer value from the given string and radix.
 ///
 /// The string passed as `text` may begin with a plus or minus sign character
 /// (`+` or `-`), followed by one or more numeric digits (`0-9`) or letters
 /// (`a-z` or `A-Z`). Parsing of the string is case insensitive.
 ///
 /// let x = Int("123")
 /// // x == 123
 ///
 /// let y = Int("-123", radix: 8)
 /// // y == -83
 /// let y = Int("+123", radix: 8)
 /// // y == +83
 ///
 /// let z = Int("07b", radix: 16)
 /// // z == 123
 ///
 /// If `text` is in an invalid format or contains characters that are out of
 /// bounds for the given `radix`, or if the value it denotes in the given
 /// `radix` is not representable, the result is `nil`. For example, the
 /// following conversions result in `nil`:
 ///
 /// Int(" 100") // Includes whitespace
 /// Int("21-50") // Invalid format
 /// Int("ff6600") // Characters out of bounds
 /// Int("zzzzzzzzzzzzz", radix: 36) // Out of range
 ///
 /// - Parameters:
 /// - text: The ASCII representation of a number in the radix passed as
 /// `radix`.
 /// - radix: The radix, or base, to use for converting `text` to an integer
 /// value. `radix` must be in the range `2...36`. The default is 10.
@inlinable // @specializable
@_semantics("optimize.sil.specialize.generic.partial.never")
publicinit?<S:StringProtocol>(_ text:S, radix:Int=10){
_precondition(2...36~= radix,"Radix not in range 2...36")

iflet str = text as?String, str._guts.isFastUTF8 {
guardlet ret = str._guts.withFastUTF8({ utf8 ->Self?in
variter= utf8.makeIterator()
return_parseASCII(codeUnits:&iter, radix:Self(radix))
})else{
returnnil
}
self= ret
return
}

 // TODO(String performance): We can provide fast paths for common radices,
 // native UTF-8 storage, etc.

variter= text.utf8.makeIterator()
guardlet ret =Self._parseASCIISlowPath(
 codeUnits:&iter, radix:Self(radix)
)else{returnnil}

self= ret
}

 /// Creates a new integer value from the given string.
 ///
 /// The string passed as `description` may begin with a plus or minus sign
 /// character (`+` or `-`), followed by one or more numeric digits (`0-9`).
 ///
 /// let x = Int("123")
 /// // x == 123
 ///
 /// If `description` is in an invalid format, or if the value it denotes in
 /// base 10 is not representable, the result is `nil`. For example, the
 /// following conversions result in `nil`:
 ///
 /// Int(" 100") // Includes whitespace
 /// Int("21-50") // Invalid format
 /// Int("ff6600") // Characters out of bounds
 /// Int("10000000000000000000000000") // Out of range
 ///
 /// - Parameter description: The ASCII representation of a number.
@inlinable
@_semantics("optimize.sil.specialize.generic.partial.never")
@inline(__always)
publicinit?(_ description:String){
self.init(description, radix:10)
}
}