Allow visiting files with malformed prop-lines.

* files.el (inhibit-first-line-modes-regexps): Add image files.
(hack-local-variables-prop-line): Return nil for malformed prop-lines.

Fixes: debbugs:9044

diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index 6b83f7c1c77c080f6d12f2f43b2d4926e7958407..a62a846d172d990ec028b089b445a3a1a75c1401 100644 (file)
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,3 +1,9 @@
+2011-09-18  Chong Yidong  <cyd@stupidchicken.com>
+
+       * files.el (inhibit-first-line-modes-regexps): Add image files.
+       (hack-local-variables-prop-line): Return nil for malformed
+       prop-lines (Bug#9044).
+
 2011-09-18  Michael Albinus  <michael.albinus@gmx.de>
 
        * net/tramp.el (top): Don't require 'shell.

diff --git a/lisp/files.el b/lisp/files.el
index 5ca9af6783d54fe26514a0d4b8dfb01afd865a8f..b29c0596d7b1244e004fca696514fe31b56064a4 100644 (file)
--- a/lisp/files.el
+++ b/lisp/files.el
@@ -2461,7 +2461,9 @@ of a script, mode MODE is enabled.
 
 See also `auto-mode-alist'.")
 
-(defvar inhibit-first-line-modes-regexps (mapcar 'purecopy '("\\.tar\\'" "\\.tgz\\'"))
+(defvar inhibit-first-line-modes-regexps
+  (mapcar 'purecopy '("\\.tar\\'" "\\.tgz\\'" "\\.tiff?\\'"
+                     "\\.gif\\'" "\\.png\\'" "\\.jpe?g\\'"))
   "List of regexps; if one matches a file name, don't look for `-*-'.")
 
 (defvar inhibit-first-line-modes-suffixes nil
@@ -2952,60 +2954,62 @@ Returns an alist of elements (VAR . VAL), where VAR is a variable
 and VAL is the specified value.  Ignores any specification for
 `mode:' and `coding:' (which should have already been handled
 by `set-auto-mode' and `set-auto-coding', respectively).
-Throws an error if the -*- line is malformed.
+Return nil if the -*- line is malformed.
 
 If MODE-ONLY is non-nil, just returns the symbol specifying the
 mode, if there is one, otherwise nil."
-  (save-excursion
-    (goto-char (point-min))
-    (let ((end (set-auto-mode-1))
-         result)
-      (cond ((not end)
-            nil)
-           ((looking-at "[ \t]*\\([^ \t\n\r:;]+\\)\\([ \t]*-\\*-\\)")
-            ;; Simple form: "-*- MODENAME -*-".
-            (if mode-only
-                (intern (concat (match-string 1) "-mode"))))
-           (t
-            ;; Hairy form: '-*-' [ <variable> ':' <value> ';' ]* '-*-'
-            ;; (last ";" is optional).
-            ;; If MODE-ONLY, just check for `mode'.
-            ;; Otherwise, parse the -*- line into the RESULT alist.
-            (while (and (or (not mode-only)
-                            (not result))
-                        (< (point) end))
-              (or (looking-at "[ \t]*\\([^ \t\n:]+\\)[ \t]*:[ \t]*")
-                  (error "Malformed -*- line"))
-              (goto-char (match-end 0))
-              ;; There used to be a downcase here,
-              ;; but the manual didn't say so,
-              ;; and people want to set var names that aren't all lc.
-              (let* ((key (intern (match-string 1)))
-                     (val (save-restriction
-                            (narrow-to-region (point) end)
-                            (let ((read-circle nil))
-                              (read (current-buffer)))))
-                     ;; It is traditional to ignore
-                     ;; case when checking for `mode' in set-auto-mode,
-                     ;; so we must do that here as well.
-                     ;; That is inconsistent, but we're stuck with it.
-                     ;; The same can be said for `coding' in set-auto-coding.
-                     (keyname (downcase (symbol-name key))))
-                (if mode-only
-                    (and (equal keyname "mode")
-                         (setq result
-                               (intern (concat (downcase (symbol-name val))
-                                               "-mode"))))
-                  (or (equal keyname "coding")
-                      (condition-case nil
-                          (push (cons (cond ((eq key 'eval) 'eval)
-                                            ;; Downcase "Mode:".
-                                            ((equal keyname "mode") 'mode)
-                                            (t (indirect-variable key)))
-                                      val) result)
-                        (error nil))))
-                (skip-chars-forward " \t;")))
-            result)))))
+  (catch 'malformed-line
+    (save-excursion
+      (goto-char (point-min))
+      (let ((end (set-auto-mode-1))
+           result)
+       (cond ((not end)
+              nil)
+             ((looking-at "[ \t]*\\([^ \t\n\r:;]+\\)\\([ \t]*-\\*-\\)")
+              ;; Simple form: "-*- MODENAME -*-".
+              (if mode-only
+                  (intern (concat (match-string 1) "-mode"))))
+             (t
+              ;; Hairy form: '-*-' [ <variable> ':' <value> ';' ]* '-*-'
+              ;; (last ";" is optional).
+              ;; If MODE-ONLY, just check for `mode'.
+              ;; Otherwise, parse the -*- line into the RESULT alist.
+              (while (and (or (not mode-only)
+                              (not result))
+                          (< (point) end))
+                (unless (looking-at "[ \t]*\\([^ \t\n:]+\\)[ \t]*:[ \t]*")
+                  (message "Malformed mode-line")
+                  (throw 'malformed-line nil))
+                (goto-char (match-end 0))
+                ;; There used to be a downcase here,
+                ;; but the manual didn't say so,
+                ;; and people want to set var names that aren't all lc.
+                (let* ((key (intern (match-string 1)))
+                       (val (save-restriction
+                              (narrow-to-region (point) end)
+                              (let ((read-circle nil))
+                                (read (current-buffer)))))
+                       ;; It is traditional to ignore
+                       ;; case when checking for `mode' in set-auto-mode,
+                       ;; so we must do that here as well.
+                       ;; That is inconsistent, but we're stuck with it.
+                       ;; The same can be said for `coding' in set-auto-coding.
+                       (keyname (downcase (symbol-name key))))
+                  (if mode-only
+                      (and (equal keyname "mode")
+                           (setq result
+                                 (intern (concat (downcase (symbol-name val))
+                                                 "-mode"))))
+                    (or (equal keyname "coding")
+                        (condition-case nil
+                            (push (cons (cond ((eq key 'eval) 'eval)
+                                              ;; Downcase "Mode:".
+                                              ((equal keyname "mode") 'mode)
+                                              (t (indirect-variable key)))
+                                        val) result)
+                          (error nil))))
+                  (skip-chars-forward " \t;")))
+              result))))))
 
 (defun hack-local-variables-filter (variables dir-name)
   "Filter local variable settings, querying the user if necessary.