ffi-hydrogen 0.1.0

data/vendor/stringencoders/src/modp_b16.h

@@ -0,0 +1,148 @@
+/**
+ * \file modp_b16.h
+ * \brief High performance encoding and decoding of base 16
+ *        (hexadecimal 0-9, A-F)
+ *
+ */
+
+/*
+ * <PRE>
+ * MODP_B16 -- High performance base16 (hex) 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>
+ *
+ */
+
+#ifndef COM_MODP_STRINGENCODERS_B16
+#define COM_MODP_STRINGENCODERS_B16
+
+#include "extern_c_begin.h"
+#include "modp_stdint.h"
+
+/**
+ * encode a string into hex (base 16, 0-9,a-f)
+ *
+ * \param[out] dest the output string.  Must have at least modp_b16_encode_len
+ *   bytes allocated
+ * \param[in] str the input string
+ * \param[in] len of the input string
+ * \return strlen of dest
+ */
+size_t modp_b16_encode(char* dest, const char* str, size_t len);
+
+/**
+ * Decode a hex-encoded string.
+ *
+ * \param[out] dest output, must have at least modp_b16_decode_len bytes allocated,
+ *   input must be a multiple of 2, and be different than the source buffer.
+ * \param[in] src the hex encoded source
+ * \param[in] len the length of the source
+ * \return the length of the the output, or -1 if an error
+ */
+size_t modp_b16_decode(char* dest, const char* src, size_t len);
+
+/**
+ * Encode length.
+ * 2 x the length of A, round up the next high multiple of 2
+ * +1 for null byte added
+ */
+#define modp_b16_encode_len(A) (2 * A + 1)
+
+/**
+ * Encode string length
+ */
+#define modp_b16_encode_strlen(A) (2 * A)
+
+/**
+ * Decode string length
+ */
+#define modp_b16_decode_len(A) ((A + 1) / 2)
+
+#include "extern_c_end.h"
+
+#ifdef __cplusplus
+#include <cstring>
+#include <string>
+
+namespace modp {
+
+inline std::string b16_encode(const char* s, size_t len)
+{
+    std::string x(modp_b16_encode_len(len), '\0');
+    size_t d = modp_b16_encode(const_cast<char*>(x.data()), s, len);
+    if (d == (size_t)-1) {
+        x.clear();
+    } else {
+        x.erase(d, std::string::npos);
+    }
+    return x;
+}
+
+inline std::string b16_encode(const char* s)
+{
+    return b16_encode(s, strlen(s));
+}
+
+inline std::string b16_encode(const std::string& s)
+{
+    return b16_encode(s.data(), s.size());
+}
+
+/**
+     * hex encode a string (self-modified)
+     * \param[in,out] s the input string to be encoded
+     * \return a reference to the input string.
+     */
+inline std::string& b16_encode(std::string& s)
+{
+    std::string x(b16_encode(s.data(), s.size()));
+    s.swap(x);
+    return s;
+}
+
+inline std::string b16_decode(const char* s, size_t len)
+{
+    std::string x(len / 2 + 1, '\0');
+    size_t d = modp_b16_decode(const_cast<char*>(x.data()), s, len);
+    if (d == (size_t)-1) {
+        x.clear();
+    } else {
+        x.erase(d, std::string::npos);
+    }
+    return x;
+}
+
+inline std::string b16_decode(const char* s)
+{
+    return b16_decode(s, strlen(s));
+}
+
+/**
+     * Decode a hex-encoded string.  On error, input string is cleared.
+     * This function does not allocate memory.
+     *
+     * \param[in,out] s the input string
+     * \return a reference to the input string
+     */
+inline std::string& b16_decode(std::string& s)
+{
+    std::string x(b16_decode(s.data(), s.size()));
+    s.swap(x);
+    return s;
+}
+
+inline std::string b16_decode(const std::string& s)
+{
+    return b16_decode(s.data(), s.size());
+}
+
+} /* namespace modp */
+
+#endif /* ifdef __cplusplus */
+
+#endif /* ifndef modp_b16 */

data/vendor/stringencoders/src/modp_b16_data.h

@@ -0,0 +1,104 @@
+static const uint8_t gsHexEncodeC1[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 gsHexEncodeC2[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'
+};
+static const uint32_t gsHexDecodeMap[256] = {
+    256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256,
+    256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256,
+    256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256,
+    256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256,
+    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 256, 256,
+    256, 256, 256, 256, 256, 10, 11, 12, 13, 14, 15, 256,
+    256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256,
+    256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256,
+    256, 10, 11, 12, 13, 14, 15, 256, 256, 256, 256, 256,
+    256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256,
+    256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256,
+    256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256,
+    256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256,
+    256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256,
+    256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256,
+    256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256,
+    256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256,
+    256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256,
+    256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256,
+    256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256,
+    256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256,
+    256, 256, 256, 256
+};
+static const uint32_t gsHexDecodeD2[256] = {
+    256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256,
+    256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256,
+    256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256,
+    256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256,
+    0, 16, 32, 48, 64, 80, 96, 112, 128, 144, 256, 256,
+    256, 256, 256, 256, 256, 160, 176, 192, 208, 224, 240, 256,
+    256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256,
+    256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256,
+    256, 160, 176, 192, 208, 224, 240, 256, 256, 256, 256, 256,
+    256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256,
+    256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256,
+    256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256,
+    256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256,
+    256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256,
+    256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256,
+    256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256,
+    256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256,
+    256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256,
+    256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256,
+    256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256,
+    256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256, 256,
+    256, 256, 256, 256
+};

data/vendor/stringencoders/src/modp_b16_gen.c

@@ -0,0 +1,65 @@
+#include "arraytoc.h"
+#include <stdio.h>
+
+static void hexencodemap_char(void)
+{
+    static const uint8_t sHexChars[] = "0123456789ABCDEF";
+    int i;
+    uint8_t e1[256];
+    uint8_t e2[256];
+
+    for (i = 0; i < 256; ++i) {
+        e1[i] = 0;
+        e2[i] = 0;
+    }
+
+    for (i = 0; i < 256; ++i) {
+        e1[i] = sHexChars[i >> 4];
+        e2[i] = sHexChars[i & 0x0f];
+    }
+
+    char_array_to_c((char*)e1, sizeof(e1), "gsHexEncodeC1");
+    char_array_to_c((char*)e2, sizeof(e2), "gsHexEncodeC2");
+}
+
+/*  exact same thing as one used on urlencode */
+static void hexdecodemap(void)
+{
+    uint32_t i;
+    uint32_t map1[256];
+    uint32_t map2[256];
+    for (i = 0; i < 256; ++i) {
+        map1[i] = 256;
+        map2[i] = 256;
+    }
+
+    /* digits */
+    for (i = '0'; i <= '9'; ++i) {
+        map1[i] = i - '0';
+        map2[i] = map1[i] << 4;
+    }
+
+    /* upper */
+    for (i = 'A'; i <= 'F'; ++i) {
+        map1[i] = i - 'A' + 10;
+        map2[i] = map1[i] << 4;
+    }
+
+    /* lower */
+    for (i = 'a'; i <= 'f'; ++i) {
+        map1[i] = i - 'a' + 10;
+        map2[i] = map1[i] << 4;
+    }
+
+    uint32_array_to_c(map1, sizeof(map1) / sizeof(uint32_t), "gsHexDecodeMap");
+
+    uint32_array_to_c(map2, sizeof(map2) / sizeof(uint32_t), "gsHexDecodeD2");
+}
+
+int main(void)
+{
+    hexencodemap_char();
+
+    hexdecodemap();
+    return 0;
+}

data/vendor/stringencoders/src/modp_b2.c

@@ -0,0 +1,69 @@
+/* -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*- */
+/* vi: set expandtab shiftwidth=4 tabstop=4: */
+
+/**
+ * \file modp_b2.c
+ * <PRE>
+ * MODP_B2 - Ascii Binary string encode/decode
+ * https://github.com/client9/stringencoders
+ *
+ * Copyright &copy; 2005-2016  Nick Galbreath
+ * All rights reserved.
+ *
+ * Released under MIT license. See LICENSE for details.
+ *
+ */
+#include "modp_b2.h"
+#include "config.h"
+#include "modp_b2_data.h"
+#include "modp_stdint.h"
+#include <string.h>
+
+size_t modp_b2_encode(char* dest, const char* str, size_t len)
+{
+    const uint8_t* orig = (const uint8_t*)str;
+#if 0
+    /* THIS IS A STANDARD VERSION */
+    static const uint8_t gsBinaryChars[] = "01";
+    int i,j;
+    for (i = 0; i < len; ++i) {
+        for (j = 0; j <= 7; ++j) {
+            *dest++ = gsBinaryChars[(orig[i] >> (7-j)) & 1];
+        }
+    }
+#else
+    /* THIS IS 10X FASTER */
+    size_t i;
+    for (i = 0; i < len; ++i) {
+        memcpy((void*)dest, modp_b2_encodemap[orig[i]], (size_t)8);
+        dest += 8;
+    }
+#endif
+    *dest = '\0';
+    return len * 8;
+}
+
+size_t modp_b2_decode(char* dest, const char* str, size_t len)
+{
+    char d;
+    size_t i;
+    int j;
+    const size_t buckets = len / 8;
+    const size_t leftover = len % 8;
+    if (leftover != 0) {
+        return (size_t)-1;
+    }
+
+    for (i = 0; i < buckets; ++i) {
+        d = 0;
+        for (j = 0; j <= 7; ++j) {
+            char c = *str++;
+            if (c == '1') {
+                d ^= (char)(1 << (7 - j));
+            }
+        }
+        *dest++ = d;
+    }
+
+    return buckets;
+}

data/vendor/stringencoders/src/modp_b2.h

@@ -0,0 +1,130 @@
+/**
+ * \file modp_b2.h
+ * \brief Encode and decode of base 2 strings ("00001110" to 0x43)
+ *
+ */
+
+/*
+ * <PRE>
+ * MODP_B2 -- Base 2 (binary) encode/decoder
+ * https://github.com/client9/stringencoders
+ *
+ * Copyright &copy; 2007-2016, Nick Galbreath
+ * All rights reserved.
+ *
+ * Released under MIT license.  See LICENSE for details.
+ * </PRE>
+ *
+ */
+
+#ifndef COM_MODP_STRINGENCODERS_B2
+#define COM_MODP_STRINGENCODERS_B2
+
+#include "extern_c_begin.h"
+#include "modp_stdint.h"
+
+/**
+ * encode a string into binary (base 2, '0' and '1')
+ *
+ * \param[out] dest the output string.  Must have at least modp_b16_encode_len
+ *   bytes allocated
+ * \param[in] str the input string
+ * \param[in] len of the input string
+ * \return strlen of dest
+ */
+size_t modp_b2_encode(char* dest, const char* str, size_t len);
+
+/**
+ * Decode a hex-encoded string.
+ *
+ * \param[out] dest output, must have at least modp_b16_decode_len bytes allocated,
+ *   input must be a multiple of 2, and be different than the source buffer.
+ * \param[in] src the hex encoded source
+ * \param[in] len the length of the source
+ * \return the length of the the output, or 0 if an error (input size not a multiple of 8)
+ */
+size_t modp_b2_decode(char* dest, const char* src, size_t len);
+
+/**
+ * Encode length.
+ * 2 x the length of A, round up the next high multiple of 2
+ * +1 for null byte added
+ */
+#define modp_b2_encode_len(A) (8 * A + 1)
+
+/**
+ * Encode string length
+ */
+#define modp_b2_encode_strlen(A) (8 * A)
+
+/**
+ * Decode string length
+ */
+#define modp_b2_decode_len(A) ((A + 1) / 8)
+
+#include "extern_c_end.h"
+
+#ifdef __cplusplus
+#include <string>
+
+namespace modp {
+/**
+     * hex encode a string (self-modified)
+     * \param[in,out] s the input string to be encoded
+     * \return a reference to the input string.
+     */
+inline std::string& b2_encode(std::string& s)
+{
+    std::string x(modp_b2_encode_len(s.size()), '\0');
+    size_t d = modp_b2_encode(const_cast<char*>(x.data()), s.data(), s.size());
+    if (d == (size_t)-1) {
+        x.clear();
+    } else {
+        x.erase(d, std::string::npos);
+    }
+    s.swap(x);
+    return s;
+}
+
+/**
+     *
+     * \param[in] s original data source
+     * \return new b2 encoding string
+     */
+inline std::string b2_encode(const std::string& s)
+{
+    std::string str(s);
+    b2_encode(str);
+    return str;
+}
+
+/**
+     * Decode a hex-encoded string.  On error, input string is cleared.
+     * This function does not allocate memory.
+     *
+     * \param[in,out] s the input string
+     * \return a reference to the input string
+     */
+inline std::string& b2_decode(std::string& s)
+{
+    size_t d = modp_b2_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 b2_decode(const std::string& s)
+{
+    std::string x(s);
+    b2_decode(x);
+    return x;
+}
+
+} /* namespace modp */
+
+#endif /* cplusplus */
+
+#endif /* ifndef modp_b2 */

data/vendor/stringencoders/src/modp_b2_data.h

@@ -0,0 +1,44 @@
+static const char* modp_b2_encodemap[] = {
+"00000000", "00000001", "00000010", "00000011", "00000100", "00000101", 
+"00000110", "00000111", "00001000", "00001001", "00001010", "00001011", 
+"00001100", "00001101", "00001110", "00001111", "00010000", "00010001", 
+"00010010", "00010011", "00010100", "00010101", "00010110", "00010111", 
+"00011000", "00011001", "00011010", "00011011", "00011100", "00011101", 
+"00011110", "00011111", "00100000", "00100001", "00100010", "00100011", 
+"00100100", "00100101", "00100110", "00100111", "00101000", "00101001", 
+"00101010", "00101011", "00101100", "00101101", "00101110", "00101111", 
+"00110000", "00110001", "00110010", "00110011", "00110100", "00110101", 
+"00110110", "00110111", "00111000", "00111001", "00111010", "00111011", 
+"00111100", "00111101", "00111110", "00111111", "01000000", "01000001", 
+"01000010", "01000011", "01000100", "01000101", "01000110", "01000111", 
+"01001000", "01001001", "01001010", "01001011", "01001100", "01001101", 
+"01001110", "01001111", "01010000", "01010001", "01010010", "01010011", 
+"01010100", "01010101", "01010110", "01010111", "01011000", "01011001", 
+"01011010", "01011011", "01011100", "01011101", "01011110", "01011111", 
+"01100000", "01100001", "01100010", "01100011", "01100100", "01100101", 
+"01100110", "01100111", "01101000", "01101001", "01101010", "01101011", 
+"01101100", "01101101", "01101110", "01101111", "01110000", "01110001", 
+"01110010", "01110011", "01110100", "01110101", "01110110", "01110111", 
+"01111000", "01111001", "01111010", "01111011", "01111100", "01111101", 
+"01111110", "01111111", "10000000", "10000001", "10000010", "10000011", 
+"10000100", "10000101", "10000110", "10000111", "10001000", "10001001", 
+"10001010", "10001011", "10001100", "10001101", "10001110", "10001111", 
+"10010000", "10010001", "10010010", "10010011", "10010100", "10010101", 
+"10010110", "10010111", "10011000", "10011001", "10011010", "10011011", 
+"10011100", "10011101", "10011110", "10011111", "10100000", "10100001", 
+"10100010", "10100011", "10100100", "10100101", "10100110", "10100111", 
+"10101000", "10101001", "10101010", "10101011", "10101100", "10101101", 
+"10101110", "10101111", "10110000", "10110001", "10110010", "10110011", 
+"10110100", "10110101", "10110110", "10110111", "10111000", "10111001", 
+"10111010", "10111011", "10111100", "10111101", "10111110", "10111111", 
+"11000000", "11000001", "11000010", "11000011", "11000100", "11000101", 
+"11000110", "11000111", "11001000", "11001001", "11001010", "11001011", 
+"11001100", "11001101", "11001110", "11001111", "11010000", "11010001", 
+"11010010", "11010011", "11010100", "11010101", "11010110", "11010111", 
+"11011000", "11011001", "11011010", "11011011", "11011100", "11011101", 
+"11011110", "11011111", "11100000", "11100001", "11100010", "11100011", 
+"11100100", "11100101", "11100110", "11100111", "11101000", "11101001", 
+"11101010", "11101011", "11101100", "11101101", "11101110", "11101111", 
+"11110000", "11110001", "11110010", "11110011", "11110100", "11110101", 
+"11110110", "11110111", "11111000", "11111001", "11111010", "11111011", 
+"11111100", "11111101", "11111110", "11111111"};

data/vendor/stringencoders/src/modp_b2_gen.c

@@ -0,0 +1,36 @@
+#include "arraytoc.h"
+#include <stdio.h>
+
+/** \brief make map of a byte to a string of 8 chars
+ *
+ *
+ */
+static void binary_encodemap(void)
+{
+    static const uint8_t sBinaryChars[] = "01";
+    int i, j;
+    uint8_t buf[9];
+
+    printf("%s", "static const char* modp_b2_encodemap[] = {\n");
+    buf[8] = 0;
+    for (i = 0; i < 256; ++i) {
+        for (j = 0; j < 8; ++j) {
+            buf[j] = sBinaryChars[(i >> (7 - j)) & 1];
+        }
+        printf("\"%s\"", buf);
+        if (i != 255) {
+            printf("%s", ", ");
+        }
+        if ((i + 1) % 6 == 0) {
+            printf("%s", "\n");
+        }
+    }
+    printf("%s", "};\n");
+}
+
+int main(void)
+{
+    binary_encodemap();
+
+    return 0;
+}