rucy 0.1.2 → 0.1.3

data/.doc/ext/rucy/tester.cpp

@@ -0,0 +1,222 @@
+#include <rucy.h>
+
+
+using namespace Rucy;
+
+
+struct Tester
+{
+
+	int value;
+
+};// Tester
+
+
+static Class cTester;
+
+
+Class
+tester_class ()
+{
+	return cTester;
+}
+
+
+namespace Rucy
+{
+
+
+	static Value
+	value (const Tester& obj)
+	{
+		return new_type<Tester>(tester_class(), new Tester(obj));
+	}
+
+	template <> inline Tester*
+	value_to<Tester*> (Value obj, bool)
+	{
+		return get_type<Tester>(obj, tester_class());
+	}
+
+
+}// Rucy
+
+
+/*
+	alloc function.
+*/
+static
+VALUE alloc(VALUE klass)
+{
+	return new_type<Tester>(klass);
+}
+
+/*
+	get value.
+*/
+static
+VALUE get_value(VALUE self)
+{
+	Tester* t = to<Tester*>(self);
+	if (t) return value(t->value);
+}
+
+/*
+	set value.
+*/
+static
+VALUE set_value(VALUE self, VALUE value)
+{
+	Tester* t = to<Tester*>(self);
+	if (t) t->value = to<int>(value);
+}
+
+/*
+	do nothing.
+*/
+static
+VALUE do_nothing(VALUE self)
+{
+}
+
+/*
+	return nil.
+*/
+static
+VALUE return_nil(VALUE self)
+{
+	return Qnil;
+}
+
+/*
+	return int.
+*/
+static
+VALUE return_int(VALUE self)
+{
+	return value(1);
+}
+
+/*
+	return flaot.
+*/
+static
+VALUE return_float(VALUE self)
+{
+	return value(1.0f);
+}
+
+/*
+	return string.
+*/
+static
+VALUE return_string(VALUE self)
+{
+	return value("");
+}
+
+/*
+	raise ruby's exception.
+*/
+static
+VALUE raise_ruby_exception(VALUE self)
+{
+	throw RubyException(rb_eStandardError, "raise_ruby_exception");
+}
+
+/*
+	raise in eval.
+*/
+static
+VALUE raise_in_eval(VALUE self)
+{
+	eval("raise 'raise_in_eval'");
+}
+
+/*
+	throw nothing.
+*/
+static
+VALUE throw_nothing(VALUE self)
+{
+	throw;
+}
+
+/*
+	throw std::exception.
+*/
+static
+VALUE throw_std_exception(VALUE self)
+{
+	throw std::exception();
+}
+
+/*
+	throw std::runtime_error.
+*/
+static
+VALUE throw_std_runtime_error(VALUE self)
+{
+	throw std::runtime_error("std::runtime_error");
+}
+
+struct MyException : public std::runtime_error
+{
+	MyException() : runtime_error("") {}
+};
+
+/*
+	throw custom exception class.
+*/
+static
+VALUE throw_custom_exception(VALUE self)
+{
+	throw MyException();
+}
+
+/*
+	throw std::string.
+*/
+static
+VALUE throw_std_string(VALUE self)
+{
+	throw std::string("std::string");
+}
+
+/*
+	throw char*.
+*/
+static
+VALUE throw_cstring(VALUE self)
+{
+	throw "cstring";
+}
+
+
+extern "C" void
+Init_tester ()
+{
+	if (!init()) return;
+
+	Module m = rb_define_module("Rucy");
+
+	Class c = rb_define_class_under(m, "Tester", rb_cObject);
+	cTester = c;
+
+	rb_define_alloc_func(c, alloc);
+	rb_define_method(c, "value", RUBY_METHOD_FUNC(get_value), 0);
+	rb_define_method(c, "value=", RUBY_METHOD_FUNC(set_value), 1);
+	rb_define_method(c, "do_nothing", RUBY_METHOD_FUNC(do_nothing), -1);
+	rb_define_method(c, "return_nil", RUBY_METHOD_FUNC(return_nil), 0);
+	rb_define_method(c, "return_int", RUBY_METHOD_FUNC(return_int), 0);
+	rb_define_method(c, "return_float", RUBY_METHOD_FUNC(return_float), 0);
+	rb_define_method(c, "return_string", RUBY_METHOD_FUNC(return_string), 0);
+	rb_define_method(c, "raise_ruby_exception", RUBY_METHOD_FUNC(raise_ruby_exception), 0);
+	rb_define_method(c, "raise_in_eval", RUBY_METHOD_FUNC(raise_in_eval), 0);
+	rb_define_method(c, "throw_nothing", RUBY_METHOD_FUNC(throw_nothing), 0);
+	rb_define_method(c, "throw_std_exception", RUBY_METHOD_FUNC(throw_std_exception), 0);
+	rb_define_method(c, "throw_std_runtime_error", RUBY_METHOD_FUNC(throw_std_runtime_error), 0);
+	rb_define_method(c, "throw_custom_exception", RUBY_METHOD_FUNC(throw_custom_exception), 0);
+	rb_define_method(c, "throw_std_string", RUBY_METHOD_FUNC(throw_std_string), 0);
+	rb_define_method(c, "throw_cstring", RUBY_METHOD_FUNC(throw_cstring), 0);
+}

data/ChangeLog

@@ -1,3 +1,8 @@
+2011-09-2 snori <snori@xord.org>
+
+	* add bin/rucy2rdoc.
+
+
 2011-08-28 snori <snori@xord.org>
 
 	* v0.1.1

data/README

@@ -1,4 +1,31 @@
 
 = Rucy - A Ruby C++ Extension Helper Library
 
-== by snori@xord.org
+ by snori@xord.org
+
+
+= What is this library?
+
+This library helps you to develop Ruby C extension library with few useful
+classes.
+
+* Wrap VALUE for easy handling.
+* Exception safe (Rucy/C++).
+
+
+= How to use
+
+$ gem install rucy
+
+write C++ source like ext/rucy/tester.cpp.
+
+
+= Examples
+
+see ext/rucy/tester.cpp.
+
+
+= Contact information.
+
+Web:  http://blog.xord.org/
+Mail: snori@xord.org

data/Rakefile

@@ -1,55 +1,28 @@
 # -*- mode: ruby; coding: utf-8 -*-
 
 
-%w[. ./lib].each do |path|
+%w[. ../xot].map {|s| "#{s}/lib"}.each do |path|
   $: << File.expand_path(File.join File.dirname(__FILE__), *path.split('/'))
 end
 
 require 'rubygems'
-require 'rbconfig'
-require 'support'
+require 'xot/rake/helpers'
+require 'xot/module'
 require 'rucy/module'
 
+include Xot::Rake
 
-MODULE = Rucy
-NAME   = MODULE.name.downcase
 
-SRCDIR  = 'src'
-INCDIR  = 'include'
-LIBDIR  = 'lib'
-EXTDIR  = 'ext'
-TASKDIR = 'task'
-
-EXTEXT = RbConfig::CONFIG['DLEXT'] || 'so'
-
-DEFS  = %w[]
-DEFS << 'WIN32' if win32?
-DEFS << 'COCOA' if cocoa?
-
-incroot = RbConfig::CONFIG['rubyhdrdir']
-INCDIRS = [
-  File.expand_path('include'),
-  incroot,
-  "#{incroot}/#{RUBY_PLATFORM}",
-  '/opt/local/include',
-  '/opt/include'
-]
-
-RBS = glob '**/*.rb'
-
-RUBY    = ENV['RUBY'] || 'ruby'
-GEM     = ENV['GEM']  || 'gem'
-GIT     = ENV['GIT']  || 'git'
-MAKE    = ENV['MAKE'] || 'make'
-CC      = RbConfig::CONFIG['CC'] || ENV['CC'] || 'g++'
-CFLAGS  = '-Wall -O' + DEFS.map{|s| " -D#{s}"}.join
-AR      = ENV['AR'] || 'ar'
-ARFLAGS = 'crs'
+MODULE     = Rucy
+INCDIRS    = [Rucy].map {|m| m.include_dirs}.flatten
+RUCY2RDOC  = 'bin/rucy2rdoc'
+NPARAM_MAX = 8
+NTIMES     = (0..NPARAM_MAX)
 
 
 task :default => :build
 
-task :build => :ext
+task :build => :lib
 
 task :rebuild => [:clean, :build]
 
@@ -57,6 +30,8 @@ task :lib => 'lib:build'
 
 task :ext => 'ext:build'
 
+task :doc => 'ext:doc'
+
 task :gem => 'gem:build'
 
 task :install => 'gem:install'
@@ -72,4 +47,4 @@ task :test => :ext do
 end
 
 
-Dir["#{TASKDIR}/**/*.rake"].each {|path| load path}
+[Xot, Rucy].each {|m| m.load_tasks}

data/VERSION

@@ -1 +1 @@
-0.1.2
+0.1.3

data/bin/rucy2rdoc

@@ -0,0 +1,113 @@
+#!/usr/bin/env ruby
+
+
+class Parser
+
+  def initialize (lines)
+    @funs = {}
+    @lines = lines
+  end
+
+  def parse ()
+    parse_functions @lines
+    parse_Init @lines
+    @lines
+  end
+
+  private
+
+    def process_lines (lines, regexp, &block)
+      lines.gsub! regexp do |str|
+        params = $~[1..-1]
+        params.unshift str
+        block.call *params
+      end
+    end
+
+    def parse_functions (lines)
+      re = %r{
+        (?:RUBY_)?DEF(\d+|N|_ALLOC)\( (\w+) \s* ((?:\, \s* \w+)*) \s* \) \s*
+        (\{ \s*
+          .*?
+        \}) \s*
+        (?:RUBY_)?END
+      }mx
+      process_lines lines, re do |all, type, name, params, body|
+        type = '-1' if type == 'N'
+        params.gsub! /\,/, ', VALUE'
+        params = '' unless params
+        if type == '_ALLOC'
+          params.gsub! /^\,\s*/, ''
+        else
+          params = 'VALUE self' + params
+        end
+        @funs[name] = {
+          :type => type,
+          :params => params,
+          :body   => body
+        }
+        "VALUE #{name}(#{params})\n#{body}"
+      end
+    end
+
+    def parse_Init (lines)
+      re = %r{
+        Init_(\w*) \s* \( \s* \) \s*
+        \{ \s*
+          .*?
+        \} \s*
+      }mx
+      process_lines lines, re do |all, name|
+        parse_module_and_class all
+        parse_methods all
+        all
+      end
+    end
+
+    def parse_module_and_class (lines)
+      re = %r{
+        (\w+) \s* \= \s*
+          (?: (\w+) \s* \. )? \s* (define_(?:module|class)) \s*
+            \( \s* (\"\w+\") \s* (?: \, \s* (\w+) )? \s* \) \s* ;
+      }mx
+      process_lines lines, re do |all, var, recv, define, name, super_|
+        define += '_under' if recv
+        recv += ", " if recv
+        super_ = 'rb_cObject' if !super_ && define =~ /class/
+        super_ = ', ' + super_ if super_
+        "#{var} = rb_#{define}(#{recv}#{name}#{super_});"
+      end
+    end
+
+    def parse_methods (lines)
+      re = %r{
+        (\w+) \s* \. \s* (define_\w+) \s*
+          \( \s* (?: (\"\w+(?:\=|\?\!)?\") \s* \, \s* )? (\w+) \s* \) \s* ;
+      }mx
+      process_lines lines, re do |all, obj, define, symbol, name|
+        type = @funs[name][:type]
+        if type == '_ALLOC'
+          "rb_#{define}(#{obj}, #{name});"
+        else
+          "rb_#{define}(#{obj}, #{symbol}, RUBY_METHOD_FUNC(#{name}), #{type});"
+        end
+      end
+    end
+
+end# Parser
+
+
+def usage ()
+  "rucy2rdoc FILE"
+end
+
+def main (argv)
+  if path = argv.shift
+    print Parser.new(File.read path).parse
+  else
+    puts usage
+  end
+end
+
+
+main ARGV.dup

data/ext/rucy/extconf.rb

@@ -1,48 +1,57 @@
 # -*- coding: utf-8 -*-
 
 
-%w[../../lib].each do |path|
+%w[. ../xot].map {|s| "../../#{s}/lib"}.each do |path|
   $: << File.expand_path(File.join File.dirname(__FILE__), *path.split('/'))
 end
 
 require 'rubygems'
 require 'mkmf'
+require 'xot/rake/helpers'
+require 'xot/module'
 require 'rucy/module'
 
+include Xot::Rake
 
-DEBUG = ENV['DEBUG'] || false
+
+DEBUG = env :DEBUG, false
 
 DEFS    = []
-INCDIRS = %w[/opt/local/include /opt/include]
+INCDIRS = %w[
+  /opt/local/include
+  /opt/include
+]
 LIBDIRS = []
 
 HEADERS = %w[
   boost/noncopyable.hpp
   ruby.h
+  xot.h
   rucy.h
 ]
-LIBS = %w[stdc++ rucy]
+LIBS = %w[
+  stdc++
+  xot
+  rucy
+]
 
 
 DEFS << '_DEBUG' if DEBUG
-
-case RUBY_PLATFORM
-when /mswin|ming|cygwin/
-  DEFS << 'WINDOWS' << 'WIN32' << $~[0].upcase
-when /darwin/
-  DEFS << 'COCOA'
-end
+DEFS << 'WINDOWS' << 'WIN32' if win32?
+DEFS << 'COCOA' if cocoa?
+DEFS << $~[0].upcase if RUBY_PLATFORM =~ /mswin|ming|cygwin|darwin/i
 
 $CPPFLAGS   << DEFS.map    {|s| " -D#{s}"}.join
 $CPPFLAGS   << INCDIRS.map {|s| " -I#{s}"}.join
 $LDFLAGS    << LIBDIRS.map {|s| " -L#{s}"}.join
 $LOCAL_LIBS << ' -lrucy'
 
-dir_config 'boost'
-dir_config 'rucy', Rucy.root_dir
+Config::CONFIG.each {|key, val| val.gsub!(/gcc/, 'g++')}
 
 
-Config::CONFIG.each {|key, val| val.gsub!(/gcc/, 'g++')}
+dir_config 'boost'
+dir_config 'xot',  Xot.root_dir
+dir_config 'rucy', Rucy.root_dir
 
 exit 1 unless HEADERS.all? {|s| have_header(s)}
 exit 1 unless LIBS.all?    {|s| have_library(s)}