anchor.diff:  
   (defmethod asdf:action-description ((op link-op) (c asdf:component))
     (format nil "~@<linking ~3i~_~A~@:>" c))
  +
  +#+:verbose
  +(defmethod asdf:perform :before (op component)
  +  (v:trace :abcd.build "~a" (asdf:action-description op component)))
  
positive.code:   NIL)
  
  (defmethod execute ((op link-op) inputs outputs)
    (let ((output (first outputs)))
      (when (cdr outputs)
        (warn "Don't know how to use multiple outputs with ~a" op))
      (apply (operation-compiler-function op) T inputs output
             (merge-flags (operation-direct-flags op)
                          (operation-effective-flags op)))))
  
  (defun preprocess-system (system &rest args &key flags force force-not verbose version &allow-other-keys)
    (declare (ignore force force-not verbose version))
    (apply 'asdf:operate (make-instance 'preprocess-op :flags flags) system args)
    T)
  
  (defun assemble-system (system &rest args &key flags force force-not verbose version &allow-other-keys)
    (declare (ignore force force-not verbose version))
    (apply 'asdf:operate (make-instance 'assemble-op :flags flags) system args)
    T)
  
  (defun link-system (system &rest args &key flags force force-not verbose version &allow-other-keys)
    (declare (ignore force force-not verbose version))
    (apply 'asdf:operate (make-instance 'link-op :flags flags) system args)
    T)
  
  (defmethod asdf:action-description ((op preprocess-op) (c asdf:component))
    (format nil "~@<preprocessing ~3i~_~A~@:>" c))
  
negative.code: 
  (in-package #:org.shirakumo.abcd)
  
  (defvar *default-flags* '(:warnings :all))
  
  (define-asdf/interface-class c-compiler-op (asdf:operation)
    ((direct-flags :initarg :flags :accessor operation-direct-flags)
     (effective-flags :initform *default-flags* :accessor operation-effective-flags)
     (compiler-function :initarg :compiler-function :accessor operation-compiler-function)
     (compiler :initarg :compiler :accessor operation-compiler))
    (:default-initargs
     :flags ()
     :compiler NIL
     :compiler-function #'c-compile))
  
  (defmethod execute ((op c-compiler-op) inputs outputs)
    (let ((flags (merge-flags (operation-direct-flags op)
                              (operation-effective-flags op))))
      (loop for input in inputs
            for output in outputs
            do (apply (operation-compiler-function op)
                      (or (operation-compiler op) T)
                      (minimal-shell-namestring input)
                      (minimal-shell-namestring output)
                      flags))))
  
  (define-asdf/interface-class compute-flags-op (asdf:upward-operation)
    ())
  
  (defmethod asdf:operation-done-p ((op compute-flags-op) component)
    NIL)
  
  (defmethod asdf:perform ((op compute-flags-op) component)
    NIL)
  
  (define-asdf/interface-class preprocess-op (c-compiler-op asdf:selfward-operation asdf:sideway-operation)
    ((asdf:selfward-operation :initform 'compute-flags-op :allocation :class))
    (:default-initargs
     :compiler-function #'c-preprocess))
  
  