1
0
mirror of https://git.savannah.gnu.org/git/emacs.git synced 2024-12-25 10:47:00 +00:00

(gud-format-command): Rewrite.

(gud-format-command): Use gud-last-last-frame if
gud-last-frame is nil.

(gud-mipsdbx-massage-args, gud-mipsdbx-marker-filter):
New functions for dbx support on Mips under Ultrix.
(gud-dbx-mips-p, gud-mipsdbx-marker-acc): New variables.
(dbx) If gud-dbx-mips-p is non-nil, overload above two functions
and initialize appropriate command strings for dbx.

(gud-common-init): Call substitute-in-file-name.

(dbx): Let `comint-prompt-regexp' not match more than one line.
This commit is contained in:
Richard M. Stallman 1993-12-23 02:56:37 +00:00
parent 7d847440c5
commit 13eaa0261c

View File

@ -351,6 +351,70 @@ and source-file directory for your debugger."
(substring string (match-beginning 1) (match-end 1))))))
string)
;; Functions for dbx on Mips/Ultrix.
;; This is very similar to the code for gdb. The trick is to start dbx
;; with the (undocumented) option `-emacs'.
;; Are we running on a Mips system under Ultrix?
(defvar gud-dbx-mips-p (file-exists-p "/usr/include/mips"))
(defun gud-mipsdbx-massage-args (file args)
(cons "-emacs" (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-mipsdbx-marker-acc "")
(defun gud-mipsdbx-marker-filter (string)
(save-match-data
(setq gud-mipsdbx-marker-acc (concat gud-mipsdbx-marker-acc string))
(let ((output ""))
;; Process all the complete markers in this chunk.
(while (string-match
"^[] [0-9]*\032\032\\([^:\n]*\\):\\([0-9]*\\):.*\n"
gud-mipsdbx-marker-acc)
(setq
;; Extract the frame position from the marker.
gud-last-frame (cons
(substring gud-mipsdbx-marker-acc
(match-beginning 1) (match-end 1))
(string-to-int
(substring gud-mipsdbx-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-mipsdbx-marker-acc
0 (match-beginning 0)))
;; Set the accumulator to the remaining text.
gud-mipsdbx-marker-acc (substring gud-mipsdbx-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-mipsdbx-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 "^[] [0-9]*\032.*\\'" gud-mipsdbx-marker-acc)
(setq
;; Everything before the potential marker start can be output.
output (concat output (substring gud-mipsdbx-marker-acc
0 (match-beginning 0)))
;; Everything after, we save, to combine with later input.
gud-mipsdbx-marker-acc (substring gud-mipsdbx-marker-acc
(match-beginning 0)))
(setq output (concat output gud-mipsdbx-marker-acc)
gud-mipsdbx-marker-acc ""))
output)))
(defun gud-dbx-find-file (f)
(find-file-noselect f))
@ -366,17 +430,29 @@ and source-file directory for your debugger."
"dbx ")
nil nil
'(gud-dbx-history . 1))))
(gud-overload-functions '((gud-massage-args . gud-dbx-massage-args)
(gud-marker-filter . gud-dbx-marker-filter)
(gud-find-file . gud-dbx-find-file)
))
(gud-overload-functions
(cond
(gud-dbx-mips-p
'((gud-massage-args . gud-mipsdbx-massage-args)
(gud-marker-filter . gud-mipsdbx-marker-filter)
(gud-find-file . gud-dbx-find-file)))
(t
'((gud-massage-args . gud-dbx-massage-args)
(gud-marker-filter . gud-dbx-marker-filter)
(gud-find-file . gud-dbx-find-file)))))
(gud-common-init command-line)
(gud-def gud-break "file \"%d%f\"\nstop at %l"
"\C-b" "Set breakpoint at current line.")
;; (gud-def gud-break "stop at \"%f\":%l"
;; "\C-b" "Set breakpoint at current line.")
(cond
(gud-dbx-mips-p
(gud-def gud-break "stop at \"%f\":%l"
"\C-b" "Set breakpoint at current line.")
(gud-def gud-finish "return" "\C-f" "Finish executing current function."))
(t
(gud-def gud-break "file \"%d%f\"\nstop at %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 "step %p" "\C-s" "Step one line with display.")
(gud-def gud-stepi "stepi %p" "\C-i" "Step one instruction with display.")
@ -386,7 +462,7 @@ and source-file directory for your debugger."
(gud-def gud-down "down %p" ">" "Down (numeric arg) stack frames.")
(gud-def gud-print "print %e" "\C-p" "Evaluate C expression at point.")
(setq comint-prompt-regexp "^[^)]*dbx) *")
(setq comint-prompt-regexp "^[^)\n]*dbx) *")
(run-hooks 'dbx-mode-hook)
)
@ -733,7 +809,7 @@ comint mode, which see."
(setq w (cdr w)))
(car w)))
(args (delq file-word (cdr words)))
(file (expand-file-name file-word))
(file (expand-file-name (substitute-in-file-name file-word)))
(filepart (file-name-nondirectory file)))
(switch-to-buffer (concat "*gud-" filepart "*"))
(setq default-directory (file-name-directory file))
@ -863,49 +939,40 @@ Obeying it means displaying in another window the specified file and line."
;;; gud-last-frame. Here's how we do it:
(defun gud-format-command (str arg)
(let ((insource (not (eq (current-buffer) gud-comint-buffer))))
(if (string-match "\\(.*\\)%f\\(.*\\)" str)
(setq str (concat
(substring str (match-beginning 1) (match-end 1))
(file-name-nondirectory (if insource
(let ((insource (not (eq (current-buffer) gud-comint-buffer)))
(frame (or gud-last-frame gud-last-last-frame))
result)
(while (and str (string-match "\\([^%]*\\)%\\([adeflp]\\)" str))
(let ((key (string-to-char (substring str (match-beginning 2))))
subst)
(cond
((eq key ?f)
(setq subst (file-name-nondirectory (if insource
(buffer-file-name)
(car frame)))))
((eq key ?d)
(setq subst (file-name-directory (if insource
(buffer-file-name)
(car gud-last-frame)))
(substring str (match-beginning 2) (match-end 2)))))
(if (string-match "\\(.*\\)%d\\(.*\\)" str)
(setq str (concat
(substring str (match-beginning 1) (match-end 1))
(file-name-directory (if insource
(buffer-file-name)
(car gud-last-frame)))
(substring str (match-beginning 2) (match-end 2)))))
(if (string-match "\\(.*\\)%l\\(.*\\)" str)
(setq str (concat
(substring str (match-beginning 1) (match-end 1))
(if insource
(save-excursion
(beginning-of-line)
(save-restriction (widen)
(1+ (count-lines 1 (point)))))
(cdr gud-last-frame))
(substring str (match-beginning 2) (match-end 2)))))
(if (string-match "\\(.*\\)%e\\(.*\\)" str)
(setq str (concat
(substring str (match-beginning 1) (match-end 1))
(find-c-expr)
(substring str (match-beginning 2) (match-end 2)))))
(if (string-match "\\(.*\\)%a\\(.*\\)" str)
(setq str (concat
(substring str (match-beginning 1) (match-end 1))
(gud-read-address)
(substring str (match-beginning 2) (match-end 2)))))
(if (string-match "\\(.*\\)%p\\(.*\\)" str)
(setq str (concat
(substring str (match-beginning 1) (match-end 1))
(if arg (int-to-string arg) "")
(substring str (match-beginning 2) (match-end 2)))))
)
str
)
(car frame)))))
((eq key ?l)
(setq subst (if insource
(save-excursion
(beginning-of-line)
(save-restriction (widen)
(1+ (count-lines 1 (point)))))
(cdr frame))))
((eq key ?e)
(setq subst (find-c-expr)))
((eq key ?a)
(setq subst (gud-read-address)))
((eq key ?p)
(setq subst (if arg (int-to-string arg) ""))))
(setq result (concat result
(substring str (match-beginning 1) (match-end 1))
subst)))
(setq str (substring str (match-end 2))))
;; There might be text left in STR when the loop ends.
(concat result str)))
(defun gud-read-address ()
"Return a string containing the core-address found in the buffer at point."