1 ;;; cc-cmds.el --- user level commands for CC Mode
3 ;; Copyright (C) 1985,1987,1992-2001 Free Software Foundation, Inc.
5 ;; Authors: 2000- Martin Stjernholm
6 ;; 1998-1999 Barry A. Warsaw and Martin Stjernholm
7 ;; 1992-1997 Barry A. Warsaw
8 ;; 1987 Dave Detlefs and Stewart Clamen
9 ;; 1985 Richard M. Stallman
10 ;; Maintainer: bug-cc-mode@gnu.org
11 ;; Created: 22-Apr-1997 (split from cc-mode.el)
12 ;; Version: See cc-mode.el
13 ;; Keywords: c languages oop
15 ;; This file is part of GNU Emacs.
17 ;; GNU Emacs is free software; you can redistribute it and/or modify
18 ;; it under the terms of the GNU General Public License as published by
19 ;; the Free Software Foundation; either version 2, or (at your option)
22 ;; GNU Emacs is distributed in the hope that it will be useful,
23 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
24 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
25 ;; GNU General Public License for more details.
27 ;; You should have received a copy of the GNU General Public License
28 ;; along with this program; see the file COPYING. If not, write to
29 ;; the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
30 ;; Boston, MA 02111-1307, USA.
38 (if (and (boundp 'byte-compile-dest-file)
39 (stringp byte-compile-dest-file))
40 (cons (file-name-directory byte-compile-dest-file) load-path)
42 (require 'cc-bytecomp)))
46 (cc-require 'cc-langs)
47 (cc-require 'cc-engine)
49 ;; Silence the compiler.
50 (cc-bytecomp-defvar delete-key-deletes-forward) ; XEmacs 20+
51 (cc-bytecomp-defun delete-forward-p) ; XEmacs 21+
52 (cc-bytecomp-obsolete-fun insert-and-inherit) ; Marked obsolete in XEmacs 19
53 (cc-bytecomp-defvar filladapt-mode) ; c-fill-paragraph contains a kludge
54 ; which looks at this.
57 (defun c-calculate-state (arg prevstate)
58 ;; Calculate the new state of PREVSTATE, t or nil, based on arg. If
59 ;; arg is nil or zero, toggle the state. If arg is negative, turn
60 ;; the state off, and if arg is positive, turn the state on
62 (zerop (setq arg (prefix-numeric-value arg))))
66 ;; Auto-newline and hungry-delete
67 (defun c-toggle-auto-state (&optional arg)
68 "Toggle auto-newline feature.
69 Optional numeric ARG, if supplied, turns on auto-newline when
70 positive, turns it off when negative, and just toggles it when zero or
73 When the auto-newline feature is enabled (as evidenced by the `/a' or
74 `/ah' on the modeline after the mode name) newlines are automatically
75 inserted after special characters such as brace, comma, semi-colon,
78 (setq c-auto-newline (c-calculate-state arg c-auto-newline))
80 (c-keep-region-active))
82 (defun c-toggle-hungry-state (&optional arg)
83 "Toggle hungry-delete-key feature.
84 Optional numeric ARG, if supplied, turns on hungry-delete when
85 positive, turns it off when negative, and just toggles it when zero or
88 When the hungry-delete-key feature is enabled (as evidenced by the
89 `/h' or `/ah' on the modeline after the mode name) the delete key
90 gobbles all preceding whitespace in one fell swoop."
92 (setq c-hungry-delete-key (c-calculate-state arg c-hungry-delete-key))
94 (c-keep-region-active))
96 (defun c-toggle-auto-hungry-state (&optional arg)
97 "Toggle auto-newline and hungry-delete-key features.
98 Optional numeric ARG, if supplied, turns on auto-newline and
99 hungry-delete when positive, turns them off when negative, and just
100 toggles them when zero or left out.
102 See `c-toggle-auto-state' and `c-toggle-hungry-state' for details."
104 (setq c-auto-newline (c-calculate-state arg c-auto-newline))
105 (setq c-hungry-delete-key (c-calculate-state arg c-hungry-delete-key))
107 (c-keep-region-active))
112 (defun c-electric-backspace (arg)
113 "Deletes preceding character or whitespace.
114 If `c-hungry-delete-key' is non-nil, as evidenced by the \"/h\" or
115 \"/ah\" string on the mode line, then all preceding whitespace is
116 consumed. If however a prefix argument is supplied, or
117 `c-hungry-delete-key' is nil, or point is inside a literal then the
118 function in the variable `c-backspace-function' is called.
120 See also \\[c-electric-delete]."
122 (if (or (not c-hungry-delete-key)
125 (funcall c-backspace-function (prefix-numeric-value arg))
126 (let ((here (point)))
127 (skip-chars-backward " \t\n")
128 (if (/= (point) here)
129 (delete-region (point) here)
130 (funcall c-backspace-function 1)
133 (defun c-electric-delete-forward (arg)
134 "Deletes following character or whitespace.
135 If `c-hungry-delete-key' is non-nil, as evidenced by the \"/h\" or
136 \"/ah\" string on the mode line, then all following whitespace is
137 consumed. If however a prefix argument is supplied, or
138 `c-hungry-delete-key' is nil, or point is inside a literal then the
139 function in the variable `c-delete-function' is called."
141 (if (or (not c-hungry-delete-key)
144 (funcall c-delete-function (prefix-numeric-value arg))
145 (let ((here (point)))
146 (skip-chars-forward " \t\n")
147 (if (/= (point) here)
148 (delete-region (point) here)
149 (funcall c-delete-function 1)))))
151 (defun c-electric-delete (arg)
152 "Deletes preceding or following character or whitespace.
153 This function either deletes forward as `c-electric-delete-forward' or
154 backward as `c-electric-backspace', depending on the configuration:
156 If the function `delete-forward-p' is defined (XEmacs 21) and returns
157 non-nil, it deletes forward. Else, if the variable
158 `delete-key-deletes-forward' is defined (XEmacs 20) and is set to
159 non-nil, it deletes forward. Otherwise it deletes backward.
161 Note: This is the way in XEmacs 20 and later to choose the correct
162 action for the [delete] key, whichever key that means. In other
163 flavors this function isn't used, instead it's left to the user to
164 bind [delete] to either \\[c-electric-delete-forward] or \\[c-electric-backspace] as appropriate
165 \(the keymap `function-key-map' is useful for that). Emacs 21 handles
166 that automatically, though."
168 (if (or (and (fboundp 'delete-forward-p) ;XEmacs 21
170 (and (boundp 'delete-key-deletes-forward) ;XEmacs 20
171 delete-key-deletes-forward))
172 (c-electric-delete-forward arg)
173 (c-electric-backspace arg)))
175 (defun c-electric-pound (arg)
176 "Electric pound (`#') insertion.
177 Inserts a `#' character specially depending on the variable
178 `c-electric-pound-behavior'. If a numeric ARG is supplied, or if
179 point is inside a literal, nothing special happens."
182 (not (memq 'alignleft c-electric-pound-behavior))
183 (save-excursion (skip-chars-backward " \t") (not (bolp)))
185 ;; do nothing special
186 (self-insert-command (prefix-numeric-value arg))
187 ;; place the pound character at the left edge
188 (let ((pos (- (point-max) (point)))
191 (delete-horizontal-space)
192 (insert-char last-command-char 1)
194 (goto-char (- (point-max) pos)))
197 (defun c-electric-brace (arg)
200 If the auto-newline feature is turned on, as evidenced by the \"/a\"
201 or \"/ah\" string on the mode line, newlines are inserted before and
202 after braces based on the value of `c-hanging-braces-alist'.
204 Also, the line is re-indented unless a numeric ARG is supplied, there
205 are non-whitespace characters present on the line after the brace, the
206 brace is inserted inside a literal, or `c-syntactic-indentation' is
209 This function does various newline cleanups based on the value of
212 (let* ((c-state-cache (c-parse-state))
213 (safepos (c-safe-position (point) c-state-cache))
214 (literal (c-in-literal safepos)))
215 ;; if we're in a literal, or we're not at the end of the line, or
216 ;; a numeric arg is provided, or auto-newlining is turned off,
217 ;; then just insert the character.
220 (not (looking-at "[ \t]*$")))
221 (self-insert-command (prefix-numeric-value arg))
223 ;; This is the list of brace syntactic symbols that can
224 ;; hang. If any new ones are added to c-offsets-alist,
225 ;; they should be added here as well.
226 '(class-open class-close defun-open defun-close
227 inline-open inline-close
228 brace-list-open brace-list-close
229 brace-list-intro brace-entry-open
230 block-open block-close
231 substatement-open statement-case-open
232 extern-lang-open extern-lang-close
233 namespace-open namespace-close
234 inexpr-class-open inexpr-class-close
236 ;; we want to inhibit blinking the paren since this will
237 ;; be most disruptive. we'll blink it ourselves later on
238 (old-blink-paren blink-paren-function)
240 (insertion-point (point))
242 (preserve-p (and (not (bobp))
243 (eq ?\ (char-syntax (char-before)))))
245 (c-echo-syntactic-information-p nil)
247 ;; only insert a newline if there is
248 ;; non-whitespace behind us
250 (skip-chars-backward " \t")
253 (setq delete-temp-newline t)))
254 (if (eq last-command-char ?{)
255 (setq c-state-cache (cons (point) c-state-cache)))
256 (self-insert-command (prefix-numeric-value arg))
257 ;; state cache doesn't change
258 (c-guess-basic-syntax)))
263 ;; Substitute inexpr-class and class-open
264 ;; or class-close with inexpr-class-open
265 ;; or inexpr-class-close.
266 (if (assq 'inexpr-class syntax)
267 (cond ((assq 'class-open syntax)
268 '((inexpr-class-open)))
269 ((assq 'class-close syntax)
270 '((inexpr-class-close)))
273 c-hanging-braces-alist)
274 '(ignore before after)))))
275 ;; Do not try to insert newlines around a special (Pike-style)
277 (if (and c-special-brace-lists
279 (c-safe (if (= (char-before) ?{)
282 (c-looking-at-special-brace-list))))
284 ;; If syntax is a function symbol, then call it using the
285 ;; defined semantics.
286 (if (and (not (consp (cdr newlines)))
287 (functionp (cdr newlines)))
288 (let ((c-syntactic-context syntax))
290 (funcall (cdr newlines) (car newlines) insertion-point))))
291 ;; does a newline go before the open brace?
292 (if (memq 'before newlines)
293 ;; we leave the newline we've put in there before,
294 ;; but we need to re-indent the line above
296 (old-point-max (point-max))
297 (pos (- (point-max) (point)))
300 (setq old-ind (c-point 'boi))
301 (let ((c-state-cache (c-whack-state (point) c-state-cache)))
302 ;; we may need to update the cache. this should
303 ;; still be faster than recalculating the state
307 (narrow-to-region here (point))
308 (if (and (c-safe (progn (backward-up-list -1) t))
309 (memq (char-before) '(?\) ?}))
311 (c-safe (progn (c-forward-sexp -1)
314 (c-hack-state (point) 'open c-state-cache)))))
315 (if c-syntactic-indentation
316 (indent-according-to-mode)))
317 (setq c-state-cache (c-adjust-state (c-point 'bol) old-point-max
318 (- (c-point 'boi) old-ind)
320 (goto-char (- (point-max) pos))
321 ;; if the buffer has changed due to the indentation, we
322 ;; need to recalculate syntax for the current line, but
323 ;; we won't need to update the state cache.
324 (if (/= (point) here)
325 (setq syntax (c-guess-basic-syntax))))
326 ;; must remove the newline we just stuck in (if we really did it)
327 (and delete-temp-newline
329 ;; if there is whitespace before point, then preserve
330 ;; at least one space.
333 (setq c-state-cache (c-whack-state (point) c-state-cache))
336 ;; since we're hanging the brace, we need to recalculate
337 ;; syntax. Update the state to accurately reflect the
338 ;; beginning of the line. We punt if we cross any open or
339 ;; closed parens because its just too hard to modify the
340 ;; known state. This limitation will be fixed in v5.
342 (let ((bol (c-point 'bol)))
343 (if (zerop (car (parse-partial-sexp bol (1- (point)))))
344 (setq syntax (c-guess-basic-syntax))
345 ;; gotta punt. this requires some horrible kludgery
347 (setq c-state-cache nil
348 c-state-cache (c-parse-state)
351 ;; Now adjust the line's indentation. Don't update the state
352 ;; cache since c-guess-basic-syntax isn't called when
353 ;; c-syntactic-context is set.
354 (let* ((old-ind (c-point 'boi))
355 (old-point-max (point-max))
356 (c-syntactic-context syntax))
357 (indent-according-to-mode)
358 (setq c-state-cache (c-adjust-state (c-point 'bol) old-point-max
359 (- (c-point 'boi) old-ind)
361 ;; Do all appropriate clean ups
363 (pos (- (point-max) (point)))
365 ;; clean up empty defun braces
366 (if (and c-auto-newline
367 (memq 'empty-defun-braces c-cleanup-list)
368 (eq last-command-char ?\})
369 (c-intersect-lists '(defun-close class-close inline-close)
373 (skip-chars-backward " \t\n")
374 (eq (char-before) ?\{))
375 ;; make sure matching open brace isn't in a comment
376 (not (c-in-literal)))
377 (delete-region (point) (1- here)))
378 ;; clean up brace-else-brace and brace-elseif-brace
379 (when (and c-auto-newline
380 (eq last-command-char ?\{)
381 (not (c-in-literal)))
383 ((and (memq 'brace-else-brace c-cleanup-list)
384 (re-search-backward "}[ \t\n]*else[ \t\n]*{" nil t)
386 (setq mbeg (match-beginning 0)
388 (eq (match-end 0) here)))
389 (delete-region mbeg mend)
391 ((and (memq 'brace-elseif-brace c-cleanup-list)
393 (goto-char (1- here))
395 (skip-chars-backward " \t\n")
397 (eq (char-before) ?\)))
398 (= (c-backward-token-1 1 t) 0)
399 (eq (char-after) ?\()
402 (re-search-backward "}[ \t\n]*else[ \t\n]+if[ \t\n]*"
404 (eq (match-end 0) tmp))
405 (delete-region mbeg mend)
408 (goto-char (- (point-max) pos))
410 ;; does a newline go after the brace?
411 (if (memq 'after newlines)
414 ;; update on c-state-cache
415 (let* ((bufpos (- (point) 2))
416 (which (if (eq (char-after bufpos) ?{) 'open 'close))
417 (c-state-cache (c-hack-state bufpos which c-state-cache)))
418 (indent-according-to-mode))))
420 (and (eq last-command-char ?\})
423 (c-backward-syntactic-ws safepos)
424 (funcall old-blink-paren)))
427 (defun c-electric-slash (arg)
428 "Insert a slash character.
430 Indent the line as a comment, if:
432 1. The slash is second of a `//' line oriented comment introducing
433 token and we are on a comment-only-line, or
435 2. The slash is part of a `*/' token that closes a block oriented
438 If a numeric ARG is supplied, point is inside a literal, or
439 `c-syntactic-indentation' is nil, indentation is inhibited."
441 (let* ((ch (char-before))
442 (indentp (and c-syntactic-indentation
444 (eq last-command-char ?/)
446 (not (c-in-literal)))
451 (c-echo-syntactic-information-p nil))
452 (self-insert-command (prefix-numeric-value arg))
454 (indent-according-to-mode))))
456 (defun c-electric-star (arg)
457 "Insert a star character.
458 If the star is the second character of a C style comment introducing
459 construct, and we are on a comment-only-line, indent line as comment.
460 If a numeric ARG is supplied, point is inside a literal, or
461 `c-syntactic-indentation' is nil, indentation is inhibited."
463 (self-insert-command (prefix-numeric-value arg))
464 ;; if we are in a literal, or if arg is given do not re-indent the
465 ;; current line, unless this star introduces a comment-only line.
466 (if (and c-syntactic-indentation
468 (memq (c-in-literal) '(c))
469 (eq (char-before) ?*)
472 (skip-chars-backward "*")
473 (if (eq (char-before) ?/)
475 (skip-chars-backward " \t")
477 (let (c-echo-syntactic-information-p) ; shut this up
478 (indent-according-to-mode))
481 (defun c-electric-semi&comma (arg)
482 "Insert a comma or semicolon.
483 When the auto-newline feature is turned on, as evidenced by the \"/a\"
484 or \"/ah\" string on the mode line, a newline might be inserted. See
485 the variable `c-hanging-semi&comma-criteria' for how newline insertion
488 When semicolon is inserted, the line is re-indented unless a numeric
489 arg is supplied, point is inside a literal, or there are
490 non-whitespace characters on the line following the semicolon, or
491 `c-syntactic-indentation' is nil.
493 Based on the value of `c-cleanup-list', this function cleans up commas
494 following brace lists and semicolons following defuns."
496 (let* ((lim (c-most-enclosing-brace (c-parse-state)))
497 (literal (c-in-literal lim))
500 (c-echo-syntactic-information-p nil))
503 (not (looking-at "[ \t]*$")))
504 (self-insert-command (prefix-numeric-value arg))
505 ;; do some special stuff with the character
506 (self-insert-command (prefix-numeric-value arg))
507 ;; do all cleanups and newline insertions if c-auto-newline is
509 (if (not c-auto-newline)
510 (if c-syntactic-indentation
511 (indent-according-to-mode))
513 (let ((pos (- (point-max) (point))))
515 (eq last-command-char ?,)
516 (memq 'list-close-comma c-cleanup-list))
518 (eq last-command-char ?\;)
519 (memq 'defun-close-semi c-cleanup-list)))
522 (skip-chars-backward " \t\n")
523 (eq (char-before) ?}))
524 ;; make sure matching open brace isn't in a comment
525 (not (c-in-literal lim)))
526 (delete-region (point) here))
527 (goto-char (- (point-max) pos)))
529 (if c-syntactic-indentation
530 (indent-according-to-mode))
531 ;; check to see if a newline should be added
532 (let ((criteria c-hanging-semi&comma-criteria)
533 answer add-newline-p)
535 (setq answer (funcall (car criteria)))
536 ;; only nil value means continue checking
538 (setq criteria (cdr criteria))
540 ;; only 'stop specifically says do not add a newline
541 (setq add-newline-p (not (eq answer 'stop)))
545 (indent-according-to-mode)))
548 (defun c-electric-colon (arg)
551 If the auto-newline feature is turned on, as evidenced by the \"/a\"
552 or \"/ah\" string on the mode line, newlines are inserted before and
553 after colons based on the value of `c-hanging-colons-alist'.
555 Also, the line is re-indented unless a numeric ARG is supplied, there
556 are non-whitespace characters present on the line after the colon, the
557 colon is inserted inside a literal, or `c-syntactic-indentation' is
560 This function cleans up double colon scope operators based on the
561 value of `c-cleanup-list'."
563 (let* ((bod (c-point 'bod))
564 (literal (c-in-literal bod))
565 syntax newlines is-scope-op
567 (c-echo-syntactic-information-p nil))
570 (not (looking-at "[ \t]*$")))
571 (self-insert-command (prefix-numeric-value arg))
572 ;; insert the colon, then do any specified cleanups
573 (self-insert-command (prefix-numeric-value arg))
574 (let ((pos (- (point-max) (point)))
576 (if (and c-auto-newline
577 (memq 'scope-operator c-cleanup-list)
578 (eq (char-before) ?:)
581 (skip-chars-backward " \t\n")
582 (eq (char-before) ?:))
584 (not (eq (char-after (- (point) 2)) ?:)))
586 (delete-region (point) (1- here))
587 (setq is-scope-op t)))
588 (goto-char (- (point-max) pos)))
589 ;; lets do some special stuff with the colon character
590 (setq syntax (c-guess-basic-syntax)
591 ;; some language elements can only be determined by
592 ;; checking the following line. Lets first look for ones
593 ;; that can be found when looking on the line with the
597 (or (c-lookup-lists '(case-label label access-label)
598 syntax c-hanging-colons-alist)
599 (c-lookup-lists '(member-init-intro inher-intro)
600 (let ((buffer-undo-list t))
603 (c-guess-basic-syntax)
605 c-hanging-colons-alist))))
606 ;; indent the current line if it's done syntactically.
607 (if c-syntactic-indentation
608 (let ((c-syntactic-context syntax))
609 (indent-according-to-mode)))
610 ;; does a newline go before the colon? Watch out for already
611 ;; non-hung colons. However, we don't unhang them because that
612 ;; would be a cleanup (and anti-social).
613 (if (and (memq 'before newlines)
616 (skip-chars-backward ": \t")
618 (let ((pos (- (point-max) (point))))
621 (indent-according-to-mode)
622 (goto-char (- (point-max) pos))))
623 ;; does a newline go after the colon?
624 (if (and (memq 'after (cdr-safe newlines))
628 (indent-according-to-mode)))
631 (defun c-electric-lt-gt (arg)
632 "Insert a less-than, or greater-than character.
633 The line will be re-indented if the character inserted is the second
634 of a C++ style stream operator and the buffer is in C++ mode.
635 Exceptions are when a numeric argument is supplied, point is inside a
636 literal, or `c-syntactic-indentation' is nil, in which case the line
637 will not be re-indented."
639 (let ((indentp (and c-syntactic-indentation
641 (eq (char-before) last-command-char)
642 (not (c-in-literal))))
644 (c-echo-syntactic-information-p nil))
645 (self-insert-command (prefix-numeric-value arg))
647 (indent-according-to-mode))))
649 (defun c-electric-paren (arg)
650 "Insert a parenthesis.
652 Some newline cleanups are done if appropriate; see the variable
655 Also, the line is re-indented unless a numeric ARG is supplied, there
656 are non-whitespace characters present on the line after the
657 parenthesis, the parenthesis is inserted inside a literal, or
658 `c-syntactic-indentation' is nil."
660 (let (;; shut this up
661 (c-echo-syntactic-information-p nil))
663 (c-in-literal (c-point 'bod)))
664 (self-insert-command (prefix-numeric-value arg))
665 ;; do some special stuff with the character
666 (let* (;; We want to inhibit blinking the paren since this will
667 ;; be most disruptive. We'll blink it ourselves
669 (old-blink-paren blink-paren-function)
670 blink-paren-function)
671 (self-insert-command (prefix-numeric-value arg))
672 (when (looking-at "[ \t]*$")
673 (if c-syntactic-indentation
674 (indent-according-to-mode))
676 ;; Do all appropriate clean ups
678 (pos (- (point-max) (point)))
680 ;; clean up brace-elseif-brace
681 (if (and (memq 'brace-elseif-brace c-cleanup-list)
682 (eq last-command-char ?\()
683 (re-search-backward "}[ \t\n]*else[ \t\n]+if[ \t\n]*("
686 (setq mbeg (match-beginning 0)
689 (not (c-in-literal)))
691 (delete-region mbeg mend)
692 (insert "} else if (")))
693 ;; clean up brace-catch-brace
694 (if (and (memq 'brace-catch-brace c-cleanup-list)
695 (eq last-command-char ?\()
696 (re-search-backward "}[ \t\n]*catch[ \t\n]*(" nil t)
698 (setq mbeg (match-beginning 0)
701 (not (c-in-literal)))
703 (delete-region mbeg mend)
704 (insert "} catch (")))
705 (goto-char (- (point-max) pos))
707 (let (beg (end (1- (point))))
708 (cond ((and (memq 'space-before-funcall c-cleanup-list)
709 (eq last-command-char ?\()
712 (skip-chars-backward " \t")
716 (delete-region beg end)
719 ((and (memq 'compact-empty-funcall c-cleanup-list)
720 (eq last-command-char ?\))
722 (c-safe (backward-char 2))
723 (when (looking-at "()")
725 (skip-chars-backward " \t")
728 (delete-region beg end))))
730 (funcall old-blink-paren))))))
732 (defun c-electric-continued-statement ()
733 "Reindent the current line if appropriate.
735 This function is used to reindent the line after a keyword which
736 continues an earlier statement is typed, e.g. an \"else\" or the
737 \"while\" in a do-while block.
739 The line is reindented if there is nothing but whitespace before the
740 keyword on the line, the keyword is not inserted inside a literal, and
741 `c-syntactic-indentation' is non-nil."
742 (let (;; shut this up
743 (c-echo-syntactic-information-p nil))
744 (when (and c-syntactic-indentation
745 (not (eq last-command-char ?_))
747 (skip-syntax-backward "w")
750 (not (c-in-literal (c-point 'bod))))
751 (indent-according-to-mode))))
754 ;; better movement routines for ThisStyleOfVariablesCommonInCPlusPlus
755 ;; originally contributed by Terry_Glanfield.Southern@rxuk.xerox.com
756 (defun c-forward-into-nomenclature (&optional arg)
757 "Move forward to end of a nomenclature section or word.
758 With arg, to it arg times."
760 (let ((case-fold-search nil))
762 (re-search-forward "\\W*\\([A-Z]*[a-z0-9]*\\)" (point-max) t arg)
763 (while (and (< arg 0)
765 "\\(\\(\\W\\|[a-z0-9]\\)[A-Z]+\\|\\W\\w+\\)"
768 (setq arg (1+ arg)))))
769 (c-keep-region-active))
771 (defun c-backward-into-nomenclature (&optional arg)
772 "Move backward to beginning of a nomenclature section or word.
773 With optional ARG, move that many times. If ARG is negative, move
776 (c-forward-into-nomenclature (- arg))
777 (c-keep-region-active))
779 (defun c-scope-operator ()
780 "Insert a double colon scope operator at point.
781 No indentation or other \"electric\" behavior is performed."
785 (defun c-beginning-of-defun (&optional arg)
786 "Move backward to the beginning of a defun.
787 With argument, do it that many times. Negative arg -N
788 means move forward to Nth following beginning of defun.
789 Returns t unless search stops due to beginning or end of buffer.
791 Unlike the built-in `beginning-of-defun' this tries to be smarter
792 about finding the char with open-parenthesis syntax that starts the
795 (unless arg (setq arg 1))
797 (c-end-of-defun (- arg))
799 (let ((state (nreverse (c-parse-state)))
801 (while (and state (not bod))
802 (setq bod (car state)
805 (setq prevbod (car bod)
808 (bod (goto-char bod))
809 (prevbod (goto-char prevbod))
810 (t (goto-char (point-min))
812 (setq arg (1- arg))))
813 (c-keep-region-active)
816 (defun c-end-of-defun (&optional arg)
817 "Move forward to next end of defun. With argument, do it that many times.
818 Negative argument -N means move back to Nth preceding end of defun.
819 Returns t unless search stops due to beginning or end of buffer.
821 An end of a defun occurs right after the close-parenthesis that matches
822 the open-parenthesis that starts a defun; see `beginning-of-defun'."
827 (c-beginning-of-defun (- arg))
831 (while (and (c-safe (down-list 1) t)
832 (not (eq (char-before) ?{)))
833 ;; skip down into the next defun-block
836 (c-beginning-of-defun 1)
837 (setq eol (c-point 'eol))
840 ;; Don't move to next line for one line defuns.
842 (when (<= (point) pos)
843 (goto-char (point-max))
845 (setq arg (1- arg))))
846 (c-keep-region-active)
850 (defun c-beginning-of-statement (&optional count lim sentence-flag)
851 "Go to the beginning of the innermost C statement.
852 With prefix arg, go back N - 1 statements. If already at the
853 beginning of a statement then go to the beginning of the closest
854 preceding one, moving into nested blocks if necessary (use
855 \\[backward-sexp] to skip over a block). If within or next to a
856 comment or multiline string, move by sentences instead of statements.
858 When called from a program, this function takes 3 optional args: the
859 repetition count, a buffer position limit which is the farthest back
860 to search for the syntactic context, and a flag saying whether to do
861 sentence motion in or near comments and multiline strings."
862 (interactive (list (prefix-numeric-value current-prefix-arg)
864 (let* ((count (or count 1))
866 (range (c-collect-line-comments (c-literal-limits lim))))
867 (while (and (/= count 0)
868 (or (not lim) (> (point) lim)))
870 (if (and (not range) sentence-flag)
872 ;; Find the comment next to point if we're not in one.
874 (if (c-forward-comment -1)
875 (setq range (cons (point)
876 (progn (c-forward-comment 1) (point))))
877 (skip-chars-backward " \t\n\r\f")
880 (if (eq (char-before) ?\")
881 (c-safe (c-backward-sexp 1)
882 (cons (point) range)))))
883 ;; skip-syntax-* doesn't count \n as whitespace..
884 (skip-chars-forward " \t\n\r\f")
885 (if (eq (char-after) ?\")
886 (setq range (cons (point)
891 (setq range (if (c-forward-comment 1)
894 (setq range (c-collect-line-comments range))))
895 (if (and (< count 0) (= here (point-max)))
896 ;; Special case because eob might be in a literal.
899 (if (and sentence-flag
900 (or (/= (char-syntax (char-after (car range))) ?\")
901 ;; Only visit a string if it spans more than one line.
903 (goto-char (car range))
904 (skip-chars-forward "^\n" (cdr range))
905 (< (point) (cdr range)))))
906 (let* ((lit-type (c-literal-type range))
907 (line-prefix (concat "[ \t]*\\("
908 c-current-comment-prefix
910 (beg (if (eq lit-type 'string)
913 (goto-char (car range))
915 (looking-at comment-start-skip)
918 (looking-at line-prefix)
920 (end (- (cdr range) (if (eq lit-type 'c) 2 1)))
921 (beg-of-para (if (eq lit-type 'string)
925 (if (looking-at line-prefix)
926 (goto-char (match-end 0)))))))
928 ;; Move by sentence, but not past the limit of the
929 ;; literal, narrowed to the appropriate
931 (narrow-to-region (save-excursion
932 (let ((pos (min here end)))
934 (forward-paragraph -1)
935 (if (looking-at paragraph-separate)
937 (when (> (point) beg)
938 (funcall beg-of-para)
939 (when (>= (point) pos)
940 (forward-paragraph -2)
941 (funcall beg-of-para)))
944 (c-safe (forward-sentence (if (< count 0) 1 -1)))
945 (if (and (memq lit-type '(c c++))
946 ;; Check if we stopped due to a comment
947 ;; prefix and not a sentence end.
948 (/= (point) (point-min))
949 (/= (point) (point-max))
952 (looking-at line-prefix))
953 (>= (point) (match-beginning 0))
954 (/= (match-beginning 1) (match-end 1))
955 (or (< (point) (match-end 0))
957 (= (point) (match-end 0))
958 ;; The comment prefix may contain
959 ;; characters that is regarded as end
964 (forward-paragraph -1)
965 (< (point) (match-beginning 0)))
968 (or (not (re-search-backward
973 (c-point 'eol)))))))))
974 (setq count (+ count (if (< count 0) -1 1)))
977 ;; In block comments, if there's only
978 ;; horizontal ws between the text and the
979 ;; comment ender, stop before it. Stop after
980 ;; the ender if there's either nothing or
982 (when (and (eq lit-type 'c)
983 (eq (point) (point-max)))
985 (when (or (= (skip-chars-backward " \t") 0)
986 (eq (point) (point-max))
988 (goto-char (cdr range)))))
989 (when (and (eq (point) (point-min))
990 (looking-at "[ \t]*$"))
991 ;; Stop before instead of after the comment
992 ;; starter if nothing follows it.
994 (goto-char (car range))
995 (if (and (eq lit-type 'string) (/= (point) here))
996 (setq count (1+ count)
998 ;; See if we should escape the literal.
1000 (if (< (point) here)
1001 (setq count (1- count))
1002 (goto-char (car range))
1004 (if (> (point) here)
1005 (setq count (1+ count))
1006 (goto-char (cdr range))
1008 (goto-char (if (> count 0) (car range) (cdr range)))
1010 ;; Below we do approximately the same as
1011 ;; c-beginning-of-statement-1 and c-end-of-statement-1, and
1012 ;; perhaps they should be changed, but that'd likely break a
1013 ;; lot in cc-engine.
1017 ;; Stop before `{' and after `;', `{', `}' and `};'
1018 ;; when not followed by `}' or `)', but on the other
1019 ;; side of the syntactic ws. Move by sexps and move
1020 ;; into parens. Also stop before `#' when it's at boi
1022 (let ((literal-pos (not sentence-flag))
1023 (large-enough (- (point-max)))
1024 last last-below-line)
1028 (when (and (or (eq (char-after) ?\{)
1029 (and (eq (char-after) ?#)
1030 (eq (point) (c-point 'boi)))
1033 (unless (and c-special-brace-lists
1034 (eq (char-after) ?{)
1035 (c-looking-at-special-brace-list))
1036 (if (and (eq (char-after) ?#)
1037 (numberp last-below-line)
1038 (not (eq last-below-line here)))
1039 (goto-char last-below-line))
1042 (c-forward-comment large-enough)
1043 (when (c-forward-comment -1)
1044 ;; Record position of first comment.
1046 (c-forward-comment 1)
1047 (setq literal-pos (point)))
1048 (c-forward-comment large-enough)))
1049 (unless last-below-line
1051 (re-search-forward "\\(^\\|[^\\]\\)$" last t))
1052 (setq last-below-line last)))
1053 (cond ((bobp) ; Must handle bob specially.
1058 ((progn (backward-char)
1059 (looking-at "[;{}]"))
1060 (if (and c-special-brace-lists
1061 (eq (char-after) ?{)
1062 (c-looking-at-special-brace-list))
1063 (skip-syntax-backward "w_") ; Speedup only.
1064 (if (or (= here last)
1065 (memq (char-after last) '(?\) ?})))
1066 (if (and (eq (char-before) ?})
1067 (eq (char-after) ?\;))
1071 ((= (char-syntax (char-after)) ?\")
1072 (let ((end (point)))
1076 (skip-chars-forward "^\n" end)
1077 (when (< (point) end)
1078 ;; Break at multiline string.
1079 (setq literal-pos (1+ end))
1081 (t (skip-syntax-backward "w_")) ; Speedup only.
1083 (if (and (numberp literal-pos)
1084 (< (point) literal-pos))
1085 ;; We jumped over a comment or string that
1086 ;; should be investigated.
1087 (goto-char literal-pos)
1088 (setq count (1- count))))
1090 (goto-char (point-min))
1093 ;; Stop before `{', `}', and `#' when it's at boi on a
1094 ;; line, but on the other side of the syntactic ws, and
1095 ;; after `;', `}' and `};'. Only stop before `{' if at
1096 ;; top level or inside braces, though. Move by sexps
1097 ;; and move into parens. Also stop at eol of lines
1098 ;; with `#' at the boi.
1099 (let ((literal-pos (not sentence-flag))
1100 (large-enough (point-max))
1106 (c-forward-comment large-enough)
1108 (skip-chars-forward " \t\n\r\f")
1109 ;; Record position of first comment.
1110 (setq literal-pos (point))
1111 (c-forward-comment 1))
1112 (c-forward-comment large-enough)
1113 (setq literal-pos nil)))
1114 (cond ((and (eq (char-after) ?{)
1115 (not (and c-special-brace-lists
1116 (c-looking-at-special-brace-list)))
1119 (or (not (c-safe (up-list -1) t))
1120 (= (char-after) ?{))))
1123 ((and c-special-brace-lists
1124 (eq (char-after) ?})
1126 (and (c-safe (up-list -1) t)
1127 (c-looking-at-special-brace-list))))
1129 (skip-syntax-forward "w_")) ; Speedup only.
1130 ((and (eq (char-after) ?})
1134 ((and (eq (char-after) ?#)
1135 (= (point) (c-point 'boi)))
1137 (or (re-search-forward "\\(^\\|[^\\]\\)$" nil t)
1138 (goto-char (point-max)))
1141 ((looking-at ";\\|};?")
1142 (goto-char (match-end 0))
1144 ((= (char-syntax (char-after)) ?\")
1145 (let ((beg (point)))
1148 (skip-chars-backward "^\n" beg)
1149 (when (> (point) beg)
1150 ;; Break at multiline string.
1151 (setq literal-pos beg)
1155 (skip-syntax-forward "w_")) ; Speedup only.
1157 (if (and (numberp literal-pos)
1158 (> (point) literal-pos))
1159 ;; We jumped over a comment that should be investigated.
1160 (goto-char literal-pos)
1161 (setq count (1+ count))))
1163 (goto-char (point-max))
1166 ;; If we haven't moved we're near a buffer limit.
1167 (when (and (not (zerop count)) (= (point) here))
1168 (goto-char (if (> count 0) (point-min) (point-max)))
1170 (c-keep-region-active))
1172 (defun c-end-of-statement (&optional count lim sentence-flag)
1173 "Go to the end of the innermost C statement.
1174 With prefix arg, go forward N - 1 statements. Move forward to the end
1175 of the next statement if already at end, and move into nested blocks
1176 \(use \\[forward-sexp] to skip over a block). If within or next to a
1177 comment or multiline string, move by sentences instead of statements.
1179 When called from a program, this function takes 3 optional args: the
1180 repetition count, a buffer position limit which is the farthest back
1181 to search for the syntactic context, and a flag saying whether to do
1182 sentence motion in or near comments and multiline strings."
1183 (interactive (list (prefix-numeric-value current-prefix-arg)
1185 (c-beginning-of-statement (- (or count 1)) lim sentence-flag)
1186 (c-keep-region-active))
1189 ;; set up electric character functions to work with pending-del,
1190 ;; (a.k.a. delsel) mode. All symbols get the t value except
1191 ;; the functions which delete, which gets 'supersede.
1195 (put sym 'delete-selection t) ; for delsel (Emacs)
1196 (put sym 'pending-delete t))) ; for pending-del (XEmacs)
1201 c-electric-semi&comma
1205 (put 'c-electric-delete 'delete-selection 'supersede) ; delsel
1206 (put 'c-electric-delete 'pending-delete 'supersede) ; pending-del
1207 (put 'c-electric-backspace 'delete-selection 'supersede) ; delsel
1208 (put 'c-electric-backspace 'pending-delete 'supersede) ; pending-del
1209 (put 'c-electric-delete-forward 'delete-selection 'supersede) ; delsel
1210 (put 'c-electric-delete-forward 'pending-delete 'supersede) ; pending-del
1213 ;; This is used by indent-for-comment to decide how much to indent a
1214 ;; comment in C code based on its context.
1215 (defun c-comment-indent ()
1216 (if (looking-at (concat "^\\(" c-comment-start-regexp "\\)"))
1217 0 ;Existing comment at bol stays there.
1218 (let ((opoint (point))
1223 ;; CASE 1: A comment following a solitary close-brace should
1224 ;; have only one space.
1225 ((looking-at (concat "[ \t]*}[ \t]*\\($\\|"
1226 c-comment-start-regexp
1228 (search-forward "}")
1229 (1+ (current-column)))
1230 ;; CASE 2: 2 spaces after #endif
1231 ((or (looking-at "[ \t]*#[ \t]*endif[ \t]*")
1232 (looking-at "[ \t]*#[ \t]*else[ \t]*"))
1234 ;; CASE 3: when c-indent-comments-syntactically-p is t,
1235 ;; calculate the offset according to c-offsets-alist.
1236 ;; E.g. identical to hitting TAB.
1237 ((and c-indent-comments-syntactically-p
1239 (skip-chars-forward " \t")
1240 (or (looking-at c-comment-start-regexp)
1242 (let ((syntax (c-guess-basic-syntax)))
1243 ;; BOGOSITY ALERT: if we're looking at the eol, its
1244 ;; because indent-for-comment hasn't put the comment-start
1245 ;; in the buffer yet. this will screw up the syntactic
1246 ;; analysis so we kludge in the necessary info. Another
1247 ;; kludge is that if we're at the bol, then we really want
1248 ;; to ignore any anchoring as specified by
1249 ;; c-comment-only-line-offset since it doesn't apply here.
1251 (back-to-indentation)
1253 (c-add-syntax 'comment-intro))
1254 (let ((c-comment-only-line-offset
1255 (if (consp c-comment-only-line-offset)
1256 c-comment-only-line-offset
1257 (cons c-comment-only-line-offset
1258 c-comment-only-line-offset))))
1259 (c-get-syntactic-indentation syntax))))
1260 ;; CASE 4: If previous line is a comment-only line, use its
1261 ;; indentation if it's greater than comment-column. Leave at
1262 ;; least one space between the comment and the last nonblank
1263 ;; character in any case.
1268 (skip-chars-forward " \t")
1270 (looking-at c-comment-start-regexp)
1271 (setq placeholder (current-column))))
1273 (skip-chars-backward " \t")
1274 (max (if (bolp) 0 (1+ (current-column)))
1277 ;; CASE 5: If comment-column is 0, and nothing but space
1278 ;; before the comment, align it at 0 rather than 1.
1281 (skip-chars-backward " \t")
1282 (and (= comment-column 0) (bolp)))
1284 ;; CASE 6: indent at comment column except leave at least one
1286 (t (max (1+ (current-column))
1291 ;; used by outline-minor-mode
1292 (defun c-outline-level ()
1293 ;; This so that `current-column' DTRT in otherwise-hidden text.
1294 (let (buffer-invisibility-spec)
1296 (skip-chars-forward "\t ")
1300 (defun c-up-conditional (count)
1301 "Move back to the containing preprocessor conditional, leaving mark behind.
1302 A prefix argument acts as a repeat count. With a negative argument,
1303 move forward to the end of the containing preprocessor conditional.
1305 `#elif' is treated like `#else' followed by `#if', so the function
1306 stops at them when going backward, but not when going forward."
1308 (c-forward-conditional (- count) -1)
1309 (c-keep-region-active))
1311 (defun c-up-conditional-with-else (count)
1312 "Move back to the containing preprocessor conditional, including `#else'.
1313 Just like `c-up-conditional', except it also stops at `#else'
1316 (c-forward-conditional (- count) -1 t)
1317 (c-keep-region-active))
1319 (defun c-down-conditional (count)
1320 "Move forward into the next preprocessor conditional, leaving mark behind.
1321 A prefix argument acts as a repeat count. With a negative argument,
1322 move backward into the previous preprocessor conditional.
1324 `#elif' is treated like `#else' followed by `#if', so the function
1325 stops at them when going forward, but not when going backward."
1327 (c-forward-conditional count 1)
1328 (c-keep-region-active))
1330 (defun c-down-conditional-with-else (count)
1331 "Move forward into the next preprocessor conditional, including `#else'.
1332 Just like `c-down-conditional', except it also stops at `#else'
1335 (c-forward-conditional count 1 t)
1336 (c-keep-region-active))
1338 (defun c-backward-conditional (count &optional target-depth with-else)
1339 "Move back across a preprocessor conditional, leaving mark behind.
1340 A prefix argument acts as a repeat count. With a negative argument,
1341 move forward across a preprocessor conditional."
1343 (c-forward-conditional (- count) target-depth with-else)
1344 (c-keep-region-active))
1346 (defun c-forward-conditional (count &optional target-depth with-else)
1347 "Move forward across a preprocessor conditional, leaving mark behind.
1348 A prefix argument acts as a repeat count. With a negative argument,
1349 move backward across a preprocessor conditional.
1351 `#elif' is treated like `#else' followed by `#if', except that the
1352 nesting level isn't changed when tracking subconditionals.
1354 The optional argument TARGET-DEPTH specifies the wanted nesting depth
1355 after each scan. I.e. if TARGET-DEPTH is -1, the function will move
1356 out of the enclosing conditional. A non-integer non-nil TARGET-DEPTH
1359 If the optional argument WITH-ELSE is non-nil, `#else' directives are
1360 treated as conditional clause limits. Normally they are ignored."
1362 (let* ((forward (> count 0))
1363 (increment (if forward -1 1))
1364 (search-function (if forward 're-search-forward 're-search-backward))
1366 (unless (integerp target-depth)
1367 (setq target-depth (if target-depth -1 0)))
1371 ;; subdepth is the depth in "uninteresting" subtrees,
1372 ;; i.e. those that takes us farther from the target
1373 ;; depth instead of closer.
1377 ;; Find the "next" significant line in the proper direction.
1378 (while (and (not found)
1379 ;; Rather than searching for a # sign that
1380 ;; comes at the beginning of a line aside from
1381 ;; whitespace, search first for a string
1382 ;; starting with # sign. Then verify what
1383 ;; precedes it. This is faster on account of
1384 ;; the fastmap feature of the regexp matcher.
1385 (funcall search-function
1386 "#[ \t]*\\(if\\|elif\\|endif\\|else\\)"
1389 ;; Now verify it is really a preproc line.
1390 (if (looking-at "^[ \t]*#[ \t]*\\(if\\|elif\\|endif\\|else\\)")
1391 (let (dchange (directive (match-string 1)))
1392 (cond ((string= directive "if")
1393 (setq dchange (- increment)))
1394 ((string= directive "endif")
1395 (setq dchange increment))
1397 ;; When we're not in an "uninteresting"
1398 ;; subtree, we might want to act on "elif"
1400 (if (cond (with-else
1401 ;; Always move toward the target depth.
1403 (if (> target-depth 0) 1 -1)))
1404 ((string= directive "elif")
1405 (setq dchange (- increment))))
1406 ;; Ignore the change if it'd take us
1407 ;; into an "uninteresting" subtree.
1408 (if (eq (> dchange 0) (<= target-depth 0))
1409 (setq dchange nil)))))
1411 (when (or (/= subdepth 0)
1412 (eq (> dchange 0) (<= target-depth 0)))
1413 (setq subdepth (+ subdepth dchange)))
1414 (setq depth (+ depth dchange))
1415 ;; If we are trying to move across, and we find an
1416 ;; end before we find a beginning, get an error.
1417 (if (and (< depth target-depth) (< dchange 0))
1419 "No following conditional at this level"
1420 "No previous conditional at this level"))))
1421 ;; When searching forward, start from next line so
1422 ;; that we don't find the same line again.
1423 (if forward (forward-line 1))
1424 ;; We found something if we've arrived at the
1426 (if (and dchange (= depth target-depth))
1427 (setq found (point))))
1429 (if forward (forward-line 1)))))
1431 (error "No containing preprocessor conditional"))
1432 (goto-char (setq new found)))
1433 (setq count (+ count increment))))
1436 (c-keep-region-active))
1439 ;; commands to indent lines, regions, defuns, and expressions
1440 (defun c-indent-command (&optional arg)
1441 "Indent current line as C code, and/or insert some whitespace.
1443 If `c-tab-always-indent' is t, always just indent the current line.
1444 If nil, indent the current line only if point is at the left margin or
1445 in the line's indentation; otherwise insert some whitespace[*]. If
1446 other than nil or t, then some whitespace[*] is inserted only within
1447 literals (comments and strings) and inside preprocessor directives,
1448 but the line is always reindented.
1450 If `c-syntactic-indentation' is t, indentation is done according to
1451 the syntactic context. If it's nil, the line is just indented one
1452 step according to `c-basic-offset'. In this mode, a numeric argument
1453 indents a number of such steps, positive or negative, and an empty
1454 prefix argument is equivalent to -1.
1456 If `c-syntactic-indentation' is t, then a numeric argument, regardless
1457 of its value, means indent rigidly all the lines of the expression
1458 starting after point so that this line becomes properly indented. The
1459 relative indentation among the lines of the expression is preserved.
1461 [*] The amount and kind of whitespace inserted is controlled by the
1462 variable `c-insert-tab-function', which is called to do the actual
1463 insertion of whitespace. Normally the function in this variable
1464 just inserts a tab character, or the equivalent number of spaces,
1465 depending on the variable `indent-tabs-mode'."
1468 (let ((bod (c-point 'bod))
1470 (if c-syntactic-indentation
1471 (symbol-function 'indent-according-to-mode)
1473 (let ((steps (cond ((not current-prefix-arg) 1)
1474 ((equal current-prefix-arg '(4)) -1)
1476 (c-shift-line-indentation (* steps c-basic-offset)))
1478 (if (and c-syntactic-indentation current-prefix-arg)
1479 ;; If c-syntactic-indentation and got arg, always indent this
1480 ;; line as C and shift remaining lines of expression the same
1482 (let ((shift-amt (save-excursion
1483 (back-to-indentation)
1487 (setq shift-amt (- (save-excursion
1488 (back-to-indentation)
1492 (if (eq c-tab-always-indent t)
1493 (beginning-of-line))
1501 (indent-code-rigidly beg end shift-amt "#")))
1502 ;; Else use c-tab-always-indent to determine behavior.
1504 ;; CASE 1: indent when at column zero or in lines indentation,
1505 ;; otherwise insert a tab
1506 ((not c-tab-always-indent)
1508 (skip-chars-backward " \t")
1510 (funcall c-insert-tab-function)
1511 (funcall indent-function)))
1512 ;; CASE 2: just indent the line
1513 ((eq c-tab-always-indent t)
1514 (funcall indent-function))
1515 ;; CASE 3: if in a literal, insert a tab, but always indent the
1518 (if (c-in-literal bod)
1519 (funcall c-insert-tab-function))
1520 (funcall indent-function)
1523 (defun c-indent-exp (&optional shutup-p)
1524 "Indent each line in the balanced expression following point syntactically.
1525 If optional SHUTUP-P is non-nil, no errors are signalled if no
1526 balanced expression is found."
1528 (let ((here (point-marker))
1530 (set-marker-insertion-type here t)
1533 ;; try to be smarter about finding the range of
1534 ;; lines to indent. skip all following
1535 ;; whitespace, then try to find any
1536 ;; opening paren on the current line
1537 (skip-chars-forward " \t\n")
1539 (narrow-to-region (point-min) (c-point 'eol))
1540 (c-safe (1- (scan-lists (point) 1 -1)))))))
1541 ;; find balanced expression end
1542 (setq end (and (c-safe (progn (c-forward-sexp 1) t))
1547 (error "Cannot find start of balanced expression to indent"))
1550 (setq start (point))
1553 (error "Cannot find end of balanced expression to indent"))
1555 (c-indent-region start end)))))
1557 (set-marker here nil))))
1559 (defun c-indent-defun ()
1560 "Indent the current top-level function def, struct or class declaration
1563 (let ((here (point-marker))
1564 (c-echo-syntactic-information-p nil)
1565 (brace (c-least-enclosing-brace (c-parse-state))))
1566 (goto-char (or brace (c-point 'bod)))
1567 ;; if we're sitting at b-o-b, it might be because there was no
1568 ;; least enclosing brace and we were sitting on the defun's open
1570 (if (and (bobp) (not (eq (char-after) ?\{)))
1572 ;; if defun-prompt-regexp is non-nil, b-o-d might not leave us at
1573 ;; the open brace. I consider this an Emacs bug.
1574 (and (boundp 'defun-prompt-regexp)
1576 (looking-at defun-prompt-regexp)
1577 (goto-char (match-end 0)))
1578 ;; catch all errors in c-indent-exp so we can 1. give more
1579 ;; meaningful error message, and 2. restore point
1583 (set-marker here nil))))
1585 (defun c-indent-region (start end &optional quiet)
1586 "Indent every line whose first char is between START and END inclusive.
1587 Be silent about syntactic errors if the optional argument QUIET is non-nil."
1590 ;; Advance to first nonblank line.
1591 (skip-chars-forward " \t\n")
1593 (setq c-parsing-error
1594 (or (let ((endmark (copy-marker end))
1595 (c-parsing-error nil)
1596 ;; shut up any echo msgs on indiv lines
1597 (c-echo-syntactic-information-p nil))
1600 (c-progress-init start end 'c-indent-region)
1603 (< (point) endmark))
1607 (skip-chars-forward " \t\n")
1609 ;; indent the current line
1610 (c-indent-line nil t)
1612 (set-marker endmark nil)
1613 (c-progress-fini 'c-indent-region))
1614 (c-echo-parsing-error quiet))
1617 (defun c-mark-function ()
1618 "Put mark at end of current top-level defun, point at beginning."
1620 (let ((here (point))
1621 (eod (c-point 'eod))
1622 (state (c-parse-state)))
1623 ;; Are we sitting at the top level, someplace between either the
1624 ;; beginning of buffer, or the nearest preceding defun? If so,
1625 ;; try first to figure out whether we're sitting on the
1626 ;; introduction to a top-level defun, in which case we want to
1627 ;; mark the entire defun we're sitting on.
1629 ;; If we're sitting on anything else at the top-level, we want to
1630 ;; just mark the statement that we're on
1631 (if (or (and (consp (car state))
1632 (= (length state) 1))
1634 ;; Are we in the whitespace after the nearest preceding defun?
1636 (looking-at "[ \t]*$")
1638 (c-backward-syntactic-ws)
1639 (skip-chars-backward ";")
1644 (goto-char (car (car state)))
1645 (c-beginning-of-statement-1))
1646 (if (= ?{ (save-excursion
1647 (c-end-of-statement-1)
1649 ;; We must be in a defuns's introduction
1651 (c-end-of-statement-1)
1652 (skip-chars-backward "{")
1653 (c-beginning-of-statement-1)
1654 (c-forward-syntactic-ws))
1655 ;; Just mark the statement
1656 (c-end-of-statement-1)
1659 (c-beginning-of-statement-1)))
1660 ;; We are inside some enclosing brace structure, so we first
1661 ;; need to find our way to the least enclosing brace. Then, in
1662 ;; both cases, we to mark the region from the beginning of the
1663 ;; current statement, until the end of the next following defun
1665 (or (consp (car state))
1666 (goto-char (car state)))
1667 (setq state (cdr state)))
1668 (c-beginning-of-statement-1))
1670 (push-mark eod nil t)))
1672 (defun c-fn-region-is-active-p ()
1673 ;; Function version of the macro for use in places that aren't
1674 ;; compiled, e.g. in the menus.
1675 (c-region-is-active-p))
1677 (defun c-indent-line-or-region ()
1678 "When the region is active, indent it. Otherwise indent the current line."
1679 ;; Emacs has a variable called mark-active, XEmacs uses region-active-p
1681 (if (c-region-is-active-p)
1682 (c-indent-region (region-beginning) (region-end))
1683 (indent-according-to-mode)))
1686 ;; for progress reporting
1687 (defvar c-progress-info nil)
1689 (defun c-progress-init (start end context)
1692 ((not c-progress-interval))
1693 ;; Start the progress update messages. If this Emacs doesn't have
1694 ;; a built-in timer, just be dumb about it.
1695 ((not (fboundp 'current-time))
1696 (message "Indenting region... (this may take a while)"))
1697 ;; If progress has already been initialized, do nothing. otherwise
1698 ;; initialize the counter with a vector of:
1699 ;; [start end lastsec context]
1701 (t (setq c-progress-info (vector start
1705 (nth 1 (current-time))
1707 (message "Indenting region..."))
1710 (defun c-progress-update ()
1712 (if (not (and c-progress-info c-progress-interval))
1714 (let ((now (nth 1 (current-time)))
1715 (start (aref c-progress-info 0))
1716 (end (aref c-progress-info 1))
1717 (lastsecs (aref c-progress-info 2)))
1718 ;; should we update? currently, update happens every 2 seconds,
1719 ;; what's the right value?
1720 (if (< c-progress-interval (- now lastsecs))
1722 (message "Indenting region... (%d%% complete)"
1723 (/ (* 100 (- (point) start)) (- end start)))
1724 (aset c-progress-info 2 now)))
1727 (defun c-progress-fini (context)
1729 (if (not c-progress-interval)
1731 (if (or (eq context (aref c-progress-info 3))
1734 (set-marker (aref c-progress-info 1) nil)
1735 (setq c-progress-info nil)
1736 (message "Indenting region... done")))))
1740 ;;; This page handles insertion and removal of backslashes for C macros.
1742 (defun c-backslash-region (from to delete-flag)
1743 "Insert, align, or delete end-of-line backslashes on the lines in the region.
1744 With no argument, inserts backslashes and aligns existing backslashes.
1745 With an argument, deletes the backslashes.
1747 This function does not modify blank lines at the start of the region.
1748 If the region ends at the start of a line, it always deletes the
1749 backslash (if any) at the end of the previous line.
1751 You can put the region around an entire macro definition and use this
1752 command to conveniently insert and align the necessary backslashes."
1753 (interactive "*r\nP")
1756 (let ((column c-backslash-column)
1757 (endmark (make-marker)))
1758 (move-marker endmark to)
1759 ;; Compute the smallest column number past the ends of all the lines.
1760 (if (not delete-flag)
1761 (while (< (point) to)
1763 (if (eq (char-before) ?\\)
1764 (progn (forward-char -1)
1765 (skip-chars-backward " \t")))
1766 (setq column (max column (1+ (current-column))))
1768 ;; Adjust upward to a tab column, if that doesn't push past the margin.
1769 (if (> (% column tab-width) 0)
1770 (let ((adjusted (* (/ (+ column tab-width -1) tab-width) tab-width)))
1771 (if (< adjusted (window-width))
1772 (setq column adjusted))))
1773 ;; Don't modify blank lines at start of region.
1775 (while (and (< (point) endmark) (eolp))
1777 ;; Add or remove backslashes on all the lines.
1778 (while (< (point) endmark)
1779 (if (and (not delete-flag)
1780 ;; Un-backslashify the last line
1781 ;; if the region ends right at the start of the next line.
1784 (< (point) endmark)))
1785 (c-append-backslash column)
1786 (c-delete-backslash))
1788 (move-marker endmark nil))))
1790 (defun c-append-backslash (column)
1792 (if (eq (char-before) ?\\)
1793 (progn (forward-char -1)
1794 (delete-horizontal-space)
1799 (defun c-delete-backslash ()
1804 (if (looking-at "\\\\")
1805 (delete-region (1+ (point))
1806 (progn (skip-chars-backward " \t") (point)))))))
1810 ;;; Line breaking and paragraph filling.
1812 (defvar c-auto-fill-prefix t)
1813 (defvar c-lit-limits nil)
1814 (defvar c-lit-type nil)
1816 ;; The filling code is based on a simple theory; leave the intricacies
1817 ;; of the text handling to the currently active mode for that
1818 ;; (e.g. adaptive-fill-mode or filladapt-mode) and do as little as
1819 ;; possible to make them work correctly wrt the comment and string
1820 ;; separators, one-line paragraphs etc. Unfortunately, when it comes
1821 ;; to it, there's quite a lot of special cases to handle which makes
1822 ;; the code anything but simple. The intention is that it will work
1823 ;; with any well-written text filling package that preserves a fill
1826 ;; We temporarily mask comment starters and enders as necessary for
1827 ;; the filling code to do its job on a seemingly normal text block.
1828 ;; We do _not_ mask the fill prefix, so it's up to the filling code to
1829 ;; preserve it correctly (especially important when filling C++ style
1830 ;; line comments). By default, we set up and use adaptive-fill-mode,
1831 ;; which is standard in all supported Emacs flavors.
1833 (defun c-guess-fill-prefix (lit-limits lit-type)
1834 ;; Determine the appropriate comment fill prefix for a block or line
1835 ;; comment. Return a cons of the prefix string and the column where
1836 ;; it ends. If fill-prefix is set, it'll override. Note that this
1837 ;; function also uses the value of point in some heuristics.
1838 (let* ((here (point))
1839 (prefix-regexp (concat "[ \t]*\\("
1840 c-current-comment-prefix
1842 (comment-start-regexp (if (eq lit-type 'c++)
1844 comment-start-skip))
1845 prefix-line comment-prefix res comment-text-end)
1848 (setq res (cons fill-prefix
1849 ;; Ugly way of getting the column after the fill
1850 ;; prefix; it'd be nice with a current-column
1851 ;; that works on strings..
1852 (let ((buffer-modified (buffer-modified-p))
1853 (buffer-undo-list t)
1857 (insert ?\n fill-prefix)
1859 (delete-region start (point))
1860 (set-buffer-modified-p buffer-modified))))))
1863 ;; Set fallback for comment-prefix if none is found.
1864 (setq comment-prefix "// "
1865 comment-text-end (cdr lit-limits))
1867 (if (> (point) (car lit-limits))
1868 ;; The current line is not the comment starter, so the
1869 ;; comment has more than one line, and it can therefore be
1870 ;; used to find the comment fill prefix.
1871 (setq prefix-line (point))
1872 (goto-char (car lit-limits))
1873 (if (and (= (forward-line 1) 0)
1874 (< (point) (cdr lit-limits)))
1875 ;; The line after the comment starter is inside the
1876 ;; comment, so we can use it.
1877 (setq prefix-line (point))
1878 ;; The comment is only one line. Take the comment prefix
1879 ;; from it and keep the indentation.
1880 (goto-char (car lit-limits))
1881 (if (looking-at prefix-regexp)
1882 (goto-char (match-end 0))
1884 (skip-chars-forward " \t"))
1886 (if (eq (c-point 'boi) (car lit-limits))
1887 ;; There is only whitespace before the comment
1888 ;; starter; take the prefix straight from this
1890 (cons (buffer-substring-no-properties
1891 (c-point 'bol) (point))
1893 ;; There is code before the comment starter, so we
1894 ;; have to temporarily insert and indent a new
1895 ;; line to get the right space/tab mix in the
1897 (let ((buffer-modified (buffer-modified-p))
1898 (buffer-undo-list t)
1899 (prefix-len (- (point) (car lit-limits)))
1903 (goto-char (car lit-limits))
1904 (indent-to (prog1 (current-column)
1907 (forward-char prefix-len)
1908 (cons (buffer-substring-no-properties
1909 (c-point 'bol) (point))
1911 (delete-region (car lit-limits) tmp)
1912 (set-buffer-modified-p buffer-modified))))
1916 (setq comment-text-end (- (cdr lit-limits) 2))
1918 (if (and (> (point) (car lit-limits))
1919 (not (and (looking-at "[ \t]*\\*/")
1920 (eq (cdr lit-limits) (match-end 0)))))
1921 ;; The current line is not the comment starter and
1922 ;; contains more than just the ender, so it's good enough
1923 ;; to be used for the comment fill prefix.
1924 (setq prefix-line (point))
1925 (goto-char (car lit-limits))
1926 (if (or (/= (forward-line 1) 0)
1927 (>= (point) (cdr lit-limits))
1928 (and (looking-at "[ \t]*\\*/")
1929 (eq (cdr lit-limits) (match-end 0)))
1930 (and (looking-at prefix-regexp)
1931 (<= (1- (cdr lit-limits)) (match-end 0)))
1932 (and (< here (point))
1933 (or (not (match-beginning 0))
1934 (looking-at "[ \t]*$"))))
1935 ;; The comment is either one line or the next line
1936 ;; contains just the comment ender. Also, if point is
1937 ;; on the comment opener line and the following line is
1938 ;; empty or doesn't match c-current-comment-prefix we
1939 ;; assume that this is in fact a not yet closed one line
1940 ;; comment, so we shouldn't look for the comment prefix
1941 ;; on the next line. In these cases we have no
1942 ;; information about a suitable comment prefix, so we
1943 ;; resort to c-block-comment-prefix.
1944 (setq comment-prefix (or c-block-comment-prefix "")
1945 res (let ((buffer-modified (buffer-modified-p))
1946 (buffer-undo-list t)
1948 ;; The comment doesn't give any information
1949 ;; about the indentation column. We'll have to
1950 ;; temporarily insert a new comment line and
1951 ;; indent it to find the correct column.
1954 (goto-char (car lit-limits))
1955 (if (looking-at comment-start-regexp)
1956 (goto-char (match-end 0))
1958 (skip-chars-forward " \t"))
1959 (when (eq (char-syntax (char-before)) ?\ )
1960 ;; If there's ws on the current
1961 ;; line, we'll use it instead of
1962 ;; what's ending comment-prefix.
1963 (setq comment-prefix
1964 (concat (substring comment-prefix
1968 (buffer-substring-no-properties
1970 (skip-chars-backward " \t")
1973 (setq tmp-pre (point-marker))
1974 ;; We insert an extra non-whitespace
1975 ;; character before the line break and
1976 ;; after comment-prefix in case it's
1977 ;; "" or ends with whitespace.
1978 (insert "x\n" comment-prefix ?x)
1979 (setq tmp-post (point-marker))
1980 (indent-according-to-mode)
1981 (goto-char (1- tmp-post))
1982 (cons (buffer-substring-no-properties
1983 (c-point 'bol) (point))
1986 (delete-region tmp-pre tmp-post)
1987 (set-marker tmp-pre nil)
1988 (set-marker tmp-post nil))
1989 (set-buffer-modified-p buffer-modified))))
1990 ;; Otherwise the line after the comment starter is good
1991 ;; enough to find the prefix in.
1992 (setq prefix-line (point)))))))
1995 ;; prefix-line is the bol of a line on which we should try
1996 ;; to find the prefix.
1997 (let* (fb-string fb-endpos ; Contains any fallback prefix found.
2000 (when (and (looking-at prefix-regexp)
2001 (<= (match-end 0) comment-text-end))
2002 (unless (eq (match-end 0) (c-point 'eol))
2003 ;; The match is fine if there's text after it.
2004 (throw 'found (cons (buffer-substring-no-properties
2005 (match-beginning 0) (match-end 0))
2006 (progn (goto-char (match-end 0))
2007 (current-column)))))
2009 ;; This match is better than nothing, so let's
2010 ;; remember it in case nothing better is found
2012 (setq fb-string (buffer-substring-no-properties
2013 (match-beginning 0) (match-end 0))
2014 fb-endpos (match-end 0)))
2017 ;; Search for a line which has text after the prefix
2018 ;; so that we get the proper amount of whitespace
2019 ;; after it. We start with the current line, then
2020 ;; search backwards, then forwards.
2021 (goto-char prefix-line)
2022 (when (and (funcall test-line)
2023 (or (/= (match-end 1) (match-end 0))
2024 ;; The whitespace is sucked up by the
2025 ;; first [ \t]* glob if the prefix is empty.
2026 (and (= (match-beginning 1) (match-end 1))
2027 (/= (match-beginning 0) (match-end 0)))))
2028 ;; If the current line doesn't have text but do
2029 ;; have whitespace after the prefix, we'll use it.
2030 (throw 'found (cons fb-string
2031 (progn (goto-char fb-endpos)
2032 (current-column)))))
2033 (if (eq lit-type 'c++)
2034 ;; For line comments we can search up to and
2035 ;; including the first line.
2036 (while (and (zerop (forward-line -1))
2037 (>= (point) (car lit-limits)))
2038 (funcall test-line))
2039 ;; For block comments we must stop before the
2041 (while (and (zerop (forward-line -1))
2042 (> (point) (car lit-limits)))
2043 (funcall test-line)))
2044 (goto-char prefix-line)
2045 (while (and (zerop (forward-line 1))
2046 (< (point) (cdr lit-limits)))
2047 (funcall test-line))
2048 (goto-char prefix-line)
2051 ;; A good line wasn't found, but at least we have a
2052 ;; fallback that matches the comment prefix regexp.
2053 (cond ((string-match "\\s \\'" fb-string)
2054 ;; There are ws after the prefix, so let's use it.
2056 (progn (goto-char fb-endpos) (current-column))))
2058 ;; Check if there's any whitespace padding
2059 ;; on the comment start line that we can
2060 ;; use after the prefix.
2061 (goto-char (car lit-limits))
2062 (if (looking-at comment-start-regexp)
2063 (goto-char (match-end 0))
2065 (skip-chars-forward " \t"))
2066 (eq (char-syntax (char-before)) ?\ ))
2067 (setq fb-string (buffer-substring-no-properties
2069 (skip-chars-backward " \t")
2072 (goto-char fb-endpos)
2073 (skip-chars-backward " \t")
2074 (let ((buffer-modified (buffer-modified-p))
2075 (buffer-undo-list t)
2077 ;; Got to mess in the buffer once again to
2078 ;; ensure the column gets correct. :P
2082 (cons (buffer-substring-no-properties
2086 (delete-region tmp (point))
2087 (set-buffer-modified-p buffer-modified))))
2089 ;; Last resort: Just add a single space after
2091 (cons (concat fb-string " ")
2092 (progn (goto-char fb-endpos)
2093 (1+ (current-column)))))))
2094 ;; The line doesn't match the comment prefix regexp.
2096 ;; We have a fallback for line comments that we must use.
2097 (cons (concat (buffer-substring-no-properties
2098 prefix-line (c-point 'boi))
2100 (progn (back-to-indentation)
2101 (+ (current-column) (length comment-prefix))))
2102 ;; Assume we are dealing with a "free text" block
2103 ;; comment where the lines doesn't have any comment
2104 ;; prefix at all and we should just fill it as
2109 (defun c-fill-paragraph (&optional arg)
2110 "Like \\[fill-paragraph] but handles C and C++ style comments.
2111 If any of the current line is a comment or within a comment, fill the
2112 comment or the paragraph of it that point is in, preserving the
2113 comment indentation or line-starting decorations (see the
2114 `c-comment-prefix-regexp' and `c-block-comment-prefix' variables for
2117 If point is inside multiline string literal, fill it. This currently
2118 does not respect escaped newlines, except for the special case when it
2119 is the very first thing in the string. The intended use for this rule
2120 is in situations like the following:
2122 char description[] = \"\\
2123 A very long description of something that you want to fill to make
2124 nicely formatted output.\"\;
2126 If point is in any other situation, i.e. in normal code, do nothing.
2128 Optional prefix ARG means justify paragraph as well."
2130 (let (lit-limits lit-type fill
2131 ;; beg and end limits the region to be filled. end is a marker.
2133 ;; tmp-pre and tmp-post mark strings that are temporarily
2134 ;; inserted at the start and end of the region. tmp-pre is a
2135 ;; cons of the positions of the prepended string. tmp-post is
2136 ;; a marker pointing to the single character of the appended
2139 ;; If hang-ender-stuck isn't nil, the comment ender is
2140 ;; hanging. In that case it's set to the number of spaces
2141 ;; that should be between the text and the ender.
2144 ;; Restore point on undo. It's necessary since we do a lot of
2145 ;; hidden inserts and deletes below that should be as transparent
2147 (if (and buffer-undo-list (not (eq buffer-undo-list t)))
2148 (setq buffer-undo-list (cons (point) buffer-undo-list)))
2150 ;; Widen to catch comment limits correctly.
2152 (setq lit-limits (c-collect-line-comments (c-literal-limits nil t))
2153 lit-type (c-literal-type lit-limits)))
2155 (unless (c-safe (backward-char)
2159 (forward-paragraph))
2160 (setq end (point-marker)))
2162 (unless (c-safe (forward-char)
2163 (backward-paragraph)
2166 (backward-paragraph))
2171 ((eq lit-type 'c++) ; Line comment.
2173 ;; Fill to the comment or paragraph end, whichever
2175 (set-marker end (min end (cdr lit-limits)))
2176 (when (<= beg (car lit-limits))
2177 ;; The region to be filled includes the comment
2178 ;; starter, so we must check it.
2179 (goto-char (car lit-limits))
2180 (back-to-indentation)
2181 (if (eq (point) (car lit-limits))
2182 ;; Include the first line in the fill.
2183 (setq beg (c-point 'bol))
2184 ;; The first line contains code before the
2185 ;; comment. We must fake a line that doesn't.
2188 ((eq lit-type 'c) ; Block comment.
2189 (when (>= end (cdr lit-limits))
2190 ;; The region to be filled includes the comment ender.
2191 (unless (save-excursion
2192 (goto-char (cdr lit-limits))
2194 (and (looking-at (concat "[ \t]*\\("
2195 c-current-comment-prefix
2197 (eq (cdr lit-limits) (match-end 0))
2198 ;; Leave the comment ender on its own line.
2199 (set-marker end (point))))
2200 ;; The comment ender should hang. Replace all cruft
2201 ;; between it and the last word with one or two 'x'
2202 ;; and include it in the fill. We'll change them back
2203 ;; spaces afterwards.
2204 (let* ((ender-start (save-excursion
2205 (goto-char (cdr lit-limits))
2206 (skip-syntax-backward "^w ")
2208 (point-rel (- ender-start here))
2211 (goto-char (cdr lit-limits))
2212 (setq tmp-post (point-marker))
2214 (set-marker end (point))
2216 (if (and (looking-at (concat "[ \t]*\\(\\("
2217 c-current-comment-prefix
2219 (eq ender-start (match-end 0)))
2220 ;; The comment ender is prefixed by nothing
2221 ;; but a comment line prefix. Remove it
2222 ;; along with surrounding ws.
2223 (setq spaces (- (match-end 1) (match-end 2)))
2224 (goto-char ender-start))
2225 (skip-chars-backward " \t\r\n")
2226 (if (/= (point) ender-start)
2228 (if (<= here (point))
2229 ;; Don't adjust point below if it's
2230 ;; before the string we replace.
2231 (setq point-rel -1))
2232 ;; Keep one or two spaces between the text and
2233 ;; the ender, depending on how many there are now.
2234 (unless spaces (setq spaces (- ender-start (point))))
2235 (setq spaces (max (min spaces 2) 1))
2236 ;; Insert the filler first to keep marks right.
2237 (insert (make-string spaces ?x))
2238 (delete-region (point) (+ ender-start spaces))
2239 (setq hang-ender-stuck spaces)
2241 (and (>= point-rel 0)
2242 (- (point) (min point-rel spaces)))))
2243 (setq point-rel nil)))
2245 ;; Point was in the middle of the string we
2246 ;; replaced above, so put it back in the same
2247 ;; relative position, counting from the end.
2248 (goto-char point-rel))
2250 (when (<= beg (car lit-limits))
2251 ;; The region to be filled includes the comment starter.
2253 (goto-char (car lit-limits))
2254 (if (looking-at (concat "\\(" comment-start-skip "\\)$"))
2255 ;; Begin filling with the next line.
2256 (setq beg (c-point 'bonl))
2257 ;; Fake the fill prefix in the first line.
2258 (setq tmp-pre t)))))
2259 ((eq lit-type 'string) ; String.
2261 (when (>= end (cdr lit-limits))
2262 (goto-char (1- (cdr lit-limits)))
2263 (setq tmp-post (point-marker))
2265 (set-marker end (point)))
2266 (when (<= beg (car lit-limits))
2267 (goto-char (1+ (car lit-limits)))
2268 (setq beg (if (looking-at "\\\\$")
2269 ;; Leave the start line if it's
2270 ;; nothing but an escaped newline.
2275 ;; Temporarily insert the fill prefix after the comment
2276 ;; starter so that the first line looks like any other
2277 ;; comment line in the narrowed region.
2278 (setq fill (c-guess-fill-prefix lit-limits lit-type))
2279 (unless (string-match (concat "\\`[ \t]*\\("
2280 c-current-comment-prefix
2283 ;; Oops, the prefix doesn't match the comment prefix
2284 ;; regexp. This could produce very confusing
2285 ;; results with adaptive fill packages together with
2286 ;; the insert prefix magic below, since the prefix
2287 ;; often doesn't appear at all. So let's warn about
2290 Warning: Regexp from `c-comment-prefix-regexp' doesn't match the comment prefix %S"
2292 ;; Find the right spot on the line, break it, insert
2293 ;; the fill prefix and make sure we're back in the
2294 ;; same column by temporarily prefixing the first word
2295 ;; with a number of 'x'.
2297 (goto-char (car lit-limits))
2298 (if (looking-at (if (eq lit-type 'c++)
2299 c-current-comment-prefix
2300 comment-start-skip))
2301 (goto-char (match-end 0))
2303 (skip-chars-forward " \t"))
2304 (while (< (current-column) (cdr fill)) (forward-char 1))
2305 (let ((col (current-column)))
2306 (setq beg (1+ (point))
2307 tmp-pre (list (point)))
2310 (insert ?\n (car fill))
2311 (insert (make-string (- col (current-column)) ?x)))
2312 (setcdr tmp-pre (point))))))
2314 (let ((fill-paragraph-function
2315 ;; Avoid infinite recursion.
2316 (if (not (eq fill-paragraph-function 'c-fill-paragraph))
2317 fill-paragraph-function))
2320 ;; Kludge: If the function that adapts the fill prefix
2321 ;; doesn't produce the required comment starter for line
2322 ;; comments, then force it by setting fill-prefix.
2323 (when (and (eq lit-type 'c++)
2324 ;; Kludge the kludge: filladapt-mode doesn't
2325 ;; have this problem, but it doesn't override
2326 ;; fill-context-prefix currently (version
2328 (not (and (boundp 'filladapt-mode)
2332 (or (fill-context-prefix beg end)
2334 (car (or fill (c-guess-fill-prefix
2335 lit-limits lit-type))))))
2336 (point-rel (cond ((< here beg) (- here beg))
2337 ((> here end) (- here end)))))
2338 ;; Preparations finally done! Now we can call the
2339 ;; real fill function.
2341 (narrow-to-region beg end)
2342 (fill-paragraph arg))
2344 ;; Restore point if it was outside the region.
2346 (goto-char (+ beg point-rel))
2347 (goto-char (+ end point-rel))))
2349 (when (consp tmp-pre)
2350 (delete-region (car tmp-pre) (cdr tmp-pre)))
2353 (goto-char tmp-post)
2355 (when hang-ender-stuck
2356 ;; Preserve point even if it's in the middle of the string
2357 ;; we replace; save-excursion doesn't work in that case.
2359 (goto-char tmp-post)
2360 (skip-syntax-backward "^w ")
2361 (forward-char (- hang-ender-stuck))
2362 (insert (make-string hang-ender-stuck ?\ ))
2363 (delete-char hang-ender-stuck)
2365 (set-marker tmp-post nil))
2366 (set-marker end nil)))
2367 ;; Always return t. This has the effect that if filling isn't done
2368 ;; above, it isn't done at all, and it's therefore effectively
2369 ;; disabled in normal code.
2372 (defun c-do-auto-fill ()
2373 ;; Do automatic filling if not inside a context where it should be
2375 (let ((c-auto-fill-prefix
2376 ;; The decision whether the line should be broken is actually
2377 ;; done in c-indent-new-comment-line, which do-auto-fill
2378 ;; calls to break lines. We just set this special variable
2379 ;; so that we'll know when we're called from there. It's
2380 ;; also used to detect whether fill-prefix is user set or
2381 ;; generated automatically by do-auto-fill.
2385 (defun c-indent-new-comment-line (&optional soft)
2386 "Break line at point and indent, continuing comment if within one.
2387 If inside a comment and `comment-multi-line' is non-nil, the
2388 indentation and line prefix are preserved (see the
2389 `c-comment-prefix-regexp' and `c-block-comment-prefix' variables for
2390 details). If inside a single line comment and `comment-multi-line' is
2391 nil, a new comment of the same type is started on the next line and
2392 indented as appropriate for comments.
2394 If a fill prefix is specified, it overrides all the above."
2396 (let ((fill-prefix fill-prefix)
2399 (delete-region (progn (skip-chars-backward " \t") (point))
2400 (progn (skip-chars-forward " \t") (point)))
2401 (if soft (insert-and-inherit ?\n) (newline 1))))
2402 ;; Already know the literal type and limits when called from
2403 ;; c-context-line-break.
2404 (c-lit-limits c-lit-limits)
2405 (c-lit-type c-lit-type))
2406 (when (not (eq c-auto-fill-prefix t))
2407 ;; Called from do-auto-fill.
2408 (unless c-lit-limits
2409 (setq c-lit-limits (c-literal-limits nil nil t)))
2411 (setq c-lit-type (c-literal-type c-lit-limits)))
2412 (if (memq (cond ((eq c-lit-type 'pound)
2413 ;; Come to think about it, "pound" is a bit
2414 ;; of a misnomer, so call it "cpp" instead
2415 ;; in user interaction.
2417 ((null c-lit-type) 'code)
2420 (setq fill-prefix t) ; Used as flag in the cond.
2421 (if (and (null c-auto-fill-prefix)
2423 (<= (c-point 'bol) (car c-lit-limits)))
2424 ;; The adaptive fill function has generated a prefix, but
2425 ;; we're on the first line in a block comment so it'll be
2426 ;; wrong. Ignore it to guess a better one below.
2427 (setq fill-prefix nil)
2428 (when (and (eq c-lit-type 'c++)
2429 (not (string-match "\\`[ \t]*//" (or fill-prefix ""))))
2430 ;; Kludge: If the function that adapted the fill prefix
2431 ;; doesn't produce the required comment starter for line
2432 ;; comments, then we ignore it.
2433 (setq fill-prefix nil)))
2435 (cond ((eq fill-prefix t)
2436 ;; A call from do-auto-fill which should be ignored.
2439 ;; A fill-prefix overrides anything.
2440 (funcall do-line-break)
2441 (insert-and-inherit fill-prefix))
2443 (unless c-lit-limits
2444 (setq c-lit-limits (c-literal-limits nil nil t)))
2446 (setq c-lit-type (c-literal-type c-lit-limits)))
2447 (memq c-lit-type '(c c++)))
2448 (if (or comment-multi-line
2450 (goto-char (car c-lit-limits))
2452 (< (point) (cdr c-lit-limits))))
2453 ;; Inside a comment that should be continued.
2454 (let ((fill (c-guess-fill-prefix
2456 (c-collect-line-comments c-lit-limits))
2460 (back-to-indentation)
2461 (> (point) (car c-lit-limits))
2462 (looking-at c-current-comment-prefix))
2464 ;; Skip forward past the fill prefix in case
2465 ;; we're standing in it.
2466 (while (and (< (current-column) (cdr fill))
2469 (if (> (point) (if (and (eq c-lit-type 'c)
2472 (looking-at "\\*/")))
2473 (- (cdr c-lit-limits) 2)
2474 (cdr c-lit-limits)))
2476 ;; The skip takes us out of the comment;
2477 ;; insert the fill prefix at bol instead
2478 ;; and keep the position.
2479 (setq pos (copy-marker pos t))
2481 (insert-and-inherit (car fill))
2482 (if soft (insert-and-inherit ?\n) (newline 1))
2484 (set-marker pos nil))
2485 (funcall do-line-break)
2486 (insert-and-inherit (car fill))))
2487 (funcall do-line-break)
2488 (insert-and-inherit (car fill))))
2489 ;; Inside a comment that should be broken.
2490 (let ((comment-start comment-start)
2491 (comment-end comment-end)
2493 (if (eq c-lit-type 'c)
2494 (unless (string-match "[ \t]*/\\*" comment-start)
2495 (setq comment-start "/* " comment-end " */"))
2496 (unless (string-match "[ \t]*//" comment-start)
2497 (setq comment-start "// " comment-end "")))
2498 (setq col (save-excursion
2499 (back-to-indentation)
2501 (funcall do-line-break)
2502 (when (and comment-end (not (equal comment-end "")))
2504 (insert-and-inherit comment-end)
2506 ;; c-comment-indent may look at the current
2507 ;; indentation, so let's start out with the same
2508 ;; indentation as the previous one.
2510 (insert-and-inherit comment-start)
2511 (indent-for-comment))))
2513 ;; Somewhere else in the code.
2514 (let ((col (save-excursion
2515 (while (progn (back-to-indentation)
2516 (and (looking-at "^\\s *$")
2517 (= (forward-line -1) 0))))
2519 (funcall do-line-break)
2520 (indent-to col))))))
2522 (defalias 'c-comment-line-break-function 'c-indent-new-comment-line)
2523 (make-obsolete 'c-comment-line-break-function 'c-indent-new-comment-line)
2525 ;; advice for indent-new-comment-line for older Emacsen
2526 (unless (boundp 'comment-line-break-function)
2527 (defvar c-inside-line-break-advice nil)
2528 (defadvice indent-new-comment-line (around c-line-break-advice
2529 activate preactivate)
2530 "Call `c-indent-new-comment-line' if in CC Mode."
2531 (if (or c-inside-line-break-advice
2532 (not c-buffer-is-cc-mode))
2534 (let ((c-inside-line-break-advice t))
2535 (c-indent-new-comment-line (ad-get-arg 0))))))
2537 (defun c-context-line-break ()
2538 "Do a line break suitable to the context.
2540 When point is outside a comment, insert a newline and indent according
2541 to the syntactic context.
2543 When point is inside a comment, continue it with the appropriate
2544 comment prefix (see the `c-comment-prefix-regexp' and
2545 `c-block-comment-prefix' variables for details). The end of a
2546 C++-style line comment doesn't count as inside the comment, though."
2548 (let* ((c-lit-limits (c-literal-limits nil nil t))
2549 (c-lit-type (c-literal-type c-lit-limits)))
2550 (if (or (eq c-lit-type 'c)
2551 (and (eq c-lit-type 'c++)
2553 (1- (cdr (setq c-lit-limits
2554 (c-collect-line-comments c-lit-limits)))))))
2555 (let ((comment-multi-line t)
2557 (c-indent-new-comment-line))
2558 (delete-region (point) (progn (skip-chars-backward " \t") (point)))
2560 ;; c-indent-line may look at the current indentation, so let's
2561 ;; start out with the same indentation as the previous line.
2562 (let ((col (save-excursion
2564 (while (progn (back-to-indentation)
2565 (and (looking-at "^\\s *$")
2566 (= (forward-line -1) 0))))
2569 (indent-according-to-mode))))
2572 (cc-provide 'cc-cmds)
2574 ;;; cc-cmds.el ends here