Common Lisp Error Not Understood

I'm trying to write a number guessing game in Lisp as a time-killing project. However, when I try to load up the program using SBCL, I get the following error:

debugger invoked on a SB-C::INPUT-ERROR-IN-COMPILE-FILE in thread #<THREAD
                                                                    "initial thread" RUNNING
                                                                    {AA14959}>:
  READ failure in COMPILE-FILE at character 477:
    end of file on #<SB-SYS:FD-STREAM
                     for "file /home/andy/Dropbox/Programming/Common Lisp/number-game.lisp"
                     {B4F45F9}>

Type HELP for debugger help, or (SB-EXT:QUIT) to exit from SBCL.

restarts (invokable by number or by possibly-abbreviated name):
  0: [CONTINUE] Ignore runtime option --load "number-game.lisp".
  1: [ABORT   ] Skip rest of --eval and --load options.
  2:            Skip to toplevel READ/EVAL/PRINT loop.
  3: [QUIT    ] Quit SBCL (calling #'QUIT, killing the process).

(SB-C::READ-FOR-COMPILE-FILE
 #<SB-SYS:FD-STREAM
   for "file /home/andy/Dropbox/Programming/Common Lisp/number-game.lisp"
   {B4F45F9}>
 477)

What does this error mean? The code is as follows, and the error appears when loading the file and calling (play) from the REPL:

;;;; number-game.lisp
;;;;
;;;; Andrew Levenson
;;;; 10/25/2010
;;;;
;;;; Simple number guessing game. User has
;;;; five guesses to determine a number between
;;;; one and one hundred, inclusive (1-100).

;;; Set global variable for the target number:
(defparameter *target* nil) 

;;; Set the iterator so we may check the number of guesses
(defparameter *number-of-guesses* 0)

;开发者_StackOverflow;; Welcome the user
(defun welcome-user ()
    (format t "Welcome to the number guessing game!~%"))

;;; Prompt for a guess
(defun prompt-for-guess ()
    (format t "Please enter your guess (1-100): ")
    (finish-output nil) ; nil directs finish-output to standard IO
    (check-guess((read-guess)))

;;; Read in a guess
(defun read-guess ()
    (let ((guess (read)))
        (if (numberp guess) ; If true, return guess. Else, call prompt-for-guess
            (progn
                (setq *number-of-guesses* (+ *number-of-guesses* 1))
                guess)
            (prompt-for-guess))))

;;; Check if the guess is higher than, lower than, or equal to, the target
(defun check-guess (guess)
    (if (equal guess *target*)
        (equal-to)
        (if (> guess *target*)
            (greater-than (guess))
            (if (< guess *target*)
                (less-than (guess))))))

;;; If the guess is equal to the target, the game is over
(defun equal-to ()
    (format t "Congratulations! You have guessed the target number, ~a!~%" *target*)
    (y-or-n-p "Play again? [y/n] "))

;;; If the guess is greater than the target, inform the player.
(defun greater-than (guess)
    (format t "Sorry, ~a is greater than the target.~%" guess)
    (if (< *number-of-guesses* 6)
        (prompt-for-guess)
        (game-over)))

;;; If the guess is less than the target, inform the player.
(defun less-than (guess)
    (format t "Sorry, ~a is less than the target.~%" guess)
    (if (< *number-of-guesses* 6)
        (prompt-for-guess)
        (game-over)))

;;; If the player has run out of guesses, give them the option
;;; of playing the game again.
(defun game-over ()
    (y-or-n-p "You have run out of guesses. Play again? [y/n] "))


;;; Play the game
(defun play ()
    ;; If it's their first time playing this session,
    ;; make sure to greet the user.
    (unless (> *number-of-guesses* 0)
        (welcome-user))
    ;; Reset their remaining guesses
    (setq *number-of-guesses* 0)
    ;; Set the target value
    (setq *target*
        ;; Random can return float values,
        ;; so we must round the result to get
        ;; an integer value.
        (round
            ;; Add one to the result, because
            ;; (random 100) yields a number between
            ;; 0 and 99, whereas we want a number
            ;; from 1 to 100 inclusive.
            (+ (random 100) 1)))
    (if (equal (prompt-for-guess) "y")
        (play)
        (quit)))

(I'm fairly certain that the program doesn't work minus that one error, I'm still a complete novice when it comes to Lisp. This is just the first error I've encountered that I can't figure out on my own.)

Oh, and the issue most likely has to do with the prompt-for-guess, read-guess and check-guess functions, because those were the ones I was messing with when this error cropped up.

---

It looks like you didn't close enough parens on your prompt-for-guess defun.

The reader is getting to the end of the file and noticing that it has a form still open, and can't figure out where it's from.

An easy way I use to find errors like this is to have my text editor indent the region, and make sure everything lines up like I think it should.

---

The command in Emacs is M-x check-parens (it checks everything that needs to balance, like quotes, as well). It can be a bit mystifying if everything balances, because it does nothing in that case.

check-parens Command: Check for unbalanced parentheses in the current buffer. More accurately, check the narrowed part of the buffer for unbalanced expressions ("sexps") in general. This is done according to the current syntax table and will find unbalanced brackets or quotes as appropriate. (See Info node `(emacs)Parentheses'.) If imbalance is found, an error is signaled and point is left at the first unbalanced character.

---

end of file during read, there is a closing parenthesis (or similar) missing. Character 477. Move the cursor in your text to 477 and check which expression it is.

Check your IDE for a command to find unbalanced expressions.

In LispWorks this would be M-x Find Unbalanced Parentheses.

SLIME should have some command for that, too.