auto upstream

9 files changed, 194 insertions, 99 deletions

diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index 5a752fe0c3a..99704a0b532 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,3 +1,55 @@
+2013-02-15  Alan Mackenzie  <acm@muc.de>
+
+        * emacs-lisp/easy-mmode.el (define-globalized-minor-mode): When a
+        global minor mode has been enabled, call the minor mode function
+        for a new buffer once only, after the major mode hook, whilst
+        allowing that hook explicitly to disable the minor mode.
+        (MODE-disable-in-buffer): new (generated) function.
+        (disable-MODE): new (generated) buffer local variable.
+
+2013-02-15  Jambunathan K  <kjambunathan@gmail.com>
+
+        * iswitchb.el (iswitchb-read-buffer): Bind `C-.' and `C-,' to
+        `iswitchb-next-match' and `iswitchb-prev-match' resply.
+
+        * ido.el (ido-init-completion-maps): Bind `C-.' and `C-,' to
+        `ido-next-match' and `ido-prev-match' resply.
+
+        * icomplete.el (icomplete-minibuffer-map): Unbind `C-s' and `C-r'.
+        Bind `C-.' and `C-,' to `icomplete-forward-completions' and
+        `icomplete-backward-completions' (Bug#13708).
+
+2013-02-15  Michael Albinus  <michael.albinus@gmx.de>
+
+        * emacs-lisp/easy-mmode.el (define-minor-mode): Doc fix.
+
+2013-02-15  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * net/goto-addr.el (goto-address-fontify): Add start and end args.
+        (goto-address-fontify-region): Use them instead of narrowing, so
+        syntax-ppss has access to the whole buffer.
+
+2013-02-15  Fabián Ezequiel Gallina  <fgallina@cuca>
+
+        * progmodes/python.el: Explain how to restore "cc-mode"-like
+        forward-sexp movement in header documentation (Bug#13642).
+        (python-nav--forward-sexp): Behave like emacs-lisp-mode in
+        comments and strings (GH bug 114).
+
+2013-02-15  Fabián Ezequiel Gallina  <fgallina@cuca>
+
+        * progmodes/python.el (python-info-current-defun): Fix current
+        defun detection (Bug#13618).
+
+2013-02-15  Chong Yidong  <cyd@gnu.org>
+
+        * xml.el (xml-parse-string): Fix typo in handling of bad character
+        references.
+
+2013-02-15  Glenn Morris  <rgm@gnu.org>
+
+        * play/fortune.el (fortune-compile): Simplify and fix previous change.
+
 2013-02-14  Michael Albinus  <michael.albinus@gmx.de>
 
         * net/tramp.el (tramp-debug-message): Add
diff --git a/lisp/emacs-lisp/easy-mmode.el b/lisp/emacs-lisp/easy-mmode.el
index 9173d148c6a..2088e690228 100644
--- a/lisp/emacs-lisp/easy-mmode.el
+++ b/lisp/emacs-lisp/easy-mmode.el
@@ -132,13 +132,14 @@ BODY contains code to execute each time the mode is enabled or disabled.
 :require SYM    Same as in `defcustom'.
 :variable PLACE The location to use instead of the variable MODE to store
                 the state of the mode.  This can be simply a different
-                named variable, or more generally anything that can be used
-                with the CL macro `setf'.  PLACE can also be of the form
-                \(GET . SET), where GET is an expression that returns the
-                current state, and SET is a function that takes one argument,
-                the new state, and sets it.  If you specify a :variable,
-                this function does not define a MODE variable (nor any of
-                the terms used in :variable).
+                named variable, or a generalized variable.
+                PLACE can also be of the form \(GET . SET), where GET is
+                an expression that returns the current state, and SET is
+                a function that takes one argument, the new state, and
+                sets it.  If you specify a :variable, this function does
+                not define a MODE variable (nor any of the terms used
+                in :variable).
+
 :after-hook     A single lisp form which is evaluated after the mode hooks
                 have been run.  It should not be quoted.
 
@@ -340,9 +341,14 @@ If MODE's set-up depends on the major mode in effect when it was
 enabled, then disabling and reenabling MODE should make MODE work
 correctly with the current major mode.  This is important to
 prevent problems with derived modes, that is, major modes that
-call another major mode in their body."
+call another major mode in their body.
+
+When a major mode is initialized, MODE is actually turned on just
+after running the major mode's hook.  However, MODE is not turned
+on if the hook has explicitly disabled it."
   (declare (doc-string 2))
   (let* ((global-mode-name (symbol-name global-mode))
+         (mode-name (symbol-name mode))
          (pretty-name (easy-mmode-pretty-mode-name mode))
          (pretty-global-name (easy-mmode-pretty-mode-name global-mode))
          (group nil)
@@ -353,6 +359,10 @@ call another major mode in their body."
          (MODE-check-buffers
           (intern (concat global-mode-name "-check-buffers")))
          (MODE-cmhh (intern (concat global-mode-name "-cmhh")))
+         (MODE-disable-in-buffer
+          (intern (concat global-mode-name "-disable-in-buffer")))
+         (minor-MODE-hook (intern (concat mode-name "-hook")))
+         (disable-MODE (intern (concat "disable-" mode-name)))
          (MODE-major-mode (intern (concat (symbol-name mode) "-major-mode")))
          keyw)
 
@@ -396,8 +406,6 @@ See `%s' for more information on %s."
              (progn
                (add-hook 'after-change-major-mode-hook
                          ',MODE-enable-in-buffers)
-               (add-hook 'change-major-mode-after-body-hook
-                         ',MODE-enable-in-buffers)
                (add-hook 'find-file-hook ',MODE-check-buffers)
                (add-hook 'change-major-mode-hook ',MODE-cmhh))
            (remove-hook 'after-change-major-mode-hook ',MODE-enable-in-buffers)
@@ -415,6 +423,10 @@ See `%s' for more information on %s."
        ;; up-to-here.
        :autoload-end
 
+       ;; A function which checks whether MODE has been disabled in the major
+       ;; mode hook which has just been run.
+       (add-hook ',minor-MODE-hook ',MODE-disable-in-buffer)
+
        ;; List of buffers left to process.
        (defvar ,MODE-buffers nil)
 
@@ -423,14 +435,15 @@ See `%s' for more information on %s."
          (dolist (buf ,MODE-buffers)
            (when (buffer-live-p buf)
              (with-current-buffer buf
-               (unless (eq ,MODE-major-mode major-mode)
-                 (if ,mode
-                     (progn
-                       (,mode -1)
-                       (,turn-on)
-                       (setq ,MODE-major-mode major-mode))
-                   (,turn-on)
-                   (setq ,MODE-major-mode major-mode)))))))
+               (if ,disable-MODE
+                   (if ,mode (,mode -1))
+                 (unless (eq ,MODE-major-mode major-mode)
+                   (if ,mode
+                       (progn
+                         (,mode -1)
+                         (,turn-on))
+                     (,turn-on))))
+               (setq ,MODE-major-mode major-mode)))))
        (put ',MODE-enable-in-buffers 'definition-name ',global-mode)
 
        (defun ,MODE-check-buffers ()
@@ -443,7 +456,14 @@ See `%s' for more information on %s."
        (defun ,MODE-cmhh ()
          (add-to-list ',MODE-buffers (current-buffer))
          (add-hook 'post-command-hook ',MODE-check-buffers))
-       (put ',MODE-cmhh 'definition-name ',global-mode))))
+       (put ',MODE-cmhh 'definition-name ',global-mode)
+       ;; disable-MODE is set in MODE-disable-in-buffer and cleared by
+       ;; kill-all-local-variables.
+       (defvar-local ,disable-MODE nil)
+       (defun ,MODE-disable-in-buffer ()
+         (unless ,mode
+           (setq ,disable-MODE t)))
+       (put ',MODE-disable-in-buffer 'definition-name ',global-mode))))
 
 ;;;
 ;;; easy-mmode-defmap
diff --git a/lisp/icomplete.el b/lisp/icomplete.el
index 1f9b4a3afe6..73049df097d 100644
--- a/lisp/icomplete.el
+++ b/lisp/icomplete.el
@@ -168,8 +168,8 @@ except those on this list.")
   (let ((map (make-sparse-keymap)))
     (define-key map [?\M-\t] 'minibuffer-force-complete)
     (define-key map [?\C-j]  'minibuffer-force-complete-and-exit)
-    (define-key map [?\C-s]  'icomplete-forward-completions)
-    (define-key map [?\C-r]  'icomplete-backward-completions)
+    (define-key map [?\C-.]  'icomplete-forward-completions)
+    (define-key map [?\C-,]  'icomplete-backward-completions)
     map))
 
 (defun icomplete-forward-completions ()
diff --git a/lisp/ido.el b/lisp/ido.el
index 008561aa268..066d8276af5 100644
--- a/lisp/ido.el
+++ b/lisp/ido.el
@@ -1585,6 +1585,8 @@ This function also adds a hook to the minibuffer."
     (define-key map "\C-p" 'ido-toggle-prefix)
     (define-key map "\C-r" 'ido-prev-match)
     (define-key map "\C-s" 'ido-next-match)
+    (define-key map [?\C-.] 'ido-next-match)
+    (define-key map [?\C-,] 'ido-prev-match)
     (define-key map "\C-t" 'ido-toggle-regexp)
     (define-key map "\C-z" 'ido-undo-merge-work-directory)
     (define-key map [(control ?\s)] 'ido-restrict-to-matches)
diff --git a/lisp/iswitchb.el b/lisp/iswitchb.el
index 93d589c7706..68749f1b012 100644
--- a/lisp/iswitchb.el
+++ b/lisp/iswitchb.el
@@ -471,6 +471,8 @@ interfere with other minibuffer usage.")
     (define-key map "?" 'iswitchb-completion-help)
     (define-key map "\C-s" 'iswitchb-next-match)
     (define-key map "\C-r" 'iswitchb-prev-match)
+    (define-key map [?\C-.] 'iswitchb-next-match)
+    (define-key map [?\C-,] 'iswitchb-prev-match)
     (define-key map "\t" 'iswitchb-complete)
     (define-key map "\C-j" 'iswitchb-select-buffer-text)
     (define-key map "\C-t" 'iswitchb-toggle-regexp)
diff --git a/lisp/net/goto-addr.el b/lisp/net/goto-addr.el
index 1005285917e..59e4da16619 100644
--- a/lisp/net/goto-addr.el
+++ b/lisp/net/goto-addr.el
@@ -156,18 +156,19 @@ A value of t means there is no limit--fontify regardless of the size."
 
 (defvar goto-address-prog-mode)
 
-(defun goto-address-fontify ()
+(defun goto-address-fontify (&optional start end)
   "Fontify the URLs and e-mail addresses in the current buffer.
 This function implements `goto-address-highlight-p'
 and `goto-address-fontify-p'."
   ;; Clean up from any previous go.
-  (goto-address-unfontify (point-min) (point-max))
+  (goto-address-unfontify (or start (point-min)) (or end (point-max)))
   (save-excursion
     (let ((inhibit-point-motion-hooks t))
-      (goto-char (point-min))
+      (goto-char (or start (point-min)))
       (when (or (eq t goto-address-fontify-maximum-size)
-                (< (- (point-max) (point)) goto-address-fontify-maximum-size))
-        (while (re-search-forward goto-address-url-regexp nil t)
+                (< (- (or end (point-max)) (point))
+                   goto-address-fontify-maximum-size))
+        (while (re-search-forward goto-address-url-regexp end t)
           (let* ((s (match-beginning 0))
                  (e (match-end 0))
                  this-overlay)
@@ -187,8 +188,8 @@ and `goto-address-fontify-p'."
               (overlay-put this-overlay
                            'keymap goto-address-highlight-keymap)
               (overlay-put this-overlay 'goto-address t))))
-        (goto-char (point-min))
-        (while (re-search-forward goto-address-mail-regexp nil t)
+        (goto-char (or start (point-min)))
+        (while (re-search-forward goto-address-mail-regexp end t)
           (let* ((s (match-beginning 0))
                  (e (match-end 0))
                  this-overlay)
@@ -212,11 +213,9 @@ and `goto-address-fontify-p'."
 (defun goto-address-fontify-region (start end)
   "Fontify URLs and e-mail addresses in the given region."
   (save-excursion
-    (save-restriction
-      (let ((beg-line (progn (goto-char start) (line-beginning-position)))
-            (end-line (progn (goto-char end) (line-end-position))))
-        (narrow-to-region beg-line end-line)
-        (goto-address-fontify)))))
+    (let ((beg-line (progn (goto-char start) (line-beginning-position)))
+          (end-line (progn (goto-char end) (line-end-position))))
+      (goto-address-fontify beg-line end-line))))
 
 ;; code to find and goto addresses; much of this has been blatantly
 ;; snarfed from browse-url.el
diff --git a/lisp/play/fortune.el b/lisp/play/fortune.el
index 0920012b280..cb58c0d0af0 100644
--- a/lisp/play/fortune.el
+++ b/lisp/play/fortune.el
@@ -244,17 +244,14 @@ the value of `fortune-file'.  This currently cannot handle directories."
   (let* ((fortune-file (expand-file-name (substitute-in-file-name file)))
          (fortune-dat (expand-file-name
                        (substitute-in-file-name
-                        (concat fortune-file fortune-database-extension))))
-         (fortune-dat-exist (file-exists-p fortune-dat)))
-    (cond ((file-exists-p fortune-file)
-           (if (or (not fortune-dat-exist)
-                   (and fortune-dat-exist
-                        (file-newer-than-file-p fortune-file fortune-dat)))
-               (message "Compiling new fortune database %s" fortune-dat)
-             (shell-command
-              (concat fortune-strfile fortune-strfile-options
-                      " " fortune-file fortune-quiet-strfile-options))))
-          (t (error "Can't compile fortune file %s" fortune-file)))))
+                        (concat fortune-file fortune-database-extension)))))
+  (cond ((file-exists-p fortune-file)
+         (cond ((file-newer-than-file-p fortune-file fortune-dat)
+                (message "Compiling new fortune database %s" fortune-dat)
+                (shell-command
+                 (concat fortune-strfile fortune-strfile-options
+                         " " fortune-file fortune-quiet-strfile-options)))))
+        (t (error "Can't compile fortune file %s" fortune-file)))))
 
 
 ;;; **************
diff --git a/lisp/progmodes/python.el b/lisp/progmodes/python.el
index 35c5ba19e33..eadb06fa61e 100644
--- a/lisp/progmodes/python.el
+++ b/lisp/progmodes/python.el
@@ -54,8 +54,13 @@
 ;; `python-nav-beginning-of-statement', `python-nav-end-of-statement',
 ;; `python-nav-beginning-of-block' and `python-nav-end-of-block' are
 ;; included but no bound to any key.  At last but not least the
-;; specialized `python-nav-forward-sexp' allows easy
-;; navigation between code blocks.
+;; specialized `python-nav-forward-sexp' allows easy navigation
+;; between code blocks.  If you prefer `cc-mode'-like `forward-sexp'
+;; movement, setting `forward-sexp-function' to nil is enough, You can
+;; do that using the `python-mode-hook':
+
+;; (add-hook 'python-mode-hook
+;;           (lambda () (setq forward-sexp-function nil)))
 
 ;; Shell interaction: is provided and allows you to execute easily any
 ;; block of code of your current buffer in an inferior Python process.
@@ -1349,13 +1354,10 @@ backwards."
                            're-search-backward))
            (context-type (python-syntax-context-type)))
       (cond
-       ((eq context-type 'string)
+       ((memq context-type '(string comment))
         ;; Inside of a string, get out of it.
-        (while (and (funcall re-search-fn "[\"']" nil t)
-                    (python-syntax-context 'string))))
-       ((eq context-type 'comment)
-        ;; Inside of a comment, just move forward.
-        (python-util-forward-comment dir))
+        (let ((forward-sexp-function))
+          (forward-sexp dir)))
        ((or (eq context-type 'paren)
             (and forward-p (looking-at (python-rx open-paren)))
             (and (not forward-p)
@@ -1378,16 +1380,16 @@ backwards."
                 (save-excursion
                   (python-nav-lisp-forward-sexp-safe dir)
                   (point)))
-              (next-sexp-context
-               (save-excursion
-                 (goto-char next-sexp-pos)
-                 (cond
-                  ((python-info-beginning-of-block-p) 'block-start)
-                  ((python-info-end-of-block-p) 'block-end)
-                  ((python-info-beginning-of-statement-p) 'statement-start)
-                  ((python-info-end-of-statement-p) 'statement-end)
-                  ((python-info-statement-starts-block-p) 'starts-block)
-                  ((python-info-statement-ends-block-p) 'ends-block)))))
+               (next-sexp-context
+                (save-excursion
+                  (goto-char next-sexp-pos)
+                  (cond
+                   ((python-info-beginning-of-block-p) 'block-start)
+                   ((python-info-end-of-block-p) 'block-end)
+                   ((python-info-beginning-of-statement-p) 'statement-start)
+                   ((python-info-end-of-statement-p) 'statement-end)
+                   ((python-info-statement-starts-block-p) 'starts-block)
+                   ((python-info-statement-ends-block-p) 'ends-block)))))
           (if forward-p
               (cond ((and (not (eobp))
                           (python-info-current-line-empty-p))
@@ -1411,8 +1413,8 @@ backwards."
                     (t (goto-char next-sexp-pos)))
             (cond ((and (not (bobp))
                         (python-info-current-line-empty-p))
-                     (python-util-forward-comment dir)
-                     (python-nav--forward-sexp dir))
+                   (python-util-forward-comment dir)
+                   (python-nav--forward-sexp dir))
                   ((eq context 'block-end)
                    (python-nav-beginning-of-block))
                   ((eq context 'statement-end)
@@ -2946,40 +2948,61 @@ Optional argument INCLUDE-TYPE indicates to include the type of the defun.
 This function is compatible to be used as
 `add-log-current-defun-function' since it returns nil if point is
 not inside a defun."
-    (save-restriction
-      (widen)
-      (save-excursion
-        (end-of-line 1)
-        (let ((names)
-              (starting-indentation
-               (save-excursion
-                 (and
-                  (python-nav-beginning-of-defun 1)
-                  ;; This extra number is just for checking code
-                  ;; against indentation to work well on first run.
-                  (+ (current-indentation) 4))))
-              (starting-point (point)))
-          ;; Check point is inside a defun.
-          (when (and starting-indentation
-                     (< starting-point
+  (save-restriction
+    (widen)
+    (save-excursion
+      (end-of-line 1)
+      (let ((names)
+            (starting-indentation (current-indentation))
+            (starting-pos (point))
+            (first-run t)
+            (last-indent)
+            (type))
+        (catch 'exit
+          (while (python-nav-beginning-of-defun 1)
+            (when (and
+                   (or (not last-indent)
+                       (< (current-indentation) last-indent))
+                   (or
+                    (and first-run
                          (save-excursion
-                           (python-nav-end-of-defun)
-                           (point))))
-            (catch 'exit
-              (while (python-nav-beginning-of-defun 1)
-                (when (< (current-indentation) starting-indentation)
-                  (setq starting-indentation (current-indentation))
-                  (setq names
-                        (cons
-                         (if (not include-type)
-                             (match-string-no-properties 1)
-                           (mapconcat 'identity
-                                      (split-string
-                                       (match-string-no-properties 0)) " "))
-                         names)))
-                (and (= (current-indentation) 0) (throw 'exit t)))))
-          (and names
-               (mapconcat (lambda (string) string) names "."))))))
+                           ;; If this is the first run, we may add
+                           ;; the current defun at point.
+                           (setq first-run nil)
+                           (goto-char starting-pos)
+                           (python-nav-beginning-of-statement)
+                           (beginning-of-line 1)
+                           (looking-at-p
+                            python-nav-beginning-of-defun-regexp)))
+                    (< starting-pos
+                       (save-excursion
+                         (let ((min-indent
+                                (+ (current-indentation)
+                                   python-indent-offset)))
+                           (if (< starting-indentation  min-indent)
+                               ;; If the starting indentation is not
+                               ;; within the min defun indent make the
+                               ;; check fail.
+                               starting-pos
+                             ;; Else go to the end of defun and add
+                             ;; up the current indentation to the
+                             ;; ending position.
+                             (python-nav-end-of-defun)
+                             (+ (point)
+                                (if (>= (current-indentation) min-indent)
+                                    (1+ (current-indentation))
+                                  0))))))))
+              (setq last-indent (current-indentation))
+              (if (or (not include-type) type)
+                  (setq names (cons (match-string-no-properties 1) names))
+                (let ((match (split-string (match-string-no-properties 0))))
+                  (setq type (car match))
+                  (setq names (cons (cadr match) names)))))
+            ;; Stop searching ASAP.
+            (and (= (current-indentation) 0) (throw 'exit t))))
+        (and names
+             (concat (and type (format "%s " type))
+                     (mapconcat 'identity names ".")))))))
 
 (defun python-info-current-symbol (&optional replace-self)
   "Return current symbol using dotty syntax.
diff --git a/lisp/xml.el b/lisp/xml.el
index 2232746f02a..a3d34670bfb 100644
--- a/lisp/xml.el
+++ b/lisp/xml.el
@@ -611,7 +611,7 @@ references."
                    xml-validating-parser
                    (error "XML: (Validity) Invalid character reference `%s'"
                           (match-string 0)))
-              (replace-match (or (string val) xml-undefined-entity) t t))
+              (replace-match (if val (string val) xml-undefined-entity) t t))
           ;; For an entity reference, search again from the start of
           ;; the replaced text, since the replacement can contain
           ;; entity or character references, or markup.
@@ -620,7 +620,7 @@ references."
           (and (null val)
                xml-validating-parser
                (error "XML: (Validity) Undefined entity `%s'" ref))
-          (replace-match (cdr val) t t)
+          (replace-match (or (cdr val) xml-undefined-entity) t t)
           (goto-char (match-beginning 0)))
         ;; Check for XML bombs.
         (and xml-entity-expansion-limit