ffi-hydrogen 0.1.0

data/vendor/stringencoders/src/modp_numtoa.c

@@ -0,0 +1,350 @@
+#include "modp_numtoa.h"
+
+#include <math.h>
+#include <stdio.h>
+
+#include "modp_stdint.h"
+
+/*
+ * other interesting references on num to string convesion
+ * http://www.jb.man.ac.uk/~slowe/cpp/itoa.html
+ * and http://www.ddj.com/dept/cpp/184401596?pgno=6
+ *
+ * Version 19-Nov-2007
+ * Fixed round-to-even rules to match printf
+ *   thanks to Johannes Otepka
+ * Version 22-Sep-2016
+ *  Fixed rounding error with decimals ending in 5 and low precision
+ */
+
+/**
+ * Powers of 10
+ * 10^0 to 10^9
+ */
+static const double powers_of_10[] = { 1, 10, 100, 1000, 10000, 100000, 1000000,
+    10000000, 100000000, 1000000000 };
+
+static void strreverse(char* begin, char* end)
+{
+    char aux;
+    while (end > begin)
+        aux = *end, *end-- = *begin, *begin++ = aux;
+}
+
+size_t modp_itoa10(int32_t value, char* str)
+{
+    char* wstr = str;
+    /* Take care of sign */
+    uint32_t uvalue = (value < 0) ? (uint32_t)(-value) : (uint32_t)(value);
+    /* Conversion. Number is reversed. */
+    do
+        *wstr++ = (char)(48 + (uvalue % 10));
+    while (uvalue /= 10);
+    if (value < 0)
+        *wstr++ = '-';
+    *wstr = '\0';
+
+    /* Reverse string */
+    strreverse(str, wstr - 1);
+    return (size_t)(wstr - str);
+}
+
+size_t modp_uitoa10(uint32_t value, char* str)
+{
+    char* wstr = str;
+    /* Conversion. Number is reversed. */
+    do
+        *wstr++ = (char)(48 + (value % 10));
+    while (value /= 10);
+    *wstr = '\0';
+    /* Reverse string */
+    strreverse(str, wstr - 1);
+    return (size_t)(wstr - str);
+}
+
+size_t modp_litoa10(int64_t value, char* str)
+{
+    char* wstr = str;
+    uint64_t uvalue = (value < 0) ? (uint64_t)(-value) : (uint64_t)(value);
+
+    /* Conversion. Number is reversed. */
+    do
+        *wstr++ = (char)(48 + (uvalue % 10));
+    while (uvalue /= 10);
+    if (value < 0)
+        *wstr++ = '-';
+    *wstr = '\0';
+
+    /* Reverse string */
+    strreverse(str, wstr - 1);
+    return (size_t)(wstr - str);
+}
+
+size_t modp_ulitoa10(uint64_t value, char* str)
+{
+    char* wstr = str;
+    /* Conversion. Number is reversed. */
+    do
+        *wstr++ = (char)(48 + (value % 10));
+    while (value /= 10);
+    *wstr = '\0';
+    /* Reverse string */
+    strreverse(str, wstr - 1);
+    return (size_t)(wstr - str);
+}
+
+size_t modp_dtoa(double value, char* str, int prec)
+{
+    /* Hacky test for NaN
+	 * under -fast-math this won't work, but then you also won't
+	 * have correct nan values anyways.  The alternative is
+	 * to link with libmath (bad) or hack IEEE double bits (bad)
+	 */
+    if (!(value == value)) {
+        str[0] = 'n';
+        str[1] = 'a';
+        str[2] = 'n';
+        str[3] = '\0';
+        return (size_t)3;
+    }
+    /* if input is larger than thres_max, revert to exponential */
+    const double thres_max = (double)(0x7FFFFFFF);
+
+    double diff = 0.0;
+    char* wstr = str;
+
+    if (prec < 0) {
+        prec = 0;
+    } else if (prec > 9) {
+        /* precision of >= 10 can lead to overflow errors */
+        prec = 9;
+    }
+
+    /* we'll work in positive values and deal with the
+	   negative sign issue later */
+    int neg = 0;
+    if (value < 0) {
+        neg = 1;
+        value = -value;
+    }
+
+    // given 0.05, prec=1
+    // whole = 0
+    // tmp = (0.05)* 10 = 0.5
+    // frac = 0
+    // diff = tmp -frac == 0.5 - 0.0 = 0.5
+    //
+    int whole = (int)value;
+    double tmp = (value - whole) * powers_of_10[prec];
+    uint32_t frac = (uint32_t)(tmp);
+    diff = tmp - frac;
+
+    if (diff > 0.5) {
+        ++frac;
+        /* handle rollover, e.g.  case 0.99 with prec 1 is 1.0  */
+        if (frac >= powers_of_10[prec]) {
+            frac = 0;
+            ++whole;
+        }
+    } else if (diff == 0.5 && prec > 0 && (frac & 1)) {
+        /* if halfway, round up if odd, OR
+		   if last digit is 0.  That last part is strange */
+        ++frac;
+        if (frac >= powers_of_10[prec]) {
+            frac = 0;
+            ++whole;
+        }
+    } else if (diff == 0.5 && prec == 0 && (whole & 1)) {
+        ++frac;
+        if (frac >= powers_of_10[prec]) {
+            frac = 0;
+            ++whole;
+        }
+    }
+
+    /* for very large numbers switch back to native sprintf for exponentials.
+	   anyone want to write code to replace this? */
+    /*
+	   normal printf behavior is to print EVERY whole number digit
+	   which can be 100s of characters overflowing your buffers == bad
+	   */
+    if (value > thres_max) {
+        sprintf(str, "%e", neg ? -value : value);
+        return strlen(str);
+    }
+
+    int count = prec;
+    while (count > 0) {
+        --count;
+        *wstr++ = (char)(48 + (frac % 10));
+        frac /= 10;
+    }
+    if (frac > 0) {
+        ++whole;
+    }
+
+    /* add decimal */
+    if (prec > 0) {
+        *wstr++ = '.';
+    }
+
+    /* do whole part
+	 * Take care of sign conversion
+	 * Number is reversed.
+	 */
+    do
+        *wstr++ = (char)(48 + (whole % 10));
+    while (whole /= 10);
+    if (neg) {
+        *wstr++ = '-';
+    }
+    *wstr = '\0';
+    strreverse(str, wstr - 1);
+    return (size_t)(wstr - str);
+}
+
+/* This is near identical to modp_dtoa above
+ *   The differnce is noted below
+ */
+size_t modp_dtoa2(double value, char* str, int prec)
+{
+    /* Hacky test for NaN
+	 * under -fast-math this won't work, but then you also won't
+	 * have correct nan values anyways.  The alternative is
+	 * to link with libmath (bad) or hack IEEE double bits (bad)
+	 */
+    if (!(value == value)) {
+        str[0] = 'n';
+        str[1] = 'a';
+        str[2] = 'n';
+        str[3] = '\0';
+        return (size_t)3;
+    }
+
+    /* if input is larger than thres_max, revert to exponential */
+    const double thres_max = (double)(0x7FFFFFFF);
+
+    double diff = 0.0;
+    char* wstr = str;
+
+    if (prec < 0) {
+        prec = 0;
+    } else if (prec > 9) {
+        /* precision of >= 10 can lead to overflow errors */
+        prec = 9;
+    }
+
+    /* we'll work in positive values and deal with the
+	   negative sign issue later */
+    int neg = 0;
+    if (value < 0) {
+        neg = 1;
+        value = -value;
+    }
+
+    int whole = (int)value;
+    double tmp = (value - whole) * powers_of_10[prec];
+    uint32_t frac = (uint32_t)(tmp);
+    diff = tmp - frac;
+
+    if (diff > 0.5) {
+        ++frac;
+        /* handle rollover, e.g.  case 0.99 with prec 1 is 1.0  */
+        if (frac >= powers_of_10[prec]) {
+            frac = 0;
+            ++whole;
+        }
+    } else if (diff == 0.5 && prec > 0 && (frac & 1)) {
+        /* if halfway, round up if odd, OR
+		   if last digit is 0.  That last part is strange */
+        ++frac;
+        if (frac >= powers_of_10[prec]) {
+            frac = 0;
+            ++whole;
+        }
+    } else if (diff == 0.5 && prec == 0 && (whole & 1)) {
+        ++frac;
+        if (frac >= powers_of_10[prec]) {
+            frac = 0;
+            ++whole;
+        }
+    }
+
+    /* for very large numbers switch back to native sprintf for exponentials.
+	   anyone want to write code to replace this? */
+    /*
+	   normal printf behavior is to print EVERY whole number digit
+	   which can be 100s of characters overflowing your buffers == bad
+	   */
+    if (value > thres_max) {
+        sprintf(str, "%e", neg ? -value : value);
+        return strlen(str);
+    }
+
+    int has_decimal = 0;
+    int count = prec;
+
+    /* Remove ending zeros */
+    if (prec > 0) {
+        while (count > 0 && ((frac % 10) == 0)) {
+            count--;
+            frac /= 10;
+        }
+    }
+
+    while (count > 0) {
+        --count;
+        *wstr++ = (char)(48 + (frac % 10));
+        frac /= 10;
+        has_decimal = 1;
+    }
+
+    if (frac > 0) {
+        ++whole;
+    }
+
+    /* add decimal */
+    if (has_decimal) {
+        *wstr++ = '.';
+    }
+    /* do whole part
+	 * Take care of sign conversion
+	 * Number is reversed.
+	 */
+    do
+        *wstr++ = (char)(48 + (whole % 10));
+    while (whole /= 10);
+    if (neg) {
+        *wstr++ = '-';
+    }
+    *wstr = '\0';
+    strreverse(str, wstr - 1);
+    return (size_t)(wstr - str);
+}
+
+char* modp_uitoa16(uint32_t value, char* str, int isfinal)
+{
+    static const char* hexchars = "0123456789ABCDEF";
+
+/**
+	 * Implementation note: 
+	 *  No re-assignment of "value"
+	 *  Each line is independent than the previous, so
+	 *    even dumb compilers can pipeline without loop unrolling
+	 */
+    str[0] = hexchars[(value >> 28) & 0x0000000F];
+    str[1] = hexchars[(value >> 24) & 0x0000000F];
+    str[2] = hexchars[(value >> 20) & 0x0000000F];
+    str[3] = hexchars[(value >> 16) & 0x0000000F];
+    str[4] = hexchars[(value >> 12) & 0x0000000F];
+    str[5] = hexchars[(value >> 8) & 0x0000000F];
+    str[6] = hexchars[(value >> 4) & 0x0000000F];
+    str[7] = hexchars[(value)&0x0000000F];
+
+    if (isfinal) {
+        str[8] = '\0';
+        return str;
+    } else {
+        return str + 8;
+    }
+}

data/vendor/stringencoders/src/modp_numtoa.h

@@ -0,0 +1,100 @@
+/**
+ * \file modp_numtoa.h
+ * \brief Fast integer and floating-point numbers to string conversion
+ *
+ * This defines signed/unsigned integer, and 'double' to char buffer
+ * converters.  The standard way of doing this is with "sprintf", however
+ * these functions are
+ *   * guaranteed maximum size output
+ *   * 5-20x faster!
+ *   * Won't core-dump
+ *
+ */
+
+/**
+ * <pre>
+ * Copyright &copy; 2007, Nick Galbreath -- nickg [at] client9 [dot] com
+ * All rights reserved.
+ * https://github.com/client9/stringencoders/
+ * Released under the MIT license.  See LICENSE for details.
+ * </pre>
+ *
+ */
+
+#ifndef COM_MODP_STRINGENCODERS_NUMTOA_H
+#define COM_MODP_STRINGENCODERS_NUMTOA_H
+
+#include "extern_c_begin.h"
+
+#include "modp_stdint.h"
+
+/** \brief convert an signed integer to char buffer
+ *
+ * \param[in] value
+ * \param[out] buf the output buffer.  Should be 16 chars or more.
+ */
+size_t modp_itoa10(int32_t value, char* buf);
+
+/** \brief convert an unsigned integer to char buffer
+ *
+ * \param[in] value
+ * \param[out] buf The output buffer, should be 16 chars or more.
+ */
+size_t modp_uitoa10(uint32_t value, char* buf);
+
+/** \brief convert an signed long integer to char buffer
+ *
+ * \param[in] value
+ * \param[out] buf the output buffer.  Should be 24 chars or more.
+ */
+size_t modp_litoa10(int64_t value, char* buf);
+
+/** \brief convert an unsigned long integer to char buffer
+ *
+ * \param[in] value
+ * \param[out] buf The output buffer, should be 24 chars or more.
+ */
+size_t modp_ulitoa10(uint64_t value, char* buf);
+
+/** \brief convert a floating point number to char buffer with
+ *         fixed-precision format
+ *
+ * This is similar to "%.[0-9]f" in the printf style.  It will include
+ * trailing zeros
+ *
+ * If the input value is greater than 1<<31, then the output format
+ * will be switched exponential format.
+ *
+ * \param[in] value
+ * \param[out] buf  The allocated output buffer.  Should be 32 chars or more.
+ * \param[in] precision  Number of digits to the right of the decimal point.
+ *    Can only be 0-9.
+ */
+size_t modp_dtoa(double value, char* buf, int precision);
+
+/** \brief convert a floating point number to char buffer with a
+ *         variable-precision format, and no trailing zeros
+ *
+ * This is similar to "%.[0-9]f" in the printf style, except it will
+ * NOT include trailing zeros after the decimal point.  This type
+ * of format oddly does not exists with printf.
+ *
+ * If the input value is greater than 1<<31, then the output format
+ * will be switched exponential format.
+ *
+ * \param[in] value
+ * \param[out] buf  The allocated output buffer.  Should be 32 chars or more.
+ * \param[in] precision  Number of digits to the right of the decimal point.
+ *    Can only be 0-9.
+ */
+size_t modp_dtoa2(double value, char* buf, int precision);
+
+/**
+ * adds a 8-character hexadecimal representation of value
+ *
+ */
+char* modp_uitoa16(uint32_t value, char* buf, int final);
+
+#include "extern_c_end.h"
+
+#endif

data/vendor/stringencoders/src/modp_qsiter.c

@@ -0,0 +1,76 @@
+/**
+ * \file
+ * <pre>
+ * modp_qs.c query string key-value pair iterator
+ * https://github.com/client9/stringencoders
+ *
+ * Copyright &copy; 2012-2016  Nick Galbreath
+ * All rights reserved.
+ * Released under MIT license. See LICENSE for details.
+ * </PRE>
+ */
+
+#include "modp_qsiter.h"
+
+void qsiter_reset(struct qsiter_t* qsi, const char* s, size_t len)
+{
+    qsi->s = s;
+    qsi->len = len;
+    qsi->pos = 0;
+
+    qsi->key = NULL;
+    qsi->keylen = 0;
+    qsi->val = NULL;
+    qsi->vallen = 0;
+}
+
+int qsiter_next(struct qsiter_t* qsi)
+{
+    const char* eq;
+    const char* charstart;
+    const char* ends;
+
+    if (qsi->pos >= qsi->len) {
+        qsi->key = NULL;
+        qsi->keylen = 0;
+        qsi->val = NULL;
+        qsi->vallen = 0;
+        return 0;
+    }
+
+    charstart = qsi->s + qsi->pos;
+    ends = (const char*)memchr(charstart, '&', qsi->len - qsi->pos);
+
+    if (ends == NULL) {
+        eq = (const char*)memchr(charstart, '=', qsi->len - qsi->pos);
+        if (eq == NULL) {
+            qsi->key = charstart;
+            qsi->keylen = (size_t)(qsi->len - qsi->pos);
+            qsi->val = NULL;
+            qsi->vallen = (size_t)0;
+        } else {
+            qsi->key = charstart;
+            qsi->keylen = (size_t)(eq - charstart);
+            qsi->val = eq + 1;
+            qsi->vallen = (size_t)((qsi->s + qsi->len) - qsi->val);
+        }
+        qsi->pos = qsi->len;
+        return 1;
+    } else {
+        /* &&foo=bar */
+        eq = (const char*)memchr(charstart, '=', (size_t)(ends - charstart));
+        if (eq == NULL) {
+            qsi->key = charstart;
+            qsi->keylen = (size_t)(ends - charstart);
+            qsi->val = NULL;
+            qsi->vallen = (size_t)0;
+        } else {
+            qsi->key = charstart;
+            qsi->keylen = (size_t)(eq - charstart);
+            qsi->val = eq + 1;
+            qsi->vallen = (size_t)(ends - eq - 1);
+        }
+        qsi->pos = (size_t)((ends - qsi->s) + 1);
+        return 1;
+    }
+}

data/vendor/stringencoders/src/modp_qsiter.h

@@ -0,0 +1,71 @@
+#ifndef COM_MODP_QSITER
+#define COM_MODP_QSITER
+
+#include <string.h>
+
+#include "extern_c_begin.h"
+
+/**
+ * \file modp_qsiter.h
+ * \brief 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.
+ *
+ * This also does not do query-string un-escaping.
+ *
+ * \code
+ * qsiiter_t qsi;
+ * const char* qs = "foo=bar&ding=bar";
+ * qsiter_reset(&qsi, qs, strlen(qs));
+ * while  (qsiter_next(&qsi)) {
+ *    // we only get start and length of key,value
+ *    // up to you how to copy it or not, on heap or stack
+ *    // with strcpy, strncpy, strndup, memcpy, mempcpy, strlcpy, whatever
+ *    // callers job to alloc/free memory
+ *
+ *    const char* key = (const char*) malloc(qsi.keylen + 1);
+ *    strcpy(key, qsi->key, qsi->keylen);
+ *    const char* val = (const char*) malloc(qsi.vallen + 1);
+ *    strcpy(val, qsi->val, qsi->vallen);
+ *    printf("key = %s, value = %s\n", key, val);
+ *    free(key);
+ *    free(value);
+ * }
+ * \endcode
+ *
+ */
+struct qsiter_t {
+    const char* s;
+    size_t pos;
+    size_t len;
+
+    const char* key;
+    size_t keylen;
+
+    const char* val;
+    size_t vallen;
+};
+
+/**
+ * Reset a qsiter to an initial start (constructor)
+ *
+ * This does not modifiy the original string, nor makes a copy.
+ *
+ * \param[out] qsi data struct used in iterator
+ * \param[in] s input string (does not need to be 0-terminated)
+ * \param[in] len input string length
+ *
+ */
+void qsiter_reset(struct qsiter_t* qsi, const char* s, size_t len);
+
+/**
+ * Get next key/value pair in query string
+ *
+ * \param[out] qsi data struct
+ * \return 1 if found a key value pair, 0 if no more data
+ */
+int qsiter_next(struct qsiter_t* qsi);
+
+#include "extern_c_end.h"
+
+#endif /* MODP_QSITER */

data/vendor/stringencoders/src/modp_stdint.h

@@ -0,0 +1,43 @@
+/* vi: set ft=c expandtab shiftwidth=4 tabstop=4: */
+#ifndef MODP_STDINT_H_
+#define MODP_STDINT_H_
+
+/**
+ * \file modp_stdint.h
+ * \brief An attempt to make stringencoders compile under windows
+ *
+ * This attempts to define various integral types that are normally
+ * defined in stdint.h and stdbool.h which oddly don't exit on
+ * windows.
+ *
+ * Please file bugs or patches if it doesn't work!
+ */
+
+#include <string.h>
+
+#ifndef _WIN32
+#include <stdbool.h>
+#include <stdint.h>
+#else
+/* win64 is llp64 so these are the same for 32/64bit
+   so no check for _WIN64 is required.
+ */
+typedef unsigned char uint8_t;
+typedef signed char int8_t;
+typedef unsigned short uint16_t;
+typedef signed short int16_t;
+typedef unsigned int uint32_t;
+typedef signed int int32_t;
+typedef unsigned __int64 uint64_t;
+typedef signed __int64 int64_t;
+
+/* windows doesn't do C99 and stdbool */
+
+#ifndef __cplusplus
+typedef unsigned char bool;
+#define true 1
+#define false 0
+#endif
+
+#endif /* _WIN32 */
+#endif /* MODP_STDINT_H_ */