Variable: gud-menu-map

gud-menu-map is a variable defined in gud.el.gz.

Value

<break> <gud-tool-bar-item-visible-no-fringe>              nil
<displays> <keymap> <disassembly>                          gdb-display-disassembly-buffer
<displays> <keymap> <frames>                               gdb-display-stack-buffer
<displays> <keymap> <gdb>                                  gdb-display-gdb-buffer
<displays> <keymap> <inferior>                             gdb-display-io-buffer
<displays> <keymap> <load-layout>                          gdb-load-window-configuration
<displays> <keymap> <locals>                               gdb-display-locals-buffer
<displays> <keymap> <memory>                               gdb-display-memory-buffer
<displays> <keymap> <registers>                            gdb-display-registers-buffer
<displays> <keymap> <restore-layout-after-quit> <:toggle>  gdb-restore-window-configuration-after-quit
<displays> <keymap> <save-layout>                          gdb-save-window-configuration
<displays> <keymap> <threads>                              gdb-display-threads-buffer
<frames> <keymap> <disassembly>                            gdb-frame-disassembly-buffer
<frames> <keymap> <frames>                                 gdb-frame-stack-buffer
<frames> <keymap> <gdb>                                    gdb-frame-gdb-buffer
<frames> <keymap> <inferior>                               gdb-frame-io-buffer
<frames> <keymap> <locals>                                 gdb-frame-locals-buffer
<frames> <keymap> <memory>                                 gdb-frame-memory-buffer
<frames> <keymap> <registers>                              gdb-frame-registers-buffer
<frames> <keymap> <threads>                                gdb-frame-threads-buffer
<go> <and> <gdb-show-run-p>                                nil
<help>                                                     gud-goto-info
<mi> <keymap> <all-threads> <:radio>                       gdb-gud-control-all-threads
<mi> <keymap> <gdb-many-windows> <:toggle>                 gdb-many-windows(var)/gdb-many-windows(fun)
<refresh>                                                  gud-refresh
<remove> <gud-tool-bar-item-visible-no-fringe>             nil
<stop> <or> <and> <gdb-show-stop-p>                        nil
<tooltips> <:toggle>                                       gud-tooltip-mode(var)/gud-tooltip-mode(fun)
<tooltips> <and> <display-graphic-p>                       nil
<until> <and> <gud-tool-bar-item-visible-no-fringe>        nil

Documentation

Menu for gud-mode.

Source Code

;; Defined in /usr/src/emacs/lisp/progmodes/gud.el.gz
(easy-mmode-defmap gud-menu-map
  '(([help]     "Info (debugger)" . gud-goto-info)
    ([tooltips] menu-item "Show GUD tooltips" gud-tooltip-mode
                  :enable (and (not emacs-basic-display)
			       (display-graphic-p)
			       (fboundp 'x-show-tip))
		  :visible (memq gud-minor-mode
				'(gdbmi guiler dbx sdb xdb pdb))
                  :button (:toggle . gud-tooltip-mode))
    ([refresh]	"Refresh" . gud-refresh)
    ([run]	menu-item "Run" gud-run
                  :enable (not gud-running)
		  :visible (or (memq gud-minor-mode '(gdb dbx jdb))
			       (and (eq gud-minor-mode 'gdbmi)
				    (or (not (gdb-show-run-p))
					(bound-and-true-p
					 gdb-active-process)))))
    ([go]     .	(menu-item (if (bound-and-true-p gdb-active-process)
			       "Continue" "Run")
			   gud-go
		  :visible (and (eq gud-minor-mode 'gdbmi)
                                (gdb-show-run-p))))
    ([stop]	menu-item "Stop" gud-stop-subjob
		  :visible (or (not (memq gud-minor-mode '(gdbmi pdb)))
			       (and (eq gud-minor-mode 'gdbmi)
                                    (gdb-show-stop-p))))
    ([until]	menu-item "Continue to selection" gud-until
                  :enable (not gud-running)
		  :visible (and (memq gud-minor-mode '(gdbmi gdb perldb))
				(gud-tool-bar-item-visible-no-fringe)))
    ([remove]	menu-item "Remove Breakpoint" gud-remove
                  :enable (not gud-running)
		  :visible (gud-tool-bar-item-visible-no-fringe))
    ([tbreak]	menu-item "Temporary Breakpoint" gud-tbreak
                  :enable (not gud-running)
		  :visible (memq gud-minor-mode
				'(gdbmi gdb sdb xdb)))
    ([break]	menu-item "Set Breakpoint" gud-break
                  :enable (not gud-running)
		  :visible (gud-tool-bar-item-visible-no-fringe))
    ([up]	menu-item "Up Stack" gud-up
		  :enable (not gud-running)
		  :visible (memq gud-minor-mode
				 '(gdbmi gdb guiler dbx xdb jdb pdb)))
    ([down]	menu-item "Down Stack" gud-down
		  :enable (not gud-running)
		  :visible (memq gud-minor-mode
				 '(gdbmi gdb guiler dbx xdb jdb pdb)))
    ([pp]	menu-item "Print S-expression" gud-pp
                  :enable (and (not gud-running)
				  (bound-and-true-p gdb-active-process))
		  :visible (and (string-equal
				 (buffer-local-value
				  'gud-target-name gud-comint-buffer)
				 "emacs")
				(eq gud-minor-mode 'gdbmi)))
    ([print*] . (menu-item (if (eq gud-minor-mode 'jdb)
			       "Dump object"
			     "Print Dereference")
			   gud-pstar
                  :enable (not gud-running)
		  :visible (memq gud-minor-mode '(gdbmi gdb jdb))))
    ([print]	menu-item "Print Expression" gud-print
                  :enable (not gud-running))
    ([watch]	menu-item "Watch Expression" gud-watch
		  :enable (not gud-running)
	          :visible (eq gud-minor-mode 'gdbmi))
    ([finish]	menu-item "Finish Function" gud-finish
                  :enable (not gud-running)
		  :visible (memq gud-minor-mode
				 '(gdbmi gdb guiler xdb jdb pdb)))
    ([stepi]	menu-item "Step Instruction" gud-stepi
                  :enable (not gud-running)
		  :visible (memq gud-minor-mode '(gdbmi gdb dbx)))
    ([nexti]	menu-item "Next Instruction" gud-nexti
                  :enable (not gud-running)
		  :visible (memq gud-minor-mode '(gdbmi gdb dbx)))
    ([step]	menu-item "Step Line" gud-step
                  :enable (not gud-running))
    ([next]	menu-item "Next Line" gud-next
                  :enable (not gud-running))
    ([cont]	menu-item "Continue" gud-cont
                  :enable (not gud-running)
		  :visible (not (eq gud-minor-mode 'gdbmi))))
  "Menu for `gud-mode'."
  :name "Gud")