Skip to content

package clasp debug

Karsten Poeck edited this page Jun 18, 2022 · 1 revision

CLASP-DEBUG

Definition Index

    • No documentation provided.
      • EXTERNAL SPECIAL-VARIABLE
            A list of function designators. Any CLASP-DEBUG:FRAME for which any of the functions returns true will be considered invisible by the mid level CLASP-DEBUG interface (e.g. UP, DOWN)
          • EXTERNAL CONDITION
                No documentation provided.
              • EXTERNAL FUNCTION
                  • FUNCTION
                  • &KEY
                  • DELIMITED
                  Source
                  Functional form of WITH-STACK.
                • EXTERNAL FUNCTION
                    • FRAME
                    Source
                    Return true iff this frame represents a use of WITH-CAPPED-STACK.
                  • EXTERNAL FUNCTION
                      • SPI
                      Source
                      No documentation provided.
                    • EXTERNAL FUNCTION
                        • SPI
                        Source
                        No documentation provided.
                      • EXTERNAL FUNCTION
                          • SPI
                          Source
                          No documentation provided.
                        • EXTERNAL FUNCTION
                            • FRAME
                            Source
                            Disassemble this frame's function to *standard-output*.
                          • EXTERNAL FUNCTION
                              • FRAME
                              • &OPTIONAL
                              • N
                              Source
                              Return the nth visible frame below the given frame, or if there are not that many visible frames above, return the bottommost frame.
                            • EXTERNAL FUNCTION
                                • FRAME
                                Source
                                Return the list of arguments to the call for this frame, and T.
                                

                                If the arguments are not available, returns NIL NIL.

                              • EXTERNAL FUNCTION
                                  • FRAME
                                  Source
                                  Return the frame directly below the current frame, or NIL if there are no more frames.
                                  This notion of direction is arbitrary, and unrelated to any machine stack growth directions. The frame for the callee is 'below' the frame for what called it.
                                  This function ignores visibility and may not halt at delimiters. DOWN is the lower level interface.
                                • EXTERNAL FUNCTION
                                    • FRAME
                                    Source
                                    Return the function being called in this frame, or NIL if it is not available.
                                    Note that this function may be less reliable than the FRAME-FUNCTION-etc functions.
                                  • EXTERNAL FUNCTION
                                      • FRAME
                                      Source
                                      Return the docstring for this frame's function if it exists and is available, or else NIL.
                                    • EXTERNAL FUNCTION
                                        • FRAME
                                        Source
                                        Return a lambda expression for this frame's function if it's available, or else NIL.
                                      • EXTERNAL FUNCTION
                                          • FRAME
                                          Source
                                          Return the lambda list of the function being called in this frame, and a second value indicating success. This function may fail, in which case the first value is undefined and the second is NIL. In success the first value is the lambda list and the second value is true.
                                        • EXTERNAL FUNCTION
                                            • FRAME
                                            Source
                                            Return the name of the function being called in this frame. This will be one of:
                                            
                                            • A symbol.
                                            • A list (SETF symbol).
                                            • A list that is one of Clasp's function names, such as (FLET ...), (LABELS ...), or (METHOD ...).
                                            • A string, representing a C or C++ function.
                                          • EXTERNAL FUNCTION
                                              • FRAME
                                              Source
                                              Return a CODE-SOURCE-LINE object representing the source file position for this frame's function.
                                            • EXTERNAL FUNCTION
                                                • FRAME
                                                Source
                                                Return a marker of the programming language of the code for this frame. May be :LISP or :C++.
                                              • EXTERNAL FUNCTION
                                                  • FRAME
                                                  • &KEY
                                                  • EVAL
                                                        Source
                                                        Return an alist of local lexical/special variables and their values at the continuation the frame
                                                        represents. The CARs are variable names and CDRs their values. Multiple bindings with the same
                                                        name may be returned, as there is no notion of lexical scope in this interface. By default
                                                        init-forms in the frame's lambda list that require evaluation and are not constant will not be
                                                        returned. Passing a function (lambda (form locals) ...) via the eval key will result in init-forms
                                                        being evaluated with this function along with the current locals passed as the second argument.
                                                      • EXTERNAL FUNCTION
                                                          • FRAME
                                                          Source
                                                          Return a CODE-SOURCE-LINE object representing the source file position for this frame's call, or NIL if no information is available.
                                                        • EXTERNAL FUNCTION
                                                            • FRAME
                                                            Source
                                                            Return the frame directly above the current frame, or NIL if there are no more frames.
                                                            This notion of direction is arbitrary, and unrelated to any machine stack growth directions. The frame for the caller is 'above' the frame for what it calls.
                                                            This function ignores visibility and may not halt at delimiters. UP is the higher level interface.
                                                          • EXTERNAL FUNCTION
                                                              • FUNCTION-NAME
                                                              Source
                                                              Return the package a function name conceptually belongs to, or NIL if there is none.
                                                              For example, for a function-name that is a symbol, returns that symbol's package, and for a function-name that is a list (SETF symbol), returns that symbol's package.
                                                            • EXTERNAL FUNCTION
                                                                • BASE
                                                                • I
                                                                Source
                                                                Return the frame I up from the base frame, where I is an index as in MAP-INDEXED-STACK.
                                                                Note that as such, the frame returned may not be visible.
                                                              • EXTERNAL FUNCTION
                                                                  • FUNCTION-NAME
                                                                  Source
                                                                  Mark frames whose functions have the given name as invisible.
                                                                • EXTERNAL FUNCTION
                                                                    • PACKAGE-DESIGNATOR
                                                                    Source
                                                                    Mark frames whose functions are in the given package as invisible. See FUNCTION-NAME-PACKAGE.
                                                                  • EXTERNAL FUNCTION
                                                                      • FRAME
                                                                      • &KEY
                                                                      • COUNT
                                                                      Source
                                                                      Return a list of visible frames starting at FRAME and moving upward.
                                                                      If COUNT is provided, at most that many frames are returned.
                                                                    • EXTERNAL FUNCTION
                                                                        • FUNCTION
                                                                        • &KEY
                                                                        • COUNT
                                                                        • DELIMITED
                                                                        Source
                                                                        Like MAP-STACK, but implicitly uses WITH-STACK to obtain and use the current stack.
                                                                      • EXTERNAL FUNCTION
                                                                          • FUNCTION
                                                                          • &KEY
                                                                          • COUNT
                                                                          • DELIMITED
                                                                          Source
                                                                          Like MAP-INDEXED-STACK, but implicitly uses WITH-STACK to obtain and use the current stack.
                                                                        • EXTERNAL FUNCTION
                                                                            • FUNCTION
                                                                            • BASE
                                                                            • &KEY
                                                                            • COUNT
                                                                            Source
                                                                            Like MAP-STACK, except the function is called with two arguments: the frame, and an index number.
                                                                            These index numbers start with base = 0 and increase by 1 for each frame, visible or not. This means that frames from the same WITH-STACK will have consistent indices even if visibility rules are changed between MAP-INDEXED-STACK calls.
                                                                            Note that as with MAP-STACK, only visible frames are used with respect to the COUNT.
                                                                          • EXTERNAL FUNCTION
                                                                              • FUNCTION
                                                                              • FRAME
                                                                              • &KEY
                                                                              • COUNT
                                                                              Source
                                                                              Call FUNCTION exactly once on each visible frame in the stack, starting at FRAME and then proceeding upward.
                                                                              If COUNT is provided, at most that many visible frames are called on.
                                                                            • EXTERNAL FUNCTION
                                                                                • FRAME
                                                                                • &OPTIONAL
                                                                                • OUTPUT-STREAM-DESIGNATOR
                                                                                Source
                                                                                PRIN1 a representation of the given frame's call to the stream (default STANDARD-OUTPUT).
                                                                                Extra care is taken to ensure no errors are signaled, using SAFE-PRIN1.
                                                                              • EXTERNAL FUNCTION
                                                                                  • CODE-SOURCE-LINE
                                                                                  • &OPTIONAL
                                                                                  • OUTPUT-STREAM-DESIGNATOR
                                                                                  Source
                                                                                  Write a human-readable representation of the CODE-SOURCE-LINE to the stream.
                                                                                • EXTERNAL FUNCTION
                                                                                    • &KEY
                                                                                    • STREAM
                                                                                    • COUNT
                                                                                    • SOURCE-POSITIONS
                                                                                    • DELIMITED
                                                                                    Source
                                                                                    Write a current backtrace to STREAM.
                                                                                    If COUNT is provided and not NIL, at most COUNT frames are printed.
                                                                                    If SOURCE-POSITIONS is true, a description of the source position of each frame's call will be printed.
                                                                                    Other keyword arguments are passed to WITH-STACK.
                                                                                  • EXTERNAL FUNCTION
                                                                                      • BASE
                                                                                      • &KEY
                                                                                      • STREAM
                                                                                      • COUNT
                                                                                      • SOURCE-POSITIONS
                                                                                      Source
                                                                                      Write a representation of the stack beginning at BASE to STREAM.
                                                                                      If COUNT is provided and not NIL, at most COUNT frames are printed.
                                                                                      If SOURCE-POSITIONS is true, a description of the source position of each frame's call will be printed.
                                                                                    • EXTERNAL FUNCTION
                                                                                        • OBJECT
                                                                                        • &OPTIONAL
                                                                                        • OUTPUT-STREAM-DESIGNATOR
                                                                                        Source
                                                                                        PRIN1 the OBJECT to the given stream (default STANDARD-OUTPUT).
                                                                                        Extra care is taken to ensure no errors are signaled. If the object cannot be printed, an unreadable representation is returned instead.
                                                                                      • EXTERNAL FUNCTION
                                                                                          • FRAME
                                                                                          Source
                                                                                          Return true iff this frame represents a use of WITH-TRUNCATED-STACK.
                                                                                        • EXTERNAL FUNCTION
                                                                                            • FUNCTION-NAME
                                                                                            Source
                                                                                            Undo a HIDE on the given function name.
                                                                                          • EXTERNAL FUNCTION
                                                                                                Source
                                                                                                Unhide all hidden packages and function names.
                                                                                              • EXTERNAL FUNCTION
                                                                                                  • PACKAGE-DESIGNATOR
                                                                                                  Source
                                                                                                  Undo HIDE-PACKAGE for the given package.
                                                                                                • EXTERNAL FUNCTION

                                                                                                  UP

                                                                                                    • FRAME
                                                                                                    • &OPTIONAL
                                                                                                    • N
                                                                                                    Source
                                                                                                    Return the nth visible frame above the given frame, or if there are not that many visible frames above, return the topmost frame.
                                                                                                  • EXTERNAL FUNCTION
                                                                                                      • FRAME
                                                                                                      Source
                                                                                                      If FRAME is visible, return it. Otherwise return the nearest visible frame above.
                                                                                                    • EXTERNAL MACRO
                                                                                                          Execute the body such that WITH-STACK and derived tools will not see frames above this form's continuation, unless they are passed :delimited nil.
                                                                                                          Only the outermost WITH-CAPPED-STACK matters for this purpose.
                                                                                                        • EXTERNAL MACRO
                                                                                                              Execute the body in an environment in which FRAME is bound to a CLASP-DEBUG:FRAME object representing the current continuation. This frame object has dynamic extent.
                                                                                                              You can use UP and DOWN to navigate frames. Frames above and below WITH-CAPPED-STACK and WITH-TRUNCATED-STACK are inaccessible with these operators, unless DELIMITED is false (default true).
                                                                                                              Frames hidden by FRAME-FILTERS will be skipped.
                                                                                                              The delimiters and visibility may be ignored by using the lower level FRAME-UP, FRAME-DOWN.
                                                                                                            • EXTERNAL MACRO
                                                                                                                  Execute the body such that WITH-STACK and derived tools will not see frames below this form's continuation, unless they are passed :delimited nil.
                                                                                                                  Only the innermost WITH-TRUNCATED-STACK matters for this purpose.
                                                                                                              Clone this wiki locally