GUD octave support

[Daniel Elliott]

Hello,

This is my first crack at adding octave support in GUD.  It still
needs to have some of the features from the octave-inf mode included
if possible within the GUD framework.

It is a little rough, but appears to be stable and robust.

original is the version supplied debian (etch, i beleive)

*** original.el 2007-11-17 22:50:35.000000000 -0600
--- gud.el      2007-11-17 22:34:58.000000000 -0600
*************** gud, see `gud-mode'."
*** 2332,2337 ****
--- 2332,2462 ----
  ;; End of debugger-specific information
  ;;

+ ;; ======================================================================
+ ;; octave debugger functions
+
+ (defvar gud-octavedb-command-name "octave")
+
+ ;;; History of argument lists passed to octavedb
+ (defvar gud-octavedb-history nil)
+
+ (defun gud-octavedb-massage-args (file args)
+   ;; just use the default arguments from octave-inf
+   '("-i" "--no-line-editing" "-q" "--traditional"))
+
+ (setq gud-octavedb-marker-regexp
+       "keyboard: stopped in\s\\(.*\\)\sat line \\([0-9]+\\)")
+
+ (defun gud-octavedb-marker-filter (string)
+
+   (setq gud-marker-acc (concat gud-marker-acc string))
+   (let ((output ""))
+
+
+     ;; Process all the complete markers in this chunk.
+     (while (string-match gud-octavedb-marker-regexp gud-marker-acc)
+       (setq
+
+        ;; Extract the frame position from the marker.
+        gud-last-frame
+        (cons (match-string 1 gud-marker-acc)
+            (string-to-number (match-string 2 gud-marker-acc)))
+
+        ;; 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.
+
+     ;; DLE: i doubt this is applicable to octave's debug mode
+     (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))
+
+ (defvar octavedb-path '())
+ (defvar octavedb-init-file-locations '(~/.octaverc))
+
+ (defun octavedb-paths-from-init (init-file)
+   (switch-to-buffer (find-file init-file))
+   (keep-lines "addpath")
+   (goto-char (point-min))
+   (while (re-search-forward "addpath(\"\\(.*?\\)\".*" (point-max) nil)
+     (setq octavedb-path (cons (match-string 1) octavedb-path)))
+   ;; kill file without saving
+
+   )
+
+
+ (defun octavedb-find-file (full-paths)
+   (if (or (not full-paths) (file-regular-p (car full-paths)))
+       (car full-paths)
+     (octavedb-find-file (cdr full-paths)))
+   )
+
+ (defun gud-octavedb-find-file (f)
+   (when (not octavedb-path)
+     (setq octavedb-path (octavedb-paths-from-init "~/.octaverc")))
+   (if (file-regular-p f)
+       (set-buffer (find-file-noselect f))
+     (let* ((found-file (octavedb-find-file (mapcar (lambda (x)
(concat x "/" f)) octavedb-path))))
+       (if found-file
+         (set-buffer (find-file-noselect found-file))
+       ;; DLE: ask the user for the path
+       ;; DLE: add the path to our path list
+       (set-buffer (find-file-noselect f)))))
+   )
+
+
+
+
+ ;;;###autoload
+ (defun octavedb (command-line)
+   "Run octavedb starting with FILE
+ The directory containing FILE becomes the initial working directory
+ and source-file directory for your debugger."
+   ;;   (interactive
+   ;;    (list (read-from-minibuffer "Run which octave: "
+   ;;                         (if (consp gud-octavedb-history)
+   ;;                             (car gud-octavedb-history)
+   ;;                           gud-octavedb-command-name)
+   ;;                         nil nil
+   ;;                         '(gud-octavedb-history . 1))))
+   (setq command-line gud-octavedb-command-name)
+
+   (gud-common-init command-line 'gud-octavedb-massage-args
+                  'gud-octavedb-marker-filter 'gud-octavedb-find-file)
+
+   ;; DLE: try to add temporary break point
+   (gud-def gud-break  "dbstop(\"%f\",%l)"  "\C-b" "Set breakpoint at
current line.")
+   (gud-def gud-remove "dbclear(\"%f\",%l)"  "\C-d" "Remove
breakpoint at current line")
+   (gud-def gud-step   "dbstep"      "\C-s" "Step one source line
with display.")
+   (gud-def gud-next   "dbnext"      "\C-n" "Step one line (skip functions).")
+   (gud-def gud-cont   "dbcont"         "\C-r" "Continue with display.")
+
+   (setq comint-prompt-regexp "debug>\\|>>")
+   (setq paragraph-start comint-prompt-regexp)
+   (run-hooks 'octavedb-mode-hook)
+   )

  ;; When we send a command to the debugger via gud-call, it's annoying
  ;; to see the command and the new prompt inserted into the debugger's