anchor.diff:      (next-char buffer)
       r))
   
  -(defun create-parse-number-code (&key exponent-p float-p)
  -  "Creates the code to parse a number.
  +(eval-when (:compile-toplevel)
  +  (defun create-parse-number-code (&key exponent-p float-p)
  +    "Creates the code to parse a number.
     It is assumed that the whole number is placed in an accessible variable whole-number, available at runtime. 
     If exponent-p is non-nil it is assumed that the exponent is placed in the variable exp, available at runtime.
     If float-p is non-nil it is assumed that the float is placed in the variable float, available at runtime.
     If float-p is non-nil it is assumed that the amount of numbers in the float is placed in the variable float-digits, available at runtime."
  -  (let ((code 'whole-number))
  -    (when float-p ; floats must be taken care of first
  -      (setf code `(+ ,code (/ float (expt 10 float-digits)))))
  -    (when exponent-p ; both floats and complete numbers must be multiplied by (expt 10 exp) in for the e part of the number
  -      (setf code `(* ,code (expt 10 exp))))
  -    code))
  +    (cond ((and exponent-p float-p)
  +	   `(* negate-number
  +	       (+ whole-number
  +		  (/ float (expt 10 float-digits)))
  +	       (expt 10 (* negate-exp exp))))
  +	  (exponent-p
  +	   `(* negate-number
  +	       whole-number
  +	       (expt 10 (* negate-exp exp))))
  +	  (float-p
  +	   `(* negate-number
  +	       (+ whole-number
  +		  (/ float (expt 10 float-digits)))))
  +	  (T
  +	   `(* negate-number
  +	       whole-number)))))
   
   (defmacro set-read-number-part (currently-reading buffer &body body)
     (case currently-reading
       (:whole `(let ((whole-number number))
  -	       (declare (type integer whole-number))
  +	       (declare (type fixnum whole-number))
   	       ,@body))
       (:float `(let ((float number)
   		   (float-digits (mark-length ,buffer)))
  -	       (declare (type integer float)
  -			(type integer float-digits))
  +	       (declare (type fixnum float)
  +			(type fixnum float-digits))
   	       ,@body))
       (:exponent `(let ((exp number))
  -		  (declare (type integer exp))
  +		  (declare (type fixnum exp))
   		  ,@body))))
   
   (defmacro read-number* (buffer &key (currently-reading :whole) (exponent-p T) (float-p T) (float-delimiters ".") (exp-delimiters "eE") (number-delimiters ",]} "))
  
positive.code:   (declare (type buffer buffer)
  	   (type (or cons nil) tree))
    (cons :obj
  	(loop until (progn (skip-spaces buffer)
  			   (eql (fetch-char buffer) #\})) ; we may fetch-char here, as the character is a #\, to be skipped if it is not a #\}
  	   append (multiple-value-bind (found-p key)
  		      (read-partial-key buffer tree)
  		    (progn (skip-to buffer #\:)		
  
negative.code: (define-compiler-macro parse (&whole whole string &rest keywords-to-read) ; this allows the character tree to be precompiled
    (if keywords-to-read
        `(let ((buffer (build-buffer ,string)))
  	 (read-partial-object buffer (build-character-tree ,@keywords-to-read)))
        whole))
  
  