iv-phonic 0.0.9 → 0.1.0

data/Rakefile

@@ -6,7 +6,7 @@ require 'hoe'
 require 'pp'
 $root = File.dirname(__FILE__)
 $name = 'iv-phonic'
-$version = '0.0.9'
+$version = '0.1.0'
 
 directory "ext/include/iv"
 

data/ext/include/iv/ast.h

@@ -116,6 +116,10 @@ class AstNode : public AstNodeBase<Factory> {
  public:
   virtual ~AstNode() = 0;
 
+  typedef typename SpaceVector<Factory, Statement<Factory>*>::type Statements;
+  typedef typename SpaceVector<Factory, Identifier<Factory>*>::type Identifiers;
+  typedef typename SpaceVector<Factory, Expression<Factory>*>::type Expressions;
+
   STATEMENT_NODE_LIST(DECLARE_NODE_TYPE_BASE)
   EXPRESSION_NODE_LIST(DECLARE_NODE_TYPE_BASE)
 
@@ -210,7 +214,8 @@ class Inherit<Factory, kNamedOnlyBreakableStatement>
 INHERIT(NamedOnlyBreakableStatement);
 
 template<typename Factory>
-class NamedOnlyBreakableStatement : public NamedOnlyBreakableStatementBase<Factory> {
+class NamedOnlyBreakableStatement
+  : public NamedOnlyBreakableStatementBase<Factory> {
  public:
   DECLARE_NODE_TYPE(NamedOnlyBreakableStatement)
 };
@@ -223,7 +228,8 @@ class Inherit<Factory, kAnonymousBreakableStatement>
 INHERIT(AnonymousBreakableStatement);
 
 template<typename Factory>
-class AnonymousBreakableStatement : public AnonymousBreakableStatementBase<Factory> {
+class AnonymousBreakableStatement
+  : public AnonymousBreakableStatementBase<Factory> {
  public:
   DECLARE_NODE_TYPE(AnonymousBreakableStatement)
 };
@@ -238,20 +244,15 @@ INHERIT(Block);
 template<typename Factory>
 class Block : public BlockBase<Factory> {
  public:
-  typedef typename SpaceVector<Factory, Statement<Factory>*>::type Statements;
-  explicit Block(Factory* factory)
-     : body_(typename Statements::allocator_type(factory)) { }
-
-  void AddStatement(Statement<Factory>* stmt) {
-    body_.push_back(stmt);
-  }
-
+  typedef typename AstNode<Factory>::Statements Statements;
+  explicit Block(Statements* body)
+     : body_(body) { }
   inline const Statements& body() const {
-    return body_;
+    return *body_;
   }
   DECLARE_DERIVED_NODE_TYPE(Block)
  private:
-  Statements body_;
+  Statements* body_;
 };
 
 // FunctionStatement
@@ -309,16 +310,11 @@ class VariableStatement : public VariableStatementBase<Factory> {
   typedef typename SpaceVector<
             Factory,
             Declaration<Factory>*>::type Declarations;
-  VariableStatement(Token::Type type, Factory* factory)
+  VariableStatement(Token::Type type, Declarations* decls)
     : is_const_(type == Token::CONST),
-      decls_(typename Declarations::allocator_type(factory)) { }
-
-  void AddDeclaration(Declaration<Factory>* decl) {
-    decls_.push_back(decl);
-  }
-
+      decls_(decls) { }
   inline const Declarations& decls() const {
-    return decls_;
+    return *decls_;
   }
   inline bool IsConst() const {
     return is_const_;
@@ -326,7 +322,7 @@ class VariableStatement : public VariableStatementBase<Factory> {
   DECLARE_DERIVED_NODE_TYPE(VariableStatement)
  private:
   const bool is_const_;
-  Declarations decls_;
+  Declarations* decls_;
 };
 
 // Declaration
@@ -649,16 +645,14 @@ INHERIT(CaseClause);
 template<typename Factory>
 class CaseClause : public CaseClauseBase<Factory> {
  public:
-  typedef typename SpaceVector<Factory, Statement<Factory>*>::type Statements;
+  typedef typename AstNode<Factory>::Statements Statements;
   explicit CaseClause(bool is_default,
-                      Expression<Factory>* expr, Factory* factory)
+                      Expression<Factory>* expr,
+                      Statements* body)
     : expr_(expr),
-      body_(typename Statements::allocator_type(factory)),
+      body_(body),
       default_(is_default) {
   }
-  void AddStatement(Statement<Factory>* stmt) {
-    body_.push_back(stmt);
-  }
   inline bool IsDefault() const {
     return default_;
   }
@@ -666,11 +660,11 @@ class CaseClause : public CaseClauseBase<Factory> {
     return expr_;
   }
   inline const Statements& body() const {
-    return body_;
+    return *body_;
   }
  private:
   Expression<Factory>* expr_;
-  Statements body_;
+  Statements* body_;
   bool default_;
 };
 
@@ -686,20 +680,16 @@ class SwitchStatement : public SwitchStatementBase<Factory> {
  public:
   typedef typename SpaceVector<Factory, CaseClause<Factory>*>::type CaseClauses;
   SwitchStatement(Expression<Factory>* expr,
-                  Factory* factory)
+                  CaseClauses* clauses)
     : expr_(expr),
-      clauses_(typename CaseClauses::allocator_type(factory)) {
-  }
-
-  void AddCaseClause(CaseClause<Factory>* clause) {
-    clauses_.push_back(clause);
+      clauses_(clauses) {
   }
   inline Expression<Factory>* expr() const { return expr_; }
-  inline const CaseClauses& clauses() const { return clauses_; }
+  inline const CaseClauses& clauses() const { return *clauses_; }
   DECLARE_DERIVED_NODE_TYPE(SwitchStatement)
  private:
   Expression<Factory>* expr_;
-  CaseClauses clauses_;
+  CaseClauses* clauses_;
 };
 
 // ThrowStatement
@@ -914,8 +904,7 @@ class StringLiteral : public StringLiteralBase<Factory> {
  public:
   typedef typename SpaceUString<Factory>::type value_type;
   StringLiteral(const std::vector<uc16>& buffer,
-                Factory* factory)
-  {
+                Factory* factory) {
     InitializeStringLiteral(buffer, factory);
   }
 
@@ -1133,23 +1122,22 @@ class Inherit<Factory, kArrayLiteral>
 };
 INHERIT(ArrayLiteral);
 
+
+// items is NULL able
 template<typename Factory>
 class ArrayLiteral : public ArrayLiteralBase<Factory> {
  public:
-  typedef typename SpaceVector<Factory, Expression<Factory>*>::type Expressions;
+  typedef typename AstNode<Factory>::Expressions Expressions;
 
-  explicit ArrayLiteral(Factory* factory)
-    : items_(typename Expressions::allocator_type(factory)) {
-  }
-  inline void AddItem(Expression<Factory>* expr) {
-    items_.push_back(expr);
+  explicit ArrayLiteral(Expressions* items)
+    : items_(items) {
   }
   inline const Expressions& items() const {
-    return items_;
+    return *items_;
   }
   DECLARE_DERIVED_NODE_TYPE(ArrayLiteral)
  private:
-  Expressions items_;
+  Expressions* items_;
 };
 
 // ObjectLiteral
@@ -1171,30 +1159,30 @@ class ObjectLiteral : public ObjectLiteralBase<Factory> {
                           Identifier<Factory>*,
                           Expression<Factory>*> Property;
   typedef typename SpaceVector<Factory, Property>::type Properties;
-  explicit ObjectLiteral(Factory* factory)
-    : properties_(typename Properties::allocator_type(factory)) {
+  explicit ObjectLiteral(Properties* properties)
+    : properties_(properties) {
   }
 
-  inline void AddDataProperty(Identifier<Factory>* key,
-                              Expression<Factory>* val) {
-    AddPropertyDescriptor(DATA, key, val);
+  static inline void AddDataProperty(Properties* prop,
+                                     Identifier<Factory>* key,
+                                     Expression<Factory>* val) {
+    prop->push_back(std::tr1::make_tuple(DATA, key, val));
   }
-  inline void AddAccessor(PropertyDescriptorType type,
-                          Identifier<Factory>* key,
-                          Expression<Factory>* val) {
-    AddPropertyDescriptor(type, key, val);
+
+  static inline void AddAccessor(Properties* prop,
+                                 PropertyDescriptorType type,
+                                 Identifier<Factory>* key,
+                                 Expression<Factory>* val) {
+    prop->push_back(std::tr1::make_tuple(type, key, val));
   }
+
   inline const Properties& properties() const {
-    return properties_;
+    return *properties_;
   }
   DECLARE_DERIVED_NODE_TYPE(ObjectLiteral)
+
  private:
-  inline void AddPropertyDescriptor(PropertyDescriptorType type,
-                                    Identifier<Factory>* key,
-                                    Expression<Factory>* val) {
-    properties_.push_back(std::tr1::make_tuple(type, key, val));
-  }
-  Properties properties_;
+  Properties* properties_;
 };
 
 // FunctionLiteral
@@ -1207,8 +1195,8 @@ INHERIT(FunctionLiteral);
 template<typename Factory>
 class FunctionLiteral : public FunctionLiteralBase<Factory> {
  public:
-  typedef typename SpaceVector<Factory, Statement<Factory>*>::type Statements;
-  typedef typename SpaceVector<Factory, Identifier<Factory>*>::type Identifiers;
+  typedef typename AstNode<Factory>::Statements Statements;
+  typedef typename AstNode<Factory>::Identifiers Identifiers;
   enum DeclType {
     DECLARATION,
     STATEMENT,
@@ -1369,19 +1357,18 @@ INHERIT(FunctionCall);
 template<typename Factory>
 class FunctionCall : public FunctionCallBase<Factory> {
  public:
-  typedef typename SpaceVector<Factory, Expression<Factory>*>::type Expressions;
+  typedef typename AstNode<Factory>::Expressions Expressions;
   FunctionCall(Expression<Factory>* target,
-               Factory* factory)
+               Expressions* args)
     : target_(target),
-      args_(typename Expressions::allocator_type(factory)) {
+      args_(args) {
   }
-  void AddArgument(Expression<Factory>* expr) { args_.push_back(expr); }
   inline Expression<Factory>* target() const { return target_; }
-  inline const Expressions& args() const { return args_; }
+  inline const Expressions& args() const { return *args_; }
   DECLARE_DERIVED_NODE_TYPE(FunctionCall)
  private:
   Expression<Factory>* target_;
-  Expressions args_;
+  Expressions* args_;
 };
 
 // ConstructorCall
@@ -1394,19 +1381,18 @@ INHERIT(ConstructorCall);
 template<typename Factory>
 class ConstructorCall : public ConstructorCallBase<Factory> {
  public:
-  typedef typename SpaceVector<Factory, Expression<Factory>*>::type Expressions;
+  typedef typename AstNode<Factory>::Expressions Expressions;
   ConstructorCall(Expression<Factory>* target,
-                  Factory* factory)
+                  Expressions* args)
     : target_(target),
-      args_(typename Expressions::allocator_type(factory)) {
+      args_(args) {
   }
-  void AddArgument(Expression<Factory>* expr) { args_.push_back(expr); }
   inline Expression<Factory>* target() const { return target_; }
-  inline const Expressions& args() const { return args_; }
+  inline const Expressions& args() const { return *args_; }
   DECLARE_DERIVED_NODE_TYPE(ConstructorCall)
  private:
   Expression<Factory>* target_;
-  Expressions args_;
+  Expressions* args_;
 };
 
 } } }  // namespace iv::core::ast

data/ext/include/iv/ast_factory.h

@@ -79,26 +79,25 @@ class BasicAstFactory {
         FunctionLiteral(type, static_cast<Factory*>(this));
   }
 
-  ArrayLiteral* NewArrayLiteral() {
-    return new (static_cast<Factory*>(this))
-        ArrayLiteral(static_cast<Factory*>(this));
+  ArrayLiteral* NewArrayLiteral(Expressions* items) {
+    return new (static_cast<Factory*>(this)) ArrayLiteral(items);
   }
 
-  ObjectLiteral* NewObjectLiteral() {
-    return new (static_cast<Factory*>(this))
-        ObjectLiteral(static_cast<Factory*>(this));
+  ObjectLiteral*
+      NewObjectLiteral(typename ObjectLiteral::Properties* properties) {
+    return new (static_cast<Factory*>(this)) ObjectLiteral(properties);
   }
 
   template<typename T>
   T** NewPtr() {
-    return new (static_cast<Factory*>(this)->New(sizeof(T*))) T*(NULL);
+    return new (static_cast<Factory*>(this)->New(sizeof(T*))) T*(NULL);  // NOLINT
   }
 
-  Identifiers* NewLabels() {
-    void* place = static_cast<Factory*>(this)->New(sizeof(Identifiers));
-    return new (place)
-        Identifiers(
-            typename Identifiers::allocator_type(static_cast<Factory*>(this)));
+  template<typename T>
+  typename SpaceVector<Factory, T>::type* NewVector() {
+    typedef typename SpaceVector<Factory, T>::type Vector;
+    return new (static_cast<Factory*>(this)->New(sizeof(Vector)))
+        Vector(typename Vector::allocator_type(static_cast<Factory*>(this)));
   }
 
   NullLiteral* NewNullLiteral() {
@@ -137,13 +136,14 @@ class BasicAstFactory {
     return new (static_cast<Factory*>(this)) FunctionDeclaration(func);
   }
 
-  Block* NewBlock() {
-    return new (static_cast<Factory*>(this)) Block(static_cast<Factory*>(this));
+  Block* NewBlock(Statements* body) {
+    return new (static_cast<Factory*>(this)) Block(body);
   }
 
-  VariableStatement* NewVariableStatement(Token::Type token) {
+  VariableStatement* NewVariableStatement(Token::Type token,
+                                          Declarations* decls) {
     return new (static_cast<Factory*>(this))
-        VariableStatement(token, static_cast<Factory*>(this));
+        VariableStatement(token, decls);
   }
 
   Declaration* NewDeclaration(Identifier* name, Expression* expr) {
@@ -207,14 +207,13 @@ class BasicAstFactory {
     return new (static_cast<Factory*>(this)) WithStatement(expr, stmt);
   }
 
-  SwitchStatement* NewSwitchStatement(Expression* expr) {
-    return new (static_cast<Factory*>(this))
-        SwitchStatement(expr, static_cast<Factory*>(this));
+  SwitchStatement* NewSwitchStatement(Expression* expr, CaseClauses* clauses) {
+    return new (static_cast<Factory*>(this)) SwitchStatement(expr, clauses);
   }
 
-  CaseClause* NewCaseClause(bool is_default, Expression* expr) {
-    return new (static_cast<Factory*>(this))
-        CaseClause(is_default, expr, static_cast<Factory*>(this));
+  CaseClause* NewCaseClause(bool is_default,
+                            Expression* expr, Statements* body) {
+    return new (static_cast<Factory*>(this)) CaseClause(is_default, expr, body);
   }
 
   ThrowStatement*  NewThrowStatement(Expression* expr) {
@@ -264,14 +263,12 @@ class BasicAstFactory {
     return new (static_cast<Factory*>(this)) PostfixExpression(op, expr);
   }
 
-  FunctionCall* NewFunctionCall(Expression* expr) {
-    return new (static_cast<Factory*>(this))
-        FunctionCall(expr, static_cast<Factory*>(this));
+  FunctionCall* NewFunctionCall(Expression* expr, Expressions* args) {
+    return new (static_cast<Factory*>(this)) FunctionCall(expr, args);
   }
 
-  ConstructorCall* NewConstructorCall(Expression* target) {
-    return new (static_cast<Factory*>(this))
-        ConstructorCall(target, static_cast<Factory*>(this));
+  ConstructorCall* NewConstructorCall(Expression* target, Expressions* args) {
+    return new (static_cast<Factory*>(this)) ConstructorCall(target, args);
   }
 
   IndexAccess* NewIndexAccess(Expression* expr,

data/ext/include/iv/character.h

@@ -724,8 +724,8 @@ inline Category GetCategory(uint16_t c) {
     return static_cast<Category>(kCategoryCache[c]);
   }
   const int result =
-      upper_bound(kCategoryKeys.begin(),
-                  kCategoryKeys.end(), c) - kCategoryKeys.begin() - 1;
+      static_cast<int>(upper_bound(kCategoryKeys.begin(),
+                                   kCategoryKeys.end(), c) - kCategoryKeys.begin() - 1);
   assert(result < static_cast<int>(kCategoryKeys.size()));
   const int high = kCategoryValues[result * 2];
   if (c <= high) {
@@ -816,7 +816,7 @@ inline uint16_t ToLowerCase(uint16_t c) {
   std::tr1::array<uint16_t, 101>::const_iterator it =
       upper_bound(kLowerCaseKeys.begin(),
                   kLowerCaseKeys.end(), c) - 1;
-  const int result = it - kLowerCaseKeys.begin();
+  const int result = static_cast<int>(it - kLowerCaseKeys.begin());
   assert(result < 101);
   if (result >= 0) {
     bool by2 = false;
@@ -852,7 +852,7 @@ inline uint16_t ToUpperCase(uint16_t c) {
   std::tr1::array<uint16_t, 113>::const_iterator it =
       upper_bound(kUpperCaseKeys.begin(),
                   kUpperCaseKeys.end(), c) - 1;
-  const int result = it - kUpperCaseKeys.begin();
+  const int result = static_cast<int>(it - kUpperCaseKeys.begin());
   assert(result < 113);
   if (result >= 0) {
     bool by2 = false;

data/ext/include/iv/cmdline.h

@@ -390,7 +390,6 @@ class Parser {
         def_(def) {
       description_ = full_description(desc);
     }
-    ~option_with_value() { }
 
     const T& get() const {
       return def_;
@@ -458,6 +457,81 @@ class Parser {
     std::string description_;
   };
 
+  template <class T>
+  class option_with_value_list : public option_base {
+   public:
+    option_with_value_list(const std::string& name,
+                           char short_name,
+                           const std::string& desc)
+      : name_(name),
+        short_name_(short_name),
+        has_(false),
+        def_() {
+      description_ = full_description(desc);
+    }
+
+    const std::vector<T>& get() const {
+      return def_;
+    }
+
+    bool has_value() const { return true; }
+
+    bool set() {
+      return false;
+    }
+
+    bool set(const std::string& value) {
+      try {
+        def_.push_back(read(value));
+        has_ = true;
+      } catch(const std::exception &e) {
+        return false;
+      }
+      return true;
+    }
+
+    bool has_set() const {
+      return has_;
+    }
+
+    bool valid() const {
+      return true;
+    }
+
+    bool must() const {
+      return false;
+    }
+
+    const std::string& name() const {
+      return name_;
+    }
+
+    char short_name() const {
+      return short_name_;
+    }
+
+    const std::string& description() const {
+      return description_;
+    }
+
+    std::string short_description() const {
+      return "--"+name_+"="+detail::readable_typename<T>();
+    }
+
+   protected:
+    std::string full_description(const std::string& desc) {
+      return desc;
+    }
+
+    virtual T read(const std::string& s) = 0;
+
+    std::string name_;
+    char short_name_;
+    bool has_;
+    std::vector<T> def_;
+    std::string description_;
+  };
+
   template <class T, class F>
   class option_with_value_with_reader : public option_with_value<T> {
    public:
@@ -479,6 +553,25 @@ class Parser {
     F reader;
   };
 
+  template <class T, class F>
+  class option_with_value_list_with_reader : public option_with_value_list<T> {
+   public:
+    option_with_value_list_with_reader(const std::string& name,
+                                       char short_name,
+                                       const std::string& desc,
+                                       F reader)
+      : option_with_value_list<T>(name, short_name, desc),
+        reader_(reader) {
+    }
+
+   private:
+    T read(const std::string& s) {
+      return reader_(s);
+    }
+
+    F reader_;
+  };
+
  public:
   typedef std::map<std::string, option_base*> OptionMap;
   typedef std::vector<option_base*> OptionVector;
@@ -534,6 +627,28 @@ class Parser {
     ordered_.push_back(ptr);
   }
 
+  template <class T>
+  void AddList(const std::string& key,
+               const std::string& name = "",
+               char short_name = 0,
+               const std::string& desc = "") {
+    AddList<T>(key, name, short_name, desc, default_reader<T>());
+  }
+
+  template <class T, class F>
+  void AddList(const std::string& key,
+               const std::string& name = "",
+               char short_name = 0,
+               const std::string& desc = "",
+               F reader = F()) {
+    assert(options_.count(key) == 0);
+    option_base* const ptr =
+        new option_with_value_list_with_reader<T, F>(
+            name, short_name, desc, reader);
+    options_[key] = ptr;
+    ordered_.push_back(ptr);
+  }
+
   void set_footer(const std::string& f) {
     footer_ = f;
   }
@@ -549,7 +664,7 @@ class Parser {
   }
 
   template <class T>
-  const T& get(const std::string& key) const {
+  const T& Get(const std::string& key) const {
     const OptionMap::const_iterator it = options_.find(key);
     assert(it != options_.end());
     const option_with_value<T> *p = dynamic_cast<  //NOLINT
@@ -558,6 +673,16 @@ class Parser {
     return p->get();
   }
 
+  template<typename T>
+  const std::vector<T>& GetList(const std::string& key) const {
+    const OptionMap::const_iterator it = options_.find(key);
+    assert(it != options_.end());
+    const option_with_value_list<T> *p = dynamic_cast<  //NOLINT
+        const option_with_value_list<T>*>(it->second);
+    assert(p != NULL);
+    return p->get();
+  }
+
   const std::vector<std::string>& rest() const {
     return others_;
   }

data/ext/include/iv/conversions.h

@@ -8,7 +8,6 @@
 #include <tr1/cstdint>
 #include <tr1/cmath>
 #include "character.h"
-#include "dtoa.h"
 #include "ustringpiece.h"
 #include "none.h"
 namespace iv {
@@ -18,6 +17,7 @@ template<typename T>
 class Conversions {
  public:
   static const double kNaN;
+  static const double kInf;
   static const int kMaxSignificantDigits = 772;
   static const std::string kInfinity;
   static const double DoubleToInt32_Two32;
@@ -28,6 +28,9 @@ class Conversions {
 template<typename T>
 const double Conversions<T>::kNaN = std::numeric_limits<double>::quiet_NaN();
 
+template<typename T>
+const double Conversions<T>::kInf = std::numeric_limits<double>::infinity();
+
 template<typename T>
 const std::string Conversions<T>::kInfinity = "Infinity";
 
@@ -346,7 +349,8 @@ inline double StringToIntegerWithRadix(Iter it, Iter last,
     return Conversions::kNaN;
   }
 
-  double result = 0;
+  // TODO(Constellation) precision version
+  double result = 0.0;
   const Iter start = it;
   for (; it != last; ++it) {
     const int val = Radix36Value(*it);
@@ -371,6 +375,25 @@ inline double StringToIntegerWithRadix(const UStringPiece& range,
                                   radix, strip_prefix);
 }
 
+template<typename Iter>
+inline double ParseIntegerOverflow(Iter it, Iter last, int radix) {
+  double number = 0.0;
+  double multiplier = 1.0;
+  for (--it, --last; last != it; --last) {
+    if (multiplier == Conversions::kInf) {
+      if (*last != '0') {
+        number = Conversions::kInf;
+        break;
+      }
+    } else {
+      const int digit = Radix36Value(*last);
+      number += digit * multiplier;
+    }
+    multiplier *= radix;
+  }
+  return number;
+}
+
 inline std::size_t StringToHash(const UStringPiece& x) {
   std::size_t len = x.size();
   std::size_t step = (len >> 5) + 1;