(with-input-from-string (stream "Welcome to Tutorials Point!")
   (print (read-char stream))
   (print (read-char stream))
   (print (read-char stream))
   (print (read-char stream))
   (print (read-char stream))
   (print (read-char stream))
   (print (read-char stream))
   (print (read-char stream))
   (print (read-char stream))
   (print (read-char stream))
   (print (peek-char nil stream nil  the-end))
   (values)
)

When you execute the code, it returns the following result −

#W 
#e 
#l 
#c 
#o 
#m 
#e 
#Space 
#	 
#o 
#Space 

The Output Functions

All output functions in LISP take an optional argument called output-stream, where the output is sent. If not mentioned or nil, output-stream defaults to the value of the variable *standard-output*.

The following table provides the most commonly used output functions of LISP −

Example

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

; this program inputs a numbers and doubles it
(defun DoubleNumber()
   (terpri)
   (princ "Enter Number : ")
   (setq n1 (read))
   (setq doubled (* 2.0 n1))
   (princ "The Number: ")
   (write n1)
   (terpri)
   (princ "The Number Doubled: ")
   (write doubled)
)
(DoubleNumber)

When you execute the code, it returns the following result −

Enter Number : 3456.78 (STDIN Input)
The Number: 3456.78
The Number Doubled: 6913.56

Formatted Output

The function format is used for producing nicely formatted text. It has the following syntax −

format destination control-string &rest arguments

where,

destination is standard output

control-string holds the characters to be output and the printing directive.

A format directive consists of a tilde (~), optional prefix parameters separated by commas, optional colon (:) and at-sign (@) modifiers, and a single character indicating what kind of directive this is.

The prefix parameters are generally integers, notated as optionally signed decimal numbers.

The following table provides brief description of the commonly used directives −

Example

Let us rewrite the program calculating a circle s area −

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

(defun AreaOfCircle()
   (terpri)
   (princ "Enter Radius: ")
   (setq radius (read))
   (setq area (* 3.1416 radius radius))
   (format t "Radius: = ~F~% Area = ~F" radius area)
)
(AreaOfCircle)

When you execute the code, it returns the following result −

Enter Radius: 10.234 (STDIN Input)
Radius: = 10.234
Area = 329.03473

LISP - File I/O

We have discussed about how standard input and output is handled by common LISP. All these functions work for reading from and writing into text and binary files too. Only difference is in this case the stream we use is not standard input or output, but a stream created for the specific purpose of writing into or reading from files.

In this chapter we will see how LISP can create, open, close text or binary files for their data storage.

A file represents a sequence of bytes, does not matter if it is a text file or binary file. This chapter will take you through important functions/macros for the file management.

Opening Files

You can use the open function to create a new file or to open an existing file. It is the most basic function for opening a file. However, the with-open-file is usually more convenient and more commonly used, as we will see later in this section.

When a file is opened, a stream object is constructed to represent it in the LISP environment. All operations on the stream are basically equivalent to operations on the file.

Syntax for the open function is −

open filename &key :direction :element-type :if-exists :if-does-not-exist :external-format

where,

The filename argument is the name of the file to be opened or created.

The keyword arguments specify the type of stream and error handpng ways.

The :direction keyword specifies whether the stream should handle input, output, or both, it takes the following values −

:input - for input streams (default value)

:output - for output streams

:io - for bidirectional streams

:probe - for just checking a files existence; the stream is opened and then closed.

The :element-type specifies the type of the unit of transaction for the stream.

The :if-exists argument specifies the action to be taken if the :direction is :output or :io and a file of the specified name already exists. If the direction is :input or :probe, this argument is ignored. It takes the following values −

:error - it signals an error.

:new-version - it creates a new file with the same name but larger version number.

:rename - it renames the existing file.

:rename-and-delete - it renames the existing file and then deletes it.

:append - it appends to the existing file.

:supersede - it supersedes the existing file.

nil - it does not create a file or even a stream just returns nil to indicate failure.

The :if-does-not-exist argument specifies the action to be taken if a file of the specified name does not already exist. It takes the following values −

:error - it signals an error.

:create - it creates an empty file with the specified name and then uses it.

nil - it does not create a file or even a stream, but instead simply returns nil to indicate failure.

The :external-format argument specifies an implementation-recognized scheme for representing characters in files.

For example, you can open a file named myfile.txt stored in the /tmp folder as −

(open "/tmp/myfile.txt")

Writing to and Reading from Files

The with-open-file allows reading or writing into a file, using the stream variable associated with the read/write transaction. Once the job is done, it automatically closes the file. It is extremely convenient to use.

It has the following syntax −

with-open-file (stream filename {options}*)
   {declaration}* {form}*

filename is the name of the file to be opened; it may be a string, a pathname, or a stream.

The options are same as the keyword arguments to the function open.

Example 1

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

(with-open-file (stream "/tmp/myfile.txt" :direction :output)
   (format stream "Welcome to Tutorials Point!")
   (terpri stream)
   (format stream "This is a tutorials database")
   (terpri stream)
   (format stream "Submit your Tutorials, White Papers and Articles into our Tutorials   Directory.")
)

Please note that all input-output functions discussed in the previous chapter, such as, terpri and format are working for writing into the file we created here.

When you execute the code, it does not return anything; however, our data is written into the file. The :direction :output keywords allows us do this.

However, we can read from this file using the read-pne function.

Example 2

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

(let ((in (open "/tmp/myfile.txt" :if-does-not-exist nil)))
   (when in
      (loop for pne = (read-pne in nil)
      
      while pne do (format t "~a~%" pne))
      (close in)
   )
)

When you execute the code, it returns the following result −

Welcome to Tutorials Point!
This is a tutorials database
Submit your Tutorials, White Papers and Articles into our Tutorials Directory.

Closing File

The close function closes a stream.

LISP - Structures

Structures are one of the user-defined data type, which allows you to combine data items of different kinds.

Structures are used to represent a record. Suppose you want to keep track of your books in a pbrary. You might want to track the following attributes about each book −

Title

Author

Subject

Book ID

Defining a Structure

The defstruct macro in LISP allows you to define an abstract record structure. The defstruct statement defines a new data type, with more than one member for your program.

To discuss the format of the defstruct macro, let us write the definition of the Book structure. We could define the book structure as −

(defstruct book 
   title 
   author 
   subject 
   book-id 
)

Please note

The above declaration creates a book structure with four named components. So every book created will be an object of this structure.

It defines four functions named book-title, book-author, book-subject and book-book-id, which will take one argument, a book structure, and will return the fields title, author, subject and book-id of the book object. These functions are called the access functions.

The symbol book becomes a data type and you can check it using the typep predicate.

There will also be an imppcit function named book-p, which is a predicate and will be true if its argument is a book and is false otherwise.

Another imppcit function named make-book will be created, which is a constructor, which, when invoked, will create a data structure with four components, suitable for use with the access functions.

The #S syntax refers to a structure, and you can use it to read or print instances of a book.

An imppcit function named copy-book of one argument is also defined that. It takes a book object and creates another book object, which is a copy of the first one. This function is called the copier function.

You can use setf to alter the components of a book, for example

(setf (book-book-id book3) 100)

Example

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

(defstruct book 
   title 
   author 
   subject 
   book-id 
)

( setq book1 (make-book :title "C Programming"
   :author "Nuha Ap" 
   :subject "C-Programming Tutorial"
   :book-id "478")
)

( setq book2 (make-book :title "Telecom Bilpng"
   :author "Zara Ap" 
   :subject "C-Programming Tutorial"
   :book-id "501")
) 

(write book1)
(terpri)
(write book2)
(setq book3( copy-book book1))
(setf (book-book-id book3) 100) 
(terpri)
(write book3)

#S(BOOK :TITLE "C Programming" :AUTHOR "Nuha Ap" :SUBJECT "C-Programming Tutorial" :BOOK-ID "478")
#S(BOOK :TITLE "Telecom Bilpng" :AUTHOR "Zara Ap" :SUBJECT "C-Programming Tutorial" :BOOK-ID "501")
#S(BOOK :TITLE "C Programming" :AUTHOR "Nuha Ap" :SUBJECT "C-Programming Tutorial" :BOOK-ID 100)

(defpackage :package-name
   (:use :common-psp ...)
   (:export :symbol1 :symbol2 ...)
)

make-package package-name &key :nicknames :use

(make-package :tom)
(make-package :dick)
(make-package :harry)
(in-package tom)
(defun hello () 
   (write-pne "Hello! This is Tom s Tutorials Point")
)

(hello)
(in-package dick)
(defun hello () 
   (write-pne "Hello! This is Dick s Tutorials Point")
)

(hello)
(in-package harry)
(defun hello () 
   (write-pne "Hello! This is Harry s Tutorials Point")
)

(hello)
(in-package tom)
(hello)
(in-package dick)
(hello)
(in-package harry)
(hello)

Hello! This is Tom s Tutorials Point
Hello! This is Dick s Tutorials Point
Hello! This is Harry s Tutorials Point

(make-package :tom)
(make-package :dick)
(make-package :harry)
(in-package tom)
(defun hello () 
   (write-pne "Hello! This is Tom s Tutorials Point")
)

(in-package dick)
(defun hello () 
   (write-pne "Hello! This is Dick s Tutorials Point")
)

(in-package harry)
(defun hello () 
   (write-pne "Hello! This is Harry s Tutorials Point")
)

(in-package tom)
(hello)
(in-package dick)
(hello)
(in-package harry)
(hello)
(delete-package tom)
(in-package tom)
(hello)

Hello! This is Tom s Tutorials Point
Hello! This is Dick s Tutorials Point
Hello! This is Harry s Tutorials Point
*** - EVAL: variable TOM has no value

(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.

(defclass class-name (superclass-name*)
   (slot-description*)
   class-option*))

(defclass Box () 
   (length 
   breadth 
   height)
)

(defclass Box ()
   ((length :accessor length)
      (breadth :accessor breadth)
      (height :accessor height)
   )
)

(defclass Box ()
   ((length :reader get-length :writer set-length)
      (breadth :reader get-breadth :writer set-breadth)
      (height :reader get-height :writer set-height)
   )
)

(make-instance class {initarg value}*)

(defclass box ()
   ((length :accessor box-length)
      (breadth :accessor box-breadth)
      (height :accessor box-height)
   )
)
(setf item (make-instance  box))
(setf (box-length item) 10)
(setf (box-breadth item) 10)
(setf (box-height item) 5)
(format t "Length of the Box is ~d~%" (box-length item))
(format t "Breadth of the Box is ~d~%" (box-breadth item))
(format t "Height of the Box is ~d~%" (box-height item))

Length of the Box is 10
Breadth of the Box is 10
Height of the Box is 5

(defclass box ()
   ((length :accessor box-length)
      (breadth :accessor box-breadth)
      (height :accessor box-height)
      (volume :reader volume)
   )
)

; method calculating volume   

(defmethod volume ((object box))
   (* (box-length object) (box-breadth object)(box-height object))
)

 ;setting the values 

(setf item (make-instance  box))
(setf (box-length item) 10)
(setf (box-breadth item) 10)
(setf (box-height item) 5)

; displaying values

(format t "Length of the Box is ~d~%" (box-length item))
(format t "Breadth of the Box is ~d~%" (box-breadth item))
(format t "Height of the Box is ~d~%" (box-height item))
(format t "Volume of the Box is ~d~%" (volume item))

Length of the Box is 10
Breadth of the Box is 10
Height of the Box is 5
Volume of the Box is 500

(defclass box ()
   ((length :accessor box-length)
      (breadth :accessor box-breadth)
      (height :accessor box-height)
      (volume :reader volume)
   )
)

; method calculating volume   
(defmethod volume ((object box))
   (* (box-length object) (box-breadth object)(box-height object))
)
  
;wooden-box class inherits the box class  
(defclass wooden-box (box)
((price :accessor box-price)))

;setting the values 
(setf item (make-instance  wooden-box))
(setf (box-length item) 10)
(setf (box-breadth item) 10)
(setf (box-height item) 5)
(setf (box-price item) 1000)

; displaying values
(format t "Length of the Wooden Box is ~d~%" (box-length item))
(format t "Breadth of the Wooden Box is ~d~%" (box-breadth item))
(format t "Height of the Wooden Box is ~d~%" (box-height item))
(format t "Volume of the Wooden Box is ~d~%" (volume item))
(format t "Price of the Wooden Box is ~d~%" (box-price item))

Length of the Wooden Box is 10
Breadth of the Wooden Box is 10
Height of the Wooden Box is 5
Volume of the Wooden Box is 500
Price of the Wooden Box is 1000