ffi-hydrogen 0.1.0

data/vendor/stringencoders/src/modp_ascii.c

@@ -0,0 +1,159 @@
+/*
+ * modp_ascii.c
+ * <PRE>
+ * MODP_ASCII - Ascii transformations (upper/lower, etc)
+ * https://github.com/client9/stringencoders
+ *
+ * Copyright &copy; 2007-16  Nick Galbreath -- nickg [at] client9 [dot] com
+ * MIT LICENSE
+ *
+ * </PRE>
+ */
+
+#include "modp_ascii.h"
+#include "modp_ascii_data.h"
+#include "modp_stdint.h"
+
+void modp_toupper_copy(char* dest, const char* str, size_t len)
+{
+    size_t i;
+    uint32_t eax, ebx;
+    const uint8_t* ustr = (const uint8_t*)str;
+    const size_t leftover = len % 4;
+    const size_t imax = len / 4;
+    const uint32_t* s = (const uint32_t*)str;
+    uint32_t* d = (uint32_t*)dest;
+    for (i = 0; i != imax; ++i) {
+        eax = s[i];
+        /*
+         * This is based on the algorithm by Paul Hsieh
+         * http://www.azillionmonkeys.com/qed/asmexample.html
+         */
+        ebx = (0x7f7f7f7fu & eax) + 0x05050505u;
+        ebx = (0x7f7f7f7fu & ebx) + 0x1a1a1a1au;
+        ebx = ((ebx & ~eax) >> 2) & 0x20202020u;
+        *d++ = eax - ebx;
+    }
+
+    i = imax * 4;
+    dest = (char*)d;
+    switch (leftover) {
+    case 3:
+        *dest++ = (char)gsToUpperMap[ustr[i++]];
+        /* fall through */
+    case 2:
+        *dest++ = (char)gsToUpperMap[ustr[i++]];
+        /* fall through */
+    case 1:
+        *dest++ = (char)gsToUpperMap[ustr[i]];
+        /* fall through */
+    case 0:
+        *dest = '\0';
+    }
+}
+
+void modp_tolower_copy(char* dest, const char* str, size_t len)
+{
+    size_t i;
+    uint32_t eax, ebx;
+    const uint8_t* ustr = (const uint8_t*)str;
+    const size_t leftover = len % 4;
+    const size_t imax = len / 4;
+    const uint32_t* s = (const uint32_t*)str;
+    uint32_t* d = (uint32_t*)dest;
+    for (i = 0; i != imax; ++i) {
+        eax = s[i];
+        /*
+         * This is based on the algorithm by Paul Hsieh
+         * http://www.azillionmonkeys.com/qed/asmexample.html
+         */
+        ebx = (0x7f7f7f7fu & eax) + 0x25252525u;
+        ebx = (0x7f7f7f7fu & ebx) + 0x1a1a1a1au;
+        ebx = ((ebx & ~eax) >> 2) & 0x20202020u;
+        *d++ = eax + ebx;
+    }
+
+    i = imax * 4;
+    dest = (char*)d;
+    switch (leftover) {
+    case 3:
+        *dest++ = (char)gsToLowerMap[ustr[i++]];
+        /* fall through */
+    case 2:
+        *dest++ = (char)gsToLowerMap[ustr[i++]];
+        /* fall through */
+    case 1:
+        *dest++ = (char)gsToLowerMap[ustr[i]];
+        /* fall through */
+    case 0:
+        *dest = '\0';
+    }
+}
+
+void modp_toupper(char* str, size_t len)
+{
+    modp_toupper_copy(str, str, len);
+}
+
+void modp_tolower(char* str, size_t len)
+{
+    modp_tolower_copy(str, str, len);
+}
+
+void modp_toprint_copy(char* dest, const char* str, size_t len)
+{
+    size_t i;
+    uint8_t c1, c2, c3, c4;
+
+    const size_t leftover = len % 4;
+    const size_t imax = len - leftover;
+    const uint8_t* s = (const uint8_t*)str;
+    for (i = 0; i != imax; i += 4) {
+        /*
+         * it's important to make these variables
+         * it helps the optimizer to figure out what to do
+         */
+        c1 = s[i];
+        c2 = s[i + 1];
+        c3 = s[i + 2];
+        c4 = s[i + 3];
+        dest[0] = (char)gsToPrintMap[c1];
+        dest[1] = (char)gsToPrintMap[c2];
+        dest[2] = (char)gsToPrintMap[c3];
+        dest[3] = (char)gsToPrintMap[c4];
+        dest += 4;
+    }
+
+    switch (leftover) {
+    case 3:
+        *dest++ = (char)gsToPrintMap[s[i++]];
+        /* fall through */
+    case 2:
+        *dest++ = (char)gsToPrintMap[s[i++]];
+        /* fall through */
+    case 1:
+        *dest++ = (char)gsToPrintMap[s[i]];
+        /* fall through */
+    case 0:
+        *dest = '\0';
+    }
+}
+
+void modp_toprint(char* str, size_t len)
+{
+    modp_toprint_copy(str, str, len);
+}
+
+size_t modp_rtrim(char* str, size_t len)
+{
+    while (len) {
+        char c = str[len - 1];
+        if (c == ' ' || c == '\n' || c == '\t' || c == '\r') {
+            str[len - 1] = '\0';
+            len -= 1;
+        } else {
+            break;
+        }
+    }
+    return len;
+}

data/vendor/stringencoders/src/modp_ascii.h

@@ -0,0 +1,162 @@
+/**
+ * \file modp_ascii.h
+ * \brief Simple ASCII manipulations including upper and lower casing,
+ *        white space trimming, and conversion to "printable" characters.
+ *
+ * blah blah blah
+ */
+
+/*
+ * <PRE>
+ * MODP_ASCII -- Simple ascii manipulation (uppercase, lowercase, etc)
+ * https://github.com/client9/stringencoders
+ *
+ * Copyright &copy; 2007-2016, Nick Galbreath -- nickg [at] client9 [dot] com
+ * All rights reserved.
+ *
+ * Released under MIT license.  See LICENSE for details.
+ * </PRE>
+ *
+ */
+
+#ifndef COM_MODP_STRINGENCODERS_ASCII
+#define COM_MODP_STRINGENCODERS_ASCII
+
+#include "extern_c_begin.h"
+#include "modp_stdint.h"
+
+/*
+ * \param[in,out] str the input string
+ * \param[in] len the length of input string (the strlen)
+ */
+void modp_toupper(char* str, size_t len);
+
+/** \brief make lower case copy of input string
+ *
+ * \param[out] dest output buffer, with at least 'len + 1' bytes allocated
+ * \param[in] str the input string
+ * \param[in] len the length of input string (the strlen)
+ *
+ * Please make sure dest has been allocation with at least 'len+1'
+ * bytes.  This appends a trailing NULL character at the end of
+ * dest!
+ *
+ * This is based on the algorithm by Paul Hsieh
+ * http://www.azillionmonkeys.com/qed/asmexample.html
+ */
+void modp_toupper_copy(char* dest, const char* str, size_t len);
+
+/** \brief lower case a string in place
+ *
+ * \param[in,out] str the input string
+ * \param[in] len the length of input string (the strlen)
+ *
+ */
+void modp_tolower(char* str, size_t len);
+
+/** \brief make lower case copy of input string
+ *
+ * \param[out] dest output buffer, with at least 'len + 1' bytes allocated
+ * \param[in] str the input string
+ * \param[in] len the length of input string (the strlen)
+ *
+ * Please make sure dest has been allocation with at least 'len+1'
+ * bytes.  This appends a trailing NULL character at the end of
+ * dest!
+ *
+ * This is based on the algorithm by Paul Hsieh
+ * http://www.azillionmonkeys.com/qed/asmexample.html
+ */
+void modp_tolower_copy(char* dest, const char* str, size_t len);
+
+/** \brief turn a string into 7-bit printable ascii.
+ *
+ * By "printable" we means all characters between 32 and 126.
+ * All other values are turned into '?'
+ *
+ * \param[in,out] str the input string
+ * \param[in] len the length of input string (the strlen)
+ *
+ */
+void modp_toprint(char* str, size_t len);
+
+/** \brief make a printable copy of a string
+ *
+ * By "printable" we means all characters between 32 and 126.
+ * All other values are turned into '?'
+ *
+ * \param[out] dest output buffer, with at least 'len + 1' bytes allocated
+ * \param[in] str the input string
+ * \param[in] len the length of input string (the strlen)
+ *
+ * Please make sure dest has been allocation with at least 'len+1'
+ * bytes.  This appends a trailing NULL character at the end of
+ * dest!
+ */
+void modp_toprint_copy(char* dest, const char* str, size_t len);
+
+/**
+ * \brief remove trailing whitespace from a string
+ * \param[in,out] str  string to be stripped
+ * \param[in] len the size of the input
+ * \return the size of the output, not including any ending null byte.
+ */
+size_t modp_rtrim(char* str, size_t len);
+
+#include "extern_c_end.h"
+
+#ifdef __cplusplus
+#include <string>
+
+namespace modp {
+
+inline std::string& toupper(std::string& str)
+{
+    modp_toupper(const_cast<char*>(str.c_str()), str.size());
+    return str;
+}
+
+inline std::string toupper(const std::string& str)
+{
+    std::string s(str.size(), '\0');
+    modp_toupper_copy(const_cast<char*>(s.data()), str.data(), str.size());
+    return s;
+}
+
+inline std::string tolower(const std::string& str)
+{
+    std::string s(str.size(), '\0');
+    modp_tolower_copy(const_cast<char*>(s.data()), str.data(), str.size());
+    return s;
+}
+
+inline std::string& tolower(std::string& str)
+{
+    modp_tolower(const_cast<char*>(str.c_str()), str.size());
+    return str;
+}
+
+inline std::string toprint(const std::string& str)
+{
+    std::string s(str.size(), '\0');
+    modp_toprint_copy(const_cast<char*>(s.data()), str.data(), str.size());
+    return s;
+}
+
+inline std::string& toprint(std::string& str)
+{
+    modp_toprint(const_cast<char*>(str.c_str()), str.size());
+    return str;
+}
+
+inline std::string& rtrim(std::string& s)
+{
+    size_t d = modp_rtrim(const_cast<char*>(s.data()), s.size());
+    s.erase(d, std::string::npos);
+    return s;
+}
+}
+
+#endif /* __cplusplus */
+
+#endif /* MODP_ASCII */

data/vendor/stringencoders/src/modp_ascii_data.h

@@ -0,0 +1,84 @@
+static const uint8_t gsToUpperMap[256] = {
+    '\0', 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, '\t',
+    '\n', 0x0b, 0x0c, '\r', 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13,
+    0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d,
+    0x1e, 0x1f, ' ', '!', '"', '#', '$', '%', '&', '\'',
+    '(', ')', '*', '+', ',', '-', '.', '/', '0', '1',
+    '2', '3', '4', '5', '6', '7', '8', '9', ':', ';',
+    '<', '=', '>', '?', '@', 'A', 'B', 'C', 'D', 'E',
+    'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
+    'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y',
+    'Z', '[', '\\', ']', '^', '_', '`', 'A', 'B', 'C',
+    'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
+    'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W',
+    'X', 'Y', 'Z', '{', '|', '}', '~', 0x7f, 0x80, 0x81,
+    0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b,
+    0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95,
+    0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
+    0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9,
+    0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3,
+    0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd,
+    0xbe, 0xbf, 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
+    0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xd0, 0xd1,
+    0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb,
+    0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5,
+    0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
+    0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9,
+    0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
+};
+static const uint8_t gsToLowerMap[256] = {
+    '\0', 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, '\t',
+    '\n', 0x0b, 0x0c, '\r', 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13,
+    0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d,
+    0x1e, 0x1f, ' ', '!', '"', '#', '$', '%', '&', '\'',
+    '(', ')', '*', '+', ',', '-', '.', '/', '0', '1',
+    '2', '3', '4', '5', '6', '7', '8', '9', ':', ';',
+    '<', '=', '>', '?', '@', 'a', 'b', 'c', 'd', 'e',
+    'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
+    'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y',
+    'z', '[', '\\', ']', '^', '_', '`', 'a', 'b', 'c',
+    'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
+    'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w',
+    'x', 'y', 'z', '{', '|', '}', '~', 0x7f, 0x80, 0x81,
+    0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b,
+    0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95,
+    0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
+    0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9,
+    0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3,
+    0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd,
+    0xbe, 0xbf, 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
+    0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xd0, 0xd1,
+    0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb,
+    0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5,
+    0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
+    0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9,
+    0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
+};
+static const uint8_t gsToPrintMap[256] = {
+    '?', '?', '?', '?', '?', '?', '?', '?', '?', '?',
+    '?', '?', '?', '?', '?', '?', '?', '?', '?', '?',
+    '?', '?', '?', '?', '?', '?', '?', '?', '?', '?',
+    '?', '?', ' ', '!', '"', '#', '$', '%', '&', '\'',
+    '(', ')', '*', '+', ',', '-', '.', '/', '0', '1',
+    '2', '3', '4', '5', '6', '7', '8', '9', ':', ';',
+    '<', '=', '>', '?', '@', 'A', 'B', 'C', 'D', 'E',
+    'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
+    'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y',
+    'Z', '[', '\\', ']', '^', '_', '`', 'a', 'b', 'c',
+    'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
+    'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w',
+    'x', 'y', 'z', '{', '|', '}', '~', '?', '?', '?',
+    '?', '?', '?', '?', '?', '?', '?', '?', '?', '?',
+    '?', '?', '?', '?', '?', '?', '?', '?', '?', '?',
+    '?', '?', '?', '?', '?', '?', '?', '?', '?', '?',
+    '?', '?', '?', '?', '?', '?', '?', '?', '?', '?',
+    '?', '?', '?', '?', '?', '?', '?', '?', '?', '?',
+    '?', '?', '?', '?', '?', '?', '?', '?', '?', '?',
+    '?', '?', '?', '?', '?', '?', '?', '?', '?', '?',
+    '?', '?', '?', '?', '?', '?', '?', '?', '?', '?',
+    '?', '?', '?', '?', '?', '?', '?', '?', '?', '?',
+    '?', '?', '?', '?', '?', '?', '?', '?', '?', '?',
+    '?', '?', '?', '?', '?', '?', '?', '?', '?', '?',
+    '?', '?', '?', '?', '?', '?', '?', '?', '?', '?',
+    '?', '?', '?', '?', '?', '?'
+};

data/vendor/stringencoders/src/modp_ascii_gen.c

@@ -0,0 +1,55 @@
+#include "arraytoc.h"
+#include <stdio.h>
+
+static void modp_toupper_map(void)
+{
+    size_t i = 0;
+    char map[256];
+    for (i = 0; i < sizeof(map); ++i) {
+        if (i >= 'a' && i <= 'z') {
+            map[i] = (char)(i - 32);
+        } else {
+            map[i] = (char)(i);
+        }
+    }
+
+    char_array_to_c(map, sizeof(map), "gsToUpperMap");
+}
+
+static void modp_tolower_map(void)
+{
+    size_t i = 0;
+    char map[256];
+    for (i = 0; i < sizeof(map); ++i) {
+        if (i >= 'A' && i <= 'Z') {
+            map[i] = (char)(i + 32);
+        } else {
+            map[i] = (char)i;
+        }
+    }
+
+    char_array_to_c(map, sizeof(map), "gsToLowerMap");
+}
+
+static void modp_toprint_map(void)
+{
+    size_t i = 0;
+    char map[256];
+    for (i = 0; i < sizeof(map); ++i) {
+        if (i < 32 || i > 126) {
+            map[i] = '?';
+        } else {
+            map[i] = (char)i;
+        }
+    }
+
+    char_array_to_c(map, sizeof(map), "gsToPrintMap");
+}
+
+int main(void)
+{
+    modp_toupper_map();
+    modp_tolower_map();
+    modp_toprint_map();
+    return 0;
+}

data/vendor/stringencoders/src/modp_b16.c

@@ -0,0 +1,125 @@
+/**
+ * \file
+ * <PRE>
+ * MODP_B16 - High performance base16 encoder/decoder
+ * https://github.com/client9/stringencoders
+ *
+ * Copyright &copy; 2005-2016  Nick Galbreath
+ * All rights reserved.
+ * Released under MIT license. See LICENSE for details.
+ * </PRE>
+ */
+#include "modp_b16.h"
+#include "config.h"
+#include "modp_b16_data.h"
+#include "modp_stdint.h"
+
+size_t modp_b16_encode(char* dest, const char* str, size_t len)
+{
+    size_t i;
+    const size_t buckets = len >> 2; /* i.e. i / 4 */
+    const size_t leftover = len & 0x03; /* i.e. i % 4 */
+    const uint8_t* srcChar;
+    uint8_t* p = (uint8_t*)dest;
+    uint8_t t1, t2, t3, t4;
+    const uint32_t* srcInt = (const uint32_t*)str;
+    uint32_t x;
+    for (i = 0; i < buckets; ++i) {
+        x = *srcInt++;
+/*      t1 = *s++; t2 = *s++; t3 = *s++; t4 = *s++; */
+#ifdef WORDS_BIGENDIAN
+        t1 = (uint8_t)(x >> 24);
+        t2 = (uint8_t)(x >> 16);
+        t3 = (uint8_t)(x >> 8);
+        t4 = (uint8_t)x;
+#else
+        t4 = (uint8_t)(x >> 24);
+        t3 = (uint8_t)(x >> 16);
+        t2 = (uint8_t)(x >> 8);
+        t1 = (uint8_t)x;
+#endif
+        *p++ = gsHexEncodeC1[t1];
+        *p++ = gsHexEncodeC2[t1];
+        *p++ = gsHexEncodeC1[t2];
+        *p++ = gsHexEncodeC2[t2];
+        *p++ = gsHexEncodeC1[t3];
+        *p++ = gsHexEncodeC2[t3];
+        *p++ = gsHexEncodeC1[t4];
+        *p++ = gsHexEncodeC2[t4];
+    }
+
+    srcChar = (const uint8_t*)srcInt;
+    switch (leftover) {
+    case 0:
+        break;
+    case 1:
+        t1 = (uint8_t)*srcChar;
+        *p++ = gsHexEncodeC1[t1];
+        *p++ = gsHexEncodeC2[t1];
+        break;
+    case 2:
+        t1 = (uint8_t)*srcChar++;
+        t2 = (uint8_t)*srcChar;
+        *p++ = gsHexEncodeC1[t1];
+        *p++ = gsHexEncodeC2[t1];
+        *p++ = gsHexEncodeC1[t2];
+        *p++ = gsHexEncodeC2[t2];
+        break;
+    default: /* case 3 */
+        t1 = (uint8_t)*srcChar++;
+        t2 = (uint8_t)*srcChar++;
+        t3 = (uint8_t)*srcChar;
+        *p++ = gsHexEncodeC1[t1];
+        *p++ = gsHexEncodeC2[t1];
+        *p++ = gsHexEncodeC1[t2];
+        *p++ = gsHexEncodeC2[t2];
+        *p++ = gsHexEncodeC1[t3];
+        *p++ = gsHexEncodeC2[t3];
+    }
+    *p = '\0';
+    return (size_t)(p - (uint8_t*)dest);
+}
+
+size_t modp_b16_decode(char* dest, const char* str, size_t len)
+{
+    size_t i;
+    uint8_t t0, t1, t2, t3;
+    uint8_t* p = (uint8_t*)dest;
+    uint32_t val1, val2;
+    const uint8_t* s = (const uint8_t*)str;
+    const size_t buckets = len >> 2; /* i.e. len / 4 */
+    const size_t leftover = len & 0x03; /* i.e. len % 4 */
+    if (leftover & 0x01) { /* i.e if leftover is odd,      */
+        /* leftover==1 || leftover == 3 */
+        return (size_t)-1;
+    }
+
+    /* read 4 bytes, output 2.
+     * Note on PPC G4, GCC 4.0, it's quite a bit faster to
+     * NOT use t0,t1,t2,t3, and just put the *s++ in the gsHexDecodeMap
+     * lookup
+     */
+    for (i = 0; i < buckets; ++i) {
+        t0 = *s++;
+        t1 = *s++;
+        t2 = *s++;
+        t3 = *s++;
+        val1 = gsHexDecodeD2[t0] | gsHexDecodeMap[t1];
+        val2 = gsHexDecodeD2[t2] | gsHexDecodeMap[t3];
+        if (val1 > 0xff || val2 > 0xff) {
+            return (size_t)-1;
+        }
+        *p++ = (uint8_t)val1;
+        *p++ = (uint8_t)val2;
+    }
+
+    if (leftover == 2) {
+        val1 = gsHexDecodeD2[s[0]] | gsHexDecodeMap[s[1]];
+        if (val1 > 0xff) {
+            return (size_t)-1;
+        }
+        *p++ = (uint8_t)val1;
+    }
+
+    return (size_t)(p - (uint8_t*)dest);
+}