wurlinc-rice 1.4.0.1

data/ruby/lib/mkmf-rice.rb.in

@@ -0,0 +1,216 @@
+# Make sure that archflags does not include ppc if we're 
+# on Intel x86 processor on Mac, and that we use the proper
+# arch depending on 10.5 or 10.6
+if `uname`.chomp == "Darwin"
+  arch = 
+    if RUBY_PLATFORM =~ /darwin10/
+      'x86_64'
+    else
+      `uname -p`.chomp
+    end
+
+  ENV["ARCHFLAGS"] = "-arch #{arch}"
+end
+
+require 'mkmf'
+require 'rbconfig'
+
+# 
+# A script to override some defaults in mkmf.rb for C++ code
+# compilation.
+#
+# If this looks like a big hack, that's because it is.
+#
+
+def init_mkmf_rice(config = CONFIG)
+  # Set some defaults that we got from autoconf -- they're more likely
+  # to be correct than what Ruby was built with
+  $CXX = "@CXX@"
+  $LIBS = "@RUBY_LIBS@"
+  $LIBRUBYARG = "@RUBY_LIBRUBYARG@"
+  $LIBRUBYARG_STATIC = "@RUBY_LIBRUBYARG_STATIC@"
+  $RICE_CPPFLAGS = "@RICE_CPPFLAGS@"
+  $RICE_LDFLAGS = "@RICE_LDFLAGS@"
+  $RICE_PREFIX = "@prefix@"
+
+  $RICE_USING_MINGW32 = @RICE_USING_MINGW32@
+
+  # Ruby < 1.8.6 does not have $DEFLIBPATH
+  $DEFLIBPATH ||= []
+
+  # We use this for the samples
+  $DEFLIBPATH.unshift(with_config('libpath')) if with_config('libpath')
+
+  # Ruby 1.8.6 uses $preload without setting it
+  $preload ||= nil
+
+  $CPPFLAGS << " #{$RICE_CPPFLAGS} -I#{$RICE_PREFIX}/include"
+  $LDFLAGS << " #{$RICE_LDFLAGS} -L#{$RICE_PREFIX}/lib"
+
+  # Turn on debugging and verbose warnings by default on compilers that
+  # support it
+  $CXXFLAGS = ''
+  if $CXX == 'g++'
+    $CXXFLAGS << ' -Wall -g'
+  end
+
+  # Fix-up the linker used for confidence tests
+  TRY_LINK.sub!(/^#{Regexp.quote("$(CC)")}/, $CXX)
+  TRY_LINK.sub!(/^#{config['CC']}/, $CXX)
+  TRY_LINK.sub!(/#{Regexp.quote("$(CFLAGS)")}/, "$(CXXFLAGS)")
+
+  # Set $LDSHARED_CXX to the linker to be used for C++ libraries (usually
+  # the C++ compiler itself)
+  case config['target_os']
+  when 'darwin'
+    $LDSHARED_CXX = \
+      replace_cc_with_cxx(config['LDSHARED']) + \
+      ' -read_only_relocs suppress'
+  when 'mswin32'
+    if $RICE_USING_MINGW32 then
+      init_rice_mkmf_cross_compile_mingw2_for_vc6
+    end
+  else
+    $LDSHARED_CXX = \
+      replace_cc_with_cxx(config['LDSHARED'])
+  end
+
+  # Link against the rice library by default
+  have_library('rice') or raise 
+end
+
+def replace_cc_with_cxx(str)
+  return str.sub(
+      /^(cc|\$\(CC\)|#{CONFIG['CC']})(?=\s)/,
+      $CXX)
+end
+
+def init_rice_mkmf_cross_compile_mingw2_for_vc6
+  $LDSHARED_CXX = "#{$CXX} -shared -s"
+  $OBJEXT = 'o'
+  $DLDFLAGS.gsub!(/^-link.*\.pdb$/, '')
+
+  constants = {
+    :TRY_LINK =>
+      "#{$LDSHARED_CXX} -oconftest $(INCFLAGS) $(CPPFLAGS) " + \
+      "$(CFLAGS) $(src) $(LIBPATH) $(LDFLAGS) $(ARCH_FLAG) " + \
+      "$(LOCAL_LIBS) $(LIBS)",
+    :LINK_SO =>
+      "#{$LDSHARED_CXX} $(DLDFLAGS) $(LIBPATH) -o$@ " + \
+      "$(OBJS) $(LOCAL_LIBS) $(LIBS)",
+    :LIBARG =>
+        '-l%s',
+    :LIBPATHFLAG =>
+        ' -L %s',
+    :COMPILE_RULES =>
+        %w[.%s.%s:],
+    :RULE_SUBST =>
+        '%s',
+    :COMPILE_CXX =>
+        '$(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $<',
+    :OUTFLAG =>
+        '-o',
+  }
+
+  constants.each do |name, value|
+    Object.instance_eval { remove_const name }
+    Object.const_set(name, value)
+  end
+end
+
+class Object
+  alias_method :configuration_orig, :configuration
+  def configuration(srcdir)
+    configuration = configuration_orig(srcdir)
+    configuration.each do |config|
+      # Make sure we link the extension using the C++ compiler
+      config.gsub!(/^LDSHARED\s*=.*$/, "LDSHARED = #{$LDSHARED_CXX}")
+
+      # Make sure set the C++ flags correctly
+      config.gsub!(/^CXXFLAGS\s*=.*$/, "CXXFLAGS = $(CFLAGS) #{$CXXFLAGS}")
+    end
+    configuration << "\nCXX = #{$CXX}"
+    return configuration
+  end
+
+  alias_method :link_command_orig, :link_command
+  def link_command(ldflags, opt='', libpath=$DEFLIBPATH|$LIBPATH)
+    link_command = link_command_orig(ldflags, opt, libpath)
+    return Config::expand(
+        link_command,
+        'CXXFLAGS' => "#{$CXXFLAGS}")
+  end
+
+  alias_method :create_header_orig, :create_header
+  def create_header(header = 'extconf.hpp')
+    create_header_orig(header)
+  end
+
+  alias_method :create_makefile_orig, :create_makefile
+  def create_makefile(target, srcprefix = nil)
+    makefile_creator = RiceMakefileCreator.new
+    makefile_creator.create_makefile(target, srcprefix)
+  end
+end
+
+class RiceMakefileCreator
+  def create_makefile(target, srcprefix)
+    create_makefile_orig(target, srcprefix)
+  end
+
+  class MakefileWriter
+    def self.new(file, mode)
+      file = super(file, mode)
+      if block_given? then
+        begin
+          yield file
+        ensure
+          file.close if not file.closed?
+        end
+      else
+        return file
+      end
+    end
+
+    def initialize(file, mode)
+      @file = File.open(file, mode)
+    end
+
+    def print(*strings)
+      strings.each do |string|
+        # Make sure -lruby comes after -lrice (necessary on some
+        # platforms)
+        string = string.to_s.gsub(/^(LIBS\s*=\s*)(#{Regexp.quote($LIBRUBYARG)})\s+(.*)\s+(#{$LIBS})$/, '\1\3\2 \4')
+        @file.print(string)
+      end
+    end
+
+    def printf(format, *args)
+      @file.printf(format, *args)
+    end
+
+    def puts(*strings)
+      print(*strings.flatten.map { |s| "#{s}\n" })
+    end
+
+    def close
+      @file.close
+    end
+
+    def closed?
+      return @file.closed?
+    end
+  end
+
+  def open(file, mode, &block)
+    # Intercept makefile output using the MakefileWriter
+    if file == 'Makefile' then
+      return MakefileWriter.new(file, mode, &block)
+    else
+      return super(file, mode, &block)
+    end
+  end
+end
+
+init_mkmf_rice
+

data/ruby/lib/version.rb

@@ -0,0 +1,3 @@
+module Rice
+  VERSION = "1.4.0"
+end

data/ruby.ac

@@ -0,0 +1,136 @@
+dnl Get a key from ruby's configuration table
+AC_DEFUN([RUBY_CONFIG], [
+          $RUBY -rrbconfig -e "puts(Config::CONFIG[['$1']] || '')"])
+
+AC_DEFUN([RB_INIT_RUBY], [
+
+AC_ARG_WITH(
+    ruby,
+    AC_HELP_STRING(
+     --with-ruby=PATH,
+     [ path to the ruby interpreter [[ruby]] ]),
+    [ RUBY=$withval ],
+    [ RUBY=ruby ])
+AC_ARG_WITH(
+    ruby_sitelibdir,
+    AC_HELP_STRING(
+     --with-ruby-sitelibdir=PATH,
+     [ path to install ruby scripts [[auto-detect]] ]),
+    [ ruby_sitelibdir=$withval ],
+    [ ruby_sitelibdir=NONE ])
+
+AC_SUBST(RUBY)
+
+RUBY_VERSION_CODE=`$RUBY -e "puts RUBY_VERSION.gsub(/\./, '')"`
+AC_SUBST(RUBY_VERSION_CODE)
+
+RUBY_CONFIG_SO_NAME=`RUBY_CONFIG(RUBY_SO_NAME)`
+RUBY_CONFIG_ARCHDIR=`RUBY_CONFIG(archdir)`
+RUBY_CONFIG_ARCH=`RUBY_CONFIG(arch)`
+RUBY_CONFIG_LIBDIR=`RUBY_CONFIG(libdir)`
+RUBY_CONFIG_BINDIR=`RUBY_CONFIG(bindir)`
+RUBY_CONFIG_RUBYHDRDIR=`RUBY_CONFIG(rubyhdrdir)`
+RUBY_CONFIG_CFLAGS=`RUBY_CONFIG(CFLAGS)`
+RUBY_CONFIG_LIBS=`RUBY_CONFIG(LIBS)`
+RUBY_CONFIG_DLDLIBS=`RUBY_CONFIG(DLDLIBS)`
+RUBY_CONFIG_LDFLAGS=`RUBY_CONFIG(LDFLAGS)`
+RUBY_CONFIG_LIBRUBYARG=`RUBY_CONFIG(LIBRUBYARG)`
+RUBY_CONFIG_LIBRUBYARG_STATIC=`RUBY_CONFIG(LIBRUBYARG_STATIC)`
+RUBY_CONFIG_CCDLFLAGS=`RUBY_CONFIG(CCDLFLAGS)`
+
+if test "x${RUBY_CONFIG_RUBYHDRDIR}x" != "xx"; then
+  # 1.9
+  RUBY_CPPFLAGS="-I${RUBY_CONFIG_RUBYHDRDIR}"
+  RUBY_CPPFLAGS="${RUBY_CPPFLAGS} -I${RUBY_CONFIG_RUBYHDRDIR}/${RUBY_CONFIG_ARCH}"
+else
+  # 1.8
+  RUBY_CPPFLAGS="-I${RUBY_CONFIG_ARCHDIR}"
+fi
+AC_SUBST(RUBY_CPPFLAGS)
+
+RUBY_CFLAGS="${RUBY_CONFIG_CFLAGS} ${RUBY_CONFIG_CCDLFLAGS}"
+AC_SUBST(RUBY_CFLAGS)
+
+RUBY_CXXFLAGS="${RUBY_CONFIG_CFLAGS} ${RUBY_CONFIG_CCDLFLAGS}"
+AC_SUBST(RUBY_CXXFLAGS)
+
+RUBY_LDFLAGS="-L${RUBY_CONFIG_ARCHDIR} -L${RUBY_CONFIG_LIBDIR} ${RUBY_CONFIG_LDFLAGS}"
+AC_SUBST(RUBY_LDFLAGS)
+
+RUBY_LIBS="${RUBY_CONFIG_LIBS} ${RUBY_CONFIG_DLDLIBS}"
+AC_SUBST(RUBY_LIBS)
+ 
+RUBY_LIBRUBYARG="${RUBY_CONFIG_LIBRUBYARG}"
+AC_SUBST(RUBY_LIBRUBYARG)
+
+RUBY_LIBRUBYARG_STATIC="${RUBY_CONFIG_LIBRUBYARG_STATIC}"
+AC_SUBST(RUBY_LIBRUBYARG_STATIC)
+
+dnl If the user specified a prefix, then use it, otherwise defalut to
+dnl the configured sitelibdir
+if test "x${ruby_sitelibdir}x" != "xNONEx"
+then
+  RUBY_SITELIBDIR="${ruby_sitelibdir}"
+else
+  if test "x${prefix}x" = "xNONEx"
+  then
+    RUBY_SITELIBDIR=`RUBY_CONFIG(sitelibdir)`
+  else
+    sitelibdir_no_prefix=`$RUBY -rrbconfig \
+    -e "include Config; \
+    puts CONFIG[['sitelibdir']].sub(CONFIG[['prefix']], '')"`
+    RUBY_SITELIBDIR="${prefix}/${sitelibdir_no_prefix}"
+  fi
+fi
+AC_SUBST(RUBY_SITELIBDIR)
+
+dnl The fourth parameter to AC_CHECK_HEADER keeps autoconf from
+dnl searching for standard header files as a side-effect (which we want)
+CPPFLAGS_save="${CPPFLAGS}"
+CPPFLAGS="${CPPFLAGS} ${RUBY_CPPFLAGS}"
+CXXFLAGS="${CPPFLAGS}"
+AC_CHECK_HEADERS(ruby.h,,AC_MSG_ERROR(
+                could not find ruby.h (check config.log)),[ ])
+AC_CHECK_HEADERS(node.h,,,[
+#include <ruby.h>
+])
+AC_CHECK_HEADERS(ruby/node.h,
+                 [ AC_DEFINE(REALLY_HAVE_RUBY_NODE_H, [],
+                             [ Define this macro to use ruby/node.h ]) ],
+                             ,[
+#include <ruby.h>
+])
+AC_CHECK_HEADERS(version.h,,,[
+#include <ruby.h>
+])
+AC_CHECK_HEADERS(env.h,,,[
+#include <ruby.h>
+])
+
+CPPFLAGS="${CPPFLAGS_save}"
+
+AC_MINGW32
+
+if test x"${MINGW32}"x = xyesx; then
+  RB_FIX_MINGW_LIBS
+fi
+
+]) dnl RB_INIT_RUBY
+
+dnl We would like to be able to build using MingW against the one-click
+dnl installer, which is built using VC6.  So, we detect this situation
+dnl and fix up the link step if this is the case.
+dnl
+dnl Static linking isn't likely to work correctly, so we disable it by
+dnl default, but if the user asks for LIBRUBYARG_STATIC, they'll still
+dnl get static linking.
+AC_DEFUN([RB_FIX_MINGW_LIBS], [
+RUBY_LIBS=`echo ${RUBY_LIBS} | sed -e "s%oldnames.lib%-lmoldname%"`
+RUBY_LIBS=`echo ${RUBY_LIBS} | sed -e "s%user32.lib%-luser32%"`
+RUBY_LIBS=`echo ${RUBY_LIBS} | sed -e "s%advapi32.lib%-ladvapi32%"`
+RUBY_LIBS=`echo ${RUBY_LIBS} | sed -e "s%ws2_32.lib%-lws2_32%"`
+RUBY_LIBRUBYARG=`echo ${RUBY_LIBRUBYARG} | sed -e "s%\(msvcrt-ruby.*\).lib%${RUBY_CONFIG_BINDIR}/\1.dll%"`
+RUBY_LIBRUBYARG_STATIC=`echo ${RUBY_LIBRUBYARG_STATIC} | sed -e "s%\(msvcrt-ruby.*\).lib%${RUBY_CONFIG_LIBDIR}/\1.lib%"`
+]) dnl RB_FIX_MINGW_LIBS
+
+dnl vim:ft=config

data/sample/Makefile.am

@@ -0,0 +1,47 @@
+RUBY_EXTCONF_OPTIONS = -I@RICE_ROOT@/ruby/lib
+EXTCONF_OPTIONS = --with-cppflags="-I@RICE_ROOT@" --with-libpath="@RICE_ROOT@/rice"
+
+EXTRA_DIST = \
+	enum/extconf.rb \
+	enum/sample_enum.cpp \
+	enum/test.rb \
+	map/extconf.rb \
+	map/map.cpp \
+	map/test.rb \
+	inheritance/extconf.rb \
+	inheritance/animals.cpp \
+	inheritance/test.rb
+
+enum/Makefile: enum/extconf.rb ../config.status ../ruby/lib/mkmf-rice.rb
+	@RUBY@ $(RUBY_EXTCONF_OPTIONS) -C enum extconf.rb $(EXTCONF_OPTIONS)
+
+map/Makefile: map/extconf.rb ../config.status ../ruby/lib/mkmf-rice.rb
+	@RUBY@ $(RUBY_EXTCONF_OPTIONS) -C map extconf.rb $(EXTCONF_OPTIONS)
+
+inheritance/Makefile: inheritance/extconf.rb ../config.status ../ruby/lib/mkmf-rice.rb
+	@RUBY@ $(RUBY_EXTCONF_OPTIONS) -C inheritance extconf.rb $(EXTCONF_OPTIONS)
+
+all: enum/Makefile map/Makefile inheritance/Makefile all_extensions
+
+all_extensions:
+	@for sample in $(RICE_SAMPLES); \
+	do \
+	  $(MAKE) -C $${sample} all; \
+	done
+
+clean: enum/Makefile map/Makefile inheritance/Makefile clean_extensions
+
+clean_extensions:
+	@for sample in $(RICE_SAMPLES); \
+	do \
+	  $(MAKE) -C $${sample} clean; \
+	done
+
+distclean: enum/Makefile map/Makefile inheritance/Makefile distclean_extensions
+
+distclean_extensions:
+	@for sample in $(RICE_SAMPLES);
+	do \
+	  $(MAKE) -C $${sample} distclean; \
+	done
+

data/sample/enum/extconf.rb

@@ -0,0 +1,3 @@
+require 'mkmf-rice'
+create_makefile('sample_enum')
+

data/sample/enum/sample_enum.cpp

@@ -0,0 +1,54 @@
+#include "rice/Enum.hpp"
+#include "rice/ruby_try_catch.hpp"
+
+using namespace Rice;
+
+namespace
+{
+
+enum Sample_Enum
+{
+  SE_FOO = 1,
+  SE_BAR = 42,
+  SE_BAZ = 100,
+};
+
+Rice::Enum<Sample_Enum> sample_enum_type;
+
+char const * description(Sample_Enum e)
+{
+  switch(e)
+  {
+    case SE_FOO: return "Fairly Ordinary Object";
+    case SE_BAR: return "Beginner's All-purpose Ratchet";
+    case SE_BAZ: return "Better than A Zebra";
+  }
+  return "???";
+}
+
+} // namespace
+
+template<>
+Sample_Enum from_ruby<Sample_Enum>(Object x)
+{
+  Data_Object<Sample_Enum> d(x, sample_enum_type);
+  return *d;
+}
+
+extern "C"
+void Init_sample_enum()
+{
+  RUBY_TRY
+  {
+    sample_enum_type =
+      define_enum<Sample_Enum>("Sample_Enum")
+      .define_value("FOO", SE_FOO)
+      .define_value("BAR", SE_BAR)
+      .define_value("BAZ", SE_BAZ);
+     
+    sample_enum_type
+      .define_method("description", description);
+  }
+  RUBY_CATCH
+}
+

data/sample/enum/test.rb

@@ -0,0 +1,8 @@
+require 'sample_enum'
+
+Sample_Enum.each { |x| p x }
+s = Sample_Enum::FOO
+puts s
+puts s.inspect
+puts s < Sample_Enum::BAR
+

data/sample/inheritance/animals.cpp

@@ -0,0 +1,98 @@
+#include "rice/Data_Type.hpp"
+#include "rice/Constructor.hpp"
+
+using namespace Rice;
+
+class Organism
+{
+public:
+  virtual ~Organism() = 0;
+  virtual char const * name() = 0;
+};
+
+Organism::
+~Organism()
+{
+}
+
+class Animal
+  : public Organism
+{
+public:
+  virtual ~Animal() = 0;
+  virtual char const * speak() = 0;
+};
+
+Animal::
+~Animal()
+{
+}
+
+class Bear
+  : public Animal
+{
+public:
+  virtual char const * name()
+  {
+    return "Bear";
+  }
+
+  virtual char const * speak()
+  {
+    return "I'm smarter than the average bear";
+  }
+};
+
+class Dog
+  : public Animal
+{
+public:
+  virtual char const * name()
+  {
+    return "Dog";
+  }
+
+  virtual char const * speak()
+  {
+    return "Woof woof";
+  }
+};
+
+class Rabbit
+  : public Animal
+{
+public:
+  virtual char const * name()
+  {
+    return "Rabbit";
+  }
+
+  virtual char const * speak()
+  {
+    return "What's up, doc?";
+  }
+};
+
+extern "C"
+void Init_animals(void)
+{
+  RUBY_TRY
+  {
+    define_class<Organism>("Organism")
+      .define_method("name", &Organism::name);
+
+    define_class<Animal, Organism>("Animal")
+      .define_method("speak", &Animal::speak);
+
+    define_class<Bear, Animal>("Bear")
+      .define_constructor(Constructor<Bear>());
+      
+    define_class<Dog, Animal>("Dog")
+      .define_constructor(Constructor<Dog>());
+
+    define_class<Rabbit, Animal>("Rabbit")
+      .define_constructor(Constructor<Rabbit>());
+  }
+  RUBY_CATCH
+}
+

data/sample/inheritance/extconf.rb

@@ -0,0 +1,3 @@
+require 'mkmf-rice'
+create_makefile('animals')
+

data/sample/inheritance/test.rb

@@ -0,0 +1,7 @@
+require 'animals'
+
+[ Bear, Dog, Rabbit].each do |klass|
+  animal = klass.new
+  puts "A #{animal.name} says: #{animal.speak}"
+end
+

data/sample/map/extconf.rb

@@ -0,0 +1,3 @@
+require 'mkmf-rice'
+create_makefile('map')
+

data/sample/map/map.cpp

@@ -0,0 +1,81 @@
+#include "rice/Data_Type.hpp"
+#include "rice/Constructor.hpp"
+
+#include <map>
+
+using namespace Rice;
+
+namespace
+{
+
+class Map
+{
+private:
+  struct Ruby_Value_Compare
+  {
+    bool operator()(Object lhs, Object rhs) const
+    {
+      Object result = lhs.call("<", rhs);
+      return result.test();
+    }
+  };
+
+  typedef std::map<Object, Object, Ruby_Value_Compare> Value_Map;
+
+public:
+  Object bracket(Object k)
+  {
+    Value_Map::iterator it = map_.find(k);
+    return it == map_.end() ? Object(Qnil) : it->second;
+  }
+
+  Object bracket_equals(Object k, Object v)
+  {
+    map_[k] = v;
+    return Qnil;
+  }
+
+  Value_Map::iterator begin() { return map_.begin(); }
+  Value_Map::iterator end() { return map_.end(); }
+
+  typedef Value_Map::value_type value_type;
+  typedef Value_Map::iterator iterator;
+
+private:
+  Value_Map map_;
+};
+
+Data_Type<Map> rb_cMap;
+
+} // namespace
+
+template<>
+Object to_ruby<Map::value_type>(Map::value_type const & p)
+{
+  return protect(rb_assoc_new, p.first, p.second);
+}
+
+#include <iostream>
+extern "C"
+void Init_map(void)
+{
+  RUBY_TRY
+  {
+    Map::iterator (Map::*begin)() = &Map::begin;
+    Map::iterator (Map::*end)() = &Map::end;
+    Rice::Module rb_mStd = define_module("Std");
+
+    // TODO: no delete method on the map, because I'm not sure how to
+    // make delete work properly while iterating
+    rb_cMap =
+      define_class_under<Map>(rb_mStd, "Map")
+      .define_constructor(Constructor<Map>())
+      .define_method("[]", &Map::bracket)
+      .define_method("[]=", &Map::bracket_equals)
+      .define_iterator(begin, end)
+      .include_module(rb_mEnumerable)
+      ;
+  }
+  RUBY_CATCH
+}
+

data/sample/map/test.rb

@@ -0,0 +1,7 @@
+require 'map'
+m = Std::Map.new
+m[0] = 1
+m[1] = 2
+m[3] = 3
+m.each { |x| p x }
+