anchor.diff:  			 (progn (skip-to buffer #\:)
   				(read-value buffer))))))
   
  -
   (defun read-partial-object (buffer tree)
     "Reads an object from the buffer, but only when the key matches a key in the tree"
     (declare (type buffer buffer)
   	   (type (or cons nil) tree))
  +  (skip-until* buffer "{")
     (cons :obj
   	(loop until (progn (skip-until* buffer "\"}")
  -			   (eql (read-char buffer) #\}))
  +			   (when (eql (current-char buffer) #\})
  +			     (next-char buffer) T))
   	   append (multiple-value-bind (found-p key)
   		      (read-partial-key buffer tree)
  -		    (progn (skip-to buffer #\:)		
  +		    (progn (skip-to buffer #\:)
   			   (if found-p
   			       (list (cons key (read-value buffer)))
   			       (progn (skip-value buffer) nil)))))))
   
   (defun skip-object (buffer)
  -  "Skips an object from the buffer"
  -  (declare (type buffer buffer))
  -  (loop until (progn (skip-spaces buffer)
  -		     (eql (fetch-char buffer) #\})) ; we may read-char here, as the character is a , to be skipped if it is not a }
  +  "Skips an object from the buffer
  +  PRE: Assumes the buffer's index is at the starting { of the object
  +  POST: The buffer's index is right after the ending } of the object"
  +  (declare (type buffer buffer))
  +  (loop until (progn (skip-until* buffer "\"}")
  +		     (when (eql (current-char buffer) #\})
  +		       (next-char buffer) T))
        do (progn (skip-key buffer)
   	       (skip-value buffer))))
   
   (defun read-partial-key (buffer tree)
  -  "reads a key from the buffer.  Returns (values key T) if the key was found as a valid key in the tree, or (values nil nil) if it was not"
  +  "reads a key from the buffer. 
  +  PRE: Assumes the buffer's index is at the starting \" of the key
  +  POST: Returns (values key T) if the key was found as a valid key in the tree, or (values nil nil) if it was not
  +  POST: The buffer's index is right after the ending \" of the key"
     (declare (type buffer buffer)
   	   (type (or cons nil) tree))
  -  (skip-to buffer #\")
     (multiple-value-bind (accepted-p solution)
         (subseq-tree buffer #\" tree)
       (declare (type (or nil T) accepted-p)
   	     (type simple-string solution))
  -    (skip-to buffer #\") ;; clean up mess
  +    (skip-to/ buffer #\") ;; skip everything we needn't know
       (values accepted-p solution)))
   
   (defun read-key (buffer)
  -  "reads a key from the key-value list"
  +  "Reads a key from the key-value list.
  +  PRE: Assumes the buffer's index is at the starting \" of the key
  +  POST: The buffer's index is right after the ending \" of the key"
     (declare (type buffer buffer))
     (parse-string buffer))
   
   (defun skip-key (buffer)
  -  "reads a key from the key-value list"
  -  (declare (type buffer buffer))
  -  (skip-to buffer #\")
  +  "Skips a key from the key-value list.
  +  PRE: Assumes the buffer's index is at the starting \" of the key
  +  POST: The buffer's index is right after the ending \" of the key"
  +  (declare (type buffer buffer))
     (skip-string buffer))
   
   (defun read-value (buffer)
  
positive.code:     (when solution
        (values (second solution) (first solution)))))
  
  ;;;;;;;;;;;;;;;;;
  ;;;; parsing code
  
  ;; (eval-when (:compile-toplevel)
  ;;  (defconstant +space-characters+ '(#\Return #\Space #\Newline #\Tab #\Linefeed)
  
negative.code:   POST: returns a list containing all read objects
    POST: the buffer's index is right after the ending ]"
    (declare (type buffer buffer))
    (loop 
       until (progn (skip-until* buffer ",][") ; the [ is included as a shortcut for kickstarting the skipping of values.  This could be refactored for a minor speed bump on spaces.
  		  (eql (fetch-char buffer) #\])) ; fetch-char reads the character from the stream, thus forwarding us to the correct position for skip-value and dropping the last #\] from the line.
       collect (progn
  	       (read-value buffer))))
  
  (eval-when (:compile-toplevel)
    (defun create-parse-number-code (&key exponent-p float-p)
  