iv-phonic 0.0.1

data/.autotest

@@ -0,0 +1,24 @@
+# -*- coding: utf-8 -*-
+
+require 'autotest/restart'
+
+Autotest.add_hook :initialize do |at|
+#   at.extra_files << "../some/external/dependency.rb"
+#
+#   at.libs << ":../some/external"
+#
+#   at.add_exception 'vendor'
+#
+  at.add_mapping(/.*\.(?:cc|c)/) do |f, _|
+    at.files_matching(/test_.*rb$/)
+  end
+#
+#   %w(TestA TestB).each do |klass|
+#     at.extra_class_map[klass] = "test/test_misc.rb"
+#   end
+end
+
+Autotest.add_hook :run_command do |at|
+  system "rake clean compile"
+end
+# -*- ruby -*-

data/Manifest.txt

@@ -0,0 +1,49 @@
+.autotest
+Manifest.txt
+README.rdoc
+Rakefile
+test/test_iv_phonic.rb
+ext/include/iv/uchar.h
+ext/include/iv/space.h
+ext/include/iv/lexer.h
+ext/include/iv/conversions.h
+ext/include/iv/dtoa.h
+ext/include/iv/mt19937.h
+ext/include/iv/ast.h
+ext/include/iv/noncopyable.h
+ext/include/iv/ast-factory.h
+ext/include/iv/stringpiece.h
+ext/include/iv/static_assert.h
+ext/include/iv/functor.h
+ext/include/iv/parser.h
+ext/include/iv/errors.h
+ext/include/iv/ast-visitor.h
+ext/include/iv/token.h
+ext/include/iv/enable_if.h
+ext/include/iv/source.h
+ext/include/iv/any.h
+ext/include/iv/cmdline.h
+ext/include/iv/xorshift.h
+ext/include/iv/location.h
+ext/include/iv/none.h
+ext/include/iv/algorithm.h
+ext/include/iv/ustring.h
+ext/include/iv/ast-fwd.h
+ext/include/iv/utils.h
+ext/include/iv/alloc.h
+ext/include/iv/chars.h
+ext/include/iv/fixedcontainer.h
+ext/include/iv/ustringpiece.h
+ext/include/iv/ast-serializer.h
+ext/include/iv/ucdata.h
+ext/iv/phonic/rnode.h
+ext/iv/phonic/ast.h
+ext/iv/phonic/factory.h
+ext/iv/phonic/parser.h
+ext/iv/phonic/encoding.h
+ext/iv/phonic/source.h
+ext/iv/phonic/phonic.cc
+ext/iv/phonic/rparser.h
+ext/iv/phonic/creator.h
+ext/iv/phonic/ast-fwd.h
+ext/iv/phonic/extconf.rb

data/README.rdoc

@@ -0,0 +1,32 @@
+== iv / phonic
+
+https://github.com/Constellation/iv/tree/master/src/phonic/
+
+== DESCRIPTION
+
+phonic is ruby binding for iv AST API
+
+== MILESTONE
+
++ parser - done
++ specialized AST - working
+
+== TARGET
+
+Aims at flexible Ast Access API binding of ECMAScript 5th
+
+== INSTALL
+
+  gem install iv-phonic
+
+== USAGE
+
+  require 'iv/phonic'
+  require 'pp'
+  pp IV::Phonic::parse(<<-EOS)
+  var i = "OK";
+  function test() {
+    alert("OK");
+  }
+  EOS
+

data/Rakefile

@@ -0,0 +1,54 @@
+# -*- coding: utf-8 -*-
+
+require 'rubygems'
+require 'rake/extensiontask'
+require 'hoe'
+require 'pp'
+$root = File.dirname(__FILE__)
+
+directory "ext/include/iv"
+
+HOE = Hoe.spec 'iv-phonic' do
+  developer('Constellation', 'utatane.tea@gmail.com')
+  self.version = '0.0.1'
+  self.readme_file = 'README.rdoc'
+  self.history_file = 'ChangeLog'
+  self.extra_rdoc_files = FileList['*.rdoc']
+  self.extra_dev_deps << ['rake-compiler', '>= 0']
+  self.spec_extras = {
+    :extensions => ['ext/iv/phonic/extconf.rb']
+  }
+  self.summary = "iv / phonic : ECMAScript AST"
+  self.require_ruby_version '>= 1.9.1'
+end
+
+Rake::ExtensionTask.new('phonic', HOE.spec) do |ext|
+  ext.lib_dir = File.join('lib', 'iv', 'phonic')
+  ext.ext_dir = File.join('ext', 'iv', 'phonic')
+  ext.config_options << "--with-iv-include=#{File.join($root, 'ext', 'include')}"
+end
+
+Rake::Task[:test].prerequisites << :compile
+
+task :checkout => ["ext/include/iv"] do |t|
+  list = [
+    ".autotest",
+    "Manifest.txt",
+    "README.rdoc",
+    "Rakefile",
+    "test/test_iv_phonic.rb"
+  ]
+  Dir.glob("../*.h") do |f|
+    path = File.join("ext", "include", "iv", File.basename(f))
+    list << path
+    cp f, File.expand_path(path)
+  end
+  Dir.glob("ext/iv/phonic/*.*") do |f|
+    list << f
+  end
+  File.open("Manifest.txt", "w") do |f|
+    f.write(list.join("\n"))
+  end
+end
+
+# vim: syntax=ruby

data/ext/include/iv/algorithm.h

@@ -0,0 +1,23 @@
+#ifndef _IV_ALGORITHM_H
+#define _IV_ALGORITHM_H_
+namespace iv {
+namespace algorithm {
+template<class InputIterator,
+         class OutputIterator,
+         class UnaryFunction,
+         class Predicate>
+OutputIterator transform_if(InputIterator first,
+                            InputIterator last,
+                            OutputIterator result,
+                            UnaryFunction f,
+                            Predicate pred) {
+  while (first != last) {
+    if (pred(*first)) {
+      *result++ = f(*first);
+    }
+    ++first;
+  }
+  return result;
+}
+} }  // namespace iv::algorithm
+#endif  // _IV_ALGORITHM_H_

data/ext/include/iv/alloc.h

@@ -0,0 +1,200 @@
+#ifndef _IV_ALLOC_H_
+#define _IV_ALLOC_H_
+#include <cstdlib>
+#include <new>
+#include <vector>
+#include <algorithm>
+#include <string>
+#include <limits>
+#include "uchar.h"
+#include "utils.h"
+
+namespace iv {
+namespace core {
+
+// Malloc
+// memory allocated from std::malloc
+class Malloced {
+ public:
+  inline void* operator new(std::size_t size) { return New(size); }
+  void  operator delete(void* p) { Delete(p); }
+  static inline void* New(std::size_t size) {
+    void* result = std::malloc(size);
+    if (result == NULL) {
+      OutOfMemory();
+    }
+    return result;
+  }
+  static void OutOfMemory() {
+    std::exit(EXIT_FAILURE);
+  }
+  static inline void Delete(void* p) {
+    std::free(p);
+  }
+};
+
+class Pool {
+ public:
+  static const unsigned int kPoolSize = Size::KB * 4;
+  inline void Initialize(uintptr_t start, Pool* next) {
+    start_ = start;
+    position_ = start;
+    limit_ = start + Pool::kPoolSize + 1;
+    next_ = next;
+  }
+  Pool* Next() const { return next_; }
+  inline void* New(uintptr_t size) {
+    if ((position_ + size) < limit_) {
+      // in this pool
+      uintptr_t result = position_;
+      position_ += size;
+      return reinterpret_cast<void*>(result);
+    }
+    return NULL;
+  }
+ private:
+  uintptr_t start_;
+  uintptr_t position_;
+  uintptr_t limit_;
+  Pool* next_;
+};
+
+class Arena {
+ public:
+  static const unsigned int kPoolNum = 64;
+  static const uintptr_t kAlignment = 8;
+  static const unsigned int kArenaSize = (Pool::kPoolSize * kPoolNum) +
+                                ((Pool::kPoolSize <= kAlignment) ?
+                                  0 : (Pool::kPoolSize - kAlignment));
+  Arena()
+    : pools_(),
+      result_(),
+      now_(&pools_[0]),
+      start_(now_),
+      next_(NULL) {
+    uintptr_t address = reinterpret_cast<uintptr_t>(result_);
+
+    uintptr_t pool_address = AlignOffset(address, Pool::kPoolSize);
+    unsigned int c = 0;
+    for (; c < kPoolNum-1; ++c) {
+      pools_[c].Initialize(pool_address+c*Pool::kPoolSize, &pools_[c+1]);
+    }
+    pools_[kPoolNum-1].Initialize(
+        pool_address+(kPoolNum-1)*Pool::kPoolSize, NULL);
+  }
+
+  inline void* New(std::size_t raw_size) {
+    uintptr_t size = AlignOffset(raw_size, kAlignment);
+    void* result = now_->New(size);
+    if (result == NULL) {
+      now_ = now_->Next();
+      while (now_) {
+        result = now_->New(size);
+        if (result == NULL) {
+          now_ = now_->Next();
+        } else {
+          return result;
+        }
+      }
+      return NULL;  // full up
+    }
+    return result;
+  }
+  inline void SetNext(Arena* next) { next_ = next; }
+  inline Arena* Next() const { return next_; }
+ private:
+  Pool pools_[kPoolNum];
+  char result_[kArenaSize];
+  Pool* now_;
+  const Pool* start_;
+  Arena* next_;
+};
+
+template<std::size_t N>
+class Space {
+ public:
+  Space()
+    : arena_(&init_arenas_[0]),
+      start_malloced_(NULL),
+      malloced_() {
+    unsigned int c = 0;
+    for (; c < kInitArenas-1; ++c) {
+      init_arenas_[c].SetNext(&init_arenas_[c+1]);
+    }
+  }
+  virtual ~Space() {
+    if (start_malloced_) {
+      Arena *now = start_malloced_, *next = start_malloced_;
+      while (now) {
+        next = now->Next();
+        delete now;
+        now = next;
+      }
+    }
+    std::for_each(malloced_.begin(), malloced_.end(), &Malloced::Delete);
+  }
+  inline void* New(std::size_t size) {
+    if ((size - 1) < kThreshold) {
+      // small memory allocator
+      void* result = arena_->New(size);
+      if (result == NULL) {
+        Arena *arena = arena_->Next();
+        if (arena) {
+          arena_ = arena;
+        } else {
+          NewArena();
+          if (!start_malloced_) {
+            start_malloced_ = arena_;
+          }
+        }
+        result = arena_->New(size);
+        if (result == NULL) {
+          Malloced::OutOfMemory();
+        }
+      }
+      return result;
+    } else {
+      // malloc as memory allocator
+      void* result = Malloced::New(size);
+      malloced_.push_back(result);
+      return result;
+    }
+  }
+
+  virtual inline void Clear() {
+    arena_ = init_arenas_;
+    std::for_each(malloced_.begin(), malloced_.end(), &Malloced::Delete);
+    malloced_.clear();
+  }
+
+ private:
+  static const std::size_t kThreshold = 256;
+  static const std::size_t kInitArenas = N;
+
+  inline Arena* NewArena() {
+    Arena* arena = NULL;
+    try {
+      arena = new Arena();
+      if (arena == NULL) {
+        Malloced::OutOfMemory();
+        return arena;
+      }
+    } catch(const std::bad_alloc&) {
+      Malloced::OutOfMemory();
+      return arena;
+    }
+    arena_->SetNext(arena);
+    arena_ = arena;
+    return arena;
+  }
+  inline const std::vector<void*>& malloced() const {
+    return malloced_;
+  }
+  Arena init_arenas_[kInitArenas];
+  Arena* arena_;
+  Arena* start_malloced_;
+  std::vector<void*>malloced_;
+};
+
+} }  // namespace iv::core
+#endif  // _IV_ALLOC_H_

data/ext/include/iv/any.h

@@ -0,0 +1,71 @@
+#ifndef _IV_ANY_H_
+#define _IV_ANY_H_
+#include <algorithm>
+namespace iv {
+namespace core {
+
+class Any {
+ public:
+  Any() : ptr_(NULL) { }
+
+  // This is Wrapper Class,
+  // so we cannot set constructor as explicit.
+  template<typename T>
+  Any(const T & val) : ptr_(new Holder<T>(val)) { }  // NOLINT
+
+  template<typename T>
+  Any(T* val) : ptr_(new Holder<T*>(val)) { }  // NOLINT
+
+  Any(const Any & other)
+    : ptr_(other.ptr_ ? other.ptr_->Clone() : NULL) { }
+
+  ~Any() {
+    delete ptr_;
+  }
+
+  template<typename T>
+  T* As() {
+    return &(static_cast<Holder<T> *>(ptr_)->val_);
+  }
+
+  void Swap(Any& rhs) throw() {
+    using std::swap;
+    swap(ptr_, rhs.ptr_);
+  }
+
+  friend void swap(Any& rhs, Any& lhs) {
+    return rhs.Swap(lhs);
+  }
+
+  template<typename T>
+  Any& operator=(const T & rhs) {
+    Any(rhs).Swap(*this);  // NOLINT
+    return *this;
+  }
+
+  Any& operator=(Any & rhs) {
+    rhs.Swap(*this);
+    return *this;
+  }
+
+ private:
+  class Placeholder {
+   public:
+    virtual ~Placeholder() { }
+    virtual Placeholder* Clone() const = 0;
+  };
+
+  template<typename T>
+  class Holder : public Placeholder {
+   public:
+    explicit Holder(const T& val) : val_(val) { }
+    Placeholder* Clone() const {
+      return new Holder<T>(val_);
+    }
+    T val_;
+  };
+  Placeholder* ptr_;
+};
+
+} }  // namespace iv::core
+#endif  // _IV_ANY_H_