The portable-condition-system Reference Manual

Table of Contents

The portable-condition-system Reference Manual

This is the portable-condition-system Reference Manual, version 1.0.0, generated automatically by Declt version 3.0 "Montgomery Scott" on Tue Apr 28 12:42:50 2020 GMT+0.

1 Introduction

Portable Condition System

Description

This is an example implementation of the Common Lisp condition system, based on the original condition system implementation by Kent M. Pitman.

This code has been:

• forked from its original source location with the original file copied into this repository for posterity,
• cleaned to compile on contemporary Common Lisp implementations without warnings,
• downcased and adjusted to follow modern Lisp style standards,
• modernized to use ANSI CL functionalities, wherever applicable: for example, defclass, defmethod, print-object, print-unreadable-object, or destructuring-bind,
• updated to shadow the ANSI CL symbol list instead of the original CLtL1 symbol list and to follow the ANSI CL standard in functionality,
• documented via documentation strings for all suitable definition forms,
• made installable as a system-wide condition system that integrates with the host condition system,
• packaged as an ASDF system portable-condition-system,
• submitted to Quicklisp,
• tested via the ANSI-TEST test suites related to the condition system.

This system additionally defines a common-lisp+portable-condition-system package. It is equivalent to the common-lisp package, except all symbols related to the condition system are instead imported from the portable-condition-system, effectively overriding the condition system implementation from the host. This, along with running the portable-condition-system.integration:install function (see the integration system manual for details), ensures that the host's condition system is overridden by the custom one defined by portable-condition-system.

Background

The original comment from by Kent states:

This is a sample implementation. It is not in any way intended as the definition of any aspect of the condition system. It is simply an existence proof that the condition system can be implemented.

While this written to be "portable", this is not a portable condition system in that loading this file will not redefine your condition system. Loading this file will define a bunch of functions which work like a condition system. Redefining existing condition systems is beyond the goal of this implementation attempt.

This system has been created as a part of the efforts behind my upcoming book, Common Lisp Condition System. It is meant to be educational material for people who want to see how to implement a condition system from scratch. Additionally, it may be used for Common Lisp implementations which do not have a condition system themselves and would nonetheless like to adopt.

Extending

The debugger itself is roughly extensible by means of defining new methods on the internal run-debugger-command generic function and pushing help-printing hooks onto *help-hooks*. See debugger.lisp for details.

Tests

The test suite has been adapted from ANSI-TEST at commit c4679fdd9966. To run it, evaluate (asdf:test-system :portable-condition-system) or manually load ASDF system portable-condition-system/test and run (portable-condition-system/test:run).

Example

Example debugger session:

PORTABLE-CONDITION-SYSTEM> (tagbody :go
                              (let ((condition (make-condition 'type-error
                                                               :datum 42
                                                               :expected-type 'string)))
                                (restart-case (invoke-debugger condition)
                                  (abort () :report "Abort.")
                                  (retry () :report "Retry." (go :go))
                                  (fail () :report "Fail."))))
;; Debugger level 1 entered on TYPE-ERROR:
;; The value
;;   42
;; is not of type
;;   STRING.
;; Type :HELP for available commands.
[1] Debug> :help

;; This is the standard debugger of the Portable Condition System.
;; The debugger read-eval-print loop supports the standard REPL variables:
;;   *   **   ***   +   ++   +++   /   //   ///   -
;;
;; Available debugger commands:
;;  :HELP              Show this text.
;;  :EVAL <form>       Evaluate a form typed after the :EVAL command.
;;  :REPORT            Report the condition the debugger was invoked with.
;;  :CONDITION         Return the condition object the debugger was invoked with.
;;  :RESTARTS          Print available restarts.
;;  :RESTART <n>, <n>  Invoke a restart with the given number.
;;  :ABORT, :Q         Exit by calling #'ABORT.
;;
;; Any non-keyword non-integer form is evaluated.
[1] Debug> :restarts

;; Available restarts:
;;  0: [ABORT] Abort.
;;  1: [RETRY] Retry.
;;  2: [FAIL ] Fail.
[1] Debug> (error "recursive debugger time")

;; Debugger level 2 entered on SIMPLE-ERROR:
;; recursive debugger time
;; Type :HELP for available commands.
[2] Debug> :restarts

;; Available restarts:
;;  0: [ABORT] Return to debugger level 1.
;;  1: [ABORT] Abort.
;;  2: [RETRY] Retry.
;;  3: [FAIL ] Fail.
[2] Debug> 0

[1] Debug> (+ 2 2)

4
[1] Debug> :eval (+ 22 22)

44
[1] Debug> +

(+ 22 22)
[1] Debug> ***

4
[1] Debug> :q

NIL
PORTABLE-CONDITION-SYSTEM> 

License

CC0 / Public Domain.

The test suite for this system is licensed under the MIT license.

2 Systems

The main system appears first, followed by any subsystem dependency.

2.1 portable-condition-system

Maintainer

Michał "phoe" Herda <phoe@disroot.org>

Author

Kent M. Pitman <kent@nhplace.com>

License

CC0

Description

A portable condition system for Common Lisp

Version

1.0.0

Dependencies

• alexandria
• split-sequence

Source

portable-condition-system.asd (file)

Components

• package.lisp (file)
• conditions.lisp (file)
• condition-hierarchy.lisp (file)
• coerce-to-condition.lisp (file)
• restarts.lisp (file)
• assertions.lisp (file)
• signaling.lisp (file)
• handlers.lisp (file)
• debugger.lisp (file)

3 Files

Files are sorted by type and then listed depth-first from the systems components trees.

3.1 Lisp

3.1.1 portable-condition-system.asd

Location

/home/quickref/quicklisp/dists/quicklisp/software/portable-condition-system-20200427-git/portable-condition-system.asd

Systems

portable-condition-system (system)

3.1.2 portable-condition-system/package.lisp

Parent

portable-condition-system (system)

Location

package.lisp

Packages

• common-lisp+portable-condition-system
• portable-condition-system/install
• portable-condition-system

Internal Definitions

generate-defpackages (macro)

3.1.3 portable-condition-system/conditions.lisp

Dependency

package.lisp (file)

Parent

portable-condition-system (system)

Location

conditions.lisp

Exported Definitions

• condition (class)
• define-condition (macro)
• make-condition (function)

Internal Definitions

• expand-define-condition (function)
• expand-define-condition-remove-report-method (function)
• expand-define-condition-report-method (function)

3.1.4 portable-condition-system/condition-hierarchy.lisp

Dependency

conditions.lisp (file)

Parent

portable-condition-system (system)

Location

condition-hierarchy.lisp

Exported Definitions

• arithmetic-error (class)
• cell-error (class)
• cell-error-name (method)
• control-error (class)
• division-by-zero (class)
• end-of-file (class)
• error (class)
• file-error (class)
• floating-point-inexact (class)
• floating-point-invalid-operation (class)
• floating-point-overflow (class)
• floating-point-underflow (class)
• package-error (class)
• package-error-package (method)
• parse-error (class)
• print-not-readable (class)
• print-not-readable-object (method)
• program-error (class)
• reader-error (class)
• serious-condition (class)
• simple-condition (class)
• simple-condition-format-arguments (method)
• simple-condition-format-control (method)
• simple-error (class)
• simple-type-error (class)
• simple-warning (class)
• storage-condition (class)
• stream-error (class)
• stream-error-stream (method)
• style-warning (class)
• type-error (class)
• type-error-datum (method)
• type-error-expected-type (method)
• unbound-slot (class)
• unbound-slot-instance (method)
• unbound-variable (class)
• undefined-function (class)
• warning (class)

Internal Definitions

• abort-failure (class)
• case-failure (class)
• case-failure-name (method)
• case-failure-possibilities (method)
• operands-error-operands (method)
• operation-error-operation (method)
• pathname-error-pathname (method)
• report-case-failure (function)
• report-simple-condition (function)
• report-type-error (function)
• report-unbound-slot (function)
• report-unbound-variable (function)
• report-undefined-function (function)
• restart-not-found (class)
• restart-not-found-restart-name (method)

3.1.5 portable-condition-system/coerce-to-condition.lisp

Dependency

condition-hierarchy.lisp (file)

Parent

portable-condition-system (system)

Location

coerce-to-condition.lisp

Internal Definitions

• coerce-to-condition (generic function)
• coerce-to-condition (method)
• coerce-to-condition (method)
• coerce-to-condition (method)
• coerce-to-condition (method)
• coerce-to-condition (method)

3.1.6 portable-condition-system/restarts.lisp

Dependency

coerce-to-condition.lisp (file)

Parent

portable-condition-system (system)

Location

restarts.lisp

Exported Definitions

• abort (function)
• compute-restarts (generic function)
• compute-restarts (method)
• continue (function)
• find-restart (generic function)
• find-restart (method)
• invoke-restart (generic function)
• invoke-restart (method)
• invoke-restart (method)
• invoke-restart (method)
• invoke-restart-interactively (generic function)
• invoke-restart-interactively (method)
• invoke-restart-interactively (method)
• invoke-restart-interactively (method)
• muffle-warning (function)
• restart (structure)
• restart-bind (macro)
• restart-case (macro)
• restart-name (function)
• (setf restart-name) (function)
• store-value (function)
• use-value (function)
• with-condition-restarts (macro)
• with-simple-restart (macro)

Internal Definitions

• *restart-clusters* (special variable)
• copy-restart (function)
• make-restart (function)
• maybe-invoke-restart (function)
• restart-associated-conditions (function)
• (setf restart-associated-conditions) (function)
• restart-bind-transform-binding (function)
• restart-case-expand-cerror (function)
• restart-case-expand-non-cerror (function)
• restart-case-expand-signaling-form (function)
• restart-case-make-interactive-subform (function)
• restart-case-make-report-subform (function)
• restart-case-make-restart-binding (function)
• restart-case-make-restart-case (function)
• restart-case-make-test-subform (function)
• restart-case-parse-case (function)
• restart-case-pop-keywords-from-case (function)
• restart-case-signaling-form-p (function)
• restart-function (function)
• (setf restart-function) (function)
• restart-interactive-function (function)
• (setf restart-interactive-function) (function)
• restart-p (function)
• restart-report-function (function)
• (setf restart-report-function) (function)
• restart-test-function (function)
• (setf restart-test-function) (function)
• restart-visible-p (function)

3.1.7 portable-condition-system/assertions.lisp

Dependency

restarts.lisp (file)

Parent

portable-condition-system (system)

Location

assertions.lisp

Exported Definitions

• assert (macro)
• ccase (macro)
• check-type (macro)
• ctypecase (macro)
• ecase (macro)
• etypecase (macro)

Internal Definitions

• assert-prompt (function)
• assert-restart-report (function)
• case-accumulate-keys (function)
• case-failure (function)
• case-transform-t-otherwise-cases (function)
• check-type-error (function)
• store-value-read-evaluated-form (function)
• with-store-value-restart (macro)

3.1.8 portable-condition-system/signaling.lisp

Dependency

assertions.lisp (file)

Parent

portable-condition-system (system)

Location

signaling.lisp

Exported Definitions

• *break-on-signals* (special variable)
• cerror (function)
• error (function)
• signal (function)
• warn (function)

Internal Definitions

*handler-clusters* (special variable)

3.1.9 portable-condition-system/handlers.lisp

Dependency

signaling.lisp (file)

Parent

portable-condition-system (system)

Location

handlers.lisp

Exported Definitions

• handler-bind (macro)
• handler-case (macro)
• ignore-errors (macro)

Internal Definitions

• handler-case-make-handler-binding (function)
• handler-case-make-handler-case (function)
• handler-case-parse-case (function)
• make-handler-case-with-no-error-case (function)
• make-handler-case-without-no-error-case (function)

3.1.10 portable-condition-system/debugger.lisp

Dependency

handlers.lisp (file)

Parent

portable-condition-system (system)

Location

debugger.lisp

Exported Definitions

• *debugger-hook* (special variable)
• break (function)
• invoke-debugger (generic function)
• invoke-debugger (method)

Internal Definitions

• *debug-level* (special variable)
• *help-hooks* (special variable)
• debugger-invoke-restart (function)
• define-command (macro)
• read-eval-print-command (function)
• restart-max-name-length (function)
• run-debugger-command (generic function)
• run-debugger-command (method)
• run-debugger-command (method)
• run-debugger-command (method)
• run-debugger-command (method)
• run-debugger-command (method)
• run-debugger-command (method)
• run-debugger-command (method)
• run-debugger-command (method)
• run-debugger-command (method)
• run-debugger-command (method)
• run-debugger-command (method)
• standard-debugger (function)

4 Packages

Packages are listed by definition order.

4.1 common-lisp+portable-condition-system

Source

package.lisp (file)

Use List

• portable-condition-system
• common-lisp

4.2 portable-condition-system/install

Source

package.lisp (file)

Use List

common-lisp

Internal Definitions

generate-defpackages (macro)

4.3 portable-condition-system

Source

package.lisp (file)

Nickname

pcs

Use List

common-lisp

Used By List

common-lisp+portable-condition-system

Exported Definitions

• *break-on-signals* (special variable)
• *debugger-hook* (special variable)
• abort (function)
• arithmetic-error (class)
• assert (macro)
• break (function)
• ccase (macro)
• cell-error (class)
• cell-error-name (generic function)
• cell-error-name (method)
• cerror (function)
• check-type (macro)
• compute-restarts (generic function)
• compute-restarts (method)
• condition (class)
• continue (function)
• control-error (class)
• ctypecase (macro)
• define-condition (macro)
• division-by-zero (class)
• ecase (macro)
• end-of-file (class)
• error (function)
• error (class)
• etypecase (macro)
• file-error (class)
• find-restart (generic function)
• find-restart (method)
• floating-point-inexact (class)
• floating-point-invalid-operation (class)
• floating-point-overflow (class)
• floating-point-underflow (class)
• handler-bind (macro)
• handler-case (macro)
• ignore-errors (macro)
• invoke-debugger (generic function)
• invoke-debugger (method)
• invoke-restart (generic function)
• invoke-restart (method)
• invoke-restart (method)
• invoke-restart (method)
• invoke-restart-interactively (generic function)
• invoke-restart-interactively (method)
• invoke-restart-interactively (method)
• invoke-restart-interactively (method)
• make-condition (function)
• muffle-warning (function)
• package-error (class)
• package-error-package (generic function)
• package-error-package (method)
• parse-error (class)
• print-not-readable (class)
• print-not-readable-object (generic function)
• print-not-readable-object (method)
• program-error (class)
• reader-error (class)
• restart (structure)
• restart-bind (macro)
• restart-case (macro)
• restart-name (function)
• (setf restart-name) (function)
• serious-condition (class)
• signal (function)
• simple-condition (class)
• simple-condition-format-arguments (generic function)
• simple-condition-format-arguments (method)
• simple-condition-format-control (generic function)
• simple-condition-format-control (method)
• simple-error (class)
• simple-type-error (class)
• simple-warning (class)
• storage-condition (class)
• store-value (function)
• stream-error (class)
• stream-error-stream (generic function)
• stream-error-stream (method)
• style-warning (class)
• type-error (class)
• type-error-datum (generic function)
• type-error-datum (method)
• type-error-expected-type (generic function)
• type-error-expected-type (method)
• unbound-slot (class)
• unbound-slot-instance (generic function)
• unbound-slot-instance (method)
• unbound-variable (class)
• undefined-function (class)
• use-value (function)
• warn (function)
• warning (class)
• with-condition-restarts (macro)
• with-simple-restart (macro)

Internal Definitions

• *debug-level* (special variable)
• *handler-clusters* (special variable)
• *help-hooks* (special variable)
• *restart-clusters* (special variable)
• abort-failure (class)
• assert-prompt (function)
• assert-restart-report (function)
• case-accumulate-keys (function)
• case-failure (function)
• case-failure (class)
• case-failure-name (generic function)
• case-failure-name (method)
• case-failure-possibilities (generic function)
• case-failure-possibilities (method)
• case-transform-t-otherwise-cases (function)
• check-type-error (function)
• coerce-to-condition (generic function)
• coerce-to-condition (method)
• coerce-to-condition (method)
• coerce-to-condition (method)
• coerce-to-condition (method)
• coerce-to-condition (method)
• copy-restart (function)
• debugger-invoke-restart (function)
• define-command (macro)
• expand-define-condition (function)
• expand-define-condition-remove-report-method (function)
• expand-define-condition-report-method (function)
• handler-case-make-handler-binding (function)
• handler-case-make-handler-case (function)
• handler-case-parse-case (function)
• make-handler-case-with-no-error-case (function)
• make-handler-case-without-no-error-case (function)
• make-restart (function)
• maybe-invoke-restart (function)
• operands-error-operands (generic function)
• operands-error-operands (method)
• operation-error-operation (generic function)
• operation-error-operation (method)
• pathname-error-pathname (generic function)
• pathname-error-pathname (method)
• read-eval-print-command (function)
• report-case-failure (function)
• report-simple-condition (function)
• report-type-error (function)
• report-unbound-slot (function)
• report-unbound-variable (function)
• report-undefined-function (function)
• restart-associated-conditions (function)
• (setf restart-associated-conditions) (function)
• restart-bind-transform-binding (function)
• restart-case-expand-cerror (function)
• restart-case-expand-non-cerror (function)
• restart-case-expand-signaling-form (function)
• restart-case-make-interactive-subform (function)
• restart-case-make-report-subform (function)
• restart-case-make-restart-binding (function)
• restart-case-make-restart-case (function)
• restart-case-make-test-subform (function)
• restart-case-parse-case (function)
• restart-case-pop-keywords-from-case (function)
• restart-case-signaling-form-p (function)
• restart-function (function)
• (setf restart-function) (function)
• restart-interactive-function (function)
• (setf restart-interactive-function) (function)
• restart-max-name-length (function)
• restart-not-found (class)
• restart-not-found-restart-name (generic function)
• restart-not-found-restart-name (method)
• restart-p (function)
• restart-report-function (function)
• (setf restart-report-function) (function)
• restart-test-function (function)
• (setf restart-test-function) (function)
• restart-visible-p (function)
• run-debugger-command (generic function)
• run-debugger-command (method)
• run-debugger-command (method)
• run-debugger-command (method)
• run-debugger-command (method)
• run-debugger-command (method)
• run-debugger-command (method)
• run-debugger-command (method)
• run-debugger-command (method)
• run-debugger-command (method)
• run-debugger-command (method)
• run-debugger-command (method)
• standard-debugger (function)
• store-value-read-evaluated-form (function)
• with-store-value-restart (macro)

5 Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.

5.1 Exported definitions

5.1.1 Special variables

Special Variable: *break-on-signals*

Declares a condition type for which all signaling functions will call BREAK before actually signaling the condition.

Package

portable-condition-system

Source

signaling.lisp (file)

Special Variable: *debugger-hook*

If set, it is called as a function before entry into the debugger with two arguments: the condition object that the debugger is invoked with, and itself.

Package

portable-condition-system

Source

debugger.lisp (file)

5.1.2 Macros

Macro: assert TEST-FORM &optional PLACES DATUM &rest ARGUMENTS

Evaluates TEST-FORM and checks if it is true; otherwise, signals a correctable error that allows the programmer to retry the assertion. If any places are supplied, the CONTINUE restart allows the programmer to set their values before retrying the assertion. The optional arguments DATUM and ARGUMENTS, if supplied, are used to report the assertion error.

Package

portable-condition-system

Source

assertions.lisp (file)

Macro: ccase KEYFORM &rest CASES

Evaluates the keyform (which must be a place) and checks if it matches any of the keys in the provided cases. Signals a correctable error otherwise, allowing the programmer to modify the value stored in the keyform.

Package

portable-condition-system

Source

assertions.lisp (file)

Macro: check-type PLACE TYPE &optional TYPE-STRING

Evaluates PLACE and checks if its value is of the provided type. Otherwise, signals a correctable error with an established STORE-VALUE restart that allows the programmer to provide a new value for the place before the typecheck is retried. The optional TYPE-STRING argument is used to construct the report for the signaled error.

Package

portable-condition-system

Source

assertions.lisp (file)

Macro: ctypecase KEYFORM &rest CASES

Evaluates the keyform (which must be a place) and checks if it is of any of the types in the provided cases. Signals a correctable error otherwise, allowing the programmer to modify the value stored in the keyform.

Package

portable-condition-system

Source

assertions.lisp (file)

Macro: define-condition NAME (&rest SUPERTYPES) DIRECT-SLOTS &rest OPTIONS

Defines or redefines a condition type.

Package

portable-condition-system

Source

conditions.lisp (file)

Macro: ecase KEYFORM &rest CASES

Evaluates the keyform and checks if it matches any of the keys in the provided cases. Signals an error otherwise.

Package

portable-condition-system

Source

assertions.lisp (file)

Macro: etypecase KEYFORM &rest CASES

Evaluates the keyform and checks if it is of any of the types in the provided cases. Signals an error otherwise.

Package

portable-condition-system

Source

assertions.lisp (file)

Macro: handler-bind BINDINGS &body FORMS

Executes the body forms in a dynamic context where the newly established handlers are available.

Package

portable-condition-system

Source

handlers.lisp (file)

Macro: handler-case FORM &rest CASES

Executes the body forms in a dynamic context where the newly established handlers are available. Each handler immediately transfers control to its handler case upon invocation, executing the body forms of the case and returning their value from HANDLER-CASE.

Package

portable-condition-system

Source

handlers.lisp (file)

Macro: ignore-errors &rest FORMS

Executes the body forms in a dynamic context where a newly established ERROR handler is available. This handler handler immediately transfers control outside the form upon invocation, returning NIL as its primary value and the signaled condition object as its secondary value.

Package

portable-condition-system

Source

handlers.lisp (file)

Macro: restart-bind BINDINGS &body BODY

Executes the body forms in a dynamic context where the newly established restarts are available.

Package

portable-condition-system

Source

restarts.lisp (file)

Macro: restart-case EXPRESSION &body CASES

Executes the body forms in a dynamic context where the newly established restarts are available. Each restart immediately transfers control to its restart case upon invocation, executing the body forms of the case and returning their value from RESTART-CASE.

Package

portable-condition-system

Source

restarts.lisp (file)

Macro: with-condition-restarts CONDITION (&rest RESTARTS) &body BODY

Associates the provided condition object with multiple provided restart objects within the dynamic scope of the provided body forms.

Package

portable-condition-system

Source

restarts.lisp (file)

Macro: with-simple-restart (NAME FORMAT-CONTROL &rest ARGS) &body FORMS

Executes the body forms in a dynamic context where the newly established restart is available. This restart restart immediately transfers control outside the form upon invocation, returning NIL as its primary value and T as its secondary value.

Package

portable-condition-system

Source

restarts.lisp (file)

5.1.3 Functions

Function: abort &optional CONDITION

Invokes the most recent ABORT restart. If the optional condition argument is provided, instead the most recent ABORT restart that is not associated with any other condition. If no ABORT restart is available, or the restart fails to transfer control outside of this form, signals an error.

Package

portable-condition-system

Source

restarts.lisp (file)

Function: break &optional FORMAT-CONTROL &rest FORMAT-ARGUMENTS

Binds *debugger-hook* to NIL, establishes a CONTINUE restart, and invokes the debugger with a condition object whose report is constructed from the optional format control and format arguments.

Package

portable-condition-system

Source

debugger.lisp (file)

Function: cerror CONTINUE-STRING DATUM &rest ARGUMENTS

Coerces the provided arguments to a warning condition, establishes a CONTINUE restart, and signals the condition. If the condition is not handled, invokes the debugger with that condition, allowing execution to continue if the CONTINUE restart is invoked.

Package

portable-condition-system

Source

signaling.lisp (file)

Function: continue &optional CONDITION

Invokes the most recent CONTINUE restart. If the optional condition argument is provided, instead the most recent CONTINUE restart that is not associated with any other condition. If no CONTINUE restart is available, returns NIL.

Package

portable-condition-system

Source

restarts.lisp (file)

Function: error DATUM &rest ARGUMENTS

Coerces the provided arguments to an error condition and signals it. If the condition is not handled, invokes the debugger with that condition.

Package

portable-condition-system

Source

signaling.lisp (file)

Function: make-condition TYPE &rest ARGS

Instantiates a new condition object of the provided type with the provided arguments.

Package

portable-condition-system

Source

conditions.lisp (file)

Function: muffle-warning &optional CONDITION

Invokes the most recent MUFFLE-WARNING restart. If the optional condition argument is provided, instead the most recent MUFFLE-WARNING restart that is not associated with any other condition. If no MUFFLE-WARNING restart is available, signals an error.

Package

portable-condition-system

Source

restarts.lisp (file)

Function: restart-name INSTANCE

Function: (setf restart-name) VALUE INSTANCE

Package

portable-condition-system

Source

restarts.lisp (file)

Function: signal DATUM &rest ARGUMENTS

Coerces the provided arguments to a condition and signals it, calling all condition handlers which match the type of the signaled condition.

Package

portable-condition-system

Source

signaling.lisp (file)

Function: store-value VALUE &optional CONDITION

Invokes the most recent STORE-VALUE restart. If the optional condition argument is provided, instead the most recent STORE-VALUE restart that is not associated with any other condition. If no STORE-VALUE restart is available, returns NIL.

Package

portable-condition-system

Source

restarts.lisp (file)

Function: use-value VALUE &optional CONDITION

Invokes the most recent USE-VALUE restart. If the optional condition argument is provided, instead the most recent USE-VALUE restart that is not associated with any other condition. If no USE-VALUE restart is available, returns NIL.

Package

portable-condition-system

Source

restarts.lisp (file)

Function: warn DATUM &rest ARGUMENTS

Coerces the provided arguments to a warning condition, establishes a MUFFLE-WARNING restart, and signals the condition. If the condition is not handled and the MUFFLE-WARNING restart is not invoked, the condition is reported to the error output stream.

Package

portable-condition-system

Source

signaling.lisp (file)

5.1.4 Generic functions

Generic Function: cell-error-name OBJECT

Package

portable-condition-system

Methods

Method: cell-error-name (CELL-ERROR cell-error)

automatically generated reader method

Source

condition-hierarchy.lisp (file)

Generic Function: compute-restarts &optional CONDITION

Return a list of all currently established restarts. If the
optional condition argument is supplied, omits all restarts which are associated with conditions other than the provided one.

Package

portable-condition-system

Source

restarts.lisp (file)

Methods

Method: compute-restarts &optional CONDITION

Walks all restart clusters and collects all restarts which are visible.

Generic Function: find-restart NAME &optional CONDITION

Finds the first currently established restart with the
provided name. If the optional condition argument is supplied, the search skips over all restarts which are associated with conditions other than the provided one.

Package

portable-condition-system

Source

restarts.lisp (file)

Methods

Method: find-restart NAME &optional CONDITION

Walks all restart clusters and returns the first restart with the correct name and visibility status.

Generic Function: invoke-debugger CONDITION

Invokes the debugger with the provided condition object.

Package

portable-condition-system

Source

debugger.lisp (file)

Methods

Method: invoke-debugger (CONDITION condition)

If the debugger hook is set, calls it with the condition object and itself. Then, enters the standard debugger.

Generic Function: invoke-restart RESTART &rest ARGUMENTS

Invokes a restart with the provided argument. If the restart
is provided by name, this function calls FIND-RESTART with the provided name first and signals an error if no such restart is available. If the restart returns normally, returns the value returned by the restart function.

Package

portable-condition-system

Source

restarts.lisp (file)

Methods

Method: invoke-restart (RESTART restart) &rest ARGUMENTS

Apply the restart function to the provided arguments.

Method: invoke-restart (RESTART symbol) &rest ARGUMENTS

Find the restart with the provided name and invoke it.

Method: invoke-restart RESTART &rest ARGUMENTS

Signal an error that an invalid argument has been passed to INVOKE-RESTART.

Generic Function: invoke-restart-interactively RESTART

Invokes a restart after calling the restart’s interactive
function to retrieve a list of arguments for invoking the restart. If the restart is provided by name, this function calls FIND-RESTART with the provided name first and signals an error if no such restart is available. If the restart returns normally, returns the value returned by the restart function.

Package

portable-condition-system

Source

restarts.lisp (file)

Methods

Method: invoke-restart-interactively (RESTART restart)

Call the restart’s interactive function to obtain the list of arguments and apply the restart functions to them.

Method: invoke-restart-interactively (RESTART symbol)

Find the restart with the provided name and invoke it.

Method: invoke-restart-interactively RESTART

Signal an error that an invalid argument has been passed to INVOKE-RESTART-INTERACTIVELY.

Generic Function: package-error-package OBJECT

Package

portable-condition-system

Methods

Method: package-error-package (PACKAGE-ERROR package-error)

automatically generated reader method

Source

condition-hierarchy.lisp (file)

Generic Function: print-not-readable-object OBJECT

Package

portable-condition-system

Methods

Method: print-not-readable-object (PRINT-NOT-READABLE print-not-readable)

automatically generated reader method

Source

condition-hierarchy.lisp (file)

Generic Function: simple-condition-format-arguments OBJECT

Package

portable-condition-system

Methods

Method: simple-condition-format-arguments (SIMPLE-CONDITION simple-condition)

automatically generated reader method

Source

condition-hierarchy.lisp (file)

Generic Function: simple-condition-format-control OBJECT

Package

portable-condition-system

Methods

Method: simple-condition-format-control (SIMPLE-CONDITION simple-condition)

automatically generated reader method

Source

condition-hierarchy.lisp (file)

Generic Function: stream-error-stream OBJECT

Package

portable-condition-system

Methods

Method: stream-error-stream (STREAM-ERROR stream-error)

automatically generated reader method

Source

condition-hierarchy.lisp (file)

Generic Function: type-error-datum OBJECT

Package

portable-condition-system

Methods

Method: type-error-datum (TYPE-ERROR type-error)

automatically generated reader method

Source

condition-hierarchy.lisp (file)

Generic Function: type-error-expected-type OBJECT

Package

portable-condition-system

Methods

Method: type-error-expected-type (TYPE-ERROR type-error)

automatically generated reader method

Source

condition-hierarchy.lisp (file)

Generic Function: unbound-slot-instance OBJECT

Package

portable-condition-system

Methods

Method: unbound-slot-instance (UNBOUND-SLOT unbound-slot)

automatically generated reader method

Source

condition-hierarchy.lisp (file)

5.1.5 Structures

Structure: restart ()

A restart structure, implementing the ANSI CL system class RESTART.

Package

portable-condition-system

Source

restarts.lisp (file)

Direct superclasses

structure-object (structure)

Direct methods

• invoke-restart-interactively (method)
• invoke-restart (method)
• print-object (method)
• print-object (method)

Direct slots

Slot: name

Initform

(portable-condition-system:error "name required.")

Readers

restart-name (function)

Writers

(setf restart-name) (function)

Slot: function

Initform

(portable-condition-system:error "function required.")

Readers

restart-function (function)

Writers

(setf restart-function) (function)

Slot: report-function

Readers

restart-report-function (function)

Writers

(setf restart-report-function) (function)

Slot: interactive-function

Readers

restart-interactive-function (function)

Writers

(setf restart-interactive-function) (function)

Slot: test-function

Initform

(constantly t)

Readers

restart-test-function (function)

Writers

(setf restart-test-function) (function)

Slot: associated-conditions

Initform

(quote nil)

Readers

restart-associated-conditions (function)

Writers

(setf restart-associated-conditions) (function)

5.1.6 Classes

Class: arithmetic-error ()

Package

portable-condition-system

Source

condition-hierarchy.lisp (file)

Direct superclasses

error (class)

Direct subclasses

• division-by-zero (class)
• floating-point-invalid-operation (class)
• floating-point-inexact (class)
• floating-point-overflow (class)
• floating-point-underflow (class)

Direct methods

• operands-error-operands (method)
• operation-error-operation (method)

Direct slots

Slot: operation

Initargs

:operation

Readers

operation-error-operation (generic function)

Slot: operands

Initargs

:operands

Readers

operands-error-operands (generic function)

Class: cell-error ()

Package

portable-condition-system

Source

condition-hierarchy.lisp (file)

Direct superclasses

error (class)

Direct subclasses

• unbound-variable (class)
• undefined-function (class)
• unbound-slot (class)

Direct methods

cell-error-name (method)

Direct slots

Slot: name

Initargs

:name

Readers

cell-error-name (generic function)

Class: condition ()

The base condition type that is the supertype of all condition objects.

Package

portable-condition-system

Source

conditions.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses

• warning (class)
• serious-condition (class)
• simple-condition (class)

Direct methods

• invoke-debugger (method)
• coerce-to-condition (method)
• print-object (method)
• print-object (method)

Class: control-error ()

Package

portable-condition-system

Source

condition-hierarchy.lisp (file)

Direct superclasses

error (class)

Direct subclasses

• restart-not-found (class)
• abort-failure (class)

Class: division-by-zero ()

Package

portable-condition-system

Source

condition-hierarchy.lisp (file)

Direct superclasses

arithmetic-error (class)

Class: end-of-file ()

Package

portable-condition-system

Source

condition-hierarchy.lisp (file)

Direct superclasses

stream-error (class)

Class: error ()

Package

portable-condition-system

Source

condition-hierarchy.lisp (file)

Direct superclasses

serious-condition (class)

Direct subclasses

• simple-error (class)
• type-error (class)
• control-error (class)
• program-error (class)
• cell-error (class)
• stream-error (class)
• parse-error (class)
• package-error (class)
• arithmetic-error (class)
• file-error (class)
• print-not-readable (class)

Class: file-error ()

Package

portable-condition-system

Source

condition-hierarchy.lisp (file)

Direct superclasses

error (class)

Direct methods

pathname-error-pathname (method)

Direct slots

Slot: pathname

Initargs

:pathname

Readers

pathname-error-pathname (generic function)

Class: floating-point-inexact ()

Package

portable-condition-system

Source

condition-hierarchy.lisp (file)

Direct superclasses

arithmetic-error (class)

Class: floating-point-invalid-operation ()

Package

portable-condition-system

Source

condition-hierarchy.lisp (file)

Direct superclasses

arithmetic-error (class)

Class: floating-point-overflow ()

Package

portable-condition-system

Source

condition-hierarchy.lisp (file)

Direct superclasses

arithmetic-error (class)

Class: floating-point-underflow ()

Package

portable-condition-system

Source

condition-hierarchy.lisp (file)

Direct superclasses

arithmetic-error (class)

Class: package-error ()

Package

portable-condition-system

Source

condition-hierarchy.lisp (file)

Direct superclasses

error (class)

Direct methods

package-error-package (method)

Direct slots

Slot: package

Initargs

:package

Readers

package-error-package (generic function)

Class: parse-error ()

Package

portable-condition-system

Source

condition-hierarchy.lisp (file)

Direct superclasses

error (class)

Direct subclasses

reader-error (class)

Direct slots

Slot: stream

Class: print-not-readable ()

Package

portable-condition-system

Source

condition-hierarchy.lisp (file)

Direct superclasses

error (class)

Direct methods

print-not-readable-object (method)

Direct slots

Slot: object

Initargs

:object

Readers

print-not-readable-object (generic function)

Class: program-error ()

Package

portable-condition-system

Source

condition-hierarchy.lisp (file)

Direct superclasses

error (class)

Class: reader-error ()

Package

portable-condition-system

Source

condition-hierarchy.lisp (file)

Direct superclasses

• stream-error (class)
• parse-error (class)

Class: serious-condition ()

Package

portable-condition-system

Source

condition-hierarchy.lisp (file)

Direct superclasses

condition (class)

Direct subclasses

• error (class)
• storage-condition (class)

Class: simple-condition ()

Package

portable-condition-system

Source

condition-hierarchy.lisp (file)

Direct superclasses

condition (class)

Direct subclasses

• simple-warning (class)
• simple-error (class)
• simple-type-error (class)

Direct methods

• print-object (method)
• simple-condition-format-arguments (method)
• simple-condition-format-control (method)

Direct slots

Slot: format-control

Initargs

:format-control

Readers

simple-condition-format-control (generic function)

Slot: format-arguments

Initargs

:format-arguments

Readers

simple-condition-format-arguments (generic function)

Direct Default Initargs

Initarg	Value
:format-control	nil
:format-arguments	(quote nil)

Class: simple-error ()

Package

portable-condition-system

Source

condition-hierarchy.lisp (file)

Direct superclasses

• error (class)
• simple-condition (class)

Class: simple-type-error ()

Package

portable-condition-system

Source

condition-hierarchy.lisp (file)

Direct superclasses

• type-error (class)
• simple-condition (class)

Class: simple-warning ()

Package

portable-condition-system

Source

condition-hierarchy.lisp (file)

Direct superclasses

• warning (class)
• simple-condition (class)

Class: storage-condition ()

Package

portable-condition-system

Source

condition-hierarchy.lisp (file)

Direct superclasses

serious-condition (class)

Class: stream-error ()

Package

portable-condition-system

Source

condition-hierarchy.lisp (file)

Direct superclasses

error (class)

Direct subclasses

• end-of-file (class)
• reader-error (class)

Direct methods

stream-error-stream (method)

Direct slots

Slot: stream

Initargs

:stream

Readers

stream-error-stream (generic function)

Class: style-warning ()

Package

portable-condition-system

Source

condition-hierarchy.lisp (file)

Direct superclasses

warning (class)

Class: type-error ()

Package

portable-condition-system

Source

condition-hierarchy.lisp (file)

Direct superclasses

error (class)

Direct subclasses

• simple-type-error (class)
• case-failure (class)

Direct methods

• print-object (method)
• type-error-expected-type (method)
• type-error-datum (method)

Direct slots

Slot: datum

Initargs

:datum

Readers

type-error-datum (generic function)

Slot: expected-type

Initargs

:expected-type

Readers

type-error-expected-type (generic function)

Class: unbound-slot ()

Package

portable-condition-system

Source

condition-hierarchy.lisp (file)

Direct superclasses

cell-error (class)

Direct methods

• print-object (method)
• unbound-slot-instance (method)

Direct slots

Slot: instance

Initargs

:instance

Readers

unbound-slot-instance (generic function)

Class: unbound-variable ()

Package

portable-condition-system

Source

condition-hierarchy.lisp (file)

Direct superclasses

cell-error (class)

Direct methods

print-object (method)

Class: undefined-function ()

Package

portable-condition-system

Source

condition-hierarchy.lisp (file)

Direct superclasses

cell-error (class)

Direct methods

print-object (method)

Class: warning ()

Package

portable-condition-system

Source

condition-hierarchy.lisp (file)

Direct superclasses

condition (class)

Direct subclasses

• style-warning (class)
• simple-warning (class)

5.2 Internal definitions

5.2.1 Special variables

Special Variable: *debug-level*

A variable holding the current debugger level, rebound dynamically on each debugger entry.

Package

portable-condition-system

Source

debugger.lisp (file)

Special Variable: *handler-clusters*

A list containing a list of all handler clusters, where a cluster is a list of handlers established together.

Package

portable-condition-system

Source

signaling.lisp (file)

Special Variable: *help-hooks*

A list of hooks that are called when the :HELP debugger command is invoked. Each hook must be a function that accepts a condition object that the debugger was entered with and a stream that the hook should print to.

Package

portable-condition-system

Source

debugger.lisp (file)

Special Variable: *restart-clusters*

A list containing a list of all restart clusters, where a cluster is a list of restarts established together.

Package

portable-condition-system

Source

restarts.lisp (file)

5.2.2 Macros

Macro: define-command NAME (STREAM CONDITION &rest ARGUMENTS) &body BODY

Accepts a command name (which should be a keyword) and generates a DEFMETHOD form in which the stream, condition, and argument variables are available for use inside the method body.

Package

portable-condition-system

Source

debugger.lisp (file)

Macro: generate-defpackages ()

Generates the package definition forms which utilize PCS-SYMBOLS.

Package

portable-condition-system/install

Source

package.lisp (file)

Macro: with-store-value-restart (TEMP-VAR PLACE TAG) &body FORMS

Evaluates the provided forms in an environment with a freshly established STORE-VALUE restart. The arguments accepted by the macro are a pair of places that should be set by the restart and the TAGBODY tag that control should be transferred to after setting the value.

Package

portable-condition-system

Source

assertions.lisp (file)

5.2.3 Functions

Function: assert-prompt PLACE-NAME VALUE

Queries the programmer whether they would like to modify the value of a given place. If not, returns the old value; if yes, queries the programmer for an expression to evaluate and returns its value.

If the old place is a symbol naming a variable, it is dynamically bound by PROGV to its old value, so the programmer can use it in the newly evaluated expression.

Package

portable-condition-system

Source

assertions.lisp (file)

Function: assert-restart-report NAMES STREAM

Reports the restart bound by ASSERT, printing the list of places supplied to ASSERT, if any.

Package

portable-condition-system

Source

assertions.lisp (file)

Function: case-accumulate-keys CASES

Collects all keys from the provided cases into a single list.

Package

portable-condition-system

Source

assertions.lisp (file)

Function: case-failure DATUM COMPLEX-TYPE OPERATOR-NAME KEYS

Signals a CASE-FAILURE error using the provided datum, the name of the case operator, complex type specifier, and the case keys which were not matched.

Package

portable-condition-system

Source

assertions.lisp (file)

Function: case-transform-t-otherwise-cases CASES

Transforms T/OTHERWISE cases to prevent them from having a special effect in CASE.

Package

portable-condition-system

Source

assertions.lisp (file)

Function: check-type-error PLACE VALUE TYPE TYPE-STRING

Instantiates an error object suitable to signal within CHECK-TYPE, using the provided place, value, and expected type or provided type string.

Package

portable-condition-system

Source

assertions.lisp (file)

Function: copy-restart INSTANCE

Package

portable-condition-system

Source

restarts.lisp (file)

Function: debugger-invoke-restart NAME STREAM CONDITION

Finds and invokes a restart with the given name; if no such restart is available, informs the user about that fact.

Package

portable-condition-system

Source

debugger.lisp (file)

Function: expand-define-condition NAME SUPERTYPES DIRECT-SLOTS OPTIONS

Defines a new condition type via DEFCLASS, handling the :REPORT options via defining a PRINT-object method on the newly created class.

Package

portable-condition-system

Source

conditions.lisp (file)

Function: expand-define-condition-remove-report-method NAME

Accepts the method name and expands into a form which removes any PRINT-OBJECT method defined on the class named by NAME.

Package

portable-condition-system

Source

conditions.lisp (file)

Function: expand-define-condition-report-method NAME REPORT-OPTION

Accepts the name of the condition being defined and the report option provided to DEFINE-CONDITION, and returns a DEFMETHOD PRINT-OBJECT form meant to be spliced into the generated DEFINE-CONDITION expansion.

Package

portable-condition-system

Source

conditions.lisp (file)

Function: handler-case-make-handler-binding TEMP-VAR DATUM

Accepts an annotated HANDLER-CASE case and generates a HANDLER-BIND binding based on it.

Package

portable-condition-system

Source

handlers.lisp (file)

Function: handler-case-make-handler-case BLOCK-NAME TEMP-VAR DATUM

Accepts an annotated HANDLER-CASE case and generates a TAGBODY case based on it.

Package

portable-condition-system

Source

handlers.lisp (file)

Function: handler-case-parse-case DATUM

Parses and annotates a handler case with a unique go tag.

Package

portable-condition-system

Source

handlers.lisp (file)

Function: make-handler-case-with-no-error-case FORM CASES

Generates the HANDLER-CASE body in situation where a :NO-ERROR case is provided.

Package

portable-condition-system

Source

handlers.lisp (file)

Function: make-handler-case-without-no-error-case FORM CASES

Generates the HANDLER-CASE body in situation where no :NO-ERROR case is provided.

Package

portable-condition-system

Source

handlers.lisp (file)

Function: make-restart &key (NAME NAME) (FUNCTION FUNCTION) (REPORT-FUNCTION REPORT-FUNCTION) (INTERACTIVE-FUNCTION INTERACTIVE-FUNCTION) (TEST-FUNCTION TEST-FUNCTION) (ASSOCIATED-CONDITIONS ASSOCIATED-CONDITIONS)

Package

portable-condition-system

Source

restarts.lisp (file)

Function: maybe-invoke-restart RESTART-NAME &optional CONDITION ERRORP &rest ARGUMENTS

Searches for a restart with the provided restart name, using the optionally provided condition argument during the search. If a restart is found, it is invoked; otherwise, if ERRORP is true, a RESTART-NOT-FOUND error is signaled. Otherwise, this function returns NIL.

Package

portable-condition-system

Source

restarts.lisp (file)

Function: read-eval-print-command STREAM CONDITION

Implements a single read-eval-print pass of the debugger REPL. Keywords are treated as debugger commands and integers are treated as arguments to :RESTART.

Package

portable-condition-system

Source

debugger.lisp (file)

Function: report-case-failure CONDITION STREAM

Package

portable-condition-system

Source

condition-hierarchy.lisp (file)

Function: report-simple-condition CONDITION STREAM

Package

portable-condition-system

Source

condition-hierarchy.lisp (file)

Function: report-type-error CONDITION STREAM

Package

portable-condition-system

Source

condition-hierarchy.lisp (file)

Function: report-unbound-slot CONDITION STREAM

Package

portable-condition-system

Source

condition-hierarchy.lisp (file)

Function: report-unbound-variable CONDITION STREAM

Package

portable-condition-system

Source

condition-hierarchy.lisp (file)

Function: report-undefined-function CONDITION STREAM

Package

portable-condition-system

Source

condition-hierarchy.lisp (file)

Function: restart-associated-conditions INSTANCE

Function: (setf restart-associated-conditions) VALUE INSTANCE

Package

portable-condition-system

Source

restarts.lisp (file)

Function: restart-bind-transform-binding BINDING

Transforms the RESTART-BIND binding into a MAKE-RESTART form.

Package

portable-condition-system

Source

restarts.lisp (file)

Function: restart-case-expand-cerror EXPANSION

Expands the provided CERROR form into a signaling form whose condition is associated with the restarts that are newly established by HANDLER-CASE.

Package

portable-condition-system

Source

restarts.lisp (file)

Function: restart-case-expand-non-cerror EXPANSION

Expands the provided SIGNAL, WARN, or ERROR form into a signaling form whose condition is associated with the restarts that are newly established by HANDLER-CASE.

Package

portable-condition-system

Source

restarts.lisp (file)

Function: restart-case-expand-signaling-form EXPRESSION ENV

Expands the provided signaling form into a signaling form whose condition is associated with the restarts that are newly established by HANDLER-CASE.

Package

portable-condition-system

Source

restarts.lisp (file)

Function: restart-case-make-interactive-subform INTERACTIVE

Accepts an argument to HANDLER-CASE’s :INTERACTIVE option and generates a :INTERACTIVE-FUNCTION subform, meant to be spliced into the HANDLER-BIND binding generated by HANDLER-CASE.

Package

portable-condition-system

Source

restarts.lisp (file)

Function: restart-case-make-report-subform REPORT

Accepts an argument to HANDLER-CASE’s :REPORT option and generates a :REPORT-FUNCTION subform, meant to be spliced into the HANDLER-BIND binding generated by HANDLER-CASE.

Package

portable-condition-system

Source

restarts.lisp (file)

Function: restart-case-make-restart-binding TEMP-VAR PARSED-CASE

Accepts a parsed RESTART-CASE case and generates a RESTART-BIND binding based on it.

Package

portable-condition-system

Source

restarts.lisp (file)

Function: restart-case-make-restart-case BLOCK-TAG TEMP-VAR PARSED-CASE

Accepts a parsed RESTART-CASE case and generates a TAGBODY case based on it.

Package

portable-condition-system

Source

restarts.lisp (file)

Function: restart-case-make-test-subform TEST

Accepts an argument to HANDLER-CASE’s :TEST option and generates a :TEST-FUNCTION subform, meant to be spliced into the HANDLER-BIND binding generated by HANDLER-CASE.

Package

portable-condition-system

Source

restarts.lisp (file)

Function: restart-case-parse-case CASE

Parses the provided handler case and returns five values: restart name, lambda list of the restart case, a list of HANDLER-BIND keywords meant to be spliced into the handler binding, the body forms of the handler case, and a globally unique symbol that is meant to be used as a GO tag within the main body of HANDLER-CASE.

Package

portable-condition-system

Source

restarts.lisp (file)

Function: restart-case-pop-keywords-from-case CASE-FORMS

Accepts the forms of a handler case following the case’s lambda list and parses that form, checking for the presence of :REPORT, :INTERACTIVE, and :TEST keywords within the case’s body. Returns four values: the body forms of the case remaining after removing the aforementioned keyword-argument pairs, and the values of :REPORT, :INTERACTIVE, and :TEST keywords found in the body (or NIL, if the respective keyword was not found).

Package

portable-condition-system

Source

restarts.lisp (file)

Function: restart-case-signaling-form-p EXPRESSION ENV

Returns true if the expression provided to RESTART-CASE is a known condition-signaling form whose condition should be associated with the restarts that are newly established by HANDLER-CASE.

Package

portable-condition-system

Source

restarts.lisp (file)

Function: restart-function INSTANCE

Function: (setf restart-function) VALUE INSTANCE

Package

portable-condition-system

Source

restarts.lisp (file)

Function: restart-interactive-function INSTANCE

Function: (setf restart-interactive-function) VALUE INSTANCE

Package

portable-condition-system

Source

restarts.lisp (file)

Function: restart-max-name-length RESTARTS

Returns the length of the longest name from the provided restarts.

Package

portable-condition-system

Source

debugger.lisp (file)

Function: restart-p OBJECT

Package

portable-condition-system

Source

restarts.lisp (file)

Function: restart-report-function INSTANCE

Function: (setf restart-report-function) VALUE INSTANCE

Package

portable-condition-system

Source

restarts.lisp (file)

Function: restart-test-function INSTANCE

Function: (setf restart-test-function) VALUE INSTANCE

Package

portable-condition-system

Source

restarts.lisp (file)

Function: restart-visible-p RESTART CONDITION

Returns true if the restart should be visible when computed for a given condition object. If the condition is null, return true; otherwise, if the restart is associated with a different condition, return false; otherwise, return true.

Package

portable-condition-system

Source

restarts.lisp (file)

Function: standard-debugger CONDITION &optional STREAM

Implements the standard debugger.

Package

portable-condition-system

Source

debugger.lisp (file)

Function: store-value-read-evaluated-form ()

Queries the user for a single form to be evaluated, then reads and evaluates that form.

Package

portable-condition-system

Source

assertions.lisp (file)

5.2.4 Generic functions

Generic Function: case-failure-name OBJECT

Package

portable-condition-system

Methods

Method: case-failure-name (CASE-FAILURE case-failure)

automatically generated reader method

Source

condition-hierarchy.lisp (file)

Generic Function: case-failure-possibilities OBJECT

Package

portable-condition-system

Methods

Method: case-failure-possibilities (CASE-FAILURE case-failure)

automatically generated reader method

Source

condition-hierarchy.lisp (file)

Generic Function: coerce-to-condition DATUM ARGUMENTS DEFAULT-TYPE NAME

Attempts to coerce the provided arguments into a condition
object. The DEFAULT-TYPE argument describes the default condition type that should be created if no condition type can be inferred from DATUM; the NAME argument is the name of the coercing operator and is used during invalid coercions to properly report the error.

Package

portable-condition-system

Source

coerce-to-condition.lisp (file)

Methods

Method: coerce-to-condition DATUM ARGUMENTS DEFAULT-TYPE NAME

Signals an error that the provided datum is not coercable to a condition object.

Method: coerce-to-condition (DATUM function) ARGUMENTS DEFAULT-TYPE NAME

Makes a SIMPLE-CONDITION of the provided DEFAULT-TYPE, using the DATUM function as its format control and ARGUMENTS as format arguments.

Method: coerce-to-condition (DATUM string) ARGUMENTS DEFAULT-TYPE NAME

Makes a SIMPLE-CONDITION of the provided DEFAULT-TYPE, using the DATUM string as its format control and ARGUMENTS as its format arguments.

Method: coerce-to-condition (DATUM symbol) ARGUMENTS DEFAULT-TYPE NAME

Calls MAKE-CONDITION on the provided symbol and arguments.

Method: coerce-to-condition (DATUM condition) ARGUMENTS DEFAULT-TYPE NAME

Returns the condition object that was passed to the function. If arguments are non-NIL, signals a continuable error.

Generic Function: operands-error-operands OBJECT

Package

portable-condition-system

Methods

Method: operands-error-operands (ARITHMETIC-ERROR arithmetic-error)

automatically generated reader method

Source

condition-hierarchy.lisp (file)

Generic Function: operation-error-operation OBJECT

Package

portable-condition-system

Methods

Method: operation-error-operation (ARITHMETIC-ERROR arithmetic-error)

automatically generated reader method

Source

condition-hierarchy.lisp (file)

Generic Function: pathname-error-pathname OBJECT

Package

portable-condition-system

Methods

Method: pathname-error-pathname (FILE-ERROR file-error)

automatically generated reader method

Source

condition-hierarchy.lisp (file)

Generic Function: restart-not-found-restart-name OBJECT

Package

portable-condition-system

Methods

Method: restart-not-found-restart-name (RESTART-NOT-FOUND restart-not-found)

automatically generated reader method

Source

condition-hierarchy.lisp (file)

Generic Function: run-debugger-command COMMAND STREAM CONDITION &rest ARGUMENTS

Executes the provided debugger command, reading input from
and printing output to the provided stream. The condition object the debugger was entered with and optional command arguments are available for use within the command itself.

Package

portable-condition-system

Source

debugger.lisp (file)

Methods

Method: run-debugger-command (COMMAND0 (eql help)) STREAM CONDITION &rest ARGUMENTS1

Prints the debugger help.

Method: run-debugger-command (COMMAND0 (eql c)) STREAM CONDITION &rest ARGUMENTS1

Shorthand for :CONTINUE.

Method: run-debugger-command (COMMAND0 (eql continue)) STREAM CONDITION &rest ARGUMENTS1

Finds and invokes the CONTINUE restart; if no such restart is available, informs the user about that fact.

Method: run-debugger-command (COMMAND0 (eql q)) STREAM CONDITION &rest ARGUMENTS1

Shorthand for :ABORT.

Method: run-debugger-command (COMMAND0 (eql abort)) STREAM CONDITION &rest ARGUMENTS1

Finds and invokes the ABORT restart; if no such restart is available, informs the user about that fact.

Method: run-debugger-command (COMMAND0 (eql restart)) STREAM CONDITION &rest ARGUMENTS1

Invokes a particular restart.

Method: run-debugger-command (COMMAND0 (eql restarts)) STREAM CONDITION &rest ARGUMENTS1

Prints a list of available restarts.

Method: run-debugger-command (COMMAND0 (eql condition)) STREAM CONDITION &rest ARGUMENTS1

Returns the condition object that the debugger was entered with.

Method: run-debugger-command (COMMAND0 (eql report)) STREAM CONDITION &rest ARGUMENTS1

Informs the user that the debugger has been entered and reports the condition object the debugger was entered with.

Method: run-debugger-command (COMMAND0 (eql eval)) STREAM CONDITION &rest ARGUMENTS1

Evaluates a form. The form may be provided as an optional argument; otherwise, it read from the provided stream.

Method: run-debugger-command COMMAND STREAM CONDITION &rest ARGUMENTS

Informs the user that the provided debugger command was not recognized.

5.2.5 Classes

Class: abort-failure ()

A condition type signaled when the ABORT restart invoked by function ABORT failed to transfer control outside of the function.

Package

portable-condition-system

Source

condition-hierarchy.lisp (file)

Direct superclasses

control-error (class)

Direct methods

print-object (method)

Class: case-failure ()

A condition type signaled when a case assertion
(such as ECASE, ETYPECASE, CCASE, or CTYPECASE) fails to match its keyform.

Package

portable-condition-system

Source

condition-hierarchy.lisp (file)

Direct superclasses

type-error (class)

Direct methods

• print-object (method)
• case-failure-possibilities (method)
• case-failure-name (method)

Direct slots

Slot: name

Initargs

:name

Readers

case-failure-name (generic function)

Slot: possibilities

Initargs

:possibilities

Readers

case-failure-possibilities (generic function)

Class: restart-not-found ()

A condition type signaled when a restart with a given name was not found, even thought it was expected.

Package

portable-condition-system

Source

condition-hierarchy.lisp (file)

Direct superclasses

control-error (class)

Direct methods

• print-object (method)
• restart-not-found-restart-name (method)

Direct slots

Slot: restart-name

Initargs

:restart-name

Readers

restart-not-found-restart-name (generic function)

Appendix A Indexes

A.1 Concepts

A.2 Functions