X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcode%2Fdebug.lisp;h=76179a01856883401b732fbad02e8999a99ecced;hb=18d4de696bc5063aad026ba62be613c7b07f5fc8;hp=dde5f757fd9113962a199cd8675aa5680a267568;hpb=2d195da5e29feadce7190ea1a68a2efa83a5e1c0;p=sbcl.git diff --git a/src/code/debug.lisp b/src/code/debug.lisp index dde5f75..76179a0 100644 --- a/src/code/debug.lisp +++ b/src/code/debug.lisp @@ -37,15 +37,22 @@ ;;; nestedness inside debugger command loops (defvar *debug-command-level* 0) -(defvar *stack-top-hint* nil - #!+sb-doc - "If this is bound before the debugger is invoked, it is used as the stack - top by the debugger.") +;;; If this is bound before the debugger is invoked, it is used as the +;;; stack top by the debugger. +(defvar *stack-top-hint* nil) + (defvar *stack-top* nil) (defvar *real-stack-top* nil) (defvar *current-frame* nil) +;;; Beginner-oriented help messages are important because you end up +;;; in the debugger whenever something bad happens, or if you try to +;;; get out of the system with Ctrl-C or (EXIT) or EXIT or whatever. +;;; But after memorizing them the wasted screen space gets annoying.. +(defvar *debug-beginner-help-p* t + "Should the debugger display beginner-oriented help messages?") + (defun debug-prompt (stream) ;; old behavior, will probably go away in sbcl-0.7.x @@ -126,8 +133,8 @@ Function and macro commands: #!+sb-doc "When true, list the code location type in the LIST-LOCATIONS command.") -;;; a list of the types of code-locations that should not be stepped to and -;;; should not be listed when listing breakpoints +;;; a list of the types of code-locations that should not be stepped +;;; to and should not be listed when listing breakpoints (defvar *bad-code-location-types* '(:call-site :internal-error)) (declaim (type list *bad-code-location-types*)) @@ -135,12 +142,12 @@ Function and macro commands: (defvar *possible-breakpoints*) (declaim (type list *possible-breakpoints*)) -;;; a list of the made and active breakpoints, each is a breakpoint-info -;;; structure +;;; a list of the made and active breakpoints, each is a +;;; BREAKPOINT-INFO structure (defvar *breakpoints* nil) (declaim (type list *breakpoints*)) -;;; a list of breakpoint-info structures of the made and active step +;;; a list of BREAKPOINT-INFO structures of the made and active step ;;; breakpoints (defvar *step-breakpoints* nil) (declaim (type list *step-breakpoints*)) @@ -165,8 +172,8 @@ Function and macro commands: (setf found t))) first-code-location)) -;;; Return a list of the next code-locations following the one passed. One of -;;; the *BAD-CODE-LOCATION-TYPES* will not be returned. +;;; Return a list of the next code-locations following the one passed. +;;; One of the *BAD-CODE-LOCATION-TYPES* will not be returned. (defun next-code-locations (code-location) (let ((debug-block (sb!di:code-location-debug-block code-location)) (block-code-locations nil)) @@ -201,11 +208,11 @@ Function and macro commands: (push code-location possible-breakpoints)))))) (nreverse possible-breakpoints))) -;;; Searches the info-list for the item passed (code-location, debug-function, -;;; or breakpoint-info). If the item passed is a debug function then kind will -;;; be compared if it was specified. The kind if also compared if a -;;; breakpoint-info is passed since it's in the breakpoint. The info structure -;;; is returned if found. +;;; Searches the info-list for the item passed (code-location, +;;; debug-function, or breakpoint-info). If the item passed is a debug +;;; function then kind will be compared if it was specified. The kind +;;; if also compared if a breakpoint-info is passed since it's in the +;;; breakpoint. The info structure is returned if found. (defun location-in-list (place info-list &optional (kind nil)) (when (breakpoint-info-p place) (setf kind (sb!di:breakpoint-kind (breakpoint-info-breakpoint place))) @@ -227,8 +234,9 @@ Function and macro commands: (eq kind (sb!di:breakpoint-kind y-breakpoint)))))))))) -;;; If Loc is an unknown location, then try to find the block start location. -;;; Used by source printing to some information instead of none for the user. +;;; If LOC is an unknown location, then try to find the block start +;;; location. Used by source printing to some information instead of +;;; none for the user. (defun maybe-block-start-location (loc) (if (sb!di:code-location-unknown-p loc) (let* ((block (sb!di:code-location-debug-block loc)) @@ -246,24 +254,24 @@ Function and macro commands: ;;;; the BREAKPOINT-INFO structure ;;; info about a made breakpoint -(defstruct breakpoint-info +(defstruct (breakpoint-info (:copier nil)) ;; where we are going to stop (place (required-argument) :type (or sb!di:code-location sb!di:debug-function)) ;; the breakpoint returned by sb!di:make-breakpoint (breakpoint (required-argument) :type sb!di:breakpoint) - ;; the function returned from sb!di:preprocess-for-eval. If result is + ;; the function returned from SB!DI:PREPROCESS-FOR-EVAL. If result is ;; non-NIL, drop into the debugger. (break #'identity :type function) ;; the function returned from sb!di:preprocess-for-eval. If result is ;; non-NIL, eval (each) print and print results. (condition #'identity :type function) - ;; the list of functions from sb!di:preprocess-for-eval to evaluate. Results - ;; are conditionally printed. Car of each element is the function, cdr is the - ;; form it goes with. + ;; the list of functions from sb!di:preprocess-for-eval to evaluate. + ;; Results are conditionally printed. Car of each element is the + ;; function, cdr is the form it goes with. (print nil :type list) - ;; the number used when listing the possible breakpoints within a function. - ;; Could also be a symbol such as start or end. + ;; the number used when listing the possible breakpoints within a + ;; function. Could also be a symbol such as start or end. (code-location-number (required-argument) :type (or symbol integer)) ;; the number used when listing the breakpoints active and to delete ;; breakpoints @@ -310,8 +318,8 @@ Function and macro commands: ;;;; MAIN-HOOK-FUNCTION for steps and breakpoints -;;; This must be passed as the hook function. It keeps track of where step -;;; breakpoints are. +;;; This must be passed as the hook function. It keeps track of where +;;; STEP breakpoints are. (defun main-hook-function (current-frame breakpoint &optional return-vals function-end-cookie) (setf *default-breakpoint-debug-function* @@ -431,7 +439,7 @@ Function and macro commands: (*standard-output* *debug-io*)) #!+sb-doc "Show a listing of the call stack going down from the current frame. In the - debugger, the current frame is indicated by the prompt. Count is how many + debugger, the current frame is indicated by the prompt. COUNT is how many frames to show." (fresh-line *standard-output*) (do ((frame (if *in-the-debugger* *current-frame* (sb!di:top-frame)) @@ -446,8 +454,8 @@ Function and macro commands: (eval-when (:compile-toplevel :execute) -;;; This is a convenient way to express what to do for each type of lambda-list -;;; element. +;;; This is a convenient way to express what to do for each type of +;;; lambda-list element. (sb!xc:defmacro lambda-list-element-dispatch (element &key required @@ -464,7 +472,7 @@ Function and macro commands: (:rest ,@rest) (:keyword ,@keyword))) (symbol - (assert (eq ,element :deleted)) + (aver (eq ,element :deleted)) ,@deleted))) (sb!xc:defmacro lambda-var-dispatch (variable location deleted valid other) @@ -485,7 +493,8 @@ Function and macro commands: (:print-object (lambda (x s) (print-unreadable-object (x s :type t) (write-string (unprintable-object-string x) - s))))) + s)))) + (:copier nil)) string) ;;; Print FRAME with verbosity level 1. If we hit a &REST arg, then @@ -580,18 +589,6 @@ Function and macro commands: (defvar *debug-restarts*) (defvar *debug-condition*) -;;; Print *DEBUG-CONDITION*, taking care to avoid recursive invocation -;;; of the debugger in case of a problem (e.g. a bug in the PRINT-OBJECT -;;; method for *DEBUG-CONDITION*). -(defun princ-debug-condition-carefully (stream) - (handler-case (princ *debug-condition* stream) - (error (condition) - (format stream - " (caught ~S when trying to print ~S)" - (type-of condition) - '*debug-condition*))) - *debug-condition*) - (defun invoke-debugger (condition) #!+sb-doc "Enter the debugger." @@ -643,18 +640,22 @@ reset to ~S." ;; the last line of output or so, and get confused. (flush-standard-output-streams) - ;; The initial output here goes to *ERROR-OUTPUT*, because the + ;; (The initial output here goes to *ERROR-OUTPUT*, because the ;; initial output is not interactive, just an error message, ;; and when people redirect *ERROR-OUTPUT*, they could ;; reasonably expect to see error messages logged there, - ;; regardless of what the debugger does afterwards. - #!+sb-show (sb!kernel:show-condition *debug-condition* - *error-output*) - (format *error-output* - "~2&debugger invoked on condition of type ~S:~% " - (type-of *debug-condition*)) - (princ-debug-condition-carefully *error-output*) - (terpri *error-output*) + ;; regardless of what the debugger does afterwards.) + (handler-case + (format *error-output* + "~2&~@~%" + (type-of *debug-condition*) + *debug-condition*) + (error (condition) + (format *error-output* + "~&(caught ~S trying to print ~S when entering debugger)~%" + (type-of condition) + '*debug-condition*))) ;; After the initial error/condition/whatever announcement to ;; *ERROR-OUTPUT*, we become interactive, and should talk on @@ -679,15 +680,17 @@ reset to ~S." ;; that file, and right to send them to *DEBUG-IO*. (*error-output* *debug-io*)) (unless (typep condition 'step-condition) - (format *debug-io* - "~%~@~2%" - '*debug-condition*) - (show-restarts *debug-restarts* *debug-io*) - (terpri *debug-io*)) + (when *debug-beginner-help-p* + (format *debug-io* + "~%~@~2%" + '*debug-condition* + '*debug-beginner-help-p*)) + (show-restarts *debug-restarts* *debug-io*)) (internal-debug)))))) (defun show-restarts (restarts s) @@ -798,20 +801,34 @@ reset to ~S." (t (funcall cmd-fun))))))))))))))) -(defvar *auto-eval-in-frame* t +;;; FIXME: As far as I know, the CMU CL X86 codebase has never +;;; supported access to the environment of the debugged function. It +;;; would be really, really nice to make that work! (Until then, +;;; non-NIL *AUTO-EVAL-IN-FRAME* seems to be useless, and as of +;;; sbcl-0.6.10 it even seemed to be actively harmful, since the +;;; debugger gets confused when trying to unwind the frames which +;;; arise in SIGINT interrupts. So it's set to NIL.) +(defvar *auto-eval-in-frame* nil #!+sb-doc - "When set (the default), evaluations in the debugger's command loop occur - relative to the current frame's environment without the need of debugger - forms that explicitly control this kind of evaluation.") + "When set, evaluations in the debugger's command loop occur relative + to the current frame's environment without the need of debugger + forms that explicitly control this kind of evaluation. In an ideal + world, the default would be T, but since unfortunately the X86 + debugger support isn't good enough to make this useful, the + default is NIL instead.") ;;; FIXME: We could probably use INTERACTIVE-EVAL for much of this logic. -(defun debug-eval-print (exp) - (setq +++ ++ ++ + + - - exp) +(defun debug-eval-print (expr) + (/noshow "entering DEBUG-EVAL-PRINT" expr) + (/noshow (fboundp 'compile)) + (/noshow (and (fboundp 'compile) *auto-eval-in-frame*)) + (setq +++ ++ ++ + + - - expr) (let* ((values (multiple-value-list (if (and (fboundp 'compile) *auto-eval-in-frame*) (sb!di:eval-in-frame *current-frame* -) (eval -)))) (*standard-output* *debug-io*)) + (/noshow "done with EVAL in DEBUG-EVAL-PRINT") (fresh-line) (if values (prin1 (car values))) (dolist (x (cdr values)) @@ -828,8 +845,8 @@ reset to ~S." ;;;; debug loop functions -;;; These commands are functions, not really commands, so that users can get -;;; their hands on the values returned. +;;; These commands are functions, not really commands, so that users +;;; can get their hands on the values returned. (eval-when (:execute :compile-toplevel) @@ -858,8 +875,8 @@ reset to ~S." `(setf (sb!di:debug-var-value (car vars) *current-frame*) ,value-var)))) (t - ;; Since we have more than one, first see whether we have any - ;; variables that exactly match the specification. + ;; Since we have more than one, first see whether we have + ;; any variables that exactly match the specification. (let* ((name (etypecase name (symbol (symbol-name name)) (simple-string name))) @@ -917,9 +934,11 @@ reset to ~S." ) ; EVAL-WHEN +;;; FIXME: This doesn't work. It would be real nice we could make it +;;; work! Alas, it doesn't seem to work in CMU CL X86 either.. (defun var (name &optional (id 0 id-supplied)) #!+sb-doc - "Returns a variable's value if possible. Name is a simple-string or symbol. + "Return a variable's value if possible. NAME is a simple-string or symbol. If it is a simple-string, it is an initial substring of the variable's name. If name is a symbol, it has the same name and package as the variable whose value this function returns. If the symbol is uninterned, then the variable @@ -959,7 +978,8 @@ reset to ~S." :rest ((let ((var (second ele))) (lambda-var-dispatch var (sb!di:frame-code-location *current-frame*) - (error "unused &REST argument before n'th argument") + (error "unused &REST argument before n'th +argument") (dolist (value (sb!di:debug-var-value var *current-frame*) (error @@ -994,10 +1014,8 @@ reset to ~S." ;;; Interface to *DEBUG-COMMANDS*. No required arguments in args are ;;; permitted. -;;; -;;; FIXME: This is not needed in the target Lisp system. -(defmacro def-debug-command (name args &rest body) - (let ((fun-name (intern (concatenate 'simple-string name "-DEBUG-COMMAND")))) +(defmacro !def-debug-command (name args &rest body) + (let ((fun-name (symbolicate name "-DEBUG-COMMAND"))) `(progn (setf *debug-commands* (remove ,name *debug-commands* :key #'car :test #'string=)) @@ -1008,18 +1026,19 @@ reset to ~S." (push (cons ,name #',fun-name) *debug-commands*) ',fun-name))) -(defun def-debug-command-alias (new-name existing-name) +(defun !def-debug-command-alias (new-name existing-name) (let ((pair (assoc existing-name *debug-commands* :test #'string=))) (unless pair (error "unknown debug command name: ~S" existing-name)) (push (cons new-name (cdr pair)) *debug-commands*)) new-name) -;;; This takes a symbol and uses its name to find a debugger command, using -;;; initial substring matching. It returns the command function if form -;;; identifies only one command, but if form is ambiguous, this returns a list -;;; of the command names. If there are no matches, this returns nil. Whenever -;;; the loop that looks for a set of possibilities encounters an exact name -;;; match, we return that command function immediately. +;;; This takes a symbol and uses its name to find a debugger command, +;;; using initial substring matching. It returns the command function +;;; if form identifies only one command, but if form is ambiguous, +;;; this returns a list of the command names. If there are no matches, +;;; this returns nil. Whenever the loop that looks for a set of +;;; possibilities encounters an exact name match, we return that +;;; command function immediately. (defun debug-command-p (form &optional other-commands) (if (or (symbolp form) (integerp form)) (let* ((name @@ -1056,29 +1075,29 @@ reset to ~S." ((not cmds) res) (setf (car cmds) (caar cmds)))))))) -;;; Returns a list of debug commands (in the same format as *debug-commands*) -;;; that invoke each active restart. +;;; Return a list of debug commands (in the same format as +;;; *debug-commands*) that invoke each active restart. ;;; -;;; Two commands are made for each restart: one for the number, and one for -;;; the restart name (unless it's been shadowed by an earlier restart of the -;;; same name). +;;; Two commands are made for each restart: one for the number, and +;;; one for the restart name (unless it's been shadowed by an earlier +;;; restart of the same name, or it is NIL). (defun make-restart-commands (&optional (restarts *debug-restarts*)) (let ((commands) (num 0)) ; better be the same as show-restarts! (dolist (restart restarts) (let ((name (string (restart-name restart)))) - (unless (find name commands :key #'car :test #'string=) - (let ((restart-fun - #'(lambda () - (invoke-restart-interactively restart)))) - (push (cons name restart-fun) commands) - (push (cons (format nil "~D" num) restart-fun) commands)))) - (incf num)) - commands)) + (let ((restart-fun + #'(lambda () (invoke-restart-interactively restart)))) + (push (cons (format nil "~d" num) restart-fun) commands) + (unless (or (null (restart-name restart)) + (find name commands :key #'car :test #'string=)) + (push (cons name restart-fun) commands)))) + (incf num)) + commands)) ;;;; frame-changing commands -(def-debug-command "UP" () +(!def-debug-command "UP" () (let ((next (sb!di:frame-up *current-frame*))) (cond (next (setf *current-frame* next) @@ -1086,7 +1105,7 @@ reset to ~S." (t (format t "~&Top of stack."))))) -(def-debug-command "DOWN" () +(!def-debug-command "DOWN" () (let ((next (sb!di:frame-down *current-frame*))) (cond (next (setf *current-frame* next) @@ -1094,29 +1113,29 @@ reset to ~S." (t (format t "~&Bottom of stack."))))) -(def-debug-command-alias "D" "DOWN") +(!def-debug-command-alias "D" "DOWN") -;;; CMU CL had this command, but SBCL doesn't, since -;;; it's redundant with "FRAME 0", and it interferes with abbreviations -;;; for the TOPLEVEL restart. -;;;(def-debug-command "TOP" () +;;; CMU CL had this command, but SBCL doesn't, since it's redundant +;;; with "FRAME 0", and it interferes with abbreviations for the +;;; TOPLEVEL restart. +;;;(!def-debug-command "TOP" () ;;; (do ((prev *current-frame* lead) ;;; (lead (sb!di:frame-up *current-frame*) (sb!di:frame-up lead))) ;;; ((null lead) ;;; (setf *current-frame* prev) ;;; (print-frame-call prev)))) -(def-debug-command "BOTTOM" () +(!def-debug-command "BOTTOM" () (do ((prev *current-frame* lead) (lead (sb!di:frame-down *current-frame*) (sb!di:frame-down lead))) ((null lead) (setf *current-frame* prev) (print-frame-call prev)))) -(def-debug-command-alias "B" "BOTTOM") +(!def-debug-command-alias "B" "BOTTOM") -(def-debug-command "FRAME" (&optional - (n (read-prompting-maybe "frame number: "))) +(!def-debug-command "FRAME" (&optional + (n (read-prompting-maybe "frame number: "))) (setf *current-frame* (multiple-value-bind (next-frame-fun limit-string) (if (< n (sb!di:frame-number *current-frame*)) @@ -1135,7 +1154,7 @@ reset to ~S." (return frame))))))) (print-frame-call *current-frame*)) -(def-debug-command-alias "F" "FRAME") +(!def-debug-command-alias "F" "FRAME") ;;;; commands for entering and leaving the debugger @@ -1145,16 +1164,18 @@ reset to ~S." ;;; things in the system, "restart the top level REPL" in the debugger ;;; and "terminate the Lisp system" as the SB-EXT:QUIT function.) ;;; -;;;(def-debug-command "QUIT" () +;;;(!def-debug-command "QUIT" () ;;; (throw 'sb!impl::top-level-catcher nil)) -;;; CMU CL supported this GO debug command, but SBCL doesn't -- just -;;; type the CONTINUE restart name. -;;;(def-debug-command "GO" () +;;; CMU CL supported this GO debug command, but SBCL doesn't -- in +;;; SBCL you just type the CONTINUE restart name instead (or "RESTART +;;; CONTINUE", that's OK too). + +;;;(!def-debug-command "GO" () ;;; (continue *debug-condition*) ;;; (error "There is no restart named CONTINUE.")) -(def-debug-command "RESTART" () +(!def-debug-command "RESTART" () (let ((num (read-if-available :prompt))) (when (eq num :prompt) (show-restarts *debug-restarts* *debug-io*) @@ -1182,32 +1203,32 @@ reset to ~S." ;;;; information commands -(def-debug-command "HELP" () +(!def-debug-command "HELP" () ;; CMU CL had a little toy pager here, but "if you aren't running ;; ILISP (or a smart windowing system, or something) you deserve to ;; lose", so we've dropped it in SBCL. However, in case some ;; desperate holdout is running this on a dumb terminal somewhere, ;; we tell him where to find the message stored as a string. (format *debug-io* - "~&~a~2%(The HELP string is stored in ~S.)~%" + "~&~A~2%(The HELP string is stored in ~S.)~%" *debug-help-string* '*debug-help-string*)) -(def-debug-command-alias "?" "HELP") +(!def-debug-command-alias "?" "HELP") -(def-debug-command "ERROR" () +(!def-debug-command "ERROR" () (format *debug-io* "~A~%" *debug-condition*) (show-restarts *debug-restarts* *debug-io*)) -(def-debug-command "BACKTRACE" () +(!def-debug-command "BACKTRACE" () (backtrace (read-if-available most-positive-fixnum))) -(def-debug-command "PRINT" () +(!def-debug-command "PRINT" () (print-frame-call *current-frame*)) -(def-debug-command-alias "P" "PRINT") +(!def-debug-command-alias "P" "PRINT") -(def-debug-command "LIST-LOCALS" () +(!def-debug-command "LIST-LOCALS" () (let ((d-fun (sb!di:frame-debug-function *current-frame*))) (if (sb!di:debug-var-info-available d-fun) (let ((*standard-output* *debug-io*) @@ -1238,9 +1259,9 @@ reset to ~S." prefix)))) (write-line "There is no variable information available.")))) -(def-debug-command-alias "L" "LIST-LOCALS") +(!def-debug-command-alias "L" "LIST-LOCALS") -(def-debug-command "SOURCE" () +(!def-debug-command "SOURCE" () (fresh-line) (print-code-location-source-form (sb!di:frame-code-location *current-frame*) (read-if-available 0))) @@ -1267,10 +1288,10 @@ reset to ~S." (defvar *cached-readtable* nil) (declaim (type (or readtable null) *cached-readtable*)) -(pushnew #'(lambda () - (setq *cached-debug-source* nil *cached-source-stream* nil - *cached-readtable* nil)) - sb!int:*before-save-initializations*) +(pushnew (lambda () + (setq *cached-debug-source* nil *cached-source-stream* nil + *cached-readtable* nil)) + *before-save-initializations*) ;;; We also cache the last top-level form that we printed a source for ;;; so that we don't have to do repeated reads and calls to @@ -1364,7 +1385,7 @@ reset to ~S." ;;; breakpoint and step commands ;;; Step to the next code-location. -(def-debug-command "STEP" () +(!def-debug-command "STEP" () (setf *number-of-steps* (read-if-available 1)) (set-step-breakpoint *current-frame*) (continue *debug-condition*) @@ -1374,7 +1395,7 @@ reset to ~S." ;;; where the CONTINUE restart will transfer control. Set ;;; *POSSIBLE-BREAKPOINTS* to the code-locations which can then be ;;; used by sbreakpoint. -(def-debug-command "LIST-LOCATIONS" () +(!def-debug-command "LIST-LOCATIONS" () (let ((df (read-if-available *default-breakpoint-debug-function*))) (cond ((consp df) (setf df (sb!di:function-debug-function (eval df))) @@ -1435,10 +1456,10 @@ reset to ~S." :function-end) (format t "~&::FUNCTION-END *Active* ")))) -(def-debug-command-alias "LL" "LIST-LOCATIONS") +(!def-debug-command-alias "LL" "LIST-LOCATIONS") ;;; Set breakpoint at the given number. -(def-debug-command "BREAKPOINT" () +(!def-debug-command "BREAKPOINT" () (let ((index (read-prompting-maybe "location number, :START, or :END: ")) (break t) (condition t) @@ -1536,20 +1557,20 @@ reset to ~S." (print-breakpoint-info (first *breakpoints*)) (format t "~&added")))) -(def-debug-command-alias "BP" "BREAKPOINT") +(!def-debug-command-alias "BP" "BREAKPOINT") ;;; List all breakpoints which are set. -(def-debug-command "LIST-BREAKPOINTS" () +(!def-debug-command "LIST-BREAKPOINTS" () (setf *breakpoints* (sort *breakpoints* #'< :key #'breakpoint-info-breakpoint-number)) (dolist (info *breakpoints*) (print-breakpoint-info info))) -(def-debug-command-alias "LB" "LIST-BREAKPOINTS") -(def-debug-command-alias "LBP" "LIST-BREAKPOINTS") +(!def-debug-command-alias "LB" "LIST-BREAKPOINTS") +(!def-debug-command-alias "LBP" "LIST-BREAKPOINTS") ;;; Remove breakpoint N, or remove all breakpoints if no N given. -(def-debug-command "DELETE-BREAKPOINT" () +(!def-debug-command "DELETE-BREAKPOINT" () (let* ((index (read-if-available nil)) (bp-info (find index *breakpoints* :key #'breakpoint-info-breakpoint-number))) @@ -1564,11 +1585,11 @@ reset to ~S." (setf *breakpoints* nil) (format t "all breakpoints deleted~%"))))) -(def-debug-command-alias "DBP" "DELETE-BREAKPOINT") +(!def-debug-command-alias "DBP" "DELETE-BREAKPOINT") ;;; miscellaneous commands -(def-debug-command "DESCRIBE" () +(!def-debug-command "DESCRIBE" () (let* ((curloc (sb!di:frame-code-location *current-frame*)) (debug-fun (sb!di:code-location-debug-function curloc)) (function (sb!di:debug-function-function debug-fun)))