ffi-hydrogen 0.1.0

data/vendor/stringencoders/src/modp_b36.c

@@ -0,0 +1,108 @@
+/**
+ * \file
+ * <PRE>
+ * MODP_B36 - High performance base36 encoder/decoder
+ * https://github.com/client9/stringencoders
+ *
+ * Copyright &copy; 2006-2016  Nick Galbreath
+ * All rights reserved.
+ *
+ * Released under MIT license. See LICENSE for details.
+ * </pre>
+ */
+
+/* exported public header */
+#include "modp_b36.h"
+#include "modp_stdint.h"
+/* private header */
+#include "modp_b36_data.h"
+
+/*
+ * Might need changing depending on platform
+ * we need htonl, and ntohl
+ */
+#include <arpa/inet.h>
+
+/**
+ * you can decode IN PLACE!
+ * no memory allocated
+ */
+size_t modp_b36_decode(char* out, const char* data, size_t len)
+{
+    size_t i;
+    int j;
+    const size_t buckets = len / 7;
+    const uint8_t* d2 = (const uint8_t*)data;
+    if (len % 7 != 0) {
+        return (size_t)-1;
+    }
+
+    uint32_t* o2 = (uint32_t*)out;
+    for (i = 0; i < buckets; ++i) {
+        uint32_t tmp = 0;
+        for (j = 0; j < 7; ++j) {
+            uint32_t digit = gsCharToInt[(uint32_t)*d2++];
+            if (digit >= 36) {
+                return (size_t)-1;
+            }
+            tmp = tmp * 36 + digit;
+        }
+        *o2++ = htonl(tmp);
+    }
+    return 4 * buckets;
+}
+
+/**
+ * src != out
+ */
+size_t modp_b36_encode(char* out, const char* src, size_t len)
+{
+    const uint32_t* sary = (const uint32_t*)src;
+    const size_t buckets = len / 4;
+    if (len % 4 != 0) {
+        return (size_t)-1;
+    }
+
+    size_t i;
+    for (i = 0; i < buckets; ++i) {
+        uint32_t tmp = *sary++;
+        tmp = htonl(tmp);
+
+/* this crazy function */
+#if 0
+        *out++ =  (char)gsIntToChar[(tmp / 52200625)]; // don't need % 36 here, always < 36
+        *out++ =  (char)gsIntToChar[(tmp / 614125) % 36];
+        *out++ =  (char)gsIntToChar[(tmp / 7225) % 36];
+        *out++ =  (char)gsIntToChar[(tmp / 36) % 36];
+        *out++ =  (char)gsIntToChar[tmp % 36];
+#else
+        /* is really this */
+        *(out + 6) = gsIntToChar[tmp % 36];
+        tmp /= 36;
+        *(out + 5) = gsIntToChar[tmp % 36];
+        tmp /= 36;
+        *(out + 4) = gsIntToChar[tmp % 36];
+        tmp /= 36;
+        *(out + 3) = gsIntToChar[tmp % 36];
+        tmp /= 36;
+        *(out + 2) = gsIntToChar[tmp % 36];
+        tmp /= 36;
+        *(out + 1) = gsIntToChar[tmp % 36];
+        tmp /= 36;
+        *out = gsIntToChar[tmp];
+        out += 7;
+#endif
+        // NOTES
+        // Version 1 under -O3 is about 10-20 PERCENT faster than version 2
+        // BUT Version 1 is 10 TIMES SLOWER when used with -Os !!!
+        // Reason: gcc does a lot of tricks to remove the divisions
+        //  op with multiplies and shift.
+        // In V1 with -O3 this works.  Under -Os it reverts to very
+        //   slow division.
+        // In V2 -O3 it does the same thing, but under Os, it's smart
+        // enough to know we want the quotient and remainder and only
+        // one div call per line.
+    }
+    *out = 0; // final null
+    return buckets * 7;
+}

data/vendor/stringencoders/src/modp_b36.h

@@ -0,0 +1,170 @@
+/**
+ * \file modp_b36.h
+ * \brief Base 36 encoding and decoding
+ *
+ * This provides a endian-safe base36 encode/decode operations.  This
+ * means, the result will be the same on x86 or ibm/sparc chips.
+ */
+
+/*
+ * <pre>
+ * High Performance Base36 Encoder / Decoder
+ *
+ * Copyright &copy; 2013-2016 Nick Galbreath
+ * All rights reserved.
+ *
+ * https://github.com/client9/stringencoders
+ *
+ * Released under MIT license.  See LICENSE for details.
+ * </PRE>
+ *
+ * This provides a endian-safe base36 encode/decode operations.  This
+ * means, the result will be the same on x86 or ibm/sparc chips.
+ *
+ * (Note: making it endian-specifc only results in a 5% savings in
+ *  the decode operation, so why bother)
+ */
+
+#ifndef COM_MODP_STRINGENCODERS_B36
+#define COM_MODP_STRINGENCODERS_B36
+#include "extern_c_begin.h"
+#include "modp_stdint.h"
+
+/**
+ * \brief base 36 encode
+ *
+ * \param[out] dest  should have at least b36fast_encode_len memory allocated
+ * \param[in] src   input string
+ * \param[in] len   input string length, must be a multiple of 4
+ * \return the strlen of the destination, or -1 if error
+ *
+ */
+size_t modp_b36_encode(char* dest, const char* src, size_t len);
+
+/**
+ * \brief Base 36 decode
+ * \param[out] dest -- destination locations.  May equal input.
+ * \param[in] src -- source b36data
+ * \param len -- length of source
+ * \return -1 on decoding error, length of output otherwise
+ *    No ending null is added
+ */
+size_t modp_b36_decode(char* dest, const char* src, size_t len);
+
+/**
+ * \brief Returns the amount of memory to allocate for encoding the input
+ *        string.
+ *
+ */
+#define modp_b36_encode_len(A) ((A + 3) / 4 * 5 + 1)
+
+/**
+ * \brief Return output strlen, without a NULL
+ */
+#define modp_b36_encode_strlen(A) ((A + 3) / 4 * 5)
+
+/**
+ * \brief Return the amount of memory to allocate for decoding a base 36
+ *        encoded string.
+ *
+ */
+#define modp_b36_decode_len(A) ((A + 4) / 5 * 4)
+
+#include "extern_c_end.h"
+
+#ifdef __cplusplus
+#include <cstring>
+#include <string>
+
+namespace modp {
+
+/**
+     *
+     * \param[in] s the input data
+     * \param[in] len the length of input
+     * \return b36 encoded string
+     */
+inline std::string b36_encode(const char* s, size_t len)
+{
+    std::string x(modp_b36_encode_len(len), '\0');
+    size_t d = modp_b36_encode(const_cast<char*>(x.data()), s, len);
+    if (d == (size_t)-1) {
+        x.clear();
+    } else {
+        x.erase(d, std::string::npos);
+    }
+    return x;
+}
+
+/**
+     * \param[in] null-terminated c-string input
+     * \return b36 encoded string
+     */
+inline std::string b36_encode(const char* s)
+{
+    return b36_encode(s, strlen(s));
+}
+
+/**
+     * /param[in,out] s the string to encode
+     * /return a reference to the input string, empty if error
+     */
+inline std::string& b36_encode(std::string& s)
+{
+    std::string x(b36_encode(s.data(), s.size()));
+    s.swap(x);
+    return s;
+}
+
+/**
+     * \param[in] s the input string
+     * \return base36 encoded string
+     */
+inline std::string b36_encode(const std::string& s)
+{
+    return b36_encode(s.data(), s.size());
+}
+
+/**
+     * Base36 decode a string.
+     * This function does not allocate memory.
+     *
+     * \param s the string to decode
+     * \return a reference to the input string. The string is empty
+     *   if an error occurred.
+     */
+inline std::string& b36_decode(std::string& s)
+{
+    size_t d = modp_b36_decode(const_cast<char*>(s.data()), s.data(), s.size());
+    if (d == (size_t)-1) {
+        s.clear();
+    } else {
+        s.erase(d, std::string::npos);
+    }
+    return s;
+}
+
+inline std::string b36_decode(const std::string& s)
+{
+    std::string x(s);
+    b36_decode(x);
+    return x;
+}
+
+inline std::string b36_decode(const char* s, size_t len)
+{
+    std::string x(s, len);
+    return b36_decode(x);
+}
+
+inline std::string b36_decode(const char* s)
+{
+    std::string x(s);
+    return b36_decode(x);
+}
+
+} /* namespace modp */
+
+#endif /* ifdef __cplusplus */
+
+#endif /* ifndef MODP_B36 */

data/vendor/stringencoders/src/modp_b64.c

@@ -0,0 +1,254 @@
+/**
+ * \file modp_b64.c
+ * <PRE>
+ * MODP_B64 - High performance base64 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>
+ */
+
+/*
+ * If you are ripping this out of the library, comment out the next
+ * line and uncomment the next lines as approrpiate
+ */
+// #include "config.h"
+
+/* public header */
+#include "modp_b64.h"
+
+/* if on motorola, sun, ibm; uncomment this */
+/* #define WORDS_BIGENDIAN 1 */
+/* else for Intel, Amd; uncomment this */
+/* #undef WORDS_BIGENDIAN */
+
+#include "modp_b64_data.h"
+
+#define BADCHAR 0x01FFFFFF
+
+/**
+ * you can control if we use padding by commenting out this
+ * next line.  However, I highly recommend you use padding and not
+ * using it should only be for compatibility with a 3rd party.
+ * Also, 'no padding' is not tested!
+ */
+#define DOPAD 1
+
+/*
+ * if we aren't doing padding
+ * set the pad character to NULL
+ */
+#ifndef DOPAD
+#undef CHARPAD
+#define CHARPAD '\0'
+#endif
+
+size_t modp_b64_encode(char* dest, const char* str, size_t len)
+{
+    size_t i = 0;
+    const uint8_t* s = (const uint8_t*)str;
+    uint8_t* p = (uint8_t*)dest;
+
+    /* unsigned here is important! */
+    /* uint8_t is fastest on G4, amd */
+    /* uint32_t is fastest on Intel */
+    uint32_t t1, t2, t3;
+
+    if (len > 2) {
+        for (i = 0; i < len - 2; i += 3) {
+            t1 = s[i];
+            t2 = s[i + 1];
+            t3 = s[i + 2];
+            *p++ = e0[t1];
+            *p++ = e1[((t1 & 0x03) << 4) | ((t2 >> 4) & 0x0F)];
+            *p++ = e1[((t2 & 0x0F) << 2) | ((t3 >> 6) & 0x03)];
+            *p++ = e2[t3];
+        }
+    }
+
+    switch (len - i) {
+    case 0:
+        break;
+    case 1:
+        t1 = s[i];
+        *p++ = e0[t1];
+        *p++ = e1[(t1 & 0x03) << 4];
+        *p++ = CHARPAD;
+        *p++ = CHARPAD;
+        break;
+    default: /* case 2 */
+        t1 = s[i];
+        t2 = s[i + 1];
+        *p++ = e0[t1];
+        *p++ = e1[((t1 & 0x03) << 4) | ((t2 >> 4) & 0x0F)];
+        *p++ = e2[(t2 & 0x0F) << 2];
+        *p++ = CHARPAD;
+    }
+
+    *p = '\0';
+    return (size_t)(p - (uint8_t*)dest);
+}
+
+#ifdef WORDS_BIGENDIAN /* BIG ENDIAN -- SUN / IBM / MOTOROLA */
+size_t modp_b64_decode(char* dest, const char* src, size_t len)
+{
+    size_t i;
+    if (len == 0)
+        return 0;
+
+#ifdef DOPAD
+    /* if padding is used, then the message must be at least
+       4 chars and be a multiple of 4.
+       there can be at most 2 pad chars at the end */
+    if (len < 4 || (len % 4 != 0))
+        return -1;
+    if (src[len - 1] == CHARPAD) {
+        len--;
+        if (src[len - 1] == CHARPAD) {
+            len--;
+        }
+    }
+#endif /* DOPAD */
+
+    size_t leftover = len % 4;
+    size_t chunks = (leftover == 0) ? len / 4 - 1 : len / 4;
+
+    uint8_t* p = (uint8_t*)dest;
+    uint32_t x = 0;
+    uint32_t* destInt = (uint32_t*)p;
+    uint32_t* srcInt = (uint32_t*)src;
+    uint32_t y = *srcInt++;
+    for (i = 0; i < chunks; ++i) {
+        x = d0[y >> 24 & 0xff] | d1[y >> 16 & 0xff] | d2[y >> 8 & 0xff] | d3[y & 0xff];
+
+        if (x >= BADCHAR)
+            return -1;
+        *destInt = x << 8;
+        p += 3;
+        destInt = (uint32_t*)p;
+        y = *srcInt++;
+    }
+
+    switch (leftover) {
+    case 0:
+        x = d0[y >> 24 & 0xff] | d1[y >> 16 & 0xff] | d2[y >> 8 & 0xff] | d3[y & 0xff];
+        if (x >= BADCHAR)
+            return -1;
+        *p++ = ((uint8_t*)&x)[1];
+        *p++ = ((uint8_t*)&x)[2];
+        *p = ((uint8_t*)&x)[3];
+        return (chunks + 1) * 3;
+#ifndef DOPAD
+    case 1: /* with padding this is an impossible case */
+        x = d3[y >> 24];
+        *p = (uint8_t)x;
+        break;
+#endif
+    case 2:
+        x = d3[y >> 24] * 64 + d3[(y >> 16) & 0xff];
+        *p = (uint8_t)(x >> 4);
+        break;
+    default: /* case 3 */
+        x = (d3[y >> 24] * 64 + d3[(y >> 16) & 0xff]) * 64 + d3[(y >> 8) & 0xff];
+        *p++ = (uint8_t)(x >> 10);
+        *p = (uint8_t)(x >> 2);
+        break;
+    }
+
+    if (x >= BADCHAR)
+        return -1;
+    return 3 * chunks + (6 * leftover) / 8;
+}
+
+#else /* LITTLE  ENDIAN -- INTEL AND FRIENDS */
+
+size_t modp_b64_decode(char* dest, const char* src, size_t len)
+{
+    size_t i;
+    size_t leftover;
+    size_t chunks;
+
+    uint8_t* p;
+    uint32_t x;
+    uint32_t* destInt;
+    const uint32_t* srcInt = (const uint32_t*)src;
+    uint32_t y = *srcInt++;
+
+    if (len == 0)
+        return 0;
+
+#ifdef DOPAD
+    /*
+     * if padding is used, then the message must be at least
+     * 4 chars and be a multiple of 4
+     */
+    if (len < 4 || (len % 4 != 0)) {
+        return (size_t)-1; /* error */
+    }
+    /* there can be at most 2 pad chars at the end */
+    if (src[len - 1] == CHARPAD) {
+        len--;
+        if (src[len - 1] == CHARPAD) {
+            len--;
+        }
+    }
+#endif
+
+    leftover = len % 4;
+    chunks = (leftover == 0) ? len / 4 - 1 : len / 4;
+
+    p = (uint8_t*)dest;
+    x = 0;
+    destInt = (uint32_t*)p;
+    srcInt = (const uint32_t*)src;
+    y = *srcInt++;
+    for (i = 0; i < chunks; ++i) {
+        x = d0[y & 0xff] | d1[(y >> 8) & 0xff] | d2[(y >> 16) & 0xff] | d3[(y >> 24) & 0xff];
+
+        if (x >= BADCHAR) {
+            return (size_t)-1;
+        }
+        *destInt = x;
+        p += 3;
+        destInt = (uint32_t*)p;
+        y = *srcInt++;
+    }
+
+    switch (leftover) {
+    case 0:
+        x = d0[y & 0xff] | d1[(y >> 8) & 0xff] | d2[(y >> 16) & 0xff] | d3[(y >> 24) & 0xff];
+
+        if (x >= BADCHAR) {
+            return (size_t)-1;
+        }
+        *p++ = ((uint8_t*)(&x))[0];
+        *p++ = ((uint8_t*)(&x))[1];
+        *p = ((uint8_t*)(&x))[2];
+        return (chunks + 1) * 3;
+#ifndef DOPAD
+    case 1: /* with padding this is an impossible case */
+        x = d0[y & 0xff];
+        *p = *((uint8_t*)(&x)); /* i.e. first char/byte in int */
+        break;
+#endif
+    case 2: /* case 2, 1  output byte */
+        x = d0[y & 0xff] | d1[y >> 8 & 0xff];
+        *p = *((uint8_t*)(&x)); /* i.e. first char */
+        break;
+    default: /* case 3, 2 output bytes */
+        x = d0[y & 0xff] | d1[y >> 8 & 0xff] | d2[y >> 16 & 0xff]; /* 0x3c */
+        *p++ = ((uint8_t*)(&x))[0];
+        *p = ((uint8_t*)(&x))[1];
+        break;
+    }
+
+    if (x >= BADCHAR) {
+        return (size_t)-1;
+    }
+
+    return 3 * chunks + (6 * leftover) / 8;
+}
+
+#endif /* if bigendian / else / endif */