anchor.diff:  		     (invalid-number-value c)
                        (invalid-number-reason c)))))
   
  -(defparameter *whitespace-characters*
  -  '(#\space #\tab #\return #\newline)
  -  "A list of whitespace characters.")
  -
  -(defparameter *exponent-markers*
  -  '(#\D #\E #\L #\F #\S)
  -  "A list of all of the exponent markers in uppercase.")
  -
  -(defparameter *zero* (make-parsed-integer 0 0)
  -  "The zero parsed integer.")
  -
  -(defun digit-char-value (char)
  -  "Returns the value of an alphabetical
  -   character if it were to be used as a digit."
  -  (+ 10
  -     (- (char-code (char-upcase char))
  -        (char-code #\A))))
  -
  -(defun exponent-markers (radix)
  -  "Return a list of all of the valid exponent markers in the given
  -   radix."
  -  (remove-if-not (lambda (c)
  -                   (>= (digit-char-value c)
  -                       radix))
  -                 *exponent-markers*))
  -
  -(defun exponent-marker-p (char &optional (radix 10))
  -  "Is the given character an exponent marker in the given radix?"
  -  (find (char-upcase char) (exponent-markers radix)))
  -
  -(defun whitespace-p (x)
  -  "Is the given character a white space character?"
  -  (find x *whitespace-characters*))
  -
  -(defun valid-p (char radix)
  -  "Is the character valid in the given radix?"
  -  (or (digit-char-p char radix)
  -      (exponent-marker-p char radix)
  -      (find char '(#\. #\/))))
  -
   (defun invalid-number (string reason)
     "Given a string for a value and a reason, signal an 'invalid-number'
      error with the given arguments."
     (error 'invalid-number :value string :reason reason))
  +
  +(defun parse-trimmed-number (string radix)
  +  "Parse any number out of a string that has been trimmed."
  +  ;; This mostly handles complex numbers.
  +  (or (and (eql (char string 0) #\#)
  +	   (eql (char-upcase (char string 1)) #\C)
  +	   (let ((pos-left  (position #\( string))
  +		 (pos-right (position #\) string)))
  +	     (if (not (and pos-left pos-right (< pos-left pos-right)
  +			   (eql (count #\( string) 1)
  +			   (eql (count #\) string) 1)))
  +		 (invalid-number string "Mismatched parenthesis")
  +		 (let* ((starting-left (position-if-not #'whitespace-p string :start (+ pos-left 1)))
  +			(delimiting-left (position-if #'whitespace-p string :start starting-left))
  +			(starting-right (position-if-not #'whitespace-p string :end pos-right :from-end t))
  +			(delimiting-right (position-if #'whitespace-p string :end starting-right :from-end t)))
  +		   (complex
  +		    (parse-real-number string :start starting-left :end delimiting-left :radix radix)
  +		    (parse-real-number string :start delimiting-right :end (+ starting-right 1) :radix radix))))))
  +      (parse-real-number string :radix radix)))
   
   (defun parse-trimmed-positive-real-number (string radix)
     "Parse a positive real number from a string that has been trimmed."
  
positive.code: (defun invalid-last-char (char radix)
    "Is this character valid except at the end of a number?"
    (or (exponent-marker-p char radix) (eql char #\/)))
  
  (defun split-and-parse (string radix &rest points)
    "Given a string of integers and a list of locations in beteween
  
negative.code:      (,regular (string-trim *whitespace-characters* (subseq string start end))
  	       radix)))
  
  (deftrimmer parse-number parse-trimmed-number)
  (deftrimmer parse-real-number parse-trimmed-real-number)
  (deftrimmer parse-positive-real-number parse-trimmed-positive-real-number)
  