iv-phonic 0.0.1

data/ext/include/iv/ast-serializer.h

@@ -0,0 +1,579 @@
+#ifndef _IV_AST_SERIALIZER_H_
+#define _IV_AST_SERIALIZER_H_
+#include <cstdio>
+#include <ostream>  // NOLINT
+#include <sstream>
+#include <tr1/tuple>
+#include "uchar.h"
+#include "ast.h"
+#include "ast-visitor.h"
+#include "ustring.h"
+#include "stringpiece.h"
+#include "ustringpiece.h"
+namespace iv {
+namespace core {
+namespace ast {
+
+template<typename Factory>
+class AstSerializer: public AstVisitor<Factory>::const_type {
+ public:
+
+  typedef void ReturnType;
+
+#define V(AST) typedef typename iv::core::ast::AST<Factory> AST;
+  AST_NODE_LIST(V)
+#undef V
+#define V(X, XS) typedef typename core::SpaceVector<Factory, X *>::type XS;
+  AST_LIST_LIST(V)
+#undef V
+#define V(S) typedef typename core::SpaceUString<Factory>::type S;
+  AST_STRING(V)
+#undef V
+
+  AstSerializer() : out_() { }
+  inline const UString& out() const {
+    return out_;
+  }
+
+  void Append(const StringPiece& str) {
+    out_.append(str.begin(), str.end());
+  }
+
+  void Append(const UStringPiece& str) {
+    out_.append(str.begin(), str.end());
+  }
+
+  void Append(uc16 c) {
+    out_.push_back(c);
+  }
+
+  void Append(char c) {
+    out_.push_back(c);
+  }
+
+  void Visit(const Block* block) {
+    Append("{\"type\":\"block\",\"body\":[");
+    typename Statements::const_iterator it = block->body().begin();
+    const typename Statements::const_iterator end = block->body().end();
+    while (it != end) {
+      (*it)->Accept(this);
+      ++it;
+      if (it != end) {
+        Append(',');
+      }
+    }
+    Append("]}");
+  }
+
+  void Visit(const FunctionStatement* func) {
+    Append("{\"type\":\"function_statement\",\"def\":");
+    func->function()->Accept(this);
+    Append('}');
+  }
+
+  void Visit(const VariableStatement* var) {
+    Append("{\"type\":");
+    if (var->IsConst()) {
+      Append("\"const\",\"decls\":[");
+    } else {
+      Append("\"var\",\"decls\":[");
+    }
+    typename Declarations::const_iterator it = var->decls().begin();
+    const typename Declarations::const_iterator end = var->decls().end();
+    while (it != end) {
+      (*it)->Accept(this);
+      ++it;
+      if (it != end) {
+        Append(',');
+      }
+    }
+    Append("]}");
+  }
+
+  void Visit(const Declaration* decl) {
+    Append("{\"type\":\"decl\",\"name\":");
+    decl->name()->Accept(this);
+    Append(",\"exp\":");
+    if (decl->expr()) {
+      decl->expr()->Accept(this);
+    }
+    Append('}');
+  }
+
+  void Visit(const EmptyStatement* empty) {
+    Append("{\"type\":\"empty\"}");
+  }
+
+  void Visit(const IfStatement* ifstmt) {
+    Append("{\"type\":\"if\",\"cond\":");
+    ifstmt->cond()->Accept(this);
+    Append(",\"body\":");
+    ifstmt->then_statement()->Accept(this);
+    if (ifstmt->else_statement()) {
+      Append(",\"else\":");
+      ifstmt->else_statement()->Accept(this);
+    }
+    Append('}');
+  }
+
+  void Visit(const DoWhileStatement* dowhile) {
+    Append("{\"type\":\"dowhile\",\"cond\":");
+    dowhile->cond()->Accept(this);
+    Append(",\"body\":");
+    dowhile->body()->Accept(this);
+    Append('}');
+  }
+
+  void Visit(const WhileStatement* whilestmt) {
+    Append("{\"type\":\"while\",\"cond\":");
+    whilestmt->cond()->Accept(this);
+    Append(",\"body\":");
+    whilestmt->body()->Accept(this);
+    Append('}');
+  }
+
+  void Visit(const ForStatement* forstmt) {
+    Append("{\"type\":\"for\"");
+    if (forstmt->init() != NULL) {
+      Append(",\"init\":");
+      forstmt->init()->Accept(this);
+    }
+    if (forstmt->cond() != NULL) {
+      Append(",\"cond\":");
+      forstmt->cond()->Accept(this);
+    }
+    if (forstmt->next() != NULL) {
+      Append(",\"next\":");
+      forstmt->next()->Accept(this);
+    }
+    Append(",\"body\":");
+    forstmt->body()->Accept(this);
+    Append('}');
+  }
+
+  void Visit(const ForInStatement* forstmt) {
+    Append("{\"type\":\"forin\",\"each\":");
+    forstmt->each()->Accept(this);
+    Append(",\"enumerable\":");
+    forstmt->enumerable()->Accept(this);
+    Append(",\"body\":");
+    forstmt->body()->Accept(this);
+    Append('}');
+  }
+
+  void Visit(const ContinueStatement* continuestmt) {
+    Append("{\"type\":\"continue\"");
+    if (continuestmt->label()) {
+      Append(",\"label\":");
+      continuestmt->label()->Accept(this);
+    }
+    Append('}');
+  }
+
+  void Visit(const BreakStatement* breakstmt) {
+    Append("{\"type\":\"break\"");
+    if (breakstmt->label()) {
+      Append(",\"label\":");
+      breakstmt->label()->Accept(this);
+    }
+    Append('}');
+  }
+
+  void Visit(const ReturnStatement* returnstmt) {
+    Append("{\"type\":\"return\",\"exp\":");
+    returnstmt->expr()->Accept(this);
+    Append('}');
+  }
+
+  void Visit(const WithStatement* withstmt) {
+    Append("{\"type\":\"with\",\"context\":");
+    withstmt->context()->Accept(this);
+    Append(",\"body\":");
+    withstmt->body()->Accept(this);
+    Append('}');
+  }
+
+  void Visit(const LabelledStatement* labelledstmt) {
+    Append("{\"type\":\"labelled\",\"label\":");
+    labelledstmt->label()->Accept(this);
+    Append(",\"body\":");
+    labelledstmt->body()->Accept(this);
+    Append('}');
+  }
+
+  void Visit(const CaseClause* clause) {
+    if (clause->IsDefault()) {
+      Append("{\"type\":\"default\"");
+    } else {
+      Append("{\"type\":\"case\",\"exp\":");
+      clause->expr()->Accept(this);
+    }
+    Append(",\"body\"[");
+    typename Statements::const_iterator it = clause->body().begin();
+    const typename Statements::const_iterator end = clause->body().end();
+    while (it != end) {
+      (*it)->Accept(this);
+      ++it;
+      if (it != end) {
+        Append(',');
+      }
+    }
+    Append("]}");
+  }
+
+  void Visit(const SwitchStatement* switchstmt) {
+    Append("{\"type\":\"switch\",\"exp\":");
+    switchstmt->expr()->Accept(this);
+    Append(",\"clauses\":[");
+    typename CaseClauses::const_iterator
+        it = switchstmt->clauses().begin();
+    const typename CaseClauses::const_iterator
+        end = switchstmt->clauses().end();
+    while (it != end) {
+      (*it)->Accept(this);
+      ++it;
+      if (it != end) {
+        Append(',');
+      }
+    }
+    Append("]}");
+  }
+
+  void Visit(const ThrowStatement* throwstmt) {
+    Append("{\"type\":\"throw\",\"exp\":");
+    throwstmt->expr()->Accept(this);
+    Append('}');
+  }
+
+  void Visit(const TryStatement* trystmt) {
+    Append("{\"type\":\"try\",\"body\":");
+    trystmt->body()->Accept(this);
+    if (trystmt->catch_name()) {
+      Append(",\"catch\":{\"type\":\"catch\",\"name\":");
+      trystmt->catch_name()->Accept(this);
+      Append(",\"body\":");
+      trystmt->catch_block()->Accept(this);
+      Append('}');
+    }
+    if (trystmt->finally_block()) {
+      Append(",\"finally\":{\"type\":\"finally\",\"body\":");
+      trystmt->finally_block()->Accept(this);
+      Append('}');
+    }
+    Append('}');
+  }
+
+  void Visit(const DebuggerStatement* debuggerstmt) {
+    Append("{\"type\":\"debugger\"}");
+  }
+
+  void Visit(const ExpressionStatement* exprstmt) {
+    Append("{\"type\":\"expstatement\",\"exp\":");
+    exprstmt->expr()->Accept(this);
+    Append('}');
+  }
+
+  void Visit(const Assignment* assign) {
+    Append("{\"type\":\"assign\",\"op\":\"");
+    Append(Token::ToString(assign->op()));
+    Append("\",\"left\":");
+    assign->left()->Accept(this);
+    Append(",\"right\":");
+    assign->right()->Accept(this);
+    Append('}');
+  }
+
+  void Visit(const BinaryOperation* binary) {
+    Append("{\"type\":\"binary\",\"op\":\"");
+    Append(Token::ToString(binary->op()));
+    Append("\",\"left\":");
+    binary->left()->Accept(this);
+    Append(",\"right\":");
+    binary->right()->Accept(this);
+    Append('}');
+  }
+
+  void Visit(const ConditionalExpression* cond) {
+    Append("{\"type\":\"conditional\",\"cond\":");
+    cond->cond()->Accept(this);
+    Append(",\"left\":");
+    cond->left()->Accept(this);
+    Append(",\"right\":");
+    cond->right()->Accept(this);
+    Append('}');
+  }
+
+  void Visit(const UnaryOperation* unary) {
+    Append("{\"type\":\"unary\",\"op\":\"");
+    Append(Token::ToString(unary->op()));
+    Append("\",\"exp\":");
+    unary->expr()->Accept(this);
+    Append('}');
+  }
+
+  void Visit(const PostfixExpression* postfix) {
+    Append("{\"type\":\"postfix\",\"op\":\"");
+    Append(Token::ToString(postfix->op()));
+    Append("\",\"exp\":");
+    postfix->expr()->Accept(this);
+    Append('}');
+  }
+
+  void Visit(const StringLiteral* literal) {
+    Append("{\"type\":\"string\",\"value\":\"");
+    DecodeString(literal->value().begin(), literal->value().end());
+    Append("\"}");
+  }
+
+  void Visit(const NumberLiteral* literal) {
+    std::ostringstream sout;
+    sout << literal->value();
+    Append("{\"type\":\"number\",\"value\":\"");
+    Append(sout.str());
+    Append("\"}");
+  }
+
+  void Visit(const Identifier* literal) {
+    Append("{\"type\":\"identifier\",\"value\":\"");
+    Append(literal->value());
+    Append("\"}");
+  }
+
+  void Visit(const ThisLiteral* literal) {
+    Append("{\"type\":\"this\"}");
+  }
+
+  void Visit(const NullLiteral* literal) {
+    Append("{\"type\":\"null\"}");
+  }
+
+  void Visit(const TrueLiteral* literal) {
+    Append("{\"type\":\"true\"}");
+  }
+
+  void Visit(const FalseLiteral* literal) {
+    Append("{\"type\":\"false\"}");
+  }
+
+  void Visit(const Undefined* literal) {
+    Append("{\"type\":\"undefined\"}");
+  }
+
+  void Visit(const RegExpLiteral* literal) {
+    Append("{\"type\":\"regexp\",\"value\":\"");
+    DecodeString(literal->value().begin(), literal->value().end());
+    Append("\",\"flags\":\"");
+    Append(literal->flags());
+    Append("\"}");
+  }
+
+  void Visit(const ArrayLiteral* literal) {
+    Append("{\"type\":\"array\",\"value\":[");
+    typename Expressions::const_iterator it = literal->items().begin();
+    const typename Expressions::const_iterator end = literal->items().end();
+    bool previous_is_elision = false;
+    while (it != end) {
+      if ((*it)) {
+        (*it)->Accept(this);
+        previous_is_elision = false;
+      } else {
+        previous_is_elision = true;
+      }
+      ++it;
+      if (it != end) {
+        Append(',');
+      }
+    }
+    if (previous_is_elision) {
+      Append(',');
+    }
+    Append("]}");
+  }
+
+  void Visit(const ObjectLiteral* literal) {
+    using std::tr1::get;
+    Append("{\"type\":\"object\",\"value\":[");
+    typename ObjectLiteral::Properties::const_iterator
+        it = literal->properties().begin();
+    const typename ObjectLiteral::Properties::const_iterator
+      end = literal->properties().end();
+    while (it != end) {
+      Append("{\"type\":");
+      const typename ObjectLiteral::PropertyDescriptorType type(get<0>(*it));
+      if (type == ObjectLiteral::DATA) {
+        Append("\"data\"");
+      } else if (type == ObjectLiteral::SET) {
+        Append("\"setter\"");
+      } else {
+        Append("\"getter\"");
+      }
+      Append(",\"key\":");
+      get<1>(*it)->Accept(this);
+      Append(",\"val\":");
+      get<2>(*it)->Accept(this);
+      Append('}');
+      ++it;
+      if (it == end) {
+        break;
+      }
+      Append(',');
+    }
+    Append("]}");
+  }
+
+  void Visit(const FunctionLiteral* literal) {
+    Append("{\"type\":\"function\",\"name\":");
+    if (literal->name()) {
+      literal->name()->Accept(this);
+    }
+    Append(",\"params\":[");
+    typename Identifiers::const_iterator it = literal->params().begin();
+    const typename Identifiers::const_iterator end = literal->params().end();
+    while (it != end) {
+      (*it)->Accept(this);
+      ++it;
+      if (it == end) {
+        break;
+      }
+      Append(',');
+    }
+    Append("],\"body\":[");
+    typename Statements::const_iterator it_body = literal->body().begin();
+    const typename Statements::const_iterator end_body = literal->body().end();
+    while (it_body != end_body) {
+      (*it_body)->Accept(this);
+      ++it_body;
+      if (it_body == end_body) {
+        break;
+      }
+      Append(',');
+    }
+    Append("]}");
+  }
+
+  void Visit(const IndexAccess* prop) {
+    Append("{\"type\":\"property\",\"target\":");
+    prop->target()->Accept(this);
+    Append(",\"key\":");
+    prop->key()->Accept(this);
+    Append('}');
+  }
+
+  void Visit(const IdentifierAccess* prop) {
+    Append("{\"type\":\"property\",\"target\":");
+    prop->target()->Accept(this);
+    Append(",\"key\":");
+    prop->key()->Accept(this);
+    Append('}');
+  }
+
+  void Visit(const FunctionCall* call) {
+    Append("{\"type\":\"funcall\",\"target\":");
+    call->target()->Accept(this);
+    Append(",\"args\":[");
+    typename Expressions::const_iterator it = call->args().begin();
+    const typename Expressions::const_iterator end = call->args().end();
+    while (it != end) {
+      (*it)->Accept(this);
+      ++it;
+      if (it == end) {
+        break;
+      }
+      Append(',');
+    }
+    Append("]}");
+  }
+
+  void Visit(const ConstructorCall* call) {
+    Append("{\"type\":\"new\",\"target\":");
+    call->target()->Accept(this);
+    Append(",\"args\":[");
+    typename Expressions::const_iterator it = call->args().begin();
+    const typename Expressions::const_iterator end = call->args().end();
+    while (it != end) {
+      (*it)->Accept(this);
+      ++it;
+      if (it == end) {
+        break;
+      }
+      Append(',');
+    }
+    Append("]}");
+  }
+
+ private:
+  template <class Iter>
+  void DecodeString(Iter it, const Iter last) {
+    char buf[5];
+    for (;it != last; ++it) {
+      const uc16 val = *it;
+      switch (val) {
+        case '"':
+          Append("\\\"");
+          break;
+
+        case '\\':
+          Append("\\\\");
+          break;
+
+        case '/':
+          Append("\\/");
+          break;
+
+        case '\b':
+          Append("\\b");
+          break;
+
+        case '\f':
+          Append("\\f");
+          break;
+
+        case '\n':
+          Append("\\n");
+          break;
+
+        case '\r':
+          Append("\\r");
+          break;
+
+        case '\t':
+          Append("\\t");
+          break;
+
+        case '\x0B':  // \v
+          Append("\\u000b");
+          break;
+
+        default:
+          if (val < 0x20) {
+            if (val < 0x10) {
+              Append("\\u000");
+              std::snprintf(buf, sizeof(buf), "%x", val);
+              Append(buf);
+            } else if (0x10 <= val && val < 0x20) {
+              Append("\\u00");
+              std::snprintf(buf, sizeof(buf), "%x", val);
+              Append(buf);
+            }
+          } else if (0x80 <= val) {
+            if (0x80 <= val && val < 0x1000) {
+              Append("\\u0");
+              std::snprintf(buf, sizeof(buf), "%x", val);
+              Append(buf);
+            } else if (0x1000 <= val) {
+              Append("\\u");
+              std::snprintf(buf, sizeof(buf), "%x", val);
+              Append(buf);
+            }
+          } else {
+            Append(val);
+          }
+          break;
+      }
+    }
+  }
+  UString out_;
+};
+
+} } }  // namespace iv::core::ast
+#endif  // _IV_AST_SERIALIZER_H_

data/ext/include/iv/ast-visitor.h

@@ -0,0 +1,121 @@
+#ifndef _IV_AST_VISITOR_H_
+#define _IV_AST_VISITOR_H_
+#include <tr1/type_traits>
+#include "noncopyable.h"
+#include "ast-fwd.h"
+
+namespace iv {
+namespace core {
+namespace ast {
+namespace detail {
+
+template<bool IsConst, typename T>
+struct AstVisitorTraits {
+};
+
+template<typename T>
+struct AstVisitorTraits<true, T> {
+  typedef typename std::tr1::add_pointer<
+      typename std::tr1::add_const<T>::type>::type type;
+};
+
+template<typename T>
+struct AstVisitorTraits<false, T> {
+  typedef typename std::tr1::add_pointer<
+      typename std::tr1::add_const<T>::type>::type type;
+};
+
+}  // namespace iv::core::ast::detail
+
+template<bool IsConst, typename Factory>
+class BasicAstVisitor
+  : private Noncopyable<BasicAstVisitor<IsConst, Factory> >::type {
+ private:
+  template<typename T>
+  struct add {
+    typedef typename detail::AstVisitorTraits<IsConst, T>::type type;
+  };
+ public:
+  virtual ~BasicAstVisitor() = 0;
+  virtual void Visit(typename add<Block<Factory> >::type block) = 0;  //NOLINT
+  virtual void Visit(typename add<FunctionStatement<Factory> >::type func) = 0;  //NOLINT
+  virtual void Visit(typename add<VariableStatement<Factory> >::type var) = 0;  //NOLINT
+  virtual void Visit(typename add<Declaration<Factory> >::type decl) = 0;  //NOLINT
+  virtual void Visit(typename add<EmptyStatement<Factory> >::type empty) = 0;  //NOLINT
+  virtual void Visit(typename add<IfStatement<Factory> >::type ifstmt) = 0;  //NOLINT
+  virtual void Visit(typename add<DoWhileStatement<Factory> >::type dowhile) = 0;  //NOLINT
+  virtual void Visit(typename add<WhileStatement<Factory> >::type whilestmt) = 0;  //NOLINT
+  virtual void Visit(typename add<ForStatement<Factory> >::type forstmt) = 0;  //NOLINT
+  virtual void Visit(typename add<ForInStatement<Factory> >::type forstmt) = 0;  //NOLINT
+  virtual void Visit(typename add<ContinueStatement<Factory> >::type continuestmt) = 0;  //NOLINT
+  virtual void Visit(typename add<BreakStatement<Factory> >::type breakstmt) = 0;  //NOLINT
+  virtual void Visit(typename add<ReturnStatement<Factory> >::type returnstmt) = 0;  //NOLINT
+  virtual void Visit(typename add<WithStatement<Factory> >::type withstmt) = 0;  //NOLINT
+  virtual void Visit(typename add<LabelledStatement<Factory> >::type labelledstmt) = 0;  //NOLINT
+  virtual void Visit(typename add<CaseClause<Factory> >::type clause) = 0;  //NOLINT
+  virtual void Visit(typename add<SwitchStatement<Factory> >::type switchstmt) = 0;  //NOLINT
+  virtual void Visit(typename add<ThrowStatement<Factory> >::type throwstmt) = 0;  //NOLINT
+  virtual void Visit(typename add<TryStatement<Factory> >::type trystmt) = 0;  //NOLINT
+  virtual void Visit(typename add<DebuggerStatement<Factory> >::type debuggerstmt) = 0;  //NOLINT
+  virtual void Visit(typename add<ExpressionStatement<Factory> >::type exprstmt) = 0;  //NOLINT
+
+  virtual void Visit(typename add<Assignment<Factory> >::type assign) = 0;  //NOLINT
+  virtual void Visit(typename add<BinaryOperation<Factory> >::type binary) = 0;  //NOLINT
+  virtual void Visit(typename add<ConditionalExpression<Factory> >::type cond) = 0;  //NOLINT
+  virtual void Visit(typename add<UnaryOperation<Factory> >::type unary) = 0;  //NOLINT
+  virtual void Visit(typename add<PostfixExpression<Factory> >::type postfix) = 0;  //NOLINT
+
+  virtual void Visit(typename add<StringLiteral<Factory> >::type literal) = 0;  //NOLINT
+  virtual void Visit(typename add<NumberLiteral<Factory> >::type literal) = 0;  //NOLINT
+  virtual void Visit(typename add<Identifier<Factory> >::type literal) = 0;  //NOLINT
+  virtual void Visit(typename add<ThisLiteral<Factory> >::type literal) = 0;  //NOLINT
+  virtual void Visit(typename add<NullLiteral<Factory> >::type literal) = 0;  //NOLINT
+  virtual void Visit(typename add<TrueLiteral<Factory> >::type literal) = 0;  //NOLINT
+  virtual void Visit(typename add<FalseLiteral<Factory> >::type literal) = 0;  //NOLINT
+  virtual void Visit(typename add<Undefined<Factory> >::type literal) = 0;  //NOLINT
+  virtual void Visit(typename add<RegExpLiteral<Factory> >::type literal) = 0;  //NOLINT
+  virtual void Visit(typename add<ArrayLiteral<Factory> >::type literal) = 0;  //NOLINT
+  virtual void Visit(typename add<ObjectLiteral<Factory> >::type literal) = 0;  //NOLINT
+  virtual void Visit(typename add<FunctionLiteral<Factory> >::type literal) = 0;  //NOLINT
+
+  virtual void Visit(typename add<IdentifierAccess<Factory> >::type prop) = 0;  //NOLINT
+  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
+ protected:
+  template<typename T>
+  class Acceptor {
+   public:
+    explicit Acceptor(T* visitor) :  visitor_(visitor) { }
+    template<typename U>
+    void operator()(U* p) const {
+      p->Accept(visitor_);
+    }
+   private:
+    T* const visitor_;
+  };
+
+  template<typename T>
+  class Visitor {
+   public:
+    explicit Visitor(T* visitor) :  visitor_(visitor) { }
+    template<typename U>
+    void operator()(U* p) const {
+      visitor_->Visit(p);
+    }
+   private:
+    T* const visitor_;
+  };
+};
+
+template<bool IsConst, typename Factory>
+inline BasicAstVisitor<IsConst, Factory>::~BasicAstVisitor() { }
+
+template<typename Factory>
+struct AstVisitor {
+  typedef BasicAstVisitor<false, Factory> type;
+  typedef BasicAstVisitor<true, Factory> const_type;
+};
+
+} } }  // namespace iv::core::ast
+#endif  // _IV_AST_VISITOR_H_