anchor.diff:  
   ;;; Print objects using Protobufs text format
   
  -(defun print-text-format (object &key (stream *standard-output*)
  -                                 (print-name t)
  -                                 (pretty-print t))
  +(defun print-text-format (object &key
  +                                   (indent 0)
  +                                   (stream *standard-output*)
  +                                   (name nil)
  +                                   (print-name t)
  +                                   (pretty-print t))
     "Prints a protocol buffer message to a stream.
   Parameters:
     OBJECT: The protocol buffer message to print.
  +  INDENT: Indent the output by INDENT spaces.
     STREAM: The stream to print to.
  +  NAME: A string. If supplied (and PRINT-NAME is T), this string will be
  +    used as the name in printing.
     PRINT-NAME: Bool for printing the name of the top level proto message.
     PRETTY-PRINT: When true, generate line breaks and other human readable output
       in the text format. When false, replace line breaks with spaces."
  
positive.code:     (macrolet ((read-slot (object slot reader)
                   `(if ,reader
                        (funcall ,reader ,object)
                        (slot-value ,object ,slot))))
        (labels ((has-struct-field-p (object field)
                   ;; If a field doesn't have an offset it's an extension.
                   ;; Call slot-value to avoid generic dispatch.
                   (if (slot-value field 'field-offset)
                       (= (bit (slot-value object '%%is-set)
                               (proto-field-offset field))
                          1)
                       (has-extension object (proto-internal-field-name field))))
                 (do-field (object indent field)
                   ;; We don't do cycle detection here
                   ;; If the client needs it, he can define his own 'print-text-format'
                   ;; method to clean things up first
                   (let* ((type   (proto-class field))
                          (slot   (proto-internal-field-name field))
                          (reader (proto-reader field))
                          msg)
                     (when (has-struct-field-p object field)
                       (cond ((eq (proto-label field) :repeated)
                              (cond ((scalarp type)
                                     (doseq (v (read-slot object slot reader))
                                       (print-scalar v type field stream
                                                     (and pretty-print indent))))
                                    ((typep (setq msg (and type (or (find-message type)
                                                                    (find-enum type)
                                                                    (find-type-alias type))))
                                            'message-descriptor)
                                     (let ((values (if slot
                                                       (read-slot object slot reader)
                                                       (list object))))
                                       (when values
                                         (let ((indent (+ indent 2)))
                                           (dolist (v values)
                                             (if pretty-print
                                                 (format stream "~&~VT~A {~%" indent
                                                         (proto-name field))
                                                 (format stream "~A { " (proto-name field)))
                                             (dolist (f (proto-fields msg))
                                               (do-field v indent f))
                                             (if pretty-print
                                                 (format stream "~&~VT}~%" indent)
                                                 (format stream "} ")))))))
                                    ((typep msg 'enum-descriptor)
                                     (doseq (v (read-slot object slot reader))
                                       (print-enum v msg field stream
                                                   (and pretty-print indent))))
                                    ((typep msg 'protobuf-type-alias)
                                     (let ((type (proto-proto-type msg)))
                                       (doseq (v (read-slot object slot reader))
                                         (let ((v (funcall (proto-serializer msg) v)))
                                           (print-scalar v type field stream
                                                         (and pretty-print indent))))))
                                    (t
                                     (undefined-field-type "While printing ~S to text format,"
                                                           object type field))))
                             (t
                              (cond ((scalarp type)
                                     (let ((v (read-slot object slot reader)))
                                       (print-scalar v type field stream
                                                     (and pretty-print indent))))
                                    ((typep (setq msg (and type (or (find-message type)
                                                                    (find-enum type)
                                                                    (find-type-alias type)
                                                                    (find-map-descriptor type))))
                                            'message-descriptor)
                                     (let ((v (if slot (read-slot object slot reader) object)))
                                       (when v
                                         (let ((indent (+ indent 2)))
                                           (if pretty-print
                                               (format stream "~&~VT~A {~%" indent (proto-name field))
                                               (format stream "~A { " (proto-name field)))
                                           (dolist (f (proto-fields msg))
                                             (do-field v indent f))
                                           (if pretty-print
                                               (format stream "~&~VT}~%" indent)
                                               (format stream "} "))))))
                                    ((typep msg 'enum-descriptor)
                                     (let ((v (read-slot object slot reader)))
                                       (when (and v (not (eql v (proto-default field))))
                                         (print-enum v msg field stream
                                                     (and pretty-print indent)))))
                                    ((typep msg 'protobuf-type-alias)
                                     (let ((v (read-slot object slot reader)))
                                       (when v
                                         (let ((v    (funcall (proto-serializer msg) v))
                                               (type (proto-proto-type msg)))
                                           (print-scalar v type field stream
                                                         (and pretty-print indent))))))
                                    ;; todo(benkuehnert): use specified map format
                                    ((typep msg 'map-descriptor)
                                     (let ((key-class (map-descriptor-key-class msg))
                                           (val-class (map-descriptor-val-class msg))
                                           (val (read-slot object slot reader)))
                                       (if pretty-print
                                           (format stream "~&~VT~A: {~%" (+ 2 indent)
                                                   (proto-name field))
                                           (format stream "~A: {" (proto-name field)))
                                       (flet ((print-entry (k v)
                                                (format stream "~&~VT" (+ 4 indent))
                                                (print-scalar k key-class nil stream nil)
                                                (format stream "-> ")
                                                (if (scalarp val-class)
                                                    (print-scalar v val-class nil stream nil)
                                                    (print-text-format v :stream stream
                                                                         :pretty-print nil))
                                                (format stream "~%")))
                                         (maphash #'print-entry val)
                                         (format stream "~&~VT}" (+ indent 2)))))
  
                                    (t
                                     (undefined-field-type "While printing ~S to text format,"
                                                           object type field)))))))))
          (declare (dynamic-extent #'do-field))
          (if print-name
              (if pretty-print
                  (format stream "~&~A {~%" (proto-name message))
                  (format stream "~A { " (proto-name message)))
              (format stream "{"))
          (dolist (f (proto-fields message))
            (do-field object 0 f))
          (if pretty-print
              (format stream "~&}~%")
              (format stream "}"))
          nil))))
  
  (defun print-scalar (val type field stream indent)
    "Print scalar value to stream
  
negative.code:             do not write a newline."
    (when val
      (if indent
        (format stream "~&~V,0T~A: " (+ indent 2) (proto-name field))
        (format stream "~A: " (proto-name field)))
      (let* ((e (find (keywordify val)
                      (enum-descriptor-values enum)
  