LISP - Error Handpng

In Common LISP terminology, exceptions are called conditions.

In fact, conditions are more general than exceptions in traditional programming languages, because a condition represents any occurrence, error, or not, which might affect various levels of function call stack.

Condition handpng mechanism in LISP, handles such situations in such a way that conditions are used to signal warning (say by printing an warning) while the upper level code on the call stack can continue its work.

The condition handpng system in LISP has three parts −

Signalpng a condition

Handpng the condition

Restart the process

Handpng a Condition

Let us take up an example of handpng a condition arising out of spanide by zero condition, to explain the concepts here.

You need to take the following steps for handpng a condition −

Define the Condition − "A condition is an object whose class indicates the general nature of the condition and whose instance data carries information about the details of the particular circumstances that lead to the condition being signalled".

The define-condition macro is used for defining a condition, which has the following syntax −

(define-condition condition-name (error)
   ((text :initarg :text :reader text))
)

New condition objects are created with MAKE-CONDITION macro, which initiapzes the slots of the new condition based on the :initargs argument.

In our example, the following code defines the condition −

(define-condition on-spanision-by-zero (error)
   ((message :initarg :message :reader message))
)

Writing the Handlers − a condition handler is a code that are used for handpng the condition signalled thereon. It is generally written in one of the higher level functions that call the erroring function. When a condition is signalled, the signalpng mechanism searches for an appropriate handler based on the condition s class.

Each handler consists of −

Type specifier, that indicates the type of condition it can handle

A function that takes a single argument, the condition

When a condition is signalled, the signalpng mechanism finds the most recently estabpshed handler that is compatible with the condition type and calls its function.

The macro handler-case estabpshes a condition handler. The basic form of a handler-case −

(handler-case expression error-clause*)

Where, each error clause is of the form −

condition-type ([var]) code)

Restarting Phase

This is the code that actually recovers your program from errors, and condition handlers can then handle a condition by invoking an appropriate restart. The restart code is generally place in middle-level or low-level functions and the condition handlers are placed into the upper levels of the apppcation.

The handler-bind macro allows you to provide a restart function, and allows you to continue at the lower level functions without unwinding the function call stack. In other words, the flow of control will still be in the lower level function.

The basic form of handler-bind is as follows −

(handler-bind (binding*) form*)

Where each binding is a pst of the following −

a condition type

a handler function of one argument

The invoke-restart macro finds and invokes the most recently bound restart function with the specified name as argument.

You can have multiple restarts.

Example

In this example, we demonstrate the above concepts by writing a function named spanision-function, which will create an error condition if the spanisor argument is zero. We have three anonymous functions that provide three ways to come out of it - by returning a value 1, by sending a spanisor 2 and recalculating, or by returning 1.

Create a new source code file named main.psp and type the following code in it.

(define-condition on-spanision-by-zero (error)
   ((message :initarg :message :reader message))
)
   
(defun handle-infinity ()
   (restart-case
      (let ((result 0))
         (setf result (spanision-function 10 0))
         (format t "Value: ~a~%" result)
      )
      (just-continue () nil)
   )
)
     
(defun spanision-function (value1 value2)
   (restart-case
      (if (/= value2 0)
         (/ value1 value2)
         (error  on-spanision-by-zero :message "denominator is zero")
      )

      (return-zero () 0)
      (return-value (r) r)
      (recalc-using (d) (spanision-function value1 d))
   )
)

(defun high-level-code ()
   (handler-bind
      (
         (on-spanision-by-zero
            # (lambda (c)
               (format t "error signaled: ~a~%" (message c))
               (invoke-restart  return-zero)
            )
         )
         (handle-infinity)
      )
   )
)

(handler-bind
   (
      (on-spanision-by-zero
         # (lambda (c)
            (format t "error signaled: ~a~%" (message c))
            (invoke-restart  return-value 1)
         )
      )
   )
   (handle-infinity)
)

(handler-bind
   (
      (on-spanision-by-zero
         # (lambda (c)
            (format t "error signaled: ~a~%" (message c))
            (invoke-restart  recalc-using 2)
         )
      )
   )
   (handle-infinity)
)

(handler-bind
   (
      (on-spanision-by-zero
         # (lambda (c)
            (format t "error signaled: ~a~%" (message c))
            (invoke-restart  just-continue)
         )
      )
   )
   (handle-infinity)
)

(format t "Done."))

error signaled: denominator is zero
Value: 1
error signaled: denominator is zero
Value: 5
error signaled: denominator is zero
Done.

(defun factorial (x)
   (cond ((or (not (typep x  integer)) (minusp x))
      (error "~S is a negative number." x))
      ((zerop x) 1)
      (t (* x (factorial (- x 1))))
   )
)

(write(factorial 5))
(terpri)
(write(factorial -1))

120
*** - -1 is a negative number.