iv-phonic 0.0.1

data/ext/iv/phonic/factory.h

@@ -0,0 +1,247 @@
+#ifndef _IV_PHONIC_FACTORY_H_
+#define _IV_PHONIC_FACTORY_H_
+#include <tr1/array>
+#include <ruby.h>
+#include <ruby/oniguruma.h>
+#include <iv/alloc.h>
+#include <iv/ustringpiece.h>
+#include "encoding.h"
+#include "ast.h"
+namespace iv {
+namespace phonic {
+
+class AstFactory : public core::Space<2> {
+ public:
+  AstFactory()
+    : core::Space<2>(),
+      undefined_instance_(new(this)Undefined()),
+      empty_statement_instance_(new(this)EmptyStatement()),
+      debugger_statement_instance_(new(this)DebuggerStatement()),
+      this_instance_(new(this)ThisLiteral()),
+      null_instance_(new(this)NullLiteral()),
+      true_instance_(new(this)TrueLiteral()),
+      false_instance_(new(this)FalseLiteral()) {
+  }
+
+  Identifier* NewIdentifier(const core::UStringPiece& buffer) {
+    Identifier* ident = new (this) Identifier(buffer, this);
+    return ident;
+  }
+
+  Identifier* NewIdentifier(const std::vector<uc16>& buffer) {
+    Identifier* ident = new (this) Identifier(buffer, this);
+    return ident;
+  }
+
+  Identifier* NewIdentifier(const std::vector<char>& buffer) {
+    Identifier* ident = new (this) Identifier(buffer, this);
+    return ident;
+  }
+
+  NumberLiteral* NewNumberLiteral(const double& val) {
+    return new (this) NumberLiteral(val);
+  }
+
+  StringLiteral* NewStringLiteral(const std::vector<uc16>& buffer) {
+    return new (this) StringLiteral(buffer, this);
+  }
+
+  Directivable* NewDirectivable(const std::vector<uc16>& buffer) {
+    return new (this) Directivable(buffer, this);
+  }
+
+  RegExpLiteral* NewRegExpLiteral(const std::vector<uc16>& content,
+                                  const std::vector<uc16>& flags) {
+//    OnigErrorInfo einfo;
+//    regex_t* reg;
+//    // TODO(Constellation) Little Endian?
+//    int r = onig_new(&reg,
+//                     reinterpret_cast<const OnigUChar*>(content.data()),
+//                     reinterpret_cast<const OnigUChar*>(content.data()+content.size()),
+//                     ONIG_OPTION_DEFAULT, rb_enc_get(Encoding::UTF16LEEncoding()),
+//                     ONIG_SYNTAX_DEFAULT, &einfo);
+//    if (r != ONIG_NORMAL) {
+//      return NULL;
+//    }
+//    onig_free(reg);
+    return new (this) RegExpLiteral(content, flags, this);
+  }
+
+  FunctionLiteral* NewFunctionLiteral(FunctionLiteral::DeclType type) {
+    return new (this) FunctionLiteral(type, this);
+  }
+
+  ArrayLiteral* NewArrayLiteral() {
+    return new (this) ArrayLiteral(this);
+  }
+
+  ObjectLiteral* NewObjectLiteral() {
+    return new (this) ObjectLiteral(this);
+  }
+
+  Identifiers* NewLabels() {
+    return new (New(sizeof(Identifiers)))
+        Identifiers(Identifiers::allocator_type(this));
+  }
+
+  NullLiteral* NewNullLiteral() {
+    return null_instance_;
+  }
+
+  EmptyStatement* NewEmptyStatement() {
+    return empty_statement_instance_;
+  }
+
+  DebuggerStatement* NewDebuggerStatement() {
+    return debugger_statement_instance_;
+  }
+
+  ThisLiteral* NewThisLiteral() {
+    return this_instance_;
+  }
+
+  Undefined* NewUndefined() {
+    return undefined_instance_;
+  }
+
+  TrueLiteral* NewTrueLiteral() {
+    return true_instance_;
+  }
+
+  FalseLiteral* NewFalseLiteral() {
+    return false_instance_;
+  }
+
+  FunctionStatement* NewFunctionStatement(FunctionLiteral* func) {
+    return new (this) FunctionStatement(func);
+  }
+
+  Block* NewBlock() {
+    return new (this) Block(this);
+  }
+
+  VariableStatement* NewVariableStatement(core::Token::Type token) {
+    return new (this) VariableStatement(token, this);
+  }
+
+  Declaration* NewDeclaration(Identifier* name, Expression* expr) {
+    return new (this) Declaration(name, expr);
+  }
+
+  IfStatement* NewIfStatement(Expression* cond, Statement* then) {
+    return new (this) IfStatement(cond, then);
+  }
+
+  DoWhileStatement* NewDoWhileStatement() {
+    return new (this) DoWhileStatement();
+  }
+
+  WhileStatement* NewWhileStatement(Expression* expr) {
+    return new (this) WhileStatement(expr);
+  }
+
+  ForInStatement* NewForInStatement(Statement* each, Expression* enumerable) {
+    return new (this) ForInStatement(each, enumerable);
+  }
+
+  ExpressionStatement* NewExpressionStatement(Expression* expr) {
+    return new (this) ExpressionStatement(expr);
+  }
+
+  ForStatement* NewForStatement() {
+    return new (this) ForStatement();
+  }
+
+  ContinueStatement* NewContinueStatement() {
+    return new (this) ContinueStatement();
+  }
+
+  BreakStatement* NewBreakStatement() {
+    return new (this) BreakStatement();
+  }
+
+  ReturnStatement* NewReturnStatement(Expression* expr) {
+    return new (this) ReturnStatement(expr);
+  }
+
+  WithStatement* NewWithStatement(Expression* expr, Statement* stmt) {
+    return new (this) WithStatement(expr, stmt);
+  }
+
+  SwitchStatement* NewSwitchStatement(Expression* expr) {
+    return new (this) SwitchStatement(expr, this);
+  }
+
+  CaseClause* NewCaseClause() {
+    return new (this) CaseClause(this);
+  }
+
+  ThrowStatement*  NewThrowStatement(Expression* expr) {
+    return new (this) ThrowStatement(expr);
+  }
+
+  TryStatement* NewTryStatement(Block* block) {
+    return new (this) TryStatement(block);
+  }
+
+  LabelledStatement* NewLabelledStatement(Expression* expr, Statement* stmt) {
+    return new (this) LabelledStatement(expr, stmt);
+  }
+
+  BinaryOperation* NewBinaryOperation(core::Token::Type op,
+                                      Expression* result,
+                                      Expression* right) {
+    return new (this) BinaryOperation(op, result, right);
+  }
+
+  Assignment* NewAssignment(core::Token::Type op,
+                            Expression* left,
+                            Expression* right) {
+    return new (this) Assignment(op, left, right);
+  }
+
+  ConditionalExpression* NewConditionalExpression(Expression* cond,
+                                                  Expression* left,
+                                                  Expression* right) {
+    return new (this) ConditionalExpression(cond, left, right);
+  }
+
+  UnaryOperation* NewUnaryOperation(core::Token::Type op,
+                                    Expression* expr) {
+    return new (this) UnaryOperation(op, expr);
+  }
+
+  PostfixExpression* NewPostfixExpression(core::Token::Type op,
+                                          Expression* expr) {
+    return new (this) PostfixExpression(op, expr);
+  }
+
+  FunctionCall* NewFunctionCall(Expression* expr) {
+    return new (this) FunctionCall(expr, this);
+  }
+
+  ConstructorCall* NewConstructorCall(Expression* target) {
+    return new (this) ConstructorCall(target, this);
+  }
+
+  IndexAccess* NewIndexAccess(Expression* expr, Expression* index) {
+    return new (this) IndexAccess(expr, index);
+  }
+
+  IdentifierAccess* NewIdentifierAccess(Expression* expr, Identifier* ident) {
+    return new (this) IdentifierAccess(expr, ident);
+  }
+
+ private:
+  Undefined* undefined_instance_;
+  EmptyStatement* empty_statement_instance_;
+  DebuggerStatement* debugger_statement_instance_;
+  ThisLiteral* this_instance_;
+  NullLiteral* null_instance_;
+  TrueLiteral* true_instance_;
+  FalseLiteral* false_instance_;
+};
+
+
+} }  // namespace iv::phonic
+#endif  // _IV_PHONIC_FACTORY_H_

data/ext/iv/phonic/parser.h

@@ -0,0 +1,12 @@
+#ifndef _IV_PHONIC_PARSER_H_
+#define _IV_PHONIC_PARSER_H_
+#include <ruby.h>
+#include <iv/parser.h>
+#include "factory.h"
+namespace iv {
+namespace phonic {
+
+typedef core::Parser<AstFactory> Parser;
+
+} }  // namespace iv::phonic
+#endif  // _IV_PHONIC_PARSER_H_

data/ext/iv/phonic/phonic.cc

@@ -0,0 +1,69 @@
+#include <ruby.h>
+#include "rparser.h"
+
+#define RBFUNC(func) (reinterpret_cast<VALUE(*)(...)>(func))
+
+extern "C" {
+
+void Init_phonic() {
+  iv::phonic::Encoding::Init();
+  // IV
+  VALUE mIV = rb_define_module("IV");
+
+  // IV::Phonic
+  VALUE mIVPhonic = rb_define_module_under(mIV, "Phonic");
+  rb_define_module_function(mIVPhonic, "parse",
+                            RBFUNC(&iv::phonic::RParser::Parse), 1);
+
+  iv::phonic::RParser::Init(mIVPhonic);
+
+  VALUE cNode = rb_define_class_under(mIVPhonic, "Node", rb_cObject);
+  VALUE cExpr = rb_define_class_under(mIVPhonic, "Expression", cNode);
+  VALUE cStmt = rb_define_class_under(mIVPhonic, "Statement", cNode);
+
+  // Expressions
+  rb_define_class_under(mIVPhonic, "Identifier", cExpr);
+  rb_define_class_under(mIVPhonic, "StringLiteral", cExpr);
+  rb_define_class_under(mIVPhonic, "NumberLiteral", cExpr);
+  rb_define_class_under(mIVPhonic, "RegExpLiteral", cExpr);
+  rb_define_class_under(mIVPhonic, "FunctionLiteral", cExpr);
+  rb_define_class_under(mIVPhonic, "ArrayLiteral", cExpr);
+  rb_define_class_under(mIVPhonic, "ObjectLiteral", cExpr);
+  rb_define_class_under(mIVPhonic, "NullLiteral", cExpr);
+  rb_define_class_under(mIVPhonic, "ThisLiteral", cExpr);
+  rb_define_class_under(mIVPhonic, "Undefined", cExpr);
+  rb_define_class_under(mIVPhonic, "TrueLiteral", cExpr);
+  rb_define_class_under(mIVPhonic, "FalseLiteral", cExpr);
+  rb_define_class_under(mIVPhonic, "ConditionalExpression", cExpr);
+  rb_define_class_under(mIVPhonic, "PostfixExpression", cExpr);
+  rb_define_class_under(mIVPhonic, "BinaryOperation", cExpr);
+  rb_define_class_under(mIVPhonic, "UnaryOperation", cExpr);
+  rb_define_class_under(mIVPhonic, "Assignment", cExpr);
+  rb_define_class_under(mIVPhonic, "FunctionCall", cExpr);
+  rb_define_class_under(mIVPhonic, "ConstructorCall", cExpr);
+  rb_define_class_under(mIVPhonic, "IndexAccess", cExpr);
+  rb_define_class_under(mIVPhonic, "IdentifierAccess", cExpr);
+
+  // Statements
+  rb_define_class_under(mIVPhonic, "Block", cStmt);
+  rb_define_class_under(mIVPhonic, "VariableStatement", cStmt);
+  rb_define_class_under(mIVPhonic, "IfStatement", cStmt);
+  rb_define_class_under(mIVPhonic, "DoWhileStatement", cStmt);
+  rb_define_class_under(mIVPhonic, "WhileStatement", cStmt);
+  rb_define_class_under(mIVPhonic, "ForInStatement", cStmt);
+  rb_define_class_under(mIVPhonic, "ForStatement", cStmt);
+  rb_define_class_under(mIVPhonic, "ExpressionStatement", cStmt);
+  rb_define_class_under(mIVPhonic, "ContinueStatement", cStmt);
+  rb_define_class_under(mIVPhonic, "ReturnStatement", cStmt);
+  rb_define_class_under(mIVPhonic, "BreakStatement", cStmt);
+  rb_define_class_under(mIVPhonic, "WithStatement", cStmt);
+  rb_define_class_under(mIVPhonic, "SwitchStatement", cStmt);
+  rb_define_class_under(mIVPhonic, "ThrowStatement", cStmt);
+  rb_define_class_under(mIVPhonic, "TryStatement", cStmt);
+  rb_define_class_under(mIVPhonic, "LabelledStatement", cStmt);
+  rb_define_class_under(mIVPhonic, "DebuggerStatement", cStmt);
+}
+
+}
+
+#undef RBFUNC

data/ext/iv/phonic/rnode.h

@@ -0,0 +1,15 @@
+#ifndef _IV_PHONIC_RNODE_H_
+#define _IV_PHONIC_RNODE_H_
+#include <cstdlib>
+#include <cstring>
+#include <tr1/type_traits>
+#include <ruby.h>
+#include <ruby/encoding.h>
+#include <ruby/intern.h>
+#include <iv/ast.h>
+#include <iv/static_assert.h>
+namespace iv {
+namespace phonic {
+
+} }  // namespace iv::phonic
+#endif  // _IV_PHONIC_RNODE_H_

data/ext/iv/phonic/rparser.h

@@ -0,0 +1,48 @@
+#ifndef _IV_PHONIC_RPARSER_H_
+#define _IV_PHONIC_RPARSER_H_
+#include <cstdlib>
+#include <cstring>
+#include <tr1/type_traits>
+#include <ruby.h>
+#include <ruby/encoding.h>
+#include <ruby/intern.h>
+#include <iv/parser.h>
+#include "encoding.h"
+#include "factory.h"
+#include "parser.h"
+#include "creator.h"
+#include "source.h"
+namespace iv {
+namespace phonic {
+
+static VALUE cParseError;
+
+class RParser {
+ public:
+  static VALUE Parse(VALUE self, VALUE rb_str) {
+    AstFactory factory;
+    Check_Type(rb_str, T_STRING);
+    VALUE encoded_rb_str = rb_str_encode(rb_str,
+                                         Encoding::UTF16Encoding(),
+                                         0,
+                                         Qnil);
+    const char* str = StringValuePtr(encoded_rb_str);
+    std::size_t len = RSTRING_LEN(encoded_rb_str);
+    UTF16Source source(str, len);
+    Parser parser(&source, &factory);
+    FunctionLiteral* global = parser.ParseProgram();
+    if (!global) {
+      rb_raise(cParseError, "%s", parser.error().c_str());
+    } else {
+      Creator creator;
+      return creator.Result(global);
+    }
+  }
+
+  static void Init(VALUE mIVPhonic) {
+    cParseError = rb_define_class_under(mIVPhonic, "ParseError", rb_eStandardError);
+  }
+};
+
+} }  // namespace iv::phonic
+#endif  // _IV_PHONIC_RPARSER_H_

data/ext/iv/phonic/source.h

@@ -0,0 +1,146 @@
+#ifndef _IV_PHONIC_SOURCE_H_
+#define _IV_PHONIC_SOURCE_H_
+#include <cstddef>
+#include <cassert>
+#include <string>
+#include <tr1/cstdint>
+#include <ruby.h>
+#include <iv/source.h>
+#include <iv/stringpiece.h>
+#include <iv/ustring.h>
+#include <iv/none.h>
+namespace iv {
+namespace phonic {
+namespace detail {
+template<typename T>
+class FilenameData {
+ public:
+  static const std::string kFilename;
+};
+
+template<typename T>
+const std::string FilenameData<T>::kFilename = "<anonymous>";
+
+}  // namespace iv::phonic::detail
+
+typedef detail::FilenameData<core::None> FilenameData;
+
+class AsciiSource : public core::BasicSource {
+ public:
+  static const int kEOS = -1;
+  explicit AsciiSource(const char* str)
+    : source_(str) {
+  }
+  ~AsciiSource() { }
+
+  inline uc16 Get(std::size_t pos) const {
+    assert(pos < size());
+    return source_[pos];
+  }
+  inline std::size_t size() const {
+    return source_.size();
+  }
+  inline const std::string& filename() const {
+    return FilenameData::kFilename;
+  }
+  inline core::UStringPiece SubString(
+      std::size_t n, std::size_t len = std::string::npos) const {
+    return core::UStringPiece();
+  }
+
+ private:
+  std::string source_;
+};
+
+class UTF16Source : public core::BasicSource {
+ public:
+  static const int kEOS = -1;
+  explicit UTF16Source(const char* str, std::size_t len)
+    : buf_(reinterpret_cast<const uint16_t*>(str)),
+      size_(len / 2) {
+      assert(len % 2 == 0);
+  }
+  ~UTF16Source() { }
+
+  inline uc16 Get(std::size_t pos) const {
+    assert(pos < size());
+    return *(buf_ + pos);
+  }
+  inline std::size_t size() const {
+    return size_;
+  }
+  inline const std::string& filename() const {
+    return FilenameData::kFilename;
+  }
+  inline core::UStringPiece SubString(
+      std::size_t n, std::size_t len = std::string::npos) const {
+    return core::UStringPiece();
+  }
+
+ private:
+  const uint16_t* buf_;
+  std::size_t size_;
+};
+
+class UTF16LESource : public core::BasicSource {
+ public:
+  static const int kEOS = -1;
+  explicit UTF16LESource(const char* str, std::size_t len)
+    : buf_(str),
+      size_(len / 2) {
+      assert(len % 2 == 0);
+  }
+  ~UTF16LESource() { }
+
+  inline uc16 Get(std::size_t pos) const {
+    assert(pos < size());
+    return (*(buf_ + pos*2)) | (*(buf_ + pos*2 + 1) << 8);
+  }
+  inline std::size_t size() const {
+    return size_;
+  }
+  inline const std::string& filename() const {
+    return FilenameData::kFilename;
+  }
+  inline core::UStringPiece SubString(
+      std::size_t n, std::size_t len = std::string::npos) const {
+    return core::UStringPiece();
+  }
+
+ private:
+  const char* buf_;
+  std::size_t size_;
+};
+
+class UTF16BESource : public core::BasicSource {
+ public:
+  static const int kEOS = -1;
+  explicit UTF16BESource(const char* str, std::size_t len)
+    : buf_(str),
+      size_(len / 2) {
+      assert(len % 2 == 0);
+  }
+  ~UTF16BESource() { }
+
+  inline uc16 Get(std::size_t pos) const {
+    assert(pos < size());
+    return (*(buf_ + pos*2) << 8) | (*(buf_ + pos*2 + 1));
+  }
+  inline std::size_t size() const {
+    return size_;
+  }
+  inline const std::string& filename() const {
+    return FilenameData::kFilename;
+  }
+  inline core::UStringPiece SubString(
+      std::size_t n, std::size_t len = std::string::npos) const {
+    return core::UStringPiece();
+  }
+
+ private:
+  const char* buf_;
+  std::size_t size_;
+};
+
+} }  // namespace iv::phonic
+#endif  // _IV_PHONIC_SOURCE_H_

data/test/test_iv_phonic.rb

@@ -0,0 +1,32 @@
+# -*- coding: utf-8 -*-
+require "test/unit"
+require "iv/phonic"
+require "pp"
+
+class TestPhonic < Test::Unit::TestCase
+  def test_phonic
+    assert(Object.const_defined? :IV)
+    assert(IV.const_defined? :Phonic)
+  end
+  def test_parse
+    assert_respond_to(IV::Phonic, :parse)
+    assert_raise(TypeError) {
+      IV::Phonic::parse(100);
+    }
+    assert_raise(TypeError) {
+      IV::Phonic::parse(/TEST/);
+    }
+    assert_raise(TypeError) {
+      IV::Phonic::parse(IV);
+    }
+    assert(IV::Phonic::parse("FILE"))
+    assert(IV::Phonic::parse("T"))
+    assert(IV::Phonic::parse("var test = \"おはようございます\";"))
+    assert_raise(IV::Phonic::ParseError) {
+      IV::Phonic::parse("var test = var;")
+    }
+    assert_nothing_raised {
+      IV::Phonic::parse("var test = /test/;")
+    }
+  end
+end