CODEWITHSUNDEEP
fileparsingcommon-lispsbcl
chez93
chez93

Reputation: 149

In Common Lisp (SBCL) how do you parse a file?

I have a file: test.lisp with this content:

(+ 3 3)

(let ((n 3)) (+ n 1))

(let ((n 4))
  (+ n 1))

(defun d (f)
  (let ((n 3)
    (f 4)
    (g 3))
    (if (= n 0)
    (+ n f g)
      (* n f g))))

I am trying to read the file like this:

  (let ((in (open dd)))
   (when in 
    (loop for line = (read-line in nil)
     while line do (format t "~a~%" line))
     (close in)))

which gives me the apparent correct output:

(+ 3 3)

(let ((n 3)) (+ n 1))

(let ((n 4))
  (+ n 1))

(defun d (f)
  (let ((n 3)
    (f 4)
    (g 3))
    (if (= n 0)
    (+ n f g)
      (* n f g))))

I want to call my function parse-exp on each line of the file corresponding to each expression above.

From a different answer here on Stackoverflow I tried to do this:

* (defun get-file (filename)
   (let ((in (open filename)))
    (loop for line = (read-line in nil)
     while line
     collect line)))
GET-FILE
* (get-file dd)
("(+ 3 3)" "" "(let ((n 3)) (+ n 1))" "" "(let ((n 4))" "  (+ n 1))" ""
 "(defun d (f)" "  (let ((n 3)" "   (f 4)" "    (g 3))" "    (if (= n 0)"
 "  (+ n f g)" "      (* n f g))))")

which converts each line to a string and its not in the format that I want.

I also tried doing this:

(uiop:read-file-lines "file.txt")

but I get the same output as the previous example.

I want to be able to use each line/expression as input to parse-exp - like this:

(parse-exp '(+ 3 3)) or (parse-exp '(let ((n 3)) (+ n 1))) and so on.

How do I do this?

Thanks.

Upvotes: 0

Views: 555

Answers (2)

Rainer Joswig
Rainer Joswig

Reputation: 139251

Common Lisp has a bunch of functions to deal with that:

  • read reads an s-expression from a stream.
  • read-from-string reads an s-expression from a string
  • print, prin1 and pprint prints an s-expression. The latter pretty prints it.
  • eval evaluates an s-expression.
  • with-open-file is a macro which opens and closes a file as a stream
  • with-input-from-string is a macro which creates a stream, so that one can read from that string

Upvotes: 0

Gwang-Jin Kim
Gwang-Jin Kim

Reputation: 9865

What you search for is read instead of read-line which reads expression-wise (and is used by lisp interpreters).

(with-open-file (stream "test1.lisp")
  (loop for expr = (read stream nil 'eof)
    until (eq expr 'eof)
    collect expr))
;; ((+ 3 3) (LET ((N 3)) (+ N 1)) (LET ((N 4)) (+ N 1))
;; (DEFUN D (F) (LET ((N 3) (F 4) (G 3)) (IF (= N 0) (+ N F G) (* N F G)))))
;; every element is an expression.

If you want the expressions to be strings instead of list of symbols, use (format nil "~a" ...):

(with-open-file (stream "test1.lisp")
  (loop for expr = (read stream nil 'eof)
    until (eq expr 'eof)
    collect (format nil "~a" expr)))
;; ("(+ 3 3)" "(LET ((N 3)) (+ N 1))" "(LET ((N 4)) (+ N 1))"
;;  "(DEFUN D (F) (LET ((N 3) (F 4) (G 3)) (IF (= N 0) (+ N F G) (* N F G))))")

Upvotes: 4

Related Questions