[Emacs-diffs] master 5b8be58 2/2: Merge branch 'master' of git.sv.gnu.org:/srv/git/emacs

[Michael Albinus]

branch: master
commit 5b8be5809eff0f644c3484a2a110a8812236f518
Merge: 16f14a4 95fb826
Author: Michael Albinus <address@hidden>
Commit: Michael Albinus <address@hidden>

    Merge branch 'master' of git.sv.gnu.org:/srv/git/emacs
---
 lisp/gnus/gnus-sum.el       |  1 +
 lisp/progmodes/cc-engine.el | 57 +++++++++++++++++++++++++++++++++++++++++----
 src/image.c                 | 12 +++++-----
 3 files changed, 60 insertions(+), 10 deletions(-)

diff --git a/lisp/gnus/gnus-sum.el b/lisp/gnus/gnus-sum.el
index 556fb63..31958ff 100644
--- a/lisp/gnus/gnus-sum.el
+++ b/lisp/gnus/gnus-sum.el
@@ -42,6 +42,7 @@
 (defvar gnus-tmp-indentation)
 (defvar gnus-tmp-level)
 (defvar gnus-tmp-lines)
+(defvar gnus-tmp-name)
 (defvar gnus-tmp-number)
 (defvar gnus-tmp-opening-bracket)
 (defvar gnus-tmp-process)
diff --git a/lisp/progmodes/cc-engine.el b/lisp/progmodes/cc-engine.el
index 41bab27..c0f044d 100644
--- a/lisp/progmodes/cc-engine.el
+++ b/lisp/progmodes/cc-engine.el
@@ -4491,6 +4491,30 @@ comment at the start of cc-engine.el for more info."
                       (goto-char pos))))))
       (< (point) start)))
 
+(defun c-end-of-token (&optional back-limit)
+  ;; Move to the end of the token we're just before or in the middle of.
+  ;; BACK-LIMIT may be used to bound the backward search; if given it's
+  ;; assumed to be at the boundary between two tokens.  Return non-nil if the
+  ;; point is moved, nil otherwise.
+  ;;
+  ;; This function might do hidden buffer changes.
+  (let ((start (point)))
+    (cond ;; ((< (skip-syntax-backward "w_" (1- start)) 0)
+     ;;  (skip-syntax-forward "w_"))
+     ((> (skip-syntax-forward "w_") 0))
+     ((< (skip-syntax-backward ".()" back-limit) 0)
+      (while (< (point) start)
+       (if (looking-at c-nonsymbol-token-regexp)
+           (goto-char (match-end 0))
+         ;; `c-nonsymbol-token-regexp' should always match since
+         ;; we've skipped backward over punctuation or paren
+         ;; syntax, but move forward in case it doesn't so that
+         ;; we don't leave point earlier than we started with.
+         (forward-char))))
+     (t (if (looking-at c-nonsymbol-token-regexp)
+           (goto-char (match-end 0)))))
+    (> (point) start)))
+
 (defun c-end-of-current-token (&optional back-limit)
   ;; Move to the end of the current token.  Do not move if not in the
   ;; middle of one.  BACK-LIMIT may be used to bound the backward
@@ -5878,9 +5902,14 @@ comment at the start of cc-engine.el for more info."
             ;; comment style has removed face properties from a construct,
             ;; and is relying on `c-font-lock-declarations' to add them
             ;; again.
-            (and (< (point) cfd-limit)
-                 (looking-at c-doc-line-join-re)
-                 (goto-char (match-end 0)))))
+            (cond
+             ((looking-at c-noise-macro-name-re)
+              (c-forward-noise-clause-not-macro-decl nil)) ; Returns t.
+             ((looking-at c-noise-macro-with-parens-name-re)
+              (c-forward-noise-clause-not-macro-decl t)) ; Always returns t.
+             ((and (< (point) cfd-limit)
+                   (looking-at c-doc-line-join-re))
+              (goto-char (match-end 0))))))
        ;; Set the position to continue at.  We can avoid going over
        ;; the comments skipped above a second time, but it's possible
        ;; that the comment skipping has taken us past `cfd-prop-match'
@@ -5909,6 +5938,8 @@ comment at the start of cc-engine.el for more info."
   ;; o The first token after the end of submatch 1 in
   ;;   `c-decl-prefix-or-start-re' when that submatch matches.  This
   ;;   submatch is typically a (L or R) brace or paren, a ;, or a ,.
+  ;;    As a special case, noise macros are skipped over and the next
+  ;;    token regarded as the spot.
   ;; o The start of each `c-decl-prefix-or-start-re' match when
   ;;   submatch 1 doesn't match.  This is, for example, the keyword
   ;;   "class" in Pike.
@@ -7439,6 +7470,21 @@ comment at the start of cc-engine.el for more info."
       (c-forward-syntactic-ws))
   t)
 
+(defun c-forward-noise-clause-not-macro-decl (maybe-parens)
+  ;; Point is at a noise macro identifier, which, when MAYBE-PARENS is
+  ;; non-nil, optionally takes paren arguments.  Go forward over this name,
+  ;; and when there may be optional parens, any parenthesis expression which
+  ;; follows it, but DO NOT go over any macro declaration which may come
+  ;; between them.  Always return t.
+  (c-end-of-token)
+  (when maybe-parens
+    (let ((here (point)))
+      (c-forward-comments)
+      (if (not (and (eq (char-after) ?\()
+                   (c-go-list-forward)))
+         (goto-char here))))
+  t)
+
 (defun c-forward-keyword-clause (match)
   ;; Submatch MATCH in the current match data is assumed to surround a
   ;; token.  If it's a keyword, move over it and any immediately
@@ -9053,7 +9099,10 @@ This function might do hidden buffer changes."
           ((and c-opt-cpp-prefix
                 (looking-at c-noise-macro-with-parens-name-re))
            (setq noise-start (point))
-           (c-forward-noise-clause)
+           (while
+               (and
+                 (c-forward-noise-clause)
+                 (looking-at c-noise-macro-with-parens-name-re)))
            (setq kwd-clause-end (point))))
 
          (when (setq found-type (c-forward-type t)) ; brace-block-too
diff --git a/src/image.c b/src/image.c
index b82bf12..071b92a 100644
--- a/src/image.c
+++ b/src/image.c
@@ -9696,15 +9696,15 @@ static bool
 initialize_image_type (struct image_type const *type)
 {
 #ifdef WINDOWSNT
-  bool (*init) (void) = type->init;
+  Lisp_Object typesym = builtin_lisp_symbol (type->type);
+  Lisp_Object tested = Fassq (typesym, Vlibrary_cache);
+  /* If we failed to load the library before, don't try again.  */
+  if (CONSP (tested))
+    return !NILP (XCDR (tested)) ? true : false;
 
+  bool (*init) (void) = type->init;
   if (init)
     {
-      /* If we failed to load the library before, don't try again.  */
-      Lisp_Object typesym = builtin_lisp_symbol (type->type);
-      Lisp_Object tested = Fassq (typesym, Vlibrary_cache);
-      if (CONSP (tested) && NILP (XCDR (tested)))
-       return false;
       bool type_valid = init ();
       Vlibrary_cache = Fcons (Fcons (typesym, type_valid ? Qt : Qnil),
                              Vlibrary_cache);