iv-phonic 0.0.1 → 0.0.2

data/Rakefile

@@ -10,7 +10,7 @@ directory "ext/include/iv"
 
 HOE = Hoe.spec 'iv-phonic' do
   developer('Constellation', 'utatane.tea@gmail.com')
-  self.version = '0.0.1'
+  self.version = '0.0.2'
   self.readme_file = 'README.rdoc'
   self.history_file = 'ChangeLog'
   self.extra_rdoc_files = FileList['*.rdoc']
@@ -23,7 +23,7 @@ HOE = Hoe.spec 'iv-phonic' do
 end
 
 Rake::ExtensionTask.new('phonic', HOE.spec) do |ext|
-  ext.lib_dir = File.join('lib', 'iv', 'phonic')
+  ext.lib_dir = File.join('lib', 'iv')
   ext.ext_dir = File.join('ext', 'iv', 'phonic')
   ext.config_options << "--with-iv-include=#{File.join($root, 'ext', 'include')}"
 end

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

@@ -2,6 +2,7 @@
 #define _IV_AST_FACTORY_H_
 #include <tr1/type_traits>
 #include "functor.h"
+#include "location.h"
 #include "ast.h"
 #include "alloc.h"
 #include "static_assert.h"
@@ -48,19 +49,10 @@ class BasicAstFactory : public Space<N> {
                      is_base_of_factory::value);
   }
 
-  Identifier* NewIdentifier(const UStringPiece& buffer) {
+  template<typename Range>
+  Identifier* NewIdentifier(const Range& range) {
     return new (static_cast<Factory*>(this))
-        Identifier(buffer, static_cast<Factory*>(this));
-  }
-
-  Identifier* NewIdentifier(const std::vector<uc16>& buffer) {
-    return new (static_cast<Factory*>(this))
-        Identifier(buffer, static_cast<Factory*>(this));
-  }
-
-  Identifier* NewIdentifier(const std::vector<char>& buffer) {
-    return new (static_cast<Factory*>(this))
-        Identifier(buffer, static_cast<Factory*>(this));
+        Identifier(range, static_cast<Factory*>(this));
   }
 
   NumberLiteral* NewNumberLiteral(const double& val) {
@@ -149,37 +141,51 @@ class BasicAstFactory : public Space<N> {
     return new (static_cast<Factory*>(this)) Declaration(name, expr);
   }
 
-  IfStatement* NewIfStatement(Expression* cond, Statement* then) {
-    return new (static_cast<Factory*>(this)) IfStatement(cond, then);
+  IfStatement* NewIfStatement(Expression* cond,
+                              Statement* then_statement,
+                              Statement* else_statement) {
+    return new (static_cast<Factory*>(this)) IfStatement(cond,
+                                                         then_statement,
+                                                         else_statement);
   }
 
-  DoWhileStatement* NewDoWhileStatement() {
-    return new (static_cast<Factory*>(this)) DoWhileStatement();
+  DoWhileStatement* NewDoWhileStatement(Statement* body,
+                                        Expression* cond) {
+    return new (static_cast<Factory*>(this)) DoWhileStatement(body, cond);
   }
 
-  WhileStatement* NewWhileStatement(Expression* expr) {
-    return new (static_cast<Factory*>(this)) WhileStatement(expr);
+  WhileStatement* NewWhileStatement(Statement* body,
+                                    Expression* cond) {
+    return new (static_cast<Factory*>(this)) WhileStatement(body, cond);
   }
 
-  ForInStatement* NewForInStatement(Statement* each,
+  ForInStatement* NewForInStatement(Statement* body,
+                                    Statement* each,
                                     Expression* enumerable) {
-    return new (static_cast<Factory*>(this)) ForInStatement(each, enumerable);
+    return new (static_cast<Factory*>(this)) ForInStatement(body,
+                                                            each, enumerable);
   }
 
   ExpressionStatement* NewExpressionStatement(Expression* expr) {
     return new (static_cast<Factory*>(this)) ExpressionStatement(expr);
   }
 
-  ForStatement* NewForStatement() {
-    return new (static_cast<Factory*>(this)) ForStatement();
+  ForStatement* NewForStatement(Statement* body,
+                                Statement* init,
+                                Expression* cond,
+                                Statement* next) {
+    return new (static_cast<Factory*>(this)) ForStatement(body, init,
+                                                          cond, next);
   }
 
-  ContinueStatement* NewContinueStatement() {
-    return new (static_cast<Factory*>(this)) ContinueStatement();
+  ContinueStatement* NewContinueStatement(Identifier* label,
+                                          IterationStatement** target) {
+    return new (static_cast<Factory*>(this)) ContinueStatement(label, target);
   }
 
-  BreakStatement* NewBreakStatement() {
-    return new (static_cast<Factory*>(this)) BreakStatement();
+  BreakStatement* NewBreakStatement(Identifier* label,
+                                    BreakableStatement** target) {
+    return new (static_cast<Factory*>(this)) BreakStatement(label, target);
   }
 
   ReturnStatement* NewReturnStatement(
@@ -197,17 +203,23 @@ class BasicAstFactory : public Space<N> {
         SwitchStatement(expr, static_cast<Factory*>(this));
   }
 
-  CaseClause* NewCaseClause() {
+  CaseClause* NewCaseClause(bool is_default, Expression* expr) {
     return new (static_cast<Factory*>(this))
-        CaseClause(static_cast<Factory*>(this));
+        CaseClause(is_default, expr, static_cast<Factory*>(this));
   }
 
   ThrowStatement*  NewThrowStatement(Expression* expr) {
     return new (static_cast<Factory*>(this)) ThrowStatement(expr);
   }
 
-  TryStatement* NewTryStatement(Block* block) {
-    return new (static_cast<Factory*>(this)) TryStatement(block);
+  TryStatement* NewTryStatement(Block* try_block,
+                                Identifier* catch_name,
+                                Block* catch_block,
+                                Block* finally_block) {
+    return new (static_cast<Factory*>(this)) TryStatement(try_block,
+                                                          catch_name,
+                                                          catch_block,
+                                                          finally_block);
   }
 
   LabelledStatement* NewLabelledStatement(

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

@@ -4,8 +4,7 @@ namespace iv {
 namespace core {
 namespace ast {
 
-#define STATEMENT_NODE_LIST(V)\
-V(Statement)\
+#define STATEMENT_DERIVED_NODE_LIST(V)\
 V(EmptyStatement)\
 V(DebuggerStatement)\
 V(FunctionStatement)\
@@ -25,10 +24,14 @@ V(SwitchStatement)\
 V(ThrowStatement)\
 V(TryStatement)\
 V(LabelledStatement)\
+
+#define STATEMENT_NODE_LIST(V)\
+V(Statement)\
+V(IterationStatement)\
 V(BreakableStatement)\
 V(NamedOnlyBreakableStatement)\
 V(AnonymousBreakableStatement)\
-V(IterationStatement)
+STATEMENT_DERIVED_NODE_LIST(V)
 
 #define LITERAL_NODE_LIST(V)\
 V(Literal)\
@@ -46,11 +49,7 @@ V(Undefined)\
 V(TrueLiteral)\
 V(FalseLiteral)
 
-#define EXPRESSION_NODE_LIST(V)\
-V(Expression)\
-V(IndexAccess)\
-V(PropertyAccess)\
-V(Call)\
+#define EXPRESSION_DERIVED_NODE_LIST(V)\
 V(FunctionCall)\
 V(ConstructorCall)\
 V(BinaryOperation)\
@@ -59,15 +58,26 @@ V(ConditionalExpression)\
 V(UnaryOperation)\
 V(PostfixExpression)\
 V(IdentifierAccess)\
+V(IndexAccess)\
 LITERAL_NODE_LIST(V)
 
+#define EXPRESSION_NODE_LIST(V)\
+V(Expression)\
+V(PropertyAccess)\
+V(Call)\
+EXPRESSION_DERIVED_NODE_LIST(V)
+
 #define OTHER_NODE_LIST(V)\
 V(AstNode)\
-V(Variable)\
 V(Declaration)\
-V(IdentifierKey)\
 V(Scope)\
-V(CaseClause)
+V(CaseClause)\
+V(Variable)\
+V(IdentifierKey)
+
+#define AST_DERIVED_NODE_LIST(V)\
+STATEMENT_DERIVED_NODE_LIST(V)\
+EXPRESSION_DERIVED_NODE_LIST(V)
 
 #define AST_NODE_LIST(V)\
 OTHER_NODE_LIST(V)\
@@ -79,7 +89,7 @@ V(Identifier, Identifiers)\
 V(Declaration, Declarations)\
 V(Expression, Expressions)\
 V(Statement, Statements)\
-V(CaseClause, CaseClauses)\
+V(CaseClause, CaseClauses)
 
 #define AST_STRING(V) V(SpaceUString)
 

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

@@ -81,7 +81,14 @@ class AstSerializer: public AstVisitor<Factory>::const_type {
     typename Declarations::const_iterator it = var->decls().begin();
     const typename Declarations::const_iterator end = var->decls().end();
     while (it != end) {
-      (*it)->Accept(this);
+      const Declaration& decl = **it;
+      Append("{\"type\":\"decl\",\"name\":");
+      decl.name()->Accept(this);
+      Append(",\"exp\":");
+      if (decl.expr()) {
+        decl.expr()->Accept(this);
+      }
+      Append('}');
       ++it;
       if (it != end) {
         Append(',');
@@ -90,16 +97,6 @@ class AstSerializer: public AstVisitor<Factory>::const_type {
     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\"}");
   }
@@ -201,26 +198,6 @@ class AstSerializer: public AstVisitor<Factory>::const_type {
     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);
@@ -230,7 +207,24 @@ class AstSerializer: public AstVisitor<Factory>::const_type {
     const typename CaseClauses::const_iterator
         end = switchstmt->clauses().end();
     while (it != end) {
-      (*it)->Accept(this);
+      const CaseClause& clause = **it;
+      if (clause.IsDefault()) {
+        Append("{\"type\":\"default\"");
+      } else {
+        Append("{\"type\":\"case\",\"exp\":");
+        clause.expr()->Accept(this);
+      }
+      Append(",\"body\"[");
+      typename Statements::const_iterator stit = clause.body().begin();
+      const typename Statements::const_iterator stend = clause.body().end();
+      while (stit != stend) {
+        (*stit)->Accept(this);
+        ++stit;
+        if (stit != stend) {
+          Append(',');
+        }
+      }
+      Append("]}");
       ++it;
       if (it != end) {
         Append(',');

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

@@ -40,7 +40,6 @@ class BasicAstVisitor
   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
@@ -52,7 +51,6 @@ class BasicAstVisitor
   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