iv-phonic 0.0.3 → 0.0.5

data/ext/include/iv/conversions.h

@@ -21,6 +21,8 @@ class Conversions {
   static const std::string kInfinity;
   static const double DoubleToInt32_Two32;
   static const double DoubleToInt32_Two31;
+  static const char* kHex;
+  static const int kMaxDoubleToStringWithRadixBufferSize = 2200;
 };
 template<typename T>
 const double Conversions<T>::kNaN = std::numeric_limits<double>::quiet_NaN();
@@ -33,14 +35,19 @@ const double Conversions<T>::DoubleToInt32_Two32 = 4294967296.0;
 
 template<typename T>
 const double Conversions<T>::DoubleToInt32_Two31 = 2147483648.0;
+
+template<typename T>
+const char* Conversions<T>::kHex = "0123456789abcdefghijklmnopqrstuvwxyz";
+
 }  // namespace iv::core::detail
 
 typedef detail::Conversions<None> Conversions;
 
 template<typename Iter>
-inline double StringToDouble(Iter it, Iter last) {
+inline double StringToDouble(Iter it, Iter last, bool parse_float) {
   bool is_decimal = true;
   bool is_signed = false;
+  bool is_sign_found = false;
   std::size_t pos = 0;
   int significant_digits = 0;
   int insignificant_digits = 0;
@@ -48,7 +55,7 @@ inline double StringToDouble(Iter it, Iter last) {
 
   // empty string ""
   if (it == last) {
-    return 0;
+    return (parse_float) ? Conversions::kNaN : 0;
   }
 
   while (it != last &&
@@ -58,15 +65,17 @@ inline double StringToDouble(Iter it, Iter last) {
 
   // white space only "  "
   if (it == last) {
-    return 0;
+    return (parse_float) ? Conversions::kNaN : 0;
   }
 
   if (*it == '-') {
     buffer[pos++] = '-';
     ++it;
     is_signed = true;
+    is_sign_found = true;
   } else if (*it == '+') {
     ++it;
+    is_sign_found = true;
   }
 
   if (it == last) {
@@ -79,7 +88,10 @@ inline double StringToDouble(Iter it, Iter last) {
       if (it == last) {
         return 0;
       }
-      if (*it == 'x' || *it == 'X') {
+      if (!parse_float && (*it == 'x' || *it == 'X')) {
+        if (is_sign_found) {
+          return Conversions::kNaN;
+        }
         is_decimal = false;
         buffer[pos++] = '0';
         buffer[pos++] = *it;
@@ -158,7 +170,7 @@ inline double StringToDouble(Iter it, Iter last) {
              (Chars::IsWhiteSpace(*it) || Chars::IsLineTerminator(*it))) {
         ++it;
       }
-      if (it == last) {
+      if (it == last || parse_float) {
         if (is_signed) {
           return -std::numeric_limits<double>::infinity();
         } else {
@@ -213,10 +225,10 @@ inline double StringToDouble(Iter it, Iter last) {
     ++it;
   }
 
-  if (it == last) {
+  if (it == last || parse_float) {
     if (pos == 0) {
       // empty
-      return 0;
+      return (parse_float) ? Conversions::kNaN : 0;
     } else {
       buffer[pos++] = '\0';
       return std::strtod(buffer.data(), NULL);
@@ -226,12 +238,12 @@ inline double StringToDouble(Iter it, Iter last) {
   }
 }
 
-inline double StringToDouble(const StringPiece& str) {
-  return StringToDouble(str.begin(), str.end());
+inline double StringToDouble(const StringPiece& str, bool parse_float) {
+  return StringToDouble(str.begin(), str.end(), parse_float);
 }
 
-inline double StringToDouble(const UStringPiece& str) {
-  return StringToDouble(str.begin(), str.end());
+inline double StringToDouble(const UStringPiece& str, bool parse_float) {
+  return StringToDouble(str.begin(), str.end(), parse_float);
 }
 
 inline std::size_t StringToHash(const UStringPiece& x) {
@@ -276,6 +288,16 @@ inline int32_t DoubleToUInt32(double d) {
   return static_cast<uint32_t>(d);
 }
 
+inline double DoubleToInteger(double d) {
+  if (std::isnan(d)) {
+    return 0;
+  }
+  if (!std::isfinite(d) || d == 0) {
+    return d;
+  }
+  return std::floor(std::abs(d)) * (std::signbit(d) ? -1 : 1);
+}
+
 inline bool ConvertToUInt32(const UStringPiece& str, uint32_t* value) {
   uint16_t ch;
   *value = 0;
@@ -303,6 +325,52 @@ inline bool ConvertToUInt32(const UStringPiece& str, uint32_t* value) {
            (ch < (std::numeric_limits<uint32_t>::max() % 10))));
 }
 
+template<typename T>
+inline std::size_t DoubleToStringWithRadix(double v, int radix, T* buf) {
+  static const int kMaxBufSize = 1100;
+  std::tr1::array<
+      char,
+      Conversions::kMaxDoubleToStringWithRadixBufferSize> buffer;
+  const bool is_negative = v < 0.0;
+  if (is_negative) {
+    v = -v;
+  }
+  double integer = std::floor(v);
+  double decimal = v - integer;
+
+  // integer part
+  int integer_pos = kMaxBufSize - 1;
+  do {
+    buffer[integer_pos--] =
+        Conversions::kHex[static_cast<std::size_t>(std::fmod(integer, radix))];
+    integer /= radix;
+  } while (integer >= 1.0);
+  if (is_negative) {
+    buffer[integer_pos--] = '-';
+  }
+  assert(integer_pos >= 0);
+
+  // decimal part
+  int decimal_pos = kMaxBufSize;
+  if (decimal) {
+    buffer[decimal_pos++] = '.';
+    while ((decimal > 0.0) && (decimal_pos < (kMaxBufSize * 2))) {
+      decimal *= radix;
+      const std::size_t res = static_cast<std::size_t>(std::floor(decimal));
+      buffer[decimal_pos++] = Conversions::kHex[res];
+      decimal -= res;
+    }
+  }
+  buf->assign(buffer.data() + integer_pos + 1,
+              buffer.data() + decimal_pos);
+  return decimal_pos - integer_pos - 1;  // size
+}
+
+inline std::string DoubleToStringWithRadix(double v, int radix) {
+  std::string str;
+  DoubleToStringWithRadix(v, radix, &str);
+  return str;
+}
 
 } }  // namespace iv::core
 #endif  // IV_CONVERSIONS_H_

data/ext/include/iv/keyword.h

@@ -0,0 +1,460 @@
+#ifndef _IV_KEYWORD_H_
+#define _IV_KEYWORD_H_
+#include <cstddef>
+#include "token.h"
+namespace iv {
+namespace core {
+
+// tags
+class IdentifyReservedWords { };
+class IgnoreReservedWords { };
+class IgnoreReservedWordsAndIdentifyGetterOrSetter { };
+
+namespace detail {
+template<typename LexType>
+class Keyword { };
+
+// detect which Identifier is Keyword, FutureReservedWord or not
+// Keyword and FutureReservedWord are defined in ECMA-262 5th.
+//
+// Some words such as :
+// int, short, boolean, byte, long, char, float, double, abstract, volatile,
+// transient, final, throws, goto, native, synchronized
+// were defined as FutureReservedWord in ECMA-262 3rd, but not in 5th.
+// So, Detect interprets them as Identifier.
+template<>
+class Keyword<IdentifyReservedWords> {
+ public:
+  template<typename Buffer>
+  static Token::Type Detect(const Buffer& buf, bool strict) {
+    const std::size_t len = buf.size();
+    Token::Type token = Token::IDENTIFIER;
+    switch (len) {
+      case 2:
+        // if in do
+        if (buf[0] == 'i') {
+          if (buf[1] == 'f') {
+            token = Token::IF;
+          } else if (buf[1] == 'n') {
+            token = Token::IN;
+          }
+        } else if (buf[0] == 'd' && buf[1] == 'o') {
+          // do
+          token = Token::DO;
+        }
+        break;
+      case 3:
+        // for var int new try let
+        switch (buf[2]) {
+          case 't':
+            if (buf[0] == 'l' && buf[1] == 'e' && strict) {
+              // let
+              token = Token::LET;
+            } else if (buf[0] == 'i' && buf[1] == 'n') {
+              // int (removed)
+              // token = Token::INT;
+            }
+            break;
+          case 'r':
+            // for var
+            if (buf[0] == 'f' && buf[1] == 'o') {
+              // for
+              token = Token::FOR;
+            } else if (buf[0] == 'v' && buf[1] == 'a') {
+              // var
+              token = Token::VAR;
+            }
+            break;
+          case 'y':
+            // try
+            if (buf[0] == 't' && buf[1] == 'r') {
+              token = Token::TRY;
+            }
+            break;
+          case 'w':
+            // new
+            if (buf[0] == 'n' && buf[1] == 'e') {
+              token = Token::NEW;
+            }
+            break;
+        }
+        break;
+      case 4:
+        // else case true byte null this
+        // void with long enum char goto
+        // number 3 character is most duplicated
+        switch (buf[3]) {
+          case 'e':
+            // else case true byte
+            if (buf[2] == 's') {
+              if (buf[0] == 'e' && buf[1] == 'l') {
+                // else
+                token = Token::ELSE;
+              } else if (buf[0] == 'c' && buf[1] == 'a') {
+                // case
+                token = Token::CASE;
+              }
+            } else if (buf[0] == 't' &&
+                       buf[1] == 'r' && buf[2] == 'u') {
+              // true
+              token = Token::TRUE_LITERAL;
+            } else if (buf[0] == 'b' &&
+                       buf[1] == 'y' && buf[2] == 't') {
+              // byte (removed)
+              // token = Token::BYTE;
+            }
+            break;
+          case 'l':
+            // null
+            if (buf[0] == 'n' &&
+                buf[1] == 'u' && buf[2] == 'l') {
+              token = Token::NULL_LITERAL;
+            }
+            break;
+          case 's':
+            // this
+            if (buf[0] == 't' &&
+                buf[1] == 'h' && buf[2] == 'i') {
+              token = Token::THIS;
+            }
+            break;
+          case 'd':
+            // void
+            if (buf[0] == 'v' &&
+                buf[1] == 'o' && buf[2] == 'i') {
+              token = Token::VOID;
+            }
+            break;
+          case 'h':
+            // with
+            if (buf[0] == 'w' &&
+                buf[1] == 'i' && buf[2] == 't') {
+              token = Token::WITH;
+            }
+            break;
+          case 'g':
+            // long (removed)
+            if (buf[0] == 'l' &&
+                buf[1] == 'o' && buf[2] == 'n') {
+              // token = Token::LONG;
+            }
+            break;
+          case 'm':
+            // enum
+            if (buf[0] == 'e' &&
+                buf[1] == 'n' && buf[2] == 'u') {
+              token = Token::ENUM;
+            }
+            break;
+          case 'r':
+            // char (removed)
+            if (buf[0] == 'c' &&
+                buf[1] == 'h' && buf[2] == 'a') {
+              // token = Token::CHAR;
+            }
+            break;
+          case 'o':
+            // goto (removed)
+            if (buf[0] == 'g' &&
+                buf[1] == 'o' && buf[2] == 't') {
+              // token = Token::GOTO;
+            }
+            break;
+        }
+        break;
+      case 5:
+        // break final float catch super while
+        // throw short class const false yield
+        // number 3 character is most duplicated
+        switch (buf[3]) {
+          case 'a':
+            // break final float
+            if (buf[0] == 'b' && buf[1] == 'r' &&
+                buf[2] == 'e' && buf[4] == 'k') {
+              // break
+              token = Token::BREAK;
+            } else if (buf[0] == 'f') {
+              if (buf[1] == 'i' &&
+                  buf[2] == 'n' && buf[4] == 'l') {
+                // final (removed)
+                // token = Token::FINAL;
+              } else if (buf[1] == 'l' &&
+                         buf[2] == 'o' && buf[4] == 't') {
+                // float (removed)
+                // token = Token::FLOAT;
+              }
+            }
+            break;
+          case 'c':
+            if (buf[0] == 'c' && buf[1] == 'a' &&
+                buf[2] == 't' && buf[4] == 'h') {
+              // catch
+              token = Token::CATCH;
+            }
+            break;
+          case 'e':
+            if (buf[0] == 's' && buf[1] == 'u' &&
+                buf[2] == 'p' && buf[4] == 'r') {
+              // super
+              token = Token::SUPER;
+            }
+            break;
+          case 'l':
+            if (buf[0] == 'w' && buf[1] == 'h' &&
+                buf[2] == 'i' && buf[4] == 'e') {
+              // while
+              token = Token::WHILE;
+            } else if (strict &&
+                       buf[0] == 'y' && buf[1] == 'i' &&
+                       buf[2] == 'e' && buf[4] == 'd') {
+              // yield
+              token = Token::YIELD;
+            }
+            break;
+          case 'o':
+            if (buf[0] == 't' && buf[1] == 'h' &&
+                buf[2] == 'r' && buf[4] == 'w') {
+              // throw
+              token = Token::THROW;
+            }
+            break;
+          case 'r':
+            if (buf[0] == 's' && buf[1] == 'h' &&
+                buf[2] == 'o' && buf[4] == 't') {
+              // short (removed)
+              // token = Token::SHORT;
+            }
+            break;
+          case 's':
+            // class const false
+            if (buf[0] == 'c') {
+              if (buf[1] == 'l' &&
+                  buf[2] == 'a' && buf[4] == 's') {
+                // class
+                token = Token::CLASS;
+              } else if (buf[1] == 'o' &&
+                         buf[2] == 'n' && buf[4] == 't') {
+                // const
+                token = Token::CONST;
+              }
+            } else if (buf[0] == 'f' && buf[1] == 'a' &&
+                       buf[2] == 'l' && buf[4] == 'e') {
+              // false
+              token = Token::FALSE_LITERAL;
+            }
+            break;
+        }
+        break;
+      case 6:
+        // double delete export import native
+        // public return static switch typeof throws
+        // number 0 character is most duplicated
+        switch (buf[0]) {
+          case 'd':
+            // double delete
+            if (buf[5] == 'e' &&
+                buf[4] == 'l' && buf[3] == 'b' &&
+                buf[2] == 'u' && buf[1] == 'o') {
+              // double
+              // token = Token::DOUBLE;
+            } else if (buf[5] == 'e' &&
+                       buf[4] == 't' && buf[3] == 'e' &&
+                       buf[2] == 'l' && buf[1] == 'e') {
+              // delete
+              token = Token::DELETE;
+            }
+            break;
+          case 'e':
+            // export
+            token = IsMatch("export", buf, Token::EXPORT);
+            break;
+          case 'i':
+            // import
+            token = IsMatch("import", buf, Token::IMPORT);
+            break;
+          case 'n':
+            // native (removed)
+            // token = IsMatch("native", buf, Token::NATIVE);
+            break;
+          case 'p':
+            // public
+            token = IsMatch("public", buf, Token::PUBLIC, strict);
+            break;
+          case 'r':
+            // return
+            token = IsMatch("return", buf, Token::RETURN);
+            break;
+          case 's':
+            // switch static
+            if (buf[1] == 'w' &&
+                buf[2] == 'i' && buf[3] == 't' &&
+                buf[4] == 'c' && buf[5] == 'h') {
+              // switch
+              token = Token::SWITCH;
+            } else if (strict &&
+                       buf[1] == 't' &&
+                       buf[2] == 'a' && buf[3] == 't' &&
+                       buf[4] == 'i' && buf[5] == 'c') {
+              // static
+              token = Token::STATIC;
+            }
+            break;
+          case 't':
+            // typeof throws
+            if (buf[5] == 'f' &&
+                buf[4] == 'o' && buf[3] == 'e' &&
+                buf[2] == 'p' && buf[1] == 'y') {
+              // typeof
+              token = Token::TYPEOF;
+            } else if (buf[5] == 's' &&
+                       buf[4] == 'w' && buf[3] == 'o' &&
+                       buf[2] == 'r' && buf[1] == 'h') {
+              // throws (removed)
+              // token = Token::THROWS;
+            }
+            break;
+        }
+        break;
+      case 7:
+        // boolean default extends finally package private
+        // number 0 character is most duplicated
+        switch (buf[0]) {
+          case 'b':
+            // boolean (removed)
+            // token = IsMatch("boolean", buf, Token::BOOLEAN);
+            break;
+          case 'd':
+            token = IsMatch("default", buf, Token::DEFAULT);
+            break;
+          case 'e':
+            token = IsMatch("extends", buf, Token::EXTENDS);
+            break;
+          case 'f':
+            token = IsMatch("finally", buf, Token::FINALLY);
+            break;
+          case 'p':
+            if (buf[1] == 'a') {
+              token = IsMatch("package", buf, Token::PACKAGE, strict);
+            } else if (buf[1] == 'r') {
+              token = IsMatch("private", buf, Token::PRIVATE, strict);
+            }
+            break;
+        }
+        break;
+      case 8:
+        // debugger continue abstract volatile function
+        // number 4 character is most duplicated
+        switch (buf[4]) {
+          case 'g':
+            token = IsMatch("debugger", buf, Token::DEBUGGER);
+            break;
+          case 'i':
+            token = IsMatch("continue", buf, Token::CONTINUE);
+            break;
+          case 'r':
+            // abstract (removed)
+            // token = IsMatch("abstract", buf, Token::ABSTRACT);
+            break;
+          case 't':
+            if (buf[1] == 'o') {
+              // token = IsMatch("volatile", buf, Token::VOLATILE);
+            } else if (buf[1] == 'u') {
+              token = IsMatch("function", buf, Token::FUNCTION);
+            }
+            break;
+        }
+        break;
+      case 9:
+        // interface protected transient
+        if (buf[1] == 'n') {
+          token = IsMatch("interface", buf, Token::INTERFACE, strict);
+        } else if (buf[1] == 'r') {
+          if (buf[0] == 'p') {
+            token = IsMatch("protected", buf, Token::PROTECTED, strict);
+          } else if (buf[0] == 't') {
+            // transient (removed)
+            // token = IsMatch("transient", buf, Token::TRANSIENT);
+          }
+        }
+        break;
+      case 10:
+        // instanceof implements
+        if (buf[1] == 'n') {
+          token = IsMatch("instanceof", buf, Token::INSTANCEOF);
+        } else if (buf[1] == 'm') {
+          token = IsMatch("implements", buf, Token::IMPLEMENTS, strict);
+        }
+        break;
+      case 12:
+        // synchronized (removed)
+        // token = IsMatch("synchronized", buf, Token::SYNCHRONIZED);
+        token = Token::IDENTIFIER;
+        break;
+    }
+    return token;
+  }
+
+  template<typename Buffer>
+  static inline Token::Type IsMatch(char const * keyword,
+                                    const Buffer& buf,
+                                    Token::Type guess,
+                                    bool strict) {
+    if (!strict) {
+      return Token::IDENTIFIER;
+    }
+    typename Buffer::const_iterator it = buf.begin();
+    const typename Buffer::const_iterator last = buf.end();
+    do {
+      if (*it++ != *keyword++) {
+        return Token::IDENTIFIER;
+      }
+    } while (it != last);
+    return guess;
+  }
+
+  template<typename Buffer>
+  static inline Token::Type IsMatch(char const * keyword,
+                                    const Buffer& buf,
+                                    Token::Type guess) {
+    typename Buffer::const_iterator it = buf.begin();
+    const typename Buffer::const_iterator last = buf.end();
+    do {
+      if (*it++ != *keyword++) {
+        return Token::IDENTIFIER;
+      }
+    } while (it != last);
+    return guess;
+  }
+};
+
+template<>
+class Keyword<IgnoreReservedWords> {
+ public:
+  template<typename Buffer>
+  static inline Token::Type Detect(const Buffer& buf, bool strict) {
+    return Token::IDENTIFIER;
+  }
+};
+
+template<>
+class Keyword<IgnoreReservedWordsAndIdentifyGetterOrSetter> {
+ public:
+  template<typename Buffer>
+  static inline Token::Type Detect(const Buffer& buf, bool strict) {
+    if (buf.size() == 3) {
+      if (buf[1] == 'e' && buf[2] == 't') {
+        if (buf[0] == 'g') {
+          return Token::GET;
+        } else if (buf[0] == 's') {
+          return Token::SET;
+        }
+      }
+    }
+    return Token::IDENTIFIER;
+  }
+};
+
+
+
+} } }  // namespace iv::core::detail
+#endif  // _IV_KEYWORD_H_