RubyInlineWithoutZenTest 3.12.2

data/demo/fastmath.rb

@@ -0,0 +1,27 @@
+
+begin require 'rubygems' rescue LoadError end
+require 'inline'
+
+class FastMath
+  def factorial(n)
+    f = 1
+    n.downto(2) { |x| f *= x }
+    return f
+  end
+  inline do |builder|
+    builder.c "
+    long factorial_c(int max) {
+      int i=max, result=1;
+      while (i >= 2) { result *= i--; }
+      return result;
+    }"
+  end
+end
+
+math = FastMath.new
+
+if ARGV.empty? then
+  30000.times do math.factorial(20); end
+else
+  30000.times do math.factorial_c(20); end
+end

data/demo/hello.rb

@@ -0,0 +1,13 @@
+#!/usr/local/bin/ruby -w
+
+begin require 'rubygems' rescue LoadError end
+require 'inline'
+
+class Hello
+  inline do |builder|
+    builder.include "<stdio.h>"
+    builder.c 'void hello() { puts("hello world"); }'
+  end
+end
+
+Hello.new.hello

data/example.rb

@@ -0,0 +1,86 @@
+#!/usr/local/bin/ruby -w
+
+require 'rubygems'
+$:.unshift 'lib'
+require 'inline'
+
+require 'fileutils'
+FileUtils.rm_rf File.expand_path("~/.ruby_inline")
+
+class MyTest
+
+  def factorial(n)
+    f = 1
+    n.downto(2) { |x| f *= x }
+    f
+  end
+
+  inline do |builder|
+    builder.c "
+    long factorial_c(int max) {
+      int i=max, result=1;
+      while (i >= 2) { result *= i--; }
+      return result;
+    }"
+
+    builder.c_raw "
+    static
+    VALUE
+    factorial_c_raw(int argc, VALUE *argv, VALUE self) {
+      int i=FIX2INT(argv[0]), result=1;
+      while (i >= 2) { result *= i--; }
+      return INT2NUM(result);
+    }"
+  end
+end
+
+# breakeven for build run vs native doing 5 factorial:
+#   on a PIII/750 running FreeBSD:        about 5000
+#   on a PPC/G4/800 running Mac OSX 10.2: always faster
+
+require 'benchmark'
+puts "RubyInline #{Inline::VERSION}" if $DEBUG
+
+MyTest.send(:alias_method, :factorial_alias, :factorial_c_raw)
+
+t = MyTest.new()
+max = (ARGV.shift || 1_000_000).to_i
+n   = (ARGV.shift || 5).to_i
+m   = t.factorial(n)
+
+def validate(n, m)
+  if n != m then raise "#{n} != #{m}"; end
+end
+
+puts "# of iterations = #{max}, n = #{n}"
+Benchmark::bm(20) do |x|
+  x.report("null_time") do
+    for i in 0..max do
+      # do nothing
+    end
+  end
+
+  x.report("c") do
+    for i in 0..max do
+      validate(t.factorial_c(n), m)
+    end
+  end
+
+  x.report("c-raw") do
+    for i in 0..max do
+      validate(t.factorial_c_raw(n), m)
+    end
+  end
+
+  x.report("c-alias") do
+    for i in 0..max do
+      validate(t.factorial_alias(n), m)
+    end
+  end
+
+  x.report("pure ruby") do
+    for i in 0..max do
+      validate(t.factorial(n), m)
+    end
+  end
+end

data/example2.rb

@@ -0,0 +1,33 @@
+#!/usr/local/bin/ruby17 -w
+
+begin
+  require 'rubygems'
+rescue LoadError
+  $: << 'lib'
+end
+require 'inline'
+
+class MyTest
+
+  inline do |builder|
+
+    builder.add_compile_flags %q(-x c++)
+    builder.add_link_flags %q(-lstdc++)
+
+    builder.include "<iostream>"
+
+    builder.c "
+static
+void
+hello(int i) {
+  while (i-- > 0) {
+    std::cout << \"hello\" << std::endl;
+  }
+}
+"
+  end
+end
+
+t = MyTest.new()
+
+t.hello(3)

data/lib/inline/mapping.rb

@@ -0,0 +1,119 @@
+##
+# Inline::Mapping - mapping method names from impl to test.
+#
+# Method names are mapped bidirectionally in the following way:
+#
+#   method      test_method
+#   method?     test_method_eh          (too much exposure to Canadians :)
+#   method!     test_method_bang
+#   method=     test_method_equals
+#   []          test_index
+#   *           test_times
+#   ==          test_equals2
+#   ===         test_equals3
+#
+# Further, any of the test methods should be able to have arbitrary
+# extensions put on the name to distinguish edge cases:
+#
+#   method      test_method
+#   method      test_method_simple
+#   method      test_method_no_network
+#
+# To allow for unmapped test methods (ie, non-unit tests), name them:
+#
+#   test_integration_.*
+
+module Inline
+  module Mapping
+
+    @@orig_method_map = {
+      '!'   => 'bang',
+      '%'   => 'percent',
+      '&'   => 'and',
+      '*'   => 'times',
+      '**'  => 'times2',
+      '+'   => 'plus',
+      '-'   => 'minus',
+      '/'   => 'div',
+      '<'   => 'lt',
+      '<='  => 'lte',
+      '<=>' => 'spaceship',
+      "<\<" => 'lt2',
+      '=='  => 'equals2',
+      '===' => 'equals3',
+      '=~'  => 'equalstilde',
+      '>'   => 'gt',
+      '>='  => 'ge',
+      '>>'  => 'gt2',
+      '+@'  => 'unary_plus',
+      '-@'  => 'unary_minus',
+      '[]'  => 'index',
+      '[]=' => 'index_equals',
+      '^'   => 'carat',
+      '|'   => 'or',
+      '~'   => 'tilde',
+    }
+
+    @@method_map = @@orig_method_map.merge(@@orig_method_map.invert)
+
+    @@mapped_re = @@orig_method_map.values.sort_by { |k| k.length }.map {|s|
+      Regexp.escape(s)
+    }.reverse.join("|")
+
+    def munge name
+      name = name.to_s.dup
+
+      is_cls_method = name.sub!(/^self\./, '')
+
+      name = @@method_map[name] if @@method_map.has_key? name
+      name = name.sub(/=$/, '_equals')
+      name = name.sub(/\?$/, '_eh')
+      name = name.sub(/\!$/, '_bang')
+
+      name = yield name if block_given?
+
+      name = "class_" + name if is_cls_method
+
+      name
+    end
+
+    # Generates a test method name from a normal method,
+    # taking into account names composed of metacharacters
+    # (used for arithmetic, etc
+    def normal_to_test name
+      "test_#{munge name}"
+    end
+
+    def unmunge name
+      name = name.to_s.dup
+
+      is_cls_method = name.sub!(/^class_/, '')
+
+      name = name.sub(/_equals(_.*)?$/, '=') unless name =~ /index/
+      name = name.sub(/_bang(_.*)?$/, '!')
+      name = name.sub(/_eh(_.*)?$/, '?')
+      name = name.sub(/^(#{@@mapped_re})(_.*)?$/) {$1}
+      name = yield name if block_given?
+      name = @@method_map[name] if @@method_map.has_key? name
+      name = 'self.' + name if is_cls_method
+
+      name
+    end
+
+    # Converts a method name beginning with test to its
+    # corresponding normal method name, taking into account
+    # symbolic names which may have been anglicised by
+    # #normal_to_test().
+    def test_to_normal(name, klassname=nil)
+      unmunge(name.to_s.sub(/^test_/, '')) do |n|
+        if defined? @inherited_methods then
+          known_methods = (@inherited_methods[klassname] || {}).keys.sort.reverse
+          known_methods_re = known_methods.map {|s| Regexp.escape(s) }.join("|")
+          n = n.sub(/^(#{known_methods_re})(_.*)?$/) { $1 } unless
+            known_methods_re.empty?
+          n
+        end
+      end
+    end
+  end
+end

data/lib/inline/version.rb

@@ -0,0 +1,3 @@
+module Inline
+  VERSION = "3.12.2".freeze
+end