iv-phonic 0.1.5 → 0.1.6

data/ext/iv/phonic/creator.h

@@ -5,6 +5,7 @@ extern "C" {
 }
 #include <iv/ast_visitor.h>
 #include <iv/utils.h>
+#include <iv/maybe.h>
 #include "factory.h"
 #include "encoding.h"
 #define SYM(str) ID2SYM(rb_intern(str))
@@ -78,8 +79,8 @@ class Creator : public iv::core::ast::AstVisitor<AstFactory>::const_type {
     rb_hash_aset(hash, SYM("type"), SYM("Declaration"));
     Visit(decl->name());
     rb_hash_aset(hash, SYM("name"), ret_);
-    if (decl->expr()) {
-      decl->expr()->Accept(this);
+    if (const core::Maybe<const Expression> expr = decl->expr()) {
+      (*expr).Accept(this);
       rb_hash_aset(hash, SYM("expr"), ret_);
     }
     SetLocation(hash, decl);
@@ -100,8 +101,8 @@ class Creator : public iv::core::ast::AstVisitor<AstFactory>::const_type {
     rb_hash_aset(hash, SYM("cond"), ret_);
     stmt->then_statement()->Accept(this);
     rb_hash_aset(hash, SYM("then"), ret_);
-    if (stmt->else_statement()) {
-      stmt->else_statement()->Accept(this);
+    if (const core::Maybe<const Statement> else_stmt = stmt->else_statement()) {
+      (*else_stmt).Accept(this);
       rb_hash_aset(hash, SYM("else"), ret_);
     }
     SetLocation(hash, stmt);
@@ -133,16 +134,16 @@ class Creator : public iv::core::ast::AstVisitor<AstFactory>::const_type {
   void Visit(const ForStatement* stmt) {
     VALUE hash = rb_hash_new();
     rb_hash_aset(hash, SYM("type"), SYM("ForStatement"));
-    if (stmt->init()) {
-      stmt->init()->Accept(this);
+    if (const core::Maybe<const Statement> init = stmt->init()) {
+      (*init).Accept(this);
       rb_hash_aset(hash, SYM("init"), ret_);
     }
-    if (stmt->cond()) {
-      stmt->cond()->Accept(this);
+    if (const core::Maybe<const Expression> cond = stmt->cond()) {
+      (*cond).Accept(this);
       rb_hash_aset(hash, SYM("cond"), ret_);
     }
-    if (stmt->next()) {
-      stmt->next()->Accept(this);
+    if (const core::Maybe<const Statement> next = stmt->next()) {
+      (*next).Accept(this);
       rb_hash_aset(hash, SYM("next"), ret_);
     }
     stmt->body()->Accept(this);
@@ -167,8 +168,8 @@ class Creator : public iv::core::ast::AstVisitor<AstFactory>::const_type {
   void Visit(const ContinueStatement* stmt) {
     VALUE hash = rb_hash_new();
     rb_hash_aset(hash, SYM("type"), SYM("ContinueStatement"));
-    if (stmt->label()) {
-      stmt->label()->Accept(this);
+    if (const core::Maybe<const Identifier> label = stmt->label()) {
+      (*label).Accept(this);
       rb_hash_aset(hash, SYM("label"), ret_);
     }
     SetLocation(hash, stmt);
@@ -178,8 +179,8 @@ class Creator : public iv::core::ast::AstVisitor<AstFactory>::const_type {
   void Visit(const BreakStatement* stmt) {
     VALUE hash = rb_hash_new();
     rb_hash_aset(hash, SYM("type"), SYM("BreakStatement"));
-    if (stmt->label()) {
-      stmt->label()->Accept(this);
+    if (const core::Maybe<const Identifier> label = stmt->label()) {
+      (*label).Accept(this);
       rb_hash_aset(hash, SYM("label"), ret_);
     }
     SetLocation(hash, stmt);
@@ -189,8 +190,10 @@ class Creator : public iv::core::ast::AstVisitor<AstFactory>::const_type {
   void Visit(const ReturnStatement* stmt) {
     VALUE hash = rb_hash_new();
     rb_hash_aset(hash, SYM("type"), SYM("ReturnStatement"));
-    stmt->expr()->Accept(this);
-    rb_hash_aset(hash, SYM("expr"), ret_);
+    if (const core::Maybe<const Expression> expr = stmt->expr()) {
+      (*expr).Accept(this);
+      rb_hash_aset(hash, SYM("expr"), ret_);
+    }
     SetLocation(hash, stmt);
     ret_ = hash;
   }
@@ -236,12 +239,12 @@ class Creator : public iv::core::ast::AstVisitor<AstFactory>::const_type {
   void Visit(const CaseClause* cl) {
     VALUE hash = rb_hash_new();
     rb_hash_aset(hash, SYM("type"), SYM("CaseClause"));
-    if (cl->IsDefault()) {
-      rb_hash_aset(hash, SYM("kind"), SYM("Default"));
-    } else {
+    if (const core::Maybe<const Expression> expr = cl->expr()) {
       rb_hash_aset(hash, SYM("kind"), SYM("Case"));
-      cl->expr()->Accept(this);
+      (*expr).Accept(this);
       rb_hash_aset(hash, SYM("expr"), ret_);
+    } else {
+      rb_hash_aset(hash, SYM("kind"), SYM("Default"));
     }
     VALUE stmts = rb_ary_new();
     for (Statements::const_iterator st = cl->body().begin(),
@@ -257,13 +260,28 @@ class Creator : public iv::core::ast::AstVisitor<AstFactory>::const_type {
   void Visit(const ThrowStatement* stmt) {
     VALUE hash = rb_hash_new();
     rb_hash_aset(hash, SYM("type"), SYM("ThrowStatement"));
+    stmt->expr()->Accept(this);
+    rb_hash_aset(hash, SYM("expr"), ret_);
     SetLocation(hash, stmt);
     ret_ = hash;
   }
 
   void Visit(const TryStatement* stmt) {
+    assert(stmt->catch_block() || stmt->finally_block());
     VALUE hash = rb_hash_new();
     rb_hash_aset(hash, SYM("type"), SYM("TryStatement"));
+    stmt->body()->Accept(this);
+    rb_hash_aset(hash, SYM("body"), ret_);
+    if (const core::Maybe<const Identifier> ident = stmt->catch_name()) {
+      Visit(ident.Address());
+      rb_hash_aset(hash, SYM("catch_name"), ret_);
+      Visit(stmt->catch_block().Address());
+      rb_hash_aset(hash, SYM("catch_block"), ret_);
+    }
+    if (const core::Maybe<const Block> block = stmt->finally_block()) {
+      Visit(block.Address());
+      rb_hash_aset(hash, SYM("finally_block"), ret_);
+    }
     SetLocation(hash, stmt);
     ret_ = hash;
   }
@@ -416,13 +434,6 @@ class Creator : public iv::core::ast::AstVisitor<AstFactory>::const_type {
     ret_ = hash;
   }
 
-  void Visit(const Undefined* literal) {
-    // Undefined has no location
-    VALUE hash = rb_hash_new();
-    rb_hash_aset(hash, SYM("type"), SYM("Undefined"));
-    ret_ = hash;
-  }
-
   void Visit(const RegExpLiteral* literal) {
     VALUE hash = rb_hash_new();
     rb_hash_aset(hash, SYM("type"), SYM("RegExpLiteral"));
@@ -448,16 +459,26 @@ class Creator : public iv::core::ast::AstVisitor<AstFactory>::const_type {
     VALUE hash = rb_hash_new();
     rb_hash_aset(hash, SYM("type"), SYM("ArrayLiteral"));
     VALUE array = rb_ary_new();
-    for (Expressions::const_iterator it = literal->items().begin(),
+    for (MaybeExpressions::const_iterator it = literal->items().begin(),
          last = literal->items().end(); it != last; ++it) {
-      (*it)->Accept(this);
-      rb_ary_push(array, ret_);
+      if (*it) {
+        (**it).Accept(this);
+        rb_ary_push(array, ret_);
+      } else {
+        rb_ary_push(array, NewArrayHole());
+      }
     }
     rb_hash_aset(hash, SYM("value"), array);
     SetLocation(hash, literal);
     ret_ = hash;
   }
 
+  static VALUE NewArrayHole() {
+    VALUE hash = rb_hash_new();
+    rb_hash_aset(hash, SYM("type"), SYM("ArrayHole"));
+    return hash;
+  }
+
   void Visit(const ObjectLiteral* literal) {
     using std::tr1::get;
     VALUE hash = rb_hash_new();
@@ -497,8 +518,8 @@ class Creator : public iv::core::ast::AstVisitor<AstFactory>::const_type {
   void Visit(const FunctionLiteral* literal) {
     VALUE hash = rb_hash_new();
     rb_hash_aset(hash, SYM("type"), SYM("FunctionLiteral"));
-    if (literal->name()) {
-      Visit(literal->name());
+    if (const core::Maybe<const Identifier> name = literal->name()) {
+      Visit(name.Address());
       rb_hash_aset(hash, SYM("name"), ret_);
     }
     {

data/ext/iv/phonic/factory.h

@@ -16,8 +16,7 @@ namespace phonic {
 class AstFactory : public core::Space<2> {
  public:
   AstFactory()
-    : core::Space<2>(),
-      undefined_instance_(new(this)Undefined()) {
+    : core::Space<2>() {
   }
 
   Scope* NewScope(FunctionLiteral::DeclType type) {
@@ -88,7 +87,7 @@ class AstFactory : public core::Space<2> {
   }
 
   FunctionLiteral* NewFunctionLiteral(FunctionLiteral::DeclType type,
-                                      Identifier* name,
+                                      core::Maybe<Identifier> name,
                                       Identifiers* params,
                                       Statements* body,
                                       Scope* scope,
@@ -110,7 +109,7 @@ class AstFactory : public core::Space<2> {
     return func;
   }
 
-  ArrayLiteral* NewArrayLiteral(Expressions* items,
+  ArrayLiteral* NewArrayLiteral(MaybeExpressions* items,
                                 std::size_t begin, std::size_t end) {
     ArrayLiteral* ary = new (this) ArrayLiteral(items);
     ary->Location(begin, end);
@@ -151,10 +150,6 @@ class AstFactory : public core::Space<2> {
     return th;
   }
 
-  Undefined* NewUndefined() {
-    return undefined_instance_;
-  }
-
   TrueLiteral* NewTrueLiteral(std::size_t begin, std::size_t end) {
     TrueLiteral* tr = new (this) TrueLiteral();
     tr->Location(begin, end);
@@ -201,30 +196,29 @@ class AstFactory : public core::Space<2> {
                                           Declarations* decls,
                                           std::size_t begin,
                                           std::size_t end) {
-    VariableStatement* var = new (this) VariableStatement(token, decls);
     assert(!decls->empty());
+    VariableStatement* var = new (this) VariableStatement(token, decls);
     var->Location(begin, end);
     return var;
   }
 
-  Declaration* NewDeclaration(Identifier* name, Expression* expr) {
-    assert(name && expr);
+  Declaration* NewDeclaration(Identifier* name, core::Maybe<Expression> expr) {
+    assert(name);
     Declaration* decl = new (this) Declaration(name, expr);
-    const std::size_t end = (expr->AsUndefined()) ?
-        name->end_position() : expr->end_position();
+    const std::size_t end = (expr) ? (*expr).end_position() : name->end_position();
     decl->Location(name->begin_position(), end);
     return decl;
   }
 
   IfStatement* NewIfStatement(Expression* cond,
                               Statement* then_statement,
-                              Statement* else_statement,
+                              core::Maybe<Statement> else_statement,
                               std::size_t begin) {
     IfStatement* stmt = new (this) IfStatement(cond,
                                                then_statement, else_statement);
     assert(then_statement);
     const std::size_t end = (else_statement) ?
-        else_statement->end_position() : then_statement->end_position();
+        (*else_statement).end_position() : then_statement->end_position();
     stmt->Location(begin, end);
     return stmt;
   }
@@ -258,9 +252,9 @@ class AstFactory : public core::Space<2> {
   }
 
   ForStatement* NewForStatement(Statement* body,
-                                Statement* init,
-                                Expression* cond,
-                                Statement* next,
+                                core::Maybe<Statement> init,
+                                core::Maybe<Expression> cond,
+                                core::Maybe<Statement> next,
                                 std::size_t begin) {
     assert(body);
     ForStatement* stmt = new (this) ForStatement(body, init, cond, next);
@@ -274,7 +268,7 @@ class AstFactory : public core::Space<2> {
     return stmt;
   }
 
-  ContinueStatement* NewContinueStatement(Identifier* label,
+  ContinueStatement* NewContinueStatement(core::Maybe<Identifier> label,
                                           IterationStatement** target,
                                           std::size_t begin,
                                           std::size_t end) {
@@ -283,7 +277,7 @@ class AstFactory : public core::Space<2> {
     return stmt;
   }
 
-  BreakStatement* NewBreakStatement(Identifier* label,
+  BreakStatement* NewBreakStatement(core::Maybe<Identifier> label,
                                     BreakableStatement** target,
                                     std::size_t begin,
                                     std::size_t end) {
@@ -292,10 +286,9 @@ class AstFactory : public core::Space<2> {
     return stmt;
   }
 
-  ReturnStatement* NewReturnStatement(Expression* expr,
+  ReturnStatement* NewReturnStatement(core::Maybe<Expression> expr,
                                       std::size_t begin,
                                       std::size_t end) {
-    assert(expr);
     ReturnStatement* stmt = new (this) ReturnStatement(expr);
     stmt->Location(begin, end);
     return stmt;
@@ -317,7 +310,7 @@ class AstFactory : public core::Space<2> {
   }
 
   CaseClause* NewCaseClause(bool is_default,
-                            Expression* expr, Statements* body,
+                            core::Maybe<Expression> expr, Statements* body,
                             std::size_t begin,
                             std::size_t end) {
     CaseClause* clause = new (this) CaseClause(is_default, expr, body);
@@ -336,9 +329,9 @@ class AstFactory : public core::Space<2> {
   }
 
   TryStatement* NewTryStatement(Block* try_block,
-                                Identifier* catch_name,
-                                Block* catch_block,
-                                Block* finally_block,
+                                core::Maybe<Identifier> catch_name,
+                                core::Maybe<Block> catch_block,
+                                core::Maybe<Block> finally_block,
                                 std::size_t begin) {
     TryStatement* stmt = new (this) TryStatement(try_block,
                                                  catch_name,
@@ -346,7 +339,7 @@ class AstFactory : public core::Space<2> {
                                                  finally_block);
     assert(catch_block || finally_block);
     const std::size_t end = (finally_block) ?
-        finally_block->end_position() : catch_block->end_position();
+        (*finally_block).end_position() : (*catch_block).end_position();
     stmt->Location(begin, end);
     return stmt;
   }
@@ -422,9 +415,6 @@ class AstFactory : public core::Space<2> {
     access->Location(expr->begin_position(), ident->end_position());
     return access;
   }
-
- private:
-  Undefined* undefined_instance_;
 };
 
 

metadata

@@ -2,7 +2,7 @@
 name: iv-phonic
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.1.5
+  version: 0.1.6
 platform: ruby
 authors: 
 - Constellation
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-09 00:00:00 +09:00
+date: 2011-02-10 00:00:00 +09:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -73,6 +73,7 @@ files:
 - ext/include/iv/keyword.h
 - ext/include/iv/lexer.h
 - ext/include/iv/location.h
+- ext/include/iv/maybe.h
 - ext/include/iv/mt19937.h
 - ext/include/iv/noncopyable.h
 - ext/include/iv/none.h