Initial commit
This commit is contained in:
La Ancapo
commit
c101616e62
309 changed files with 53937 additions and 0 deletions
176
bundled/Data/Memory/Encoding/Base16.hs
Normal file
176
bundled/Data/Memory/Encoding/Base16.hs
Normal file
|
|
@ -0,0 +1,176 @@
|
|||
-- |
|
||||
-- Module : Data.Memory.Encoding.Base16
|
||||
-- License : BSD-style
|
||||
-- Maintainer : Vincent Hanquez <vincent@snarc.org>
|
||||
-- Stability : experimental
|
||||
-- Portability : unknown
|
||||
--
|
||||
-- Low-level Base16 encoding and decoding.
|
||||
--
|
||||
-- If you just want to encode or decode some bytes, you probably want to use
|
||||
-- the "Data.ByteArray.Encoding" module.
|
||||
--
|
||||
{-# LANGUAGE MagicHash #-}
|
||||
{-# LANGUAGE UnboxedTuples #-}
|
||||
{-# LANGUAGE OverloadedStrings #-}
|
||||
{-# LANGUAGE BangPatterns #-}
|
||||
{-# LANGUAGE Rank2Types #-}
|
||||
module Data.Memory.Encoding.Base16
|
||||
( showHexadecimal
|
||||
, toHexadecimal
|
||||
, fromHexadecimal
|
||||
) where
|
||||
|
||||
import Data.Memory.Internal.Compat
|
||||
import Data.Word
|
||||
import Basement.Bits
|
||||
import Basement.IntegralConv
|
||||
import GHC.Prim
|
||||
import GHC.Types
|
||||
import GHC.Word
|
||||
import GHC.Char (chr)
|
||||
import Control.Monad
|
||||
import Foreign.Storable
|
||||
import Foreign.Ptr (Ptr)
|
||||
|
||||
-- | Transform a raw memory to an hexadecimal 'String'
|
||||
--
|
||||
-- user beware, no checks are made
|
||||
showHexadecimal :: (forall a . (Ptr Word8 -> IO a) -> IO a) -- ^ a 'with' type of function to hold reference to the object
|
||||
-> Int -- ^ length in bytes
|
||||
-> String
|
||||
showHexadecimal withPtr = doChunks 0
|
||||
where
|
||||
doChunks ofs len
|
||||
| len < 4 = doUnique ofs len
|
||||
| otherwise = do
|
||||
let !(a, b, c, d) = unsafeDoIO $ withPtr (read4 ofs)
|
||||
!(# w1, w2 #) = convertByte a
|
||||
!(# w3, w4 #) = convertByte b
|
||||
!(# w5, w6 #) = convertByte c
|
||||
!(# w7, w8 #) = convertByte d
|
||||
in wToChar w1 : wToChar w2 : wToChar w3 : wToChar w4
|
||||
: wToChar w5 : wToChar w6 : wToChar w7 : wToChar w8
|
||||
: doChunks (ofs + 4) (len - 4)
|
||||
|
||||
doUnique ofs len
|
||||
| len == 0 = []
|
||||
| otherwise =
|
||||
let !b = unsafeDoIO $ withPtr (byteIndex ofs)
|
||||
!(# w1, w2 #) = convertByte b
|
||||
in wToChar w1 : wToChar w2 : doUnique (ofs + 1) (len - 1)
|
||||
|
||||
read4 :: Int -> Ptr Word8 -> IO (Word8, Word8, Word8, Word8)
|
||||
read4 ofs p =
|
||||
liftM4 (,,,) (byteIndex ofs p) (byteIndex (ofs+1) p)
|
||||
(byteIndex (ofs+2) p) (byteIndex (ofs+3) p)
|
||||
|
||||
wToChar :: Word8 -> Char
|
||||
wToChar w = chr (integralUpsize w)
|
||||
|
||||
byteIndex :: Int -> Ptr Word8 -> IO Word8
|
||||
byteIndex i p = peekByteOff p i
|
||||
|
||||
-- | Transform a number of bytes pointed by.@src in the hexadecimal binary representation in @dst
|
||||
--
|
||||
-- destination memory need to be of correct size, otherwise it will lead
|
||||
-- to really bad things.
|
||||
toHexadecimal :: Ptr Word8 -- ^ destination memory
|
||||
-> Ptr Word8 -- ^ source memory
|
||||
-> Int -- ^ number of bytes
|
||||
-> IO ()
|
||||
toHexadecimal bout bin n = loop 0
|
||||
where loop i
|
||||
| i == n = return ()
|
||||
| otherwise = do
|
||||
!w <- peekByteOff bin i
|
||||
let !(# !w1, !w2 #) = convertByte w
|
||||
pokeByteOff bout (i * 2) w1
|
||||
pokeByteOff bout (i * 2 + 1) w2
|
||||
loop (i+1)
|
||||
|
||||
-- | Convert a value Word# to two Word#s containing
|
||||
-- the hexadecimal representation of the Word#
|
||||
convertByte :: Word8 -> (# Word8, Word8 #)
|
||||
convertByte bwrap = (# r tableHi b, r tableLo b #)
|
||||
where
|
||||
!(W# b) = integralUpsize bwrap
|
||||
r :: Addr# -> Word# -> Word8
|
||||
r table index = W8# (indexWord8OffAddr# table (word2Int# index))
|
||||
|
||||
!tableLo =
|
||||
"0123456789abcdef0123456789abcdef\
|
||||
\0123456789abcdef0123456789abcdef\
|
||||
\0123456789abcdef0123456789abcdef\
|
||||
\0123456789abcdef0123456789abcdef\
|
||||
\0123456789abcdef0123456789abcdef\
|
||||
\0123456789abcdef0123456789abcdef\
|
||||
\0123456789abcdef0123456789abcdef\
|
||||
\0123456789abcdef0123456789abcdef"#
|
||||
!tableHi =
|
||||
"00000000000000001111111111111111\
|
||||
\22222222222222223333333333333333\
|
||||
\44444444444444445555555555555555\
|
||||
\66666666666666667777777777777777\
|
||||
\88888888888888889999999999999999\
|
||||
\aaaaaaaaaaaaaaaabbbbbbbbbbbbbbbb\
|
||||
\ccccccccccccccccdddddddddddddddd\
|
||||
\eeeeeeeeeeeeeeeeffffffffffffffff"#
|
||||
{-# INLINE convertByte #-}
|
||||
|
||||
-- | convert a base16 @src in @dst.
|
||||
--
|
||||
-- n need to even
|
||||
fromHexadecimal :: Ptr Word8 -> Ptr Word8 -> Int -> IO (Maybe Int)
|
||||
fromHexadecimal dst src n
|
||||
| odd n = error "fromHexadecimal: invalid odd length."
|
||||
| otherwise = loop 0 0
|
||||
where loop di i
|
||||
| i == n = return Nothing
|
||||
| otherwise = do
|
||||
a <- rHi `fmap` peekByteOff src i
|
||||
b <- rLo `fmap` peekByteOff src (i+1)
|
||||
if a == 0xff || b == 0xff
|
||||
then return $ Just i
|
||||
else pokeByteOff dst di (a .|. b) >> loop (di+1) (i+2)
|
||||
|
||||
rLo, rHi :: Word8 -> Word8
|
||||
rLo index = W8# (indexWord8OffAddr# tableLo (word2Int# widx))
|
||||
where !(W# widx) = integralUpsize index
|
||||
rHi index = W8# (indexWord8OffAddr# tableHi (word2Int# widx))
|
||||
where !(W# widx) = integralUpsize index
|
||||
|
||||
!tableLo =
|
||||
"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\
|
||||
\\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\
|
||||
\\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\
|
||||
\\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\xff\xff\xff\xff\xff\xff\
|
||||
\\xff\x0a\x0b\x0c\x0d\x0e\x0f\xff\xff\xff\xff\xff\xff\xff\xff\xff\
|
||||
\\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\
|
||||
\\xff\x0a\x0b\x0c\x0d\x0e\x0f\xff\xff\xff\xff\xff\xff\xff\xff\xff\
|
||||
\\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\
|
||||
\\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\
|
||||
\\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\
|
||||
\\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\
|
||||
\\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\
|
||||
\\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\
|
||||
\\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\
|
||||
\\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\
|
||||
\\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"#
|
||||
!tableHi =
|
||||
"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\
|
||||
\\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\
|
||||
\\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\
|
||||
\\x00\x10\x20\x30\x40\x50\x60\x70\x80\x90\xff\xff\xff\xff\xff\xff\
|
||||
\\xff\xa0\xb0\xc0\xd0\xe0\xf0\xff\xff\xff\xff\xff\xff\xff\xff\xff\
|
||||
\\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\
|
||||
\\xff\xa0\xb0\xc0\xd0\xe0\xf0\xff\xff\xff\xff\xff\xff\xff\xff\xff\
|
||||
\\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\
|
||||
\\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\
|
||||
\\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\
|
||||
\\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\
|
||||
\\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\
|
||||
\\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\
|
||||
\\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\
|
||||
\\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\
|
||||
\\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"#
|
||||
256
bundled/Data/Memory/Encoding/Base32.hs
Normal file
256
bundled/Data/Memory/Encoding/Base32.hs
Normal file
|
|
@ -0,0 +1,256 @@
|
|||
-- |
|
||||
-- Module : Data.Memory.Encoding.Base32
|
||||
-- License : BSD-style
|
||||
-- Maintainer : Nicolas DI PRIMA <nicolas@di-prima.fr>
|
||||
-- Stability : experimental
|
||||
-- Portability : unknown
|
||||
--
|
||||
-- Low-level Base32 encoding and decoding.
|
||||
--
|
||||
-- If you just want to encode or decode some bytes, you probably want to use
|
||||
-- the "Data.ByteArray.Encoding" module.
|
||||
--
|
||||
{-# LANGUAGE MagicHash #-}
|
||||
{-# LANGUAGE UnboxedTuples #-}
|
||||
{-# LANGUAGE OverloadedStrings #-}
|
||||
{-# LANGUAGE BangPatterns #-}
|
||||
{-# LANGUAGE Rank2Types #-}
|
||||
module Data.Memory.Encoding.Base32
|
||||
( toBase32
|
||||
, unBase32Length
|
||||
, fromBase32
|
||||
) where
|
||||
|
||||
import Data.Memory.Internal.Compat
|
||||
import Data.Word
|
||||
import Basement.Bits
|
||||
import Basement.IntegralConv
|
||||
import GHC.Prim
|
||||
import GHC.Word
|
||||
import Control.Monad
|
||||
import Foreign.Storable
|
||||
import Foreign.Ptr (Ptr)
|
||||
|
||||
-- | Transform a number of bytes pointed by.@src in the base32 binary representation in @dst
|
||||
--
|
||||
-- destination memory need to be of correct size, otherwise it will lead
|
||||
-- to really bad things.
|
||||
toBase32 :: Ptr Word8 -- ^ input
|
||||
-> Ptr Word8 -- ^ output
|
||||
-> Int -- ^ input len
|
||||
-> IO ()
|
||||
toBase32 dst src len = loop 0 0
|
||||
where
|
||||
eqChar :: Word8
|
||||
eqChar = 0x3d
|
||||
|
||||
peekOrZero :: Int -> IO Word8
|
||||
peekOrZero i
|
||||
| i >= len = return 0
|
||||
| otherwise = peekByteOff src i
|
||||
|
||||
pokeOrPadding :: Int -- for the test
|
||||
-> Int -- src index
|
||||
-> Word8 -- the value
|
||||
-> IO ()
|
||||
pokeOrPadding i di v
|
||||
| i < len = pokeByteOff dst di v
|
||||
| otherwise = pokeByteOff dst di eqChar
|
||||
|
||||
loop :: Int -- index input
|
||||
-> Int -- index output
|
||||
-> IO ()
|
||||
loop i di
|
||||
| i >= len = return ()
|
||||
| otherwise = do
|
||||
i1 <- peekByteOff src i
|
||||
i2 <- peekOrZero (i + 1)
|
||||
i3 <- peekOrZero (i + 2)
|
||||
i4 <- peekOrZero (i + 3)
|
||||
i5 <- peekOrZero (i + 4)
|
||||
|
||||
let (o1,o2,o3,o4,o5,o6,o7,o8) = toBase32Per5Bytes (i1, i2, i3, i4, i5)
|
||||
|
||||
pokeByteOff dst di o1
|
||||
pokeByteOff dst (di + 1) o2
|
||||
pokeOrPadding (i + 1) (di + 2) o3
|
||||
pokeOrPadding (i + 1) (di + 3) o4
|
||||
pokeOrPadding (i + 2) (di + 4) o5
|
||||
pokeOrPadding (i + 3) (di + 5) o6
|
||||
pokeOrPadding (i + 3) (di + 6) o7
|
||||
pokeOrPadding (i + 4) (di + 7) o8
|
||||
|
||||
loop (i+5) (di+8)
|
||||
|
||||
toBase32Per5Bytes :: (Word8, Word8, Word8, Word8, Word8)
|
||||
-> (Word8, Word8, Word8, Word8, Word8, Word8, Word8, Word8)
|
||||
toBase32Per5Bytes (!i1, !i2, !i3, !i4, !i5) =
|
||||
(index o1, index o2, index o3, index o4, index o5, index o6, index o7, index o8)
|
||||
where
|
||||
-- 1111 1000 >> 3
|
||||
!o1 = (i1 .&. 0xF8) .>>. 3
|
||||
-- 0000 0111 << 2 | 1100 0000 >> 6
|
||||
!o2 = ((i1 .&. 0x07) .<<. 2) .|. ((i2 .&. 0xC0) .>>. 6)
|
||||
-- 0011 1110 >> 1
|
||||
!o3 = ((i2 .&. 0x3E) .>>. 1)
|
||||
-- 0000 0001 << 4 | 1111 0000 >> 4
|
||||
!o4 = ((i2 .&. 0x01) .<<. 4) .|. ((i3 .&. 0xF0) .>>. 4)
|
||||
-- 0000 1111 << 1 | 1000 0000 >> 7
|
||||
!o5 = ( (i3 .&. 0x0F) .<<. 1) .|. ((i4 .&. 0x80) .>>. 7)
|
||||
-- 0111 1100 >> 2
|
||||
!o6 = (i4 .&. 0x7C) .>>. 2
|
||||
-- 0000 0011 << 3 | 1110 0000 >> 5
|
||||
!o7 = ((i4 .&. 0x03) .<<. 3) .|. ((i5 .&. 0xE0) .>>. 5)
|
||||
-- 0001 1111
|
||||
!o8 = i5 .&. 0x1F
|
||||
|
||||
!set = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"#
|
||||
|
||||
index :: Word8 -> Word8
|
||||
index idx = W8# (indexWord8OffAddr# set (word2Int# widx))
|
||||
where !(W# widx) = integralUpsize idx
|
||||
|
||||
-- | Get the length needed for the destination buffer for a base32 decoding.
|
||||
--
|
||||
-- if the length is not a multiple of 8, Nothing is returned
|
||||
unBase32Length :: Ptr Word8 -> Int -> IO (Maybe Int)
|
||||
unBase32Length src len
|
||||
| len < 1 = return $ Just 0
|
||||
| (len `mod` 8) /= 0 = return Nothing
|
||||
| otherwise = do
|
||||
last1Byte <- peekByteOff src (len - 1)
|
||||
last2Byte <- peekByteOff src (len - 2)
|
||||
last3Byte <- peekByteOff src (len - 3)
|
||||
last4Byte <- peekByteOff src (len - 4)
|
||||
last5Byte <- peekByteOff src (len - 5)
|
||||
last6Byte <- peekByteOff src (len - 6)
|
||||
|
||||
let dstLen = caseByte last1Byte last2Byte last3Byte last4Byte last5Byte last6Byte
|
||||
return $ Just $ (len `div` 8) * 5 - dstLen
|
||||
where
|
||||
caseByte :: Word8 -> Word8 -> Word8 -> Word8 -> Word8 -> Word8 -> Int
|
||||
caseByte last1 last2 last3 last4 last5 last6
|
||||
| last6 == eqAscii = 4
|
||||
| last5 == eqAscii = 3 -- error this padding is not expected (error will be detected in fromBase32)
|
||||
| last4 == eqAscii = 3
|
||||
| last3 == eqAscii = 2
|
||||
| last2 == eqAscii = 1 -- error this padding is not expected (error will be detected in fromBase32)
|
||||
| last1 == eqAscii = 1
|
||||
| otherwise = 0
|
||||
|
||||
eqAscii :: Word8
|
||||
eqAscii = 0x3D
|
||||
|
||||
-- | convert from base32 in @src to binary in @dst, using the number of bytes specified
|
||||
--
|
||||
-- the user should use unBase32Length to compute the correct length, or check that
|
||||
-- the length specification is proper. no check is done here.
|
||||
fromBase32 :: Ptr Word8 -> Ptr Word8 -> Int -> IO (Maybe Int)
|
||||
fromBase32 dst src len
|
||||
| len == 0 = return Nothing
|
||||
| otherwise = loop 0 0
|
||||
where
|
||||
loop :: Int -- the index dst
|
||||
-> Int -- the index src
|
||||
-> IO (Maybe Int)
|
||||
loop di i
|
||||
| i == (len - 8) = do
|
||||
i1 <- peekByteOff src i
|
||||
i2 <- peekByteOff src (i + 1)
|
||||
i3 <- peekByteOff src (i + 2)
|
||||
i4 <- peekByteOff src (i + 3)
|
||||
i5 <- peekByteOff src (i + 4)
|
||||
i6 <- peekByteOff src (i + 5)
|
||||
i7 <- peekByteOff src (i + 6)
|
||||
i8 <- peekByteOff src (i + 7)
|
||||
|
||||
let (nbBytes, i3', i4', i5', i6', i7', i8') =
|
||||
case (i3, i4, i5, i6, i7, i8) of
|
||||
(0x3D, 0x3D, 0x3D, 0x3D, 0x3D, 0x3D) -> (6, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41)
|
||||
(0x3D, _ , _ , _ , _ , _ ) -> (0, i3, i4, i5, i6, i7, i8) -- invalid
|
||||
(_ , 0x3D, 0x3D, 0x3D, 0x3D, 0x3D) -> (5, i3 , 0x41, 0x41, 0x41, 0x41, 0x41)
|
||||
(_ , 0x3D, _ , _ , _ , _ ) -> (0, i3, i4, i5, i6, i7, i8) -- invalid
|
||||
(_ , _ , 0x3D, 0x3D, 0x3D, 0x3D) -> (4, i3 , i4 , 0x41, 0x41, 0x41, 0x41)
|
||||
(_ , _ , 0x3D, _ , _ , _ ) -> (0, i3, i4, i5, i6, i7, i8) -- invalid
|
||||
(_ , _ , _ , 0x3D, 0x3D, 0x3D) -> (3, i3 , i4 , i5 , 0x41, 0x41, 0x41)
|
||||
(_ , _ , _ , 0x3D, _ , _ ) -> (0, i3, i4, i5, i6, i7, i8) -- invalid
|
||||
(_ , _ , _ , _ , 0x3D, 0x3D) -> (2, i3 , i4 , i5 , i6 , 0x41, 0x41)
|
||||
(_ , _ , _ , _ , 0x3D, _ ) -> (0, i3, i4, i5, i6, i7, i8) -- invalid
|
||||
(_ , _ , _ , _ , _ , 0x3D) -> (1, i3 , i4 , i5 , i6 , i7 , 0x41)
|
||||
(_ , _ , _ , _ , _ , _ ) -> (0 :: Int, i3, i4, i5, i6, i7, i8)
|
||||
|
||||
case fromBase32Per8Bytes (i1, i2, i3', i4', i5', i6', i7', i8') of
|
||||
Left ofs -> return $ Just (i + ofs)
|
||||
Right (o1, o2, o3, o4, o5) -> do
|
||||
pokeByteOff dst di o1
|
||||
pokeByteOff dst (di+1) o2
|
||||
when (nbBytes < 5) $ pokeByteOff dst (di+2) o3
|
||||
when (nbBytes < 4) $ pokeByteOff dst (di+3) o4
|
||||
when (nbBytes < 2) $ pokeByteOff dst (di+4) o5
|
||||
return Nothing
|
||||
|
||||
| otherwise = do
|
||||
i1 <- peekByteOff src i
|
||||
i2 <- peekByteOff src (i + 1)
|
||||
i3 <- peekByteOff src (i + 2)
|
||||
i4 <- peekByteOff src (i + 3)
|
||||
i5 <- peekByteOff src (i + 4)
|
||||
i6 <- peekByteOff src (i + 5)
|
||||
i7 <- peekByteOff src (i + 6)
|
||||
i8 <- peekByteOff src (i + 7)
|
||||
|
||||
case fromBase32Per8Bytes (i1, i2, i3, i4, i5, i6, i7, i8) of
|
||||
Left ofs -> return $ Just (i + ofs)
|
||||
Right (o1, o2, o3, o4, o5) -> do
|
||||
pokeByteOff dst di o1
|
||||
pokeByteOff dst (di+1) o2
|
||||
pokeByteOff dst (di+2) o3
|
||||
pokeByteOff dst (di+3) o4
|
||||
pokeByteOff dst (di+4) o5
|
||||
loop (di+5) (i+8)
|
||||
|
||||
fromBase32Per8Bytes :: (Word8, Word8, Word8, Word8, Word8, Word8, Word8, Word8)
|
||||
-> Either Int (Word8, Word8, Word8, Word8, Word8)
|
||||
fromBase32Per8Bytes (i1, i2, i3, i4, i5, i6, i7, i8) =
|
||||
case (rset i1, rset i2, rset i3, rset i4, rset i5, rset i6, rset i7, rset i8) of
|
||||
(0xFF, _ , _ , _ , _ , _ , _ , _ ) -> Left 0
|
||||
(_ , 0xFF, _ , _ , _ , _ , _ , _ ) -> Left 1
|
||||
(_ , _ , 0xFF, _ , _ , _ , _ , _ ) -> Left 2
|
||||
(_ , _ , _ , 0xFF, _ , _ , _ , _ ) -> Left 3
|
||||
(_ , _ , _ , _ , 0xFF, _ , _ , _ ) -> Left 4
|
||||
(_ , _ , _ , _ , _ , 0xFF, _ , _ ) -> Left 5
|
||||
(_ , _ , _ , _ , _ , _ , 0xFF, _ ) -> Left 6
|
||||
(_ , _ , _ , _ , _ , _ , _ , 0xFF) -> Left 7
|
||||
(ri1 , ri2 , ri3 , ri4 , ri5 , ri6 , ri7 , ri8 ) ->
|
||||
-- 0001 1111 << 3 | 0001 11xx >> 2
|
||||
let o1 = (ri1 `unsafeShiftL` 3) .|. (ri2 `unsafeShiftR` 2)
|
||||
-- 000x xx11 << 6 | 0001 1111 << 1 | 0001 xxxx >> 4
|
||||
o2 = (ri2 `unsafeShiftL` 6) .|. (ri3 `unsafeShiftL` 1) .|. (ri4 `unsafeShiftR` 4)
|
||||
-- 000x 1111 << 4 | 0001 111x >> 1
|
||||
o3 = (ri4 `unsafeShiftL` 4) .|. (ri5 `unsafeShiftR` 1)
|
||||
-- 000x xxx1 << 7 | 0001 1111 << 2 | 0001 1xxx >> 3
|
||||
o4 = (ri5 `unsafeShiftL` 7) .|. (ri6 `unsafeShiftL` 2) .|. (ri7 `unsafeShiftR` 3)
|
||||
-- 000x x111 << 5 | 0001 1111
|
||||
o5 = (ri7 `unsafeShiftL` 5) .|. ri8
|
||||
in Right (o1, o2, o3, o4, o5)
|
||||
where
|
||||
rset :: Word8 -> Word8
|
||||
rset w = W8# (indexWord8OffAddr# rsetTable (word2Int# widx))
|
||||
where !(W# widx) = integralUpsize w
|
||||
|
||||
!rsetTable = "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\
|
||||
\\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\
|
||||
\\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\
|
||||
\\xFF\xFF\x1A\x1B\x1C\x1D\x1E\x1F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\
|
||||
\\xFF\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\
|
||||
\\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\xFF\xFF\xFF\xFF\xFF\
|
||||
\\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\
|
||||
\\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\
|
||||
\\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\
|
||||
\\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\
|
||||
\\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\
|
||||
\\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\
|
||||
\\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\
|
||||
\\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\
|
||||
\\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\
|
||||
\\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"#
|
||||
328
bundled/Data/Memory/Encoding/Base64.hs
Normal file
328
bundled/Data/Memory/Encoding/Base64.hs
Normal file
|
|
@ -0,0 +1,328 @@
|
|||
-- |
|
||||
-- Module : Data.Memory.Encoding.Base64
|
||||
-- License : BSD-style
|
||||
-- Maintainer : Vincent Hanquez <vincent@snarc.org>
|
||||
-- Stability : experimental
|
||||
-- Portability : unknown
|
||||
--
|
||||
-- Low-level Base64 encoding and decoding.
|
||||
--
|
||||
-- If you just want to encode or decode some bytes, you probably want to use
|
||||
-- the "Data.ByteArray.Encoding" module.
|
||||
--
|
||||
{-# LANGUAGE MagicHash #-}
|
||||
{-# LANGUAGE UnboxedTuples #-}
|
||||
{-# LANGUAGE OverloadedStrings #-}
|
||||
{-# LANGUAGE BangPatterns #-}
|
||||
{-# LANGUAGE Rank2Types #-}
|
||||
module Data.Memory.Encoding.Base64
|
||||
( toBase64
|
||||
, toBase64URL
|
||||
, toBase64OpenBSD
|
||||
, unBase64Length
|
||||
, unBase64LengthUnpadded
|
||||
, fromBase64
|
||||
, fromBase64URLUnpadded
|
||||
, fromBase64OpenBSD
|
||||
) where
|
||||
|
||||
import Data.Memory.Internal.Compat
|
||||
import Data.Memory.Internal.Imports
|
||||
import Basement.Bits
|
||||
import Basement.IntegralConv (integralUpsize)
|
||||
import GHC.Prim
|
||||
import GHC.Word
|
||||
import Foreign.Storable
|
||||
import Foreign.Ptr (Ptr)
|
||||
|
||||
-- | Transform a number of bytes pointed by @src@ to base64 binary representation in @dst@
|
||||
--
|
||||
-- The destination memory need to be of correct size, otherwise it will lead
|
||||
-- to really bad things.
|
||||
toBase64 :: Ptr Word8 -> Ptr Word8 -> Int -> IO ()
|
||||
toBase64 dst src len = toBase64Internal set dst src len True
|
||||
where
|
||||
!set = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"#
|
||||
|
||||
-- | Transform a number of bytes pointed by @src@ to, URL-safe base64 binary
|
||||
-- representation in @dst@. The result will be either padded or unpadded,
|
||||
-- depending on the boolean @padded@ argument.
|
||||
--
|
||||
-- The destination memory need to be of correct size, otherwise it will lead
|
||||
-- to really bad things.
|
||||
toBase64URL :: Bool -> Ptr Word8 -> Ptr Word8 -> Int -> IO ()
|
||||
toBase64URL padded dst src len = toBase64Internal set dst src len padded
|
||||
where
|
||||
!set = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"#
|
||||
|
||||
toBase64OpenBSD :: Ptr Word8 -> Ptr Word8 -> Int -> IO ()
|
||||
toBase64OpenBSD dst src len = toBase64Internal set dst src len False
|
||||
where
|
||||
!set = "./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"#
|
||||
|
||||
toBase64Internal :: Addr# -> Ptr Word8 -> Ptr Word8 -> Int -> Bool -> IO ()
|
||||
toBase64Internal table dst src len padded = loop 0 0
|
||||
where
|
||||
eqChar = 0x3d :: Word8
|
||||
|
||||
loop i di
|
||||
| i >= len = return ()
|
||||
| otherwise = do
|
||||
a <- peekByteOff src i
|
||||
b <- if i + 1 >= len then return 0 else peekByteOff src (i+1)
|
||||
c <- if i + 2 >= len then return 0 else peekByteOff src (i+2)
|
||||
|
||||
let (w,x,y,z) = convert3 table a b c
|
||||
|
||||
pokeByteOff dst di w
|
||||
pokeByteOff dst (di+1) x
|
||||
|
||||
if i + 1 < len
|
||||
then
|
||||
pokeByteOff dst (di+2) y
|
||||
else
|
||||
when padded (pokeByteOff dst (di+2) eqChar)
|
||||
if i + 2 < len
|
||||
then
|
||||
pokeByteOff dst (di+3) z
|
||||
else
|
||||
when padded (pokeByteOff dst (di+3) eqChar)
|
||||
|
||||
loop (i+3) (di+4)
|
||||
|
||||
convert3 :: Addr# -> Word8 -> Word8 -> Word8 -> (Word8, Word8, Word8, Word8)
|
||||
convert3 table !a !b !c =
|
||||
let !w = a .>>. 2
|
||||
!x = ((a .<<. 4) .&. 0x30) .|. (b .>>. 4)
|
||||
!y = ((b .<<. 2) .&. 0x3c) .|. (c .>>. 6)
|
||||
!z = c .&. 0x3f
|
||||
in (index w, index x, index y, index z)
|
||||
where
|
||||
index :: Word8 -> Word8
|
||||
index !idxb = W8# (indexWord8OffAddr# table (word2Int# idx))
|
||||
where !(W# idx) = integralUpsize idxb
|
||||
|
||||
-- | Get the length needed for the destination buffer for a base64 decoding.
|
||||
--
|
||||
-- if the length is not a multiple of 4, Nothing is returned
|
||||
unBase64Length :: Ptr Word8 -> Int -> IO (Maybe Int)
|
||||
unBase64Length src len
|
||||
| len < 1 = return $ Just 0
|
||||
| (len `mod` 4) /= 0 = return Nothing
|
||||
| otherwise = do
|
||||
last1Byte <- peekByteOff src (len - 1)
|
||||
last2Byte <- peekByteOff src (len - 2)
|
||||
let dstLen = if last1Byte == eqAscii
|
||||
then if last2Byte == eqAscii then 2 else 1
|
||||
else 0
|
||||
return $ Just $ (len `div` 4) * 3 - dstLen
|
||||
where
|
||||
eqAscii :: Word8
|
||||
eqAscii = fromIntegral (fromEnum '=')
|
||||
|
||||
-- | Get the length needed for the destination buffer for an
|
||||
-- <http://tools.ietf.org/html/rfc4648#section-3.2 unpadded> base64 decoding.
|
||||
--
|
||||
-- If the length of the encoded string is a multiple of 4, plus one, Nothing is
|
||||
-- returned. Any other value can be valid without padding.
|
||||
unBase64LengthUnpadded :: Int -> Maybe Int
|
||||
unBase64LengthUnpadded len = case r of
|
||||
0 -> Just (3*q)
|
||||
2 -> Just (3*q + 1)
|
||||
3 -> Just (3*q + 2)
|
||||
_ -> Nothing
|
||||
where (q, r) = len `divMod` 4
|
||||
|
||||
fromBase64OpenBSD :: Ptr Word8 -> Ptr Word8 -> Int -> IO (Maybe Int)
|
||||
fromBase64OpenBSD dst src len = fromBase64Unpadded rsetOpenBSD dst src len
|
||||
|
||||
fromBase64URLUnpadded :: Ptr Word8 -> Ptr Word8 -> Int -> IO (Maybe Int)
|
||||
fromBase64URLUnpadded dst src len = fromBase64Unpadded rsetURL dst src len
|
||||
|
||||
fromBase64Unpadded :: (Word8 -> Word8) -> Ptr Word8 -> Ptr Word8 -> Int -> IO (Maybe Int)
|
||||
fromBase64Unpadded rset dst src len = loop 0 0
|
||||
where loop di i
|
||||
| i == len = return Nothing
|
||||
| i == len - 1 = return Nothing -- Shouldn't happen if len is valid
|
||||
| i == len - 2 = do
|
||||
a <- peekByteOff src i
|
||||
b <- peekByteOff src (i+1)
|
||||
|
||||
case decode2 a b of
|
||||
Left ofs -> return $ Just (i + ofs)
|
||||
Right x -> do
|
||||
pokeByteOff dst di x
|
||||
return Nothing
|
||||
| i == len - 3 = do
|
||||
a <- peekByteOff src i
|
||||
b <- peekByteOff src (i+1)
|
||||
c <- peekByteOff src (i+2)
|
||||
|
||||
case decode3 a b c of
|
||||
Left ofs -> return $ Just (i + ofs)
|
||||
Right (x,y) -> do
|
||||
pokeByteOff dst di x
|
||||
pokeByteOff dst (di+1) y
|
||||
return Nothing
|
||||
| otherwise = do
|
||||
a <- peekByteOff src i
|
||||
b <- peekByteOff src (i+1)
|
||||
c <- peekByteOff src (i+2)
|
||||
d <- peekByteOff src (i+3)
|
||||
|
||||
case decode4 a b c d of
|
||||
Left ofs -> return $ Just (i + ofs)
|
||||
Right (x,y,z) -> do
|
||||
pokeByteOff dst di x
|
||||
pokeByteOff dst (di+1) y
|
||||
pokeByteOff dst (di+2) z
|
||||
loop (di + 3) (i + 4)
|
||||
|
||||
decode2 :: Word8 -> Word8 -> Either Int Word8
|
||||
decode2 a b =
|
||||
case (rset a, rset b) of
|
||||
(0xff, _ ) -> Left 0
|
||||
(_ , 0xff) -> Left 1
|
||||
(ra , rb ) -> Right ((ra `unsafeShiftL` 2) .|. (rb `unsafeShiftR` 4))
|
||||
|
||||
decode3 :: Word8 -> Word8 -> Word8 -> Either Int (Word8, Word8)
|
||||
decode3 a b c =
|
||||
case (rset a, rset b, rset c) of
|
||||
(0xff, _ , _ ) -> Left 0
|
||||
(_ , 0xff, _ ) -> Left 1
|
||||
(_ , _ , 0xff) -> Left 2
|
||||
(ra , rb , rc ) ->
|
||||
let x = (ra `unsafeShiftL` 2) .|. (rb `unsafeShiftR` 4)
|
||||
y = (rb `unsafeShiftL` 4) .|. (rc `unsafeShiftR` 2)
|
||||
in Right (x,y)
|
||||
|
||||
|
||||
decode4 :: Word8 -> Word8 -> Word8 -> Word8 -> Either Int (Word8, Word8, Word8)
|
||||
decode4 a b c d =
|
||||
case (rset a, rset b, rset c, rset d) of
|
||||
(0xff, _ , _ , _ ) -> Left 0
|
||||
(_ , 0xff, _ , _ ) -> Left 1
|
||||
(_ , _ , 0xff, _ ) -> Left 2
|
||||
(_ , _ , _ , 0xff) -> Left 3
|
||||
(ra , rb , rc , rd ) ->
|
||||
let x = (ra `unsafeShiftL` 2) .|. (rb `unsafeShiftR` 4)
|
||||
y = (rb `unsafeShiftL` 4) .|. (rc `unsafeShiftR` 2)
|
||||
z = (rc `unsafeShiftL` 6) .|. rd
|
||||
in Right (x,y,z)
|
||||
|
||||
rsetURL :: Word8 -> Word8
|
||||
rsetURL !w = W8# (indexWord8OffAddr# rsetTable (word2Int# widx))
|
||||
where !(W# widx) = integralUpsize w
|
||||
!rsetTable = "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\
|
||||
\\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\
|
||||
\\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3e\xff\xff\
|
||||
\\x34\x35\x36\x37\x38\x39\x3a\x3b\x3c\x3d\xff\xff\xff\xff\xff\xff\
|
||||
\\xff\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\
|
||||
\\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\xff\xff\xff\xff\x3f\
|
||||
\\xff\x1a\x1b\x1c\x1d\x1e\x1f\x20\x21\x22\x23\x24\x25\x26\x27\x28\
|
||||
\\x29\x2a\x2b\x2c\x2d\x2e\x2f\x30\x31\x32\x33\xff\xff\xff\xff\xff\
|
||||
\\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\
|
||||
\\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\
|
||||
\\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\
|
||||
\\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\
|
||||
\\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\
|
||||
\\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\
|
||||
\\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\
|
||||
\\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"#
|
||||
|
||||
rsetOpenBSD :: Word8 -> Word8
|
||||
rsetOpenBSD !w = W8# (indexWord8OffAddr# rsetTable (word2Int# widx))
|
||||
where !(W# widx) = integralUpsize w
|
||||
!rsetTable = "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\
|
||||
\\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\
|
||||
\\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x01\
|
||||
\\x36\x37\x38\x39\x3a\x3b\x3c\x3d\x3e\x3f\xff\xff\xff\xff\xff\xff\
|
||||
\\xff\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\
|
||||
\\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\xff\xff\xff\xff\xff\
|
||||
\\xff\x1c\x1d\x1e\x1f\x20\x21\x22\x23\x24\x25\x26\x27\x28\x29\x2a\
|
||||
\\x2b\x2c\x2d\x2e\x2f\x30\x31\x32\x33\x34\x35\xff\xff\xff\xff\xff\
|
||||
\\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\
|
||||
\\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\
|
||||
\\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\
|
||||
\\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\
|
||||
\\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\
|
||||
\\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\
|
||||
\\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\
|
||||
\\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"#
|
||||
|
||||
|
||||
-- | convert from base64 in @src@ to binary in @dst@, using the number of bytes specified
|
||||
--
|
||||
-- the user should use unBase64Length to compute the correct length, or check that
|
||||
-- the length specification is proper. no check is done here.
|
||||
fromBase64 :: Ptr Word8 -> Ptr Word8 -> Int -> IO (Maybe Int)
|
||||
fromBase64 dst src len
|
||||
| len == 0 = return Nothing
|
||||
| otherwise = loop 0 0
|
||||
where loop di i
|
||||
| i == (len-4) = do
|
||||
a <- peekByteOff src i
|
||||
b <- peekByteOff src (i+1)
|
||||
c <- peekByteOff src (i+2)
|
||||
d <- peekByteOff src (i+3)
|
||||
|
||||
let (nbBytes, c',d') =
|
||||
case (c,d) of
|
||||
(0x3d, 0x3d) -> (2, 0x30, 0x30)
|
||||
(0x3d, _ ) -> (0, c, d) -- invalid: automatically 'c' will make it error out
|
||||
(_ , 0x3d) -> (1, c, 0x30)
|
||||
(_ , _ ) -> (0 :: Int, c, d)
|
||||
case decode4 a b c' d' of
|
||||
Left ofs -> return $ Just (i + ofs)
|
||||
Right (x,y,z) -> do
|
||||
pokeByteOff dst di x
|
||||
when (nbBytes < 2) $ pokeByteOff dst (di+1) y
|
||||
when (nbBytes < 1) $ pokeByteOff dst (di+2) z
|
||||
return Nothing
|
||||
| otherwise = do
|
||||
a <- peekByteOff src i
|
||||
b <- peekByteOff src (i+1)
|
||||
c <- peekByteOff src (i+2)
|
||||
d <- peekByteOff src (i+3)
|
||||
|
||||
case decode4 a b c d of
|
||||
Left ofs -> return $ Just (i + ofs)
|
||||
Right (x,y,z) -> do
|
||||
pokeByteOff dst di x
|
||||
pokeByteOff dst (di+1) y
|
||||
pokeByteOff dst (di+2) z
|
||||
loop (di + 3) (i + 4)
|
||||
|
||||
decode4 :: Word8 -> Word8 -> Word8 -> Word8 -> Either Int (Word8, Word8, Word8)
|
||||
decode4 a b c d =
|
||||
case (rset a, rset b, rset c, rset d) of
|
||||
(0xff, _ , _ , _ ) -> Left 0
|
||||
(_ , 0xff, _ , _ ) -> Left 1
|
||||
(_ , _ , 0xff, _ ) -> Left 2
|
||||
(_ , _ , _ , 0xff) -> Left 3
|
||||
(ra , rb , rc , rd ) ->
|
||||
let x = (ra `unsafeShiftL` 2) .|. (rb `unsafeShiftR` 4)
|
||||
y = (rb `unsafeShiftL` 4) .|. (rc `unsafeShiftR` 2)
|
||||
z = (rc `unsafeShiftL` 6) .|. rd
|
||||
in Right (x,y,z)
|
||||
|
||||
rset :: Word8 -> Word8
|
||||
rset !w = W8# (indexWord8OffAddr# rsetTable (word2Int# widx))
|
||||
where !(W# widx) = integralUpsize w
|
||||
|
||||
!rsetTable = "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\
|
||||
\\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\
|
||||
\\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3e\xff\xff\xff\x3f\
|
||||
\\x34\x35\x36\x37\x38\x39\x3a\x3b\x3c\x3d\xff\xff\xff\xff\xff\xff\
|
||||
\\xff\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\
|
||||
\\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\xff\xff\xff\xff\xff\
|
||||
\\xff\x1a\x1b\x1c\x1d\x1e\x1f\x20\x21\x22\x23\x24\x25\x26\x27\x28\
|
||||
\\x29\x2a\x2b\x2c\x2d\x2e\x2f\x30\x31\x32\x33\xff\xff\xff\xff\xff\
|
||||
\\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\
|
||||
\\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\
|
||||
\\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\
|
||||
\\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\
|
||||
\\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\
|
||||
\\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\
|
||||
\\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\
|
||||
\\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"#
|
||||
Loading…
Add table
Add a link
Reference in a new issue