@eosrio/node-abieos 2.1.0-beta.0 → 2.2.0

package/include/eosio/fpconv.c

@@ -1,336 +0,0 @@
-/// From https://github.com/night-shift/fpconv
-/// Boost Software License 1.0
-/// See accompanying license file
-
-#include <stdbool.h>
-#include <string.h>
-
-#include "fpconv.h"
-#include "powers.h"
-
-#define fracmask  0x000FFFFFFFFFFFFFU
-#define expmask   0x7FF0000000000000U
-#define hiddenbit 0x0010000000000000U
-#define signmask  0x8000000000000000U
-#define expbias   (1023 + 52)
-
-#define absv(n) ((n) < 0 ? -(n) : (n))
-#define minv(a, b) ((a) < (b) ? (a) : (b))
-
-static uint64_t tens[] = {
-    10000000000000000000U, 1000000000000000000U, 100000000000000000U,
-    10000000000000000U, 1000000000000000U, 100000000000000U,
-    10000000000000U, 1000000000000U, 100000000000U,
-    10000000000U, 1000000000U, 100000000U,
-    10000000U, 1000000U, 100000U,
-    10000U, 1000U, 100U,
-    10U, 1U
-};
-
-static inline uint64_t get_dbits(double d)
-{
-    union {
-        double   dbl;
-        uint64_t i;
-    } dbl_bits = { d };
-
-    return dbl_bits.i;
-}
-
-static Fp build_fp(double d)
-{
-    uint64_t bits = get_dbits(d);
-
-    Fp fp;
-    fp.frac = bits & fracmask;
-    fp.exp = (bits & expmask) >> 52;
-
-    if(fp.exp) {
-        fp.frac += hiddenbit;
-        fp.exp -= expbias;
-
-    } else {
-        fp.exp = -expbias + 1;
-    }
-
-    return fp;
-}
-
-static void normalize(Fp* fp)
-{
-    while ((fp->frac & hiddenbit) == 0) {
-        fp->frac <<= 1;
-        fp->exp--;
-    }
-
-    int shift = 64 - 52 - 1;
-    fp->frac <<= shift;
-    fp->exp -= shift;
-}
-
-static void get_normalized_boundaries(Fp* fp, Fp* lower, Fp* upper)
-{
-    upper->frac = (fp->frac << 1) + 1;
-    upper->exp  = fp->exp - 1;
-
-    while ((upper->frac & (hiddenbit << 1)) == 0) {
-        upper->frac <<= 1;
-        upper->exp--;
-    }
-
-    int u_shift = 64 - 52 - 2;
-
-    upper->frac <<= u_shift;
-    upper->exp = upper->exp - u_shift;
-
-
-    int l_shift = fp->frac == hiddenbit ? 2 : 1;
-
-    lower->frac = (fp->frac << l_shift) - 1;
-    lower->exp = fp->exp - l_shift;
-
-
-    lower->frac <<= lower->exp - upper->exp;
-    lower->exp = upper->exp;
-}
-
-static Fp multiply(Fp* a, Fp* b)
-{
-    const uint64_t lomask = 0x00000000FFFFFFFF;
-
-    uint64_t ah_bl = (a->frac >> 32)    * (b->frac & lomask);
-    uint64_t al_bh = (a->frac & lomask) * (b->frac >> 32);
-    uint64_t al_bl = (a->frac & lomask) * (b->frac & lomask);
-    uint64_t ah_bh = (a->frac >> 32)    * (b->frac >> 32);
-
-    uint64_t tmp = (ah_bl & lomask) + (al_bh & lomask) + (al_bl >> 32);
-    /* round up */
-    tmp += 1U << 31;
-
-    Fp fp = {
-        ah_bh + (ah_bl >> 32) + (al_bh >> 32) + (tmp >> 32),
-        a->exp + b->exp + 64
-    };
-
-    return fp;
-}
-
-static void round_digit(char* digits, int ndigits, uint64_t delta, uint64_t rem, uint64_t kappa, uint64_t frac)
-{
-    while (rem < frac && delta - rem >= kappa &&
-           (rem + kappa < frac || frac - rem > rem + kappa - frac)) {
-
-        digits[ndigits - 1]--;
-        rem += kappa;
-    }
-}
-
-static int generate_digits(Fp* fp, Fp* upper, Fp* lower, char* digits, int* K)
-{
-    uint64_t wfrac = upper->frac - fp->frac;
-    uint64_t delta = upper->frac - lower->frac;
-
-    Fp one;
-    one.frac = 1ULL << -upper->exp;
-    one.exp  = upper->exp;
-
-    uint64_t part1 = upper->frac >> -one.exp;
-    uint64_t part2 = upper->frac & (one.frac - 1);
-
-    int idx = 0, kappa = 10;
-    uint64_t* divp;
-    /* 1000000000 */
-    for(divp = tens + 10; kappa > 0; divp++) {
-
-        uint64_t div = *divp;
-        unsigned digit = part1 / div;
-
-        if (digit || idx) {
-            digits[idx++] = digit + '0';
-        }
-
-        part1 -= digit * div;
-        kappa--;
-
-        uint64_t tmp = (part1 <<-one.exp) + part2;
-        if (tmp <= delta) {
-            *K += kappa;
-            round_digit(digits, idx, delta, tmp, div << -one.exp, wfrac);
-
-            return idx;
-        }
-    }
-
-    /* 10 */
-    uint64_t* unit = tens + 18;
-
-    while(true) {
-        part2 *= 10;
-        delta *= 10;
-        kappa--;
-
-        unsigned digit = part2 >> -one.exp;
-        if (digit || idx) {
-            digits[idx++] = digit + '0';
-        }
-
-        part2 &= one.frac - 1;
-        if (part2 < delta) {
-            *K += kappa;
-            round_digit(digits, idx, delta, part2, one.frac, wfrac * *unit);
-
-            return idx;
-        }
-
-        unit--;
-    }
-}
-
-static int grisu2(double d, char* digits, int* K)
-{
-    Fp w = build_fp(d);
-
-    Fp lower, upper;
-    get_normalized_boundaries(&w, &lower, &upper);
-
-    normalize(&w);
-
-    int k;
-    Fp cp = find_cachedpow10(upper.exp, &k);
-
-    w     = multiply(&w,     &cp);
-    upper = multiply(&upper, &cp);
-    lower = multiply(&lower, &cp);
-
-    lower.frac++;
-    upper.frac--;
-
-    *K = -k;
-
-    return generate_digits(&w, &upper, &lower, digits, K);
-}
-
-static int emit_digits(char* digits, int ndigits, char* dest, int K, bool neg)
-{
-    int exp = absv(K + ndigits - 1);
-
-    /* write plain integer */
-    if(K >= 0 && (exp < (ndigits + 7))) {
-        memcpy(dest, digits, ndigits);
-        memset(dest + ndigits, '0', K);
-
-        return ndigits + K;
-    }
-
-    /* write decimal w/o scientific notation */
-    if(K < 0 && (K > -7 || exp < 4)) {
-        int offset = ndigits - absv(K);
-        /* fp < 1.0 -> write leading zero */
-        if(offset <= 0) {
-            offset = -offset;
-            dest[0] = '0';
-            dest[1] = '.';
-            memset(dest + 2, '0', offset);
-            memcpy(dest + offset + 2, digits, ndigits);
-
-            return ndigits + 2 + offset;
-
-        /* fp > 1.0 */
-        } else {
-            memcpy(dest, digits, offset);
-            dest[offset] = '.';
-            memcpy(dest + offset + 1, digits + offset, ndigits - offset);
-
-            return ndigits + 1;
-        }
-    }
-
-    /* write decimal w/ scientific notation */
-    ndigits = minv(ndigits, 18 - neg);
-
-    int idx = 0;
-    dest[idx++] = digits[0];
-
-    if(ndigits > 1) {
-        dest[idx++] = '.';
-        memcpy(dest + idx, digits + 1, ndigits - 1);
-        idx += ndigits - 1;
-    }
-
-    dest[idx++] = 'e';
-
-    char sign = K + ndigits - 1 < 0 ? '-' : '+';
-    dest[idx++] = sign;
-
-    int cent = 0;
-
-    if(exp > 99) {
-        cent = exp / 100;
-        dest[idx++] = cent + '0';
-        exp -= cent * 100;
-    }
-    if(exp > 9) {
-        int dec = exp / 10;
-        dest[idx++] = dec + '0';
-        exp -= dec * 10;
-
-    } else if(cent) {
-        dest[idx++] = '0';
-    }
-
-    dest[idx++] = exp % 10 + '0';
-
-    return idx;
-}
-
-static int filter_special(double fp, char* dest)
-{
-    if(fp == 0.0) {
-        dest[0] = '0';
-        return 1;
-    }
-
-    uint64_t bits = get_dbits(fp);
-
-    bool nan = (bits & expmask) == expmask;
-
-    if(!nan) {
-        return 0;
-    }
-
-    if(bits & fracmask) {
-        dest[0] = 'n'; dest[1] = 'a'; dest[2] = 'n';
-
-    } else {
-        dest[0] = 'i'; dest[1] = 'n'; dest[2] = 'f';
-    }
-
-    return 3;
-}
-
-int fpconv_dtoa(double d, char dest[24])
-{
-    char digits[18];
-
-    int str_len = 0;
-    bool neg = false;
-
-    if(get_dbits(d) & signmask) {
-        dest[0] = '-';
-        str_len++;
-        neg = true;
-    }
-
-    int spec = filter_special(d, dest + str_len);
-
-    if(spec) {
-        return str_len + spec;
-    }
-
-    int K = 0;
-    int ndigits = grisu2(d, digits, &K);
-
-    str_len += emit_digits(digits, ndigits, dest + str_len, K, neg);
-
-    return str_len;
-}

package/include/eosio/fpconv.h

@@ -1,41 +0,0 @@
-/// From https://github.com/night-shift/fpconv
-/// Boost Software License 1.0
-/// See accompanying license file
-
-#ifndef FPCONV_H
-#   define FPCONV_H
-
-/* Fast and accurate double to string conversion based on Florian Loitsch's
- * Grisu-algorithm[1].
- *
- * Input:
- * fp -> the double to convert, dest -> destination buffer.
- * The generated string will never be longer than 24 characters.
- * Make sure to pass a pointer to at least 24 bytes of memory.
- * The emitted string will not be null terminated.
- *
- * Output:
- * The number of written characters.
- *
- * Exemplary usage:
- *
- * void print(double d)
- * {
- *      char buf[24 + 1] // plus null terminator
- *      int str_len = fpconv_dtoa(d, buf);
- *
- *      buf[str_len] = '\0';
- *      printf("%s", buf);
- * }
- *
- */
-
-#   ifdef __cplusplus
-extern "C" int fpconv_dtoa(double fp, char dest[24]);
-#   else
-int fpconv_dtoa(double fp, char dest[24]);
-#   endif
-
-#endif
-
-/* [1] http://florian.loitsch.com/publications/dtoa-pldi2010.pdf */

package/include/eosio/fpconv.license

@@ -1,23 +0,0 @@
-Boost Software License - Version 1.0 - August 17th, 2003
-
-Permission is hereby granted, free of charge, to any person or organization
-obtaining a copy of the software and accompanying documentation covered by
-this license (the "Software") to use, reproduce, display, distribute,
-execute, and transmit the Software, and to prepare derivative works of the
-Software, and to permit third-parties to whom the Software is furnished to
-do so, all subject to the following:
-
-The copyright notices in the Software and this entire statement, including
-the above license grant, this restriction and the following disclaimer,
-must be included in all copies of the Software, in whole or in part, and
-all derivative works of the Software, unless such copies or derivative
-works are solely in the form of machine-executable object code generated by
-a source language processor.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
-SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
-FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
-ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.

package/include/eosio/from_bin.hpp

@@ -1,272 +0,0 @@
-#pragma once
-
-#include <deque>
-#include "convert.hpp"
-#include "for_each_field.hpp"
-#include "stream.hpp"
-#include <list>
-#include <map>
-#include <optional>
-#include <set>
-#include <tuple>
-#include <variant>
-#include <vector>
-#include <string_view>
-
-namespace eosio {
-
-template <typename T, typename S>
-void from_bin(T& obj, S& stream);
-
-template <typename S>
-void varuint32_from_bin(uint32_t& dest, S& stream) {
-   dest          = 0;
-   int     shift = 0;
-   uint8_t b     = 0;
-   do {
-      check( shift < 35, convert_stream_error(stream_error::invalid_varuint_encoding) );
-      from_bin(b, stream);
-      dest |= uint32_t(b & 0x7f) << shift;
-      shift += 7;
-   } while (b & 0x80);
-}
-
-template <typename S>
-void varuint64_from_bin(uint64_t& dest, S& stream) {
-   dest          = 0;
-   int     shift = 0;
-   uint8_t b     = 0;
-   do {
-      check( shift < 70, convert_stream_error(stream_error::invalid_varuint_encoding) );
-      from_bin(b, stream);
-      dest |= uint64_t(b & 0x7f) << shift;
-      shift += 7;
-   } while (b & 0x80);
-}
-
-template <typename S>
-void varint32_from_bin(int32_t& result, S& stream) {
-   uint32_t v;
-   varuint32_from_bin(v, stream);
-   if (v & 1)
-      result = ((~v) >> 1) | 0x8000'0000;
-   else
-      result = v >> 1;
-}
-
-template <typename T, typename S>
-void from_bin_assoc(T& v, S& stream) {
-   uint32_t size;
-   varuint32_from_bin(size, stream);
-   for (size_t i = 0; i < size; ++i) {
-      typename T::value_type elem;
-      from_bin(elem, stream);
-      v.emplace(elem);
-   }
-}
-
-template <typename T, typename S>
-void from_bin_sequence(T& v, S& stream) {
-   uint32_t size;
-   varuint32_from_bin(size, stream);
-   for (size_t i = 0; i < size; ++i) {
-      v.emplace_back();
-      from_bin(v.back(), stream);
-   }
-}
-
-template <typename T, std::size_t N, typename S>
-void from_bin(T (&v)[N], S& stream) {
-   uint32_t size;
-   varuint32_from_bin(size, stream);
-   check( size == N, convert_stream_error(stream_error::array_size_mismatch) );
-   if constexpr (has_bitwise_serialization<T>()) {
-      stream.read(reinterpret_cast<char*>(v), size * sizeof(T));
-   } else {
-      for (size_t i = 0; i < size; ++i) {
-         from_bin(v[i], stream);
-      }
-   }
-}
-
-template <typename T, typename S>
-void from_bin(std::vector<T>& v, S& stream) {
-   if constexpr (has_bitwise_serialization<T>()) {
-      if constexpr (sizeof(size_t) >= 8) {
-         uint64_t size;
-         varuint64_from_bin(size, stream);
-         stream.check_available(size * sizeof(T));
-         v.resize(size);
-         stream.read(reinterpret_cast<char*>(v.data()), size * sizeof(T));
-      } else {
-         uint32_t size;
-         varuint32_from_bin(size, stream);
-         stream.check_available(size * sizeof(T));
-         v.resize(size);
-         stream.read(reinterpret_cast<char*>(v.data()), size * sizeof(T));
-      }
-   } else {
-      uint32_t size;
-      varuint32_from_bin(size, stream);
-      v.resize(size);
-      for (size_t i = 0; i < size; ++i) {
-         from_bin(v[i], stream);
-      }
-   }
-}
-
-template <typename T, typename S>
-void from_bin(std::set<T>& v, S& stream) {
-   return from_bin_assoc(v, stream);
-}
-
-template <typename T, typename U, typename S>
-void from_bin(std::map<T, U>& v, S& stream) {
-   uint32_t size;
-   varuint32_from_bin(size, stream);
-   for (size_t i = 0; i < size; ++i) {
-      std::pair<T, U> elem;
-      from_bin(elem, stream);
-      v.emplace(elem);
-   }
-}
-
-template <typename T, typename S>
-void from_bin(std::deque<T>& v, S& stream) {
-   return from_bin_sequence(v, stream);
-}
-
-template <typename T, typename S>
-void from_bin(std::list<T>& v, S& stream) {
-   return from_bin_sequence(v, stream);
-}
-
-template <typename S>
-void from_bin(input_stream& obj, S& stream) {
-   if constexpr (sizeof(size_t) >= 8) {
-      uint64_t size;
-      varuint64_from_bin(size, stream);
-      stream.check_available(size);
-      stream.read_reuse_storage(obj.pos, size);
-      obj.end = obj.pos + size;
-   } else {
-      uint32_t size;
-      varuint32_from_bin(size, stream);
-      stream.check_available(size);
-      stream.read_reuse_storage(obj.pos, size);
-      obj.end = obj.pos + size;
-   }
-}
-
-template <typename First, typename Second, typename S>
-void from_bin(std::pair<First, Second>& obj, S& stream) {
-   from_bin(obj.first, stream);
-   from_bin(obj.second, stream);
-}
-
-template <typename S>
-inline void from_bin(std::string& obj, S& stream) {
-   uint32_t size;
-   varuint32_from_bin(size, stream);
-   obj.resize(size);
-   stream.read(obj.data(), obj.size());
-}
-
-template <typename S>
-inline void from_bin(std::string_view& obj, S& stream) {
-   uint32_t size;
-   varuint32_from_bin(size, stream);
-   obj = std::string_view(stream.get_pos(),size);
-   stream.skip(size);
-}
-
-template <typename T, typename S>
-void from_bin(std::optional<T>& obj, S& stream) {
-   bool present;
-   from_bin(present, stream);
-   if (!present) {
-      obj.reset();
-      return;
-   }
-   obj.emplace();
-   from_bin(*obj, stream);
-}
-
-template <uint32_t I, typename... Ts, typename S>
-void variant_from_bin(std::variant<Ts...>& v, uint32_t i, S& stream) {
-   if constexpr (I < std::variant_size_v<std::variant<Ts...>>) {
-      if (i == I) {
-         auto& x = v.template emplace<I>();
-         from_bin(x, stream);
-      } else {
-         variant_from_bin<I + 1>(v, i, stream);
-      }
-   } else {
-      check( false, convert_stream_error(stream_error::bad_variant_index) );
-   }
-}
-
-template <typename... Ts, typename S>
-void from_bin(std::variant<Ts...>& obj, S& stream) {
-   uint32_t u;
-   varuint32_from_bin(u, stream);
-   variant_from_bin<0>(obj, u, stream);
-}
-
-template <typename T, std::size_t N, typename S>
-void from_bin(std::array<T, N>& obj, S& stream) {
-   for (T& elem : obj) {
-      from_bin(elem, stream);
-   }
-}
-
-template <int N, typename T, typename S>
-void from_bin_tuple(T& obj, S& stream) {
-   if constexpr (N < std::tuple_size_v<T>) {
-      from_bin(std::get<N>(obj), stream);
-      from_bin_tuple<N + 1>(obj, stream);
-   }
-}
-
-template <typename... T, typename S>
-void from_bin(std::tuple<T...>& obj, S& stream) {
-   return from_bin_tuple<0>(obj, stream);
-}
-
-template <typename T, typename S>
-void from_bin(T& obj, S& stream) {
-   if constexpr (has_bitwise_serialization<T>()) {
-      stream.read(reinterpret_cast<char*>(&obj), sizeof(T));
-   } else if constexpr (std::is_same_v<serialization_type<T>, void>) {
-      for_each_field(obj, [&](auto& member) {
-         from_bin(member, stream);
-      });
-   } else {
-      // TODO: This can operate in place for standard serializers
-      decltype(serialize_as(obj)) temp;
-      from_bin(temp, stream);
-      convert(temp, obj, choose_first);
-   }
-}
-
-template <typename T, typename S>
-T from_bin(S& stream) {
-   T    obj;
-   from_bin(obj, stream);
-   return obj;
-}
-
-template <typename T>
-void convert_from_bin(T& obj, const std::vector<char>& bin) {
-   input_stream stream{ bin };
-   return from_bin(obj, stream);
-}
-
-template <typename T>
-T convert_from_bin(const std::vector<char>& bin) {
-   T    obj;
-   convert_from_bin(obj, bin);
-   return obj;
-}
-
-} // namespace eosio