(c-forward-conditional): New function.

(c-up-conditional): Use c-forward-conditional.
(c-backward-conditional): New function.
(c-mode-map): Make bindings for them.

1 files changed, 31 insertions, 9 deletions

diff --git a/lisp/progmodes/c-mode.el b/lisp/progmodes/c-mode.el
index 198e430f60a..b52f9fa68de 100644
--- a/lisp/progmodes/c-mode.el
+++ b/lisp/progmodes/c-mode.el
@@ -48,6 +48,9 @@
   (define-key c-mode-map "\ea" 'c-beginning-of-statement)
   (define-key c-mode-map "\ee" 'c-end-of-statement)
   (define-key c-mode-map "\eq" 'c-fill-paragraph)
+  (define-key c-mode-map "\C-c\C-n" 'c-forward-conditional)
+  (define-key c-mode-map "\C-c\C-p" 'c-backward-conditional)
+  (define-key c-mode-map "\C-c\C-u" 'c-up-conditional)
   (define-key c-mode-map "\177" 'backward-delete-char-untabify)
   (define-key c-mode-map "\t" 'c-indent-command))
 
@@ -1252,15 +1255,28 @@ move forward to the end of the containing preprocessor conditional.
 When going backwards, `#elif' is treated like `#else' followed by `#if'.
 When going forwards, `#elif' is ignored."
   (interactive "p")
-  (let* ((forward (< count 0))
+  (c-forward-conditional (- count) t))
+
+(defun c-backward-conditional (count &optional up-flag)
+  "Move back across a preprocessor conditional, leaving mark behind.
+A prefix argument acts as a repeat count.  With a negative argument,
+move forward across a preprocessor conditional."
+  (interactive "p")
+  (c-forward-conditional (- count) up-flag))
+
+(defun c-forward-conditional (count &optional up-flag)
+  "Move forward across a preprocessor conditional, leaving mark behind.
+A prefix argument acts as a repeat count.  With a negative argument,
+move backward across a preprocessor conditional."
+  (interactive "p")
+  (let* ((forward (> count 0))
 	 (increment (if forward -1 1))
 	 (search-function (if forward 're-search-forward 're-search-backward))
 	 (opoint (point))
 	 (new))
     (save-excursion
       (while (/= count 0)
-	(if forward (end-of-line))
-	(let ((depth 0) found)
+	(let ((depth (if up-flag 0 -1)) found)
 	  (save-excursion
 	    ;; Find the "next" significant line in the proper direction.
 	    (while (and (not found)
@@ -1276,7 +1292,7 @@ When going forwards, `#elif' is ignored."
 	      (beginning-of-line)
 	      ;; Now verify it is really a preproc line.
 	      (if (looking-at "^[ \t]*#[ \t]*\\(if\\|elif\\|endif\\)")
-		  (progn
+		  (let ((prev depth))
 		    ;; Update depth according to what we found.
 		    (beginning-of-line)
 		    (cond ((looking-at "[ \t]*#[ \t]*endif")
@@ -1285,16 +1301,22 @@ When going forwards, `#elif' is ignored."
 			   (if (and forward (= depth 0))
 			       (setq found (point))))
 			  (t (setq depth (- depth increment))))
+		    ;; If we are trying to move across, and we find
+		    ;; an end before we find a beginning, get an error.
+		    (if (and (< prev 0) (< depth prev))
+			(error (if forward
+				   "No following conditional at this level"
+				 "No previous conditional at this level")))
+		    ;; When searching forward, start from next line
+		    ;; so that we don't find the same line again.
+		    (if forward (forward-line 1))
 		    ;; If this line exits a level of conditional, exit inner loop.
 		    (if (< depth 0)
-			(setq found (point)))
-		    ;; When searching forward, start from end of line
-		    ;; so that we don't find the same line again.
-		    (if forward (end-of-line))))))
+			(setq found (point)))))))
 	  (or found
 	      (error "No containing preprocessor conditional"))
 	  (goto-char (setq new found)))
-	(setq count (- count increment))))
+	(setq count (+ count increment))))
     (push-mark)
     (goto-char new)))