Function: edebug--recursive-edit

edebug--recursive-edit is a byte-compiled function defined in edebug.el.gz.

Signature

(edebug--recursive-edit ARG-MODE)

Source Code

;; Defined in /usr/src/emacs/lisp/emacs-lisp/edebug.el.gz
(defvar edebug-mode-map)		; will be defined fully later.

(defun edebug--recursive-edit (arg-mode)
  ;; Start up a recursive edit inside of edebug.
  ;; The current buffer is the edebug-buffer, which is put into edebug-mode.
  ;; Assume that none of the variables below are buffer-local.
  (let (;; match-data must be done in the outside buffer
	(edebug-outside-match-data
	 (with-current-buffer edebug-outside-buffer ; in case match buffer different
	   (match-data)))

	;;(edebug-number-of-recursions (1+ edebug-number-of-recursions))
	(edebug-recursion-depth (recursion-depth))
	edebug-entered			; bind locally to nil
	edebug-backtrace-buffer		; each recursive edit gets its own
	;; The window configuration may be saved and restored
	;; during a recursive-edit
	edebug-inside-windows
	)


    (let (
	  ;; Declare global values local but using the same global value.
	  ;; We could set these to the values for previous edebug call.
	  (last-command last-command)
	  (this-command this-command)
	  (current-prefix-arg nil)

	  (last-input-event nil)
	  (last-command-event nil)
	  (last-event-frame nil)
	  (last-nonmenu-event nil)
	  (track-mouse nil)

          (standard-output t)
          (standard-input t)

	  ;; Don't keep reading from an executing kbd macro
          ;; within edebug unless edebug-continue-kbd-macro is
          ;; non-nil.  Again, local binding may not be best.
          (executing-kbd-macro
           (if edebug-continue-kbd-macro executing-kbd-macro))

          ;; Don't get confused by the user's keymap changes.
          (overriding-local-map nil)
          (overriding-terminal-local-map nil)
          ;; Override other minor modes that may bind the keys
          ;; edebug uses.
          (minor-mode-overriding-map-alist
           (list (cons 'edebug-mode edebug-mode-map)))

          ;; Bind again to outside values.
	  (debug-on-error edebug-outside-debug-on-error)
	  (debug-on-quit edebug-outside-debug-on-quit)

	  ;; Don't keep defining a kbd macro.
	  (defining-kbd-macro
	    (if edebug-continue-kbd-macro defining-kbd-macro))

	  ;; others??
	  )

      (if (and (eq edebug-execution-mode 'go)
	       (not (memq arg-mode '(after error))))
	  (message "Break"))

      (setq signal-hook-function nil)

      (edebug-mode 1)
      (unwind-protect
	  (recursive-edit)		;  <<<<<<<<<< Recursive edit

	;; Do the following, even if quit occurs.
	(setq signal-hook-function #'edebug-signal)
	(if edebug-backtrace-buffer
	    (kill-buffer edebug-backtrace-buffer))

	;; Remember selected-window after recursive-edit.
	;;      (setq edebug-inside-window (selected-window))

	(set-match-data edebug-outside-match-data)

	;; Recursive edit may have changed buffers,
	;; so set it back before exiting let.
	(if (buffer-name edebug-buffer) ; if it still exists
	    (progn
	      (set-buffer edebug-buffer)
	      (when (memq edebug-execution-mode '(go Go-nonstop))
		(edebug-overlay-arrow)
		(sit-for 0))
              (edebug-mode -1))
	  ;; gotta have a buffer to let its buffer local variables be set
	  (get-buffer-create " bogus edebug buffer"))
	));; inner let
      ))