
- LISP Tutorial
- LISP - Home
- LISP - Overview
- LISP - Environment
- LISP - REPL
- LISP - Program Structure
- LISP - Basic Syntax
- LISP - Data Types
- Lisp Macros
- LISP - Macros
- LISP - Backquote and Comma
- LISP - Code Generation Using Macro
- LISP - Variable Capture and Hygienic macro
- LISP - Scope and Binding
- LISP - Macro Writing Style
- LISP - Macro Characters
- LISP - Read-Time Macros
- LISP - Compiler Macros
- LISP - Uses of Macros
- Lisp Functions
- LISP - Functions
- LISP - Functions vs Macros
- LISP - Calling Function using funcall
- LISP - Calling Function using apply
- LISP - Closures
- LISP - Functions as Arguments
- LISP - Functions as Return Values
- LISP - Recursion
- LISP - Built-in Functions
- Lisp Predicates
- LISP - Predicates
- LISP - Generic Data Type Predicates
- LISP - Specific Data Type Predicates
- LISP - Equality Predicates
- LISP - Numeric Predicates
- LISP - Comparison Predicates
- LISP - Logical Predicates
- LISP - List Predicates
- LISP - Custom Predicates
- LISP - Chaining Predicates
- Lisp Arrays
- LISP - Arrays
- LISP - Adjustable Arrays
- LISP - Fill Pointers in Arrays
- LISP - Specialized Arrays
- LISP - Arrays Properties
- LISP - Iterating over Arrays
- LISP - Multidimensional Arrays
- LISP - Row-Major Order
- Lisp Strings
- LISP - Strings
- LISP - String Concatenation
- LISP - String Comparison
- LISP - String Case Conversion
- LISP - String Trimmimg
- LISP - String Searching
- LISP - Getting Substring
- LISP - String Replacement
- LISP - Sorting Strings
- LISP - Merging Strings
- LISP - Accessing Characters of String
- LISP - String length
- LISP - Escape Sequences
- Lisp Sequences
- LISP - Sequences
- LISP - Accessing Element of Sequence
- LISP - Sequence length
- LISP - Getting Subsequence
- LISP - Search Element in Sequence
- LISP - Sequence Concatenation
- LISP - Reversing a Sequence
- LISP - Mapping Sequence Element
- LISP - position of Element
- LISP - Remove an Element
- LISP - Sort Sequence
- LISP - Merge Sequences
- LISP - every function
- LISP - some function
- LISP - notany function
- LISP - notevery function
- Lisp Lists
- LISP - Lists
- LISP - Accessing Elements of Lists
- LISP - Modifications to Lists
- LISP - Using mapcar on List
- LISP - Using mapc on List
- LISP - Using reduce on List
- LISP - Removing elements from List
- LISP - Reversing a List
- LISP - Sorting a List
- LISP - Searching a List
- LISP - List vs Vectors
- LISP - Matrix Multiplication
- Lisp Vectors
- LISP - Vectors
- LISP - Creating Vectors
- LISP - Accessing Elements of Vectors
- LISP - Modifications to Vectors
- LISP - Adjustable Vectors
- LISP - Specialized Vectors
- LISP - Vector Functions
- Lisp Set
- LISP - Set
- LISP - Adding elements to the Set
- LISP - Getting SubSet from a Set
- LISP - Set Difference
- LISP - Set Exclusive OR
- LISP - Set Intersection
- LISP - Set Union
- LISP - Representing Set with HashTable
- LISP - List as Set vs HashTable as Set
- Lisp Tree
- LISP - Tree
- LISP - Recursive Traversal
- LISP - Inorder Traversal
- LISP - Preorder Traversal
- LISP - Postorder Traversal
- LISP - Depth First Traversal
- LISP - Modifying Tree
- LISP - Search Tree
- LISP - Binary Tree
- Lisp Hash Table
- LISP - Hash Table
- Adding Values to Hash Table
- Removing Values from Hash Table
- Updating Values of Hash Table
- Iterating Hash Table Entries
- Searching key in HashTable
- Checking Size of HashTable
- Using Custom Equality Check
- Lisp - Input − Output
- LISP - Input − Output
- LISP - Streams
- LISP - Reading Data from Streams
- LISP - Writing Data to Streams
- LISP - File I/O
- LISP - String I/O
- LISP - Formatting with Format
- LISP - Interactive I/O
- LISP - Error Handling
- LISP - Binary I/O
- Lisp - Structures
- LISP - Structures
- LISP - Accessors and Mutators
- LISP - Structure Options
- LISP - Structure Types
- LISP - Applications and Best Practices
- Lisp - CLOS
- LISP - CLOS
- Lisp - Objects
- LISP - Class
- LISP - Slots and Accessors
- LISP - Generic Functions
- LISP - Class Precedence
- LISP - Metaobject Protocol
- LISP - Multimethods
- LISP - Multiple Inheritance
- LISP - Method Combinations
- LISP - Method Combinations
- LISP - :before Method Combination
- LISP - :primary Method Combination
- LISP - :after Method Combination
- LISP - :around Method Combination
- LISP - + Method Combination
- LISP - and Method Combination
- LISP - append Method Combination
- LISP Useful Resources
- Lisp - Quick Guide
- Lisp - Useful Resources
- Lisp - Discussion
Lisp - Debugging
Debugging and tracing is an important aspect of active development in any programming language. LISP provides powerful and extensive debugging tools. In this chapter, we're discussing how to trace and debug applications in LISP.
Error System
Whenever their is any issue during program execution, LISP signal an error similar to exceptions raised in some languages like Java, C++ etc. In case of using an interactive environment like IDE, debugger is automatically enabled and LISP activates the debugger and drops us on the line of error. This way we can inspect and debug the state of the program.
Features of debugger
Backtracing − During debugging phase, a debugger displays the complete sequence of function calls leading to the error. It helps in understanding the execution path.
Variable tracing − We can inspect a variable's value in the backtrace frames. It helps in understanding the failure due to data flow.
Expression Evaluation − In dubugger's frames, we can evaluate arbitrary LISP expressions. This helps in probing the environment and to understand the current state.
Restartability − Debugger provides ways to ignore error and continuation of code execution as well. We can either provide a valid value or ignore error at all or jump to another line of execution.
Stepping and Tracing − Using debugger, we can step through code line by line and trace function executions.
Example - Runtime Error
main.lisp
; define a function to divide numbers (defun divide (a b) (/ a b)) ; calculate function will throw error as y is 0 (defun calculate (x) (let ((y 0)) (divide x y))) ; call calculate with 10 (calculate 10)
Output
When you execute the code, it returns the following result −
/: division by zero
When (calculate 10) is called, it causes an error as divide by zero. In case of debugger tools, it will show a backtrace similar to given below −
ERROR /: division by zero Backtrace: (DIVIDE 10 0) (CALCULATE 10)
In divide frame, we can inspect values of a and b and in Calculate frame, we can inspect x and y. We can even restart the execution by changing the value of b.
Usage of print, format and Logging
Strategic Output − We can use print or format statements at key statements in our code. This is a simple technique to check the flow of code with the data.
Conditional Printing − We can print information on certain conditions using when or if statements.
Logging − We can use Logging libraries for complex application to log information as per severity(info, debug, warn or error).
Tracing
Track Function Calls − tracing using trace is a built-in facility in LISP and allows us to monitor function calls like when a function is entered and exited along with their arguments and return values.
Untracing − Once tracing is done, it is better to untrace once monitoring is no longer needed.
main.lisp
; define a factorial function (defun factorial (n) (if (zerop n) 1 (* n (factorial (1- n))))) ; start tracing of factorial function (trace factorial) (factorial 3) ; stop tracing of factorial function (untrace factorial)
Output
When you execute the code, it returns the following result −
WARNING: TRACE: redefining function FACTORIAL in main.lisp, was defined in top-level ;; Tracing function FACTORIAL. 1. Trace: (FACTORIAL '3) 2. Trace: (FACTORIAL '2) 3. Trace: (FACTORIAL '1) 4. Trace: (FACTORIAL '0) 4. Trace: FACTORIAL ==> 1 3. Trace: FACTORIAL ==> 1 2. Trace: FACTORIAL ==> 2 1. Trace: FACTORIAL ==> 6 WARNING: UNTRACE: redefining function FACTORIAL in main.lisp, was defined in top-level
Here we can check, calls to factorial with arguments and returned value at each step.