anchor.diff:    "Return the list form that `mark-or-offset' is inside, or NIL
   if no such form exists."
     (as-offsets ((offset mark-or-offset))
  +    (update-parse syntax 0 offset)
       (let ((form-around (form-around syntax offset)))
  -      (if (and (form-list-p form-around)
  -               (> offset (start-offset form-around)))
  -          form-around
  -          (find-list-parent form-around)))))
  +      (when form-around
  +        (if (and (form-list-p form-around)
  +                 (> offset (start-offset form-around)))
  +            form-around
  +            (find-list-parent form-around))))))
   
   (defun symbol-at-mark (syntax mark-or-offset
                          &optional (form-fetcher 'expression-at-mark))
  
positive.code:     (when (and (not (null potential-form))
                 (not (= (offset mark) (end-offset potential-form))))
  	(setf (offset mark) (end-offset potential-form)))))
  
  (defgeneric forward-one-list (mark syntax)
    (:documentation "Move `mark' forward by one list.
  
negative.code:     (let ((form-around (form-around syntax offset)))
        (when (form-string-p form-around)
          (at-end-of-form-p syntax form-around offset)))))
  
  (defun at-beginning-of-children-p (form mark-or-offset)
    "Return true if `mark-or-offset' structurally is at the
  beginning of (precedes) the children of `form'. True if `form'
  has no children."
    (as-offsets ((offset mark-or-offset))
      (let ((first-child (first (form-children form))))
        (and (null first-child)
             (>= (start-offset first-child) offset)))))
  
  (defun at-end-of-children-p (form mark-or-offset)
    "Return true if `mark-or-offset' structurally is at the end
  of (is preceded by) the children of `form'. True if `form' has no
  children."
    (as-offsets ((offset mark-or-offset))
      (let ((last-child (first (last (form-children form)))))
        (or (null last-child)
            (>= offset (end-offset last-child))))))
  
  (defun structurally-at-beginning-of-list-p (syntax mark-or-offset)
    "Return true if `mark-or-offset' structurally is at the
  beginning of (precedes) the children of the enclosing list. False
  if there is no enclosing list. True if the list has no children."
    (as-offsets ((offset mark-or-offset))
     (let ((enclosing-list (list-at-mark syntax offset)))
       (and enclosing-list (at-beginning-of-children-p enclosing-list offset)))))
  
  (defun structurally-at-end-of-list-p (syntax mark-or-offset)
    "Return true if `mark-or-offset' structurally is at the end
  of (is preceded by) the children of the enclosing list. False if
  there is no enclosing list. True of the list has no children."
    (as-offsets ((offset mark-or-offset))
     (let ((enclosing-list (list-at-mark syntax offset)))
       (and enclosing-list (at-end-of-children-p enclosing-list offset)))))
  
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ;;;
  