anchor.diff:  ;; adjective ::= any unknown token, can be used later.
   ;; noun ::= any unknown token, can be used later.
   ;; ----------------------------------------------
  +;; The goal AST:
  +;; ("verb" (adverbs) (rest-of-predicate) "chat-string"))
  +;; where (rest-of-predicate) is (noun-phrase-1 preposition noun-phrase-2)
  +;; where (noun-phrase) is (noun (modifiers))
  +;;
   ;; !!! TODO - Add everything to the parser.
   ;
  -
  -;;; Ignoring adverbs for now.
  +;;; Ignoring adverbs for now. It's worth noting that I should be able to add them as soon as I know
  +;;; how to parse noun-groups properly and completely.
   
   (defun parse-string (string)
     "Parses a STRING that was entered by PLAYER and returns an Abstract Syntax Tree"
  
positive.code: ;;~~~~~~~~~~~~~~~~~~~~ Parser ~~~~~~~~~~~~~~~~~~;;
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ;; This whole section: string-list goes in, AST comes out.
  ;; A basic parser
  ;; Grammar:
  ;; Command ::= verb [noun-phrase]
  ;; Noun-phrase ::= [article] noun
  ;; article ::= "a" | "an" | "the"
  ;; verb ::= *verbs*
  ;; noun ::= *any object in the scope of player*
  ;; -----------------------------------------------
  ;; The complete parser
  ;; Command ::= (adverb) verb (adverb) (<noun-phrase> (adverb) (preposition <noun-phrase> (adverb)))
  ;; Noun-phrase ::= <noun-group> (preposition <noun-group>)
  ;; noun-group ::= (article) (number) (adjective) pronoun | string
  ;; verb ::= *verbs*
  ;; adverb ::= *adverbs*
  ;; preposition ::= *prepositions*
  
negative.code: 
  (defun parse-command (token-list)
    "Uses a TOKEN-LIST to generate an AST"
    (let ((adverbs nil))
      (cond ((verb-p (car token-list))
  	   (let ((verb (car token-list)))
  	     (if (adverb-p (cadr token-list))
  		 (let ((adverbs (append (list (cadr token-list)) adverbs)))
  		   (multiple-value-bind (noun-phrase token-list) (parse-noun-phrase 
  								    (cddr token-list))
  		     (if (car token-list)
  			 (format t "Don't know what ~a is." (car token-list))
  			 (list verb adverbs noun-phrase nil))))
  		 (multiple-value-bind (noun-phrase token-list) (parse-noun-phrase (cdr token-list))
  		   (if (chat-string-p (car token-list))
  		       (let ((chat-string (car token-list)))
  			 (list verb adverbs noun-phrase chat-string))
  		       (list verb adverbs noun-phrase nil))))))
  	  (t
  	    (format t "Unknown verb: '~a'" (car token-list))))))
  	   
  (defun parse-noun-phrase (token-list)
    "Parses a TOKEN-LIST into an LIST representing a NOUN PHRASE. 
  MULTIPLE RETURN VALUES: NOUN-PHRASE, and REST OF THE TOKEN LIST."
    (multiple-value-bind (noun-group-1 token-list) (parse-noun-group token-list)
      (if (preposition-p (car token-list))
  	(let ((preposition (car token-list)))
  	  (multiple-value-bind (noun-group-2 token-list) (parse-noun-group (cdr token-list))
  	    (values 
  	     (list noun-group-1 preposition noun-group-2)
  	     token-list)))
  	(values (list noun-group-1) token-list))))
  
  (defun parse-noun-group (token-list)
    "Parses a TOKEN-LIST into a NOUN-GROUP."
    (if (pronoun-p (car token-list))
        (values (list (car token-list)) (cdr token-list)) ;if it's a pronoun, we're all set. :)
        (multiple-value-bind (adj-phrase token-list) 
  	  (reverse (parse-adjectival-phrase token-list))
  	(values adj-phrase token-list))))
  
  (defun parse-adjectival-phrase (token-list) ;;OH GOD WHY D:
    "Parses a TOKEN-LIST into an ADJECTIVAL PHRASE."
    (if (not (or (adverb-p (car token-list))
  	       (preposition-p (car token-list))
  	       (null (car token-list))))
        (values (append (list (car token-list)) (parse-adjectival-phrase (cdr token-list))) (cdddr token-list)) 
        nil))
  
  ;; (defun parse-noun-group (token-list) ;;THIS IS THE MOST AWFUL CRAP EVER.
  ;;   "Parses a NOUN-GROUP from a TOKEN LIST.
  ;; Returns a NOUN-GROUP list, and the rest of the token list it didn't parse."
  ;;   (cond ((pronoun-p (car token-list))
  ;; 	 (values (list (car token-list)) (cdr token-list)))
  ;; 	((article-p (car token-list))
  ;; 	 (let ((article (car token-list))
  ;; 	       (token-list (cdr token-list))))
  ;; 	   (cond ((number-qualifier-p (car token-list))
  ;; 		  (let ((number-qualifier (car token-list))
  ;; 			(token-list (cdr token-list)))
  ;; 		    (if (and (not (adverb-p (car token-list)))
  ;; 			     (not (preposition-p (cadr token-list))))
  ;; 			(if ((and (not (adverb-p (cadr token-list)))
  ;; 				  (not (preposition-p (car token-list))))
  ;; 			     (let ((adjective (car token-list))
  ;; 				   (noun (cadr token-list))
  ;; 				   (token-list (cddr token-list)))
  ;; 			       (values (list noun article number-qualifier adjective) token-list))
  ;; 			     (let ((noun (car token-list))
  ;; 				   (token-list (cdr token-list)))
  ;; 			       (values (list noun article number-qualifier) token-list))))
  ;; 			(progn (format t "~a is not a noun or adjective.")
  ;; 			       (values nil nil)))))
  ;; 		 ((
  				  
  (defun chat-string-p (string)
    "Is STRING a CHAT-STRING?."
    (if string 
        (char-equal #\' (char string 0))))
  
  (defun possessive-p (string)
    "Is STRING a POSSESSIVE?"
    (find #\' string :test #'char-equal))
     
  (defun verb-p (string)
    "Is STRING a VERB?"
    (assoc string *verbs* :test #'string-equal))
  