RubyInline 3.1.0

data/History.txt

@@ -0,0 +1,120 @@
+*** 3.1.0 / 2004-09-24
+
++ 2 minor enhancement
+	Extended API of Inline::C with prefix(code).
+	+ Documented all public API.
++ 2 bug fixes
+	+ Cleaned a lot of code and tests.
+	+ Removed nearly all tags.
+
+*** 3.0.1 / 2004-02-24
+
++ 2 bug fixes
+	+ I let references to ZenTestUnit slip through the release. Removed.
+	+ Converted History.txt to ZenWeb format.
+
+*** 3.0.0 / 2003-12-23
+
++ 3 major enhancements
+	+ Complete rewrite with new design.
+	+ Multiple language support, works with C/C++ out of the box.
+	+ Multiple functions per compilation unit, now allowing entire classes to be defined and linked in one unit.
++ Notes:
+	+ I still need to write much better/complete documentation.
+
+*** 2.2.0 / 2003-01-25
+
++ 1 minor enhancements
+	+ Touch all generated files to avoid unnecessary diffs.
++ 1 bug fixes
+	+ Added good profiling example in tutorial/*.
+	+ Added profiling strategy in README.txt.
++ Notes:
+	+ Paired with Doug Beaver <snarly@beaver.net>
+
+*** 2.1.1 / 2002-12-27
+
++ 2 bug fixes
+	+ Fixed a bug in inline.rb where it was comparing against inline.rb, not the caller.
+	+ Tweaked example.rb to take the number of iterations as an option.
+
+*** 2.1.0 / 2002-12-17
+
++ 2 minor enhancements
+	+ Added inline_c_raw to replace Inline.inline.
+	+ Removed module Inline as a whole. This gets rid of some
+	+ major version incompatibilities, tons of duplicate code, and
+	+ just seems to make things happier.
++ 4 bug fixes
+	+ Added a fix from Michael Scholz to fix the use of $0 for file test.
+	+ Added private and public declarations since we are invading
+	+ class Module.
+	+ Fixed tests... oops!
+	+ Lots of clean up...
++ Notes:
+	+ Reviewed by Doug Beaver <snarly@beaver.net>
+
+*** 2.0.0 / 2002-12-12
+
++ 2 bug fixes
+	+ Minor fix to get working on MacOS X (.so vs .bundle).
+	+ Downgraded typemap to be compatible with 1.6.x.
++ Notes:
+	+ Paired w/ Doug Beaver <snarly@beaver.net>
+
+*** 2.0.0 beta / 2002-11-22
+
++ 1 major enhancements
+	+ Added inline_c, a "compile-time" version of inline. Massively enhanced, this version has a limited form of C function parsing.
++ 2 minor enhancements
+	+ Deprecated Inline#inline for Module#inline_c. To be removed by 2.1.0.
+	+ Extended example.rb to include a fully written inlined C function.
++ 3 bug fixes
+	+ Updated README.txt and improved some of the documentation.
+	+ Added test and clean rules to Makefile.
+	+ Removed the copious warnings if running ruby < 1.7.2.
++ Notes:
+	+ Paired w/ Doug Beaver <snarly@beaver.net>
+
+*** 1.1.0 / 2002-11-01
+
++ 2 minor enhancements
+	+ Aliased methods are now inlined as well. 250x faster.
+	+ ONLY on ruby 1.7+. Warns on ruby < 1.7.
+	+ Added a makefile to automate running of all different benchmarks.
++ 1 bug fixes
+	+ Improved example to include an aliased method testcase.
+
+*** 1.0.7 / 2002-09-22
+
++ 1 minor enhancements
+	+ Only compiles the generated code if it was different from the previous version.
++ 1 bug fixes
+	+ Improved security: Checks group and global write on home directory.
+
+*** 1.0.6 / 2002-09-18
+
++ 1 minor enhancements
+	+ Added a prelude argument for header and datatype declarations.
++ 3 bug fixes
+	+ Only output stuff if invoked verbose (ie 'ruby -v ./example.rb').
+	+ Added some compatibility code for windows.
+	+ Declared requirement on POSIX system.
+
+*** 1.0.5 / 2002-09-11
+
++ 2 bug fixes
+	+ Improved security model for UNIX. Still not sure about windoze.
+	+ Fixed History.txt to be accurate, gave example in README.
+
+*** 1.0.4 / 2002-09-10
+
++ 1 major enhancements
+	+ Released to sourceforge!
++ 1 bug fixes
+	+ A number of very minor bug fixes from IRC sessions w/ others.
+
+*** 1.0.0 / 2002-09-05
+
++ 1 major enhancements
+	+ Birthday!

data/Makefile

@@ -0,0 +1,37 @@
+RUBY?=/usr/local/bin/ruby
+RDOC?=rdoc18
+
+test:
+	$(RUBY) -I. -w ./test_inline.rb
+
+examples:
+	rm -rf ~/.ruby_inline; $(RUBY) -I. -w ./example.rb
+	rm -rf ~/.ruby_inline; $(RUBY) -I. -w ./example2.rb
+	rm -rf ~/.ruby_inline; $(RUBY) -I. -w ./tutorial/example1.rb
+	rm -rf ~/.ruby_inline; $(RUBY) -I. -w ./tutorial/example2.rb
+
+docs:
+	$(RDOC) --main inline.rb
+
+bench:
+	@echo "Running native"
+	@$(RUBY) -I. ./example.rb 3 2> /dev/null
+	@echo "Running primer - preloads the compiler and stuff"
+	@rm -rf ~/.ruby_inline; $(RUBY) -I. ./example.rb 0 2>&1 > /dev/null
+	@echo "With full builds"
+	@rm -rf ~/.ruby_inline; $(RUBY) -I. ./example.rb 0 2> /dev/null
+	@rm -rf ~/.ruby_inline; $(RUBY) -I. ./example.rb 1 2> /dev/null
+	@rm -rf ~/.ruby_inline; $(RUBY) -I. ./example.rb 2 2> /dev/null
+	@echo "Without builds"
+	@$(RUBY) -I. ./example.rb 0 2> /dev/null
+	@$(RUBY) -I. ./example.rb 1 2> /dev/null
+	@$(RUBY) -I. ./example.rb 2 2> /dev/null
+
+install:
+	@where=`$(RUBY) -rrbconfig -e 'include Config; print CONFIG["sitelibdir"]'`; \
+	echo "installing inline.rb in $$where"; \
+	cp -f inline.rb $$where; \
+	echo Installed
+
+clean:
+	rm -rf *~ doc ~/.ruby_inline

data/Manifest.txt

@@ -0,0 +1,12 @@
+History.txt
+Makefile
+Manifest.txt
+README.txt
+example.rb
+example2.rb
+inline.gemspec
+inline.rb
+inline-compat.rb
+test_inline.rb
+tutorial/example1.rb
+tutorial/example2.rb

data/README.txt

@@ -0,0 +1,118 @@
+** Ruby Inline
+
+    http://www.zenspider.com/ZSS/Products/RubyInline/
+    support@zenspider.com
+
+** DESCRIPTION:
+
+Ruby Inline is my quick attempt to create an analog to Perl's
+Inline::C. It allows you to embed C or C++ external module code in
+your ruby script directly. The code is compiled and run on the fly
+when needed. The ruby version isn't near as feature-full as the perl
+version, but it is neat!
+
+** FEATURES/PROBLEMS:
+
++ Quick and easy inlining of your C or C++ code embedded in your ruby script.
++ Rudimentary automatic conversion between ruby and C basic types
+  (char, unsigned, unsigned int, char *, int, long, unsigned long).
++ inline_c_raw exists for when the automatic conversion isn't sufficient.
++ Only recompiles if the inlined code has changed.
++ Pretends to be secure.
++ Only uses standard ruby libraries, nothing extra to download.
++ Simple as it can be. Less than 230 lines long... um... sorta simple.
+
+** SYNOPSYS:
+
+  require "inline"
+  class MyTest
+    inline_c "
+      long factorial(int max) {
+        int i=max, result=1;
+        while (i >= 2) { result *= i--; }
+        return result;
+      }"
+  end
+  t = MyTest.new()
+  factorial_5 = t.factorial(5)
+
+** SYNOPSYS (C++):
+
+  $INLINE_FLAGS = " -x c++ "
+  $INLINE_LIBS  = " -lstdc++ "
+  require "inline"
+  class MyTest
+    inline_c "
+      #include <iostream>
+      static
+      VALUE
+      hello(int i) {
+        while (i-- > 0) {
+          std::cout << \"hello\" << std::endl;
+        }
+      }"
+  end
+  t = MyTest.new()
+  t.hello(3)
+
+** (PSEUDO)BENCHMARKS:
+
+  > make bench
+
+  Running native
+  Type = Native   , Iter = 1000000, T = 28.70058100 sec, 0.00002870 sec / iter
+  Running primer - preloads the compiler and stuff
+  With full builds
+  Type = Inline C , Iter = 1000000, T = 7.55118600 sec, 0.00000755 sec / iter
+  Type = InlineRaw, Iter = 1000000, T = 7.54488300 sec, 0.00000754 sec / iter
+  Type = Alias    , Iter = 1000000, T = 7.53243100 sec, 0.00000753 sec / iter
+  Without builds
+  Type = Inline C , Iter = 1000000, T = 7.59543300 sec, 0.00000760 sec / iter
+  Type = InlineRaw, Iter = 1000000, T = 7.54097200 sec, 0.00000754 sec / iter
+  Type = Alias    , Iter = 1000000, T = 7.53654000 sec, 0.00000754 sec / iter
+
+** PROFILING STRATEGY:
+
+0) Always keep a log of your progress and changes.
+1) Run code with 'time' and large dataset.
+2) Run code with '-rprofile' and smaller dataset, large enough to get good #s.
+3) Examine profile output and translate 1 bottleneck to C.
+4) Run new code with 'time' and large dataset. Repeat 2-3 if unsatisfied.
+5) Run final code with 'time' and compare to the first run.
+
+** REQUIREMENTS:
+
++ Ruby - 1.6.7 & 1.7.2 has been used on FreeBSD 4.6 and MacOSX.
++ POSIX compliant system (ie pretty much any UNIX, or Cygwin on MS platforms).
++ A C/C++ compiler (the same one that compiled your ruby interpreter).
++ test::unit for running tests ( http://testunit.talbott.ws/ ).
+
+** INSTALL:
+
++ make test  (optional)
++ make install
+
+** LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2001-2002 Ryan Davis, Zen Spider Software
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/example.rb

@@ -0,0 +1,75 @@
+#!/usr/local/bin/ruby -w
+
+require "inline"
+
+class MyTest
+
+  def factorial(n)
+    f = 1
+    n.downto(2) { |x| f *= x }
+    f
+  end
+
+  inline do |builder|
+    builder.include "<math.h>"
+
+    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
+
+t = MyTest.new()
+
+arg = ARGV.shift || 0
+arg = arg.to_i
+
+# 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
+max = ARGV.shift || 1000000
+max = max.to_i
+
+puts "RubyInline #{Inline::VERSION}" if $DEBUG
+
+MyTest.send(:alias_method, :factorial_alias, :factorial_c_raw)
+
+def validate(n)
+  if n != 120 then puts "ACK! - #{n}"; end
+end
+
+tstart = Time.now
+case arg
+when 0 then
+  type = "Inline C "
+  (1..max).each { |m| n = t.factorial_c(5);     validate(n); }
+when 1 then
+  type = "InlineRaw"
+  (1..max).each { |m| n = t.factorial_c_raw(5); validate(n); }
+when 2 then
+  type = "Alias    "
+  (1..max).each { |m| n = t.factorial_alias(5); validate(n); }
+when 3 then
+  type = "Native   "
+  (1..max).each { |m| n = t.factorial(5);       validate(n); }
+else
+  $stderr.puts "ERROR: argument #{arg} not recognized"
+  exit(1)
+end
+tend = Time.now
+
+total = tend - tstart
+avg = total / max
+printf "Type = #{type}, Iter = #{max}, T = %.8f sec, %.8f sec / iter\n", total, avg

data/example2.rb

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

data/inline-compat.rb

@@ -0,0 +1,44 @@
+#!/usr/local/bin/ruby -w
+
+require "inline"
+
+############################################################
+# DEPRECATED: Remove by version 3.1 or 2003-03-01
+#
+# This file is only provided for those who require backwards compatibility with version 2.x.
+# If you don't need it, don't use it. If you do, please heed the deprecation warnings and
+# migrate to the new system as fast as you can. Thanks...
+
+module Inline
+  class C 
+
+    $INLINE_FLAGS = nil
+    $INLINE_LIBS  = nil
+
+    trace_var(:$INLINE_FLAGS) do |val|
+      $stderr.puts "WARNING: $INLINE_FLAGS is deprecated. Use #add_link_flags. Called from #{caller[1]}."
+    end
+
+    trace_var(:$INLINE_LIBS) do |val|
+      $stderr.puts "WARNING: $INLINE_LIBS is deprecated. Use #add_compile_flags. Called from #{caller[1]}."
+    end
+  end
+end
+
+class Module
+  public
+
+  def inline_c(src)
+    $stderr.puts "WARNING: inline_c is deprecated. Switch to Inline module"
+    inline(:C) do | builder |
+      builder.c src
+    end
+  end
+
+  def inline_c_raw(src)
+    $stderr.puts "WARNING: inline_c_raw is deprecated. Switch to Inline module"
+    inline(:C) do | builder |
+      builder.c_raw src
+    end
+  end
+end

data/inline.gemspec

@@ -0,0 +1,33 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'inline'
+
+spec = Gem::Specification.new do |s|
+
+  s.name = 'RubyInline'
+  s.version = Inline::VERSION
+  s.summary = "Multi-language extension coding within ruby."
+
+  paragraphs = File.read("README.txt").split(/\n\n+/)
+  s.description = paragraphs[3]
+
+  s.requirements << "A POSIX environment and a compiler for your language."
+  s.files = IO.readlines("Manifest.txt").map {|f| f.chomp }
+
+  s.require_path = '.' 
+  s.autorequire = 'inline'
+
+  s.has_rdoc = false                            # I SUCK - TODO
+  s.test_suite_file = "test_inline.rb"
+
+  s.author = "Ryan Davis"
+  s.email = "ryand-ruby@zenspider.com"
+  s.homepage = "http://www.zenspider.com/ZSS/Products/RubyInline/"
+  s.rubyforge_project = "rubyinline"
+end
+
+if $0 == __FILE__
+  Gem.manage_gems
+  Gem::Builder.new(spec).build
+end