anchor.diff:  (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)))
  -	 (skip-spaces buffer)
   	 (read-partial-object buffer (build-character-tree ,@keywords-to-read)))
         whole))
   
  
positive.code:     (next-char buffer)
      r))
  
  (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))
  
  (defmacro set-read-number-part (currently-reading buffer &body body)
    (case currently-reading
      (:whole `(let ((whole-number number))
  	       (declare (type integer whole-number))
  	       ,@body))
      (:float `(let ((float number)
  		   (float-digits (mark-length ,buffer)))
  	       (declare (type integer float)
  			(type integer float-digits))
  	       ,@body))
      (:exponent `(let ((exp number))
  		  (declare (type integer exp))
  		  ,@body))))
  
  (defmacro read-number* (buffer &key (currently-reading :whole) (exponent-p T) (float-p T) (float-delimiters ".") (exp-delimiters "eE") (number-delimiters ",]} "))
  
negative.code: 	    (if accepted-p (subseq-buffer-mark buffer) ""))))
  
  (defun read-object (buffer)
    "reads an object, starting with { and ending with } into a in internal jsown object"
    (declare (type buffer buffer))
    (skip-until* buffer "{")
    (cons :obj
  	(loop until (progn (skip-until* buffer "\"}") ; a string or the end of the objects are our only interests
  			   (eql (current-char buffer) #\}))
  	   collect (cons (read-key buffer) ; we know that the first character is the " of the key
  			 (progn (skip-to buffer #\:)
  