el4r 1.0.4

data/bin/el4r-rctool

@@ -0,0 +1,279 @@
+#!/usr/bin/env ruby
+#### Embedded RCtool ####
+#  RCtool - Automatic generate/update rcfiles.
+#  Copyright (C) 2005 rubikitch <rubikitch@ruby-lang.org>
+#  Version: $Id: rctool.rb 1016 2005-12-09 00:33:33Z rubikitch $
+
+#  This program is free software; you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation; either version 2 of the License, or
+#  (at your option) any later version.
+#    This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#    You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software
+#  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+require 'fileutils'
+require 'optparse'
+
+class RCtool
+  def initialize(x={})
+    @no_op = x[:no_op]
+    @windows_p = (RUBY_PLATFORM =~ /win/i)
+    @backup_dir = x[:backup_dir] || "backup"
+    @home_dir = (x[:home_dir] || File.expand_path("~")).chomp "/"
+    @name = x[:name]
+
+    @patches = []
+    
+    @verbose = true
+
+    unless @no_op
+      at_exit {
+        commit
+      }
+    end
+  end
+
+  Patch = Struct.new :file, :block, :comment_start, :template, :where
+  def define_patch(file, block, comment_start, template="%s", where=:append)
+    @patches << Patch.new(file, block, comment_start, template, where)
+  end
+
+  #######
+  private
+  #######
+
+  def beginning_of_block(comment_start)
+    "#{comment_start} Beginning of the #{@name} block:"
+  end
+
+  def attention_msg(comment_start)
+    "#{comment_start} RCtool generated this block automatically. " +
+      "DO NOT MODIFY this block!"
+  end
+
+  def end_of_block(comment_start)
+    "#{comment_start} End of the #{@name} block."
+  end
+
+  def user_area_msg(comment_start)
+    "#{comment_start} User-setting area is below this line."
+  end
+  
+    
+  def set_filenames(file)
+    if file[0,1] == '/' then
+      backup_dir = "#{@backup_dir}/__absolute__"
+      @target_file = file
+    elsif @windows_p and file[0,2] =~ /[A-Z]:/i # for windows
+      backup_dir = "#{@backup_dir}/__absolute__"
+      @target_file = file
+      file = file[2..-1]
+    else
+      backup_dir = "#{@backup_dir}/"
+      @target_file = "#{@home_dir}/#{file}"
+    end
+    @backup_file = "#{backup_dir}#{file}.backup"
+    @modified_file = "#{backup_dir}#{file}.new"
+
+    FileUtils.mkdir_p [File.dirname(@target_file), File.dirname(@modified_file)] unless @no_op
+  end
+  
+
+  def apply_patch(patch)
+    file, block, comment_start, template, where = patch.to_a
+
+    use_template = false
+    unless File.exist? @target_file
+      use_template = true
+      File.open(@target_file, "w") {}
+      raise "failed to write #{@target_file}" unless File.exist? @target_file 
+    end
+    FileUtils.cp @target_file, @backup_file, :verbose=>@verbose
+    
+    open(@modified_file, "w") {|f|
+      puts "Generating #{@modified_file}..." if @verbose
+      old_content = File.read(@target_file)
+
+      bob       = beginning_of_block comment_start
+      attention = attention_msg comment_start
+      eob       = end_of_block comment_start
+      user_area = user_area_msg comment_start
+
+      bob_re       = Regexp.quote bob
+      eob_re       = Regexp.quote eob
+      user_area_re = Regexp.quote user_area
+      
+      block = ["", bob, attention, block.chomp, eob, user_area]
+      
+      m = old_content.match(/\n?#{bob_re}\n.+^#{eob_re}\n(#{user_area_re}\n)?/m)
+      if m                      # target_file exists / has block
+        block = block[1..-1] if where == :prepend and old_content =~ /\A#{bob_re}/
+        f.print m.pre_match
+        f.puts block
+        f.print m.post_match
+      elsif use_template        # target_file does not exist
+        f.printf(template, block.join("\n").strip)
+      elsif where == :append    # target_file exists / has no block
+        f.print old_content
+        f.puts block
+      elsif where == :prepend   # target_file exists / has no block
+        f.puts block.join("\n").strip
+        f.print old_content
+      else
+        raise ArgumentError, "invalid where: #{where}"
+      end
+    }
+  end
+
+  def install_file(patch)
+    FileUtils.cp @modified_file, @target_file, :verbose=>@verbose
+  end
+  
+  def uninstall_file(patch)
+    FileUtils.cp @backup_file, @target_file, :verbose=>@verbose
+  end
+  
+  def diff_file(patch)
+    system "diff -u #{@backup_file} #{@modified_file}"
+  end
+  
+
+  def commit
+    method_for_each_patch = nil
+    ARGV.options {|o|
+      o.on("-p", "--prepare",
+           "create the modified and backup rcfiles"
+           ) { method_for_each_patch = :apply_patch}
+      o.on("-d", "--diff",
+           "show the differences between the modified and the backup rcfiles"
+           ) { method_for_each_patch = :diff_file} 
+      o.on("-i", "--install",
+           "copy the modified rcfiles from BACKUPDIR to HOME"
+           ) { method_for_each_patch = :install_file}
+      o.on("-u", "--uninstall",
+           "copy the backup rcfiles from BACKUPDIR to HOME"
+           ) { method_for_each_patch = :uninstall_file}
+      o.on("-q", "--quiet", "quiet output") { @verbose=false }
+
+      o.parse!
+      
+      if method_for_each_patch
+        @patches.each do |patch|
+          set_filenames patch.file
+          __send__ method_for_each_patch, patch
+        end
+      else
+        puts o.help
+      end
+      
+    }
+  end
+end
+
+
+
+#### Definition ####
+# (shell-command "rm ~/.el4rrc.rb")
+# (progn (find-sh "rake rctool; bin/el4r-rctool -p ; bin/el4r-rctool -d; bin/el4r-rctool -i") (find-filez "~/.el4rrc.rb ~/.emacs ~/.el4r/init.rb"))
+# (find-sh "ruby ~/.el4rrc.rb")
+require 'tmpdir'
+require 'rbconfig'
+include Config
+
+home_dir_expr = %q!ENV['EL4R_HOME'] || File.expand_path("~/.el4r")!
+home_dir = eval home_dir_expr
+
+bindir = CONFIG["bindir"]
+datadir = CONFIG["datadir"]
+sitelibdir = CONFIG["sitelibdir"]
+rubylibdir = CONFIG["rubylibdir"]
+
+if File.directory? File.join(rubylibdir, "el4r") # debian
+  emacsrubydir = File.join(rubylibdir, "el4r/emacsruby")
+  siteemacsrubydir = File.join(sitelibdir, "el4r/emacsruby")
+else
+  emacsrubydir = File.join(sitelibdir, "el4r/emacsruby")
+  siteemacsrubydir = File.join(home_dir, "site")
+end
+
+el_program = File.expand_path('emacs/site-lisp/el4r.el', datadir)
+el_dir = File.dirname el_program
+
+rc = RCtool.new(:name=>"el4r")
+rc.define_patch(".el4rrc.rb", <<END_OF_BLOCK, "#", <<END_OF_TEMPLATE, :prepend)
+### Internal variables
+@stdlib_dir = #{emacsrubydir.dump}
+@site_dir = #{siteemacsrubydir.dump}
+@autoload_dir = #{File.join(emacsrubydir, "autoload").dump}
+@el_program_relative = "data/emacs/site-lisp/el4r.el"
+@instance_program_relative = "bin/el4r-instance"
+@el_program = #{el_program.dump}
+@instance_program = #{File.expand_path('el4r-instance', bindir).dump}
+@lisp_object_gc_trigger_count = 100
+@lisp_object_gc_trigger_increment = 100
+@ruby_gc_trigger_count = 100
+@ruby_gc_trigger_increment = 100
+@log_buffer = "*el4r:log*"
+@output_buffer = "*el4r:output*"
+@unittest_lisp_object_gc_trigger_count = 5000
+@unittest_lisp_object_gc_trigger_increment = 5000
+@unittest_ruby_gc_trigger_count = 5000
+@unittest_ruby_gc_trigger_increment = 5000
+@temp_file = "#{Dir.tmpdir}/el4r-\#{ENV['USER'] || ENV['USERNAME'] || 'me'}.tmp"
+
+### El4r bootstrap code
+def __conf__
+  if ENV['EL4R_ROOT']
+    $: << File.join(ENV['EL4R_ROOT'], "lib")
+  end
+  require 'el4r/el4r-sub'
+  ConfigScript.new(__FILE__)
+end
+
+def __elisp_init__
+  $> << "(setq \\n"
+  instance_variables.map{|iv| [iv[1..-1], instance_variable_get(iv)]}.each {|k,v|  $> << "el4r-\#{k.gsub(/_/,'-')} \#{v.inspect}\\n" if Numeric === v or String === v}
+  $> << ')' << "\n"
+end
+
+at_exit { __elisp_init__  if __FILE__==$0 }
+
+### Customizable variables
+### You can override these variables in User-setting area.
+# directory containing EmacsRuby scripts
+@home_dir = #{home_dir_expr}
+# startup EmacsRuby script
+@init_script = "init.rb"
+# EmacsRuby search path
+@el4r_load_path = [ @home_dir, @site_dir, @stdlib_dir, "." ]
+END_OF_BLOCK
+%s
+
+# Ruby interpreter name used by el4r
+@ruby_program = "ruby"
+# Emacs program name used by el4r / el4r-runtest.rb
+@emacs_program = "emacs"
+END_OF_TEMPLATE
+
+
+dotemacs_block = <<END_OF_BLOCK
+(add-to-list 'load-path #{el_dir.dump})
+(require 'el4r)
+(el4r-boot)
+END_OF_BLOCK
+
+rc.define_patch(".emacs", dotemacs_block, ";;", "%s", :append)
+xemacs_init = ".xemacs/init.el"
+if File.exist?(File.expand_path(xemacs_init, ENV['HOME']))
+  rc.define_patch(xemacs_init, dotemacs_block, ";;", "%s", :append)
+end
+
+rc.define_patch("#{home_dir}/init.rb", <<END_OF_BLOCK, "#", "%s", :prepend)
+# This is the el4r initialization file.
+END_OF_BLOCK
+

data/bin/el4r-runtest

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+#    el4r - EmacsLisp for Ruby 
+#    Copyright (C) 2005 rubikitch <rubikitch@ruby-lang.org>
+#    Version: $Id: el4r-runtest 852 2005-11-15 19:38:07Z rubikitch $
+
+#    This program is free software; you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation; either version 2 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program; if not, write to the Free Software
+#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+require 'el4r/exec-el4r'
+exec_el4r true
+
+
+# Local Variables:
+# modes: (ruby-mode emacs-lisp-mode)
+# End:

data/data/emacs/site-lisp/el4r.el

@@ -0,0 +1,441 @@
+;; el4r - EmacsLisp for Ruby 
+;; Copyright (C) 2005 rubikitch <rubikitch@ruby-lang.org>
+;; Version: $Id: el4r.el 1280 2006-06-24 08:33:17Z rubikitch $
+
+;; This file is *NOT* part of GNU Emacs.
+
+;; This program is free software; you can redistribute it and/or
+;; modify it under the terms of the GNU General Public License as
+;; published by the Free Software Foundation; either version 2, or (at
+;; your option) any later version.
+
+;; This program is distributed in the hope that it will be useful, but
+;; WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+;; General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs; see the file COPYING. If not, write to the
+;; Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+
+(or (>= emacs-major-version 21)
+    (error "Sorry, el4r requires (X)Emacs21 or later, because it uses weak hash."))
+
+(put 'el4r-ruby-error
+     'error-conditions                        
+     '(error el4r-ruby-error))
+(put 'el4r-ruby-error 'error-message "Error raised in Ruby")
+
+(defvar el4r-ruby-program "ruby"
+  "The name of Ruby binary.")
+
+(defvar el4r-instance-program (expand-file-name "~/src/el4r/bin/el4r-instance")
+  "Full path of el4r-instance.")
+
+(defvar el4r-instance-args nil)
+(defvar el4r-debug-on-error nil)
+(defvar el4r-coding-system nil)
+
+(defvar el4r-process nil)
+(defvar el4r-process-name "el4r")
+(defvar el4r-process-bufname "*el4r:process*")
+(defvar el4r-call-level 0)
+(defvar el4r-last-error-desc nil)
+
+(defvar el4r-ruby-object-ids nil)
+(defvar el4r-ruby-object-weakhash nil)
+;(defvar el4r-defun-hash nil)
+(defvar el4r-defun-lambdas nil)
+(defvar el4r-lisp-object-hash nil)
+(defvar el4r-lisp-object-lastid 0)
+(defvar el4r-lisp-object-gc-trigger-count 100)
+(defvar el4r-lisp-object-gc-trigger-increment 100)
+
+(defun call-process-to-string (program &rest args)
+  (with-temp-buffer
+    (apply 'call-process program nil t nil args)
+    (buffer-string)))
+
+(defun call-process-and-eval (program &rest args)
+  (eval (read (apply 'call-process-to-string program args))))
+
+(defun el4r-running-p ()
+  (not (null el4r-process)))
+
+(unless (fboundp 'process-send-signal)
+  (defun process-send-signal (signal process-or-name)
+    (signal-process (process-id (get-process process-or-name)) signal))
+  )
+
+(defun el4r-boot (&optional noinit)
+  "Start el4r process, load ~/.el4r/init.rb, and prepare log buffer."
+  (interactive "P")
+  (with-current-buffer (get-buffer-create el4r-process-bufname) (erase-buffer))
+  (with-current-buffer (get-buffer-create "*el4r:log*")
+    (let ((buffer-read-only))
+      (buffer-disable-undo)
+      (erase-buffer)))
+  (el4r-init)
+  (el4r-ruby-eval
+   (if noinit "el4r_boot__noinit" "el4r_boot"))
+  )
+
+(defun el4r-shutdown ()
+  "Shutdown el4r."
+  (interactive)
+  (when (el4r-running-p)
+    (el4r-ruby-eval "el4r_shutdown")
+    (process-send-signal 'SIGTERM (process-name el4r-process))
+    (setq el4r-process nil)
+    ))
+
+(defun el4r-restart ()
+  "Shutdown then start el4r."
+  (interactive)
+  (el4r-shutdown)
+  (el4r-boot))
+
+(defun el4r-load (script)
+  "Loads Ruby script from ~/.el4r directory."
+  (el4r-ruby-call nil "el4r_load" script))
+
+(defun el4r-recover ()
+  (interactive)
+  (with-current-buffer el4r-process-bufname
+    (erase-buffer)))
+
+(defun el4r-override-variables ())
+
+(defun el4r-init ()
+  ;; In many cases  (eq el4r-process (get-buffer-process el4r-process-bufname))
+  ;; But this sexp is nil when el4r-instance is accidentally dead.
+  (and (get-buffer-process el4r-process-bufname) (el4r-shutdown))
+  ;; Override el4r-related variables from ~/.el4rrc.rb
+  (call-process-and-eval el4r-ruby-program (expand-file-name "~/.el4rrc.rb"))
+  (el4r-override-variables)
+  (setq el4r-lisp-object-hash (make-hash-table :test 'eq))
+  (setq el4r-ruby-object-weakhash (make-hash-table :test 'eq :weakness 'value))
+;  (setq el4r-defun-hash (make-hash-table :test 'eq))
+  (setq el4r-defun-lambdas nil)
+  (let ((buffer el4r-process-bufname)
+        (process-connection-type nil))  ; Use a pipe.
+    (and (get-buffer buffer) (kill-buffer buffer))
+    (get-buffer-create buffer)
+    (with-current-buffer buffer
+      (buffer-disable-undo)
+      ;; fixme I do not know why.
+      ;; (set (make-local-variable 'process-adaptive-read-buffering) nil)
+      (setq el4r-process (apply 'start-process el4r-process-name buffer
+                                el4r-ruby-program el4r-instance-program el4r-instance-args))
+      (and el4r-coding-system
+           (set-process-coding-system el4r-process
+                                      el4r-coding-system el4r-coding-system)))
+    (message "el4r started.")
+  ))
+
+
+(defun el4r-check-alive ()
+  (or (eq (process-status el4r-process) 'run)
+      (error "el4r-instance is dead.")))
+
+(defun el4r-scan-expr-from-ruby ()
+  (with-current-buffer el4r-process-bufname
+    (goto-char (point-min))
+    (save-match-data
+      (let ((point-after-zero (search-forward "\0" nil t))
+            expr)
+        (if point-after-zero
+            (progn
+              (setq expr
+                    (buffer-substring (point-min) (- point-after-zero 1)))
+              (delete-region (point-min) point-after-zero)
+              expr
+              )))
+    )))
+
+(defun el4r-recv ()
+  (let ((expr))
+    (while (eq nil (progn (setq expr (el4r-scan-expr-from-ruby)) expr))
+      (el4r-check-alive)
+      (accept-process-output el4r-process))
+    expr))
+
+(defun el4r-send (rubyexpr)
+  (el4r-check-alive)
+  (process-send-string el4r-process rubyexpr)
+  (process-send-string el4r-process "\0\n"))
+
+(defvar el4r-error-lisp-expression nil)
+(defun el4r-get ()
+  (let ((result (el4r-recv)) expr)
+    (while (eq (length result) 0)
+      (el4r-wait-expr)
+      (setq result (el4r-recv)))
+    (condition-case err
+        (eval (setq expr (read result)))
+      ;; !DRY! (find-function 'el4r-wait-expr)
+      (el4r-ruby-error (signal 'el4r-ruby-error nil))
+      (error (setq el4r-error-lisp-expression expr)
+             (signal (car err) (cdr err))))
+    ))
+
+(defun el4r-signal-last-error ()
+  (signal (car el4r-last-error-desc) (cdr el4r-last-error-desc)))
+
+(defun el4r-enter-call () (setq el4r-call-level (+ el4r-call-level 1)))
+(defun el4r-leave-call () (setq el4r-call-level (- el4r-call-level 1)))
+(defun el4r-callback-p () (not (eq el4r-call-level 0)))
+(defun el4r-send-interrupt () (el4r-send ""))
+
+(defun el4r-no-properties (str)
+  (setq str (copy-sequence str))
+  (set-text-properties 0 (length str) nil str)
+  str)
+
+(defvar el4r-treat-ctrl-codes nil)
+
+(defvar el4r-temp-file nil)
+(defvar obj nil)
+(defsubst el4r-string-to-rubystr (str)
+  (let ((file-read "File.read(conf.temp_file)"))
+    (if (or (not el4r-treat-ctrl-codes)
+            (string= str file-read))
+        (concat "%q" (prin1-to-string (el4r-no-properties obj)))
+      (cond ((eq el4r-treat-ctrl-codes 'use-file) ;experimental
+             ;; !FIXME! coding-system @ XEmacs
+             (with-temp-buffer
+               (insert str)
+               ;; suppress "wrote file-name" message
+               ;; (find-efunctiondescr 'write-region "VISIT is neither")
+               (write-region 1 (point-max) el4r-temp-file nil 0))
+             file-read)
+            (t
+	      (concat "%Q"
+                      (with-temp-buffer
+                        (insert (prin1-to-string (el4r-no-properties str)))
+                        (mapcar (lambda (x)
+                                  (goto-char 1)
+                                  (while (search-forward (car x) nil t)
+                                    (replace-match (cdr x))))
+                                '(("#" . "\\\\#")
+                                  ("\003" . "\\\\cc")
+                                  ("\004" . "\\\\cd")
+                                  ("\021" . "\\\\cq")
+                                  ("\023" . "\\\\cs")
+                                  ("\026" . "\\\\cv")
+                                  ("\027" . "\\\\cw")
+                                  ("\031" . "\\\\cy")
+                                  ("\032" . "\\\\cz")
+                                  ))
+                        (buffer-string)))
+      
+      )))))
+
+
+(defun el4r-proper-list-p (expression)
+  ;; Tell if a list is proper, id est, that it is `nil' or ends with `nil'.
+  (cond ((not expression))
+	((consp expression) (not (cdr (last expression))))))
+
+(defun el4r-lisp2ruby (obj)
+  (cond ((eq obj nil) "nil")
+        ((eq obj t) "true")
+        ((numberp obj) (number-to-string obj))
+        ((stringp obj) (el4r-string-to-rubystr obj))
+        ((el4r-rubyexpr-p obj) (el4r-rubyexpr-string obj))
+        ((el4r-rubyobj-p obj)
+         (format "el4r_rubyobj_stock.id2obj(%s)"
+                 (el4r-rubyobj-id obj)))
+        ((el4r-proper-list-p obj)
+         (format "el4r_elobject_new(%d, ELListCell)"
+                 (el4r-lisp-object-to-id obj)))
+        ((and (consp obj) (atom (cdr obj)))
+         (format "el4r_elobject_new(%d, ELConsCell)"
+                 (el4r-lisp-object-to-id obj)))
+        ((vectorp obj)
+         (format "el4r_elobject_new(%d, ELVector)"
+                 (el4r-lisp-object-to-id obj)))
+        (t
+         (format "el4r_elobject_new(%d)"
+                 (el4r-lisp-object-to-id obj)))
+        ))
+
+(defun el4r-wait-expr ()
+  (el4r-enter-call)
+  (let (evaled rubyexpr)
+    (condition-case err
+        (progn (setq evaled (el4r-get))
+               (setq rubyexpr (el4r-lisp2ruby evaled)))
+      (el4r-ruby-error (setq rubyexpr "el4r_reraise_last_error"))
+      (error (setq el4r-last-error-desc err)
+             (setq rubyexpr "el4r_raise_lisp_error")))
+    (el4r-send rubyexpr))
+  (el4r-leave-call))
+
+(defun el4r-ruby-eval (rubyexpr)
+  (and (eq 0 (length rubyexpr)) (error "Empty expression is not evaluatable."))
+  (and (el4r-callback-p) (el4r-send-interrupt))
+  (el4r-enter-call)
+  (el4r-send rubyexpr)
+  (let ((result (el4r-get)))
+    (el4r-leave-call)
+    result
+    ))
+
+(defun el4r-lisp-object-from-id (id)
+  (or (gethash id el4r-lisp-object-hash)
+      (error "No such object for given ID: %d" id)))
+
+(defun el4r-lisp-object-to-id (obj)
+  (el4r-gc-lisp-objects-if-required)
+  (let ((id el4r-lisp-object-lastid))
+    (setq el4r-lisp-object-lastid (+ id 1))
+    (puthash id obj el4r-lisp-object-hash)
+    id
+    ))
+
+(defun el4r-garbage-collect ()
+  "Force garbage collection for el4r."
+  (interactive)
+  (el4r-gc-lisp-objects)
+  (el4r-ruby-eval "el4r_rubyobj_stock.garbage_collect")
+  (message "el4r garbage collected"))
+
+
+(defun el4r-gc-lisp-objects ()
+  (let ((ids (el4r-ruby-call nil 'el4r_get_garbage_lispobj_ids)))
+    (while ids
+      (remhash (car ids) el4r-lisp-object-hash)
+      (setq ids (cdr ids))
+    )))
+
+(defun el4r-gc-lisp-objects-if-required ()
+  (if (>= (hash-table-count el4r-lisp-object-hash)
+          el4r-lisp-object-gc-trigger-count)
+      (progn (el4r-gc-lisp-objects)
+             (setq el4r-lisp-object-gc-trigger-count
+                   (+ (hash-table-count el4r-lisp-object-hash)
+                      el4r-lisp-object-gc-trigger-increment)))
+    ))
+
+(defun el4r-rubyobj-p (rubyobj)
+  (and (listp rubyobj) (eq (car rubyobj) 'el4r-rubyobj)))
+(defun el4r-rubyobj-id (rubyobj)
+  (cdr rubyobj))
+(defun el4r-rubyobj-create (id)
+  (let ((rubyobj (cons 'el4r-rubyobj id)))
+    (setq el4r-ruby-object-ids (cons id el4r-ruby-object-ids))
+    (puthash id rubyobj el4r-ruby-object-weakhash)
+    rubyobj))
+(defun el4r-rubyobj-get-alive-ids ()
+  (garbage-collect)
+;;   (let (ids)
+;;     (maphash (lambda (id obj)
+;;                (setq ids (cons id ids)))
+;;              el4r-ruby-object-weakhash)
+;;     ids))
+
+  ;; Introduce new variable `el4r-ruby-object-ids' and stop using
+  ;; maphash to avoid fatal exception. I do not know why maphash
+  ;; causes fatal. This idea is borrowed from pymacs.
+  (let ((ids el4r-ruby-object-ids)
+        used-ids)
+    (while ids
+      (let ((id (car ids)))
+        (setq ids (cdr ids))
+        (if (gethash id el4r-ruby-object-weakhash)
+            (setq used-ids (cons id used-ids))
+          )))
+    (setq el4r-ruby-object-ids used-ids)
+    used-ids))
+
+(defun el4r-rubyexpr-p (rubyexpr)
+  (and (listp rubyexpr) (eq (car rubyexpr) 'el4r-rubyexpr)))
+(defun el4r-rubyexpr-string (rubyexpr)
+  (cdr rubyexpr))
+(defun el4r-rubyexpr-quote (string)
+  (cons 'el4r-rubyexpr string))
+
+;; disabled
+' (defun el4r-list-to-rubyseq (list)
+    (let (tokens)
+      (while list
+        (setq tokens
+              (cons ", " (cons (el4r-lisp2ruby (car list)) tokens)))
+        (setq list (cdr list)))
+      (setq tokens (nreverse (cdr tokens)))
+      (apply 'concat tokens)))
+(defun el4r-list-to-rubyseq (list)
+  (mapconcat (lambda (x)
+               (el4r-lisp2ruby x))
+             list ", "))
+
+(defun el4r-list-to-rubyary (list)
+  (el4r-rubyexpr-quote (format "[%s]" (el4r-list-to-rubyseq list))))
+(defun el4r-cons-to-rubyary (cons)
+  (el4r-list-to-rubyary (list (car cons) (cdr cons))))
+
+(defalias 'el4r-vector-to-rubyseq 'el4r-list-to-rubyseq)
+(defalias 'el4r-vector-to-rubyary 'el4r-list-to-rubyary)
+
+(defun el4r-ruby-call (receiver name &rest args)
+  "Invoke ruby's method. (RECEIVER can be nil.)"
+  (setq name (cond ((symbolp name) (symbol-name name))
+                   ((stringp name) name)
+                   (t (error "Invalid value for method name: %s" name))))
+  (setq receiver (cond ((eq receiver nil) "self")
+                       (t (format "el4r_rubyobj_stock.id2obj(%s)"
+                                  (el4r-rubyobj-id receiver)))))
+  (el4r-ruby-eval (format "%s.%s(%s)"
+                          receiver
+                          name
+                          (el4r-list-to-rubyseq args))))
+
+(defun el4r-lambda-for-rubyproc (rubyproc-id &rest preform)
+  (let ((lmd (eval (append '(lambda (&rest args))    ;; Lazy list play!
+                           preform
+                           (list (list 'el4r-ruby-call-proc-by-id
+                                       rubyproc-id
+                                       'args)))
+                   )))
+    (setq el4r-ruby-object-ids (cons rubyproc-id el4r-ruby-object-ids))
+    (puthash rubyproc-id lmd el4r-ruby-object-weakhash)
+    lmd))
+(defun el4r-ruby-call-proc-by-id (rubyproc-id args)
+  (el4r-ruby-eval (format "el4r_rubyobj_stock.id2obj(%s).call(%s)"
+                          rubyproc-id (el4r-list-to-rubyseq args))))
+(defun el4r-ruby-call-proc (rubyproc &rest args)
+  (el4r-ruby-call-proc-by-id (el4r-rubyobj-id rubyproc) args))
+
+(defun el4r-ruby-eval-prompt (expr)
+  "Read and execute Ruby code."
+  (interactive "sEval Ruby: ")
+  (message (prin1-to-string (el4r-ruby-eval expr)))
+  )
+
+(defun el4r-ruby-eval-region (point mark)
+  "Execute the region as Ruby code."
+  (interactive "r")
+  (el4r-ruby-eval-prompt (buffer-substring point mark)))
+
+(defun el4r-ruby-eval-buffer ()
+  "Execute the buffer as Ruby code."
+  (interactive)
+  (el4r-ruby-eval-prompt (buffer-string)))
+
+(defun el4r-debug-ruby-eval-report (expr)
+  (interactive "sEval Ruby: ")
+  (insert (format "%s\n  => %s\n"
+                  expr
+                  (prin1-to-string (el4r-ruby-eval expr)))))
+
+(defun el4r-register-lambda (func)
+  (setq el4r-defun-lambdas (cons func el4r-defun-lambdas)))
+
+(defun el4r-define-function (name func)
+  (fset name func)
+  (el4r-register-lambda func)
+  nil)
+
+(provide 'el4r)