Merge branch 'master' of https://github.com/emacs-mirror/emacs

Author: Yuuki Harano

lisp/mail/footnote.el

@@ -457,7 +457,7 @@ footnote styles."
   (let ((fn-regexp (footnote--current-regexp index-regexp)))
     (save-excursion
       (pcase-dolist (`(,fn ,text . ,pointers) footnote--markers-alist)
-        ;; Take care of the pointers first
+        ;; Take care of the pointers first.
 	(dolist (locn pointers)
 	  (goto-char locn)
 	  ;; Try to handle the case where `footnote-start-tag' and
@@ -505,15 +505,18 @@ footnote styles."
 
 ;; Internal functions
 (defun footnote--insert-numbered-footnote (arg &optional mousable)
-  "Insert numbered footnote at point."
+  "Insert numbered footnote at point.
+Return a marker pointing to the beginning of the [...]."
   (let ((string (concat footnote-start-tag
 			(footnote--index-to-string arg)
-			footnote-end-tag)))
+			footnote-end-tag))
+        (pos (point)))
     (insert
      (if mousable
 	 (propertize
 	  string 'footnote-number arg footnote-mouse-highlight t)
-       (propertize string 'footnote-number arg)))))
+       (propertize string 'footnote-number arg)))
+    (copy-marker pos t)))
 
 (defun footnote--renumber (to alist-elem)
   "Renumber a single footnote."
@@ -550,33 +553,13 @@ footnote styles."
   (or (re-search-backward footnote-signature-separator nil t)
       (point)))
 
-(defun footnote--insert-text-marker (arg locn)
-  "Insert a marker pointing to footnote ARG, at buffer location LOCN."
-  (let ((entry (assq arg footnote--markers-alist)))
-    (unless (cadr entry)
-      (let ((marker (copy-marker locn t)))
-        (if entry
-            (setf (cadr entry) marker)
-          (push `(,arg ,marker) footnote--markers-alist)
-          (setq footnote--markers-alist
-	        (footnote--sort footnote--markers-alist)))))))
-
-(defun footnote--insert-pointer-marker (arg locn)
-  "Insert a marker pointing to footnote ARG, at buffer location LOCN."
-  (let ((entry (assq arg footnote--markers-alist))
-        (marker (copy-marker locn t)))
-    (if entry
-        (push marker (cddr entry))
-      (push `(,arg nil ,marker) footnote--markers-alist)
-      (setq footnote--markers-alist
-	    (footnote--sort footnote--markers-alist)))))
-
-(defun footnote--first-text-marker ()
-  (let ((tmp footnote--markers-alist))
-    (while (and tmp (null (cadr (car footnote--markers-alist))))
-      ;; Skip entries which don't (yet) have a TEXT marker.
-      (set tmp (cdr tmp)))
-    (cadr (car tmp))))
+(defun footnote--insert-markers (arg text ptr)
+  "Insert the markers of new footnote ARG."
+  (cl-assert (and (numberp arg) (markerp text) (markerp ptr)))
+  (cl-assert (not (assq arg footnote--markers-alist)))
+  (push `(,arg ,text ,ptr) footnote--markers-alist)
+  (setq footnote--markers-alist
+	(footnote--sort footnote--markers-alist)))
 
 (defun footnote--goto-first ()
   "Go to beginning of footnote area and return non-nil if successful.
@@ -586,42 +569,37 @@ Presumes we're within the footnote area already."
     (re-search-backward
      (concat "^" footnote-section-tag-regexp) nil t))
    (footnote--markers-alist
-    (let ((pos (footnote--first-text-marker)))
-      (when pos
-        (goto-char pos))))))
+    (goto-char (cadr (car footnote--markers-alist))))))
 
 (defun footnote--insert-footnote (arg)
   "Insert a footnote numbered ARG, at (point)."
   (push-mark)
-  (let ((old-point (point)))
-    (footnote--insert-numbered-footnote arg t)
-    (footnote--insert-pointer-marker arg old-point))
-  (footnote--goto-char-point-max)
-  (if (footnote--goto-first)
-      (save-restriction
-	(when footnote-narrow-to-footnotes-when-editing
-	  (footnote--narrow-to-footnotes))
-	(footnote-goto-footnote (1- arg)) ; evil, FIXME (less evil now)
-	;; (message "Inserting footnote %d" arg)
-	(unless
-	    (or (eq arg 1)
-		(when (re-search-forward
-		       (if footnote-spaced-footnotes
-			   "\n\n"
-			 (concat "\n" (footnote--current-regexp)))
-		       nil t)
-		  (unless (beginning-of-line) t))
-		(footnote--goto-char-point-max)
-		(footnote--goto-first))))
-    (unless (looking-at "^$")
-      (insert "\n"))
-    (when (eobp)
-      (insert "\n"))
-    (unless (string-equal footnote-section-tag "")
-      (insert footnote-section-tag "\n")))
-  (let ((old-point (point)))
-    (footnote--insert-numbered-footnote arg nil)
-    (footnote--insert-text-marker arg old-point)))
+  (let ((ptr (footnote--insert-numbered-footnote arg t)))
+    (footnote--goto-char-point-max)
+    (if (footnote--goto-first)
+        (save-restriction
+	  (when footnote-narrow-to-footnotes-when-editing
+	    (footnote--narrow-to-footnotes))
+	  (footnote-goto-footnote (1- arg)) ; evil, FIXME (less evil now)
+	  ;; (message "Inserting footnote %d" arg)
+	  (or (eq arg 1)
+	      (when (re-search-forward
+		     (if footnote-spaced-footnotes
+			 "\n\n"
+		       (concat "\n" (footnote--current-regexp)))
+		     nil t)
+		(beginning-of-line)
+                t)
+	      (footnote--goto-char-point-max)
+	      (footnote--goto-first)))
+      (unless (looking-at "^$")
+        (insert "\n"))
+      (when (eobp)
+        (insert "\n"))
+      (unless (string-equal footnote-section-tag "")
+        (insert footnote-section-tag "\n")))
+    (let ((text (footnote--insert-numbered-footnote arg nil)))
+      (footnote--insert-markers arg text ptr))))
 
 (defun footnote--sort (list)
   (sort list #'car-less-than-car))
@@ -671,14 +649,14 @@ With optional arg BEFORE-TAG, return position of the `footnote-section-tag'
 instead, if applicable."
   (cond
    ;; FIXME: Shouldn't we use `footnote--get-area-point-max' instead?
-   ((not (footnote--first-text-marker)) (point-max))
-   ((not before-tag) (footnote--first-text-marker))
-   ((string-equal footnote-section-tag "") (footnote--first-text-marker))
+   ((not footnote--markers-alist) (point-max))
+   ((not before-tag) (cadr (car footnote--markers-alist)))
+   ((string-equal footnote-section-tag "") (cadr (car footnote--markers-alist)))
    (t
     (save-excursion
-      (goto-char (footnote--first-text-marker))
+      (goto-char (cadr (car footnote--markers-alist)))
       (if (re-search-backward (concat "^" footnote-section-tag-regexp) nil t)
-          (match-beginning 0)
+          (point)
         (message "Footnote section tag not found!")
         ;; This `else' should never happen, and indicates an error,
         ;; ie. footnotes already exist and a footnote-section-tag is defined,
@@ -696,7 +674,7 @@ instead, if applicable."
         ;; function, and repeat.
         ;;
         ;; TODO: integrate sanity checks at reasonable operational points.
-        (footnote--first-text-marker))))))
+        (point))))))
 
 (defun footnote--get-area-point-max ()
   "Return the end of footnote area.
@@ -832,8 +810,8 @@ specified, jump to the text of that footnote."
        ((not (string-equal footnote-section-tag ""))
 	(re-search-backward (concat "^" footnote-section-tag-regexp))
 	(forward-line 1))
-       ((footnote--first-text-marker)
-	(goto-char (footnote--first-text-marker)))))
+       (footnote--markers-alist
+	(goto-char (cadr (car footnote--markers-alist))))))
      (t
       (error "I don't see a footnote here")))))
 

lisp/progmodes/cc-engine.el

@@ -287,7 +287,8 @@ otherwise return nil and leave point unchanged.
 
 Note that this function might do hidden buffer changes.  See the
 comment at the start of cc-engine.el for more info."
-  (let ((here (point)))
+  (let ((here (point))
+	(pause (c-point 'eol)))
     (when c-opt-cpp-prefix
       (if (and (car c-macro-cache)
 	       (>= (point) (car c-macro-cache))
@@ -307,8 +308,23 @@ comment at the start of cc-engine.el for more info."
 	(save-restriction
 	  (if lim (narrow-to-region lim (point-max)))
 	  (beginning-of-line)
-	  (while (eq (char-before (1- (point))) ?\\)
-	    (forward-line -1))
+	  (when (or (null lim)
+		    (>= here lim))
+	    (while
+		(progn
+		  (while (eq (char-before (1- (point))) ?\\)
+		    (forward-line -1))
+		  (when (and c-last-c-comment-end-on-line-re
+			     (re-search-forward
+			      c-last-c-comment-end-on-line-re pause t))
+		    (goto-char (match-end 1))
+		    (if (c-backward-single-comment)
+			(progn
+			  (beginning-of-line)
+			  (setq pause (point)))
+		      (goto-char pause)
+		      nil)))))
+
 	  (back-to-indentation)
 	  (if (and (<= (point) here)
 		   (save-match-data (looking-at c-opt-cpp-start))
@@ -345,12 +361,23 @@ comment at the start of cc-engine.el for more info."
 	      c-macro-cache-start-pos nil
 	      c-macro-cache-syntactic nil
 	      c-macro-cache-no-comment nil))
-      (while (progn
-	       (end-of-line)
-	       (when (and (eq (char-before) ?\\)
-			  (not (eobp)))
-		 (forward-char)
-		 t)))
+      (while
+	  (progn
+	    (while (progn
+		     (end-of-line)
+		     (when (and (eq (char-before) ?\\)
+				(not (eobp)))
+		       (forward-char)
+		       t)))
+	    (if (and c-last-open-c-comment-start-on-line-re
+		     (re-search-backward
+		      c-last-open-c-comment-start-on-line-re
+		      (c-point 'bol) t))
+		(progn
+		  (goto-char (match-beginning 1))
+		  (c-forward-single-comment))
+	      nil)))
+
       (when (and (car c-macro-cache)
 		 (bolp)
 		 (not (eq (char-before (1- (point))) ?\\)))
@@ -2007,6 +2034,10 @@ comment at the start of cc-engine.el for more info."
 	    ;; Take elaborate precautions to detect an open block comment at
 	    ;; the end of a macro.  If we find one, we set `safe-start' to nil
 	    ;; and break off any further scanning of comments.
+	    ;;
+	    ;; (2019-05-02): `c-end-of-macro' now moves completely over block
+	    ;; comments, even multiline ones lacking \s at their EOLs.  So a
+	    ;; lot of the following is probably redundant now.
 	    (let ((com-begin (point)) com-end in-macro)
 	      (when (and (c-forward-single-comment)
 			 (setq com-end (point))
@@ -5661,7 +5692,10 @@ comment at the start of cc-engine.el for more info."
 	       (setq cfd-re-match cfd-limit)
 	       nil)
 	      ((c-got-face-at
-		(if (setq cfd-re-match (match-end 1))
+		(if (setq cfd-re-match
+			  (or (match-end 1)
+			      (and c-dposr-cpp-macro-depth
+				   (match-end (1+ c-dposr-cpp-macro-depth)))))
 		    ;; Matched the end of a token preceding a decl spot.
 		    (progn
 		      (goto-char cfd-re-match)
@@ -5672,15 +5706,19 @@ comment at the start of cc-engine.el for more info."
 		c-literal-faces)
 	       ;; Pseudo match inside a comment or string literal.  Skip out
 	       ;; of comments and string literals.
-	       (while (progn
-			(unless
-			    (and (match-end 1)
-				 (c-got-face-at (1- (point)) c-literal-faces)
-				 (not (c-got-face-at (point) c-literal-faces)))
-			  (goto-char (c-next-single-property-change
-				      (point) 'face nil cfd-limit)))
-			(and (< (point) cfd-limit)
-			     (c-got-face-at (point) c-literal-faces))))
+	       (while
+		   (progn
+		     (unless
+			 (and
+			  (or (match-end 1)
+			      (and c-dposr-cpp-macro-depth
+				   (match-end (1+ c-dposr-cpp-macro-depth))))
+			  (c-got-face-at (1- (point)) c-literal-faces)
+			  (not (c-got-face-at (point) c-literal-faces)))
+		       (goto-char (c-next-single-property-change
+				   (point) 'face nil cfd-limit)))
+		     (and (< (point) cfd-limit)
+			  (c-got-face-at (point) c-literal-faces))))
 	       t)		      ; Continue the loop over pseudo matches.
 	      ((and c-opt-identifier-concat-key
 		    (match-string 1)
@@ -5832,7 +5870,7 @@ comment at the start of cc-engine.el for more info."
     ;; before the point, and do the first `c-decl-prefix-or-start-re'
     ;; search unless we're at bob.
 
-    (let (start-in-literal start-in-macro syntactic-pos)
+    (let (start-in-literal start-in-macro syntactic-pos hash-define-pos)
       ;; Must back up a bit since we look for the end of the previous
       ;; statement or declaration, which is earlier than the first
       ;; returned match.
@@ -5987,7 +6025,21 @@ comment at the start of cc-engine.el for more info."
 	  ;; The only syntactic ws in macros are comments.
 	  (c-backward-comments)
 	  (or (bobp) (backward-char))
-	  (c-beginning-of-current-token))
+	  (c-beginning-of-current-token)
+	  ;; If we're in a macro without argument parentheses, we could have
+	  ;; now ended up at the macro's identifier.  We need to be at #define
+	  ;; for `c-find-decl-prefix-search' to find the first token of the
+	  ;; macro's expansion.
+	  (when (and (c-on-identifier)
+		     (setq hash-define-pos
+			   (save-excursion
+			     (and
+			      (zerop (c-backward-token-2 2)) ; over define, #
+			      (save-excursion
+				(beginning-of-line)
+				(looking-at c-opt-cpp-macro-define-id))
+			      (point)))))
+	    (goto-char hash-define-pos)))
 
 	 (start-in-literal
 	  ;; If we're in a comment it can only be the closest