anchor.diff:  
   (defun arc (cx cy r theta1 theta2)
     (loop while (< theta2 theta1) do (incf theta2 (* 2 pi)))
  -  (let ((curves
  -         (approximate-elliptical-arc cx cy r r 0 theta1 theta2)))
  -    (draw-arc-curves curves)))
  -
  -
  -(defun draw-arc-curves (curves)
  -  (destructuring-bind (((startx . starty) &rest ignored-curve)
  -                       &rest ignored-curves)
  -      curves
  -    (declare (ignore ignored-curve ignored-curves))
  -    (let ((path (paths:create-path :open-polyline)))
  +  (let ((path (paths:create-path :open-polyline)))
  +    (multiple-value-bind (startx starty) (ellipse-val cx cy r r 0 theta1)
         (paths:path-reset path (paths:make-point startx starty))
  -      (loop for ((x1 . y1)
  -		 (cx1 . cy1)
  -		 (cx2 . cy2)
  -		 (x2 . y2)) in curves
  -	 do (curve-to path cx1 cy1 cx2 cy2 x2 y2))
  +      (draw-approximate-elliptical-arc path cx cy r r 0 theta1 theta2)
         path)))
  -
  -
  -(defun curve-to (path cx1 cy1 cx2 cy2 x y)
  -  (%curve-to path cx1 cy1 cx2 cy2 x y))
  -
  -(defun %curve-to (path cx1 cy1 cx2 cy2 x y)
  -  "Draw a cubic Bezier curve from the current point to (x,y)
  -through two control points."
  -  (let ((control-point-1 (paths:make-point cx1 cy1))
  -        (control-point-2 (paths:make-point cx2 cy2))
  -        (end-point (paths:make-point x y)))
  -    (paths:path-extend path
  -                       (paths:make-bezier-curve (list control-point-1
  -                                                      control-point-2))
  -                       end-point)))
   
   (defun ellipse-arc (cx cy rx ry theta eta1 eta2)
     (loop while (< eta2 eta1) do (incf eta2 (* 2 pi)))
  -  (let ((curves (approximate-elliptical-arc cx cy rx ry theta eta1 eta2)))
  -    (draw-arc-curves curves)))
  +  (let ((path (paths:create-path :open-polyline)))
  +    (multiple-value-bind (startx starty) (ellipse-val cx cy rx ry theta eta1)
  +      (paths:path-reset path (paths:make-point startx starty))
  +      (draw-approximate-elliptical-arc path cx cy rx ry theta eta1 eta2)
  +      path)))
  
positive.code:    (+ (* (- a) (sin theta) (sin eta))
        (* b (cos theta) (cos eta)))))
  
  ;;; FIXME: The original elbeno code used real abstraction to manage
  ;;; points and curves and splines. I ripped it out and replaced it
  ;;; with the following ugly mess. Fix, fix, fix. For example, it might
  ;;; be possible to use cl-vectors to accumulate the path instead of
  ;;; using lists of conses.
  
  (defun approximate-arc-single (cx cy a b theta eta1 eta2)
    (let* ((etadiff (- eta2 eta1))
           (k (tan (/ etadiff 2)))
           (alpha (* (sin etadiff)
  
negative.code:           qy1 (+ py1 (* alpha sy1))
            qx2 (- px2 (* alpha sx2))
            qy2 (- py2 (* alpha sy2)))
      (curve-to path qx1 qy1 qx2 qy2 px2 py2)))
  
  (defun draw-approximate-arc (path cx cy a b theta eta1 eta2 err)
    (cond ((< eta2 eta1)
           (error "approximate-arc: eta2 must be bigger than eta1"))
          ((> eta2 (+ eta1 (/ pi 2) (* eta2 long-float-epsilon)))
           (let ((etamid (+ eta1 (/ pi 2) (* eta2 long-float-epsilon))))
             (draw-approximate-arc path cx cy a b theta eta1 etamid err)
             (draw-approximate-arc path cx cy a b theta etamid eta2 err)))
          (t (if (> err (bezier-error a b eta1 eta2))
  	       (draw-approximate-arc-single path cx cy a b theta eta1 eta2)
                 (let ((etamid (/ (+ eta1 eta2) 2)))
                   (draw-approximate-arc path cx cy a b theta eta1 etamid err)
                   (draw-approximate-arc path cx cy a b theta etamid eta2 err))))))
  
  (defun draw-approximate-elliptical-arc (path cx cy a b theta eta1 eta2
                                     &optional (err 0.5))
    "Draw an approximate an elliptical arc with a cubic bezier spline into the path."
    (if (> b a)
        (draw-approximate-arc path cx cy b a
  			    (+ theta (/ pi 2))
  			    (- eta1 (/ pi 2))
  			    (- eta2 (/ pi 2)) err)
        (draw-approximate-arc path cx cy a b theta eta1 eta2 err)))
  
  ;;;
  ;;;
  