hex2bytes for Vector{UInt8}

base/exports.jl

@@ -762,6 +762,7 @@ export
     graphemes,
     hex,
     hex2bytes,
+    hex2bytes!,
     ind2chr,
     info,
     is_assigned_char,

base/strings/util.jl

@@ -463,12 +463,104 @@ function hex2bytes(s::AbstractString)
     return a
 end
 
+"""
+    hex2bytes(s::Vector{UInt8})
+
+Convert the hexadecimal bytes array to its binary representation. Returns an
+`Array{UInt8,1}`, i.e. an array of bytes.
+"""
+@inline function hex2bytes(s::Vector{UInt8})
+    d = Vector{UInt8}(div(length(s), 2))
+    hex2bytes!(d, s)
+    return d
+end
+
+"""
+    hex2bytes!(d::Vector{UInt8}, s::Vector{UInt8}, n::Int=length(s))
+
+Convert the first `n` hexadecimal bytes array to its binary representation. The
+results are populated into a destination array. The function returns the number of bytes
+copied into the destination array. The size of destination array must be at least half
+of the `n` parameter.
+
+# Examples
+```
+    julia> s = UInt8["01abEF"...]
+    6-element Array{UInt8,1}:
+     0x30
+     0x31
+     0x61
+     0x62
+     0x45
+     0x46
+
+    julia> d =zeros(UInt8, 3)
+    3-element Array{UInt8,1}:
+     0x00
+     0x00
+     0x00
+
+    julia> hex2bytes!(d, s, 6)
+    3
+
+    julia> d
+    3-element Array{UInt8,1}:
+     0x01
+     0xab
+     0xef
+```
+"""
+function hex2bytes!(d::Vector{UInt8}, s::Vector{UInt8}, n::Int=length(s))
+    if isodd(n)
+        throw(ArgumentError("Input data length should be even"))
+    end
+
+    if n > length(s)
+        throw(ArgumentError("Input data length should not exceed array length"))
+    end
+
+    len2 = div(n, 2)
+
+    if length(d) <  len2
+        throw(ArgumentError("Destination data buffer should be sufficiently large"))
+    end
+
+    i = j = 0
+    # This line is important as this ensures computation happens on word boundary and
+    # not byte boundary. Byte boundary computation can be almost 10 times slower.
+    n = c1 = c2 = UInt(0)
+    for j = 1:len2
+        num = 0
+        @inbounds c1 = UInt(s[i+=1])
+        @inbounds c2 = UInt(s[i+=1])
+        num = number_from_hex(c1)
+        num <<= 4
+        num += number_from_hex(c2)
+        @inbounds d[j] = (num & 0xFF)
+    end
+    return j
+end
+
+@inline function number_from_hex(c::UInt)
+    DIGIT_ZERO     = UInt('0')
+    DIGIT_NINE     = UInt('9')
+    LATIN_UPPER_A  = UInt('A')
+    LATIN_UPPER_F  = UInt('F')
+    LATIN_A        = UInt('a')
+    LATIN_F        = UInt('f')
+
+    return (DIGIT_ZERO <= c <= DIGIT_NINE) ? c - DIGIT_ZERO :
+        (LATIN_UPPER_A <= c <= LATIN_UPPER_F) ? c - LATIN_UPPER_A + 10 :
+        (LATIN_A <= c <= LATIN_F) ? c - LATIN_A + 10 :
+        throw(ArgumentError("Not a hexadecimal number"))
+end
+
 """
     bytes2hex(bin_arr::Array{UInt8, 1}) -> String
 
 Convert an array of bytes to its hexadecimal representation.
 All characters are in lower-case.
-
+it
 # Examples
 ```jldoctest
 julia> a = hex(12345)

test/strings/util.jl

@@ -247,3 +247,24 @@ bin_val = hex2bytes("07bf")
 
 #non-hex characters
 @test_throws ArgumentError hex2bytes("0123456789abcdefABCDEFGH")
+
+function test_23161()
+    arr = UInt8["0123456789abcdefABCDEF"...]
+    arr1 = Vector{UInt8}(11)
+    @test hex2bytes!(arr1, arr) == 11
+    @test "0123456789abcdefabcdef" == bytes2hex(arr1)
+    @test hex2bytes("0123456789abcdefABCDEF") == hex2bytes(arr)
+    @test hex2bytes!(arr1, UInt8[""...]) == 0
+    @test hex2bytes(UInt8[""...]) == UInt8[]
+
+    # odd size
+    @test_throws ArgumentError hex2bytes(UInt8["0123456789abcdefABCDEF0"...])
+
+    # Input array size smaller than the number of bytes to be converted.
+    @test_throws ArgumentError hex2bytes!(arr1, arr, 24)
+
+    #non-hex characters
+    @test_throws ArgumentError hex2bytes(UInt8["0123456789abcdefABCDEFGH"...])
+end
+
+test_23161()