1.4.0

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@520 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

5 files changed, 1268 insertions, 0 deletions

diff --git a/misc/README b/misc/README
new file mode 100644
index 0000000000..adc119d02e
--- /dev/null
+++ b/misc/README
@@ -0,0 +1,5 @@
+README		this file
+inf-ruby.el	program to run ruby under emacs
+ruby-mode.el	ruby mode for emacs
+rubydb2x.el	ruby debugger support for emacs 19.2x or before
+rubydb3x.el	ruby debugger support for emacs 19.3x or later
diff --git a/misc/inf-ruby.el b/misc/inf-ruby.el
new file mode 100644
index 0000000000..eaa904951c
--- /dev/null
+++ b/misc/inf-ruby.el
@@ -0,0 +1,322 @@
+;;; -*-Emacs-Lisp-*-
+;;;
+;;;  $Id$
+;;;  $Author$
+;;;  $Date$
+;;;
+;;; Inferior Ruby Mode - ruby process in a buffer.
+;;;                      adapted from cmuscheme.el
+;;;
+;;; Usage:
+;;;
+;;; (0) check ruby-program-name variable that can run your environment.
+;;;
+;;; (1) modify .emacs to use ruby-mode 
+;;;     for example :
+;;;
+;;;    (autoload 'ruby-mode "ruby-mode"
+;;;      "Mode for editing ruby source files")
+;;;    (setq auto-mode-alist
+;;;          (append '(("\\.rb$" . ruby-mode)) auto-mode-alist))
+;;;    (setq interpreter-mode-alist (append '(("^#!.*ruby" . ruby-mode))
+;;;    				     interpreter-mode-alist))
+;;;    
+;;; (2) set to road inf-ruby and set inf-ruby key definition in ruby-mode.
+;;;
+;;;    (autoload 'run-ruby "inf-ruby"
+;;;      "Run an inferior Ruby process")
+;;;    (autoload 'inf-ruby-keys "inf-ruby"
+;;;      "Set local key defs for inf-ruby in ruby-mode")
+;;;    (add-hook 'ruby-mode-hook
+;;;          '(lambda ()
+;;;             (inf-ruby-keys)
+;;;    ))
+;;;
+;;; HISTORY
+;;; senda -  8 Apr 1998: Created.
+;;;	 $Log$
+;;;	 Revision 1.2  1999/08/13 05:45:18  matz
+;;;	 1.4.0
+;;;
+;;;	 Revision 1.1.1.1.2.1  1999/07/15 07:59:59  matz
+;;;	 990715
+;;;	
+;;;	 Revision 1.1.1.1  1999/01/20 04:59:36  matz
+;;;	 ruby 1.3 cycle
+;;;	
+;;;	 Revision 1.1.2.1  1998/12/16 07:30:36  matz
+;;;	 first public release of 1.1d (pre1.2) series
+;;;	
+;;;	 Revision 1.4  1998/05/20 02:45:58  senda
+;;;	 default program to irb
+;;;
+;;;	 Revision 1.3  1998/04/10 04:11:30  senda
+;;;	 modification by Matsumoto san (1.1b9_09)
+;;;	 remove-in-string defined
+;;;	 global variable :
+;;;	 	 inferior-ruby-first-prompt-pattern
+;;;	       inferior-ruby-prompt-pattern
+;;;	 defined
+;;;
+;;;	 Revision 1.2  1998/04/09 07:53:42  senda
+;;;	 remove M-C-x in inferior-ruby-mode
+;;;
+;;;	 Revision 1.1  1998/04/09 07:28:36  senda
+;;;	 Initial revision
+;;;
+;;;
+
+(require 'comint)
+(require 'ruby-mode)
+
+;;
+;; you may change these variables
+;;
+;(defvar ruby-program-name "rbc --noreadline"
+;  "*Program invoked by the run-ruby command")
+;
+;(defvar inferior-ruby-first-prompt-pattern "^rbc0> *"
+;  "first prompt regex pattern of ruby interpreter.")
+;
+;(defvar inferior-ruby-prompt-pattern "^\\(rbc.[>*\"'] *\\)+"
+;  "prompt regex pattern of ruby interpreter.")
+
+;;;; for irb
+(defvar ruby-program-name "irb --inf-ruby-mode"
+  "*Program invoked by the run-ruby command")
+
+(defvar inferior-ruby-first-prompt-pattern "^irb(.*)[0-9:]+0> *"
+  "first prompt regex pattern of ruby interpreter.")
+
+(defvar inferior-ruby-prompt-pattern "^\\(irb(.*)[0-9:]+[>*\"'] *\\)+"
+  "prompt regex pattern of ruby interpreter.")
+
+;;
+;; mode variables
+;;
+(defvar inferior-ruby-mode-hook nil
+  "*Hook for customising inferior-ruby mode.")
+(defvar inferior-ruby-mode-map nil
+  "*Mode map for inferior-ruby-mode")
+
+(cond ((not inferior-ruby-mode-map)
+       (setq inferior-ruby-mode-map
+	     (copy-keymap comint-mode-map))
+;       (define-key inferior-ruby-mode-map "\M-\C-x" ;gnu convention
+;	           'ruby-send-definition)
+;       (define-key inferior-ruby-mode-map "\C-x\C-e" 'ruby-send-last-sexp)
+       (define-key inferior-ruby-mode-map "\C-c\C-l" 'ruby-load-file)
+))
+
+(defun inf-ruby-keys ()
+  "Set local key defs for inf-ruby in ruby-mode"
+  (define-key ruby-mode-map "\M-\C-x" 'ruby-send-definition)
+;  (define-key ruby-mode-map "\C-x\C-e" 'ruby-send-last-sexp)
+  (define-key ruby-mode-map "\C-c\C-e" 'ruby-send-definition)
+  (define-key ruby-mode-map "\C-c\M-e" 'ruby-send-definition-and-go)
+  (define-key ruby-mode-map "\C-c\C-r" 'ruby-send-region)
+  (define-key ruby-mode-map "\C-c\M-r" 'ruby-send-region-and-go)
+  (define-key ruby-mode-map "\C-c\C-z" 'switch-to-ruby)
+  (define-key ruby-mode-map "\C-c\C-l" 'ruby-load-file)
+  (define-key ruby-mode-map "\C-c\C-s" 'run-ruby)
+)
+
+(defvar ruby-buffer nil "current ruby (actually irb) process buffer.")
+
+(defun inferior-ruby-mode ()
+  "Major mode for interacting with an inferior ruby (irb) process.
+
+The following commands are available:
+\\{inferior-ruby-mode-map}
+
+A ruby process can be fired up with M-x run-ruby.
+
+Customisation: Entry to this mode runs the hooks on comint-mode-hook and
+inferior-ruby-mode-hook (in that order).
+
+You can send text to the inferior ruby process from other buffers containing
+Ruby source.
+    switch-to-ruby switches the current buffer to the ruby process buffer.
+    ruby-send-definition sends the current definition to the ruby process.
+    ruby-send-region sends the current region to the ruby process.
+
+    ruby-send-definition-and-go, ruby-send-region-and-go,
+        switch to the ruby process buffer after sending their text.
+For information on running multiple processes in multiple buffers, see
+documentation for variable ruby-buffer.
+
+Commands:
+Return after the end of the process' output sends the text from the 
+    end of process to point.
+Return before the end of the process' output copies the sexp ending at point
+    to the end of the process' output, and sends it.
+Delete converts tabs to spaces as it moves back.
+Tab indents for ruby; with argument, shifts rest
+    of expression rigidly with the current line.
+C-M-q does Tab on each line starting within following expression.
+Paragraphs are separated only by blank lines.  # start comments.
+If you accidentally suspend your process, use \\[comint-continue-subjob]
+to continue it."
+  (interactive)
+  (comint-mode)
+  ;; Customise in inferior-ruby-mode-hook
+  ;(setq comint-prompt-regexp "^[^>\n]*>+ *")
+  (setq comint-prompt-regexp inferior-ruby-prompt-pattern)
+  ;;(scheme-mode-variables)
+  (ruby-mode-variables)
+  (setq major-mode 'inferior-ruby-mode)
+  (setq mode-name "Inferior Ruby")
+  (setq mode-line-process '(":%s"))
+  (use-local-map inferior-ruby-mode-map)
+  (setq comint-input-filter (function ruby-input-filter))
+  (setq comint-get-old-input (function ruby-get-old-input))
+  (run-hooks 'inferior-ruby-mode-hook))
+
+(defvar inferior-ruby-filter-regexp "\\`\\s *\\S ?\\S ?\\s *\\'"
+  "*Input matching this regexp are not saved on the history list.
+Defaults to a regexp ignoring all inputs of 0, 1, or 2 letters.")
+
+(defun ruby-input-filter (str)
+  "Don't save anything matching inferior-ruby-filter-regexp"
+  (not (string-match inferior-ruby-filter-regexp str)))
+
+;; adapted from replace-in-string in XEmacs (subr.el)
+(defun remove-in-string (str regexp)
+  "Remove all matches in STR for REGEXP and returns the new string."
+  (let ((rtn-str "") (start 0) match prev-start)
+    (while (setq match (string-match regexp str start))
+      (setq prev-start start
+	    start (match-end 0)
+	    rtn-str (concat rtn-str (substring str prev-start match))))
+    (concat rtn-str (substring str start))))
+
+(defun ruby-get-old-input ()
+  "Snarf the sexp ending at point"
+  (save-excursion
+    (let ((end (point)))
+      (re-search-backward inferior-ruby-first-prompt-pattern)
+      (remove-in-string (buffer-substring (point) end)
+			inferior-ruby-prompt-pattern)
+      )))
+
+(defun ruby-args-to-list (string)
+  (let ((where (string-match "[ \t]" string)))
+    (cond ((null where) (list string))
+	  ((not (= where 0))
+	   (cons (substring string 0 where)
+		 (ruby-args-to-list (substring string (+ 1 where)
+						 (length string)))))
+	  (t (let ((pos (string-match "[^ \t]" string)))
+	       (if (null pos)
+		   nil
+		 (ruby-args-to-list (substring string pos
+						 (length string)))))))))
+
+(defun run-ruby (cmd)
+  "Run an inferior Ruby process, input and output via buffer *ruby*.
+If there is a process already running in `*ruby*', switch to that buffer.
+With argument, allows you to edit the command line (default is value
+of `ruby-program-name').  Runs the hooks `inferior-ruby-mode-hook'
+\(after the `comint-mode-hook' is run).
+\(Type \\[describe-mode] in the process buffer for a list of commands.)"
+
+  (interactive (list (if current-prefix-arg
+			 (read-string "Run Ruby: " ruby-program-name)
+			 ruby-program-name)))
+  (if (not (comint-check-proc "*ruby*"))
+      (let ((cmdlist (ruby-args-to-list cmd)))
+	(set-buffer (apply 'make-comint "ruby" (car cmdlist)
+			   nil (cdr cmdlist)))
+	(inferior-ruby-mode)))
+  (setq ruby-program-name cmd)
+  (setq ruby-buffer "*ruby*")
+  (pop-to-buffer "*ruby*"))
+
+(defun ruby-send-region (start end)
+  "Send the current region to the inferior Ruby process."
+  (interactive "r")
+  (comint-send-region (ruby-proc) start end)
+  (comint-send-string (ruby-proc) "\n"))
+
+(defun ruby-send-definition ()
+  "Send the current definition to the inferior Ruby process."
+  (interactive)
+  (save-excursion
+    (ruby-end-of-defun)
+    (let ((end (point)))
+      (ruby-beginning-of-defun)
+      (ruby-send-region (point) end))))
+
+;(defun ruby-send-last-sexp ()
+;  "Send the previous sexp to the inferior Ruby process."
+;  (interactive)
+;  (ruby-send-region (save-excursion (backward-sexp) (point)) (point)))
+
+(defun switch-to-ruby (eob-p)
+  "Switch to the ruby process buffer.
+With argument, positions cursor at end of buffer."
+  (interactive "P")
+  (if (get-buffer ruby-buffer)
+      (pop-to-buffer ruby-buffer)
+      (error "No current process buffer. See variable ruby-buffer."))
+  (cond (eob-p
+	 (push-mark)
+	 (goto-char (point-max)))))
+
+(defun ruby-send-region-and-go (start end)
+  "Send the current region to the inferior Ruby process.
+Then switch to the process buffer."
+  (interactive "r")
+  (ruby-send-region start end)
+  (switch-to-ruby t))
+
+(defun ruby-send-definition-and-go ()
+  "Send the current definition to the inferior Ruby. 
+Then switch to the process buffer."
+  (interactive)
+  (ruby-send-definition)
+  (switch-to-ruby t))
+
+(defvar ruby-source-modes '(ruby-mode)
+  "*Used to determine if a buffer contains Ruby source code.
+If it's loaded into a buffer that is in one of these major modes, it's
+considered a ruby source file by ruby-load-file.
+Used by these commands to determine defaults.")
+
+(defvar ruby-prev-l/c-dir/file nil
+  "Caches the last (directory . file) pair.
+Caches the last pair used in the last ruby-load-file command.
+Used for determining the default in the 
+next one.")
+
+(defun ruby-load-file (file-name)
+  "Load a Ruby file into the inferior Ruby process."
+  (interactive (comint-get-source "Load Ruby file: " ruby-prev-l/c-dir/file
+				  ruby-source-modes t)) ; T because LOAD 
+                                                          ; needs an exact name
+  (comint-check-source file-name) ; Check to see if buffer needs saved.
+  (setq ruby-prev-l/c-dir/file (cons (file-name-directory    file-name)
+				       (file-name-nondirectory file-name)))
+  (comint-send-string (ruby-proc) (concat "(load \""
+					    file-name
+					    "\"\)\n")))
+
+(defun ruby-proc ()
+  "Returns the current ruby process. See variable ruby-buffer."
+  (let ((proc (get-buffer-process (if (eq major-mode 'inferior-ruby-mode)
+				      (current-buffer)
+				    ruby-buffer))))
+    (or proc
+	(error "No current process. See variable ruby-buffer"))))
+
+;;; Do the user's customisation...
+
+(defvar inf-ruby-load-hook nil
+  "This hook is run when inf-ruby is loaded in.
+This is a good place to put keybindings.")
+	
+(run-hooks 'inf-ruby-load-hook)
+
+(provide 'inf-ruby)
+
+;;; inf-ruby.el ends here
diff --git a/misc/ruby-mode.el b/misc/ruby-mode.el
new file mode 100644
index 0000000000..61c6d9378b
--- /dev/null
+++ b/misc/ruby-mode.el
@@ -0,0 +1,724 @@
+;;;
+;;;  ruby-mode.el -
+;;;
+;;;  $Author$
+;;;  $Date$
+;;;  created at: Fri Feb  4 14:49:13 JST 1994
+;;;
+
+(defconst ruby-mode-revision "$Revision$")
+
+(defconst ruby-mode-version
+  (progn
+   (string-match "[0-9.]+" ruby-mode-revision)
+   (substring ruby-mode-revision (match-beginning 0) (match-end 0))))
+
+(defconst ruby-block-beg-re
+  "class\\|module\\|def\\|if\\|unless\\|case\\|while\\|until\\|for\\|begin\\|do"
+  )
+
+(defconst ruby-indent-beg-re
+  "\\(\\s *\\(class\\|module\\|def\\)\\)\\|if\\|unless\\|case\\|while\\|until\\|for\\|begin"
+    )
+
+(defconst ruby-modifier-re
+  "if\\|unless\\|while\\|until"
+  )
+
+(defconst ruby-block-mid-re
+  "then\\|else\\|elsif\\|when\\|rescue\\|ensure"
+  )
+
+(defconst ruby-block-op-re
+  "and\\|or\\|not"
+  )
+
+(defconst ruby-block-end-re "end")
+
+(defconst ruby-delimiter
+  (concat "[?$/%(){}#\"'`.:]\\|\\[\\|\\]\\|\\<\\("
+	  ruby-block-beg-re
+	  "\\|" ruby-block-end-re
+	  "\\)\\>\\|^=begin")
+  )
+
+(defconst ruby-negative
+  (concat "^[ \t]*\\(\\(" ruby-block-mid-re "\\)\\>\\|\\("
+	    ruby-block-end-re "\\)\\>\\|\\}\\|\\]\\)")
+  )
+
+(defconst ruby-operator-chars ",.+*/%-&|^~=<>:")
+(defconst ruby-operator-re (concat "[" ruby-operator-chars "]"))
+
+(defconst ruby-symbol-chars "a-zA-Z0-9_")
+(defconst ruby-symbol-re (concat "[" ruby-symbol-chars "]"))
+
+(defvar ruby-mode-abbrev-table nil
+  "Abbrev table in use in ruby-mode buffers.")
+
+(define-abbrev-table 'ruby-mode-abbrev-table ())
+
+(defvar ruby-mode-map nil "Keymap used in ruby mode.")
+
+(if ruby-mode-map
+    nil
+  (setq ruby-mode-map (make-sparse-keymap))
+  (define-key ruby-mode-map "{" 'ruby-electric-brace)
+  (define-key ruby-mode-map "}" 'ruby-electric-brace)
+  (define-key ruby-mode-map "\e\C-a" 'ruby-beginning-of-defun)
+  (define-key ruby-mode-map "\e\C-e" 'ruby-end-of-defun)
+  (define-key ruby-mode-map "\e\C-b" 'ruby-beginning-of-block)
+  (define-key ruby-mode-map "\e\C-f" 'ruby-end-of-block)
+  (define-key ruby-mode-map "\e\C-p" 'ruby-beginning-of-block)
+  (define-key ruby-mode-map "\e\C-n" 'ruby-end-of-block)
+  (define-key ruby-mode-map "\e\C-h" 'ruby-mark-defun)
+  (define-key ruby-mode-map "\t" 'ruby-indent-command)
+  (define-key ruby-mode-map "\C-c\C-e" 'ruby-insert-end)
+  (define-key ruby-mode-map "\C-j" 'ruby-reindent-then-newline-and-indent)
+  (define-key ruby-mode-map "\C-m" 'newline))
+
+(defvar ruby-mode-syntax-table nil
+  "Syntax table in use in ruby-mode buffers.")
+
+(if ruby-mode-syntax-table
+    ()
+  (setq ruby-mode-syntax-table (make-syntax-table))
+  (modify-syntax-entry ?\' "\"" ruby-mode-syntax-table)
+  (modify-syntax-entry ?\" "\"" ruby-mode-syntax-table)
+  (modify-syntax-entry ?\` "\"" ruby-mode-syntax-table)
+  (modify-syntax-entry ?# "<" ruby-mode-syntax-table)
+  (modify-syntax-entry ?\n ">" ruby-mode-syntax-table)
+  (modify-syntax-entry ?\\ "\\" ruby-mode-syntax-table)
+  (modify-syntax-entry ?$ "." ruby-mode-syntax-table)
+  (modify-syntax-entry ?? "_" ruby-mode-syntax-table)
+  (modify-syntax-entry ?_ "_" ruby-mode-syntax-table)
+  (modify-syntax-entry ?< "." ruby-mode-syntax-table)
+  (modify-syntax-entry ?> "." ruby-mode-syntax-table)
+  (modify-syntax-entry ?& "." ruby-mode-syntax-table)
+  (modify-syntax-entry ?| "." ruby-mode-syntax-table)
+  (modify-syntax-entry ?% "." ruby-mode-syntax-table)
+  (modify-syntax-entry ?= "." ruby-mode-syntax-table)
+  (modify-syntax-entry ?/ "." ruby-mode-syntax-table)
+  (modify-syntax-entry ?+ "." ruby-mode-syntax-table)
+  (modify-syntax-entry ?* "." ruby-mode-syntax-table)
+  (modify-syntax-entry ?- "." ruby-mode-syntax-table)
+  (modify-syntax-entry ?\; "." ruby-mode-syntax-table)
+  (modify-syntax-entry ?\( "()" ruby-mode-syntax-table)
+  (modify-syntax-entry ?\) ")(" ruby-mode-syntax-table)
+  (modify-syntax-entry ?\{ "(}" ruby-mode-syntax-table)
+  (modify-syntax-entry ?\} "){" ruby-mode-syntax-table)
+  (modify-syntax-entry ?\[ "(]" ruby-mode-syntax-table)
+  (modify-syntax-entry ?\] ")[" ruby-mode-syntax-table)
+  )
+
+(defvar ruby-indent-level 2
+  "*Indentation of ruby statements.")
+
+(defun ruby-mode-variables ()
+  (set-syntax-table ruby-mode-syntax-table)
+  (setq local-abbrev-table ruby-mode-abbrev-table)
+  (make-local-variable 'indent-line-function)
+  (setq indent-line-function 'ruby-indent-line)
+  (make-local-variable 'require-final-newline)
+  (setq require-final-newline t)
+  (make-variable-buffer-local 'comment-start)
+  (setq comment-start "# ")
+  (make-variable-buffer-local 'comment-end)
+  (setq comment-end "")
+  (make-variable-buffer-local 'comment-column)
+  (setq comment-column 32)
+  (make-variable-buffer-local 'comment-start-skip)
+  (setq comment-start-skip "\\(^\\|\\s-\\);?#+ *")
+  (make-local-variable 'parse-sexp-ignore-comments)
+  (setq parse-sexp-ignore-comments t)
+  (make-local-variable 'paragraph-start)
+  (setq paragraph-start (concat "$\\|" page-delimiter))
+  (make-local-variable 'paragraph-separate)
+  (setq paragraph-separate paragraph-start)
+  (make-local-variable 'paragraph-ignore-fill-prefix)
+  (setq paragraph-ignore-fill-prefix t))
+
+(defun ruby-mode ()
+  "Major mode for editing ruby scripts.
+\\[ruby-indent-command] properly indents subexpressions of multi-line
+class, module, def, if, while, for, do, and case statements, taking
+nesting into account.
+
+The variable ruby-indent-level controls the amount of indentation.
+\\{ruby-mode-map}"
+  (interactive)
+  (kill-all-local-variables)
+  (use-local-map ruby-mode-map)
+  (setq mode-name "Ruby")
+  (setq major-mode 'ruby-mode)
+  (ruby-mode-variables)
+
+  (run-hooks 'ruby-mode-hook))
+
+(defun ruby-current-indentation ()
+  (save-excursion
+    (beginning-of-line)
+    (back-to-indentation)
+    (current-column)))
+
+(defun ruby-indent-line (&optional flag)
+  "Correct indentation of the current ruby line."
+  (ruby-indent-to (ruby-calculate-indent)))
+
+(defun ruby-indent-command ()
+  (interactive)
+  (ruby-indent-line t))
+
+(defun ruby-indent-to (x)
+  (if x
+      (let (shift top beg)
+	(and (< x 0)
+	     (error "invalid nest"))
+	(setq shift (current-column))
+	(beginning-of-line)
+	(setq beg (point))
+	(back-to-indentation)
+	(setq top (current-column))
+	(skip-chars-backward " \t")
+	(cond
+	 ((>= x shift)
+	  (setq shift 0))
+	 ((>= shift top)
+	  (setq shift (- shift top)))
+	 (t (setq shift 0)))
+	(if (and (bolp)
+		 (= x top))
+	    (move-to-column (+ x shift))
+	  (move-to-column top)
+	  (delete-region beg (point))
+	  (beginning-of-line)
+	  (indent-to x)
+	  (move-to-column (+ x shift))))))
+
+(defun ruby-expr-beg (&optional modifier)
+  (save-excursion
+    (if (looking-at "\\?")
+	(progn
+	  (or (bolp) (forward-char -1))
+	  (not (looking-at "\\sw")))
+      (store-match-data nil)
+      (skip-chars-backward " \t")
+      (or (bolp) (forward-char -1))
+      (or (bolp)
+	  (looking-at ruby-operator-re)
+	  (looking-at "[\\[({]")
+	  (and (not modifier) (looking-at "[!?]"))
+	  (and (looking-at ruby-symbol-re)
+	       (forward-word -1)
+	       (if (and (not modifier) (bolp))
+		   t
+		 (if (or (looking-at ruby-block-beg-re)
+			 (looking-at ruby-block-op-re)
+			 (looking-at ruby-block-mid-re))
+		     (progn
+		       (goto-char (match-end 0))
+		       (looking-at "\\>"))
+		   (looking-at "[a-zA-Z][a-zA-z0-9_]* +/[^ \t]"))))))))
+
+(defun ruby-parse-region (start end)
+  (let ((indent-point end)
+	  (indent 0)
+	  (in-string nil)
+	  (in-paren nil)
+	  (depth 0)
+	  (nest nil)
+	  (pcol nil))
+    (save-excursion
+	(if start
+	    (goto-char start)
+	  (ruby-beginning-of-indent))
+	(save-restriction
+	  (narrow-to-region (point) end)
+	  (while (and (> indent-point (point))
+		      (re-search-forward ruby-delimiter indent-point t))
+	    (or depth (setq depth 0))
+	    (let ((pnt (point)) w)
+	      (goto-char (match-beginning 0))
+	      (cond
+	       ((or (looking-at "\"")	;skip string
+		    (looking-at "'")
+		    (looking-at "`"))
+		(setq w (char-after (point)))
+		(cond
+		 ((and (not (eobp))
+		       (re-search-forward (format "[^\\]\\(\\\\\\\\\\)*%c" w) indent-point t))
+		  nil)
+		 (t
+		  (setq in-string (point))
+		  (goto-char indent-point))))
+	       ((looking-at "/")
+		(cond
+		 ((and (not (eobp)) (ruby-expr-beg))
+		  (if (re-search-forward "[^\\]/" indent-point t)
+		      nil
+		    (setq in-string (point))
+		    (goto-char indent-point)))
+		 (t
+		  (goto-char pnt))))
+	       ((looking-at "%")
+		(cond
+		 ((and (not (eobp)) (ruby-expr-beg)
+		       (not (looking-at "%="))
+		       (looking-at "%[Qqrxw]?\\(.\\)"))
+		  (setq w (buffer-substring (match-beginning 1)
+					    (match-end 1)))
+		  (cond
+		   ((string= w "[") (setq w "]"))
+		   ((string= w "{") (setq w "}"))
+		   ((string= w "(") (setq w ")"))
+		   ((string= w "<") (setq w ">")))
+		  (goto-char (match-end 0))
+		  (if (search-forward w indent-point t)
+		      nil
+		    (setq in-string (point))
+		    (goto-char indent-point)))
+		 (t
+		  (goto-char pnt))))
+	       ((looking-at "\\?")	;skip ?char
+		(cond
+		 ((ruby-expr-beg)
+		  (looking-at "?\\(\\\\C-\\|\\\\M-\\)*.")
+		  (goto-char (match-end 0)))
+		 (t
+		  (goto-char pnt))))
+	       ((looking-at "\\$")	;skip $char
+		(goto-char pnt)
+		(forward-char 1))
+	       ((looking-at "#")	;skip comment
+		(forward-line 1)
+		(goto-char (point))
+		)
+	       ((looking-at "(")
+		(setq nest (cons (cons (char-after (point)) pnt) nest))
+		(setq pcol (cons (cons pnt depth) pcol))
+		(setq depth 0)
+		(goto-char pnt)
+		)
+	       ((looking-at "[\\[{]")
+		(setq nest (cons (cons (char-after (point)) pnt) nest))
+		(setq depth (1+ depth))
+		(goto-char pnt)
+		)
+	       ((looking-at ")")
+		(setq nest (cdr nest))
+		(setq depth (cdr (car pcol)))
+		(setq pcol (cdr pcol))
+		(goto-char pnt))
+	       ((looking-at "[])}]")
+		(setq nest (cdr nest))
+		(setq depth (1- depth))
+		(goto-char pnt))
+	       ((looking-at ruby-block-end-re)
+		(if (or (and (not (bolp))
+			     (progn
+			       (forward-char -1)
+			       (eq ?_ (char-after (point)))))
+			(progn
+			  (goto-char pnt)
+			  (setq w (char-after (point)))
+			  (or (eq ?_ w)
+			      (eq ?! w)
+			      (eq ?? w))))
+		    nil
+		  (setq nest (cdr nest))
+		  (setq depth (1- depth)))
+		(goto-char pnt))
+	       ((looking-at "def\\s +[^(\n;]*")
+		(if (or (bolp)
+			(progn
+			  (forward-char -1)
+			  (not (eq ?_ (char-after (point))))))
+		    (progn
+		      (setq nest (cons (cons nil pnt) nest))
+		      (setq depth (1+ depth))))
+		(goto-char (match-end 0)))
+	       ((looking-at ruby-block-beg-re)
+		(and 
+		 (or (bolp)
+		     (progn
+		       (forward-char -1)
+		       (not (eq ?_ (char-after (point))))))
+		 (goto-char pnt)
+		 (setq w (char-after (point)))
+		 (not (eq ?_ w))
+		 (not (eq ?! w))
+		 (not (eq ?? w))
+		 (skip-chars-forward " \t")
+		 (if (not (eolp))
+		     (progn
+		       (goto-char (match-beginning 0))
+		       (if (looking-at ruby-modifier-re)
+			   (ruby-expr-beg t)
+			 t))
+		   t)
+		 (goto-char pnt)
+		 (setq nest (cons (cons nil pnt) nest))
+		 (setq depth (1+ depth)))
+		(goto-char pnt))
+	       ((looking-at ":\\([a-zA-Z_][a-zA-Z_0-9]*\\)?")
+		(goto-char (match-end 0)))
+	       ((or (looking-at "\\.")
+		    (looking-at "\\.\\.\\.?")
+		    (looking-at "\\.[0-9]+")
+		    (looking-at "\\.[a-zA-Z_0-9]+"))
+		(goto-char (match-end 0)))
+	       ((looking-at "^=begin")
+		(if (re-search-forward "^=end" indent-point t)
+		    (forward-line 1)
+		  (setq in-string (match-end 0))
+		  (goto-char indent-point)))
+	       (t
+		(error (format "bad string %s"
+			       (buffer-substring (point) pnt)
+			       )))))))
+	(list in-string (car nest) depth (car (car pcol))))))
+
+(defun ruby-indent-size (pos nest)
+  (+ pos (* (if nest nest 1) ruby-indent-level)))
+
+(defun ruby-calculate-indent (&optional parse-start)
+  (save-excursion
+    (beginning-of-line)
+    (let ((indent-point (point))
+	    (case-fold-search nil)
+	    state bol eol
+	    (indent 0))
+	(if parse-start
+	    (goto-char parse-start)
+	  (ruby-beginning-of-indent)
+	  (setq parse-start (point)))
+	(back-to-indentation)
+	(setq indent (current-column))
+	(setq state (ruby-parse-region parse-start indent-point))
+	(cond
+	 ((nth 0 state)			; within string
+	  (setq indent nil))		;  do nothing
+
+	 ((car (nth 1 state))		; in paren
+	  (goto-char (cdr (nth 1 state)))
+	  (if (eq (car (nth 1 state)) ?\( )
+	      (let ((column (current-column))
+		    (s (ruby-parse-region (point) indent-point)))
+		(cond
+		 ((and (nth 2 s) (> (nth 2 s) 0))
+		  (goto-char (cdr (nth 1 s)))
+		  (forward-word -1)
+		  (setq indent (ruby-indent-size (current-column) (nth 2 state))))
+		 (t 
+		  (setq indent (current-column)))))
+	    (cond
+	     ((nth 3 state)
+	      (goto-char (nth 3 state))
+	      (setq indent (ruby-indent-size (current-column) (nth 2 state))))
+	     (t
+	      (goto-char parse-start)
+	      (back-to-indentation)
+	      (setq indent (ruby-indent-size (current-column) (nth 2 state)))))
+	    ))
+	  
+	 ((and (nth 2 state)(> (nth 2 state) 0)) ; in nest
+	  (if (null (cdr (nth 1 state)))
+	      (error "invalid nest"))
+	  (goto-char (cdr (nth 1 state)))
+	  (forward-word -1)		; skip back a keyword
+	  (cond
+	   ((looking-at "do")		; iter block is a special case
+	    (cond
+	     ((nth 3 state)
+	      (goto-char (nth 3 state))
+	      (setq indent (ruby-indent-size (current-column) (nth 2 state))))
+	     (t
+	      (goto-char parse-start)
+	      (back-to-indentation)
+	      (setq indent (ruby-indent-size (current-column) (nth 2 state))))))
+	   (t
+	    (setq indent (+ (current-column) ruby-indent-level)))))
+
+	 ((and (nth 2 state) (< (nth 2 state) 0)) ; in negative nest
+	  (setq indent (ruby-indent-size (current-column) (nth 2 state)))))
+	 
+	(cond
+	 (indent
+	  (goto-char indent-point)
+	  (end-of-line)
+	  (setq eol (point))
+	  (beginning-of-line)
+	  (cond 
+	   ((re-search-forward ruby-negative eol t)
+	    (and (not (eq ?_ (char-after (match-end 0))))
+		 (setq indent (- indent ruby-indent-level))))
+	   ;;operator terminated lines
+	   ((and
+	     (save-excursion
+	       (beginning-of-line)
+	       (not (bobp)))
+	     (or (null (car (nth 1 state))) ;not in parens
+		 (and (eq (car (nth 1 state)) ?\{)
+		      (save-excursion	;except non-block braces
+			(goto-char (cdr (nth 1 state)))
+			(or (bobp) (forward-char -1))
+			(not (ruby-expr-beg))))))
+	    ;; goto beginning of non-empty no-comment line
+	    (let (end done)
+	      (while (not done)
+		(skip-chars-backward " \t\n")
+		(setq end (point))
+		(beginning-of-line)
+		(if (re-search-forward "^\\s *#" end t)
+		    (beginning-of-line)
+		  (setq done t))))
+	    (setq bol (point))
+	    (end-of-line)
+	    (skip-chars-backward " \t")
+	    (and (re-search-backward "#" (save-excursion
+					   (beginning-of-line)
+					   (point)) t)
+		 (setq state (ruby-parse-region parse-start (point)))
+		 (nth 0 state)
+		 (goto-char (nth 0 state)))
+	    (or (bobp) (forward-char -1))
+	    (and
+	     (or (and (looking-at ruby-symbol-re)
+		      (skip-chars-backward ruby-symbol-chars)
+		      (looking-at ruby-block-op-re)
+		      (save-excursion
+			(goto-char (match-end 0))
+			(not (looking-at "[a-z_]"))))
+		 (and (looking-at ruby-operator-re)
+		      (or (not (eq ?/ (char-after (point))))
+			  (null (nth 0 (ruby-parse-region parse-start (point)))))
+		      (not (eq (char-after (1- (point))) ?$))
+		      (or (not (eq ?| (char-after (point))))
+			  (save-excursion
+			    (or (eolp) (forward-char -1))
+			    (and (search-backward "|")
+				 (skip-chars-backward " \t\n")
+				 (and (not (eolp))
+				      (progn
+					(forward-char -1)
+					(not (looking-at "\\{")))
+				      (progn
+					(forward-word -1)
+					(not (looking-at "do\\>[^_]")))))))))
+	     (setq indent (+ indent ruby-indent-level)))))))
+	indent)))
+ 
+(defun ruby-electric-brace (arg)
+  (interactive "P")
+  (self-insert-command (prefix-numeric-value arg))
+  (ruby-indent-line t))
+
+(defun ruby-beginning-of-defun (&optional arg)
+  "Move backward to next beginning-of-defun.
+With argument, do this that many times.
+Returns t unless search stops due to end of buffer."
+  (interactive "p")
+  (and (re-search-backward (concat "^\\(" ruby-block-beg-re "\\)\\b")
+			   nil 'move (or arg 1))
+       (progn (beginning-of-line) t)))
+
+(defun ruby-beginning-of-indent ()
+  (and (re-search-backward (concat "^\\(" ruby-indent-beg-re "\\)\\b")
+			   nil 'move)
+       (progn
+	 (beginning-of-line)
+	 t)))
+
+(defun ruby-end-of-defun (&optional arg)
+  "Move forward to next end of defun.
+An end of a defun is found by moving forward from the beginning of one."
+  (interactive "p")
+  (and (re-search-forward (concat "^\\(" ruby-block-end-re "\\)\\($\\|\\b[^_]\\)")
+			  nil 'move (or arg 1))
+       (progn (beginning-of-line) t))
+  (forward-line 1))
+
+(defun ruby-move-to-block (n)
+  (let (start pos done down)
+    (setq start (ruby-calculate-indent))
+    (if (eobp)
+	nil
+      (while (and (not (bobp)) (not done))
+	(forward-line n)
+	(cond
+	 ((looking-at "^$"))
+	 ((looking-at "^\\s *#"))
+	 (t
+	  (setq pos (current-indentation))
+	  (cond
+	   ((< start pos)
+	    (setq down t))
+	   ((and down (= pos start))
+	    (setq done t))
+	   ((> start pos)
+	    (setq done t)))))
+	(if done
+	    (progn
+	      (back-to-indentation)
+	      (if (looking-at ruby-block-mid-re)
+		  (setq done nil)))))))
+  (back-to-indentation))
+
+(defun ruby-beginning-of-block ()
+  "Move backward to next beginning-of-block"
+  (interactive)
+  (ruby-move-to-block -1))
+
+(defun ruby-end-of-block ()
+  "Move forward to next beginning-of-block"
+  (interactive)
+  (ruby-move-to-block 1))
+
+(defun ruby-reindent-then-newline-and-indent ()
+  (interactive "*")
+  (save-excursion
+    (delete-region (point) (progn (skip-chars-backward " \t") (point))))
+  (newline)
+  (save-excursion
+    (forward-line -1)
+    (indent-according-to-mode))
+  (indent-according-to-mode))
+
+(fset 'ruby-encomment-region (symbol-function 'comment-region))
+
+(defun ruby-decomment-region (beg end)
+  (interactive "r")
+  (save-excursion
+    (goto-char beg)
+    (while (re-search-forward "^\\([ \t]*\\)#" end t)
+      (replace-match "\\1" nil nil)
+      (save-excursion
+	(ruby-indent-line)))))
+
+(defun ruby-insert-end ()
+  (interactive)
+  (insert "end")
+  (ruby-indent-line t)
+  (end-of-line))
+
+(defun ruby-mark-defun ()
+  "Put mark at end of this Ruby function, point at beginning."
+  (interactive)
+  (push-mark (point))
+  (ruby-end-of-defun)
+  (push-mark (point) nil t)
+  (ruby-beginning-of-defun)
+  (re-search-backward "^\n" (- (point) 1) t))
+
+(cond
+ ((featurep 'font-lock)
+  (or (boundp 'font-lock-variable-name-face)
+      (setq font-lock-variable-name-face font-lock-type-face))
+
+  (add-hook 'ruby-mode-hook
+	    '(lambda ()
+	       (make-local-variable 'font-lock-syntactic-keywords)
+	       (setq font-lock-syntactic-keywords
+		     '(("\\$\\([#\"'`$\\]\\)" 1 (1 . nil))
+		       ("\\(#\\)[{$@]" 1 (1 . nil))))
+	       (make-local-variable 'font-lock-defaults)
+	       (setq font-lock-defaults '((ruby-font-lock-keywords) nil nil))
+	       (setq font-lock-keywords ruby-font-lock-keywords)))
+
+  (defun ruby-font-lock-docs (limit)
+    (if (re-search-forward "^=begin\\s *$" limit t)
+	(let (beg)
+	  (beginning-of-line)
+	  (setq beg (point))
+	  (forward-line 1)
+	  (if (re-search-forward "^=end\\s *$" limit t)
+	      (progn
+		(set-match-data (list beg (point)))
+		t)))))
+
+  (defvar ruby-font-lock-keywords
+    (list
+     (cons (concat
+	    "\\(^\\|[^_:.@$]\\|\\.\\.\\)\\b\\("
+	    (mapconcat
+	     'identity
+	     '("alias"
+	       "and"
+	       "begin"
+	       "break"
+	       "case"
+	       "catch"
+	       "class"
+	       "def"
+	       "do"
+	       "elsif"
+	       "else"
+	       "fail"
+	       "ensure"
+	       "for"
+	       "end"
+	       "if"
+	       "in"
+	       "module"
+	       "next"
+	       "not"
+	       "or"
+	       "raise"
+	       "redo"
+	       "rescue"
+	       "retry"
+	       "return"
+	       "then"
+	       "throw"
+	       "self"
+	       "super"
+	       "unless"
+	       "undef"
+	       "until"
+	       "when"
+	       "while"
+	       )
+	     "\\|")
+	    "\\)\\>[^_]")
+	   2)
+     ;; variables
+     '("\\b\\(nil\\|self\\|true\\|false\\)\\b"
+       1 font-lock-variable-name-face)
+     ;; variables
+     '("[$@].\\(\\w\\|_\\)*"
+       0 font-lock-variable-name-face)
+     ;; embedded document
+     '(ruby-font-lock-docs
+       0 font-lock-comment-face t)
+     ;; constants
+     '("\\(^\\|[^_]\\)\\b\\([A-Z]+\\(\\w\\|_\\)*\\)"
+       2 font-lock-type-face)
+     ;; functions
+     '("^\\s *def\\s *\\<\\(\\(\\w\\|_\\)+\\(\\.\\|::\\)\\)?\\(\\(\\w\\|_\\)+\\??\\)\\>"
+       4 font-lock-function-name-face t)
+     ;; symbols
+     '("\\(^\\|[^:]\\)\\(:\\(\\w\\|_\\)+\\??\\)\\b"
+       2 font-lock-reference-face))
+    "*Additional expressions to highlight in ruby mode."))
+
+ ((featurep 'hilit19)
+  (hilit-set-mode-patterns
+   'ruby-mode
+   '(("[^$\\?]\\(\"[^\\\"]*\\(\\\\\\(.\\|\n\\)[^\\\"]*\\)*\"\\)" 1 string)
+     ("[^$\\?]\\('[^\\']*\\(\\\\\\(.\\|\n\\)[^\\']*\\)*'\\)" 1 string)
+     ("[^$\\?]\\(`[^\\`]*\\(\\\\\\(.\\|\n\\)[^\\`]*\\)*`\\)" 1 string)
+     ("^\\s *#.*$" nil comment)
+     ("[^$@?\\]\\(#[^$@{\n].*$\\)" 1 comment)
+     ("[^a-zA-Z_]\\(\\?\\(\\\\[CM]-\\)*.\\)" 1 string)
+     ("^\\s *\\(require\\|load\\).*$" nil include)
+     ("^\\s *\\(include\\|alias\\|undef\\).*$" nil decl)
+     ("^\\s *\\<\\(class\\|def\\|module\\)\\>" "[)\n;]" defun)
+     ("[^_]\\<\\(begin\\|case\\|else\\|elsif\\|end\\|ensure\\|for\\|if\\|unless\\|rescue\\|then\\|when\\|while\\|until\\|do\\)\\>[^_]" 1 defun)
+     ("[^_]\\<\\(and\\|break\\|next\\|raise\\|fail\\|in\\|not\\|or\\|redo\\|retry\\|return\\|super\\|yield\\|catch\\|throw\\|self\\|nil\\)\\>[^_]" 1 keyword)
+     ("\\$\\(.\\|\\sw+\\)" nil type)
+     ("[$@].[a-zA-Z_0-9]*" nil struct)
+     ("^__END__" nil label))))
+ )
+
+
+(provide 'ruby-mode)
diff --git a/misc/rubydb2x.el b/misc/rubydb2x.el
new file mode 100644
index 0000000000..a74265fb0e
--- /dev/null
+++ b/misc/rubydb2x.el
@@ -0,0 +1,104 @@
+(require 'gud)
+(provide 'rubydb)
+
+;; ======================================================================
+;; rubydb functions
+
+;;; History of argument lists passed to rubydb.
+(defvar gud-rubydb-history nil)
+
+(defun gud-rubydb-massage-args (file args)
+  (cons "-I" (cons "." (cons "-r" (cons "debug" (cons file args))))))
+
+;; There's no guarantee that Emacs will hand the filter the entire
+;; marker at once; it could be broken up across several strings.  We
+;; might even receive a big chunk with several markers in it.  If we
+;; receive a chunk of text which looks like it might contain the
+;; beginning of a marker, we save it here between calls to the
+;; filter.
+(defvar gud-rubydb-marker-acc "")
+
+(defun gud-rubydb-marker-filter (string)
+  (save-match-data
+    (setq gud-marker-acc (concat gud-marker-acc string))
+    (let ((output ""))
+      
+      ;; Process all the complete markers in this chunk.
+      (while (string-match "\032\032\\([^:\n]*\\):\\([0-9]*\\):.*\n"
+                           gud-marker-acc)
+        (setq
+         
+         ;; Extract the frame position from the marker.
+         gud-last-frame
+         (cons (substring gud-marker-acc (match-beginning 1) (match-end 1))
+               (string-to-int (substring gud-marker-acc
+                                         (match-beginning 2)
+                                         (match-end 2))))
+         
+         ;; Append any text before the marker to the output we're going
+         ;; to return - we don't include the marker in this text.
+         output (concat output
+                        (substring gud-marker-acc 0 (match-beginning 0)))
+         
+         ;; Set the accumulator to the remaining text.
+         gud-marker-acc (substring gud-marker-acc (match-end 0))))
+      
+      ;; Does the remaining text look like it might end with the
+      ;; beginning of another marker?  If it does, then keep it in
+      ;; gud-marker-acc until we receive the rest of it.  Since we
+      ;; know the full marker regexp above failed, it's pretty simple to
+      ;; test for marker starts.
+      (if (string-match "\032.*\\'" gud-marker-acc)
+          (progn
+            ;; Everything before the potential marker start can be output.
+            (setq output (concat output (substring gud-marker-acc
+                                                   0 (match-beginning 0))))
+            
+            ;; Everything after, we save, to combine with later input.
+            (setq gud-marker-acc
+                  (substring gud-marker-acc (match-beginning 0))))
+        
+        (setq output (concat output gud-marker-acc)
+              gud-marker-acc ""))
+      
+      output)))
+  
+(defun gud-rubydb-find-file (f)
+  (find-file-noselect f))
+
+(defvar rubydb-command-name "ruby"
+  "File name for executing ruby.")
+
+;;;###autoload
+(defun rubydb (command-line)
+  "Run rubydb on program FILE in buffer *gud-FILE*.
+The directory containing FILE becomes the initial working directory
+and source-file directory for your debugger."
+  (interactive
+   (list (read-from-minibuffer "Run rubydb (like this): "
+                               (if (consp gud-rubydb-history)
+                                   (car gud-rubydb-history)
+                                 (concat rubydb-command-name " "))
+                               nil nil
+                               '(gud-rubydb-history . 1))))
+
+  (gud-overload-functions '((gud-massage-args . gud-rubydb-massage-args)
+                            (gud-marker-filter . gud-rubydb-marker-filter)
+                            (gud-find-file . gud-rubydb-find-file)
+                            ))
+  (gud-common-init command-line)
+
+  (gud-def gud-break  "b %l"         "\C-b" "Set breakpoint at current line.")
+;  (gud-def gud-remove "clear %l"     "\C-d" "Remove breakpoint at current line")
+  (gud-def gud-step   "s"            "\C-s" "Step one source line with display.")
+  (gud-def gud-next   "n"            "\C-n" "Step one line (skip functions).")
+  (gud-def gud-cont   "c"            "\C-r" "Continue with display.")
+  (gud-def gud-finish "finish"       "\C-f" "Finish executing current function.")
+  (gud-def gud-up     "up %p"        "<" "Up N stack frames (numeric arg).")
+  (gud-def gud-down   "down %p"      ">" "Down N stack frames (numeric arg).")
+  (gud-def gud-print  "p %e"         "\C-p" "Evaluate ruby expression at point.")
+
+  (setq comint-prompt-regexp "^(rdb:-) ")
+  (setq paragraph-start comint-prompt-regexp)
+  (run-hooks 'rubydb-mode-hook)
+  )
diff --git a/misc/rubydb3x.el b/misc/rubydb3x.el
new file mode 100644
index 0000000000..14e3dac83b
--- /dev/null
+++ b/misc/rubydb3x.el
@@ -0,0 +1,113 @@
+(require 'gud)
+(provide 'rubydb)
+
+;; ======================================================================
+;; rubydb functions
+
+;;; History of argument lists passed to rubydb.
+(defvar gud-rubydb-history nil)
+
+(if (fboundp 'gud-overload-functions)
+    (defun gud-rubydb-massage-args (file args)
+      (cons "-r" (cons "debug" (cons file args))))
+  (defun gud-rubydb-massage-args (file args)
+      (cons "-r" (cons "debug" args))))
+
+;; There's no guarantee that Emacs will hand the filter the entire
+;; marker at once; it could be broken up across several strings.  We
+;; might even receive a big chunk with several markers in it.  If we
+;; receive a chunk of text which looks like it might contain the
+;; beginning of a marker, we save it here between calls to the
+;; filter.
+(defvar gud-rubydb-marker-acc "")
+(make-variable-buffer-local 'gud-rubydb-marker-acc)
+
+(defun gud-rubydb-marker-filter (string)
+  (setq gud-rubydb-marker-acc (concat gud-rubydb-marker-acc string))
+  (let ((output ""))
+
+    ;; Process all the complete markers in this chunk.
+    (while (string-match "\032\032\\([^:\n]*\\):\\([0-9]*\\):.*\n"
+			 gud-rubydb-marker-acc)
+      (setq
+
+       ;; Extract the frame position from the marker.
+       gud-last-frame
+       (cons (substring gud-rubydb-marker-acc (match-beginning 1) (match-end 1))
+	     (string-to-int (substring gud-rubydb-marker-acc
+				       (match-beginning 2)
+				       (match-end 2))))
+
+       ;; Append any text before the marker to the output we're going
+       ;; to return - we don't include the marker in this text.
+       output (concat output
+		      (substring gud-rubydb-marker-acc 0 (match-beginning 0)))
+
+       ;; Set the accumulator to the remaining text.
+       gud-rubydb-marker-acc (substring gud-rubydb-marker-acc (match-end 0))))
+
+    ;; Does the remaining text look like it might end with the
+    ;; beginning of another marker?  If it does, then keep it in
+    ;; gud-rubydb-marker-acc until we receive the rest of it.  Since we
+    ;; know the full marker regexp above failed, it's pretty simple to
+    ;; test for marker starts.
+    (if (string-match "\032.*\\'" gud-rubydb-marker-acc)
+	(progn
+	  ;; Everything before the potential marker start can be output.
+	  (setq output (concat output (substring gud-rubydb-marker-acc
+						 0 (match-beginning 0))))
+
+	  ;; Everything after, we save, to combine with later input.
+	  (setq gud-rubydb-marker-acc
+		(substring gud-rubydb-marker-acc (match-beginning 0))))
+
+      (setq output (concat output gud-rubydb-marker-acc)
+	    gud-rubydb-marker-acc ""))
+
+    output))
+
+(defun gud-rubydb-find-file (f)
+  (save-excursion
+    (let ((buf (find-file-noselect f)))
+      (set-buffer buf)
+;;      (gud-make-debug-menu)
+      buf)))
+
+(defvar rubydb-command-name "ruby"
+  "File name for executing ruby.")
+
+;;;###autoload
+(defun rubydb (command-line)
+  "Run rubydb on program FILE in buffer *gud-FILE*.
+The directory containing FILE becomes the initial working directory
+and source-file directory for your debugger."
+  (interactive
+   (list (read-from-minibuffer "Run rubydb (like this): "
+			       (if (consp gud-rubydb-history)
+				   (car gud-rubydb-history)
+				 (concat rubydb-command-name " "))
+			       nil nil
+			       '(gud-rubydb-history . 1))))
+
+  (if (not (fboundp 'gud-overload-functions))
+      (gud-common-init command-line 'gud-rubydb-massage-args
+		       'gud-rubydb-marker-filter 'gud-rubydb-find-file)
+    (gud-overload-functions '((gud-massage-args . gud-rubydb-massage-args)
+			      (gud-marker-filter . gud-rubydb-marker-filter)
+			      (gud-find-file . gud-rubydb-find-file)))
+    (gud-common-init command-line rubydb-command-name))
+
+  (gud-def gud-break  "b %l"         "\C-b" "Set breakpoint at current line.")
+;  (gud-def gud-remove "clear %l"     "\C-d" "Remove breakpoint at current line")
+  (gud-def gud-step   "s"            "\C-s" "Step one source line with display.")
+  (gud-def gud-next   "n"            "\C-n" "Step one line (skip functions).")
+  (gud-def gud-cont   "c"            "\C-r" "Continue with display.")
+  (gud-def gud-finish "finish"       "\C-f" "Finish executing current function.")
+  (gud-def gud-up     "up %p"        "<" "Up N stack frames (numeric arg).")
+  (gud-def gud-down   "down %p"      ">" "Down N stack frames (numeric arg).")
+  (gud-def gud-print  "p %e"         "\C-p" "Evaluate ruby expression at point.")
+
+  (setq comint-prompt-regexp "^(rdb:-) ")
+  (set (make-local-variable 'paragraph-start) comint-prompt-regexp)
+  (run-hooks 'rubydb-mode-hook)
+  )