Recent bug in insert-directory.

[Luc Teirlinck]

If you do not have "-a" in `dired-listing-switches', an empty directory
gets listed in a Dired buffer as:

  /home/teirllm/empty:
  total used in directory 0 available 21863712
//DIRED-OPTIONS// --quoting-style=(null)

The last line looks weird.  This must be a very recent bug, or I would
have noticed it sooner.  The code in `insert-directory' apparently does
no longer take into account that for an empty directory we get:

[bash2.05b.0 ~ 3 2] ls -l --dired empty
  total 0
//DIRED-OPTIONS// --quoting-style=(null)

without any //DIRED// line.

Or is this just because my version of ls is too old?

The patch below fixes the bug.  However, I am not familiar with the
"error" stuff that led to the recent changes that introduced the bug.
I am not sure whether or not the "error problem" can occur for an
empty directory, listed without "-a".  If not, the patch below should
be sufficient.  Otherwise, additional (or other) changes would be needed.

===File ~/files.el-diff=====================================
*** files.el    04 Jan 2005 16:51:47 -0600      1.742
--- files.el    08 Jan 2005 22:22:27 -0600      
***************
*** 4550,4594 ****
          (when (if (stringp switches)
                    (string-match "--dired\\>" switches)
                  (member "--dired" switches))
            (forward-line -2)
              (when (looking-at "//SUBDIRED//")
                (delete-region (point) (progn (forward-line 1) (point)))
                (forward-line -1))
!           (when (looking-at "//DIRED//")
!             (let ((end (line-end-position))
!                   (linebeg (point))
!                   error-lines)
!               ;; Find all the lines that are error messages,
!               ;; and record the bounds of each one.
!               (goto-char beg)
!               (while (< (point) linebeg)
!                 (or (eql (following-char) ?\s)
!                     (push (list (point) (line-end-position)) error-lines))
!                 (forward-line 1))
!               (setq error-lines (nreverse error-lines))
!               ;; Now read the numeric positions of file names.
!               (goto-char linebeg)
!               (forward-word 1)
!               (forward-char 3)
!               (while (< (point) end)
!                 (let ((start (insert-directory-adj-pos
                                (+ beg (read (current-buffer)))
!                               error-lines))
!                       (end (insert-directory-adj-pos
!                             (+ beg (read (current-buffer)))
!                             error-lines)))
!                   (if (memq (char-after end) '(?\n ?\ ))
!                       ;; End is followed by \n or by " -> ".
!                       (put-text-property start end 'dired-filename t)
!                     ;; It seems that we can't trust ls's output as to
!                     ;; byte positions of filenames.
!                     (put-text-property beg (point) 'dired-filename nil)
!                     (end-of-line))))
!               (goto-char end)
!               (beginning-of-line)
!               (delete-region (point) (progn (forward-line 1) (point))))
!             (if (looking-at "//DIRED-OPTIONS//")
!                 (delete-region (point) (progn (forward-line 1) (point))))))
  
          ;; Now decode what read if necessary.
          (let ((coding (or coding-system-for-read
--- 4550,4603 ----
          (when (if (stringp switches)
                    (string-match "--dired\\>" switches)
                  (member "--dired" switches))
+           ;; The following overshoots by one line for an empty
+           ;; directory listed with "--dired", but without "-a"
+           ;; switch, where the ls output contains a
+           ;; "//DIRED-OPTIONS//" line, but no "//DIRED//" line.
+           ;; We take care of that case later.
            (forward-line -2)
              (when (looking-at "//SUBDIRED//")
                (delete-region (point) (progn (forward-line 1) (point)))
                (forward-line -1))
!           (if (looking-at "//DIRED//")
!               (let ((end (line-end-position))
!                     (linebeg (point))
!                     error-lines)
!                 ;; Find all the lines that are error messages,
!                 ;; and record the bounds of each one.
!                 (goto-char beg)
!                 (while (< (point) linebeg)
!                   (or (eql (following-char) ?\s)
!                       (push (list (point) (line-end-position)) error-lines))
!                   (forward-line 1))
!                 (setq error-lines (nreverse error-lines))
!                 ;; Now read the numeric positions of file names.
!                 (goto-char linebeg)
!                 (forward-word 1)
!                 (forward-char 3)
!                 (while (< (point) end)
!                   (let ((start (insert-directory-adj-pos
!                                 (+ beg (read (current-buffer)))
!                                 error-lines))
!                         (end (insert-directory-adj-pos
                                (+ beg (read (current-buffer)))
!                               error-lines)))
!                     (if (memq (char-after end) '(?\n ?\ ))
!                         ;; End is followed by \n or by " -> ".
!                         (put-text-property start end 'dired-filename t)
!                       ;; It seems that we can't trust ls's output as to
!                       ;; byte positions of filenames.
!                       (put-text-property beg (point) 'dired-filename nil)
!                       (end-of-line))))
!                 (goto-char end)
!                 (beginning-of-line)
!                 (delete-region (point) (progn (forward-line 1) (point))))
!             ;; Take care of the case where the ls output contains a
!             ;; "//DIRED-OPTIONS//"-line, but no "//DIRED//"-line
!             ;; and we went one line too far back (see above.)
!             (forward-line 1))
!           (if (looking-at "//DIRED-OPTIONS//")
!               (delete-region (point) (progn (forward-line 1) (point)))))
  
          ;; Now decode what read if necessary.
          (let ((coding (or coding-system-for-read
============================================================