ffi-hydrogen 0.1.0

data/vendor/stringencoders/src/modp_b85.h

@@ -0,0 +1,171 @@
+/**
+ * \file modp_b85.h
+ * \brief Base 85 encoding and decoding
+ *
+ * This provides a endian-safe base85 encode/decode operations.  This
+ * means, the result will be the same on x86 or ibm/sparc chips.
+ */
+
+/*
+ * <pre>
+ * High Performance Base85 Encoder / Decoder
+ *
+ * Copyright &copy; 2006-2016 Nick Galbreath -- nickg [at] client9 [dot] com
+ * All rights reserved.
+ *
+ * https://github.com/client9/stringencoders/
+ *
+ * Released under MIT license.  See LICENSE for details.
+ * </PRE>
+ *
+ * This provides a endian-safe base85 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_B85
+#define COM_MODP_STRINGENCODERS_B85
+#include "extern_c_begin.h"
+#include "modp_stdint.h"
+
+/**
+ * \brief base 85 encode
+ *
+ * \param[out] dest  should have at least b85fast_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_b85_encode(char* dest, const char* src, size_t len);
+
+/**
+ * \brief Base 85 decode
+ * \param[out] dest -- destination locations.  May equal input.
+ * \param[in] src -- source b85data
+ * \param len -- length of source
+ * \return -1 on decoding error, length of output otherwise
+ *    No ending null is added
+ */
+size_t modp_b85_decode(char* dest, const char* src, size_t len);
+
+/**
+ * \brief Returns the amount of memory to allocate for encoding the input
+ *        string.
+ *
+ */
+#define modp_b85_encode_len(A) ((A + 3) / 4 * 5 + 1)
+
+/**
+ * \brief Return output strlen, without a NULL
+ */
+#define modp_b85_encode_strlen(A) ((A + 3) / 4 * 5)
+
+/**
+ * \brief Return the amount of memory to allocate for decoding a base 85
+ *        encoded string.
+ *
+ */
+#define modp_b85_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 b85 encoded string
+     */
+inline std::string b85_encode(const char* s, size_t len)
+{
+    std::string x(modp_b85_encode_len(len), '\0');
+    size_t d = modp_b85_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 b85 encoded string
+     */
+inline std::string b85_encode(const char* s)
+{
+    return b85_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& b85_encode(std::string& s)
+{
+    std::string x(b85_encode(s.data(), s.size()));
+    s.swap(x);
+    return s;
+}
+
+/**
+     * \param[in] s the input string
+     * \return base85 encoded string
+     */
+inline std::string b85_encode(const std::string& s)
+{
+    return b85_encode(s.data(), s.size());
+}
+
+/**
+     * Base85 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& b85_decode(std::string& s)
+{
+    size_t d = modp_b85_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 b85_decode(const std::string& s)
+{
+    std::string x(s);
+    b85_decode(x);
+    return x;
+}
+
+inline std::string b85_decode(const char* s, size_t len)
+{
+    std::string x(s, len);
+    return b85_decode(x);
+}
+
+inline std::string b85_decode(const char* s)
+{
+    std::string x(s);
+    return b85_decode(x);
+}
+
+} /* namespace modp */
+
+#endif /* ifdef __cplusplus */
+
+#endif /* ifndef MODP_B85 */

data/vendor/stringencoders/src/modp_b85_data.h

@@ -0,0 +1,36 @@
+/* do not edit -- autogenerated from b85gen */
+static const uint32_t gsCharToInt[256] = {
+    99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
+    99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
+    99, 99, 99, 99, 99, 99, 99, 99, 99, 0, 99, 1,
+    2, 3, 99, 4, 5, 6, 7, 8, 99, 9, 10, 11,
+    12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 99,
+    23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
+    35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46,
+    47, 48, 49, 50, 51, 52, 53, 54, 99, 55, 56, 57,
+    58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
+    70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
+    82, 83, 84, 99, 99, 99, 99, 99, 99, 99, 99, 99,
+    99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
+    99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
+    99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
+    99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
+    99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
+    99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
+    99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
+    99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
+    99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
+    99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
+    99, 99, 99, 99
+};
+static const uint8_t gsIntToChar[85] = {
+    '!', '#', '$', '%', '\'', '(', ')', '*', '+', '-',
+    '.', '/', '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_b85_gen.c

@@ -0,0 +1,65 @@
+#include "arraytoc.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+/**
+ * raw data to base85 char map
+ */
+static char gsIntToChar[85];
+
+/**
+ * base 85 char to int
+ */
+static uint32_t gsCharToInt[256];
+
+/*
+ * Set up the above arrays
+ */
+static void initTables(void)
+{
+    int i = 0;
+    int j = 0;
+    for (i = 0; i < 256; i++) {
+        gsCharToInt[i] = 99;
+    }
+
+    /* i < 33 or '!' is unprintable
+     * 127 is an unprintable character
+     */
+    for (i = '!', j = 0; j < 85 && i < 127; ++i) {
+
+        /* You can have 8 restrictions in the following line.
+         * Traditional postscript removes: ';', '&', '\', '"'
+         *   so that 'last' character is 'y' ('z' is special)
+         * For web/cookie applications, I recommend those plus ','
+         */
+        if (i == ';' || i == '&' || i == '\\' || i == '"' || i == ',') {
+            continue;
+        }
+        gsIntToChar[j] = (char)i;
+        gsCharToInt[i] = (uint32_t)j;
+        ++j;
+    }
+
+    if (j != 85) {
+        fprintf(stderr, "Error in base85 table.  You probably had too many restrictions\n");
+        exit(1);
+    }
+}
+
+/**
+ * beginning headers
+ */
+static void printStart(void)
+{
+    printf("/* do not edit -- autogenerated from b85gen */\n");
+}
+
+int main(void)
+{
+    initTables();
+    printStart();
+    uint32_array_to_c(gsCharToInt, sizeof(gsCharToInt) / sizeof(uint32_t), "gsCharToInt");
+    char_array_to_c(gsIntToChar, sizeof(gsIntToChar), "gsIntToChar");
+    return 0;
+}

data/vendor/stringencoders/src/modp_bjavascript.c

@@ -0,0 +1,65 @@
+/**
+ * \file
+ * <pre>
+ * modp_bjavascript.c High performance URL 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>
+ */
+#include "modp_bjavascript.h"
+#include "modp_bjavascript_data.h"
+#include "modp_stdint.h"
+
+size_t modp_bjavascript_encode(char* dest, const char* src, size_t len)
+{
+    const char* deststart = dest;
+    const uint8_t* s = (const uint8_t*)src;
+    const uint8_t* srcend = s + len;
+    uint8_t x;
+    uint8_t val;
+
+    /* if 0, do nothing
+     * if 'A', hex escape
+     * else, \\ + value
+     */
+    while (s < srcend) {
+        x = *s++;
+        val = gsJavascriptEncodeMap[x];
+        if (val == 0) {
+            *dest++ = (char)x;
+        } else if (val == 'A') {
+            *dest++ = '\\';
+            *dest++ = 'x';
+            *dest++ = (char)(gsHexEncodeMap1[x]);
+            *dest++ = (char)(gsHexEncodeMap2[x]);
+        } else {
+            *dest++ = '\\';
+            *dest++ = (char)val;
+        }
+    }
+    *dest = '\0';
+    return (size_t)(dest - deststart);
+}
+
+size_t modp_bjavascript_encode_strlen(const char* src, size_t len)
+{
+    const uint8_t* s = (const uint8_t*)src;
+    const uint8_t* srcend = s + len;
+    size_t count = 0;
+    uint8_t val;
+
+    while (s < srcend) {
+        val = gsJavascriptEncodeMap[*s++];
+        if (val == 0) {
+            count++;
+        } else if (val == 'A') {
+            count += 4;
+        } else {
+            count += 2;
+        }
+    }
+    return count;
+}

data/vendor/stringencoders/src/modp_bjavascript.h

@@ -0,0 +1,105 @@
+/**
+ * \file modp_bjavascript.h
+ * \brief "C-string" to "javascript-string" encoder
+ *
+ * Used in emitting dynamically-generated javascript.  Given a regular
+ * C-string which might contain binary, the encoder will emit a string
+ * that can be used inside a javascript string.  For example:
+ *
+ * \code
+ *  printf("var foo = '%s';", modp_bjavascript_encode(mystring, len));
+ * \endcode
+ *
+ * The "b" in "modp_bjavascript" is due to legacy reasons.  It doesn't
+ * mean anything
+ *
+ * There is no decoder.
+ */
+
+/*
+ * <PRE>
+ * High Performance c-string to javascript-string encoder
+ *
+ * Copyright &copy; 2006-2016  Nick Galbreath
+ * All rights reserved.
+ *
+ * https://github.com/client9/stringencoders
+ *
+ * Released under MIT license.  See LICENSE for details.
+ * </PRE>
+ */
+
+#ifndef COM_MODP_STRINGENCODERS_BJAVASCRIPT
+#define COM_MODP_STRINGENCODERS_BJAVASCRIPT
+
+#include "modp_stdint.h"
+
+#include "extern_c_begin.h"
+
+/**
+ * "javascript" encode a stirng
+ * This takes a c-string and does character escaping
+ * so it can be put into a var js_string = '...';
+ *
+ * \param[out] dest output string.  Must
+ * \param[in] str The input string
+ * \param[in] len  The length of the input string, excluding any
+ *   final null byte.
+ */
+size_t modp_bjavascript_encode(char* dest, const char* str, size_t len);
+
+#define modp_bjavascript_encode_len(A) (4 * A + 1)
+
+/**
+ * Given the exact size of output string.
+ *
+ * Can be used to allocate the right amount of memory for
+ * modp_burl_encode.  Be sure to add 1 byte for final null.
+ *
+ * This is somewhat expensive since it examines every character
+ *  in the input string
+ *
+ * \param[in] str  The input string
+ * \param[in] len  THe length of the input string, excluding any
+ *   final null byte (i.e. strlen(str))
+ * \return the size of the output string, excluding the final
+ *   null byte.
+ */
+size_t modp_bjavascript_encode_strlen(const char* str, size_t len);
+
+#include "extern_c_end.h"
+
+#ifdef __cplusplus
+#include <cstring>
+#include <string>
+namespace modp {
+
+inline std::string javascript_encode(const char* s, size_t len)
+{
+    std::string x(modp_bjavascript_encode_len(len), '\0');
+    size_t d = modp_bjavascript_encode(const_cast<char*>(x.data()), s, len);
+    x.erase(d, std::string::npos);
+    return x;
+}
+
+inline std::string javascript_encode(const char* s)
+{
+    return javascript_encode(s, strlen(s));
+}
+
+inline std::string& javascript_encode(std::string& s)
+{
+    std::string x(javascript_encode(s.data(), s.size()));
+    s.swap(x);
+    return s;
+}
+
+inline std::string javascript_encode(const std::string& s)
+{
+    return javascript_encode(s.data(), s.size());
+}
+
+} /* namespace modp */
+#endif /* __cplusplus */
+
+#endif /* modp_bjavascript */

data/vendor/stringencoders/src/modp_bjavascript_data.h

@@ -0,0 +1,84 @@
+static const uint8_t gsJavascriptEncodeMap[256] = {
+    'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'b', 't',
+    'n', 'v', 'f', 'r', 'A', 'A', 'A', 'A', 'A', 'A',
+    'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
+    'A', 'A', '\0', '\0', '"', '\0', '\0', '\0', '\0', '\'',
+    '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
+    '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
+    '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
+    '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
+    '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
+    '\0', '\0', '\\', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
+    '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
+    '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0',
+    '\0', '\0', '\0', '\0', '\0', '\0', '\0', 'A', 'A', 'A',
+    'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
+    'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
+    'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
+    'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
+    'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
+    'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
+    'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
+    'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
+    'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
+    'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
+    'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
+    'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
+    'A', 'A', 'A', 'A', 'A', 'A'
+};
+static const uint8_t gsHexEncodeMap1[256] = {
+    '0', '0', '0', '0', '0', '0', '0', '0', '0', '0',
+    '0', '0', '0', '0', '0', '0', '1', '1', '1', '1',
+    '1', '1', '1', '1', '1', '1', '1', '1', '1', '1',
+    '1', '1', '2', '2', '2', '2', '2', '2', '2', '2',
+    '2', '2', '2', '2', '2', '2', '2', '2', '3', '3',
+    '3', '3', '3', '3', '3', '3', '3', '3', '3', '3',
+    '3', '3', '3', '3', '4', '4', '4', '4', '4', '4',
+    '4', '4', '4', '4', '4', '4', '4', '4', '4', '4',
+    '5', '5', '5', '5', '5', '5', '5', '5', '5', '5',
+    '5', '5', '5', '5', '5', '5', '6', '6', '6', '6',
+    '6', '6', '6', '6', '6', '6', '6', '6', '6', '6',
+    '6', '6', '7', '7', '7', '7', '7', '7', '7', '7',
+    '7', '7', '7', '7', '7', '7', '7', '7', '8', '8',
+    '8', '8', '8', '8', '8', '8', '8', '8', '8', '8',
+    '8', '8', '8', '8', '9', '9', '9', '9', '9', '9',
+    '9', '9', '9', '9', '9', '9', '9', '9', '9', '9',
+    'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A',
+    'A', 'A', 'A', 'A', 'A', 'A', 'B', 'B', 'B', 'B',
+    'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B', 'B',
+    'B', 'B', 'C', 'C', 'C', 'C', 'C', 'C', 'C', 'C',
+    'C', 'C', 'C', 'C', 'C', 'C', 'C', 'C', 'D', 'D',
+    'D', 'D', 'D', 'D', 'D', 'D', 'D', 'D', 'D', 'D',
+    'D', 'D', 'D', 'D', 'E', 'E', 'E', 'E', 'E', 'E',
+    'E', 'E', 'E', 'E', 'E', 'E', 'E', 'E', 'E', 'E',
+    'F', 'F', 'F', 'F', 'F', 'F', 'F', 'F', 'F', 'F',
+    'F', 'F', 'F', 'F', 'F', 'F'
+};
+static const uint8_t gsHexEncodeMap2[256] = {
+    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+    'A', 'B', 'C', 'D', 'E', 'F', '0', '1', '2', '3',
+    '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D',
+    'E', 'F', '0', '1', '2', '3', '4', '5', '6', '7',
+    '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', '0', '1',
+    '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B',
+    'C', 'D', 'E', 'F', '0', '1', '2', '3', '4', '5',
+    '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F',
+    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+    'A', 'B', 'C', 'D', 'E', 'F', '0', '1', '2', '3',
+    '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D',
+    'E', 'F', '0', '1', '2', '3', '4', '5', '6', '7',
+    '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', '0', '1',
+    '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B',
+    'C', 'D', 'E', 'F', '0', '1', '2', '3', '4', '5',
+    '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F',
+    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+    'A', 'B', 'C', 'D', 'E', 'F', '0', '1', '2', '3',
+    '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D',
+    'E', 'F', '0', '1', '2', '3', '4', '5', '6', '7',
+    '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', '0', '1',
+    '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B',
+    'C', 'D', 'E', 'F', '0', '1', '2', '3', '4', '5',
+    '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F',
+    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+    'A', 'B', 'C', 'D', 'E', 'F'
+};

data/vendor/stringencoders/src/modp_bjavascript_gen.c

@@ -0,0 +1,58 @@
+/* -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*- */
+/* vi: set expandtab shiftwidth=4 tabstop=4: */
+
+#include "arraytoc.h"
+
+static void hexencodemap(void)
+{
+    static const char sHexChars[] = "0123456789ABCDEF";
+    int i;
+    char hexEncode1[256];
+    char hexEncode2[256];
+    for (i = 0; i < 256; ++i) {
+        hexEncode1[i] = sHexChars[i >> 4];
+        hexEncode2[i] = sHexChars[i & 0x0f];
+    }
+
+    char_array_to_c(hexEncode1, sizeof(hexEncode1), "gsHexEncodeMap1");
+    char_array_to_c(hexEncode2, sizeof(hexEncode2), "gsHexEncodeMap2");
+}
+
+static void jsencodemap(void)
+{
+    int i;
+    char jsEncodeMap[256];
+
+    /* set everything to "as is" */
+    for (i = 0; i < 256; ++i) {
+        jsEncodeMap[i] = 0;
+    }
+
+    /* chars that need hex escaping */
+    for (i = 0; i < 32; ++i) {
+        jsEncodeMap[i] = 'A';
+    }
+    for (i = 127; i < 256; ++i) {
+        jsEncodeMap[i] = 'A';
+    }
+
+    /* items that have special escaping */
+    jsEncodeMap[0x08] = 'b';
+    jsEncodeMap[0x09] = 't';
+    jsEncodeMap[0x0a] = 'n';
+    jsEncodeMap[0x0b] = 'v';
+    jsEncodeMap[0x0c] = 'f';
+    jsEncodeMap[0x0d] = 'r';
+    jsEncodeMap[0x5c] = '\\'; /* blackslash gets escaped */
+    jsEncodeMap[0x22] = '"'; /* dquote gets escaped */
+    jsEncodeMap[0x27] = '\''; /* squote gets escaped */
+
+    char_array_to_c(jsEncodeMap, sizeof(jsEncodeMap), "gsJavascriptEncodeMap");
+}
+
+int main(void)
+{
+    jsencodemap();
+    hexencodemap();
+    return 0;
+}