iv-phonic 0.0.1

data/ext/include/iv/conversions.h

@@ -0,0 +1,308 @@
+#ifndef IV_CONVERSIONS_H_
+#define IV_CONVERSIONS_H_
+#include <cstdio>
+#include <cmath>
+#include <string>
+#include <limits>
+#include <tr1/array>
+#include <tr1/cstdint>
+#include "chars.h"
+#include "dtoa.h"
+#include "ustringpiece.h"
+#include "none.h"
+namespace iv {
+namespace core {
+namespace detail {
+template<typename T>
+class Conversions {
+ public:
+  static const double kNaN;
+  static const int kMaxSignificantDigits = 772;
+  static const std::string kInfinity;
+  static const double DoubleToInt32_Two32;
+  static const double DoubleToInt32_Two31;
+};
+template<typename T>
+const double Conversions<T>::kNaN = std::numeric_limits<double>::quiet_NaN();
+
+template<typename T>
+const std::string Conversions<T>::kInfinity = "Infinity";
+
+template<typename T>
+const double Conversions<T>::DoubleToInt32_Two32 = 4294967296.0;
+
+template<typename T>
+const double Conversions<T>::DoubleToInt32_Two31 = 2147483648.0;
+}  // namespace iv::core::detail
+
+typedef detail::Conversions<None> Conversions;
+
+template<typename Iter>
+inline double StringToDouble(Iter it, Iter last) {
+  bool is_decimal = true;
+  bool is_signed = false;
+  std::size_t pos = 0;
+  int significant_digits = 0;
+  int insignificant_digits = 0;
+  std::tr1::array<char, Conversions::kMaxSignificantDigits+10> buffer;
+
+  // empty string ""
+  if (it == last) {
+    return 0;
+  }
+
+  while (it != last &&
+         (Chars::IsWhiteSpace(*it) || Chars::IsLineTerminator(*it))) {
+    ++it;
+  }
+
+  // white space only "  "
+  if (it == last) {
+    return 0;
+  }
+
+  if (*it == '-') {
+    buffer[pos++] = '-';
+    ++it;
+    is_signed = true;
+  } else if (*it == '+') {
+    ++it;
+  }
+
+  if (it == last) {
+    return Conversions::kNaN;
+  }
+
+  if (Chars::IsDecimalDigit(*it)) {
+    if (*it == '0') {
+      ++it;
+      if (it == last) {
+        return 0;
+      }
+      if (*it == 'x' || *it == 'X') {
+        is_decimal = false;
+        buffer[pos++] = '0';
+        buffer[pos++] = *it;
+        ++it;
+        ++significant_digits;
+        if (it == last || !Chars::IsHexDigit(*it)) {
+          return Conversions::kNaN;
+        }
+        // waste leading zero
+        while (it != last && *it == '0') {
+          ++it;
+        }
+        while (it != last && Chars::IsHexDigit(*it)) {
+          if (significant_digits < Conversions::kMaxSignificantDigits) {
+            buffer[pos++] = *it;
+            ++it;
+            ++significant_digits;
+          } else {
+            ++it;
+          }
+        }
+      } else {
+        // waste leading zero
+        while (it != last && *it == '0') {
+          ++it;
+        }
+      }
+    }
+    if (is_decimal) {
+      while (it != last &&
+             Chars::IsDecimalDigit(*it)) {
+        if (significant_digits < Conversions::kMaxSignificantDigits) {
+          buffer[pos++] = *it;
+          ++significant_digits;
+        } else {
+          ++insignificant_digits;
+        }
+        ++it;
+      }
+      if (it != last && *it == '.') {
+        buffer[pos++] = '.';
+        ++it;
+        while (it != last &&
+               Chars::IsDecimalDigit(*it)) {
+          if (significant_digits < Conversions::kMaxSignificantDigits) {
+            buffer[pos++] = *it;
+            ++significant_digits;
+          }
+          ++it;
+        }
+      }
+    }
+  } else {
+    if (*it == '.') {
+      buffer[pos++] = '.';
+      ++it;
+      while (it != last &&
+             Chars::IsDecimalDigit(*it)) {
+        if (significant_digits < Conversions::kMaxSignificantDigits) {
+          buffer[pos++] = *it;
+          ++significant_digits;
+        }
+        ++it;
+      }
+    } else {
+      for (std::string::const_iterator inf_it = Conversions::kInfinity.begin(),
+           inf_last = Conversions::kInfinity.end();
+           inf_it != inf_last; ++inf_it, ++it) {
+        if (it == last ||
+            (*inf_it) != (*it)) {
+          return Conversions::kNaN;
+        }
+      }
+      // infinity
+      while (it != last &&
+             (Chars::IsWhiteSpace(*it) || Chars::IsLineTerminator(*it))) {
+        ++it;
+      }
+      if (it == last) {
+        if (is_signed) {
+          return -std::numeric_limits<double>::infinity();
+        } else {
+          return std::numeric_limits<double>::infinity();
+        }
+      } else {
+        return Conversions::kNaN;
+      }
+    }
+  }
+
+  // exponent part
+  if (it != last && (*it == 'e' || *it == 'E')) {
+    if (!is_decimal) {
+      return Conversions::kNaN;
+    }
+    buffer[pos++] = *it;
+    ++it;
+    if (it == last) {
+      return Conversions::kNaN;
+    }
+    if (*it == '+' || *it == '-') {
+      buffer[pos++] = *it;
+      ++it;
+    }
+    if (it == last) {
+      return Conversions::kNaN;
+    }
+    // more than 1 decimal digit required
+    if (!Chars::IsDecimalDigit(*it)) {
+      return Conversions::kNaN;
+    }
+    int exponent = 0;
+    do {
+      if (exponent > 9999) {
+        exponent = 9999;
+      } else {
+        exponent = exponent * 10 + (*it - '0');
+      }
+      ++it;
+    } while (it != last && Chars::IsDecimalDigit(*it));
+    exponent+=insignificant_digits;
+    if (exponent > 9999) {
+      exponent = 9999;
+    }
+    std::snprintf(buffer.data()+pos, 5, "%d", exponent);  // NOLINT
+    pos+=4;
+  }
+
+  while (it != last &&
+         (Chars::IsWhiteSpace(*it) || Chars::IsLineTerminator(*it))) {
+    ++it;
+  }
+
+  if (it == last) {
+    if (pos == 0) {
+      // empty
+      return 0;
+    } else {
+      buffer[pos++] = '\0';
+      return std::strtod(buffer.data(), NULL);
+    }
+  } else {
+    return Conversions::kNaN;
+  }
+}
+
+inline double StringToDouble(const StringPiece& str) {
+  return StringToDouble(str.begin(), str.end());
+}
+
+inline double StringToDouble(const UStringPiece& str) {
+  return StringToDouble(str.begin(), str.end());
+}
+
+inline std::size_t StringToHash(const UStringPiece& x) {
+  std::size_t len = x.size();
+  std::size_t step = (len >> 5) + 1;
+  std::size_t h = 0;
+  for (std::size_t l1 = len; l1 >= step; l1 -= step) {
+    h = h ^ ((h << 5) + (h >> 2) + x[l1-1]);
+  }
+  return h;
+}
+
+inline std::size_t StringToHash(const StringPiece& x) {
+  std::size_t len = x.size();
+  std::size_t step = (len >> 5) + 1;
+  std::size_t h = 0;
+  for (std::size_t l1 = len; l1 >= step; l1 -= step) {
+    h = h ^ ((h << 5) + (h >> 2) + x[l1-1]);
+  }
+  return h;
+}
+
+
+inline int32_t DoubleToInt32(double d) {
+  int32_t i = static_cast<int32_t>(d);
+  if (static_cast<double>(i) == d) {
+    return i;
+  }
+  if (!std::isfinite(d) || d == 0) {
+    return 0;
+  }
+  if (d < 0 || d >= Conversions::DoubleToInt32_Two32) {
+    d = std::fmod(d, Conversions::DoubleToInt32_Two32);
+  }
+  d = (d >= 0) ?
+      std::floor(d) : std::ceil(d) + Conversions::DoubleToInt32_Two32;
+  return static_cast<int32_t>(d >= Conversions::DoubleToInt32_Two31 ?
+                              d - Conversions::DoubleToInt32_Two32 : d);
+}
+
+inline int32_t DoubleToUInt32(double d) {
+  return static_cast<uint32_t>(d);
+}
+
+inline bool ConvertToUInt32(const UStringPiece& str, uint32_t* value) {
+  uint16_t ch;
+  *value = 0;
+  UStringPiece::const_iterator it = str.begin();
+  const UStringPiece::const_iterator last = str.end();
+  if (it != last && *it != '0' && Chars::IsDecimalDigit(*it)) {
+    ch = *it - '0';
+    *value = ch;
+  } else {
+    return false;
+  }
+  ++it;
+  uint32_t prev = *value;
+  for (;it != last; ++it) {
+    prev = *value;
+    if (Chars::IsDecimalDigit(*it)) {
+      ch = *it - '0';
+      *value = ch + (prev * 10);
+    } else {
+      return false;
+    }
+  }
+  return (prev < (std::numeric_limits<uint32_t>::max() / 10) ||
+          ((prev == (std::numeric_limits<uint32_t>::max() / 10)) &&
+           (ch < (std::numeric_limits<uint32_t>::max() % 10))));
+}
+
+
+} }  // namespace iv::core
+#endif  // IV_CONVERSIONS_H_

data/ext/include/iv/dtoa.h

@@ -0,0 +1,20 @@
+#ifndef IV_LV5_DTOA_H_
+#define IV_LV5_DTOA_H_
+// Double to String
+
+// David M Gay's algorithm and V8 fast-dtoa
+
+namespace v8 {
+namespace internal {
+// Printing floating-point numbers quickly and accurately with integers. 
+// Florian Loitsch, PLDI 2010.
+extern char* DoubleToCString(double v, char* buffer, int buflen);
+} }  // namespace v8::internal
+
+namespace iv {
+namespace core {
+
+using v8::internal::DoubleToCString;
+
+} }  // namespace iv::lv5
+#endif  // IV_LV5_DTOA_H_

data/ext/include/iv/enable_if.h

@@ -0,0 +1,18 @@
+#ifndef _IV_ENABLE_IF_H_
+#define _IV_ENABLE_IF_H_
+namespace iv {
+
+template<bool B, class T = void>
+struct enable_if_c {
+  typedef T type;
+};
+template<class T>
+struct enable_if_c<false, T> {
+  // NO TYPEDEF!
+};
+template<class Cond, class T = void>
+struct enable_if : public enable_if_c<Cond::value, T> {
+};
+
+}  // namespace iv
+#endif  // _IV_ENABLE_IF_H_

data/ext/include/iv/errors.h

@@ -0,0 +1,15 @@
+#ifndef _IV_ERRORS_H_
+#define _IV_ERRORS_H_
+namespace iv {
+namespace core {
+
+class Errors {
+ public:
+  enum Type {
+    kILLEGAL = 0,
+    kLEFTHANDSIDE = 0,
+  };
+};
+
+} }  // namespace iv::core
+#endif  // _IV_ERRORS_H_

data/ext/include/iv/fixedcontainer.h

@@ -0,0 +1,42 @@
+#ifndef IV_FIXEDCONTAINE_H_
+#define IV_FIXEDCONTAINE_H_
+#include <cstddef>
+#include <iterator>
+#include <tr1/type_traits>
+namespace iv {
+namespace core {
+
+template<typename T>
+class FixedContainer {
+ public:
+  typedef T value_type;
+  typedef typename std::tr1::add_pointer<T>::type pointer;
+  typedef pointer iterator;
+  typedef typename std::tr1::add_const<iterator>::type const_iterator;
+  typedef typename std::tr1::add_reference<T>::type  reference;
+  typedef typename std::tr1::add_const<reference>::type const_reference;
+  typedef std::reverse_iterator<iterator> reverse_iterator;
+  typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+  typedef std::ptrdiff_t difference_type;
+  typedef std::size_t size_type;
+  FixedContainer(pointer buffer, size_type size)
+    : buf_(buffer),
+      size_(size) { }
+  // iterator begin() { return buf_; }
+  // iterator end() { return buf_+size_; }
+  const_iterator begin() const { return buf_; }
+  const_iterator end() const { return buf_+size_; }
+  size_type size() const { return size_; }
+  reference operator[](std::size_t n) {
+    return *(buf_+n);
+  }
+  const_reference operator[](std::size_t n) const {
+    return *(buf_+n);
+  }
+ protected:
+  pointer buf_;
+  size_type size_;
+};
+
+} }  // namespace iv::core
+#endif  // IV_FIXEDCONTAINER_H_

data/ext/include/iv/functor.h

@@ -0,0 +1,29 @@
+#ifndef _IV_FUNCTOR_H_
+#define _IV_FUNCTOR_H_
+#include <functional>
+namespace iv {
+namespace core {
+
+template<typename T>
+struct Deleter : public std::unary_function<T, void> {
+  void operator()(T* p) const {
+    delete p;
+  }
+};
+
+template<typename T>
+struct Deleter<T[]> : public std::unary_function<T[], void> {
+  void operator()(T* p) const {
+    delete [] p;
+  }
+};
+
+template<typename T>
+struct Destructor : public std::unary_function<T, void> {
+  void operator()(T* p) const {
+    p->~T();
+  }
+};
+
+} }  // namespace iv::core
+#endif  // _IV_FUNCTOR_H_