iv-phonic 0.1.5 → 0.1.6

data/ext/include/iv/ast_visitor.h

@@ -71,7 +71,6 @@ class BasicAstVisitor
   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

data/ext/include/iv/maybe.h

@@ -0,0 +1,72 @@
+#ifndef _IV_MAYBE_H_
+#define _IV_MAYBE_H_
+#include <cassert>
+#include <algorithm>
+#include <tr1/type_traits>
+#include "enable_if.h"
+
+// Maybe NULL pointer wrapper class
+// not have ownership
+
+namespace iv {
+namespace core {
+
+template<class T>
+class Maybe {
+ public:
+  typedef Maybe<T> this_type;
+  typedef void (this_type::*bool_type)() const;
+
+  Maybe(T* ptr) : ptr_(ptr) { }
+  Maybe() : ptr_(NULL) { }
+
+  template<class U>
+  Maybe(const Maybe<U>& rhs,
+        typename enable_if<std::tr1::is_convertible<U*, T*> >::type* = 0)
+    : ptr_(rhs.get_address_maybe_null()) {
+  }
+
+  T& operator*() const {
+    assert(ptr_);
+    return *ptr_;
+  }
+
+  T* Address() const {
+    assert(ptr_);
+    return ptr_;
+  }
+
+  operator bool_type() const {
+    return ptr_ != NULL ?
+        &this_type::this_type_does_not_support_comparisons : 0;
+  }
+
+  template<typename U>
+  this_type& operator=(const Maybe<U>& rhs) {
+    if (this != &rhs) {
+      this_type(rhs).swap(*this);
+    }
+    return *this;
+  }
+
+  inline void swap(this_type& rhs) {
+    using std::swap;
+    swap(ptr_, rhs.ptr_);
+  }
+
+  inline friend void swap(this_type& lhs, this_type& rhs) {
+    return lhs.swap(rhs);
+  }
+
+  inline T* get_address_maybe_null() const {
+    return ptr_;
+  }
+
+ private:
+  void this_type_does_not_support_comparisons() const { }
+
+  T* ptr_;
+};
+
+} }  // namespace iv::core
+#endif  // _IV_MAYBE_H_

data/ext/include/iv/parser.h

@@ -8,6 +8,7 @@
 #include <tr1/type_traits>
 #include <tr1/array>
 #include "static_assert.h"
+#include "maybe.h"
 #include "ast.h"
 #include "ast_factory.h"
 #include "lexer.h"
@@ -152,7 +153,7 @@ class Parser
 #define V(AST) typedef typename ast::AST<Factory> AST;
   AST_NODE_LIST(V)
 #undef V
-#define V(X, XS) typedef typename SpaceVector<Factory, X *>::type XS;
+#define V(XS) typedef typename ast::AstNode<Factory>::XS XS;
   AST_LIST_LIST(V)
 #undef V
 #define V(S) typedef typename SpaceUString<Factory>::type S;
@@ -263,6 +264,11 @@ class Parser
     Next();
     const bool strict = ParseSourceElements(Token::EOS, body, CHECK);
     const std::size_t end_position = lexer_.end_position();
+#ifdef DEBUG
+    if (error_flag) {
+      assert(params && body && scope);
+    }
+#endif
     return (error_flag) ?
         factory_->NewFunctionLiteral(FunctionLiteral::GLOBAL,
                                      NULL,
@@ -464,6 +470,7 @@ class Parser
         FunctionLiteral::GENERAL, CHECK);
     // define named function as FunctionDeclaration
     scope_->AddFunctionDeclaration(expr);
+    assert(expr);
     return factory_->NewFunctionDeclaration(expr);
   }
 
@@ -486,6 +493,7 @@ class Parser
       body->push_back(stmt);
     }
     Next();
+    assert(body);
     Block* const block = factory_->NewBlock(body,
                                             begin,
                                             lexer_.previous_end_position());
@@ -503,6 +511,7 @@ class Parser
     Declarations* const decls = factory_->template NewVector<Declaration*>();
     ParseVariableDeclarations(decls, token_ == Token::CONST, true, CHECK);
     ExpectSemicolon(CHECK);
+    assert(decls);
     return factory_->NewVariableStatement(op,
                                           decls,
                                           begin,
@@ -552,10 +561,12 @@ class Parser
         Next();
         // AssignmentExpression
         expr = ParseAssignmentExpression(contains_in, CHECK);
+        assert(name);
         decl = factory_->NewDeclaration(name, expr);
       } else {
         // Undefined Expression
-        decl = factory_->NewDeclaration(name, factory_->NewUndefined());
+        assert(name);
+        decl = factory_->NewDeclaration(name, NULL);
       }
       decls->push_back(decl);
       scope_->AddUnresolved(name, is_const);
@@ -593,6 +604,7 @@ class Parser
       Next();
       else_statement = ParseStatement(CHECK);
     }
+    assert(expr && then_statement);
     return factory_->NewIfStatement(expr,
                                     then_statement,
                                     else_statement,
@@ -635,6 +647,7 @@ class Parser
     if (token_ == Token::SEMICOLON) {
       Next();
     }
+    assert(stmt && expr);
     DoWhileStatement* const dowhile = factory_->NewDoWhileStatement(
         stmt, expr, begin, lexer_.previous_end_position());
     target.set_node(dowhile);
@@ -655,6 +668,7 @@ class Parser
     EXPECT(Token::RPAREN);
 
     Statement* const stmt = ParseStatement(CHECK);
+    assert(stmt);
     WhileStatement* const whilestmt = factory_->NewWhileStatement(stmt,
                                                                   expr, begin);
 
@@ -687,6 +701,7 @@ class Parser
             factory_->template NewVector<Declaration*>();
         ParseVariableDeclarations(decls, token_ == Token::CONST, false, CHECK);
         if (token_ == Token::IN) {
+          assert(decls);
           VariableStatement* const var =
               factory_->NewVariableStatement(op,
                                              decls,
@@ -705,12 +720,14 @@ class Parser
           EXPECT(Token::RPAREN);
           Target target(this, Target::kIterationStatement);
           Statement* const body = ParseStatement(CHECK);
+          assert(body && init && enumerable);
           ForInStatement* const forstmt =
               factory_->NewForInStatement(body, init, enumerable,
                                           for_stmt_begin);
           target.set_node(forstmt);
           return forstmt;
         } else {
+          assert(decls);
           init = factory_->NewVariableStatement(op, decls,
                                                 begin,
                                                 lexer_.end_position());
@@ -719,6 +736,7 @@ class Parser
         Expression* const init_expr = ParseExpression(false, CHECK);
         if (token_ == Token::IN) {
           // for in loop
+          assert(init_expr);
           init = factory_->NewExpressionStatement(init_expr,
                                                   lexer_.previous_end_position());
           if (!init_expr->IsValidLeftHandSide()) {
@@ -729,12 +747,14 @@ class Parser
           EXPECT(Token::RPAREN);
           Target target(this, Target::kIterationStatement);
           Statement* const body = ParseStatement(CHECK);
+          assert(body && init && enumerable);
           ForInStatement* const forstmt =
               factory_->NewForInStatement(body, init, enumerable,
                                           for_stmt_begin);
           target.set_node(forstmt);
           return forstmt;
         } else {
+          assert(init_expr);
           init = factory_->NewExpressionStatement(init_expr,
                                                   lexer_.end_position());
         }
@@ -757,7 +777,8 @@ class Parser
     if (token_ == Token::RPAREN) {
       Next();
     } else {
-      Expression* next_expr = ParseExpression(true, CHECK);
+      Expression* const next_expr = ParseExpression(true, CHECK);
+      assert(next_expr);
       next = factory_->NewExpressionStatement(next_expr,
                                               lexer_.previous_end_position());
       EXPECT(Token::RPAREN);
@@ -765,6 +786,7 @@ class Parser
 
     Target target(this, Target::kIterationStatement);
     Statement* const body = ParseStatement(CHECK);
+    assert(body);
     ForStatement* const forstmt =
         factory_->NewForStatement(body, init, cond, next, for_stmt_begin);
     target.set_node(forstmt);
@@ -845,7 +867,6 @@ class Parser
 //  ReturnStatement
 //    : RETURN Expression_opt ';'
   Statement* ParseReturnStatement(bool *res) {
-    // TODO(Constellation) NewUndefined -> NULL
     assert(token_ == Token::RETURN);
     const std::size_t begin = lexer_.begin_position();
     Next();
@@ -861,11 +882,11 @@ class Parser
         token_ == Token::RBRACE ||
         token_ == Token::EOS) {
       ExpectSemicolon(CHECK);
-      return factory_->NewReturnStatement(factory_->NewUndefined(),
+      return factory_->NewReturnStatement(NULL,
                                           begin,
                                           lexer_.previous_end_position());
     }
-    Expression *expr = ParseExpression(true, CHECK);
+    Expression* const expr = ParseExpression(true, CHECK);
     ExpectSemicolon(CHECK);
     return factory_->NewReturnStatement(expr, begin,
                                         lexer_.previous_end_position());
@@ -891,6 +912,7 @@ class Parser
     EXPECT(Token::RPAREN);
 
     Statement *stmt = ParseStatement(CHECK);
+    assert(expr && stmt);
     return factory_->NewWithStatement(expr, stmt, begin);
   }
 
@@ -934,6 +956,7 @@ class Parser
       clauses->push_back(case_clause);
     }
     Next();
+    assert(expr && clauses);
     SwitchStatement* const switch_stmt =
         factory_->NewSwitchStatement(expr, clauses,
                                      begin,
@@ -973,6 +996,7 @@ class Parser
       body->push_back(stmt);
     }
 
+    assert(body);
     return factory_->NewCaseClause(expr == NULL,
                                    expr, body,
                                    begin, lexer_.previous_end_position());
@@ -990,6 +1014,7 @@ class Parser
     }
     Expression* const expr = ParseExpression(true, CHECK);
     ExpectSemicolon(CHECK);
+    assert(expr);
     return factory_->NewThrowStatement(expr,
                                        begin, lexer_.previous_end_position());
   }
@@ -1055,6 +1080,7 @@ class Parser
       RAISE("missing catch or finally after try statement");
     }
 
+    assert(try_block);
     return factory_->NewTryStatement(try_block,
                                      name, catch_block,
                                      finally_block, begin);
@@ -1074,6 +1100,7 @@ class Parser
   Statement* ParseExpressionStatement(bool *res) {
     Expression* const expr = ParseExpression(true, CHECK);
     ExpectSemicolon(CHECK);
+    assert(expr);
     return factory_->NewExpressionStatement(expr,
                                             lexer_.previous_end_position());
   }
@@ -1105,9 +1132,11 @@ class Parser
       const LabelSwitcher label_switcher(this, labels, exist_labels);
 
       Statement* const stmt = ParseStatement(CHECK);
+      assert(expr && stmt);
       return factory_->NewLabelledStatement(expr, stmt);
     }
     ExpectSemicolon(CHECK);
+    assert(expr);
     return factory_->NewExpressionStatement(expr,
                                             lexer_.previous_end_position());
   }
@@ -1124,7 +1153,9 @@ class Parser
         FunctionLiteral::GENERAL,
         CHECK);
     // define named function as variable declaration
-    scope_->AddUnresolved(expr->name(), false);
+    assert(expr);
+    assert(expr->name());
+    scope_->AddUnresolved(expr->name().Address(), false);
     return factory_->NewFunctionStatement(expr);
   }
 
@@ -1146,6 +1177,7 @@ class Parser
     while (token_ == Token::COMMA) {
       Next();
       right = ParseAssignmentExpression(contains_in, CHECK);
+      assert(result && right);
       result = factory_->NewBinaryOperation(Token::COMMA, result, right);
     }
     return result;
@@ -1178,6 +1210,7 @@ class Parser
     const Token::Type op = token_;
     Next();
     Expression* const right = ParseAssignmentExpression(contains_in, CHECK);
+    assert(result && right);
     return factory_->NewAssignment(op, result, right);
   }
 
@@ -1192,6 +1225,7 @@ class Parser
       Expression* const left = ParseAssignmentExpression(true, CHECK);
       EXPECT(Token::COLON);
       Expression* const right = ParseAssignmentExpression(contains_in, CHECK);
+      assert(result && left && right);
       result = factory_->NewConditionalExpression(result, left, right);
     }
     return result;
@@ -1293,6 +1327,7 @@ class Parser
       op = token_;
       Next();
       right = ParseBinaryExpression(contains_in, 2, CHECK);
+      assert(left && right);
       left = factory_->NewBinaryOperation(op, left, right);
     }
     if (prec < 4) return left;
@@ -1305,6 +1340,7 @@ class Parser
       op = token_;
       Next();
       right = ParseBinaryExpression(contains_in, 3, CHECK);
+      assert(left && right);
       left = factory_->NewBinaryOperation(op, left, right);
     }
     if (prec < 5) return left;
@@ -1341,6 +1377,7 @@ class Parser
       op = token_;
       Next();
       right = ParseBinaryExpression(contains_in, 7, CHECK);
+      assert(left && right);
       left = factory_->NewBinaryOperation(op, left, right);
     }
     if (prec < 9) return left;
@@ -1350,6 +1387,7 @@ class Parser
       op = token_;
       Next();
       right = ParseBinaryExpression(contains_in, 8, CHECK);
+      assert(left && right);
       left = factory_->NewBinaryOperation(op, left, right);
     }
     return left;
@@ -1420,11 +1458,13 @@ class Parser
         }
 
         default:
+          assert(left && right);
           res = factory_->NewBinaryOperation(op, left, right);
           break;
       }
       return res;
     } else {
+      assert(left && right);
       return factory_->NewBinaryOperation(op, left, right);
     }
   }
@@ -1434,6 +1474,7 @@ class Parser
                                     Expression* left,
                                     Expression* right,
                                     typename enable_if_c<!Reduce>::type* = 0) {
+    assert(left && right);
     return factory_->NewBinaryOperation(op, left, right);
   }
 
@@ -1458,6 +1499,7 @@ class Parser
       case Token::TYPEOF:
         Next();
         expr = ParseUnaryExpression(CHECK);
+        assert(expr);
         result = factory_->NewUnaryOperation(op, expr, begin);
         break;
 
@@ -1471,6 +1513,7 @@ class Parser
             expr->AsIdentifier()) {
           RAISE("delete to direct identifier not allowed in strict code");
         }
+        assert(expr);
         result = factory_->NewUnaryOperation(op, expr, begin);
         break;
 
@@ -1481,6 +1524,7 @@ class Parser
           result = factory_->NewReducedNumberLiteral(
               ~DoubleToInt32(expr->AsNumberLiteral()->value()));
         } else {
+          assert(expr);
           result = factory_->NewUnaryOperation(op, expr, begin);
         }
         break;
@@ -1491,6 +1535,7 @@ class Parser
         if (expr->AsNumberLiteral()) {
           result = expr;
         } else {
+          assert(expr);
           result = factory_->NewUnaryOperation(op, expr, begin);
         }
         break;
@@ -1502,6 +1547,7 @@ class Parser
           result = factory_->NewReducedNumberLiteral(
               -(expr->AsNumberLiteral()->value()));
         } else {
+          assert(expr);
           result = factory_->NewUnaryOperation(op, expr, begin);
         }
         break;
@@ -1528,6 +1574,7 @@ class Parser
             }
           }
         }
+        assert(expr);
         result = factory_->NewUnaryOperation(op, expr, begin);
         break;
 
@@ -1563,6 +1610,7 @@ class Parser
           }
         }
       }
+      assert(expr);
       expr = factory_->NewPostfixExpression(token_, expr,
                                             lexer_.end_position());
       Next();
@@ -1600,6 +1648,7 @@ class Parser
       if (token_ == Token::LPAREN) {
         ParseArguments(args, CHECK);
       }
+      assert(target && args);
       expr = factory_->NewConstructorCall(target, args, lexer_.previous_end_position());
     }
     while (true) {
@@ -1607,6 +1656,7 @@ class Parser
         case Token::LBRACK: {
           Next();
           Expression* const index = ParseExpression(true, CHECK);
+          assert(expr && index);
           expr = factory_->NewIndexAccess(expr, index);
           EXPECT(Token::RBRACK);
           break;
@@ -1616,6 +1666,7 @@ class Parser
           Next<IgnoreReservedWords>();  // IDENTIFIERNAME
           IS(Token::IDENTIFIER);
           Identifier* const ident = ParseIdentifier(lexer_.Buffer());
+          assert(expr && ident);
           expr = factory_->NewIdentifierAccess(expr, ident);
           break;
         }
@@ -1625,6 +1676,7 @@ class Parser
             Expressions* const args =
                 factory_->template NewVector<Expression*>();
             ParseArguments(args, CHECK);
+            assert(expr && args);
             expr = factory_->NewFunctionCall(expr, args,
                                              lexer_.previous_end_position());
           } else {
@@ -1800,12 +1852,12 @@ class Parser
 //    | Elision ','
   Expression* ParseArrayLiteral(bool *res) {
     const std::size_t begin = lexer_.begin_position();
-    Expressions* const items = factory_->template NewVector<Expression*>();
+    MaybeExpressions* const items = factory_->template NewVector<Maybe<Expression> >();
     Next();
     while (token_ != Token::RBRACK) {
       if (token_ == Token::COMMA) {
         // when Token::COMMA, only increment length
-        items->push_back(NULL);
+        items->push_back(Maybe<Expression>());
       } else {
         Expression* const expr = ParseAssignmentExpression(true, CHECK);
         items->push_back(expr);
@@ -1815,6 +1867,7 @@ class Parser
       }
     }
     Next();
+    assert(items);
     return factory_->NewArrayLiteral(items,
                                      begin, lexer_.previous_end_position());
   }
@@ -1959,6 +2012,7 @@ class Parser
     }
     const std::size_t end = lexer_.begin_position();
     Next();
+    assert(prop);
     return factory_->NewObjectLiteral(prop, begin, end);
   }
 
@@ -2135,6 +2189,7 @@ class Parser
     }
     Next();
     const std::size_t end_block_position = lexer_.previous_end_position();
+    assert(params && body && scope);
     return factory_->NewFunctionLiteral(decl_type,
                                         name,
                                         params,

data/ext/iv/phonic/ast_fwd.h

@@ -52,7 +52,7 @@ namespace phonic {
 #define V(AST) typedef core::ast::AST<AstFactory> AST;
   AST_NODE_LIST(V)
 #undef V
-#define V(X, XS) typedef core::SpaceVector<AstFactory, X *>::type XS;
+#define V(XS) typedef core::ast::AstNode<AstFactory>::XS XS;
   AST_LIST_LIST(V)
 #undef V
 #define V(S) typedef core::SpaceUString<AstFactory>::type S;