+++ /dev/null
-(defmacro gud (form)
- (` (save-excursion (set-buffer "*gud-a.out*") (, form))))
-
-(defun dbug (foo &optional fun)
- (save-excursion
- (set-buffer (get-buffer-create "*trace*"))
- (goto-char (point-max))
- (insert "***" (symbol-name foo) "\n")
- (if fun
- (funcall fun))))
-
-
-;;; gud.el --- Grand Unified Debugger mode for gdb, sdb, dbx, or xdb
-;;; under Emacs
-
-;; Author: Eric S. Raymond <esr@snark.thyrsus.com>
-;; Maintainer: FSF
-;; Version: 1.3
-;; Keywords: unix, tools
-
-;; Copyright (C) 1992, 1993 Free Software Foundation, Inc.
-
-;; This file is part of GNU Emacs.
-
-;; GNU Emacs 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.
-
-;; GNU Emacs 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; if not, write to the Free Software
-;; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-
-;;; Commentary:
-
-;; The ancestral gdb.el was by W. Schelter <wfs@rascal.ics.utexas.edu>
-;; It was later rewritten by rms. Some ideas were due to Masanobu.
-;; Grand Unification (sdb/dbx support) by Eric S. Raymond <esr@thyrsus.com>
-;; The overloading code was then rewritten by Barry Warsaw <bwarsaw@cen.com>,
-;; who also hacked the mode to use comint.el. Shane Hartman <shane@spr.com>
-;; added support for xdb (HPUX debugger).
-
-;; Cygnus Support added support for gdb's --annotate=2.
-
-;;; Code:
-
-(require 'comint)
-(require 'etags)
-
-;; ======================================================================
-;; GUD commands must be visible in C buffers visited by GUD
-
-(defvar gud-key-prefix "\C-x\C-a"
- "Prefix of all GUD commands valid in C buffers.")
-
-(global-set-key (concat gud-key-prefix "\C-l") 'gud-refresh)
-(global-set-key "\C-x " 'gud-break) ;; backward compatibility hack
-
-;; ======================================================================
-;; the overloading mechanism
-
-(defun gud-overload-functions (gud-overload-alist)
- "Overload functions defined in GUD-OVERLOAD-ALIST.
-This association list has elements of the form
- (ORIGINAL-FUNCTION-NAME OVERLOAD-FUNCTION)"
- (mapcar
- (function (lambda (p) (fset (car p) (symbol-function (cdr p)))))
- gud-overload-alist))
-
-(defun gud-massage-args (file args)
- (error "GUD not properly entered."))
-
-(defun gud-marker-filter (str)
- (error "GUD not properly entered."))
-
-(defun gud-find-file (f)
- (error "GUD not properly entered."))
-\f
-;; ======================================================================
-;; command definition
-
-;; This macro is used below to define some basic debugger interface commands.
-;; Of course you may use `gud-def' with any other debugger command, including
-;; user defined ones.
-
-;; A macro call like (gud-def FUNC NAME KEY DOC) expands to a form
-;; which defines FUNC to send the command NAME to the debugger, gives
-;; it the docstring DOC, and binds that function to KEY in the GUD
-;; major mode. The function is also bound in the global keymap with the
-;; GUD prefix.
-
-(defmacro gud-def (func cmd key &optional doc)
- "Define FUNC to be a command sending STR and bound to KEY, with
-optional doc string DOC. Certain %-escapes in the string arguments
-are interpreted specially if present. These are:
-
- %f name (without directory) of current source file.
- %d directory of current source file.
- %l number of current source line
- %e text of the C lvalue or function-call expression surrounding point.
- %a text of the hexadecimal address surrounding point
- %p prefix argument to the command (if any) as a number
-
- The `current' source file is the file of the current buffer (if
-we're in a C file) or the source file current at the last break or
-step (if we're in the GUD buffer).
- The `current' line is that of the current buffer (if we're in a
-source file) or the source line number at the last break or step (if
-we're in the GUD buffer)."
- (list 'progn
- (list 'defun func '(arg)
- (or doc "")
- '(interactive "p")
- (list 'gud-call cmd 'arg))
- (if key
- (list 'define-key
- '(current-local-map)
- (concat "\C-c" key)
- (list 'quote func)))
- (if key
- (list 'global-set-key
- (list 'concat 'gud-key-prefix key)
- (list 'quote func)))))
-
-;; Where gud-display-frame should put the debugging arrow. This is
-;; set by the marker-filter, which scans the debugger's output for
-;; indications of the current program counter.
-(defvar gud-last-frame nil)
-
-;; Used by gud-refresh, which should cause gud-display-frame to redisplay
-;; the last frame, even if it's been called before and gud-last-frame has
-;; been set to nil.
-(defvar gud-last-last-frame nil)
-
-;; All debugger-specific information is collected here.
-;; Here's how it works, in case you ever need to add a debugger to the mode.
-;;
-;; Each entry must define the following at startup:
-;;
-;;<name>
-;; comint-prompt-regexp
-;; gud-<name>-massage-args
-;; gud-<name>-marker-filter
-;; gud-<name>-find-file
-;;
-;; The job of the massage-args method is to modify the given list of
-;; debugger arguments before running the debugger.
-;;
-;; The job of the marker-filter method is to detect file/line markers in
-;; strings and set the global gud-last-frame to indicate what display
-;; action (if any) should be triggered by the marker. Note that only
-;; whatever the method *returns* is displayed in the buffer; thus, you
-;; can filter the debugger's output, interpreting some and passing on
-;; the rest.
-;;
-;; The job of the find-file method is to visit and return the buffer indicated
-;; by the car of gud-tag-frame. This may be a file name, a tag name, or
-;; something else.
-\f
-;; ======================================================================
-;; gdb functions
-
-;;; History of argument lists passed to gdb.
-(defvar gud-gdb-history nil)
-
-(defun gud-gdb-massage-args (file args)
- (cons "--annotate=2" (cons file args)))
-
-\f
-;;
-;; In this world, there are gdb instance objects (of unspecified
-;; representation) and buffers associated with those objects.
-;;
-
-;;
-;; gdb-instance objects
-;;
-
-(defun make-gdb-instance (proc)
- "Create a gdb instance object from a gdb process."
- (setq last-proc proc)
- (let ((instance (cons 'gdb-instance proc)))
- (save-excursion
- (set-buffer (process-buffer proc))
- (setq gdb-buffer-instance instance)
- (progn
- (mapcar 'make-variable-buffer-local gdb-instance-variables)
- (setq gdb-buffer-type 'gud)
- ;; If we're taking over the buffer of another process,
- ;; take over it's ancillery buffers as well.
- ;;
- (let ((dead (or old-gdb-buffer-instance)))
- (mapcar
- (function
- (lambda (b)
- (progn
- (set-buffer b)
- (if (eq dead gdb-buffer-instance)
- (setq gdb-buffer-instance instance)))))
- (buffer-list)))))
- instance))
-
-(defun gdb-instance-process (inst) (cdr inst))
-
-;;; The list of instance variables is built up by the expansions of
-;;; DEF-GDB-VARIABLE
-;;;
-(defvar gdb-instance-variables '()
- "A list of variables that are local to the gud buffer associated
-with a gdb instance.")
-
-(defmacro def-gdb-variable
- (name accessor setter &optional default doc)
- (`
- (progn
- (defvar (, name) (, default) (, (or doc "undocumented")))
- (if (not (memq '(, name) gdb-instance-variables))
- (setq gdb-instance-variables
- (cons '(, name) gdb-instance-variables)))
- (, (and accessor
- (`
- (defun (, accessor) (instance)
- (let
- ((buffer (gdb-get-instance-buffer instance 'gud)))
- (and buffer
- (save-excursion
- (set-buffer buffer)
- (, name))))))))
- (, (and setter
- (`
- (defun (, setter) (instance val)
- (let
- ((buffer (gdb-get-instance-buffer instance 'gud)))
- (and buffer
- (save-excursion
- (set-buffer buffer)
- (setq (, name) val)))))))))))
-
-(defmacro def-gdb-var (root-symbol &optional default doc)
- (let* ((root (symbol-name root-symbol))
- (accessor (intern (concat "gdb-instance-" root)))
- (setter (intern (concat "set-gdb-instance-" root)))
- (var-name (intern (concat "gdb-" root))))
- (` (def-gdb-variable
- (, var-name) (, accessor) (, setter)
- (, default) (, doc)))))
-
-(def-gdb-var buffer-instance nil
- "In an instance buffer, the buffer's instance.")
-
-(def-gdb-var buffer-type nil
- "One of the symbols bound in gdb-instance-buffer-rules")
-
-(def-gdb-var burst ""
- "A string of characters from gdb that have not yet been processed.")
-
-(def-gdb-var input-queue ()
- "A list of high priority gdb command objects.")
-
-(def-gdb-var idle-input-queue ()
- "A list of low priority gdb command objects.")
-
-(def-gdb-var prompting nil
- "True when gdb is idle with no pending input.")
-
-(def-gdb-var output-sink 'user
- "The disposition of the output of the current gdb command.
-Possible values are these symbols:
-
- user -- gdb output should be copied to the gud buffer
- for the user to see.
-
- inferior -- gdb output should be copied to the inferior-io buffer
-
- pre-emacs -- output should be ignored util the post-prompt
- annotation is received. Then the output-sink
- becomes:...
- emacs -- output should be collected in the partial-output-buffer
- for subsequent processing by a command. This is the
- disposition of output generated by commands that
- gud mode sends to gdb on its own behalf.
- post-emacs -- ignore input until the prompt annotation is
- received, then go to USER disposition.
-")
-
-(def-gdb-var current-item nil
- "The most recent command item sent to gdb.")
-
-(def-gdb-var pending-triggers '()
- "A list of trigger functions that have run later than their output
-handlers.")
-
-(defun in-gdb-instance-context (instance form)
- "Funcall `form' in the gud buffer of `instance'"
- (save-excursion
- (set-buffer (gdb-get-instance-buffer instance 'gud))
- (funcall form)))
-
-;; end of instance vars
-
-;;
-;; finding instances
-;;
-
-(defun gdb-proc->instance (proc)
- (save-excursion
- (set-buffer (process-buffer proc))
- gdb-buffer-instance))
-
-(defun gdb-mru-instance-buffer ()
- "Return the most recently used (non-auxiliary) gdb gud buffer."
- (save-excursion
- (gdb-goto-first-gdb-instance (buffer-list))))
-
-(defun gdb-goto-first-gdb-instance (blist)
- "Use gdb-mru-instance-buffer -- not this."
- (and blist
- (progn
- (set-buffer (car blist))
- (or (and gdb-buffer-instance
- (eq gdb-buffer-type 'gud)
- (car blist))
- (gdb-goto-first-gdb-instance (cdr blist))))))
-
-(defun buffer-gdb-instance (buf)
- (save-excursion
- (set-buffer buf)
- gdb-buffer-instance))
-
-(defun gdb-needed-default-instance ()
- "Return the most recently used gdb instance or signal an error."
- (let ((buffer (gdb-mru-instance-buffer)))
- (or (and buffer (buffer-gdb-instance buffer))
- (error "No instance of gdb found."))))
-
-(defun gdb-instance-target-string (instance)
- "The apparent name of the program being debugged by a gdb instance.
-For sure this the root string used in smashing together the gud
-buffer's name, even if that doesn't happen to be the name of a
-program."
- (in-gdb-instance-context
- instance
- (function (lambda () gud-target-name))))
-
-\f
-
-;;
-;; Instance Buffers.
-;;
-
-;; More than one buffer can be associated with a gdb instance.
-;;
-;; Each buffer has a TYPE -- a symbol that identifies the function
-;; of that particular buffer.
-;;
-;; The usual gud interaction buffer is given the type `gud' and
-;; is constructed specially.
-;;
-;; Others are constructed by gdb-get-create-instance-buffer and
-;; named according to the rules set forth in the gdb-instance-buffer-rules-assoc
-
-(defun gdb-get-instance-buffer (instance key)
- "Return the instance buffer for `instance' tagged with type `key'.
-The key should be one of the cars in `gdb-instance-buffer-rules-assoc'."
- (save-excursion
- (gdb-look-for-tagged-buffer instance key (buffer-list))))
-
-(defun gdb-get-create-instance-buffer (instance key)
- "Create a new gdb instance buffer of the type specified by `key'.
-The key should be one of the cars in `gdb-instance-buffer-rules-assoc'."
- (or (gdb-get-instance-buffer instance key)
- (let* ((rules (assoc key gdb-instance-buffer-rules-assoc))
- (name (funcall (gdb-rules-name-maker rules) instance))
- (new (get-buffer-create name)))
- (save-excursion
- (set-buffer new)
- (make-variable-buffer-local 'gdb-buffer-type)
- (setq gdb-buffer-type key)
- (make-variable-buffer-local 'gdb-buffer-instance)
- (setq gdb-buffer-instance instance)
- (if (cdr (cdr rules))
- (funcall (car (cdr (cdr rules)))))
- new))))
-
-(defun gdb-rules-name-maker (rules) (car (cdr rules)))
-
-(defun gdb-look-for-tagged-buffer (instance key bufs)
- (let ((retval nil))
- (while (and (not retval) bufs)
- (set-buffer (car bufs))
- (if (and (eq gdb-buffer-instance instance)
- (eq gdb-buffer-type key))
- (setq retval (car bufs)))
- (setq bufs (cdr bufs))
- )
- retval))
-
-(defun gdb-instance-buffer-p (buf)
- (save-excursion
- (set-buffer buf)
- (and gdb-buffer-type
- (not (eq gdb-buffer-type 'gud)))))
-
-;;
-;; This assoc maps buffer type symbols to rules. Each rule is a list of
-;; at least one and possible more functions. The functions have these
-;; roles in defining a buffer type:
-;;
-;; NAME - take an instance, return a name for this type buffer for that
-;; instance.
-;; The remaining function(s) are optional:
-;;
-;; MODE - called in new new buffer with no arguments, should establish
-;; the proper mode for the buffer.
-;;
-
-(defvar gdb-instance-buffer-rules-assoc '())
-
-(defun gdb-set-instance-buffer-rules (buffer-type &rest rules)
- (let ((binding (assoc buffer-type gdb-instance-buffer-rules-assoc)))
- (if binding
- (setcdr binding rules)
- (setq gdb-instance-buffer-rules-assoc
- (cons (cons buffer-type rules)
- gdb-instance-buffer-rules-assoc)))))
-
-(gdb-set-instance-buffer-rules 'gud 'error) ; gud buffers are an exception to the rules
-
-;;
-;; partial-output buffers
-;;
-;; These accumulate output from a command executed on
-;; behalf of emacs (rather than the user).
-;;
-
-(gdb-set-instance-buffer-rules 'gdb-partial-output-buffer
- 'gdb-partial-output-name)
-
-(defun gdb-partial-output-name (instance)
- (concat "*partial-output-"
- (gdb-instance-target-string instance)
- "*"))
-
-\f
-(gdb-set-instance-buffer-rules 'gdb-inferior-io
- 'gdb-inferior-io-name
- 'gud-inferior-io-mode)
-
-(defun gdb-inferior-io-name (instance)
- (concat "*input/output of "
- (gdb-instance-target-string instance)
- "*"))
-
-(defvar gdb-inferior-io-mode-map (copy-keymap comint-mode-map))
-(define-key comint-mode-map "\C-c\C-c" 'gdb-inferior-io-interrupt)
-(define-key comint-mode-map "\C-c\C-z" 'gdb-inferior-io-stop)
-(define-key comint-mode-map "\C-c\C-\\" 'gdb-inferior-io-quit)
-(define-key comint-mode-map "\C-c\C-d" 'gdb-inferior-io-eof)
-
-(defun gud-inferior-io-mode ()
- "Major mode for gud inferior-io.
-
-\\{comint-mode-map}"
- ;; We want to use comint because it has various nifty and familiar
- ;; features. We don't need a process, but comint wants one, so create
- ;; a dummy one.
- (make-comint (substring (buffer-name) 1 (- (length (buffer-name)) 1))
- "/bin/cat")
- (setq major-mode 'gud-inferior-io-mode)
- (setq mode-name "Debuggee I/O")
- (setq comint-input-sender 'gud-inferior-io-sender)
-)
-
-(defun gud-inferior-io-sender (proc string)
- (save-excursion
- (set-buffer (process-buffer proc))
- (let ((instance gdb-buffer-instance))
- (set-buffer (gdb-get-instance-buffer instance 'gud))
- (let ((gud-proc (get-buffer-process (current-buffer))))
- (process-send-string gud-proc string)
- (process-send-string gud-proc "\n")
- ))
- ))
-
-(defun gdb-inferior-io-interrupt (instance)
- "Interrupt the program being debugged."
- (interactive (list (gdb-needed-default-instance)))
- (interrupt-process
- (get-buffer-process (gdb-get-instance-buffer instance 'gud)) comint-ptyp))
-
-(defun gdb-inferior-io-quit (instance)
- "Send quit signal to the program being debugged."
- (interactive (list (gdb-needed-default-instance)))
- (quit-process
- (get-buffer-process (gdb-get-instance-buffer instance 'gud)) comint-ptyp))
-
-(defun gdb-inferior-io-stop (instance)
- "Stop the program being debugged."
- (interactive (list (gdb-needed-default-instance)))
- (stop-process
- (get-buffer-process (gdb-get-instance-buffer instance 'gud)) comint-ptyp))
-
-(defun gdb-inferior-io-eof (instance)
- "Send end-of-file to the program being debugged."
- (interactive (list (gdb-needed-default-instance)))
- (process-send-eof
- (get-buffer-process (gdb-get-instance-buffer instance 'gud))))
-\f
-
-;;
-;; gdb communications
-;;
-
-;; INPUT: things sent to gdb
-;;
-;; Each instance has a high and low priority
-;; input queue. Low priority input is sent only
-;; when the high priority queue is idle.
-;;
-;; The queues are lists. Each element is either
-;; a string (indicating user or user-like input)
-;; or a list of the form:
-;;
-;; (INPUT-STRING HANDLER-FN)
-;;
-;;
-;; The handler function will be called from the
-;; partial-output buffer when the command completes.
-;; This is the way to write commands which
-;; invoke gdb commands autonomously.
-;;
-;; These lists are consumed tail first.
-;;
-
-(defun gdb-send (proc string)
- "A comint send filter for gdb.
-This filter may simply queue output for a later time."
- (let ((instance (gdb-proc->instance proc)))
- (gdb-instance-enqueue-input instance (concat string "\n"))))
-
-;; Note: Stuff enqueued here will be sent to the next prompt, even if it
-;; is a query, or other non-top-level prompt. To guarantee stuff will get
-;; sent to the top-level prompt, currently it must be put in the idle queue.
-;; ^^^^^^^^^
-;; [This should encourage gud extentions that invoke gdb commands to let
-;; the user go first; it is not a bug. -t]
-;;
-
-(defun gdb-instance-enqueue-input (instance item)
- (if (gdb-instance-prompting instance)
- (progn
- (gdb-send-item instance item)
- (set-gdb-instance-prompting instance nil))
- (set-gdb-instance-input-queue
- instance
- (cons item (gdb-instance-input-queue instance)))))
-
-(defun gdb-instance-dequeue-input (instance)
- (let ((queue (gdb-instance-input-queue instance)))
- (and queue
- (if (not (cdr queue))
- (let ((answer (car queue)))
- (set-gdb-instance-input-queue instance '())
- answer)
- (gdb-take-last-elt queue)))))
-
-(defun gdb-instance-enqueue-idle-input (instance item)
- (if (and (gdb-instance-prompting instance)
- (not (gdb-instance-input-queue instance)))
- (progn
- (gdb-send-item instance item)
- (set-gdb-instance-prompting instance nil))
- (set-gdb-instance-idle-input-queue
- instance
- (cons item (gdb-instance-idle-input-queue instance)))))
-
-(defun gdb-instance-dequeue-idle-input (instance)
- (let ((queue (gdb-instance-idle-input-queue instance)))
- (and queue
- (if (not (cdr queue))
- (let ((answer (car queue)))
- (set-gdb-instance-idle-input-queue instance '())
- answer)
- (gdb-take-last-elt queue)))))
-
-; Don't use this in general.
-(defun gdb-take-last-elt (l)
- (if (cdr (cdr l))
- (gdb-take-last-elt (cdr l))
- (let ((answer (car (cdr l))))
- (setcdr l '())
- answer)))
-
-\f
-;;
-;; output -- things gdb prints to emacs
-;;
-;; GDB output is a stream interrupted by annotations.
-;; Annotations can be recognized by their beginning
-;; with \C-j\C-z\C-z<tag><opt>\C-j
-;;
-;; The tag is a string obeying symbol syntax.
-;;
-;; The optional part `<opt>' can be either the empty string
-;; or a space followed by more data relating to the annotation.
-;; For example, the SOURCE annotation is followed by a filename,
-;; line number and various useless goo. This data must not include
-;; any newlines.
-;;
-
-
-(defun gud-gdb-marker-filter (string)
- "A gud marker filter for gdb."
- ;; Bogons don't tell us the process except through scoping crud.
- (let ((instance (gdb-proc->instance proc)))
- (gdb-output-burst instance string)))
-
-(defvar gdb-annotation-rules
- '(("frames-invalid" gdb-invalidate-frames)
- ("breakpoints-invalid" gdb-invalidate-breakpoints)
- ("pre-prompt" gdb-pre-prompt)
- ("prompt" gdb-prompt)
- ("commands" gdb-subprompt)
- ("overload-choice" gdb-subprompt)
- ("query" gdb-subprompt)
- ("prompt-for-continue" gdb-subprompt)
- ("post-prompt" gdb-post-prompt)
- ("source" gdb-source)
- ("starting" gdb-starting)
- ("exited" gdb-stopping)
- ("signalled" gdb-stopping)
- ("signal" gdb-stopping)
- ("breakpoint" gdb-stopping)
- ("watchpoint" gdb-stopping)
- ("stopped" gdb-stopped)
- )
- "An assoc mapping annotation tags to functions which process them.")
-
-
-(defun gdb-ignore-annotation (instance args)
- nil)
-
-(defconst gdb-source-spec-regexp
- "\\(.*\\):\\([0-9]*\\):[0-9]*:[a-z]*:0x[a-f0-9]*")
-
-;; Do not use this except as an annotation handler."
-(defun gdb-source (instance args)
- (string-match gdb-source-spec-regexp args)
- ;; Extract the frame position from the marker.
- (setq gud-last-frame
- (cons
- (substring args (match-beginning 1) (match-end 1))
- (string-to-int (substring args
- (match-beginning 2)
- (match-end 2))))))
-
-;; An annotation handler for `prompt'.
-;; This sends the next command (if any) to gdb.
-(defun gdb-prompt (instance ignored)
- (let ((sink (gdb-instance-output-sink instance)))
- (cond
- ((eq sink 'user) t)
- ((eq sink 'post-emacs)
- (set-gdb-instance-output-sink instance 'user))
- (t
- (set-gdb-instance-output-sink instance 'user)
- (error "Phase error in gdb-prompt (got %s)" sink))))
- (let ((highest (gdb-instance-dequeue-input instance)))
- (if highest
- (gdb-send-item instance highest)
- (let ((lowest (gdb-instance-dequeue-idle-input instance)))
- (if lowest
- (gdb-send-item instance lowest)
- (progn
- (set-gdb-instance-prompting instance t)
- (gud-display-frame)))))))
-
-;; An annotation handler for non-top-level prompts.
-(defun gdb-subprompt (instance ignored)
- (let ((highest (gdb-instance-dequeue-input instance)))
- (if highest
- (gdb-send-item instance highest)
- (set-gdb-instance-prompting instance t))))
-
-(defun gdb-send-item (instance item)
- (set-gdb-instance-current-item instance item)
- (if (stringp item)
- (progn
- (set-gdb-instance-output-sink instance 'user)
- (process-send-string (gdb-instance-process instance)
- item))
- (progn
- (gdb-clear-partial-output instance)
- (set-gdb-instance-output-sink instance 'pre-emacs)
- (process-send-string (gdb-instance-process instance)
- (car item)))))
-
-;; An annotation handler for `pre-prompt'.
-;; This terminates the collection of output from a previous
-;; command if that happens to be in effect.
-(defun gdb-pre-prompt (instance ignored)
- (let ((sink (gdb-instance-output-sink instance)))
- (cond
- ((eq sink 'user) t)
- ((eq sink 'emacs)
- (set-gdb-instance-output-sink instance 'post-emacs)
- (let ((handler
- (car (cdr (gdb-instance-current-item instance)))))
- (save-excursion
- (set-buffer (gdb-get-create-instance-buffer
- instance 'gdb-partial-output-buffer))
- (funcall handler))))
- (t
- (set-gdb-instance-output-sink instance 'user)
- (error "Output sink phase error 1.")))))
-
-;; An annotation handler for `starting'. This says that I/O for the subprocess
-;; is now the program being debugged, not GDB.
-(defun gdb-starting (instance ignored)
- (let ((sink (gdb-instance-output-sink instance)))
- (cond
- ((eq sink 'user)
- (set-gdb-instance-output-sink instance 'inferior)
- ;; FIXME: need to send queued input
- )
- (t (error "Unexpected `starting' annotation")))))
-
-;; An annotation handler for `exited' and other annotations which say that
-;; I/O for the subprocess is now GDB, not the program being debugged.
-(defun gdb-stopping (instance ignored)
- (let ((sink (gdb-instance-output-sink instance)))
- (cond
- ((eq sink 'inferior)
- (set-gdb-instance-output-sink instance 'user)
- )
- (t (error "Unexpected stopping annotation")))))
-
-;; An annotation handler for `stopped'. It is just like gdb-stopping, except
-;; that if we already set the output sink to 'user in gdb-stopping, that is
-;; fine.
-(defun gdb-stopped (instance ignored)
- (let ((sink (gdb-instance-output-sink instance)))
- (cond
- ((eq sink 'inferior)
- (set-gdb-instance-output-sink instance 'user)
- )
- ((eq sink 'user)
- t)
- (t (error "Unexpected stopping annotation")))))
-
-;; An annotation handler for `post-prompt'.
-;; This begins the collection of output from the current
-;; command if that happens to be appropriate."
-(defun gdb-post-prompt (instance ignored)
- (gdb-invalidate-registers instance ignored)
- (let ((sink (gdb-instance-output-sink instance)))
- (cond
- ((eq sink 'user) t)
- ((eq sink 'pre-emacs)
- (set-gdb-instance-output-sink instance 'emacs))
-
- (t
- (set-gdb-instance-output-sink instance 'user)
- (error "Output sink phase error 3.")))))
-
-;; Handle a burst of output from a gdb instance.
-;; This function is (indirectly) used as a gud-marker-filter.
-;; It must return output (if any) to be insterted in the gud
-;; buffer.
-
-(defun gdb-output-burst (instance string)
- "Handle a burst of output from a gdb instance.
-This function is (indirectly) used as a gud-marker-filter.
-It must return output (if any) to be insterted in the gud
-buffer."
-
- (save-match-data
- (let (
- ;; Recall the left over burst from last time
- (burst (concat (gdb-instance-burst instance) string))
- ;; Start accumulating output for the gud buffer
- (output ""))
-
- ;; Process all the complete markers in this chunk.
-
- (while (string-match "\n\032\032\\(.*\\)\n" burst)
- (let ((annotation (substring burst
- (match-beginning 1)
- (match-end 1))))
-
- ;; Stuff prior to the match is just ordinary output.
- ;; It is either concatenated to OUTPUT or directed
- ;; elsewhere.
- (setq output
- (gdb-concat-output
- instance
- output
- (substring burst 0 (match-beginning 0))))
-
- ;; Take that stuff off the burst.
- (setq burst (substring burst (match-end 0)))
-
- ;; Parse the tag from the annotation, and maybe its arguments.
- (string-match "\\(\\S-*\\) ?\\(.*\\)" annotation)
- (let* ((annotation-type (substring annotation
- (match-beginning 1)
- (match-end 1)))
- (annotation-arguments (substring annotation
- (match-beginning 2)
- (match-end 2)))
- (annotation-rule (assoc annotation-type
- gdb-annotation-rules)))
- ;; Call the handler for this annotation.
- (if annotation-rule
- (funcall (car (cdr annotation-rule))
- instance
- annotation-arguments)
- ;; Else the annotation is not recognized. Ignore it silently,
- ;; so that GDB can add new annotations without causing
- ;; us to blow up.
- ))))
-
-
- ;; Does the remaining text end in a partial line?
- ;; If it does, then keep part of the burst until we get more.
- (if (string-match "\n\\'\\|\n\032\\'\\|\n\032\032.*\\'"
- burst)
- (progn
- ;; Everything before the potential marker start can be output.
- (setq output
- (gdb-concat-output
- instance
- output
- (substring burst 0 (match-beginning 0))))
-
- ;; Everything after, we save, to combine with later input.
- (setq burst (substring burst (match-beginning 0))))
-
- ;; In case we know the burst contains no partial annotations:
- (progn
- (setq output (gdb-concat-output instance output burst))
- (setq burst "")))
-
- ;; Save the remaining burst for the next call to this function.
- (set-gdb-instance-burst instance burst)
- output)))
-
-(defun gdb-concat-output (instance so-far new)
- (let ((sink (gdb-instance-output-sink instance)))
- (cond
- ((eq sink 'user) (concat so-far new))
- ((or (eq sink 'pre-emacs) (eq sink 'post-emacs)) so-far)
- ((eq sink 'emacs)
- (gdb-append-to-partial-output instance new)
- so-far)
- ((eq sink 'inferior)
- (gdb-append-to-inferior-io instance new)
- so-far)
- (t (error "Bogon output sink %S" sink)))))
-
-(defun gdb-append-to-partial-output (instance string)
- (save-excursion
- (set-buffer
- (gdb-get-create-instance-buffer
- instance 'gdb-partial-output-buffer))
- (goto-char (point-max))
- (insert string)))
-
-(defun gdb-clear-partial-output (instance)
- (save-excursion
- (set-buffer
- (gdb-get-create-instance-buffer
- instance 'gdb-partial-output-buffer))
- (delete-region (point-min) (point-max))))
-
-(defun gdb-append-to-inferior-io (instance string)
- (save-excursion
- (set-buffer
- (gdb-get-create-instance-buffer
- instance 'gdb-inferior-io))
- (goto-char (point-max))
- (insert-before-markers string))
- (gud-display-buffer
- (gdb-get-create-instance-buffer instance
- 'gdb-inferior-io)))
-
-(defun gdb-clear-inferior-io (instance)
- (save-excursion
- (set-buffer
- (gdb-get-create-instance-buffer
- instance 'gdb-inferior-io))
- (delete-region (point-min) (point-max))))
-\f
-
-
-;; One trick is to have a command who's output is always available in
-;; a buffer of it's own, and is always up to date. We build several
-;; buffers of this type.
-;;
-;; There are two aspects to this: gdb has to tell us when the output
-;; for that command might have changed, and we have to be able to run
-;; the command behind the user's back.
-;;
-;; The idle input queue and the output phasing associated with
-;; the instance variable `(gdb-instance-output-sink instance)' help
-;; us to run commands behind the user's back.
-;;
-;; Below is the code for specificly managing buffers of output from one
-;; command.
-;;
-
-
-;; The trigger function is suitable for use in the assoc GDB-ANNOTATION-RULES
-;; It adds an idle input for the command we are tracking. It should be the
-;; annotation rule binding of whatever gdb sends to tell us this command
-;; might have changed it's output.
-;;
-;; NAME is the function name. DEMAND-PREDICATE tests if output is really needed.
-;; GDB-COMMAND is a string of such. OUTPUT-HANDLER is the function bound to the
-;; input in the input queue (see comment about ``gdb communications'' above).
-(defmacro def-gdb-auto-update-trigger (name demand-predicate gdb-command output-handler)
- (`
- (defun (, name) (instance &optional ignored)
- (if (and ((, demand-predicate) instance)
- (not (member '(, name)
- (gdb-instance-pending-triggers instance))))
- (progn
- (gdb-instance-enqueue-idle-input
- instance
- (list (, gdb-command) '(, output-handler)))
- (set-gdb-instance-pending-triggers
- instance
- (cons '(, name)
- (gdb-instance-pending-triggers instance))))))))
-
-(defmacro def-gdb-auto-update-handler (name trigger buf-key)
- (`
- (defun (, name) ()
- (set-gdb-instance-pending-triggers
- instance
- (delq '(, trigger)
- (gdb-instance-pending-triggers instance)))
- (let ((buf (gdb-get-instance-buffer instance
- '(, buf-key))))
- (and buf
- (save-excursion
- (set-buffer buf)
- (let ((p (point))
- (buffer-read-only nil))
- (delete-region (point-min) (point-max))
- (insert-buffer (gdb-get-create-instance-buffer
- instance
- 'gdb-partial-output-buffer))
- (goto-char p))))))))
-
-(defmacro def-gdb-auto-updated-buffer
- (buffer-key trigger-name gdb-command output-handler-name)
- (`
- (progn
- (def-gdb-auto-update-trigger (, trigger-name)
- ;; The demand predicate:
- (lambda (instance)
- (gdb-get-instance-buffer instance '(, buffer-key)))
- (, gdb-command)
- (, output-handler-name))
- (def-gdb-auto-update-handler (, output-handler-name)
- (, trigger-name) (, buffer-key)))))
-
-
-\f
-;;
-;; Breakpoint buffers
-;;
-;; These display the output of `info breakpoints'.
-;;
-
-
-(gdb-set-instance-buffer-rules 'gdb-breakpoints-buffer
- 'gdb-breakpoints-buffer-name
- 'gud-breakpoints-mode)
-
-(def-gdb-auto-updated-buffer gdb-breakpoints-buffer
- ;; This defines the auto update rule for buffers of type
- ;; `gdb-breakpoints-buffer'.
- ;;
- ;; It defines a function to serve as the annotation handler that
- ;; handles the `foo-invalidated' message. That function is called:
- gdb-invalidate-breakpoints
-
- ;; To update the buffer, this command is sent to gdb.
- "server info breakpoints\n"
-
- ;; This also defines a function to be the handler for the output
- ;; from the command above. That function will copy the output into
- ;; the appropriately typed buffer. That function will be called:
- gdb-info-breakpoints-handler)
-
-(defun gdb-breakpoints-buffer-name (instance)
- (save-excursion
- (set-buffer (process-buffer (gdb-instance-process instance)))
- (concat "*breakpoints of " (gdb-instance-target-string instance) "*")))
-
-(defun gud-display-breakpoints-buffer (instance)
- (interactive (list (gdb-needed-default-instance)))
- (gud-display-buffer
- (gdb-get-create-instance-buffer instance
- 'gdb-breakpoints-buffer)))
-
-(defun gud-frame-breakpoints-buffer (instance)
- (interactive (list (gdb-needed-default-instance)))
- (gud-frame-buffer
- (gdb-get-create-instance-buffer instance
- 'gdb-breakpoints-buffer)))
-
-(defvar gud-breakpoints-mode-map nil)
-(setq gud-breakpoints-mode-map (make-keymap))
-(suppress-keymap gud-breakpoints-mode-map)
-(define-key gud-breakpoints-mode-map " " 'gud-toggle-bp-this-line)
-(define-key gud-breakpoints-mode-map "d" 'gud-delete-bp-this-line)
-
-(defun gud-breakpoints-mode ()
- "Major mode for gud breakpoints.
-
-\\{gud-breakpoints-mode-map}"
- (setq major-mode 'gud-breakpoints-mode)
- (setq mode-name "Breakpoints")
- (use-local-map gud-breakpoints-mode-map)
- (setq buffer-read-only t)
- (gdb-invalidate-breakpoints gdb-buffer-instance))
-
-(defun gud-toggle-bp-this-line ()
- (interactive)
- (save-excursion
- (beginning-of-line 1)
- (if (not (looking-at "\\([0-9]*\\)\\s-*\\S-*\\s-*\\S-*\\s-*\\(.\\)"))
- (error "Not recognized as breakpoint line (demo foo).")
- (gdb-instance-enqueue-idle-input
- gdb-buffer-instance
- (list
- (concat
- (if (eq ?y (char-after (match-beginning 2)))
- "server disable "
- "server enable ")
- (buffer-substring (match-beginning 0)
- (match-end 1))
- "\n")
- '(lambda () nil)))
- )))
-
-(defun gud-delete-bp-this-line ()
- (interactive)
- (save-excursion
- (beginning-of-line 1)
- (if (not (looking-at "\\([0-9]*\\)\\s-*\\S-*\\s-*\\S-*\\s-*\\(.\\)"))
- (error "Not recognized as breakpoint line (demo foo).")
- (gdb-instance-enqueue-idle-input
- gdb-buffer-instance
- (list
- (concat
- "server delete "
- (buffer-substring (match-beginning 0)
- (match-end 1))
- "\n")
- '(lambda () nil)))
- )))
-
-
-
-\f
-;;
-;; Frames buffers. These display a perpetually correct bactracktrace
-;; (from the command `where').
-;;
-;; Alas, if your stack is deep, they are costly.
-;;
-
-(gdb-set-instance-buffer-rules 'gdb-stack-buffer
- 'gdb-stack-buffer-name
- 'gud-frames-mode)
-
-(def-gdb-auto-updated-buffer gdb-stack-buffer
- gdb-invalidate-frames
- "server where\n"
- gdb-info-frames-handler)
-
-(defun gdb-stack-buffer-name (instance)
- (save-excursion
- (set-buffer (process-buffer (gdb-instance-process instance)))
- (concat "*stack frames of "
- (gdb-instance-target-string instance) "*")))
-
-(defun gud-display-stack-buffer (instance)
- (interactive (list (gdb-needed-default-instance)))
- (gud-display-buffer
- (gdb-get-create-instance-buffer instance
- 'gdb-stack-buffer)))
-
-(defun gud-frame-stack-buffer (instance)
- (interactive (list (gdb-needed-default-instance)))
- (gud-frame-buffer
- (gdb-get-create-instance-buffer instance
- 'gdb-stack-buffer)))
-
-(defvar gud-frames-mode-map nil)
-(setq gud-frames-mode-map (make-keymap))
-(suppress-keymap gud-frames-mode-map)
-(define-key gud-frames-mode-map [mouse-2]
- 'gud-frames-select-by-mouse)
-
-(defun gud-frames-mode ()
- "Major mode for gud frames.
-
-\\{gud-frames-mode-map}"
- (setq major-mode 'gud-frames-mode)
- (setq mode-name "Frames")
- (setq buffer-read-only t)
- (use-local-map gud-frames-mode-map)
- (gdb-invalidate-frames gdb-buffer-instance))
-
-(defun gud-get-frame-number ()
- (save-excursion
- (let* ((pos (re-search-backward "^#\\([0-9]*\\)" nil t))
- (n (or (and pos
- (string-to-int
- (buffer-substring (match-beginning 1)
- (match-end 1))))
- 0)))
- n)))
-
-(defun gud-frames-select-by-mouse (e)
- (interactive "e")
- (let (selection)
- (save-excursion
- (set-buffer (window-buffer (posn-window (event-end e))))
- (save-excursion
- (goto-char (posn-point (event-end e)))
- (setq selection (gud-get-frame-number))))
- (select-window (posn-window (event-end e)))
- (save-excursion
- (set-buffer (gdb-get-instance-buffer (gdb-needed-default-instance) 'gud))
- (gud-call "fr %p" selection)
- (gud-display-frame))))
-
-\f
-;;
-;; Registers buffers
-;;
-
-(def-gdb-auto-updated-buffer gdb-registers-buffer
- gdb-invalidate-registers
- "server info registers\n"
- gdb-info-registers-handler)
-
-(gdb-set-instance-buffer-rules 'gdb-registers-buffer
- 'gdb-registers-buffer-name
- 'gud-registers-mode)
-
-(defvar gud-registers-mode-map nil)
-(setq gud-registers-mode-map (make-keymap))
-(suppress-keymap gud-registers-mode-map)
-
-(defun gud-registers-mode ()
- "Major mode for gud registers.
-
-\\{gud-registers-mode-map}"
- (setq major-mode 'gud-registers-mode)
- (setq mode-name "Registers")
- (setq buffer-read-only t)
- (use-local-map gud-registers-mode-map)
- (gdb-invalidate-registers gdb-buffer-instance))
-
-(defun gdb-registers-buffer-name (instance)
- (save-excursion
- (set-buffer (process-buffer (gdb-instance-process instance)))
- (concat "*registers of " (gdb-instance-target-string instance) "*")))
-
-(defun gud-display-registers-buffer (instance)
- (interactive (list (gdb-needed-default-instance)))
- (gud-display-buffer
- (gdb-get-create-instance-buffer instance
- 'gdb-registers-buffer)))
-
-(defun gud-frame-registers-buffer (instance)
- (interactive (list (gdb-needed-default-instance)))
- (gud-frame-buffer
- (gdb-get-create-instance-buffer instance
- 'gdb-registers-buffer)))
-
-\f
-
-;;;; Menu windows:
-
-
-;; MENU-LIST is ((option option option...) (option option ...)...)
-;;
-(defun gud-display-menu (menu-list)
- (setq fill-column (min 120 (- (window-width)
- (min 8 (window-width)))))
- (while menu-list
- (mapcar (function (lambda (x) (insert (symbol-name x) " "))) (car menu-list))
- (fill-paragraph nil)
- (insert "\n\n")
- (setq menu-list (cdr menu-list)))
- (goto-char (point-min))
- (while (re-search-forward "\\([^ \n]+\\)\\(\n\\| \\)" nil t)
- (put-text-property (match-beginning 1) (match-end 1)
- 'mouse-face 'highlight))
- (goto-char (point-min)))
-
-(defun gud-goto-menu (menu)
- (setq gud-menu-position menu)
- (let ((buffer-read-only nil))
- (delete-region (point-min) (point-max))
- (gud-display-menu menu)))
-
-(defun gud-menu-pick (event)
- "Choose an item from a gdb command menu."
- (interactive "e")
- (let (choice)
- (save-excursion
- (set-buffer (window-buffer (posn-window (event-start event))))
- (goto-char (posn-point (event-start event)))
- (let (beg end)
- (skip-chars-forward "^ \t\n")
- (setq end (point))
- (skip-chars-backward "^ \t\n")
- (setq beg (point))
- (setq choice (buffer-substring beg end))
- (message choice)
- (gud-invoke-menu (intern choice))))))
-
-(defun gud-invoke-menu (symbol)
- (let ((meaning (assoc symbol gud-menu-rules)))
- (cond
- ((and (consp meaning)
- (consp (car (cdr meaning))))
- (gud-goto-menu (car (cdr meaning))))
- (meaning (call-interactively (car (cdr meaning)))))))
-
-\f
-
-(gdb-set-instance-buffer-rules 'gdb-command-buffer
- 'gdb-command-buffer-name
- 'gud-command-mode)
-
-(defvar gud-command-mode-map nil)
-(setq gud-command-mode-map (make-keymap))
-(suppress-keymap gud-command-mode-map)
-(define-key gud-command-mode-map [mouse-2] 'gud-menu-pick)
-
-(defun gud-command-mode ()
- "Major mode for gud menu.
-
-\\{gud-command-mode-map}" (interactive) (setq major-mode 'gud-command-mode)
- (setq mode-name "Menu") (setq buffer-read-only t) (use-local-map
- gud-command-mode-map) (make-variable-buffer-local 'gud-menu-position)
- (if (not gud-menu-position) (gud-goto-menu gud-running-menu)))
-
-(defun gdb-command-buffer-name (instance)
- (save-excursion
- (set-buffer (process-buffer (gdb-instance-process instance)))
- (concat "*menu of " (gdb-instance-target-string instance) "*")))
-
-(defun gud-display-command-buffer (instance)
- (interactive (list (gdb-needed-default-instance)))
- (gud-display-buffer
- (gdb-get-create-instance-buffer instance
- 'gdb-command-buffer)
- 6))
-
-(defun gud-frame-command-buffer (instance)
- (interactive (list (gdb-needed-default-instance)))
- (gud-frame-buffer
- (gdb-get-create-instance-buffer instance
- 'gdb-command-buffer)))
-
-(defvar gud-selected-menu-titles ())
-(setq gud-selected-menu-titles
- '(RUNNING STACK DATA BREAKPOINTS FILES))
-
-(setq gud-running-menu
- (list
- '(RUNNING stack breakpoints files)
- '(target run next step continue finish stepi kill help-running)))
-
-(setq gud-stack-menu
- (list
- '(running STACK breakpoints files)
- '(up down frame backtrace return help-stack)))
-
-(setq gud-data-menu
- (list
- '(running stack DATA breakpoints files)
- '(whatis ptype print set display undisplay disassemble help-data)))
-
-(setq gud-breakpoints-menu
- (list
- '(running stack BREAKPOINTS files)
- '(awatch rwatch watch break delete enable disable condition ignore help-breakpoints)))
-
-(setq gud-files-menu
- (list
- '(running stack breakpoints FILES)
- '(file core-file help-files)
- '(exec-file load symbol-file add-symbol-file sharedlibrary)))
-
-(setq gud-menu-rules
- (list
- (list 'running gud-running-menu)
- (list 'RUNNING gud-running-menu)
- (list 'stack gud-stack-menu)
- (list 'STACK gud-stack-menu)
- (list 'data gud-data-menu)
- (list 'DATA gud-data-menu)
- (list 'breakpoints gud-breakpoints-menu)
- (list 'BREAKPOINTS gud-breakpoints-menu)
- (list 'files gud-files-menu)
- (list 'FILES gud-files-menu)
-
- (list 'target 'gud-target)
- (list 'kill 'gud-kill)
- (list 'stepi 'gud-stepi)
- (list 'step 'gud-step)
- (list 'next 'gud-next)
- (list 'finish 'gud-finish)
- (list 'continue 'gud-cont)
- (list 'run 'gud-run)
-
- (list 'backtrace 'gud-backtrace)
- (list 'frame 'gud-frame)
- (list 'down 'gud-down)
- (list 'up 'gud-up)
- (list 'return 'gud-return)
-
- (list 'file 'gud-file)
- (list 'core-file 'gud-core-file)
- (list 'cd 'gud-cd)
-
- (list 'exec-file 'gud-exec-file)
- (list 'load 'gud-load)
- (list 'symbol-file 'gud-symbol-file)
- (list 'add-symbol-file 'gud-add-symbol-file)
- (list 'sharedlibrary 'gud-sharedlibrary)
- ))
-
-
-\f
-
-(defun gdb-call-showing-gud (instance command)
- (gud-display-gud-buffer instance)
- (comint-input-sender (gdb-instance-process instance) command))
-
-(defvar gud-target-history ())
-
-(defun gud-temp-buffer-show (buf)
- (let ((ow (selected-window)))
- (unwind-protect
- (progn
- (pop-to-buffer buf)
-
- ;; This insertion works around a bug in emacs.
- ;; The bug is that all the empty space after a
- ;; highlighted word that terminates a buffer
- ;; gets highlighted. That's really ugly, so
- ;; make sure a highlighted word can't ever
- ;; terminate the buffer.
- (goto-char (point-max))
- (insert "\n")
- (goto-char (point-min))
-
- (if (< (window-height) 10)
- (enlarge-window (- 10 (window-height)))))
- (select-window ow))))
-
-(defun gud-target (instance command)
- (interactive
- (let* ((instance (gdb-needed-default-instance))
- (temp-buffer-show-function (function gud-temp-buffer-show))
- (target-name (completing-read (format "Target type: ")
- '(("remote")
- ("core")
- ("child")
- ("exec"))
- nil
- t
- nil
- 'gud-target-history)))
- (list instance
- (cond
- ((equal target-name "child") "run")
-
- ((equal target-name "core")
- (concat "target core "
- (read-file-name "core file: "
- nil
- "core"
- t)))
-
- ((equal target-name "exec")
- (concat "target exec "
- (read-file-name "exec file: "
- nil
- "a.out"
- t)))
-
- ((equal target-name "remote")
- (concat "target remote "
- (read-file-name "serial line for remote: "
- "/dev/"
- "ttya"
- t)))
-
- (t "echo No such target command!")))))
-
- (gud-display-gud-buffer instance)
- (apply comint-input-sender
- (list (gdb-instance-process instance) command)))
-
-(defun gud-backtrace ()
- (interactive)
- (let ((instance (gdb-needed-default-instance)))
- (gud-display-gud-buffer instance)
- (apply comint-input-sender
- (list (gdb-instance-process instance)
- "backtrace"))))
-
-(defun gud-frame ()
- (interactive)
- (let ((instance (gdb-needed-default-instance)))
- (apply comint-input-sender
- (list (gdb-instance-process instance)
- "frame"))))
-
-(defun gud-return (instance command)
- (interactive
- (let ((temp-buffer-show-function (function gud-temp-buffer-show)))
- (list (gdb-needed-default-instance)
- (concat "return " (read-string "Expression to return: ")))))
- (gud-display-gud-buffer instance)
- (apply comint-input-sender
- (list (gdb-instance-process instance) command)))
-
-
-(defun gud-file (instance command)
- (interactive
- (let ((temp-buffer-show-function (function gud-temp-buffer-show)))
- (list (gdb-needed-default-instance)
- (concat "file " (read-file-name "Executable to debug: "
- nil
- "a.out"
- t)))))
- (gud-display-gud-buffer instance)
- (apply comint-input-sender
- (list (gdb-instance-process instance) command)))
-
-(defun gud-core-file (instance command)
- (interactive
- (let ((temp-buffer-show-function (function gud-temp-buffer-show)))
- (list (gdb-needed-default-instance)
- (concat "core " (read-file-name "Core file to debug: "
- nil
- "core-file"
- t)))))
- (gud-display-gud-buffer instance)
- (apply comint-input-sender
- (list (gdb-instance-process instance) command)))
-
-(defun gud-cd (dir)
- (interactive "FChange GDB's default directory: ")
- (let ((instance (gdb-needed-default-instance)))
- (save-excursion
- (set-buffer (gdb-get-instance-buffer instance 'gud))
- (cd dir))
- (gud-display-gud-buffer instance)
- (apply comint-input-sender
- (list (gdb-instance-process instance)
- (concat "cd " dir)))))
-
-
-(defun gud-exec-file (instance command)
- (interactive
- (let ((temp-buffer-show-function (function gud-temp-buffer-show)))
- (list (gdb-needed-default-instance)
- (concat "exec-file " (read-file-name "Init memory from executable: "
- nil
- "a.out"
- t)))))
- (gud-display-gud-buffer instance)
- (apply comint-input-sender
- (list (gdb-instance-process instance) command)))
-
-(defun gud-load (instance command)
- (interactive
- (let ((temp-buffer-show-function (function gud-temp-buffer-show)))
- (list (gdb-needed-default-instance)
- (concat "load " (read-file-name "Dynamicly load from file: "
- nil
- "a.out"
- t)))))
- (gud-display-gud-buffer instance)
- (apply comint-input-sender
- (list (gdb-instance-process instance) command)))
-
-(defun gud-symbol-file (instance command)
- (interactive
- (let ((temp-buffer-show-function (function gud-temp-buffer-show)))
- (list (gdb-needed-default-instance)
- (concat "symbol-file " (read-file-name "Read symbol table from file: "
- nil
- "a.out"
- t)))))
- (gud-display-gud-buffer instance)
- (apply comint-input-sender
- (list (gdb-instance-process instance) command)))
-
-
-(defun gud-add-symbol-file (instance command)
- (interactive
- (let ((temp-buffer-show-function (function gud-temp-buffer-show)))
- (list (gdb-needed-default-instance)
- (concat "add-symbol-file "
- (read-file-name "Add symbols from file: "
- nil
- "a.out"
- t)))))
- (gud-display-gud-buffer instance)
- (apply comint-input-sender
- (list (gdb-instance-process instance) command)))
-
-
-(defun gud-sharedlibrary (instance command)
- (interactive
- (let ((temp-buffer-show-function (function gud-temp-buffer-show)))
- (list (gdb-needed-default-instance)
- (concat "sharedlibrary "
- (read-string "Load symbols for files matching regexp: ")))))
- (gud-display-gud-buffer instance)
- (apply comint-input-sender
- (list (gdb-instance-process instance) command)))
-
-
-
-\f
-
-;;;; Window management
-
-
-;;; FIXME: This should only return true for buffers in the current instance
-(defun gud-protected-buffer-p (buffer)
- "Is BUFFER a buffer which we want to leave displayed?"
- (save-excursion
- (set-buffer buffer)
- (or gdb-buffer-type
- overlay-arrow-position)))
-
-;;; The way we abuse the dedicated-p flag is pretty gross, but seems
-;;; to do the right thing. Seeing as there is no way for Lisp code to
-;;; get at the use_time field of a window, I'm not sure there exists a
-;;; more elegant solution without writing C code.
-
-(defun gud-display-buffer (buf &optional size)
- (let ((must-split nil)
- (answer nil))
- (unwind-protect
- (progn
- (walk-windows
- '(lambda (win)
- (if (gud-protected-buffer-p (window-buffer win))
- (set-window-dedicated-p win t))))
- (setq answer (get-buffer-window buf))
- (if (not answer)
- (let ((window (get-lru-window)))
- (if window
- (progn
- (set-window-buffer window buf)
- (setq answer window))
- (setq must-split t)))))
- (walk-windows
- '(lambda (win)
- (if (gud-protected-buffer-p (window-buffer win))
- (set-window-dedicated-p win nil)))))
- (if must-split
- (let* ((largest (get-largest-window))
- (cur-size (window-height largest))
- (new-size (and size (< size cur-size) (- cur-size size))))
- (setq answer (split-window largest new-size))
- (set-window-buffer answer buf)))
- answer))
-
-(defun existing-source-window (buffer)
- (catch 'found
- (save-excursion
- (walk-windows
- (function
- (lambda (win)
- (if (and overlay-arrow-position
- (eq (window-buffer win)
- (marker-buffer overlay-arrow-position)))
- (progn
- (set-window-buffer win buffer)
- (throw 'found win))))))
- nil)))
-
-(defun gud-display-source-buffer (buffer)
- (or (existing-source-window buffer)
- (gud-display-buffer buffer)))
-
-(defun gud-frame-buffer (buf)
- (save-excursion
- (set-buffer buf)
- (make-frame)))
-
-\f
-
-;;; Shared keymap initialization:
-
-(defun make-windows-menu (map)
- (define-key map [menu-bar displays]
- (cons "GDB-Windows" (make-sparse-keymap "GDB-Windows")))
- (define-key map [menu-bar displays gdb]
- '("Gdb" . gud-display-gud-buffer))
- (define-key map [menu-bar displays registers]
- '("Registers" . gud-display-registers-buffer))
- (define-key map [menu-bar displays frames]
- '("Stack" . gud-display-stack-buffer))
- (define-key map [menu-bar displays breakpoints]
- '("Breakpoints" . gud-display-breakpoints-buffer))
- (define-key map [menu-bar displays commands]
- '("Commands" . gud-display-command-buffer)))
-
-(defun gud-display-gud-buffer (instance)
- (interactive (list (gdb-needed-default-instance)))
- (gud-display-buffer
- (gdb-get-create-instance-buffer instance 'gud)))
-
-(make-windows-menu gud-breakpoints-mode-map)
-(make-windows-menu gud-frames-mode-map)
-(make-windows-menu gud-registers-mode-map)
-
-
-
-(defun make-frames-menu (map)
- (define-key map [menu-bar frames]
- (cons "GDB-Frames" (make-sparse-keymap "GDB-Frames")))
- (define-key map [menu-bar frames gdb]
- '("Gdb" . gud-frame-gud-buffer))
- (define-key map [menu-bar frames registers]
- '("Registers" . gud-frame-registers-buffer))
- (define-key map [menu-bar frames frames]
- '("Stack" . gud-frame-stack-buffer))
- (define-key map [menu-bar frames breakpoints]
- '("Breakpoints" . gud-frame-breakpoints-buffer))
- (define-key map [menu-bar displays commands]
- '("Commands" . gud-display-command-buffer)))
-
-(defun gud-frame-gud-buffer (instance)
- (interactive (list (gdb-needed-default-instance)))
- (gud-frame-buffer
- (gdb-get-create-instance-buffer instance 'gud)))
-
-(make-frames-menu gud-breakpoints-mode-map)
-(make-frames-menu gud-frames-mode-map)
-(make-frames-menu gud-registers-mode-map)
-
-\f
-(defun gud-gdb-find-file (f)
- (find-file-noselect f))
-
-;;;###autoload
-(defun gdb (command-line)
- "Run gdb 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 gdb (like this): "
- (if (consp gud-gdb-history)
- (car gud-gdb-history)
- "gdb ")
- nil nil
- '(gud-gdb-history . 1))))
- (gud-overload-functions
- '((gud-massage-args . gud-gdb-massage-args)
- (gud-marker-filter . gud-gdb-marker-filter)
- (gud-find-file . gud-gdb-find-file)
- ))
-
- (let* ((words (gud-chop-words command-line))
- (program (car words))
- (file-word (let ((w (cdr words)))
- (while (and w (= ?- (aref (car w) 0)))
- (setq w (cdr w)))
- (car w)))
- (args (delq file-word (cdr words)))
- (file (expand-file-name file-word))
- (filepart (file-name-nondirectory file))
- (buffer-name (concat "*gud-" filepart "*")))
- (setq gdb-first-time (not (get-buffer-process buffer-name))))
-
- (gud-common-init command-line)
-
- (gud-def gud-break "break %f:%l" "\C-b" "Set breakpoint at current line.")
- (gud-def gud-tbreak "tbreak %f:%l" "\C-t" "Set breakpoint at current line.")
- (gud-def gud-remove "clear %l" "\C-d" "Remove breakpoint at current line")
- (gud-def gud-kill "kill" nil "Kill the program.")
- (gud-def gud-run "run" nil "Run the program.")
- (gud-def gud-stepi "stepi %p" "\C-i" "Step one instruction with display.")
- (gud-def gud-step "step %p" "\C-s" "Step one source line with display.")
- (gud-def gud-next "next %p" "\C-n" "Step one line (skip functions).")
- (gud-def gud-finish "finish" "\C-f" "Finish executing current function.")
- (gud-def gud-cont "cont" "\C-r" "Continue with display.")
- (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 "print %e" "\C-p" "Evaluate C expression at point.")
-
- (setq comint-prompt-regexp "^(.*gdb[+]?) *")
- (setq comint-input-sender 'gdb-send)
- (run-hooks 'gdb-mode-hook)
- (let ((instance
- (make-gdb-instance (get-buffer-process (current-buffer)))
- ))
- (if gdb-first-time (gdb-clear-inferior-io instance)))
- )
-
-\f
-;; ======================================================================
-;; sdb functions
-
-;;; History of argument lists passed to sdb.
-(defvar gud-sdb-history nil)
-
-(defvar gud-sdb-needs-tags (not (file-exists-p "/var"))
- "If nil, we're on a System V Release 4 and don't need the tags hack.")
-
-(defvar gud-sdb-lastfile nil)
-
-(defun gud-sdb-massage-args (file args)
- (cons file args))
-
-(defun gud-sdb-marker-filter (string)
- (cond
- ;; System V Release 3.2 uses this format
- ((string-match "\\(^0x\\w* in \\|^\\|\n\\)\\([^:\n]*\\):\\([0-9]*\\):.*\n"
- string)
- (setq gud-last-frame
- (cons
- (substring string (match-beginning 2) (match-end 2))
- (string-to-int
- (substring string (match-beginning 3) (match-end 3))))))
- ;; System V Release 4.0
- ((string-match "^\\(BREAKPOINT\\|STEPPED\\) process [0-9]+ function [^ ]+ in \\(.+\\)\n"
- string)
- (setq gud-sdb-lastfile
- (substring string (match-beginning 2) (match-end 2))))
- ((and gud-sdb-lastfile (string-match "^\\([0-9]+\\):" string))
- (setq gud-last-frame
- (cons
- gud-sdb-lastfile
- (string-to-int
- (substring string (match-beginning 1) (match-end 1))))))
- (t
- (setq gud-sdb-lastfile nil)))
- string)
-
-(defun gud-sdb-find-file (f)
- (if gud-sdb-needs-tags
- (find-tag-noselect f)
- (find-file-noselect f)))
-
-;;;###autoload
-(defun sdb (command-line)
- "Run sdb 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 sdb (like this): "
- (if (consp gud-sdb-history)
- (car gud-sdb-history)
- "sdb ")
- nil nil
- '(gud-sdb-history . 1))))
- (if (and gud-sdb-needs-tags
- (not (and (boundp 'tags-file-name) (file-exists-p tags-file-name))))
- (error "The sdb support requires a valid tags table to work."))
- (gud-overload-functions '((gud-massage-args . gud-sdb-massage-args)
- (gud-marker-filter . gud-sdb-marker-filter)
- (gud-find-file . gud-sdb-find-file)
- ))
-
- (gud-common-init command-line)
-
- (gud-def gud-break "%l b" "\C-b" "Set breakpoint at current line.")
- (gud-def gud-tbreak "%l c" "\C-t" "Set temporary breakpoint at current line.")
- (gud-def gud-remove "%l d" "\C-d" "Remove breakpoint at current line")
- (gud-def gud-step "s %p" "\C-s" "Step one source line with display.")
- (gud-def gud-stepi "i %p" "\C-i" "Step one instruction with display.")
- (gud-def gud-next "S %p" "\C-n" "Step one line (skip functions).")
- (gud-def gud-cont "c" "\C-r" "Continue with display.")
- (gud-def gud-print "%e/" "\C-p" "Evaluate C expression at point.")
-
- (setq comint-prompt-regexp "\\(^\\|\n\\)\\*")
- (run-hooks 'sdb-mode-hook)
- )
-\f
-;; ======================================================================
-;; dbx functions
-
-;;; History of argument lists passed to dbx.
-(defvar gud-dbx-history nil)
-
-(defun gud-dbx-massage-args (file args)
- (cons file args))
-
-(defun gud-dbx-marker-filter (string)
- (if (or (string-match
- "stopped in .* at line \\([0-9]*\\) in file \"\\([^\"]*\\)\""
- string)
- (string-match
- "signal .* in .* at line \\([0-9]*\\) in file \"\\([^\"]*\\)\""
- string))
- (setq gud-last-frame
- (cons
- (substring string (match-beginning 2) (match-end 2))
- (string-to-int
- (substring string (match-beginning 1) (match-end 1))))))
- string)
-
-(defun gud-dbx-find-file (f)
- (find-file-noselect f))
-
-;;;###autoload
-(defun dbx (command-line)
- "Run dbx 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 dbx (like this): "
- (if (consp gud-dbx-history)
- (car gud-dbx-history)
- "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-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.")
- (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.")
- (gud-def gud-next "next %p" "\C-n" "Step one line (skip functions).")
- (gud-def gud-cont "cont" "\C-r" "Continue with display.")
- (gud-def gud-up "up %p" "<" "Up (numeric arg) stack frames.")
- (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) *")
- (run-hooks 'dbx-mode-hook)
- )
-\f
-;; ======================================================================
-;; xdb (HP PARISC debugger) functions
-
-;;; History of argument lists passed to xdb.
-(defvar gud-xdb-history nil)
-
-(defvar gud-xdb-directories nil
- "*A list of directories that xdb should search for source code.
-If nil, only source files in the program directory
-will be known to xdb.
-
-The file names should be absolute, or relative to the directory
-containing the executable being debugged.")
-
-(defun gud-xdb-massage-args (file args)
- (nconc (let ((directories gud-xdb-directories)
- (result nil))
- (while directories
- (setq result (cons (car directories) (cons "-d" result)))
- (setq directories (cdr directories)))
- (nreverse (cons file result)))
- args))
-
-(defun gud-xdb-file-name (f)
- "Transform a relative pathname to a full pathname in xdb mode"
- (let ((result nil))
- (if (file-exists-p f)
- (setq result (expand-file-name f))
- (let ((directories gud-xdb-directories))
- (while directories
- (let ((path (concat (car directories) "/" f)))
- (if (file-exists-p path)
- (setq result (expand-file-name path)
- directories nil)))
- (setq directories (cdr directories)))))
- result))
-
-;; xdb does not print the lines all at once, so we have to accumulate them
-(defvar gud-xdb-accumulation "")
-
-(defun gud-xdb-marker-filter (string)
- (let (result)
- (if (or (string-match comint-prompt-regexp string)
- (string-match ".*\012" string))
- (setq result (concat gud-xdb-accumulation string)
- gud-xdb-accumulation "")
- (setq gud-xdb-accumulation (concat gud-xdb-accumulation string)))
- (if result
- (if (or (string-match "\\([^\n \t:]+\\): [^:]+: \\([0-9]+\\):" result)
- (string-match "[^: \t]+:[ \t]+\\([^:]+\\): [^:]+: \\([0-9]+\\):"
- result))
- (let ((line (string-to-int
- (substring result (match-beginning 2) (match-end 2))))
- (file (gud-xdb-file-name
- (substring result (match-beginning 1) (match-end 1)))))
- (if file
- (setq gud-last-frame (cons file line))))))
- (or result "")))
-
-(defun gud-xdb-find-file (f)
- (let ((realf (gud-xdb-file-name f)))
- (if realf (find-file-noselect realf))))
-
-;;;###autoload
-(defun xdb (command-line)
- "Run xdb on program FILE in buffer *gud-FILE*.
-The directory containing FILE becomes the initial working directory
-and source-file directory for your debugger.
-
-You can set the variable 'gud-xdb-directories' to a list of program source
-directories if your program contains sources from more than one directory."
- (interactive
- (list (read-from-minibuffer "Run xdb (like this): "
- (if (consp gud-xdb-history)
- (car gud-xdb-history)
- "xdb ")
- nil nil
- '(gud-xdb-history . 1))))
- (gud-overload-functions '((gud-massage-args . gud-xdb-massage-args)
- (gud-marker-filter . gud-xdb-marker-filter)
- (gud-find-file . gud-xdb-find-file)))
-
- (gud-common-init command-line)
-
- (gud-def gud-break "b %f:%l" "\C-b" "Set breakpoint at current line.")
- (gud-def gud-tbreak "b %f:%l\\t" "\C-t"
- "Set temporary breakpoint at current line.")
- (gud-def gud-remove "db" "\C-d" "Remove breakpoint at current line")
- (gud-def gud-step "s %p" "\C-s" "Step one line with display.")
- (gud-def gud-next "S %p" "\C-n" "Step one line (skip functions).")
- (gud-def gud-cont "c" "\C-r" "Continue with display.")
- (gud-def gud-up "up %p" "<" "Up (numeric arg) stack frames.")
- (gud-def gud-down "down %p" ">" "Down (numeric arg) stack frames.")
- (gud-def gud-finish "bu\\t" "\C-f" "Finish executing current function.")
- (gud-def gud-print "p %e" "\C-p" "Evaluate C expression at point.")
-
- (setq comint-prompt-regexp "^>")
- (make-local-variable 'gud-xdb-accumulation)
- (setq gud-xdb-accumulation "")
- (run-hooks 'xdb-mode-hook))
-\f
-;; ======================================================================
-;; perldb functions
-
-;;; History of argument lists passed to perldb.
-(defvar gud-perldb-history nil)
-
-(defun gud-perldb-massage-args (file args)
- (cons "-d" (cons file (cons "-emacs" 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-perldb-marker-acc "")
-
-(defun gud-perldb-marker-filter (string)
- (save-match-data
- (setq gud-perldb-marker-acc (concat gud-perldb-marker-acc string))
- (let ((output ""))
-
- ;; Process all the complete markers in this chunk.
- (while (string-match "^\032\032\\([^:\n]*\\):\\([0-9]*\\):.*\n"
- gud-perldb-marker-acc)
- (setq
-
- ;; Extract the frame position from the marker.
- gud-last-frame
- (cons (substring gud-perldb-marker-acc (match-beginning 1) (match-end 1))
- (string-to-int (substring gud-perldb-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-perldb-marker-acc 0 (match-beginning 0)))
-
- ;; Set the accumulator to the remaining text.
- gud-perldb-marker-acc (substring gud-perldb-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-perldb-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-perldb-marker-acc)
- (progn
- ;; Everything before the potential marker start can be output.
- (setq output (concat output (substring gud-perldb-marker-acc
- 0 (match-beginning 0))))
-
- ;; Everything after, we save, to combine with later input.
- (setq gud-perldb-marker-acc
- (substring gud-perldb-marker-acc (match-beginning 0))))
-
- (setq output (concat output gud-perldb-marker-acc)
- gud-perldb-marker-acc ""))
-
- output)))
-
-(defun gud-perldb-find-file (f)
- (find-file-noselect f))
-
-;;;###autoload
-(defun perldb (command-line)
- "Run perldb 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 perldb (like this): "
- (if (consp gud-perldb-history)
- (car gud-perldb-history)
- "perl ")
- nil nil
- '(gud-perldb-history . 1))))
- (gud-overload-functions '((gud-massage-args . gud-perldb-massage-args)
- (gud-marker-filter . gud-perldb-marker-filter)
- (gud-find-file . gud-perldb-find-file)
- ))
-
- (gud-common-init command-line)
-
- (gud-def gud-break "b %l" "\C-b" "Set breakpoint at current line.")
- (gud-def gud-remove "d %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 "%e" "\C-p" "Evaluate perl expression at point.")
-
- (setq comint-prompt-regexp "^ DB<[0-9]+> ")
- (run-hooks 'perldb-mode-hook)
- )
-
-;;
-;; End of debugger-specific information
-;;
-
-\f
-;;; 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
-;;; buffer; we have other ways of knowing the command has completed.
-;;;
-;;; If the buffer looks like this:
-;;; --------------------
-;;; (gdb) set args foo bar
-;;; (gdb) -!-
-;;; --------------------
-;;; (the -!- marks the location of point), and we type `C-x SPC' in a
-;;; source file to set a breakpoint, we want the buffer to end up like
-;;; this:
-;;; --------------------
-;;; (gdb) set args foo bar
-;;; Breakpoint 1 at 0x92: file make-docfile.c, line 49.
-;;; (gdb) -!-
-;;; --------------------
-;;; Essentially, the old prompt is deleted, and the command's output
-;;; and the new prompt take its place.
-;;;
-;;; Not echoing the command is easy enough; you send it directly using
-;;; comint-input-sender, and it never enters the buffer. However,
-;;; getting rid of the old prompt is trickier; you don't want to do it
-;;; when you send the command, since that will result in an annoying
-;;; flicker as the prompt is deleted, redisplay occurs while Emacs
-;;; waits for a response from the debugger, and the new prompt is
-;;; inserted. Instead, we'll wait until we actually get some output
-;;; from the subprocess before we delete the prompt. If the command
-;;; produced no output other than a new prompt, that prompt will most
-;;; likely be in the first chunk of output received, so we will delete
-;;; the prompt and then replace it with an identical one. If the
-;;; command produces output, the prompt is moving anyway, so the
-;;; flicker won't be annoying.
-;;;
-;;; So - when we want to delete the prompt upon receipt of the next
-;;; chunk of debugger output, we position gud-delete-prompt-marker at
-;;; the start of the prompt; the process filter will notice this, and
-;;; delete all text between it and the process output marker. If
-;;; gud-delete-prompt-marker points nowhere, we leave the current
-;;; prompt alone.
-(defvar gud-delete-prompt-marker nil)
-
-\f
-(defvar gdbish-comint-mode-map (copy-keymap comint-mode-map))
-(define-key gdbish-comint-mode-map "\C-c\M-\C-r" 'gud-display-registers-buffer)
-(define-key gdbish-comint-mode-map "\C-c\M-\C-f" 'gud-display-stack-buffer)
-(define-key gdbish-comint-mode-map "\C-c\M-\C-b" 'gud-display-breakpoints-buffer)
-
-(make-windows-menu gdbish-comint-mode-map)
-(make-frames-menu gdbish-comint-mode-map)
-
-(defun gud-mode ()
- "Major mode for interacting with an inferior debugger process.
-
- You start it up with one of the commands M-x gdb, M-x sdb, M-x dbx,
-or M-x xdb. Each entry point finishes by executing a hook; `gdb-mode-hook',
-`sdb-mode-hook', `dbx-mode-hook' or `xdb-mode-hook' respectively.
-
-After startup, the following commands are available in both the GUD
-interaction buffer and any source buffer GUD visits due to a breakpoint stop
-or step operation:
-
-\\[gud-break] sets a breakpoint at the current file and line. In the
-GUD buffer, the current file and line are those of the last breakpoint or
-step. In a source buffer, they are the buffer's file and current line.
-
-\\[gud-remove] removes breakpoints on the current file and line.
-
-\\[gud-refresh] displays in the source window the last line referred to
-in the gud buffer.
-
-\\[gud-step], \\[gud-next], and \\[gud-stepi] do a step-one-line,
-step-one-line (not entering function calls), and step-one-instruction
-and then update the source window with the current file and position.
-\\[gud-cont] continues execution.
-
-\\[gud-print] tries to find the largest C lvalue or function-call expression
-around point, and sends it to the debugger for value display.
-
-The above commands are common to all supported debuggers except xdb which
-does not support stepping instructions.
-
-Under gdb, sdb and xdb, \\[gud-tbreak] behaves exactly like \\[gud-break],
-except that the breakpoint is temporary; that is, it is removed when
-execution stops on it.
-
-Under gdb, dbx, and xdb, \\[gud-up] pops up through an enclosing stack
-frame. \\[gud-down] drops back down through one.
-
-If you are using gdb or xdb, \\[gud-finish] runs execution to the return from
-the current function and stops.
-
-All the keystrokes above are accessible in the GUD buffer
-with the prefix C-c, and in all buffers through the prefix C-x C-a.
-
-All pre-defined functions for which the concept make sense repeat
-themselves the appropriate number of times if you give a prefix
-argument.
-
-You may use the `gud-def' macro in the initialization hook to define other
-commands.
-
-Other commands for interacting with the debugger process are inherited from
-comint mode, which see."
- (interactive)
- (comint-mode)
- (setq major-mode 'gud-mode)
- (setq mode-name "Debugger")
- (setq mode-line-process '(": %s"))
- (use-local-map (copy-keymap gdbish-comint-mode-map))
- (setq gud-last-frame nil)
- (make-local-variable 'comint-prompt-regexp)
- (make-local-variable 'gud-delete-prompt-marker)
- (setq gud-delete-prompt-marker (make-marker))
- (run-hooks 'gud-mode-hook)
-)
-
-(defvar gud-comint-buffer nil)
-
-;; Chop STRING into words separated by SPC or TAB and return a list of them.
-(defun gud-chop-words (string)
- (let ((i 0) (beg 0)
- (len (length string))
- (words nil))
- (while (< i len)
- (if (memq (aref string i) '(?\t ? ))
- (progn
- (setq words (cons (substring string beg i) words)
- beg (1+ i))
- (while (and (< beg len) (memq (aref string beg) '(?\t ? )))
- (setq beg (1+ beg)))
- (setq i (1+ beg)))
- (setq i (1+ i))))
- (if (< beg len)
- (setq words (cons (substring string beg) words)))
- (nreverse words)))
-
-(defvar gud-target-name "--unknown--"
- "The apparent name of the program being debugged in a gud buffer.
-For sure this the root string used in smashing together the gud
-buffer's name, even if that doesn't happen to be the name of a
-program.")
-
-;; Perform initializations common to all debuggers.
-(defun gud-common-init (command-line)
- (let* ((words (gud-chop-words command-line))
- (program (car words))
- (file-word (let ((w (cdr words)))
- (while (and w (= ?- (aref (car w) 0)))
- (setq w (cdr w)))
- (car w)))
- (args (delq file-word (cdr words)))
- (file (expand-file-name file-word))
- (filepart (file-name-nondirectory file))
- (buffer-name (concat "*gud-" filepart "*")))
- (switch-to-buffer buffer-name)
- (setq default-directory (file-name-directory file))
- (or (bolp) (newline))
- (insert "Current directory is " default-directory "\n")
- (let ((old-instance gdb-buffer-instance))
- (apply 'make-comint (concat "gud-" filepart) program nil
- (gud-massage-args file args))
- (gud-mode)
- (make-variable-buffer-local 'old-gdb-buffer-instance)
- (setq old-gdb-buffer-instance old-instance))
- (make-variable-buffer-local 'gud-target-name)
- (setq gud-target-name filepart))
- (set-process-filter (get-buffer-process (current-buffer)) 'gud-filter)
- (set-process-sentinel (get-buffer-process (current-buffer)) 'gud-sentinel)
- (gud-set-buffer)
- )
-
-(defun gud-set-buffer ()
- (cond ((eq major-mode 'gud-mode)
- (setq gud-comint-buffer (current-buffer)))))
-
-;; These functions are responsible for inserting output from your debugger
-;; into the buffer. The hard work is done by the method that is
-;; the value of gud-marker-filter.
-
-(defun gud-filter (proc string)
- ;; Here's where the actual buffer insertion is done
- (let ((inhibit-quit t))
- (save-excursion
- (set-buffer (process-buffer proc))
- (let (moving output-after-point)
- (save-excursion
- (goto-char (process-mark proc))
- ;; If we have been so requested, delete the debugger prompt.
- (if (marker-buffer gud-delete-prompt-marker)
- (progn
- (delete-region (point) gud-delete-prompt-marker)
- (set-marker gud-delete-prompt-marker nil)))
- (insert-before-markers (gud-marker-filter string))
- (setq moving (= (point) (process-mark proc)))
- (setq output-after-point (< (point) (process-mark proc)))
- ;; Check for a filename-and-line number.
- ;; Don't display the specified file
- ;; unless (1) point is at or after the position where output appears
- ;; and (2) this buffer is on the screen.
- (if (and gud-last-frame
- (not output-after-point)
- (get-buffer-window (current-buffer)))
- (gud-display-frame)))
- (if moving (goto-char (process-mark proc)))))))
-
-(defun gud-proc-died (proc)
- ;; Stop displaying an arrow in a source file.
- (setq overlay-arrow-position nil)
-
- ;; Kill the dummy process, so that C-x C-c won't worry about it.
- (save-excursion
- (set-buffer (process-buffer proc))
- (kill-process
- (get-buffer-process
- (gdb-get-instance-buffer gdb-buffer-instance 'gdb-inferior-io))))
- )
-
-(defun gud-sentinel (proc msg)
- (cond ((null (buffer-name (process-buffer proc)))
- ;; buffer killed
- (gud-proc-died proc)
- (set-process-buffer proc nil))
- ((memq (process-status proc) '(signal exit))
- (gud-proc-died proc)
-
- ;; Fix the mode line.
- (setq mode-line-process
- (concat ": "
- (symbol-name (process-status proc))))
- (let* ((obuf (current-buffer)))
- ;; save-excursion isn't the right thing if
- ;; process-buffer is current-buffer
- (unwind-protect
- (progn
- ;; Write something in *compilation* and hack its mode line,
- (set-buffer (process-buffer proc))
- ;; Force mode line redisplay soon
- (set-buffer-modified-p (buffer-modified-p))
- (if (eobp)
- (insert ?\n mode-name " " msg)
- (save-excursion
- (goto-char (point-max))
- (insert ?\n mode-name " " msg)))
- ;; If buffer and mode line will show that the process
- ;; is dead, we can delete it now. Otherwise it
- ;; will stay around until M-x list-processes.
- (delete-process proc))
- ;; Restore old buffer, but don't restore old point
- ;; if obuf is the gud buffer.
- (set-buffer obuf))))))
-
-(defun gud-display-frame ()
- "Find and obey the last filename-and-line marker from the debugger.
-Obeying it means displaying in another window the specified file and line."
- (interactive)
- (if gud-last-frame
- (progn
-; (gud-set-buffer)
- (gud-display-line (car gud-last-frame) (cdr gud-last-frame))
- (setq gud-last-last-frame gud-last-frame
- gud-last-frame nil))))
-
-;; Make sure the file named TRUE-FILE is in a buffer that appears on the screen
-;; and that its line LINE is visible.
-;; Put the overlay-arrow on the line LINE in that buffer.
-;; Most of the trickiness in here comes from wanting to preserve the current
-;; region-restriction if that's possible. We use an explicit display-buffer
-;; to get around the fact that this is called inside a save-excursion.
-
-(defun gud-display-line (true-file line)
- (let* ((buffer (gud-find-file true-file))
- (window (gud-display-source-buffer buffer))
- (pos))
- (if (not window)
- (error "foo bar baz"))
-;;; (if (equal buffer (current-buffer))
-;;; nil
-;;; (setq buffer-read-only nil))
- (save-excursion
-;;; (setq buffer-read-only t)
- (set-buffer buffer)
- (save-restriction
- (widen)
- (goto-line line)
- (setq pos (point))
- (setq overlay-arrow-string "=>")
- (or overlay-arrow-position
- (setq overlay-arrow-position (make-marker)))
- (set-marker overlay-arrow-position (point) (current-buffer)))
- (cond ((or (< pos (point-min)) (> pos (point-max)))
- (widen)
- (goto-char pos))))
- (set-window-point window overlay-arrow-position)))
-
-;;; The gud-call function must do the right thing whether its invoking
-;;; keystroke is from the GUD buffer itself (via major-mode binding)
-;;; or a C buffer. In the former case, we want to supply data from
-;;; 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
- (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
- )
-
-(defun gud-read-address ()
- "Return a string containing the core-address found in the buffer at point."
- (save-excursion
- (let ((pt (point)) found begin)
- (setq found (if (search-backward "0x" (- pt 7) t) (point)))
- (cond
- (found (forward-char 2)
- (buffer-substring found
- (progn (re-search-forward "[^0-9a-f]")
- (forward-char -1)
- (point))))
- (t (setq begin (progn (re-search-backward "[^0-9]")
- (forward-char 1)
- (point)))
- (forward-char 1)
- (re-search-forward "[^0-9]")
- (forward-char -1)
- (buffer-substring begin (point)))))))
-
-(defun gud-call (fmt &optional arg)
- (let ((msg (gud-format-command fmt arg)))
- (message "Command: %s" msg)
- (sit-for 0)
- (gud-basic-call msg)))
-
-(defun gud-basic-call (command)
- "Invoke the debugger COMMAND displaying source in other window."
- (interactive)
- (gud-set-buffer)
- (let ((proc (get-buffer-process gud-comint-buffer)))
-
- ;; Arrange for the current prompt to get deleted.
- (save-excursion
- (set-buffer gud-comint-buffer)
- (goto-char (process-mark proc))
- (beginning-of-line)
- (if (looking-at comint-prompt-regexp)
- (set-marker gud-delete-prompt-marker (point)))
- (apply comint-input-sender (list proc command)))))
-
-(defun gud-refresh (&optional arg)
- "Fix up a possibly garbled display, and redraw the arrow."
- (interactive "P")
- (recenter arg)
- (or gud-last-frame (setq gud-last-frame gud-last-last-frame))
- (gud-display-frame))
-\f
-;;; Code for parsing expressions out of C code. The single entry point is
-;;; find-c-expr, which tries to return an lvalue expression from around point.
-;;;
-;;; The rest of this file is a hacked version of gdbsrc.el by
-;;; Debby Ayers <ayers@asc.slb.com>,
-;;; Rich Schaefer <schaefer@asc.slb.com> Schlumberger, Austin, Tx.
-
-(defun find-c-expr ()
- "Returns the C expr that surrounds point."
- (interactive)
- (save-excursion
- (let ((p) (expr) (test-expr))
- (setq p (point))
- (setq expr (expr-cur))
- (setq test-expr (expr-prev))
- (while (expr-compound test-expr expr)
- (setq expr (cons (car test-expr) (cdr expr)))
- (goto-char (car expr))
- (setq test-expr (expr-prev)))
- (goto-char p)
- (setq test-expr (expr-next))
- (while (expr-compound expr test-expr)
- (setq expr (cons (car expr) (cdr test-expr)))
- (setq test-expr (expr-next))
- )
- (buffer-substring (car expr) (cdr expr)))))
-
-(defun expr-cur ()
- "Returns the expr that point is in; point is set to beginning of expr.
-The expr is represented as a cons cell, where the car specifies the point in
-the current buffer that marks the beginning of the expr and the cdr specifies
-the character after the end of the expr."
- (let ((p (point)) (begin) (end))
- (expr-backward-sexp)
- (setq begin (point))
- (expr-forward-sexp)
- (setq end (point))
- (if (>= p end)
- (progn
- (setq begin p)
- (goto-char p)
- (expr-forward-sexp)
- (setq end (point))
- )
- )
- (goto-char begin)
- (cons begin end)))
-
-(defun expr-backward-sexp ()
- "Version of `backward-sexp' that catches errors."
- (condition-case nil
- (backward-sexp)
- (error t)))
-
-(defun expr-forward-sexp ()
- "Version of `forward-sexp' that catches errors."
- (condition-case nil
- (forward-sexp)
- (error t)))
-
-(defun expr-prev ()
- "Returns the previous expr, point is set to beginning of that expr.
-The expr is represented as a cons cell, where the car specifies the point in
-the current buffer that marks the beginning of the expr and the cdr specifies
-the character after the end of the expr"
- (let ((begin) (end))
- (expr-backward-sexp)
- (setq begin (point))
- (expr-forward-sexp)
- (setq end (point))
- (goto-char begin)
- (cons begin end)))
-
-(defun expr-next ()
- "Returns the following expr, point is set to beginning of that expr.
-The expr is represented as a cons cell, where the car specifies the point in
-the current buffer that marks the beginning of the expr and the cdr specifies
-the character after the end of the expr."
- (let ((begin) (end))
- (expr-forward-sexp)
- (expr-forward-sexp)
- (setq end (point))
- (expr-backward-sexp)
- (setq begin (point))
- (cons begin end)))
-
-(defun expr-compound-sep (span-start span-end)
- "Returns '.' for '->' & '.', returns ' ' for white space,
-returns '?' for other punctuation."
- (let ((result ? )
- (syntax))
- (while (< span-start span-end)
- (setq syntax (char-syntax (char-after span-start)))
- (cond
- ((= syntax ? ) t)
- ((= syntax ?.) (setq syntax (char-after span-start))
- (cond
- ((= syntax ?.) (setq result ?.))
- ((and (= syntax ?-) (= (char-after (+ span-start 1)) ?>))
- (setq result ?.)
- (setq span-start (+ span-start 1)))
- (t (setq span-start span-end)
- (setq result ??)))))
- (setq span-start (+ span-start 1)))
- result))
-
-(defun expr-compound (first second)
- "Non-nil if concatenating FIRST and SECOND makes a single C token.
-The two exprs are represented as a cons cells, where the car
-specifies the point in the current buffer that marks the beginning of the
-expr and the cdr specifies the character after the end of the expr.
-Link exprs of the form:
- Expr -> Expr
- Expr . Expr
- Expr (Expr)
- Expr [Expr]
- (Expr) Expr
- [Expr] Expr"
- (let ((span-start (cdr first))
- (span-end (car second))
- (syntax))
- (setq syntax (expr-compound-sep span-start span-end))
- (cond
- ((= (car first) (car second)) nil)
- ((= (cdr first) (cdr second)) nil)
- ((= syntax ?.) t)
- ((= syntax ? )
- (setq span-start (char-after (- span-start 1)))
- (setq span-end (char-after span-end))
- (cond
- ((= span-start ?) ) t )
- ((= span-start ?] ) t )
- ((= span-end ?( ) t )
- ((= span-end ?[ ) t )
- (t nil))
- )
- (t nil))))
-
-(provide 'gud)
-
-;;; gud.el ends here
projects / platform / upstream / binutils.git / commitdiff