ffi-hydrogen 0.1.0

data/vendor/stringencoders/src/modp_json.c

@@ -0,0 +1,315 @@
+/**
+ * \file
+ * <pre>
+ * modp_json.c High performance JSON encoder/decoder
+ * https://github.com/client9/stringencoders
+ * NOTE THIS IS UNTESTED AND EXPERIMENTAL.
+ *
+ * Copyright &copy; 2006-2016 Nick Galbreath
+ * All rights reserved.
+ * Released under MIT license.  See LICENSE for details.
+ * </PRE>
+ */
+
+#include "modp_json.h"
+#include "modp_json_data.h"
+#include <assert.h>
+
+typedef enum {
+    JSON_NONE,
+    JSON_MAP_OPEN,
+    JSON_MAP_CLOSE,
+    JSON_MAP_KEY,
+    JSON_MAP_VAL,
+    JSON_ARY_OPEN,
+    JSON_ARY_CLOSE,
+    JSON_ARY_VAL,
+} json_state_t;
+
+static size_t modp_bjson_encode_strlen(const char* src, size_t len);
+static size_t modp_bjson_encode(char* dest, const char* src, size_t len);
+
+static void modp_json_add_char(modp_json_ctx* ctx, int c);
+static void modp_json_add_value(modp_json_ctx* ctx);
+static void modp_json_add_false(modp_json_ctx* ctx);
+static void modp_json_add_true(modp_json_ctx* ctx);
+
+static void modp_json_add_char(modp_json_ctx* ctx, int c)
+{
+    if (ctx->dest) {
+        *(ctx->dest + ctx->size) = (char)c;
+    }
+    ctx->size += 1;
+}
+
+static void modp_json_add_value(modp_json_ctx* ctx)
+{
+    int depth = ctx->depth;
+
+    switch (ctx->state[depth]) {
+    case JSON_NONE:
+        /* no-op */
+        break;
+    case JSON_MAP_OPEN:
+        /* NO comma */
+        ctx->state[depth] = JSON_MAP_KEY;
+        break;
+    case JSON_ARY_OPEN:
+        /* NO comma */
+        ctx->state[depth] = JSON_ARY_VAL;
+        break;
+    case JSON_ARY_VAL:
+        modp_json_add_char(ctx, ',');
+        break;
+    case JSON_MAP_KEY:
+        modp_json_add_char(ctx, ':');
+        ctx->state[depth] = JSON_MAP_VAL;
+        break;
+    case JSON_MAP_VAL:
+        modp_json_add_char(ctx, ',');
+        ctx->state[depth] = JSON_MAP_KEY;
+        break;
+    }
+}
+
+void modp_json_init(modp_json_ctx* ctx, char* dest)
+{
+    memset((void*)ctx, 0, sizeof(modp_json_ctx));
+    ctx->dest = dest;
+}
+
+size_t modp_json_end(modp_json_ctx* ctx)
+{
+    if (ctx->dest) {
+        *(ctx->dest + ctx->size) = '\0';
+    }
+    return ctx->size;
+}
+
+void modp_json_map_open(modp_json_ctx* ctx)
+{
+    modp_json_add_value(ctx);
+
+    ctx->depth++;
+    ctx->state[ctx->depth] = JSON_MAP_OPEN;
+
+    modp_json_add_char(ctx, '{');
+}
+
+void modp_json_map_close(modp_json_ctx* ctx)
+{
+    assert(ctx->depth > 0);
+    ctx->depth--;
+    modp_json_add_char(ctx, '}');
+}
+
+void modp_json_ary_open(modp_json_ctx* ctx)
+{
+    modp_json_add_value(ctx);
+    ctx->depth++;
+    ctx->state[ctx->depth] = JSON_ARY_OPEN;
+    modp_json_add_char(ctx, '[');
+}
+
+void modp_json_ary_close(modp_json_ctx* ctx)
+{
+    assert(ctx->depth > 0);
+    ctx->depth--;
+    modp_json_add_char(ctx, ']');
+}
+
+static void modp_json_add_true(modp_json_ctx* ctx)
+{
+    char* wstr;
+    if (ctx->dest) {
+        wstr = ctx->dest + ctx->size;
+        wstr[0] = 't';
+        wstr[1] = 'r';
+        wstr[2] = 'u';
+        wstr[3] = 'e';
+    }
+    ctx->size += 4;
+}
+
+static void modp_json_add_false(modp_json_ctx* ctx)
+{
+    char* wstr;
+
+    if (ctx->dest) {
+        wstr = ctx->dest + ctx->size;
+        wstr[0] = 'f';
+        wstr[1] = 'a';
+        wstr[2] = 'l';
+        wstr[3] = 's';
+        wstr[4] = 'e';
+    }
+    ctx->size += 5;
+}
+
+void modp_json_add_bool(modp_json_ctx* ctx, int val)
+{
+
+    modp_json_add_value(ctx);
+
+    if (val) {
+        modp_json_add_true(ctx);
+    } else {
+        modp_json_add_false(ctx);
+    }
+}
+
+void modp_json_add_null(modp_json_ctx* ctx)
+{
+    char* wstr;
+
+    modp_json_add_value(ctx);
+
+    if (ctx->dest) {
+        wstr = ctx->dest + ctx->size;
+        wstr[0] = 'n';
+        wstr[1] = 'u';
+        wstr[2] = 'l';
+        wstr[3] = 'l';
+    }
+    ctx->size += 4;
+}
+
+void modp_json_add_uint64(modp_json_ctx* ctx, uint64_t uv,
+    int stringonly)
+{
+    size_t r = (uv >= 10000000000000000000ULL) ? 20 : (uv >= 1000000000000000000ULL) ? 19 : (uv >= 100000000000000000ULL) ? 18 : (uv >= 10000000000000000ULL) ? 17 : (uv >= 1000000000000000ULL) ? 16 : (uv >= 100000000000000ULL) ? 15 : (uv >= 10000000000000ULL) ? 14 : (uv >= 1000000000000ULL) ? 13 : (uv >= 100000000000ULL) ? 12 : (uv >= 10000000000ULL) ? 11 : (uv >= 1000000000ULL) ? 10 : (uv >= 100000000ULL) ? 9 : (uv >= 10000000ULL) ? 8 : (uv >= 1000000ULL) ? 7 : (uv >= 100000ULL) ? 6 : (uv >= 10000ULL) ? 5 : (uv >= 1000ULL) ? 4 : (uv >= 100ULL) ? 3 : (uv >= 10ULL) ? 2 : 1ULL;
+
+    if (uv > (1ULL << 53)) {
+        stringonly = 1;
+    }
+
+    modp_json_add_value(ctx);
+
+    if (ctx->dest) {
+        char* wstr = ctx->dest + ctx->size;
+        if (stringonly) {
+            wstr[0] = '"';
+            wstr[r + 1] = '"';
+            wstr += r;
+        } else {
+            wstr += r - 1;
+        }
+
+        /* Conversion. Number is reversed. */
+        do
+            *wstr-- = (char)(48 + (uv % 10));
+        while (uv /= 10);
+    }
+
+    if (stringonly) {
+        r += 2;
+    }
+
+    ctx->size += r;
+}
+
+void modp_json_add_int32(modp_json_ctx* ctx, int v)
+{
+    char* wstr;
+    if (v > 0) {
+        return modp_json_add_uint32(ctx, (uint32_t)v);
+    }
+    uint32_t uv = (uint32_t)(-v);
+    size_t r = (uv >= 1000000000) ? 10 : (uv >= 100000000) ? 9 : (uv >= 10000000) ? 8 : (uv >= 1000000) ? 7 : (uv >= 100000) ? 6 : (uv >= 10000) ? 5 : (uv >= 1000) ? 4 : (uv >= 100) ? 3 : (uv >= 10) ? 2 : 1;
+
+    modp_json_add_value(ctx);
+
+    if (ctx->dest) {
+        wstr = ctx->dest + ctx->size;
+        *wstr = '-';
+        wstr += r;
+        /* Conversion. Number is reversed. */
+        do
+            *wstr-- = (char)(48 + (uv % 10));
+        while (uv /= 10);
+    }
+
+    ctx->size += r + 1; /* +1 for '-' minus sign */
+}
+
+void modp_json_add_uint32(modp_json_ctx* ctx, uint32_t uv)
+{
+    char* wstr;
+    size_t r = (uv >= 1000000000UL) ? 10 : (uv >= 100000000UL) ? 9 : (uv >= 10000000UL) ? 8 : (uv >= 1000000UL) ? 7 : (uv >= 100000UL) ? 6 : (uv >= 10000UL) ? 5 : (uv >= 1000UL) ? 4 : (uv >= 100UL) ? 3 : (uv >= 10UL) ? 2 : 1UL;
+
+    modp_json_add_value(ctx);
+
+    if (ctx->dest) {
+        wstr = ctx->dest + ctx->size;
+        wstr += r - 1;
+        do
+            *wstr-- = (char)(48 + (uv % 10));
+        while (uv /= 10);
+    }
+
+    ctx->size += r;
+}
+
+void modp_json_add_cstring(modp_json_ctx* ctx, const char* src)
+{
+    return modp_json_add_string(ctx, src, strlen(src));
+}
+
+void modp_json_add_string(modp_json_ctx* ctx, const char* src, size_t len)
+{
+    modp_json_add_value(ctx);
+
+    if (ctx->dest) {
+        ctx->size += modp_bjson_encode(ctx->dest + ctx->size, src, len);
+    } else {
+        ctx->size += modp_bjson_encode_strlen(src, len);
+    }
+}
+
+static size_t modp_bjson_encode(char* dest, const char* src, size_t len)
+{
+    static const char* hexchar = "0123456789ABCDEF";
+    const char* deststart = (const char*)dest;
+    const uint8_t* s = (const uint8_t*)src;
+    const uint8_t* srcend = s + len;
+    uint8_t x;
+    uint8_t val;
+
+    *dest++ = '"';
+
+    while (s < srcend) {
+        x = *s++;
+        val = gsJSONEncodeMap[x];
+        if (val == 'a') {
+            /* a for ascii, as-is */
+            *dest++ = (char)x;
+        } else if (val == 'u') {
+            /* u for unicode, 6 byte escape sequence */
+            dest[0] = '\\';
+            dest[1] = 'u';
+            dest[2] = '0';
+            dest[3] = '0';
+            dest[4] = hexchar[x >> 4];
+            dest[5] = hexchar[x & 0x0F];
+            dest += 6;
+        } else {
+            /* 2 byte escape sequence */
+            dest[0] = '\\';
+            dest[1] = (char)val;
+            dest += 2;
+        }
+    }
+    *dest++ = '"';
+    return (size_t)(dest - deststart);
+}
+
+static size_t modp_bjson_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 = 2; /* for start and end quotes */
+    while (s < srcend) {
+        count += (gsJSONEncodeLenMap[*s++]);
+    }
+    return count;
+}

data/vendor/stringencoders/src/modp_json.h

@@ -0,0 +1,103 @@
+/**
+ * \file modp_json.h
+ * \brief ad-hoc json generator
+ *
+ * Used to serialize data structures.
+ *
+ * There is no decoder.
+ */
+
+/*
+ * <PRE>
+ * High Performance c-string to javascript-string encoder
+ *
+ * Copyright &copy; 2014-2016 Nick Galbreath
+ * All rights reserved.
+ *
+ * https://github.com/client9/stringencoders
+ *
+ * Released under MIT license.  See LICENSE for details.
+ * </PRE>
+ */
+
+#ifndef COM_MODP_STRINGENCODERS_BJSON
+#define COM_MODP_STRINGENCODERS_BJSON
+
+#ifdef __cplusplus
+#ifndef MODP_C_BEGIN_DECLS
+#define MODP_C_BEGIN_DECLS extern "C" {
+#define MODP_C_END_DECLS }
+#endif
+#else
+#define MODP_C_BEGIN_DECLS
+#define MODP_C_END_DECLS
+#endif
+
+MODP_C_BEGIN_DECLS
+
+#ifndef JSON_MAX_DEPTH
+#define JSON_MAX_DEPTH 10
+#endif
+
+/* pull in size_t */
+#include <stdint.h>
+#include <string.h>
+
+typedef struct {
+    int depth;
+    int state[JSON_MAX_DEPTH];
+    size_t size;
+    char* dest;
+} modp_json_ctx;
+
+void modp_json_init(modp_json_ctx* ctx, char* dest);
+size_t modp_json_end(modp_json_ctx* ctx);
+void modp_json_map_open(modp_json_ctx* ctx);
+void modp_json_map_close(modp_json_ctx* ctx);
+void modp_json_ary_open(modp_json_ctx* ctx);
+void modp_json_ary_close(modp_json_ctx* ctx);
+
+/*
+ *
+ * Note: to add a 'null string' explicitly use 'add_null' and do NOT
+ * pass in a null pointer here.
+ */
+void modp_json_add_string(modp_json_ctx* ctx, const char*, size_t);
+
+void modp_json_add_cstring(modp_json_ctx* ctx, const char*);
+
+/*
+ * Sets a json 'false' value if val = 0, other wise sets a 'true' value
+ */
+void modp_json_add_bool(modp_json_ctx* ctx, int val);
+
+void modp_json_add_double(modp_json_ctx* ctx, double d);
+
+void modp_json_add_int32(modp_json_ctx* ctx, int val);
+
+void modp_json_add_uint32(modp_json_ctx* ctx, uint32_t val);
+
+/**
+ * JSON/Javascript only supports a single number type represented by a
+ * 64-bit IEEE floating-point value.  This means JSON can not exactly
+ * represent a full 64-bit integer since the mantissa of a double is
+ * only 53 bits.  If the input integer needs more than 53 bits then
+ * the value is stored as string "1234567899329342" instead of a
+ * raw/naked numeric value.  If you wish to anyways represent 64-bit
+ * integers as a string, use stringonly=1.  If you wish to never
+ * casting to a string, use add_uint32 or add_int32 which can be
+ * expressed directly or consider loosing precession and cast to a
+ * double value.
+ *
+ */
+void modp_json_add_uint64(modp_json_ctx* ctx, uint64_t val,
+    int stringonly);
+
+/*
+ * explicitly add a null type
+ */
+void modp_json_add_null(modp_json_ctx* ctx);
+
+MODP_C_END_DECLS
+
+#endif /* modp_bjson */

data/vendor/stringencoders/src/modp_json_data.h

@@ -0,0 +1,57 @@
+static const uint8_t gsJSONEncodeMap[256] = {
+    'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'b', 't',
+    'n', 'u', 'f', 'r', 'u', 'u', 'u', 'u', 'u', 'u',
+    'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u',
+    'u', 'u', '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', 'u', 'u',
+    'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u',
+    'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u',
+    'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u',
+    'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u',
+    'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u',
+    'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u',
+    'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u',
+    'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u',
+    'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u',
+    'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u',
+    'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u',
+    'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u',
+    'u', 'u', 'u', 'u', 'u', 'u',
+};
+
+static const size_t gsJSONEncodeLenMap[256] = {
+    6, 6, 6, 6, 6, 6, 6, 6, 2, 2,
+    2, 6, 2, 2, 6, 6, 6, 6, 6, 6,
+    6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+    6, 6, 1, 1, 2, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 2, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 6, 6,
+    6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+    6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+    6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+    6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+    6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+    6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+    6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+    6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+    6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+    6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+    6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+    6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
+    6, 6, 6, 6, 6, 6,
+};

data/vendor/stringencoders/src/modp_json_gen.py

@@ -0,0 +1,60 @@
+#!/usr/bin/env python
+
+def intarray_to_c(ary, name):
+    parts = []
+    parts.append("static const size_t {0}[{1}] = {{".format(name,len(ary)))
+    count = 0
+    for val in ary:
+        if (count % 10 == 0):
+            parts.append("\n  ")
+        parts.append("{0}, ".format(val))
+        count += 1
+    parts.append("\n};\n")
+    return ''.join(parts)
+
+def chararray_to_c(ary, name):
+    parts = []
+    parts.append("static const uint8_t {0}[{1}] = {{".format(name,
+                                                             len(ary)))
+    count = 0;
+    for val in ary:
+        if (count % 10 == 0):
+            parts.append("\n ")
+        parts.append("{0:>6}".format("'" + val + "',"))
+        count += 1
+
+    parts.append("\n};\n")
+    return ''.join(parts)
+
+def json_encodelen_map():
+    lenmap = [ 6 for i in range(256) ]
+    for i in range(32,128):
+        lenmap[i] = 1
+    for i in [0x08, 0x09, 0x0a,  0x0c, 0x0d, 0x5c, 0x22]:
+        lenmap[i] = 2
+    return lenmap
+
+def json_encode_map():
+    encodemap = [ 'u' for i in range(256) ]
+
+    # things to quad-hex encode  \u00XY
+    for i in range(32,128):
+        encodemap[i] = 'a';
+
+    # special escapes
+    encodemap[0x08] = 'b'
+    encodemap[0x09] = 't'
+    encodemap[0x0a] = 'n'
+    encodemap[0x0c] = 'f'
+    encodemap[0x0d] = 'r'
+    encodemap[0x5c] = "\\\\"
+    encodemap[0x22] = "\""
+
+    return encodemap
+
+if __name__ == '__main__':
+
+    with open('modp_json_data.h', 'w') as fd:
+        fd.write(chararray_to_c(json_encode_map(), "gsJSONEncodeMap"))
+        fd.write("\n")
+        fd.write(intarray_to_c(json_encodelen_map(), "gsJSONEncodeLenMap"))

data/vendor/stringencoders/src/modp_mainpage.h

@@ -0,0 +1,120 @@
+/**
+ * \mainpage
+ *
+ * The modp_b family of encoders/decoders.
+ *
+ * Most have a similar interface:
+ *  - modp_bXXX_encode(char* dest, char* src, int len) -- encodes src, and puts the result in dest.  The caller allocates dest.  It returns the strlen of the output.
+ *  - modp_bXXX_encode_len(int len) -- returns the amount of memory needed to be allocated BEFORE calling _encode.
+ *  - modp_bXXX_encode_strlen(int len) -- returns the strlen of the encoded output (but without doing the encode operation)
+ *  - modp_bXXX_decode(char* dest, char* src, int len) -- decodes src and puts result in dest.  Returns the number of bytes written.
+ *  - modp_bXXX_decode_len(int len) -- the amount of memory needed to decode.
+ *
+ * The header files all include a sample C++ std::string wrapper.
+ *
+ * In addition:
+ * - modp_numtoa.h defines fast integer and float  types to char buffer converts.
+ * - modp_ascii.h defines fast toupper, tolower transformations.
+ *
+ * \section modp_b64
+ *
+ * Converts 3 bytes into 4 characters, for 1.33 expansion ratio. This
+ * version is ridiculously fast -- on some platforms the decode
+ * operation is 4x faster than a standard implementation.
+ *
+ * See modp_b64.h for details
+ *
+ * \section modp_b64w
+ *
+ * Does the same type of transformation as modp_b64 but uses a
+ * slightly different alphabet to make it "safe" to use inside a URL.
+ * The mapping is: "/" to "_", * "+" to "-", * "=" to "."  If you are
+ * intergating with another base64 encoder, you may need to change
+ * this.
+ *
+ * See modp_b64w.h for details.
+ *
+ *
+ * \section modp_b16
+ *
+ * This is the standard "binary to ascii" encoding that convert 1 byte
+ * into two chars (0-9, a-f).  It's actually slower than base64 so
+ * there is not reason to use this except for legacy applications.
+ * (how can this be?  Because on decode we have to read 4 bytes to get
+ * 2.  and in base64 we read 4 bytes to get 3, so base64's loop is
+ * shorter).
+ *
+ * See modp_b16.h for details
+ *
+ * \section modp_b85
+ *
+ * Base 85 is the "most dense ascii encoding" possible, converting 4
+ * bytes into 5 chars (1.2).  The output is 11% smaller than base 64
+ * (1.33/1.2), but unfortunately, it's about twice as slow as base-64
+ * encoding since true division has to be used (instead of raw bit
+ * operations).
+ *
+ * See modp_b85.h for details
+ *
+ * \section mod_b2
+ *
+ * Converts the given string to a base 2 or binary encoding (all
+ * 1s and 0s).  For useful for debugging.
+ *
+ * See modp_b2.h for details
+ *
+ * \section modp_burl
+ *
+ * This performs url-encoding and url-decoding.  While not a true base
+ * converted like the others, it does use an optimized base-16
+ * converter for the encoded "%XY" data.  This has an alternate
+ * encoder that provides a minimal encoding, modp_burl_min_encode.
+ *
+ * See modp_burl.h for details
+ *
+ * \section modp_bjavascript
+ *
+ * Converts a raw c-string into something that can be enbedded into
+ * javascript.  This might be useful for server-generated dynamic
+ * javascript.  There is no decode function provided.  This is only
+ * use when generating raw "text/javascript" files.  It is <b>NOT</b>
+ * safe to make javascript that will ultimately be embedded inside
+ * HTML via script tags.
+ *
+ * See modp_bjavascript.h for details
+ *
+ * \section modp_xml
+ *
+ * An experimental XML decoder.
+ *
+ * See modp_xml.h for details
+ *
+ * \section modp_numtoa
+ *
+ * The functions modp_itoa, modp_uitoa, modp_dtoa converts signed integers,
+ * unsigned integers, and 'double' type conversion to char buffer (string).
+ * The advantages over sprintf/snprintf are
+ *  - core dump proof
+ *  - have a fixed maximum size (e.g. try printf("%f", 2.0e100) for example)
+ *  - 5-22x faster!
+ *
+ * See modp_numtoa.h for details
+ *
+ * \section modp_ascii
+ *
+ * modp_toupper and modp_tolower upper or lower case a string using
+ * the standard C locale (i.e. 7-bit ascii).  These are 2-22x faster
+ * than using standard ctype functions.  Also include is "toprint"
+ * which replaces "unprintable" characters with a "?".
+ *
+ * See modp_ascii.h for details
+ *
+ * \section modp_qsiter
+ *
+ * URL Query string key-value pair iterator.  Uses no heap, makes no
+ * copy, makes no modification of input.  Think of this as a
+ * super-strtok_r.
+ *
+ * See modp_qsiter.h for details
+ *
+ */