Re: GUD octave support

[Nick Roberts]

 > 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)

I think Debian Etch uses Emacs 21.3 and gud.el has changed significantly
since then.  Your patch looks good but you will need to checkout Emacs from
the CVS repository (http://savannah.gnu.org/projects/emacs/) to submit
improvements.

 > + (defvar gud-octavedb-command-name "octave")

Use defcustom here:

(defcustom gud-octavedb-command-name
  "octave -i --no-line-editing -q --traditional"
  "Default command to execute an Octave script under debugger."
  :type 'string
  :group 'gud
  :version "22.2")

 > + ;;; History of argument lists passed to octavedb
 > + (defvar gud-octavedb-history nil)

Do you need massage-args, or can they just be included in the command-name as
above?

 > + (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]+\\)")

Use defvar here:

(defvar 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

You don't need to match "\032.*\\'" but there may be a problem if
gud-octavedb-marker-regexp is split between chunks of output though.
Let's ignore that for now.

 > +     (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))

Just

     (setq output (concat output gud-marker-acc)
           gud-marker-acc ""))

     output))

should do.

 > + (defvar octavedb-path '())
 > + (defvar octavedb-init-file-locations '(~/.octaverc))

If it's a list, call it one.  Also this is presumably customisable.

(defcustom octavedb-init-file-list '(~/.octaverc)
   "List of...")

 > + (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)))


This looks a bit flakey.  Does Octave use an environment variable for the
path too?

 > +   ;; kill file without saving
 > +

A left over comment?

 > +   )
 > +

Please put this brace on the same line as the previous one and leave just one
space between functions.

 > +
 > + (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)))

Ditto (brace).

 > +   )
 > +
 > + (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)))))

Ditto.

 > +   )
 > +
 > +
 > +
 > +
 > + ;;;###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))))

This should presumably be uncommented.  Why not just:

  (interactive (list (gud-query-cmdline 'octavedb)))

 > +   (setq command-line gud-octavedb-command-name)
 > +
 > +   (gud-common-init command-line 'gud-octavedb-massage-args
 > +                  'gud-octavedb-marker-filter 'gud-octavedb-find-file)

If massage-args aren't needed:

  (gud-common-init command-line nil '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 I tried M-x octavedb and gave it a script as an argument:

Run octavedb (like this): octave -i --no-line-editing -q --traditional example.m

it just ran the script.  How does octavedb allow the user to stop and step
through lines?

I think this should be included in Emacs 22 when all issues have been
addressed.  Thanks for your contribution.


-- 
Nick                                           http://www.inet.net.nz/~nickrob