anchor.diff:  
   ;;; Writers
   
  -(defun translate-char (char style)
  -  (ecase char
  -    (#\0 (get-digit 0 style))
  -    (#\1 (get-digit 1 style))
  -    (#\2 (get-digit 2 style))
  -    (#\3 (get-digit 3 style))
  -    (#\4 (get-digit 4 style))
  -    (#\5 (get-digit 5 style))
  -    (#\6 (get-digit 6 style))
  -    (#\7 (get-digit 7 style))
  -    (#\8 (get-digit 8 style))
  -    (#\9 (get-digit 9 style))))
  +(defun print-positional (stream object style digits-after-dot scale)
  +  (let* ((trim-zero? (and (floatp object)
  +			  (not digits-after-dot)))
  +	 (digits-after-dot (or digits-after-dot
  +			       (- +power-min+)))
  +	 (scale (or scale 0))
  +	 (lispstr
  +	  (ctypecase object
  +	    (integer (format nil "~D" object))
  +	    (ratio (format nil "~A" object))
  +	    (float (format nil "~,v,vF" digits-after-dot scale object)))))
  +    (when trim-zero?
  +      (setf lispstr (string-right-trim '(#\0) lispstr)))
  +    (loop for c across lispstr
  +       as jp-str = 
  +       (case c
  +	 (#\0 (get-digit 0 style))
  +	 (#\1 (get-digit 1 style))
  +	 (#\2 (get-digit 2 style))
  +	 (#\3 (get-digit 3 style))
  +	 (#\4 (get-digit 4 style))
  +	 (#\5 (get-digit 5 style))
  +	 (#\6 (get-digit 6 style))
  +	 (#\7 (get-digit 7 style))
  +	 (#\8 (get-digit 8 style))
  +	 (#\9 (get-digit 9 style))
  +	 (#\. (string (get-radix-point-char style))) ; TODO: use decimal-mark arg.
  +	 (#\- (get-minus-sign style))
  +	 (#\/ (get-parts-of style))
  +	 ((#\d #\e #\f #\l #\s)
  +	  (assert nil (c)
  +		  "Exponent marker '~C' is found. This is an internal BUG of jp-numeral." c))
  +	 (otherwise
  +	  (error 'bad-format-float-error)))
  +       do (write-string jp-str stream))))
   
   
   (defun make-digits4-string (digits4 style)
  
positive.code: 	    finally
  	    (setf printed sum)
  	    (return i))
  	 do (case style
  	      (:positional
  	       (write-string (get-digit current-digit style) stream))
  	      (otherwise
  	       (when (/= 0 current-digit)
  		 (write-string (get-digit current-digit style) stream)
  		 (write-string (get-power power style) stream))))
  	 while (and (< printed frac-part)
  		    (< fp-error current-scale))))))
  			 
  
negative.code: 
  (defun print-jp-integer (stream object style)
    (declare (type (integer 0) object))
    (loop with strs = nil
       for power from 0 by 4
       for (rest digits4) = (multiple-value-list (floor object 10000))
       then (multiple-value-list (floor rest 10000))
       as digits4-str = (make-digits4-string digits4 style)
       as power-str = (if (plusp power)
  			(get-power power style) nil)
       when (plusp (length digits4-str))
       do (when power-str
  	  (push power-str strs))
       and do (push digits4-str strs)
       while (> rest 0)
       finally (mapc #'(lambda (s) (write-string s stream)) strs)))
  
  
  (defun print-fraction (stream object style digits-after-dot scale)
    (declare (type float object))
    (let* ((ratio (if digits-after-dot
  		    (rational object)
  		    (rationalize object)))
  	 ;; -- support 100000000000000.1d0
  	 (fp-error (multiple-value-bind (_scaled expon _sign)
  		       (integer-decode-float object)
  		     (declare (ignore _scaled _sign))
  