iv-phonic 0.1.0 → 0.1.1

data/Rakefile

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

data/ext/include/iv/ast.h

@@ -61,7 +61,8 @@ class type##Base\
 }
 
 template<typename Factory>
-class Scope : private Noncopyable<Scope<Factory> >::type {
+class Scope : public SpaceObject,
+              private Noncopyable<Scope<Factory> >::type {
  public:
   typedef std::pair<Identifier<Factory>*, bool> Variable;
   typedef typename SpaceVector<Factory, Variable>::type Variables;
@@ -328,8 +329,7 @@ class VariableStatement : public VariableStatementBase<Factory> {
 // Declaration
 template<typename Factory>
 class Inherit<Factory, kDeclaration>
-  : public SpaceObject,
-    private Noncopyable<Inherit<Factory, kDeclaration> >::type {
+  : public AstNode<Factory> {
 };
 INHERIT(Declaration);
 
@@ -346,6 +346,7 @@ class Declaration : public DeclarationBase<Factory> {
   inline Expression<Factory>* expr() const {
     return expr_;
   }
+  DECLARE_DERIVED_NODE_TYPE(Declaration)
  private:
   Identifier<Factory>* name_;
   Expression<Factory>* expr_;
@@ -636,9 +637,7 @@ class LabelledStatement : public LabelledStatementBase<Factory> {
 
 // CaseClause
 template<typename Factory>
-class Inherit<Factory, kCaseClause>
-  : public SpaceObject,
-    private Noncopyable<Inherit<Factory, kCaseClause> >::type {
+class Inherit<Factory, kCaseClause> : public AstNode<Factory> {
 };
 INHERIT(CaseClause);
 
@@ -662,6 +661,7 @@ class CaseClause : public CaseClauseBase<Factory> {
   inline const Statements& body() const {
     return *body_;
   }
+  DECLARE_DERIVED_NODE_TYPE(CaseClause)
  private:
   Expression<Factory>* expr_;
   Statements* body_;
@@ -1208,28 +1208,18 @@ class FunctionLiteral : public FunctionLiteralBase<Factory> {
     SETTER,
     GETTER
   };
-  inline void SetName(Identifier<Factory>* name) { name_ = name; }
   inline Identifier<Factory>* name() const {
     return name_;
   }
   inline DeclType type() const { return type_; }
   inline const Identifiers& params() const {
-    return params_;
+    return *params_;
   }
   inline const Statements& body() const {
-    return body_;
-  }
-  inline Scope<Factory>* scope() {
-    return &scope_;
+    return *body_;
   }
   inline const Scope<Factory>& scope() const {
-    return scope_;
-  }
-  inline void set_start_position(std::size_t start) {
-    start_position_ = start;
-  }
-  inline void set_end_position(std::size_t end) {
-    end_position_ = end;
+    return *scope_;
   }
   inline std::size_t start_position() const {
     return start_position_;
@@ -1240,32 +1230,30 @@ class FunctionLiteral : public FunctionLiteralBase<Factory> {
   inline bool strict() const {
     return strict_;
   }
-  inline void set_strict(bool strict) {
-    strict_ = strict;
-  }
-  FunctionLiteral(DeclType type, Factory* factory)
-    : name_(NULL),
+  FunctionLiteral(DeclType type,
+                  Identifier<Factory>* name,
+                  Identifiers* params,
+                  Statements* body,
+                  Scope<Factory>* scope,
+                  bool strict,
+                  std::size_t start_position,
+                  std::size_t end_position)
+    : name_(name),
       type_(type),
-      params_(typename Identifiers::allocator_type(factory)),
-      body_(typename Statements::allocator_type(factory)),
-      scope_(factory, type == GLOBAL),
-      strict_(false) {
-  }
-
-  void AddParameter(Identifier<Factory>* param) {
-    params_.push_back(param);
-  }
-
-  void AddStatement(Statement<Factory>* stmt) {
-    body_.push_back(stmt);
+      params_(params),
+      body_(body),
+      scope_(scope),
+      strict_(strict),
+      start_position_(start_position),
+      end_position_(end_position) {
   }
   DECLARE_DERIVED_NODE_TYPE(FunctionLiteral)
  private:
   Identifier<Factory>* name_;
   DeclType type_;
-  Identifiers params_;
-  Statements body_;
-  Scope<Factory> scope_;
+  Identifiers* params_;
+  Statements* body_;
+  Scope<Factory>* scope_;
   bool strict_;
   std::size_t start_position_;
   std::size_t end_position_;

data/ext/include/iv/ast_factory.h

@@ -49,42 +49,73 @@ class BasicAstFactory {
   }
 
   template<typename Range>
-  Identifier* NewIdentifier(const Range& range) {
+  Identifier* NewIdentifier(const Range& range,
+                            std::size_t begin,
+                            std::size_t end) {
     return new (static_cast<Factory*>(this))
         Identifier(range, static_cast<Factory*>(this));
   }
 
-  NumberLiteral* NewNumberLiteral(const double& val) {
+  NumberLiteral* NewReducedNumberLiteral(const double& val) {
     return new (static_cast<Factory*>(this)) NumberLiteral(val);
   }
 
-  StringLiteral* NewStringLiteral(const std::vector<uc16>& buffer) {
+  NumberLiteral* NewNumberLiteral(const double& val,
+                                  std::size_t begin, std::size_t end) {
+    return new (static_cast<Factory*>(this)) NumberLiteral(val);
+  }
+
+
+  StringLiteral* NewStringLiteral(const std::vector<uc16>& buffer,
+                                  std::size_t begin, std::size_t end) {
     return new (static_cast<Factory*>(this))
         StringLiteral(buffer, static_cast<Factory*>(this));
   }
 
-  Directivable* NewDirectivable(const std::vector<uc16>& buffer) {
+  Directivable* NewDirectivable(const std::vector<uc16>& buffer,
+                                std::size_t begin, std::size_t end) {
     return new (static_cast<Factory*>(this))
         Directivable(buffer, static_cast<Factory*>(this));
   }
 
   RegExpLiteral* NewRegExpLiteral(const std::vector<uc16>& content,
-                                  const std::vector<uc16>& flags) {
+                                  const std::vector<uc16>& flags,
+                                  std::size_t begin,
+                                  std::size_t end) {
     return new (static_cast<Factory*>(this))
         RegExpLiteral(content, flags, static_cast<Factory*>(this));
   }
 
-  FunctionLiteral* NewFunctionLiteral(typename FunctionLiteral::DeclType type) {
+  FunctionLiteral* NewFunctionLiteral(typename FunctionLiteral::DeclType type,
+                                      Identifier* name,
+                                      Identifiers* params,
+                                      Statements* body,
+                                      Scope* scope,
+                                      bool strict,
+                                      std::size_t begin_block_position,
+                                      std::size_t end_block_position,
+                                      std::size_t begin,
+                                      std::size_t end) {
     return new (static_cast<Factory*>(this))
-        FunctionLiteral(type, static_cast<Factory*>(this));
-  }
-
-  ArrayLiteral* NewArrayLiteral(Expressions* items) {
+        FunctionLiteral(type,
+                        name,
+                        params,
+                        body,
+                        scope,
+                        strict,
+                        begin_block_position,
+                        end_block_position);
+  }
+
+  ArrayLiteral* NewArrayLiteral(Expressions* items,
+                                std::size_t begin, std::size_t end) {
     return new (static_cast<Factory*>(this)) ArrayLiteral(items);
   }
 
   ObjectLiteral*
-      NewObjectLiteral(typename ObjectLiteral::Properties* properties) {
+      NewObjectLiteral(typename ObjectLiteral::Properties* properties,
+                       std::size_t begin,
+                       std::size_t end) {
     return new (static_cast<Factory*>(this)) ObjectLiteral(properties);
   }
 
@@ -100,19 +131,17 @@ class BasicAstFactory {
         Vector(typename Vector::allocator_type(static_cast<Factory*>(this)));
   }
 
-  NullLiteral* NewNullLiteral() {
-    return null_instance_;
-  }
-
-  EmptyStatement* NewEmptyStatement() {
-    return empty_statement_instance_;
+  Scope* NewScope(typename FunctionLiteral::DeclType type) {
+    return new (static_cast<Factory*>(this))
+        Scope(static_cast<Factory*>(this), type == FunctionLiteral::GLOBAL);
   }
 
-  DebuggerStatement* NewDebuggerStatement() {
-    return debugger_statement_instance_;
+  NullLiteral* NewNullLiteral(std::size_t begin,
+                              std::size_t end) {
+    return null_instance_;
   }
 
-  ThisLiteral* NewThisLiteral() {
+  ThisLiteral* NewThisLiteral(std::size_t begin, std::size_t end) {
     return this_instance_;
   }
 
@@ -120,133 +149,184 @@ class BasicAstFactory {
     return undefined_instance_;
   }
 
-  TrueLiteral* NewTrueLiteral() {
+  TrueLiteral* NewTrueLiteral(std::size_t begin, std::size_t end) {
     return true_instance_;
   }
 
-  FalseLiteral* NewFalseLiteral() {
+  FalseLiteral* NewFalseLiteral(std::size_t begin, std::size_t end) {
     return false_instance_;
   }
 
+  EmptyStatement* NewEmptyStatement(std::size_t begin, std::size_t end) {
+    return empty_statement_instance_;
+  }
+
+  DebuggerStatement* NewDebuggerStatement(std::size_t begin, std::size_t end) {
+    return debugger_statement_instance_;
+  }
+
+  // if you want begin / end position,
+  // set position to FunctionLiteral in NewFunctionLiteral and use it
   FunctionStatement* NewFunctionStatement(FunctionLiteral* func) {
     return new (static_cast<Factory*>(this)) FunctionStatement(func);
   }
 
+  // if you want begin / end position,
+  // set position to FunctionLiteral in NewFunctionLiteral and use it
   FunctionDeclaration* NewFunctionDeclaration(FunctionLiteral* func) {
     return new (static_cast<Factory*>(this)) FunctionDeclaration(func);
   }
 
-  Block* NewBlock(Statements* body) {
+  Block* NewBlock(Statements* body, std::size_t begin, std::size_t end) {
     return new (static_cast<Factory*>(this)) Block(body);
   }
 
   VariableStatement* NewVariableStatement(Token::Type token,
-                                          Declarations* decls) {
+                                          Declarations* decls,
+                                          std::size_t begin,
+                                          std::size_t end) {
     return new (static_cast<Factory*>(this))
         VariableStatement(token, decls);
   }
 
+  // if you want begin / end position,
+  // set position to Identifier / Expression and use it
   Declaration* NewDeclaration(Identifier* name, Expression* expr) {
     return new (static_cast<Factory*>(this)) Declaration(name, expr);
   }
 
+  // if you want end position,
+  // set position to Statement and use it
   IfStatement* NewIfStatement(Expression* cond,
                               Statement* then_statement,
-                              Statement* else_statement) {
+                              Statement* else_statement,
+                              std::size_t begin) {
     return new (static_cast<Factory*>(this)) IfStatement(cond,
                                                          then_statement,
                                                          else_statement);
   }
 
   DoWhileStatement* NewDoWhileStatement(Statement* body,
-                                        Expression* cond) {
+                                        Expression* cond,
+                                        std::size_t begin,
+                                        std::size_t end) {
     return new (static_cast<Factory*>(this)) DoWhileStatement(body, cond);
   }
 
+  // if you want end position,
+  // set position to Statement and use it
   WhileStatement* NewWhileStatement(Statement* body,
-                                    Expression* cond) {
+                                    Expression* cond,
+                                    std::size_t begin) {
     return new (static_cast<Factory*>(this)) WhileStatement(body, cond);
   }
 
+  // if you want end position,
+  // set position to Statement and use it
   ForInStatement* NewForInStatement(Statement* body,
                                     Statement* each,
-                                    Expression* enumerable) {
+                                    Expression* enumerable,
+                                    std::size_t begin) {
     return new (static_cast<Factory*>(this)) ForInStatement(body,
                                                             each, enumerable);
   }
 
-  ExpressionStatement* NewExpressionStatement(Expression* expr) {
-    return new (static_cast<Factory*>(this)) ExpressionStatement(expr);
-  }
-
+  // if you want end position,
+  // set position to Statement and use it
   ForStatement* NewForStatement(Statement* body,
                                 Statement* init,
                                 Expression* cond,
-                                Statement* next) {
+                                Statement* next,
+                                std::size_t begin) {
     return new (static_cast<Factory*>(this)) ForStatement(body, init,
                                                           cond, next);
   }
 
+  ExpressionStatement* NewExpressionStatement(Expression* expr, std::size_t end) {
+    return new (static_cast<Factory*>(this)) ExpressionStatement(expr);
+  }
+
   ContinueStatement* NewContinueStatement(Identifier* label,
-                                          IterationStatement** target) {
+                                          IterationStatement** target,
+                                          std::size_t begin,
+                                          std::size_t end) {
     return new (static_cast<Factory*>(this)) ContinueStatement(label, target);
   }
 
   BreakStatement* NewBreakStatement(Identifier* label,
-                                    BreakableStatement** target) {
+                                    BreakableStatement** target,
+                                    std::size_t begin,
+                                    std::size_t end) {
     return new (static_cast<Factory*>(this)) BreakStatement(label, target);
   }
 
-  ReturnStatement* NewReturnStatement(
-      Expression* expr) {
+  ReturnStatement* NewReturnStatement(Expression* expr,
+                                      std::size_t begin,
+                                      std::size_t end) {
     return new (static_cast<Factory*>(this)) ReturnStatement(expr);
   }
 
-  WithStatement* NewWithStatement(
-      Expression* expr, Statement* stmt) {
+  // if you want end position,
+  // set position to Expression and use it
+  WithStatement* NewWithStatement(Expression* expr,
+                                  Statement* stmt, std::size_t begin) {
     return new (static_cast<Factory*>(this)) WithStatement(expr, stmt);
   }
 
-  SwitchStatement* NewSwitchStatement(Expression* expr, CaseClauses* clauses) {
+  SwitchStatement* NewSwitchStatement(Expression* expr, CaseClauses* clauses,
+                                      std::size_t begin, std::size_t end) {
     return new (static_cast<Factory*>(this)) SwitchStatement(expr, clauses);
   }
 
+  // !!! if body is empty, end_position is end.
   CaseClause* NewCaseClause(bool is_default,
-                            Expression* expr, Statements* body) {
+                            Expression* expr, Statements* body,
+                            std::size_t begin,
+                            std::size_t end) {
     return new (static_cast<Factory*>(this)) CaseClause(is_default, expr, body);
   }
 
-  ThrowStatement*  NewThrowStatement(Expression* expr) {
+  ThrowStatement*  NewThrowStatement(Expression* expr,
+                                     std::size_t begin, std::size_t end) {
     return new (static_cast<Factory*>(this)) ThrowStatement(expr);
   }
 
+  // if you want end position,
+  // set position to Block and use it
   TryStatement* NewTryStatement(Block* try_block,
                                 Identifier* catch_name,
                                 Block* catch_block,
-                                Block* finally_block) {
+                                Block* finally_block,
+                                std::size_t begin) {
     return new (static_cast<Factory*>(this)) TryStatement(try_block,
                                                           catch_name,
                                                           catch_block,
                                                           finally_block);
   }
 
-  LabelledStatement* NewLabelledStatement(
-      Expression* expr,
-      Statement* stmt) {
+  // if you want begin / end position,
+  // set position to Expression and use it
+  LabelledStatement* NewLabelledStatement(Expression* expr, Statement* stmt) {
     return new (static_cast<Factory*>(this)) LabelledStatement(expr, stmt);
   }
 
+  // if you want begin / end position,
+  // set position to Expression and use it
   BinaryOperation* NewBinaryOperation(Token::Type op,
                                       Expression* result, Expression* right) {
     return new (static_cast<Factory*>(this)) BinaryOperation(op, result, right);
   }
 
+  // if you want begin / end position,
+  // set position to Expression and use it
   Assignment* NewAssignment(Token::Type op,
                             Expression* left,
                             Expression* right) {
     return new (static_cast<Factory*>(this)) Assignment(op, left, right);
   }
 
+  // if you want begin / end position,
+  // set position to Expression and use it
   ConditionalExpression* NewConditionalExpression(Expression* cond,
                                                   Expression* left,
                                                   Expression* right) {
@@ -254,28 +334,45 @@ class BasicAstFactory {
         ConditionalExpression(cond, left, right);
   }
 
-  UnaryOperation* NewUnaryOperation(Token::Type op, Expression* expr) {
+  // if you want end position,
+  // set position to Expression and use it
+  UnaryOperation* NewUnaryOperation(Token::Type op,
+                                    Expression* expr, std::size_t begin) {
     return new (static_cast<Factory*>(this)) UnaryOperation(op, expr);
   }
 
-  PostfixExpression* NewPostfixExpression(
-      Token::Type op, Expression* expr) {
+  // if you want begin position,
+  // set position to Expression and use it
+  PostfixExpression* NewPostfixExpression(Token::Type op,
+                                          Expression* expr, std::size_t end) {
     return new (static_cast<Factory*>(this)) PostfixExpression(op, expr);
   }
 
-  FunctionCall* NewFunctionCall(Expression* expr, Expressions* args) {
+  // if you want begin position,
+  // set position to Expression and use it
+  FunctionCall* NewFunctionCall(Expression* expr,
+                                Expressions* args, std::size_t end) {
     return new (static_cast<Factory*>(this)) FunctionCall(expr, args);
   }
 
-  ConstructorCall* NewConstructorCall(Expression* target, Expressions* args) {
+  // if you want begin position,
+  // set position to Expression and use it
+  // !!! CAUTION !!!
+  // if not right paren (like new Array), end is 0
+  ConstructorCall* NewConstructorCall(Expression* target,
+                                      Expressions* args, std::size_t end) {
     return new (static_cast<Factory*>(this)) ConstructorCall(target, args);
   }
 
+  // if you want begin / end position,
+  // set position to Expression / Identifier and use it
   IndexAccess* NewIndexAccess(Expression* expr,
                               Expression* index) {
     return new (static_cast<Factory*>(this)) IndexAccess(expr, index);
   }
 
+  // if you want begin / end position,
+  // set position to Expression / Identifier and use it
   IdentifierAccess* NewIdentifierAccess(Expression* expr,
                                         Identifier* ident) {
     return new (static_cast<Factory*>(this)) IdentifierAccess(expr, ident);

data/ext/include/iv/ast_fwd.h

@@ -68,17 +68,21 @@ V(PropertyAccess)\
 V(Call)\
 EXPRESSION_DERIVED_NODE_LIST(V)
 
+#define OTHER_DERIVED_NODE_LIST(V)\
+V(Declaration)\
+V(CaseClause)
+
 #define OTHER_NODE_LIST(V)\
 V(AstNode)\
-V(Declaration)\
 V(Scope)\
-V(CaseClause)\
 V(Variable)\
-V(IdentifierKey)
+V(IdentifierKey)\
+OTHER_DERIVED_NODE_LIST(V)
 
 #define AST_DERIVED_NODE_LIST(V)\
 STATEMENT_DERIVED_NODE_LIST(V)\
-EXPRESSION_DERIVED_NODE_LIST(V)
+EXPRESSION_DERIVED_NODE_LIST(V)\
+OTHER_DERIVED_NODE_LIST(V)
 
 #define AST_NODE_LIST(V)\
 OTHER_NODE_LIST(V)\

data/ext/include/iv/ast_serializer.h

@@ -501,6 +501,15 @@ class AstSerializer: public AstVisitor<Factory>::const_type {
     Append("]}");
   }
 
+
+  void Visit(const CaseClause* dummy) {
+    UNREACHABLE();
+  }
+
+  void Visit(const Declaration* dummy) {
+    UNREACHABLE();
+  }
+
  private:
   template <class Iter>
   void DecodeString(Iter it, const Iter last) {

data/ext/include/iv/ast_visitor.h

@@ -81,6 +81,9 @@ class BasicAstVisitor
   virtual void Visit(typename add<IndexAccess<Factory> >::type prop) = 0;  //NOLINT
   virtual void Visit(typename add<FunctionCall<Factory> >::type call) = 0;  //NOLINT
   virtual void Visit(typename add<ConstructorCall<Factory> >::type call) = 0;  //NOLINT
+
+  virtual void Visit(typename add<Declaration<Factory> >::type func) = 0;  //NOLINT
+  virtual void Visit(typename add<CaseClause<Factory> >::type func) = 0;  //NOLINT
  protected:
   template<typename T>
   class Acceptor {

data/ext/include/iv/lexer.h

@@ -38,6 +38,7 @@ class Lexer: private Noncopyable<Lexer<Source> >::type {
         has_line_terminator_before_next_(false),
         has_shebang_(false),
         line_number_(1),
+        previous_location_(),
         location_() {
     Initialize();
   }
@@ -46,6 +47,7 @@ class Lexer: private Noncopyable<Lexer<Source> >::type {
   typename Token::Type Next(bool strict) {
     typename Token::Type token;
     has_line_terminator_before_next_ = false;
+    StorePreviousLocation();
     do {
       while (Chars::IsWhiteSpace(c_)) {
         // white space
@@ -356,7 +358,11 @@ class Lexer: private Noncopyable<Lexer<Source> >::type {
           break;
       }
     } while (token == Token::NOT_FOUND);
-    location_.set_end_position(pos() - 1);
+    if (c_ == -1) {
+      location_.set_end_position(pos());
+    } else {
+      location_.set_end_position(pos() - 1);
+    }
     return token;
   }
 
@@ -418,6 +424,14 @@ class Lexer: private Noncopyable<Lexer<Source> >::type {
     return location_.end_position();
   }
 
+  inline std::size_t previous_begin_position() const {
+    return previous_location_.begin_position();
+  }
+
+  inline std::size_t previous_end_position() const {
+    return previous_location_.end_position();
+  }
+
   bool ScanRegExpLiteral(bool contains_eq) {
     // location begin_position is the same with DIV
     // so, no need to set
@@ -471,7 +485,11 @@ class Lexer: private Noncopyable<Lexer<Source> >::type {
         Record16Advance();
       }
     }
-    location_.set_end_position(pos() - 1);
+    if (c_ == -1) {
+      location_.set_end_position(pos());
+    } else {
+      location_.set_end_position(pos() - 1);
+    }
     return true;
   }
 
@@ -493,6 +511,10 @@ class Lexer: private Noncopyable<Lexer<Source> >::type {
     swap(location_, Location());
   }
 
+  inline void StorePreviousLocation() {
+    previous_location_ = location_;
+  }
+
   inline void Advance() {
     if (pos_ == end_) {
       c_ = -1;
@@ -500,18 +522,28 @@ class Lexer: private Noncopyable<Lexer<Source> >::type {
       c_ = source_->Get(pos_++);
     }
   }
+
   inline void Record8() {
     buffer8_.push_back(static_cast<char>(c_));
   }
+
   inline void Record8(const int ch) {
     buffer8_.push_back(static_cast<char>(ch));
   }
-  inline void Record16() { buffer16_.push_back(c_); }
-  inline void Record16(const int ch) { buffer16_.push_back(ch); }
+
+  inline void Record16() {
+    buffer16_.push_back(c_);
+  }
+
+  inline void Record16(const int ch) {
+    buffer16_.push_back(ch);
+  }
+
   inline void Record8Advance() {
     Record8();
     Advance();
   }
+
   inline void Record16Advance() {
     Record16();
     Advance();
@@ -879,6 +911,7 @@ class Lexer: private Noncopyable<Lexer<Source> >::type {
   bool has_shebang_;
   int c_;
   std::size_t line_number_;
+  Location previous_location_;
   Location location_;
 };