1 ;;; cc-cmds.el --- user level commands for CC Mode
3 ;; Copyright (C) 1985, 1987, 1992-2003, 2004, 2005, 2006 Free Software
6 ;; Authors: 1998- Martin Stjernholm
7 ;; 1992-1999 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., 51 Franklin Street, Fifth Floor,
30 ;; Boston, MA 02110-1301, 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 (load "cc-bytecomp" nil t)))
46 (cc-require 'cc-engine)
48 ;; Silence the compiler.
49 (cc-bytecomp-defun delete-forward-p) ; XEmacs
50 (cc-bytecomp-defvar filladapt-mode) ; c-fill-paragraph contains a kludge
51 ; which looks at this.
52 (cc-bytecomp-defun c-forward-subword)
53 (cc-bytecomp-defun c-backward-subword)
55 (defvar c-fix-backslashes t)
57 (defun c-indent-line (&optional syntax quiet ignore-point-pos)
58 "Indent the current line according to the syntactic context,
59 if `c-syntactic-indentation' is non-nil. Optional SYNTAX is the
60 syntactic information for the current line. Be silent about syntactic
61 errors if the optional argument QUIET is non-nil, even if
62 `c-report-syntactic-errors' is non-nil. Normally the position of
63 point is used to decide where the old indentation is on a lines that
64 is otherwise empty \(ignoring any line continuation backslash), but
65 that's not done if IGNORE-POINT-POS is non-nil. Returns the amount of
66 indentation change \(in columns)."
68 (let ((line-cont-backslash (save-excursion
70 (eq (char-before) ?\\)))
71 (c-fix-backslashes c-fix-backslashes)
74 (when (and (not ignore-point-pos)
77 (looking-at (if line-cont-backslash
80 (<= (point) (match-end 1)))
81 ;; Delete all whitespace after point if there's only whitespace
82 ;; on the line, so that any code that does back-to-indentation
83 ;; or similar gets the current column in this case. If this
84 ;; removes a line continuation backslash it'll be restored
86 (unless c-auto-align-backslashes
87 ;; Should try to keep the backslash alignment
90 (goto-char (match-end 0))
91 (setq bs-col (1- (current-column)))))
92 (delete-region (point) (match-end 0))
93 (setq c-fix-backslashes t))
94 (if c-syntactic-indentation
96 (or (let ((c-parsing-error nil)
99 (and (boundp 'c-syntactic-context)
100 c-syntactic-context))))
101 (c-save-buffer-state (indent)
102 (unless c-syntactic-context
103 (setq c-syntactic-context (c-guess-basic-syntax)))
104 (setq indent (c-get-syntactic-indentation
105 c-syntactic-context))
106 (and (not (c-echo-parsing-error quiet))
107 c-echo-syntactic-information-p
108 (message "syntax: %s, indent: %d"
109 c-syntactic-context indent))
110 (setq shift-amt (- indent (current-indentation))))
111 (c-shift-line-indentation shift-amt)
112 (run-hooks 'c-special-indent-hook)
117 (while (and (= (forward-line -1) 0)
118 (if (looking-at "\\s *\\\\?$")
120 (setq indent (current-indentation))
122 (setq shift-amt (- indent (current-indentation)))
123 (c-shift-line-indentation shift-amt)))
124 (when (and c-fix-backslashes line-cont-backslash)
129 (when c-auto-align-backslashes
130 ;; Realign the line continuation backslash.
131 (c-backslash-region (point) (point) nil t))))
134 (defun c-newline-and-indent (&optional newline-arg)
135 "Insert a newline and indent the new line.
136 This function fixes line continuation backslashes if inside a macro,
137 and takes care to set the indentation before calling
138 `indent-according-to-mode', so that lineup functions like
139 `c-lineup-dont-change' works better."
141 ;; TODO: Backslashes before eol in comments and literals aren't
143 (let ((c-macro-start (c-query-macro-start))
144 ;; Avoid calling c-backslash-region from c-indent-line if it's
145 ;; called during the newline call, which can happen due to
146 ;; c-electric-continued-statement, for example. We also don't
147 ;; want any backslash alignment from indent-according-to-mode.
148 (c-fix-backslashes nil)
149 has-backslash insert-backslash
154 (while (and (looking-at "[ \t]*\\\\?$")
155 (= (forward-line -1) 0)))
156 (setq col (current-indentation)))
158 (if (and (eolp) (eq (char-before) ?\\))
159 (setq insert-backslash t
161 (setq has-backslash (eq (char-before (c-point 'eol)) ?\\))))
162 (newline newline-arg)
167 ;; The backslash stayed on the previous line. Insert one
168 ;; before calling c-backslash-region, so that
169 ;; bs-col-after-end in it works better. Fixup the
170 ;; backslashes on the newly inserted line.
173 (c-backslash-region (point) (point) nil t))
174 ;; The backslash moved to the new line, if there was any. Let
175 ;; c-backslash-region fix a backslash on the previous line,
176 ;; and the one that might be on the new line.
177 ;; c-auto-align-backslashes is intentionally ignored here;
178 ;; maybe the moved backslash should be left alone if it's set,
179 ;; but we fix both lines on the grounds that the old backslash
180 ;; has been moved anyway and is now in a different context.
181 (c-backslash-region start (if has-backslash (point) start) nil t)))
182 (when c-syntactic-indentation
183 ;; Reindent syntactically. The indentation done above is not
184 ;; wasted, since c-indent-line might look at the current
186 (let ((c-syntactic-context (c-save-buffer-state nil
187 (c-guess-basic-syntax))))
188 ;; We temporarily insert another line break, so that the
189 ;; lineup functions will see the line as empty. That makes
190 ;; e.g. c-lineup-cpp-define more intuitive since it then
191 ;; proceeds to the preceding line in this case.
193 (delete-horizontal-space)
194 (setq start (- (point-max) (point)))
198 (indent-according-to-mode))
199 (goto-char (- (point-max) start))
202 ;; Must align the backslash again after reindentation. The
203 ;; c-backslash-region call above can't be optimized to ignore
204 ;; this line, since it then won't align correctly with the
205 ;; lines below if the first line in the macro is broken.
206 (c-backslash-region (point) (point) nil t)))))
208 (defun c-show-syntactic-information (arg)
209 "Show syntactic information for current line.
210 With universal argument, inserts the analysis as a comment on that line."
212 (let* ((c-parsing-error nil)
213 (syntax (if (boundp 'c-syntactic-context)
214 ;; Use `c-syntactic-context' in the same way as
215 ;; `c-indent-line', to be consistent.
217 (c-save-buffer-state nil
218 (c-guess-basic-syntax)))))
219 (if (not (consp arg))
221 (message "Syntactic analysis: %s" syntax)
225 (setq elem (pop syntax))
226 (when (setq pos (c-langelem-pos elem))
227 (push (c-put-overlay pos (1+ pos)
230 (when (setq pos (c-langelem-2nd-pos elem))
231 (push (c-put-overlay pos (1+ pos)
232 'face 'secondary-selection)
236 (c-delete-overlay (pop ols)))))
238 (insert-and-inherit (format "%s" syntax))
240 (c-keep-region-active))
242 (defun c-syntactic-information-on-region (from to)
243 "Insert a comment with the syntactic analysis on every line in the region."
247 (narrow-to-region from to)
248 (goto-char (point-min))
250 (c-show-syntactic-information '(0))
254 (defun c-update-modeline ()
255 (let ((fmt (format "/%s%s%s%s"
256 (if c-electric-flag "l" "")
257 (if (and c-electric-flag c-auto-newline)
259 (if c-hungry-delete-key "h" "")
261 ;; cc-subword might not be loaded.
262 (boundp 'c-subword-mode)
263 (symbol-value 'c-subword-mode))
266 (bare-mode-name (if (string-match "\\(^[^/]*\\)/" mode-name)
267 (substring mode-name (match-beginning 1) (match-end 1))
269 ;; (setq c-submode-indicators
270 ;; (if (> (length fmt) 1)
273 (if (> (length fmt) 1)
274 (concat bare-mode-name fmt)
276 (force-mode-line-update)))
278 (defun c-toggle-syntactic-indentation (&optional arg)
279 "Toggle syntactic indentation.
280 Optional numeric ARG, if supplied, turns on syntactic indentation when
281 positive, turns it off when negative, and just toggles it when zero or
284 When syntactic indentation is turned on (the default), the indentation
285 functions and the electric keys indent according to the syntactic
286 context keys, when applicable.
288 When it's turned off, the electric keys don't reindent, the indentation
289 functions indents every new line to the same level as the previous
290 nonempty line, and \\[c-indent-command] adjusts the indentation in steps
291 specified by `c-basic-offset'. The indentation style has no effect in
292 this mode, nor any of the indentation associated variables,
293 e.g. `c-special-indent-hook'.
295 This command sets the variable `c-syntactic-indentation'."
297 (setq c-syntactic-indentation
298 (c-calculate-state arg c-syntactic-indentation))
299 (c-keep-region-active))
301 (defun c-toggle-auto-newline (&optional arg)
302 "Toggle auto-newline feature.
303 Optional numeric ARG, if supplied, turns on auto-newline when
304 positive, turns it off when negative, and just toggles it when zero or
307 Turning on auto-newline automatically enables electric indentation.
309 When the auto-newline feature is enabled (indicated by \"/la\" on the
310 modeline after the mode name) newlines are automatically inserted
311 after special characters such as brace, comma, semi-colon, and colon."
314 (c-calculate-state arg (and c-auto-newline c-electric-flag)))
315 (if c-auto-newline (setq c-electric-flag t))
317 (c-keep-region-active))
319 (defalias 'c-toggle-auto-state 'c-toggle-auto-newline)
320 (make-obsolete 'c-toggle-auto-state 'c-toggle-auto-newline)
322 (defun c-toggle-hungry-state (&optional arg)
323 "Toggle hungry-delete-key feature.
324 Optional numeric ARG, if supplied, turns on hungry-delete when
325 positive, turns it off when negative, and just toggles it when zero or
328 When the hungry-delete-key feature is enabled (indicated by \"/h\" on
329 the modeline after the mode name) the delete key gobbles all preceding
330 whitespace in one fell swoop."
332 (setq c-hungry-delete-key (c-calculate-state arg c-hungry-delete-key))
334 (c-keep-region-active))
336 (defun c-toggle-auto-hungry-state (&optional arg)
337 "Toggle auto-newline and hungry-delete-key features.
338 Optional numeric ARG, if supplied, turns on auto-newline and
339 hungry-delete when positive, turns them off when negative, and just
340 toggles them when zero or left out.
342 See `c-toggle-auto-newline' and `c-toggle-hungry-state' for details."
344 (setq c-auto-newline (c-calculate-state arg c-auto-newline))
345 (setq c-hungry-delete-key (c-calculate-state arg c-hungry-delete-key))
347 (c-keep-region-active))
349 (defun c-toggle-electric-state (&optional arg)
350 "Toggle the electric indentation feature.
351 Optional numeric ARG, if supplied, turns on electric indentation when
352 positive, turns it off when negative, and just toggles it when zero or
355 (setq c-electric-flag (c-calculate-state arg c-electric-flag))
357 (c-keep-region-active))
362 (defun c-electric-backspace (arg)
363 "Delete the preceding character or whitespace.
364 If `c-hungry-delete-key' is non-nil (indicated by \"/h\" on the mode
365 line) then all preceding whitespace is consumed. If however a prefix
366 argument is supplied, or `c-hungry-delete-key' is nil, or point is
367 inside a literal then the function in the variable
368 `c-backspace-function' is called."
370 (if (c-save-buffer-state ()
371 (or (not c-hungry-delete-key)
374 (funcall c-backspace-function (prefix-numeric-value arg))
375 (c-hungry-delete-backwards)))
377 (defun c-hungry-delete-backwards ()
378 "Delete the preceding character or all preceding whitespace
379 back to the previous non-whitespace character.
380 See also \\[c-hungry-delete-forward]."
382 (let ((here (point)))
384 (if (/= (point) here)
385 (delete-region (point) here)
386 (funcall c-backspace-function 1))))
388 (defalias 'c-hungry-backspace 'c-hungry-delete-backwards)
390 (defun c-electric-delete-forward (arg)
391 "Delete the following character or whitespace.
392 If `c-hungry-delete-key' is non-nil (indicated by \"/h\" on the mode
393 line) then all following whitespace is consumed. If however a prefix
394 argument is supplied, or `c-hungry-delete-key' is nil, or point is
395 inside a literal then the function in the variable `c-delete-function'
398 (if (c-save-buffer-state ()
399 (or (not c-hungry-delete-key)
402 (funcall c-delete-function (prefix-numeric-value arg))
403 (c-hungry-delete-forward)))
405 (defun c-hungry-delete-forward ()
406 "Delete the following character or all following whitespace
407 up to the next non-whitespace character.
408 See also \\[c-hungry-delete-backwards]."
410 (let ((here (point)))
412 (if (/= (point) here)
413 (delete-region (point) here)
414 (funcall c-delete-function 1))))
416 ;; This function is only used in XEmacs.
417 (defun c-electric-delete (arg)
418 "Deletes preceding or following character or whitespace.
419 This function either deletes forward as `c-electric-delete-forward' or
420 backward as `c-electric-backspace', depending on the configuration: If
421 the function `delete-forward-p' is defined and returns non-nil, it
422 deletes forward. Otherwise it deletes backward.
424 Note: This is the way in XEmacs to choose the correct action for the
425 \[delete] key, whichever key that means. Other flavors don't use this
426 function to control that."
428 (if (and (fboundp 'delete-forward-p)
430 (c-electric-delete-forward arg)
431 (c-electric-backspace arg)))
433 ;; This function is only used in XEmacs.
434 (defun c-hungry-delete ()
435 "Delete a non-whitespace char, or all whitespace up to the next non-whitespace char.
436 The direction of deletion depends on the configuration: If the
437 function `delete-forward-p' is defined and returns non-nil, it deletes
438 forward using `c-hungry-delete-forward'. Otherwise it deletes
439 backward using `c-hungry-backspace'.
441 Note: This is the way in XEmacs to choose the correct action for the
442 \[delete] key, whichever key that means. Other flavors don't use this
443 function to control that."
445 (if (and (fboundp 'delete-forward-p)
447 (c-hungry-delete-forward)
448 (c-hungry-delete-backwards)))
450 (defun c-electric-pound (arg)
452 If `c-electric-flag' is set, handle it specially according to the variable
453 `c-electric-pound-behavior'. If a numeric ARG is supplied, or if point is
454 inside a literal or a macro, nothing special happens."
456 (if (c-save-buffer-state ()
458 (not c-electric-flag)
459 (not (memq 'alignleft c-electric-pound-behavior))
461 (skip-chars-backward " \t")
464 (and (= (forward-line -1) 0)
466 (eq (char-before) ?\\))))
468 ;; do nothing special
469 (self-insert-command (prefix-numeric-value arg))
470 ;; place the pound character at the left edge
471 (let ((pos (- (point-max) (point)))
474 (delete-horizontal-space)
475 (insert last-command-char)
477 (goto-char (- (point-max) pos)))
480 (defun c-point-syntax ()
481 ;; Return the syntactic context of the construct at point. (This is NOT
482 ;; nec. the same as the s.c. of the line point is on). N.B. This won't work
483 ;; between the `#' of a cpp thing and what follows (see c-opt-cpp-prefix).
484 (c-save-buffer-state (;; shut this up too
485 (c-echo-syntactic-information-p nil)
487 (c-tentative-buffer-changes
488 ;; insert a newline to isolate the construct at point for syntactic
491 ;; In AWK (etc.) or in a macro, make sure this CR hasn't changed
492 ;; the syntax. (There might already be an escaped NL there.)
493 (when (or (c-at-vsemi-p (1- (point)))
497 (and (c-beginning-of-macro)
498 (progn (c-end-of-macro)
503 (let ((c-syntactic-indentation-in-macros t)
504 (c-auto-newline-analysis t))
505 ;; Turn on syntactic macro analysis to help with auto
507 (setq syntax (c-guess-basic-syntax))
511 (defun c-brace-newlines (syntax)
512 ;; A brace stands at point. SYNTAX is the syntactic context of this brace
513 ;; (not necessarily the same as the S.C. of the line it is on). Return
514 ;; NEWLINES, the list containing some combination of the symbols `before'
515 ;; and `after' saying where newlines should be inserted.
518 ;; This is the list of brace syntactic symbols that can hang.
519 ;; If any new ones are added to c-offsets-alist, they should be
520 ;; added here as well.
521 '(class-open class-close defun-open defun-close
522 inline-open inline-close
523 brace-list-open brace-list-close
524 brace-list-intro brace-entry-open
525 block-open block-close
526 substatement-open statement-case-open
527 extern-lang-open extern-lang-close
528 namespace-open namespace-close
529 module-open module-close
530 composition-open composition-close
531 inexpr-class-open inexpr-class-close
532 ;; `statement-cont' is here for the case with a brace
533 ;; list opener inside a statement. C.f. CASE B.2 in
534 ;; `c-guess-continued-construct'.
537 (c-echo-syntactic-information-p nil)
538 symb-newlines) ; e.g. (substatement-open . (after))
541 ;; Do not try to insert newlines around a special
542 ;; (Pike-style) brace list.
543 (if (and c-special-brace-lists
545 (c-safe (if (= (char-before) ?{)
548 (c-looking-at-special-brace-list))))
550 ;; Seek the matching entry in c-hanging-braces-alist.
553 ;; Substitute inexpr-class and class-open or
554 ;; class-close with inexpr-class-open or
555 ;; inexpr-class-close.
556 (if (assq 'inexpr-class syntax)
557 (cond ((assq 'class-open syntax)
558 '((inexpr-class-open)))
559 ((assq 'class-close syntax)
560 '((inexpr-class-close)))
563 c-hanging-braces-alist)
564 '(ignore before after)))) ; Default, when not in c-h-b-l.
566 ;; If syntax is a function symbol, then call it using the
567 ;; defined semantics.
568 (if (and (not (consp (cdr symb-newlines)))
569 (functionp (cdr symb-newlines)))
570 (let ((c-syntactic-context syntax))
571 (funcall (cdr symb-newlines)
574 (cdr symb-newlines))))
576 (defun c-try-one-liner ()
577 ;; Point is just after a newly inserted }. If the non-whitespace
578 ;; content of the braces is a single line of code, compact the whole
579 ;; construct to a single line, if this line isn't too long. The Right
580 ;; Thing is done with comments.
582 ;; Point will be left after the }, regardless of whether the clean-up is
583 ;; done. Return NON-NIL if the clean-up happened, NIL if it didn't.
586 (pos (- (point-max) (point)))
587 mbeg1 mend1 mbeg4 mend4
588 eol-col cmnt-pos cmnt-col cmnt-gap)
593 ;; Avoid backtracking over a very large block. The one we
594 ;; deal with here can never be more than three lines.
595 (narrow-to-region (save-excursion
599 (and (c-safe (c-backward-sexp))
602 (narrow-to-region (point) (1- here)) ; innards of {.}
604 (cc-eval-when-compile
606 "\\(" ; (match-beginning 1)
607 "[ \t]*\\([\r\n][ \t]*\\)?" ; WS with opt. NL
608 "\\)" ; (match-end 1)
609 "[^ \t\r\n]+\\([ \t]+[^ \t\r\n]+\\)*" ; non-WS
610 "\\(" ; (match-beginning 4)
611 "[ \t]*\\([\r\n][ \t]*\\)?" ; WS with opt. NL
612 "\\)\\'"))))))) ; (match-end 4) at EOB.
614 (if (c-tentative-buffer-changes
615 (setq mbeg1 (match-beginning 1) mend1 (match-end 1)
616 mbeg4 (match-beginning 4) mend4 (match-end 4))
617 (backward-char) ; back over the `}'
619 (setq cmnt-pos (and (c-backward-single-comment)
620 (- (point) (- mend1 mbeg1)))))
621 (delete-region mbeg4 mend4)
622 (delete-region mbeg1 mend1)
623 (setq eol-col (save-excursion (end-of-line) (current-column)))
625 ;; Necessary to put the closing brace before any line
626 ;; oriented comment to keep it syntactically significant.
627 ;; This isn't necessary for block comments, but the result
628 ;; looks nicer anyway.
630 (delete-char 1) ; the `}' has blundered into a comment
632 (setq cmnt-col (1+ (current-column)))
633 (setq cmnt-pos (1+ cmnt-pos)) ; we're inserting a `}'
635 (insert-char ?\} 1) ; reinsert the `}' before the comment.
636 (setq cmnt-gap (- cmnt-col (current-column)))
637 (when (zerop cmnt-gap)
638 (insert-char ?\ 1) ; Put a space before a bare comment.
641 (or (null c-max-one-liner-length)
642 (zerop c-max-one-liner-length)
643 (<= eol-col c-max-one-liner-length)
644 ;; Can we trim space before comment to make the line fit?
646 (< (- eol-col cmnt-gap) c-max-one-liner-length)
647 (progn (goto-char cmnt-pos)
648 (backward-delete-char-untabify
649 (- eol-col c-max-one-liner-length))
651 (goto-char (- (point-max) pos))))))
653 (defun c-electric-brace (arg)
656 If `c-electric-flag' is non-nil, the brace is not inside a literal and a
657 numeric ARG hasn't been supplied, the command performs several electric
660 \(a) If the auto-newline feature is turned on (indicated by \"/la\" on
661 the mode line) newlines are inserted before and after the brace as
662 directed by the settings in `c-hanging-braces-alist'.
664 \(b) Any auto-newlines are indented. The original line is also
665 reindented unless `c-syntactic-indentation' is nil.
667 \(c) If auto-newline is turned on, various newline cleanups based on the
668 settings of `c-cleanup-list' are done."
671 (let (safepos literal
672 ;; We want to inhibit blinking the paren since this would be
673 ;; most disruptive. We'll blink it ourselves later on.
674 (old-blink-paren blink-paren-function)
675 blink-paren-function)
677 (c-save-buffer-state ()
678 (setq safepos (c-safe-position (point) (c-parse-state))
679 literal (c-in-literal safepos)))
681 ;; Insert the brace. Note that expand-abbrev might reindent
682 ;; the line here if there's a preceding "else" or something.
683 (self-insert-command (prefix-numeric-value arg))
685 (when (and c-electric-flag (not literal) (not arg))
686 (if (not (looking-at "[ \t]*\\\\?$"))
687 (if c-syntactic-indentation
688 (indent-according-to-mode))
690 (let ( ;; shut this up too
691 (c-echo-syntactic-information-p nil)
693 ln-syntax br-syntax syntax) ; Syntactic context of the original line,
694 ; of the brace itself, of the line the brace ends up on.
695 (c-save-buffer-state ((c-syntactic-indentation-in-macros t)
696 (c-auto-newline-analysis t))
697 (setq ln-syntax (c-guess-basic-syntax)))
698 (if c-syntactic-indentation
699 (c-indent-line ln-syntax))
703 (setq br-syntax (c-point-syntax)
704 newlines (c-brace-newlines br-syntax))
706 ;; Insert the BEFORE newline, if wanted, and reindent the newline.
707 (if (and (memq 'before newlines)
708 (> (current-column) (current-indentation)))
709 (if c-syntactic-indentation
710 ;; Only a plain newline for now - it's indented
711 ;; after the cleanups when the line has its final
714 (c-newline-and-indent)))
717 ;; `syntax' is the syntactic context of the line which ends up
718 ;; with the brace on it.
719 (setq syntax (if (memq 'before newlines) br-syntax ln-syntax))
721 ;; Do all appropriate clean ups
723 (pos (- (point-max) (point)))
727 ;; `}': clean up empty defun braces
728 (when (c-save-buffer-state ()
729 (and (memq 'empty-defun-braces c-cleanup-list)
730 (eq last-command-char ?\})
731 (c-intersect-lists '(defun-close class-close inline-close)
736 (eq (char-before) ?\{))
737 ;; make sure matching open brace isn't in a comment
738 (not (c-in-literal))))
739 (delete-region (point) (1- here))
740 (setq here (- (point-max) pos)))
743 ;; `}': compact to a one-liner defun?
746 (and (eq last-command-char ?\})
747 (memq 'one-liner-defun c-cleanup-list)
748 (c-intersect-lists '(defun-close) syntax)
750 (setq here (- (point-max) pos))))
752 ;; `{': clean up brace-else-brace and brace-elseif-brace
753 (when (eq last-command-char ?\{)
755 ((and (memq 'brace-else-brace c-cleanup-list)
758 "\\([ \t\n]\\|\\\\\n\\)*"
760 "\\([ \t\n]\\|\\\\\n\\)*"
764 (delete-region (match-beginning 0) (match-end 0))
765 (insert-and-inherit "} else {"))
766 ((and (memq 'brace-elseif-brace c-cleanup-list)
768 (goto-char (1- here))
772 (eq (char-before) ?\)))
773 (zerop (c-save-buffer-state nil (c-backward-token-2 1 t)))
774 (eq (char-after) ?\()
779 "\\([ \t\n]\\|\\\\\n\\)*"
781 "\\([ \t\n]\\|\\\\\n\\)+"
783 "\\([ \t\n]\\|\\\\\n\\)*"
786 ;(eq (match-end 0) tmp);
788 (delete-region mbeg mend)
792 (goto-char (- (point-max) pos))
794 ;; Indent the line after the cleanups since it might
795 ;; very well indent differently due to them, e.g. if
796 ;; c-indent-one-line-block is used together with the
797 ;; one-liner-defun cleanup.
798 (when c-syntactic-indentation
801 ;; does a newline go after the brace?
802 (if (memq 'after newlines)
803 (c-newline-and-indent))
807 (and (eq last-command-char ?\})
808 (not executing-kbd-macro)
811 (c-save-buffer-state nil
812 (c-backward-syntactic-ws safepos))
813 (funcall old-blink-paren)))))
815 (defun c-electric-slash (arg)
816 "Insert a slash character.
818 If the slash is inserted immediately after the comment prefix in a c-style
819 comment, the comment might get closed by removing whitespace and possibly
820 inserting a \"*\". See the variable `c-cleanup-list'.
822 Indent the line as a comment, if:
824 1. The slash is second of a \"//\" line oriented comment introducing
825 token and we are on a comment-only-line, or
827 2. The slash is part of a \"*/\" token that closes a block oriented
830 If a numeric ARG is supplied, point is inside a literal, or
831 `c-syntactic-indentation' is nil or `c-electric-flag' is nil, indentation
834 (let ((literal (c-save-buffer-state () (c-in-literal)))
837 (c-echo-syntactic-information-p nil))
839 ;; comment-close-slash cleanup? This DOESN'T need `c-electric-flag' or
840 ;; `c-syntactic-indentation' set.
843 (memq 'comment-close-slash c-cleanup-list)
844 (eq last-command-char ?/)
845 ; (eq c-block-comment-ender "*/") ; C-style comments ALWAYS end in */
847 (back-to-indentation)
848 (looking-at (concat c-current-comment-prefix "[ \t]*$"))))
850 (delete-horizontal-space)
851 (or (eq (char-before) ?*) (insert-char ?* 1))) ; Do I need a t (retain sticky properties) here?
853 (setq indentp (and (not arg)
854 c-syntactic-indentation
856 (eq last-command-char ?/)
857 (eq (char-before) (if literal ?* ?/))))
858 (self-insert-command (prefix-numeric-value arg))
860 (indent-according-to-mode))))
862 (defun c-electric-star (arg)
863 "Insert a star character.
864 If `c-electric-flag' and `c-syntactic-indentation' are both non-nil, and
865 the star is the second character of a C style comment starter on a
866 comment-only-line, indent the line as a comment. If a numeric ARG is
867 supplied, point is inside a literal, or `c-syntactic-indentation' is nil,
868 this indentation is inhibited."
871 (self-insert-command (prefix-numeric-value arg))
872 ;; if we are in a literal, or if arg is given do not reindent the
873 ;; current line, unless this star introduces a comment-only line.
874 (if (c-save-buffer-state ()
875 (and c-syntactic-indentation
878 (eq (c-in-literal) 'c)
879 (eq (char-before) ?*)
882 (skip-chars-backward "*")
883 (if (eq (char-before) ?/)
885 (skip-chars-backward " \t")
887 (let (c-echo-syntactic-information-p) ; shut this up
888 (indent-according-to-mode))
891 (defun c-electric-semi&comma (arg)
892 "Insert a comma or semicolon.
894 If `c-electric-flag' is non-nil, point isn't inside a literal and a
895 numeric ARG hasn't been supplied, the command performs several electric
898 \(a) When the auto-newline feature is turned on (indicated by \"/la\" on
899 the mode line) a newline might be inserted. See the variable
900 `c-hanging-semi&comma-criteria' for how newline insertion is determined.
902 \(b) Any auto-newlines are indented. The original line is also
903 reindented unless `c-syntactic-indentation' is nil.
905 \(c) If auto-newline is turned on, a comma following a brace list or a
906 semicolon following a defun might be cleaned up, depending on the
907 settings of `c-cleanup-list'."
909 (let* (lim literal c-syntactic-context
912 (c-echo-syntactic-information-p nil))
914 (c-save-buffer-state ()
915 (setq lim (c-most-enclosing-brace (c-parse-state))
916 literal (c-in-literal lim)))
918 (self-insert-command (prefix-numeric-value arg))
920 (if (and c-electric-flag (not literal) (not arg))
921 ;; do all cleanups and newline insertions if c-auto-newline is on.
922 (if (or (not c-auto-newline)
923 (not (looking-at "[ \t]*\\\\?$")))
924 (if c-syntactic-indentation
926 ;; clean ups: list-close-comma or defun-close-semi
927 (let ((pos (- (point-max) (point))))
928 (if (c-save-buffer-state ()
930 (eq last-command-char ?,)
931 (memq 'list-close-comma c-cleanup-list))
933 (eq last-command-char ?\;)
934 (memq 'defun-close-semi c-cleanup-list)))
938 (eq (char-before) ?}))
939 ;; make sure matching open brace isn't in a comment
940 (not (c-in-literal lim))))
941 (delete-region (point) here))
942 (goto-char (- (point-max) pos)))
944 (when c-syntactic-indentation
945 (setq c-syntactic-context (c-guess-basic-syntax))
946 (c-indent-line c-syntactic-context))
947 ;; check to see if a newline should be added
948 (let ((criteria c-hanging-semi&comma-criteria)
949 answer add-newline-p)
951 (setq answer (funcall (car criteria)))
952 ;; only nil value means continue checking
954 (setq criteria (cdr criteria))
956 ;; only 'stop specifically says do not add a newline
957 (setq add-newline-p (not (eq answer 'stop)))
960 (c-newline-and-indent))
963 (defun c-electric-colon (arg)
966 If `c-electric-flag' is non-nil, the colon is not inside a literal and a
967 numeric ARG hasn't been supplied, the command performs several electric
970 \(a) If the auto-newline feature is turned on (indicated by \"/la\" on
971 the mode line) newlines are inserted before and after the colon based on
972 the settings in `c-hanging-colons-alist'.
974 \(b) Any auto-newlines are indented. The original line is also
975 reindented unless `c-syntactic-indentation' is nil.
977 \(c) If auto-newline is turned on, whitespace between two colons will be
978 \"cleaned up\" leaving a scope operator, if this action is set in
982 (let* ((bod (c-point 'bod))
983 (literal (c-save-buffer-state () (c-in-literal bod)))
986 (c-echo-syntactic-information-p nil))
987 (self-insert-command (prefix-numeric-value arg))
988 ;; Any electric action?
989 (if (and c-electric-flag (not literal) (not arg))
990 ;; Unless we're at EOL, only re-indentation happens.
991 (if (not (looking-at "[ \t]*\\\\?$"))
992 (if c-syntactic-indentation
993 (indent-according-to-mode))
995 ;; scope-operator clean-up?
996 (let ((pos (- (point-max) (point)))
998 (if (c-save-buffer-state () ; Why do we need this? [ACM, 2003-03-12]
1000 (memq 'scope-operator c-cleanup-list)
1001 (eq (char-before) ?:)
1004 (c-skip-ws-backward)
1005 (eq (char-before) ?:))
1006 (not (c-in-literal))
1007 (not (eq (char-after (- (point) 2)) ?:))))
1009 (delete-region (point) (1- here))
1010 (setq is-scope-op t)))
1011 (goto-char (- (point-max) pos)))
1013 ;; indent the current line if it's done syntactically.
1014 (if c-syntactic-indentation
1015 ;; Cannot use the same syntax analysis as we find below,
1016 ;; since that's made with c-syntactic-indentation-in-macros
1018 (indent-according-to-mode))
1020 ;; Calculate where, if anywhere, we want newlines.
1021 (c-save-buffer-state
1022 ((c-syntactic-indentation-in-macros t)
1023 (c-auto-newline-analysis t)
1024 ;; Turn on syntactic macro analysis to help with auto newlines
1026 (syntax (c-guess-basic-syntax))
1028 ;; Translate substatement-label to label for this operation.
1030 (if (eq (car (car elem)) 'substatement-label)
1031 (setcar (car elem) 'label))
1032 (setq elem (cdr elem)))
1033 ;; some language elements can only be determined by checking
1034 ;; the following line. Lets first look for ones that can be
1035 ;; found when looking on the line with the colon
1038 (or (c-lookup-lists '(case-label label access-label)
1039 syntax c-hanging-colons-alist)
1040 (c-lookup-lists '(member-init-intro inher-intro)
1044 (c-guess-basic-syntax)
1046 c-hanging-colons-alist)))))
1047 ;; does a newline go before the colon? Watch out for already
1048 ;; non-hung colons. However, we don't unhang them because that
1049 ;; would be a cleanup (and anti-social).
1050 (if (and (memq 'before newlines)
1053 (skip-chars-backward ": \t")
1055 (let ((pos (- (point-max) (point))))
1057 (c-newline-and-indent)
1058 (goto-char (- (point-max) pos))))
1059 ;; does a newline go after the colon?
1060 (if (and (memq 'after (cdr-safe newlines))
1062 (c-newline-and-indent))
1065 (defun c-electric-lt-gt (arg)
1066 "Insert a \"<\" or \">\" character.
1067 If the current language uses angle bracket parens (e.g. template
1068 arguments in C++), try to find out if the inserted character is a
1069 paren and give it paren syntax if appropriate.
1071 If `c-electric-flag' and `c-syntactic-indentation' are both non-nil, the
1072 line will be reindented if the inserted character is a paren or if it
1073 finishes a C++ style stream operator in C++ mode. Exceptions are when a
1074 numeric argument is supplied, or the point is inside a literal."
1077 (let ((c-echo-syntactic-information-p nil)
1078 final-pos close-paren-inserted)
1080 (self-insert-command (prefix-numeric-value arg))
1081 (setq final-pos (point))
1083 (c-save-buffer-state (c-parse-and-markup-<>-arglists
1084 c-restricted-<>-arglists
1087 (when c-recognize-<>-arglists
1088 (if (eq last-command-char ?<)
1093 (c-beginning-of-current-token)
1096 (c-backward-token-2)
1097 (looking-at c-opt-<>-sexp-key)))
1098 (c-mark-<-as-paren (1- final-pos)))
1100 ;; It's a ">". Check if there's an earlier "<" which either has
1101 ;; open paren syntax already or that can be recognized as an arglist
1102 ;; together with this ">". Note that this won't work in cases like
1103 ;; "template <x, a < b, y>" but they ought to be rare.
1106 ;; Narrow to avoid that `c-forward-<>-arglist' below searches past
1108 (narrow-to-region (point-min) final-pos)
1112 (goto-char final-pos)
1113 (c-syntactic-skip-backward "^<;}" nil t)
1114 (eq (char-before) ?<))
1117 ;; If the "<" already got open paren syntax we know we
1118 ;; have the matching closer. Handle it and exit the
1120 (if (looking-at "\\s\(")
1122 (c-mark->-as-paren (1- final-pos))
1123 (setq close-paren-inserted t)
1128 (setq <-pos (point))
1129 (c-backward-syntactic-ws)
1130 (c-simple-skip-symbol-backward))
1131 (or (looking-at c-opt-<>-sexp-key)
1132 (not (looking-at c-keywords-regexp)))
1134 (let ((c-parse-and-markup-<>-arglists t)
1135 c-restricted-<>-arglists
1137 (c-most-enclosing-brace (c-parse-state))))
1138 (when (and containing-sexp
1139 (progn (goto-char containing-sexp)
1140 (eq (char-after) ?\())
1141 (not (eq (get-text-property (point) 'c-type)
1142 'c-decl-arg-start)))
1143 (setq c-restricted-<>-arglists t))
1145 (c-forward-<>-arglist nil))
1147 ;; Loop here if the "<" we found above belongs to a nested
1148 ;; angle bracket sexp. When we start over we'll find the
1149 ;; previous or surrounding sexp.
1150 (if (< (point) final-pos)
1152 (setq close-paren-inserted t)
1154 (goto-char final-pos)
1156 ;; Indent the line if appropriate.
1157 (when (and c-electric-flag c-syntactic-indentation)
1159 (when (prog1 (or (looking-at "\\s\(\\|\\s\)")
1160 (and (c-major-mode-is 'c++-mode)
1162 (c-beginning-of-current-token)
1163 (looking-at "<<\\|>>"))
1164 (= (match-end 0) final-pos)))
1165 (goto-char final-pos))
1166 (indent-according-to-mode)))
1168 (when (and close-paren-inserted
1169 (not executing-kbd-macro)
1170 blink-paren-function)
1171 ;; Note: Most paren blink functions, such as the standard
1172 ;; `blink-matching-open', currently doesn't handle paren chars
1173 ;; marked with text properties very well. Maybe we should avoid
1174 ;; this call for the time being?
1175 (funcall blink-paren-function))))
1177 (defun c-electric-paren (arg)
1178 "Insert a parenthesis.
1180 If `c-syntactic-indentation' and `c-electric-flag' are both non-nil, the
1181 line is reindented unless a numeric ARG is supplied, or the parenthesis
1182 is inserted inside a literal.
1184 Whitespace between a function name and the parenthesis may get added or
1185 removed; see the variable `c-cleanup-list'.
1187 Also, if `c-electric-flag' and `c-auto-newline' are both non-nil, some
1188 newline cleanups are done if appropriate; see the variable `c-cleanup-list'."
1190 (let ((literal (c-save-buffer-state () (c-in-literal)))
1192 (c-echo-syntactic-information-p nil))
1193 (self-insert-command (prefix-numeric-value arg))
1195 (if (and (not arg) (not literal))
1196 (let* ( ;; We want to inhibit blinking the paren since this will
1197 ;; be most disruptive. We'll blink it ourselves
1199 (old-blink-paren blink-paren-function)
1200 blink-paren-function)
1201 (if (and c-syntactic-indentation c-electric-flag)
1202 (indent-according-to-mode))
1204 ;; If we're at EOL, check for new-line clean-ups.
1205 (when (and c-electric-flag c-auto-newline
1206 (looking-at "[ \t]*\\\\?$"))
1208 ;; clean up brace-elseif-brace
1210 (and (memq 'brace-elseif-brace c-cleanup-list)
1211 (eq last-command-char ?\()
1214 "\\([ \t\n]\\|\\\\\n\\)*"
1216 "\\([ \t\n]\\|\\\\\n\\)+"
1218 "\\([ \t\n]\\|\\\\\n\\)*"
1222 (not (c-save-buffer-state () (c-in-literal))))
1223 (delete-region (match-beginning 0) (match-end 0))
1224 (insert-and-inherit "} else if ("))
1226 ;; clean up brace-catch-brace
1228 (and (memq 'brace-catch-brace c-cleanup-list)
1229 (eq last-command-char ?\()
1232 "\\([ \t\n]\\|\\\\\n\\)*"
1234 "\\([ \t\n]\\|\\\\\n\\)*"
1238 (not (c-save-buffer-state () (c-in-literal))))
1239 (delete-region (match-beginning 0) (match-end 0))
1240 (insert-and-inherit "} catch (")))
1242 ;; Check for clean-ups at function calls. These two DON'T need
1243 ;; `c-electric-flag' or `c-syntactic-indentation' set.
1244 ;; Point is currently just after the inserted paren.
1245 (let (beg (end (1- (point))))
1248 ;; space-before-funcall clean-up?
1249 ((and (memq 'space-before-funcall c-cleanup-list)
1250 (eq last-command-char ?\()
1253 (skip-chars-backward " \t")
1255 (c-save-buffer-state () (c-on-identifier))))
1257 (delete-region beg end)
1261 ;; compact-empty-funcall clean-up?
1262 ((c-save-buffer-state ()
1263 (and (memq 'compact-empty-funcall c-cleanup-list)
1264 (eq last-command-char ?\))
1266 (c-safe (backward-char 2))
1267 (when (looking-at "()")
1269 (skip-chars-backward " \t")
1271 (c-on-identifier)))))
1272 (delete-region beg end))))
1273 (and (eq last-input-event ?\))
1274 (not executing-kbd-macro)
1276 (funcall old-blink-paren))))))
1278 (defun c-electric-continued-statement ()
1279 "Reindent the current line if appropriate.
1281 This function is used to reindent the line after a keyword which
1282 continues an earlier statement is typed, e.g. an \"else\" or the
1283 \"while\" in a do-while block.
1285 The line is reindented if there is nothing but whitespace before the
1286 keyword on the line, the keyword is not inserted inside a literal, and
1287 `c-electric-flag' and `c-syntactic-indentation' are both non-nil."
1288 (let (;; shut this up
1289 (c-echo-syntactic-information-p nil))
1290 (when (c-save-buffer-state ()
1291 (and c-electric-flag
1292 c-syntactic-indentation
1293 (not (eq last-command-char ?_))
1295 (skip-syntax-backward "w")
1298 (not (c-in-literal (c-point 'bod)))))
1299 ;; Have to temporarily insert a space so that
1300 ;; c-guess-basic-syntax recognizes the keyword. Follow the
1301 ;; space with a nonspace to avoid messing up any whitespace
1302 ;; sensitive meddling that might be done, e.g. by
1303 ;; `c-backslash-region'.
1304 (insert-and-inherit " x")
1306 (indent-according-to-mode)
1307 (delete-char -2)))))
1310 (defun c-forward-into-nomenclature (&optional arg)
1311 "Compatibility alias for `c-forward-subword'."
1313 (require 'cc-subword)
1314 (c-forward-subword arg))
1315 (make-obsolete 'c-forward-into-nomenclature 'c-forward-subword)
1317 (defun c-backward-into-nomenclature (&optional arg)
1318 "Compatibility alias for `c-backward-subword'."
1320 (require 'cc-subword)
1321 (c-backward-subword arg))
1322 (make-obsolete 'c-backward-into-nomenclature 'c-backward-subword)
1324 (defun c-scope-operator ()
1325 "Insert a double colon scope operator at point.
1326 No indentation or other \"electric\" behavior is performed."
1328 (insert-and-inherit "::"))
1330 (defun c-beginning-of-defun (&optional arg)
1331 "Move backward to the beginning of a defun.
1332 Every top level declaration that contains a brace paren block is
1333 considered to be a defun.
1335 With a positive argument, move backward that many defuns. A negative
1336 argument -N means move forward to the Nth following beginning. Return
1337 t unless search stops due to beginning or end of buffer.
1339 Unlike the built-in `beginning-of-defun' this tries to be smarter
1340 about finding the char with open-parenthesis syntax that starts the
1344 (or arg (setq arg 1))
1347 (when (c-end-of-defun (- arg))
1348 (c-save-buffer-state nil (c-forward-syntactic-ws))
1351 (c-save-buffer-state (paren-state lim pos)
1354 ;; Note: Partial code duplication in `c-end-of-defun' and
1355 ;; `c-declaration-limits'.
1357 (setq paren-state (c-parse-state))
1359 (goto-char (c-least-enclosing-brace paren-state))
1360 ;; If we moved to the outermost enclosing paren
1361 ;; then we can use c-safe-position to set the
1362 ;; limit. Can't do that otherwise since the
1363 ;; earlier paren pair on paren-state might very
1364 ;; well be part of the declaration we should go
1366 (setq lim (c-safe-position (point) paren-state))
1368 ;; At top level. Make sure we aren't inside a literal.
1369 (setq pos (c-literal-limits
1370 (c-safe-position (point) paren-state)))
1371 (if pos (goto-char (car pos))))
1373 (while (let ((start (point)))
1374 (c-beginning-of-decl-1 lim)
1375 (if (= (point) start)
1376 ;; Didn't move. Might be due to bob or unbalanced
1377 ;; parens. Try to continue if it's the latter.
1378 (unless (c-safe (goto-char
1379 (c-down-list-backward (point))))
1380 ;; Didn't work, so it's bob then.
1381 (goto-char (point-min))
1385 ;; Check if the declaration contains a brace
1386 ;; block. If not, we try another one.
1388 (not (and (c-syntactic-re-search-forward "[;{]" nil t t)
1389 (or (eq (char-before) ?{)
1390 (and c-recognize-knr-p
1391 ;; Might have stopped on the
1392 ;; ';' in a K&R argdecl. In
1393 ;; that case the declaration
1394 ;; should contain a block.
1395 (c-in-knr-argdecl pos)))))))
1398 ;; Check if `c-beginning-of-decl-1' put us after the block
1399 ;; in a declaration that doesn't end there. We're searching
1400 ;; back and forth over the block here, which can be
1403 (if (and c-opt-block-decls-with-vars-key
1405 (c-backward-syntactic-ws)
1406 (eq (char-before) ?}))
1407 (eq (car (c-beginning-of-decl-1))
1416 ;; Try to be line oriented; position point at the closest
1417 ;; preceding boi that isn't inside a comment, but if we hit
1418 ;; the previous declaration then we use the current point
1420 (while (and (/= (point) (c-point 'boi))
1421 (c-backward-single-comment)))
1422 (if (/= (point) (c-point 'boi))
1425 (setq arg (1- arg)))))
1426 (c-keep-region-active)
1429 (defun c-end-of-defun (&optional arg)
1430 "Move forward to the end of a top level declaration.
1431 With argument, do it that many times. Negative argument -N means move
1432 back to Nth preceding end. Returns t unless search stops due to
1433 beginning or end of buffer.
1435 An end of a defun occurs right after the close-parenthesis that matches
1436 the open-parenthesis that starts a defun; see `beginning-of-defun'."
1439 (or arg (setq arg 1))
1442 (when (c-beginning-of-defun (- arg))
1443 (c-save-buffer-state nil (c-backward-syntactic-ws))
1446 (c-save-buffer-state (paren-state lim pos)
1449 ;; Note: Partial code duplication in `c-beginning-of-defun'
1450 ;; and `c-declaration-limits'.
1452 (setq paren-state (c-parse-state))
1454 (goto-char (c-least-enclosing-brace paren-state))
1455 ;; If we moved to the outermost enclosing paren
1456 ;; then we can use c-safe-position to set the
1457 ;; limit. Can't do that otherwise since the
1458 ;; earlier paren pair on paren-state might very
1459 ;; well be part of the declaration we should go
1461 (setq lim (c-safe-position (point) paren-state))
1463 ;; At top level. Make sure we aren't inside a literal.
1464 (setq pos (car-safe (c-literal-limits
1465 (c-safe-position (point) paren-state))))
1466 (if pos (goto-char pos)))
1468 ;; Have to move to the start first so that `c-end-of-decl-1'
1469 ;; has the correct start position.
1471 (when (memq (car (c-beginning-of-decl-1 lim))
1473 ;; We moved back over the previous defun or a macro. Move
1474 ;; to the next token; it's the start of the next
1475 ;; declaration. We can also be directly after the block
1476 ;; in a `c-opt-block-decls-with-vars-key' declaration, but
1477 ;; then we won't move significantly far here.
1479 (c-forward-token-2 0))
1481 (while (let ((start (point)))
1483 (if (= (point) start)
1484 ;; Didn't move. Might be due to eob or unbalanced
1485 ;; parens. Try to continue if it's the latter.
1486 (if (c-safe (goto-char (c-up-list-forward (point))))
1488 ;; Didn't work, so it's eob then.
1489 (goto-char (point-max))
1493 ;; Check if the declaration contains a brace
1494 ;; block. If not, we try another one.
1497 (not (c-syntactic-re-search-forward "{" pos t t))))))
1500 ;; Try to be line oriented; position point after the next
1501 ;; newline that isn't inside a comment, but if we hit the
1502 ;; next declaration then we use the current point instead.
1503 (while (and (not (bolp))
1504 (not (looking-at "\\s *$"))
1505 (c-forward-single-comment)))
1507 ((looking-at "\\s *$")
1512 (setq arg (1- arg)))))
1513 (c-keep-region-active)
1516 (defun c-declaration-limits (near)
1517 ;; Return a cons of the beginning and end positions of the current
1518 ;; top level declaration or macro. If point is not inside any then
1519 ;; nil is returned, unless NEAR is non-nil in which case the closest
1520 ;; following one is chosen instead (if there is any). The end
1521 ;; position is at the next line, providing there is one before the
1524 ;; This function might do hidden buffer changes.
1527 ;; Note: Some code duplication in `c-beginning-of-defun' and
1528 ;; `c-end-of-defun'.
1530 (let ((start (point))
1531 (paren-state (c-parse-state))
1534 (goto-char (c-least-enclosing-brace paren-state))
1535 ;; If we moved to the outermost enclosing paren then we
1536 ;; can use c-safe-position to set the limit. Can't do
1537 ;; that otherwise since the earlier paren pair on
1538 ;; paren-state might very well be part of the
1539 ;; declaration we should go to.
1540 (setq lim (c-safe-position (point) paren-state))
1542 ;; At top level. Make sure we aren't inside a literal.
1543 (setq pos (c-literal-limits
1544 (c-safe-position (point) paren-state)))
1545 (if pos (goto-char (car pos))))
1547 (when (c-beginning-of-macro)
1556 (when (or (eq (car (c-beginning-of-decl-1 lim)) 'previous)
1558 ;; We moved back over the previous defun. Skip to the next
1559 ;; one. Not using c-forward-syntactic-ws here since we
1560 ;; should not skip a macro. We can also be directly after
1561 ;; the block in a `c-opt-block-decls-with-vars-key'
1562 ;; declaration, but then we won't move significantly far
1565 (c-forward-comments)
1567 (when (and near (c-beginning-of-macro))
1575 (if (eobp) (throw 'exit nil))
1577 ;; Check if `c-beginning-of-decl-1' put us after the block in a
1578 ;; declaration that doesn't end there. We're searching back and
1579 ;; forth over the block here, which can be expensive.
1581 (if (and c-opt-block-decls-with-vars-key
1583 (c-backward-syntactic-ws)
1584 (eq (char-before) ?}))
1585 (eq (car (c-beginning-of-decl-1))
1589 (and (> (point) pos)
1590 (setq end-pos (point)))))
1594 (if (and (not near) (> (point) start))
1597 ;; Try to be line oriented; position the limits at the
1598 ;; closest preceding boi, and after the next newline, that
1599 ;; isn't inside a comment, but if we hit a neighboring
1600 ;; declaration then we instead use the exact declaration
1601 ;; limit in that direction.
1604 (while (and (/= (point) (c-point 'boi))
1605 (c-backward-single-comment)))
1606 (if (/= (point) (c-point 'boi))
1614 (while (and (not (bolp))
1615 (not (looking-at "\\s *$"))
1616 (c-forward-single-comment)))
1619 ((looking-at "\\s *$")
1626 (defun c-mark-function ()
1627 "Put mark at end of the current top-level declaration or macro, point at beginning.
1628 If point is not inside any then the closest following one is chosen.
1630 As opposed to \\[c-beginning-of-defun] and \\[c-end-of-defun], this
1631 function does not require the declaration to contain a brace block."
1635 (c-save-buffer-state nil
1636 ;; We try to be line oriented, unless there are several
1637 ;; declarations on the same line.
1638 (if (looking-at c-syntactic-eol)
1639 (c-backward-token-2 1 nil (c-point 'bol)))
1640 (setq decl-limits (c-declaration-limits t)))
1642 (if (not decl-limits)
1643 (error "Cannot find any declaration")
1644 (goto-char (car decl-limits))
1645 (push-mark (cdr decl-limits) nil t))))
1648 (defun c-in-comment-line-prefix-p ()
1649 ;; Point is within a comment. Is it also within a comment-prefix?
1650 ;; Space at BOL which precedes a comment-prefix counts as part of it.
1652 ;; This function might do hidden buffer changes.
1653 (let ((here (point)))
1656 (skip-chars-forward " \t")
1657 (and (looking-at c-current-comment-prefix)
1658 (/= (match-beginning 0) (match-end 0))
1659 (< here (match-end 0))))))
1661 (defun c-narrow-to-comment-innards (range)
1662 ;; Narrow to the "inside" of the comment (block) defined by range, as
1665 ;; A c-style block comment has its opening "/*" and its closing "*/" (if
1666 ;; present) removed. A c++-style line comment retains its opening "//" but
1667 ;; has any final NL removed. If POINT is currently outwith these innards,
1668 ;; move it to the appropriate boundary.
1670 ;; This narrowing simplifies the sentence movement functions, since it
1671 ;; eliminates awkward things at the boundaries of the comment (block).
1673 ;; This function might do hidden buffer changes.
1674 (let* ((lit-type (c-literal-type range))
1675 (beg (if (eq lit-type 'c) (+ (car range) 2) (car range)))
1676 (end (if (eq lit-type 'c)
1677 (if (and (eq (char-before (cdr range)) ?/)
1678 (eq (char-before (1- (cdr range))) ?*))
1681 (if (eq (cdr range) (point-max))
1683 (- (cdr range) 1)))))
1685 (goto-char end)) ; This would be done automatically by ...
1687 (goto-char beg)) ; ... narrow-to-region but is not documented.
1688 (narrow-to-region beg end)))
1690 (defun c-beginning-of-sentence-in-comment (range)
1691 ;; Move backwards to the "beginning of a sentence" within the comment
1692 ;; defined by RANGE, a cons of its starting and ending positions. If we
1693 ;; find a BOS, return NIL. Otherwise, move point to just before the start
1694 ;; of the comment and return T.
1696 ;; The BOS is either text which follows a regexp match of sentence-end,
1697 ;; or text which is a beginning of "paragraph".
1698 ;; Comment-prefixes are treated like WS when calculating BOSes or BOPs.
1700 ;; This code was adapted from GNU Emacs's forward-sentence in paragraphs.el.
1701 ;; It is not a general function, but is intended only for calling from
1702 ;; c-move-over-sentence. Not all preconditions have been explicitly stated.
1704 ;; This function might do hidden buffer changes.
1706 (let ((start-point (point)))
1708 (c-narrow-to-comment-innards range) ; This may move point back.
1709 (let* ((here (point))
1711 (here-filler ; matches WS and comment-prefices at point.
1712 (concat "\\=\\(^[ \t]*\\(" c-current-comment-prefix "\\)"
1713 "\\|[ \t\n\r\f]\\)*"))
1714 (prefix-at-bol-here ; matches WS and prefix at BOL, just before point
1715 (concat "^[ \t]*\\(" c-current-comment-prefix "\\)[ \t\n\r\f]*\\="))
1716 ;; First, find the previous paragraph start, if any.
1717 (par-beg ; point where non-WS/non-prefix text of paragraph starts.
1719 (forward-paragraph -1) ; uses cc-mode values of
1720 ; paragraph-\(start\|separate\)
1721 (if (> (re-search-forward here-filler nil t) here)
1723 (when (>= (point) here)
1724 (forward-paragraph -2)
1725 (if (> (re-search-forward here-filler nil t) here)
1729 ;; Now seek successively earlier sentence ends between PAR-BEG and
1730 ;; HERE, until the "start of sentence" following it is earlier than
1731 ;; HERE, or we hit PAR-BEG. Beware of comment prefices!
1732 (while (and (re-search-backward (c-sentence-end) par-beg 'limit)
1734 (goto-char (match-end 0)) ; tentative beginning of sentence
1735 (or (>= (point) here)
1736 (and (not (bolp)) ; Found a non-blank comment-prefix?
1738 (if (re-search-backward prefix-at-bol-here nil t)
1739 (/= (match-beginning 1) (match-end 1)))))
1740 (progn ; Skip the crud to find a real b-o-s.
1741 (if (c-in-comment-line-prefix-p)
1742 (beginning-of-line))
1743 (re-search-forward here-filler) ; always succeeds.
1744 (>= (point) here))))
1746 (re-search-forward here-filler)))
1748 (if (< (point) start-point)
1750 (goto-char (car range))
1753 (defun c-end-of-sentence-in-comment (range)
1754 ;; Move forward to the "end of a sentence" within the comment defined by
1755 ;; RANGE, a cons of its starting and ending positions (enclosing the opening
1756 ;; comment delimiter and the terminating */ or newline). If we find an EOS,
1757 ;; return NIL. Otherwise, move point to just after the end of the comment
1760 ;; The EOS is just after the non-WS part of the next match of the regexp
1761 ;; sentence-end. Typically, this is just after one of [.!?]. If there is
1762 ;; no sentence-end match following point, any WS before the end of the
1763 ;; comment will count as EOS, providing we're not already in it.
1765 ;; This code was adapted from GNU Emacs's forward-sentence in paragraphs.el.
1766 ;; It is not a general function, but is intended only for calling from
1767 ;; c-move-over-sentence.
1769 ;; This function might do hidden buffer changes.
1771 (let ((start-point (point))
1772 ;; (lit-type (c-literal-type range)) ; Commented out, 2005/11/23, ACM
1775 (c-narrow-to-comment-innards range) ; This might move point forwards.
1776 (let* ((here (point))
1777 (par-end ; EOL position of last text in current/next paragraph.
1779 ;; The cc-mode values of paragraph-\(start\|separate\), set
1780 ;; in c-setup-paragraph-variables, are used in the
1782 (forward-paragraph 1)
1783 (if (eq (preceding-char) ?\n) (forward-char -1))
1784 (when (<= (point) here) ; can happen, e.g., when HERE is at EOL.
1786 (forward-paragraph 2)
1787 (if (eq (preceding-char) ?\n) (forward-char -1)))
1792 (concat "^[ \t]*\\(" c-current-comment-prefix "\\)\\=")))
1793 ;; Go forward one "comment-prefix which looks like sentence-end"
1794 ;; each time round the following:
1795 (while (and (re-search-forward (c-sentence-end) par-end 'limit)
1798 (skip-chars-backward " \t\n")
1799 (or (and (not (bolp))
1800 (re-search-backward prefix-at-bol-here nil t)
1801 (/= (match-beginning 1) (match-end 1)))
1802 (<= (point) here))))
1805 ;; Take special action if we're up against the end of a comment (of
1806 ;; either sort): Leave point just after the last non-ws text.
1807 (if (eq (point) (point-max))
1808 (while (or (/= (skip-chars-backward " \t\n") 0)
1809 (and (re-search-backward prefix-at-bol-here nil t)
1810 (/= (match-beginning 1) (match-end 1))))))))
1812 (if (> (point) start-point)
1814 (goto-char (cdr range))
1817 (defun c-beginning-of-sentence-in-string (range)
1818 ;; Move backwards to the "beginning of a sentence" within the string defined
1819 ;; by RANGE, a cons of its starting and ending positions (enclosing the
1820 ;; string quotes). If we find a BOS, return NIL. Otherwise, move point to
1821 ;; just before the start of the string and return T.
1823 ;; The BOS is either the text which follows a regexp match of sentence-end
1824 ;; or text which is a beginning of "paragraph". For the purposes of
1825 ;; determining paragraph boundaries, escaped newlines are treated as
1826 ;; ordinary newlines.
1828 ;; This code was adapted from GNU Emacs's forward-sentence in paragraphs.el.
1829 ;; It is not a general function, but is intended only for calling from
1830 ;; c-move-over-sentence.
1832 ;; This function might do hidden buffer changes.
1834 (let* ((here (point)) last
1835 (end (1- (cdr range)))
1836 (here-filler ; matches WS and escaped newlines at point.
1837 "\\=\\([ \t\n\r\f]\\|\\\\[\n\r]\\)*")
1838 ;; Enhance paragraph-start and paragraph-separate also to recognise
1839 ;; blank lines terminated by escaped EOLs. IT MAY WELL BE that
1840 ;; these values should be customizable user options, or something.
1841 (paragraph-start c-string-par-start)
1842 (paragraph-separate c-string-par-separate)
1844 (par-beg ; beginning of current (or previous) paragraph.
1847 (narrow-to-region (1+ (car range)) end)
1848 (forward-paragraph -1) ; uses above values of
1849 ; paragraph-\(start\|separate\)
1850 (if (> (re-search-forward here-filler nil t) here)
1852 (when (>= (point) here)
1853 (forward-paragraph -2)
1854 (if (> (re-search-forward here-filler nil t) here)
1857 ;; Now see if we can find a sentence end after PAR-BEG.
1858 (while (and (re-search-backward c-sentence-end-with-esc-eol par-beg 'limit)
1860 (goto-char (match-end 0))
1864 here-filler end t) ; always succeeds. Use end rather
1865 ; than here, in case point starts
1866 ; beyond the closing quote.
1867 (>= (point) here))))
1869 (re-search-forward here-filler here t)
1870 (if (< (point) here)
1872 (goto-char (car range))
1875 (defun c-end-of-sentence-in-string (range)
1876 ;; Move forward to the "end of a sentence" within the string defined by
1877 ;; RANGE, a cons of its starting and ending positions. If we find an EOS,
1878 ;; return NIL. Otherwise, move point to just after the end of the string
1881 ;; The EOS is just after the non-WS part of the next match of the regexp
1882 ;; sentence-end. Typically, this is just after one of [.!?]. If there is
1883 ;; no sentence-end match following point, any WS before the end of the
1884 ;; string will count as EOS, providing we're not already in it.
1886 ;; This code was adapted from GNU Emacs's forward-sentence in paragraphs.el.
1887 ;; It is not a general function, but is intended only for calling from
1888 ;; c-move-over-sentence.
1890 ;; This function might do hidden buffer changes.
1892 (let* ((here (point))
1894 ;; Enhance paragraph-start and paragraph-separate to recognise
1895 ;; blank lines terminated by escaped EOLs.
1896 (paragraph-start c-string-par-start)
1897 (paragraph-separate c-string-par-separate)
1899 (par-end ; EOL position of last text in current/next paragraph.
1902 (narrow-to-region (car range) (1- (cdr range)))
1903 ;; The above values of paragraph-\(start\|separate\) are used
1904 ;; in the following.
1905 (forward-paragraph 1)
1907 ;; (re-search-backward filler-here nil t) would find an empty
1908 ;; string. Therefore we simulate it by the following:
1909 (while (or (/= (skip-chars-backward " \t\n\r\f") 0)
1910 (re-search-backward "\\\\\\($\\)\\=" nil t)))
1911 (unless (> (point) here)
1913 (forward-paragraph 1)
1914 (while (or (/= (skip-chars-backward " \t\n\r\f") 0)
1915 (re-search-backward "\\\\\\($\\)\\=" nil t))))
1917 ;; Try to go forward a sentence.
1918 (when (re-search-forward c-sentence-end-with-esc-eol par-end 'limit)
1920 (while (or (/= (skip-chars-backward " \t\n") 0)
1921 (re-search-backward "\\\\\\($\\)\\=" nil t))))
1922 ;; Did we move a sentence, or did we hit the end of the string?
1923 (if (> (point) here)
1925 (goto-char (cdr range))
1928 (defun c-ascertain-preceding-literal ()
1929 ;; Point is not in a literal (i.e. comment or string (include AWK regexp)).
1930 ;; If a literal is the next thing (aside from whitespace) to be found before
1931 ;; point, return a cons of its start.end positions (enclosing the
1932 ;; delimiters). Otherwise return NIL.
1934 ;; This function might do hidden buffer changes.
1936 (c-collect-line-comments
1937 (let ((here (point))
1939 (if (c-backward-single-comment)
1940 (cons (point) (progn (c-forward-single-comment) (point)))
1942 ;; to prevent `looking-at' seeing a " at point.
1943 (narrow-to-region (point-min) here)
1946 ;; An EOL can act as an "open string" terminator in AWK.
1947 (looking-at c-ws*-string-limit-regexp)
1949 (progn (backward-char)
1950 (looking-at c-string-limit-regexp))))
1951 (goto-char (match-end 0)) ; just after the string terminator.
1953 (c-safe (c-backward-sexp 1) ; move back over the string.
1954 (cons (point) pos)))))))))
1956 (defun c-ascertain-following-literal ()
1957 ;; Point is not in a literal (i.e. comment or string (include AWK regexp)).
1958 ;; If a literal is the next thing (aside from whitespace) following point,
1959 ;; return a cons of its start.end positions (enclosing the delimiters).
1960 ;; Otherwise return NIL.
1962 ;; This function might do hidden buffer changes.
1964 (c-collect-line-comments
1967 (if (looking-at c-string-limit-regexp) ; string-delimiter.
1968 (cons (point) (or (c-safe (progn (c-forward-sexp 1) (point)))
1971 (if (c-forward-single-comment)
1972 (cons pos (point))))))))
1974 (defun c-after-statement-terminator-p () ; Should we pass in LIM here?
1975 ;; Does point immediately follow a statement "terminator"? A virtual
1976 ;; semicolon is regarded here as such. So is a an opening brace ;-)
1978 ;; This function might do hidden buffer changes.
1981 (and (looking-at "[;{}]")
1982 (not (and c-special-brace-lists ; Pike special brace lists.
1983 (eq (char-after) ?{)
1984 (c-looking-at-special-brace-list)))))
1986 ;; The following (for macros) is not strict about exactly where we are
1987 ;; wrt white space at the end of the macro. Doesn't seem to matter too
1988 ;; much. ACM 2004/3/29.
1991 (if (c-beginning-of-macro)
1992 (setq eom (progn (c-end-of-macro)
1996 (c-forward-comments)
1997 (>= (point) eom))))))
1999 (defun c-back-over-illiterals (macro-start)
2000 ;; Move backwards over code which isn't a literal (i.e. comment or string),
2001 ;; stopping before reaching BOB or a literal or the boundary of a
2002 ;; preprocessor statement or the "beginning of a statement". MACRO-START is
2003 ;; the position of the '#' beginning the current preprocessor directive, or
2004 ;; NIL if we're not in such.
2006 ;; Return a cons (A.B), where
2007 ;; A is NIL if we moved back to a BOS (and know it), T otherwise (we
2008 ;; didn't move, or we hit a literal, or we're not sure about BOS).
2009 ;; B is MACRO-BOUNDARY if we are about to cross the boundary out of or
2010 ;; into a macro, otherwise LITERAL if we've hit a literal, otherwise NIL
2012 ;; The total collection of returned values is as follows:
2013 ;; (nil . nil): Found a BOS whilst remaining inside the illiterals.
2014 ;; (t . literal): No BOS found: only a comment/string. We _might_ be at
2015 ;; a BOS - the caller must check this.
2016 ;; (nil . macro-boundary): only happens with non-nil macro-start. We've
2017 ;; moved and reached the opening # of the macro.
2018 ;; (t . macro-boundary): Every other circumstance in which we're at a
2019 ;; macro-boundary. We might be at a BOS.
2021 ;; Point is left either at the beginning-of-statement, or at the last non-ws
2022 ;; code before encountering the literal/BOB or macro-boundary.
2024 ;; Note that this function moves within either preprocessor commands
2025 ;; (macros) or normal code, but will not cross a boundary between the two,
2026 ;; or between two distinct preprocessor commands.
2028 ;; Stop before `{' and after `;', `{', `}' and `};' when not followed by `}'
2029 ;; or `)', but on the other side of the syntactic ws. Move by sexps and
2030 ;; move into parens. Also stop before `#' when it's at boi on a line.
2032 ;; This function might do hidden buffer changes.
2034 (let ((here (point))
2035 last) ; marks the position of non-ws code, what'll be BOS if, say, a
2036 ; semicolon precedes it.
2038 (while t ;; We go back one "token" each iteration of the loop.
2041 ;; Stop at the token after a comment.
2042 ((c-backward-single-comment) ; Also functions as backwards-ws.
2044 (throw 'done '(t . literal)))
2046 ;; If we've gone back over a LF, we might have moved into or out of
2047 ;; a preprocessor line.
2048 ((and (save-excursion
2050 (re-search-forward "\\(^\\|[^\\]\\)[\n\r]" last t))
2052 (< (point) macro-start)
2053 (c-beginning-of-macro)))
2055 ;; Return a car of NIL ONLY if we've hit the opening # of a macro.
2056 (throw 'done (cons (or (eq (point) here)
2060 ;; Have we found a virtual semicolon? If so, stop, unless the next
2061 ;; statement is where we started from.
2062 ((and (c-at-vsemi-p)
2064 (not (memq (char-after last) '(?\) ?})))) ; we've moved back from ) or }
2066 (throw 'done '(nil . nil)))
2068 ;; Hit the beginning of the buffer/region?
2072 (throw 'done '(nil . nil)))
2074 ;; Move back a character.
2075 ((progn (backward-char) nil))
2077 ;; Stop at "{" (unless it's a PIKE special brace list.)
2078 ((eq (char-after) ?\{)
2079 (if (and c-special-brace-lists
2080 (c-looking-at-special-brace-list))
2081 (skip-syntax-backward "w_") ; Speedup only.
2084 (throw 'done '(nil . nil))))
2086 ;; Have we reached the start of a macro? This always counts as
2087 ;; BOS. (N.B. I don't think (eq (point) here) can ever be true
2088 ;; here. FIXME!!! ACM 2004/3/29)
2089 ((and macro-start (eq (point) macro-start))
2090 (throw 'done (cons (eq (point) here) 'macro-boundary)))
2092 ;; Stop at token just after "}" or ";".
2093 ((looking-at "[;}]")
2094 ;; If we've gone back over ;, {, or }, we're done.
2095 (if (or (= here last)
2096 (memq (char-after last) '(?\) ?}))) ; we've moved back from ) or }
2097 (if (and (eq (char-before) ?}) ; If };, treat them as a unit.
2098 (eq (char-after) ?\;))
2100 (goto-char last) ; To the statement starting after the ; or }.
2101 (throw 'done '(nil . nil))))
2103 ;; Stop at the token after a string.
2104 ((looking-at c-string-limit-regexp) ; Just gone back over a string terminator?
2106 (throw 'done '(t . literal)))
2108 ;; Nothing special: go back word characters.
2109 (t (skip-syntax-backward "w_")) ; Speedup only.
2112 (defun c-forward-over-illiterals (macro-end allow-early-stop)
2113 ;; Move forwards over code, stopping before reaching EOB or a literal
2114 ;; (i.e. a comment/string) or the boundary of a preprocessor statement or
2115 ;; the "end of a statement". MACRO-END is the position of the EOL/EOB which
2116 ;; terminates the current preprocessor directive, or NIL if we're not in
2119 ;; ALLOW-EARLY-STOP is non-nil if it is permissible to return without moving
2120 ;; forward at all, should we encounter a `{'. This is an ugly kludge, but
2121 ;; seems unavoidable. Depending on the context this function is called
2122 ;; from, we _sometimes_ need to stop there. Currently (2004/4/3),
2123 ;; ALLOW-EARLY-STOP is applied only to open braces, not to virtual
2124 ;; semicolons, or anything else.
2126 ;; Return a cons (A.B), where
2127 ;; A is NIL if we moved forward to an EOS, or stay at one (when
2128 ;; ALLOW-EARLY-STOP is set), T otherwise (we hit a literal).
2129 ;; B is 'MACRO-BOUNDARY if we are about to cross the boundary out of or
2130 ;; into a macro, otherwise 'LITERAL if we've hit a literal, otherwise NIL
2132 ;; Point is left either after the end-of-statement, or at the last non-ws
2133 ;; code before encountering the literal, or the # of the preprocessor
2134 ;; statement, or at EOB [or just after last non-WS stuff??].
2136 ;; As a clarification of "after the end-of-statement", if a comment or
2137 ;; whitespace follows a completed AWK statement, that statement is treated
2138 ;; as ending just after the last non-ws character before the comment.
2140 ;; Note that this function moves within either preprocessor commands
2141 ;; (macros) or normal code, but not both within the same invocation.
2143 ;; Stop before `{', `}', and `#' when it's at boi on a line, but on the
2144 ;; other side of the syntactic ws, and after `;', `}' and `};'. Only
2145 ;; stop before `{' if at top level or inside braces, though. Move by
2146 ;; sexps and move into parens. Also stop at eol of lines with `#' at
2149 ;; This function might do hidden buffer changes.
2150 (let ((here (point))
2153 (while t ;; We go one "token" forward each time round this loop.
2156 ;; If we've moved forward to a virtual semicolon, we're done.
2157 (if (and (> last here) ; Should we check ALLOW-EARLY-STOP, here? 2004/4/3
2159 (throw 'done '(nil . nil)))
2163 ;; Gone past the end of a macro?
2164 ((and macro-end (> (point) macro-end))
2166 (throw 'done (cons (eq (point) here) 'macro-boundary)))
2168 ;; About to hit a comment?
2169 ((save-excursion (c-forward-single-comment))
2171 (throw 'done '(t . literal)))
2177 (throw 'done '(nil . nil)))
2179 ;; If we encounter a '{', stop just after the previous token.
2180 ((and (eq (char-after) ?{)
2181 (not (and c-special-brace-lists
2182 (c-looking-at-special-brace-list)))
2183 (or allow-early-stop (/= here last))
2184 (save-excursion ; Is this a check that we're NOT at top level?
2185 ;;;; NO! This seems to check that (i) EITHER we're at the top level; OR (ii) The next enclosing
2186 ;;;; level of bracketing is a '{'. HMM. Doesn't seem to make sense.
2187 ;;;; 2003/8/8 This might have something to do with the GCC extension "Statement Expressions", e.g.
2188 ;;;; while ({stmt1 ; stmt2 ; exp ;}). This form excludes such Statement Expressions.
2189 (or (not (c-safe (up-list -1) t))
2190 (= (char-after) ?{))))
2192 (throw 'done '(nil . nil)))
2194 ;; End of a PIKE special brace list? If so, step over it and continue.
2195 ((and c-special-brace-lists
2196 (eq (char-after) ?})
2198 (and (c-safe (up-list -1) t)
2199 (c-looking-at-special-brace-list))))
2201 (skip-syntax-forward "w_")) ; Speedup only.
2203 ;; Have we got a '}' after having moved? If so, stop after the
2205 ((and (eq (char-after) ?})
2208 (throw 'done '(nil . nil)))
2210 ;; Stop if we encounter a preprocessor line.
2211 ((and (not macro-end)
2212 (eq (char-after) ?#)
2213 (= (point) (c-point 'boi)))
2215 ;(throw 'done (cons (eq (point) here) 'macro-boundary))) ; Changed 2003/3/26
2216 (throw 'done '(t . macro-boundary)))
2218 ;; Stop after a ';', '}', or "};"
2219 ((looking-at ";\\|};?")
2220 (goto-char (match-end 0))
2221 (throw 'done '(nil . nil)))
2223 ;; Found a string (this subsumes AWK regexps)?
2224 ((looking-at c-string-limit-regexp)
2226 (throw 'done '(t . literal)))
2229 (forward-char) ; Can't fail - we checked (eobp) earlier on.
2230 (skip-syntax-forward "w_") ; Speedup only.
2231 (when (and macro-end (> (point) macro-end))
2233 (throw 'done (cons (eq (point) here) 'macro-boundary))))
2236 (defun c-one-line-string-p (range)
2237 ;; Is the literal defined by RANGE a string contained in a single line?
2239 ;; This function might do hidden buffer changes.
2241 (goto-char (car range))
2242 (and (looking-at c-string-limit-regexp)
2243 (progn (skip-chars-forward "^\n" (cdr range))
2244 (eq (point) (cdr range))))))
2246 (defun c-beginning-of-statement (&optional count lim sentence-flag)
2247 "Go to the beginning of the innermost C statement.
2248 With prefix arg, go back N - 1 statements. If already at the
2249 beginning of a statement then go to the beginning of the closest
2250 preceding one, moving into nested blocks if necessary (use
2251 \\[backward-sexp] to skip over a block). If within or next to a
2252 comment or multiline string, move by sentences instead of statements.
2254 When called from a program, this function takes 3 optional args: the
2255 repetition count, a buffer position limit which is the farthest back
2256 to search for the syntactic context, and a flag saying whether to do
2257 sentence motion in or near comments and multiline strings.
2259 Note that for use in programs, `c-beginning-of-statement-1' is
2260 usually better. It has much better defined semantics than this one,
2261 which is intended for interactive use, and might therefore change to
2262 be more \"DWIM:ey\"."
2263 (interactive (list (prefix-numeric-value current-prefix-arg)
2266 (c-end-of-statement (- count) lim sentence-flag)
2267 (c-save-buffer-state
2268 ((count (or count 1))
2269 last ; start point for going back ONE chunk. Updated each chunk movement.
2271 (save-excursion (and (not (bobp)) (c-beginning-of-macro) (point))))
2272 res ; result from sub-function call
2273 not-bos ; "not beginning-of-statement"
2274 (range (c-collect-line-comments (c-literal-limits lim)))) ; (start.end) of current literal or NIL
2276 ;; Go back one statement at each iteration of the following loop.
2277 (while (and (/= count 0)
2278 (or (not lim) (> (point) lim)))
2279 ;; Go back one "chunk" each time round the following loop, stopping
2280 ;; when we reach a statement boundary, etc.
2283 (cond ; Each arm of this cond returns NIL on reaching a desired
2284 ; statement boundary, non-NIL otherwise.
2289 (range ; point is within or approaching a literal.
2291 ;; Single line string or sentence-flag is null => skip the
2293 ((or (null sentence-flag)
2294 (c-one-line-string-p range))
2295 (goto-char (car range))
2296 (setq range (c-ascertain-preceding-literal))
2297 ;; N.B. The following is essentially testing for an AWK regexp
2299 ;; Was the previous non-ws thing an end of statement?
2302 (c-backward-comments)
2303 (c-backward-syntactic-ws))
2304 (not (or (bobp) (c-after-statement-terminator-p)))))
2306 ;; Comment inside a statement or a multi-line string.
2307 (t (when (setq res ; returns non-nil when we go out of the literal
2308 (if (eq (c-literal-type range) 'string)
2309 (c-beginning-of-sentence-in-string range)
2310 (c-beginning-of-sentence-in-comment range)))
2311 (setq range (c-ascertain-preceding-literal)))
2314 ;; Non-literal code.
2315 (t (setq res (c-back-over-illiterals macro-fence))
2316 (setq not-bos ; "not reached beginning-of-statement".
2317 (or (= (point) last)
2318 (memq (char-after) '(?\) ?\}))
2321 ;; We're at a tentative BOS. The next form goes
2322 ;; back over WS looking for an end of previous
2324 (not (save-excursion
2326 (c-backward-comments)
2327 (c-backward-syntactic-ws))
2328 (or (bobp) (c-after-statement-terminator-p)))))))
2329 ;; Are we about to move backwards into or out of a
2330 ;; preprocessor command? If so, locate it's beginning.
2331 (when (eq (cdr res) 'macro-boundary)
2336 (progn (c-skip-ws-backward) (c-beginning-of-macro))
2338 ;; Are we about to move backwards into a literal?
2339 (when (memq (cdr res) '(macro-boundary literal))
2340 (setq range (c-ascertain-preceding-literal)))
2342 (setq last (point)))
2344 (if (/= count 0) (setq count (1- count))))
2345 (c-keep-region-active))))
2347 (defun c-end-of-statement (&optional count lim sentence-flag)
2348 "Go to the end of the innermost C statement.
2349 With prefix arg, go forward N - 1 statements. Move forward to the end
2350 of the next statement if already at end, and move into nested blocks
2351 \(use \\[forward-sexp] to skip over a block). If within or next to a
2352 comment or multiline string, move by sentences instead of statements.
2354 When called from a program, this function takes 3 optional args: the
2355 repetition count, a buffer position limit which is the farthest back
2356 to search for the syntactic context, and a flag saying whether to do
2357 sentence motion in or near comments and multiline strings."
2358 (interactive (list (prefix-numeric-value current-prefix-arg)
2360 (setq count (or count 1))
2361 (if (< count 0) (c-beginning-of-statement (- count) lim sentence-flag)
2363 (c-save-buffer-state
2364 (here ; start point for going forward ONE statement. Updated each statement.
2367 (and (not (eobp)) (c-beginning-of-macro)
2368 (progn (c-end-of-macro) (point)))))
2370 (range (c-collect-line-comments (c-literal-limits lim)))) ; (start.end) of current literal or NIL
2372 ;; Go back/forward one statement at each iteration of the following loop.
2373 (while (and (/= count 0)
2374 (or (not lim) (< (point) lim)))
2375 (setq here (point)) ; ONLY HERE is HERE updated
2377 ;; Go forward one "chunk" each time round the following loop, stopping
2378 ;; when we reach a statement boundary, etc.
2380 (cond ; Each arm of this cond returns NIL on reaching a desired
2381 ; statement boundary, non-NIL otherwise.
2386 (range ; point is within a literal.
2388 ;; sentence-flag is null => skip the entire literal.
2389 ;; or a Single line string.
2390 ((or (null sentence-flag)
2391 (c-one-line-string-p range))
2392 (goto-char (cdr range))
2393 (setq range (c-ascertain-following-literal))
2394 ;; Is there a virtual semicolon here (e.g. for AWK)?
2395 (not (c-at-vsemi-p)))
2397 ;; Comment or multi-line string.
2398 (t (when (setq res ; gets non-nil when we go out of the literal
2399 (if (eq (c-literal-type range) 'string)
2400 (c-end-of-sentence-in-string range)
2401 (c-end-of-sentence-in-comment range)))
2402 (setq range (c-ascertain-following-literal)))
2403 ;; If we've just come forward out of a literal, check for
2404 ;; vsemi. (N.B. AWK can't have a vsemi after a comment, but
2405 ;; some other language may do in the future)
2407 (not (c-at-vsemi-p))))))
2409 ;; Non-literal code.
2410 (t (setq res (c-forward-over-illiterals macro-fence
2412 ;; Are we about to move forward into or out of a
2413 ;; preprocessor command?
2414 (when (eq (cdr res) 'macro-boundary)
2419 (progn (c-skip-ws-forward)
2420 (c-beginning-of-macro))
2421 (progn (c-end-of-macro)
2423 ;; Are we about to move forward into a literal?
2424 (when (memq (cdr res) '(macro-boundary literal))
2425 (setq range (c-ascertain-following-literal)))
2428 (if (/= count 0) (setq count (1- count))))
2429 (c-keep-region-active))))
2433 ;; set up electric character functions to work with pending-del,
2434 ;; (a.k.a. delsel) mode. All symbols get the t value except
2435 ;; the functions which delete, which gets 'supersede.
2439 (put sym 'delete-selection t) ; for delsel (Emacs)
2440 (put sym 'pending-delete t))) ; for pending-del (XEmacs)
2445 c-electric-semi&comma
2449 (put 'c-electric-delete 'delete-selection 'supersede) ; delsel
2450 (put 'c-electric-delete 'pending-delete 'supersede) ; pending-del
2451 (put 'c-electric-backspace 'delete-selection 'supersede) ; delsel
2452 (put 'c-electric-backspace 'pending-delete 'supersede) ; pending-del
2453 (put 'c-electric-delete-forward 'delete-selection 'supersede) ; delsel
2454 (put 'c-electric-delete-forward 'pending-delete 'supersede) ; pending-del
2457 (defun c-calc-comment-indent (entry)
2458 ;; This function might do hidden buffer changes.
2460 (setq entry (or (assq entry c-indent-comment-alist)
2461 (assq 'other c-indent-comment-alist)
2462 '(default . (column . nil)))))
2463 (let ((action (car (cdr entry)))
2464 (value (cdr (cdr entry)))
2465 (col (current-column)))
2466 (cond ((eq action 'space)
2468 ((eq action 'column)
2469 (unless value (setq value comment-column))
2471 ;; Do not pad with one space if we're at bol.
2473 (max (1+ col) value)))
2479 (let ((lim (c-literal-limits (c-point 'bol) t)))
2481 (goto-char (car lim))
2482 (when (looking-at "/[/*]") ; FIXME!!! Adapt for AWK! (ACM, 2005/11/18)
2483 ;; Found comment to align with.
2485 ;; Do not pad with one space if we're at bol.
2487 (max (1+ col) (current-column))))))))
2488 ;; Recurse to handle value as a new spec.
2489 (c-calc-comment-indent (cdr entry)))))))
2491 (defun c-comment-indent ()
2492 "Used by `indent-for-comment' to create and indent comments.
2493 See `c-indent-comment-alist' for a description."
2496 (c-save-buffer-state
2497 ((eot (let ((lim (c-literal-limits (c-point 'bol) t)))
2498 (or (when (consp lim)
2499 (goto-char (car lim))
2500 (when (looking-at "/[/*]")
2501 (skip-chars-backward " \t")
2504 (skip-chars-backward " \t")
2507 (cond ((looking-at "^/[/*]")
2509 ((progn (beginning-of-line)
2512 ((progn (back-to-indentation)
2513 (and (eq (char-after) ?})
2514 (eq (point) (1- eot))))
2516 ((and (looking-at "#[ \t]*\\(endif\\|else\\)")
2517 (eq (match-end 0) eot))
2521 (if (and (memq line-type '(anchored-comment empty-line))
2522 c-indent-comments-syntactically-p)
2523 (let ((c-syntactic-context (c-guess-basic-syntax)))
2524 ;; BOGOSITY ALERT: if we're looking at the eol, its
2525 ;; because indent-for-comment hasn't put the comment-start
2526 ;; in the buffer yet. this will screw up the syntactic
2527 ;; analysis so we kludge in the necessary info. Another
2528 ;; kludge is that if we're at the bol, then we really want
2529 ;; to ignore any anchoring as specified by
2530 ;; c-comment-only-line-offset since it doesn't apply here.
2532 (c-add-syntax 'comment-intro))
2533 (let ((c-comment-only-line-offset
2534 (if (consp c-comment-only-line-offset)
2535 c-comment-only-line-offset
2536 (cons c-comment-only-line-offset
2537 c-comment-only-line-offset))))
2538 (c-get-syntactic-indentation c-syntactic-context)))
2540 (c-calc-comment-indent line-type)))))
2543 ;; used by outline-minor-mode
2544 (defun c-outline-level ()
2545 (let (buffer-invisibility-spec);; This so that `current-column' DTRT
2546 ;; in otherwise-hidden text.
2548 (skip-chars-forward "\t ")
2552 (defun c-up-conditional (count)
2553 "Move back to the containing preprocessor conditional, leaving mark behind.
2554 A prefix argument acts as a repeat count. With a negative argument,
2555 move forward to the end of the containing preprocessor conditional.
2557 \"#elif\" is treated like \"#else\" followed by \"#if\", so the
2558 function stops at them when going backward, but not when going
2561 (c-forward-conditional (- count) -1)
2562 (c-keep-region-active))
2564 (defun c-up-conditional-with-else (count)
2565 "Move back to the containing preprocessor conditional, including \"#else\".
2566 Just like `c-up-conditional', except it also stops at \"#else\"
2569 (c-forward-conditional (- count) -1 t)
2570 (c-keep-region-active))
2572 (defun c-down-conditional (count)
2573 "Move forward into the next preprocessor conditional, leaving mark behind.
2574 A prefix argument acts as a repeat count. With a negative argument,
2575 move backward into the previous preprocessor conditional.
2577 \"#elif\" is treated like \"#else\" followed by \"#if\", so the
2578 function stops at them when going forward, but not when going
2581 (c-forward-conditional count 1)
2582 (c-keep-region-active))
2584 (defun c-down-conditional-with-else (count)
2585 "Move forward into the next preprocessor conditional, including \"#else\".
2586 Just like `c-down-conditional', except it also stops at \"#else\"
2589 (c-forward-conditional count 1 t)
2590 (c-keep-region-active))
2592 (defun c-backward-conditional (count &optional target-depth with-else)
2593 "Move back across a preprocessor conditional, leaving mark behind.
2594 A prefix argument acts as a repeat count. With a negative argument,
2595 move forward across a preprocessor conditional."
2597 (c-forward-conditional (- count) target-depth with-else)
2598 (c-keep-region-active))
2600 (defun c-forward-conditional (count &optional target-depth with-else)
2601 "Move forward across a preprocessor conditional, leaving mark behind.
2602 A prefix argument acts as a repeat count. With a negative argument,
2603 move backward across a preprocessor conditional.
2605 \"#elif\" is treated like \"#else\" followed by \"#if\", except that
2606 the nesting level isn't changed when tracking subconditionals.
2608 The optional argument TARGET-DEPTH specifies the wanted nesting depth
2609 after each scan. I.e. if TARGET-DEPTH is -1, the function will move
2610 out of the enclosing conditional. A non-integer non-nil TARGET-DEPTH
2613 If the optional argument WITH-ELSE is non-nil, \"#else\" directives
2614 are treated as conditional clause limits. Normally they are ignored."
2616 (let* ((forward (> count 0))
2617 (increment (if forward -1 1))
2618 (search-function (if forward 're-search-forward 're-search-backward))
2620 (unless (integerp target-depth)
2621 (setq target-depth (if target-depth -1 0)))
2625 ;; subdepth is the depth in "uninteresting" subtrees,
2626 ;; i.e. those that takes us farther from the target
2627 ;; depth instead of closer.
2631 ;; Find the "next" significant line in the proper direction.
2632 (while (and (not found)
2633 ;; Rather than searching for a # sign that
2634 ;; comes at the beginning of a line aside from
2635 ;; whitespace, search first for a string
2636 ;; starting with # sign. Then verify what
2637 ;; precedes it. This is faster on account of
2638 ;; the fastmap feature of the regexp matcher.
2639 (funcall search-function
2640 "#[ \t]*\\(if\\|elif\\|endif\\|else\\)"
2643 ;; Now verify it is really a preproc line.
2644 (if (looking-at "^[ \t]*#[ \t]*\\(if\\|elif\\|endif\\|else\\)")
2645 (let (dchange (directive (match-string 1)))
2646 (cond ((string= directive "if")
2647 (setq dchange (- increment)))
2648 ((string= directive "endif")
2649 (setq dchange increment))
2651 ;; When we're not in an "uninteresting"
2652 ;; subtree, we might want to act on "elif"
2654 (if (cond (with-else
2655 ;; Always move toward the target depth.
2657 (if (> target-depth 0) 1 -1)))
2658 ((string= directive "elif")
2659 (setq dchange (- increment))))
2660 ;; Ignore the change if it'd take us
2661 ;; into an "uninteresting" subtree.
2662 (if (eq (> dchange 0) (<= target-depth 0))
2663 (setq dchange nil)))))
2665 (when (or (/= subdepth 0)
2666 (eq (> dchange 0) (<= target-depth 0)))
2667 (setq subdepth (+ subdepth dchange)))
2668 (setq depth (+ depth dchange))
2669 ;; If we are trying to move across, and we find an
2670 ;; end before we find a beginning, get an error.
2671 (if (and (< depth target-depth) (< dchange 0))
2673 "No following conditional at this level"
2674 "No previous conditional at this level"))))
2675 ;; When searching forward, start from next line so
2676 ;; that we don't find the same line again.
2677 (if forward (forward-line 1))
2678 ;; We found something if we've arrived at the
2680 (if (and dchange (= depth target-depth))
2681 (setq found (point))))
2683 (if forward (forward-line 1)))))
2685 (error "No containing preprocessor conditional"))
2686 (goto-char (setq new found)))
2687 (setq count (+ count increment))))
2690 (c-keep-region-active))
2693 ;; commands to indent lines, regions, defuns, and expressions
2694 (defun c-indent-command (&optional arg)
2695 "Indent current line as C code, and/or insert some whitespace.
2697 If `c-tab-always-indent' is t, always just indent the current line.
2698 If nil, indent the current line only if point is at the left margin or
2699 in the line's indentation; otherwise insert some whitespace[*]. If
2700 other than nil or t, then some whitespace[*] is inserted only within
2701 literals (comments and strings), but the line is always reindented.
2703 If `c-syntactic-indentation' is t, indentation is done according to
2704 the syntactic context. A numeric argument, regardless of its value,
2705 means indent rigidly all the lines of the expression starting after
2706 point so that this line becomes properly indented. The relative
2707 indentation among the lines of the expression is preserved.
2709 If `c-syntactic-indentation' is nil, the line is just indented one
2710 step according to `c-basic-offset'. In this mode, a numeric argument
2711 indents a number of such steps, positive or negative, and an empty
2712 prefix argument is equivalent to -1.
2714 [*] The amount and kind of whitespace inserted is controlled by the
2715 variable `c-insert-tab-function', which is called to do the actual
2716 insertion of whitespace. Normally the function in this variable
2717 just inserts a tab character, or the equivalent number of spaces,
2718 depending on the variable `indent-tabs-mode'."
2721 (let ((indent-function
2722 (if c-syntactic-indentation
2723 (symbol-function 'indent-according-to-mode)
2725 (let ((c-macro-start c-macro-start)
2726 (steps (if (equal arg '(4))
2728 (prefix-numeric-value arg))))
2729 (c-shift-line-indentation (* steps c-basic-offset))
2730 (when (and c-auto-align-backslashes
2733 (eq (char-before) ?\\))
2734 (c-query-and-set-macro-start))
2735 ;; Realign the line continuation backslash if inside a macro.
2736 (c-backslash-region (point) (point) nil t)))
2738 (if (and c-syntactic-indentation arg)
2739 ;; If c-syntactic-indentation and got arg, always indent this
2740 ;; line as C and shift remaining lines of expression the same
2742 (let ((shift-amt (save-excursion
2743 (back-to-indentation)
2747 (setq shift-amt (- (save-excursion
2748 (back-to-indentation)
2752 (if (eq c-tab-always-indent t)
2753 (beginning-of-line)) ; FIXME!!! What is this here for? ACM 2005/10/31
2761 (indent-code-rigidly beg end shift-amt "#")))
2762 ;; Else use c-tab-always-indent to determine behavior.
2764 ;; CASE 1: indent when at column zero or in line's indentation,
2765 ;; otherwise insert a tab
2766 ((not c-tab-always-indent)
2768 (skip-chars-backward " \t")
2770 (funcall c-insert-tab-function)
2771 (funcall indent-function)))
2772 ;; CASE 2: just indent the line
2773 ((eq c-tab-always-indent t)
2774 (funcall indent-function))
2775 ;; CASE 3: if in a literal, insert a tab, but always indent the
2778 (if (c-save-buffer-state () (c-in-literal))
2779 (funcall c-insert-tab-function))
2780 (funcall indent-function)
2783 (defun c-indent-exp (&optional shutup-p)
2784 "Indent each line in the balanced expression following point syntactically.
2785 If optional SHUTUP-P is non-nil, no errors are signalled if no
2786 balanced expression is found."
2788 (let ((here (point-marker))
2790 (set-marker-insertion-type here t)
2792 (let ((start (save-restriction
2793 ;; Find the closest following open paren that
2794 ;; ends on another line.
2795 (narrow-to-region (point-min) (c-point 'eol))
2796 (let (beg (end (point)))
2797 (while (and (setq beg (c-down-list-forward end))
2798 (setq end (c-up-list-forward beg))))
2800 (eq (char-syntax (char-before beg)) ?\()
2805 (error "Cannot find start of balanced expression to indent"))
2807 (setq end (c-safe (scan-sexps (point) 1)))
2810 (error "Cannot find end of balanced expression to indent"))
2813 (c-indent-region (point) end)))))
2815 (set-marker here nil))))
2817 (defun c-indent-defun ()
2818 "Indent the current top-level declaration or macro syntactically.
2819 In the macro case this also has the effect of realigning any line
2820 continuation backslashes, unless `c-auto-align-backslashes' is nil."
2822 (let ((here (point-marker)) decl-limits)
2825 (c-save-buffer-state nil
2826 ;; We try to be line oriented, unless there are several
2827 ;; declarations on the same line.
2828 (if (looking-at c-syntactic-eol)
2829 (c-backward-token-2 1 nil (c-point 'bol))
2830 (c-forward-token-2 0 nil (c-point 'eol)))
2831 (setq decl-limits (c-declaration-limits nil)))
2833 (c-indent-region (car decl-limits)
2834 (cdr decl-limits))))
2836 (set-marker here nil))))
2838 (defun c-indent-region (start end &optional quiet)
2839 "Indent syntactically every line whose first char is between START
2840 and END inclusive. If the optional argument QUIET is non-nil then no
2841 syntactic errors are reported, even if `c-report-syntactic-errors' is
2845 (skip-chars-backward " \t\n\r\f\v")
2848 ;; Advance to first nonblank line.
2850 (skip-chars-forward " \t\n\r\f\v")
2851 (setq start (point))
2853 (setq c-parsing-error
2854 (or (let ((endmark (copy-marker end))
2855 (c-parsing-error nil)
2856 ;; shut up any echo msgs on indiv lines
2857 (c-echo-syntactic-information-p nil)
2858 (in-macro (and c-auto-align-backslashes
2859 (c-save-buffer-state ()
2860 (save-excursion (c-beginning-of-macro)))
2862 (c-fix-backslashes nil)
2866 (c-progress-init start end 'c-indent-region)
2869 (< (point) endmark))
2873 (skip-chars-forward " \t\n")
2875 ;; Get syntax and indent.
2876 (c-save-buffer-state nil
2877 (setq syntax (c-guess-basic-syntax)))
2878 (if (and c-auto-align-backslashes
2879 (assq 'cpp-macro syntax))
2880 ;; Record macro start.
2881 (setq in-macro (point)))
2883 (if (looking-at "\\s *\\\\$")
2885 (c-indent-line syntax t t)
2886 (if (progn (end-of-line)
2887 (not (eq (char-before) ?\\)))
2889 ;; Fixup macro backslashes.
2891 (c-backslash-region in-macro (point) nil)
2892 (setq in-macro nil))
2894 (c-indent-line syntax t t)
2897 (c-backslash-region in-macro (c-point 'bopl) nil t)))
2898 (set-marker endmark nil)
2899 (c-progress-fini 'c-indent-region))
2900 (c-echo-parsing-error quiet))
2903 (defun c-fn-region-is-active-p ()
2904 ;; Function version of the macro for use in places that aren't
2905 ;; compiled, e.g. in the menus.
2906 (c-region-is-active-p))
2908 (defun c-indent-line-or-region ()
2909 "When the region is active, indent it syntactically. Otherwise
2910 indent the current line syntactically."
2911 ;; Emacs has a variable called mark-active, XEmacs uses region-active-p
2913 (if (c-region-is-active-p)
2914 (c-indent-region (region-beginning) (region-end))
2918 ;; for progress reporting
2919 (defvar c-progress-info nil)
2921 (defun c-progress-init (start end context)
2924 ((not c-progress-interval))
2925 ;; Start the progress update messages. If this Emacs doesn't have
2926 ;; a built-in timer, just be dumb about it.
2927 ((not (fboundp 'current-time))
2928 (message "Indenting region... (this may take a while)"))
2929 ;; If progress has already been initialized, do nothing. otherwise
2930 ;; initialize the counter with a vector of:
2931 ;; [start end lastsec context]
2933 (t (setq c-progress-info (vector start
2937 (nth 1 (current-time))
2939 (message "Indenting region..."))
2942 (defun c-progress-update ()
2943 (if (not (and c-progress-info c-progress-interval))
2945 (let ((now (nth 1 (current-time)))
2946 (start (aref c-progress-info 0))
2947 (end (aref c-progress-info 1))
2948 (lastsecs (aref c-progress-info 2)))
2949 ;; should we update? currently, update happens every 2 seconds,
2950 ;; what's the right value?
2951 (if (< c-progress-interval (- now lastsecs))
2953 (message "Indenting region... (%d%% complete)"
2954 (/ (* 100 (- (point) start)) (- end start)))
2955 (aset c-progress-info 2 now)))
2958 (defun c-progress-fini (context)
2959 (if (not c-progress-interval)
2961 (if (or (eq context (aref c-progress-info 3))
2964 (set-marker (aref c-progress-info 1) nil)
2965 (setq c-progress-info nil)
2966 (message "Indenting region... done")))))
2970 ;;; This page handles insertion and removal of backslashes for C macros.
2972 (defun c-backslash-region (from to delete-flag &optional line-mode)
2973 "Insert, align, or delete end-of-line backslashes on the lines in the region.
2974 With no argument, inserts backslashes and aligns existing backslashes.
2975 With an argument, deletes the backslashes. The backslash alignment is
2976 done according to the settings in `c-backslash-column',
2977 `c-backslash-max-column' and `c-auto-align-backslashes'.
2979 This function does not modify blank lines at the start of the region.
2980 If the region ends at the start of a line and the macro doesn't
2981 continue below it, the backslash (if any) at the end of the previous
2984 You can put the region around an entire macro definition and use this
2985 command to conveniently insert and align the necessary backslashes."
2986 (interactive "*r\nP")
2987 (let ((endmark (make-marker))
2988 ;; Keep the backslash trimming functions from changing the
2989 ;; whitespace around point, since in this case it's only the
2990 ;; position of point that tells the indentation of the line.
2991 (point-pos (if (save-excursion
2992 (skip-chars-backward " \t")
2993 (and (bolp) (looking-at "[ \t]*\\\\?$")))
2996 column longest-line-col bs-col-after-end)
2999 (if (and (not line-mode) (bobp))
3000 ;; Nothing to do if to is at bob, since we should back up
3001 ;; and there's no line to back up to.
3003 (when (and (not line-mode) (bolp))
3004 ;; Do not back up the to line if line-mode is set, to make
3005 ;; e.g. c-newline-and-indent consistent regardless whether
3006 ;; the (newline) call leaves point at bol or not.
3011 (set-marker endmark (point))
3013 (c-delete-backslashes-forward endmark point-pos))
3014 ;; Set bs-col-after-end to the column of any backslash
3015 ;; following the region, or nil if there is none.
3016 (setq bs-col-after-end
3017 (and (progn (end-of-line)
3018 (eq (char-before) ?\\))
3019 (= (forward-line 1) 0)
3020 (progn (end-of-line)
3021 (eq (char-before) ?\\))
3022 (1- (current-column))))
3024 ;; Back up the to line if line-mode is set, since the line
3025 ;; after the newly inserted line break should not be
3026 ;; touched in c-newline-and-indent.
3027 (setq to (max from (or (c-safe (c-point 'eopl)) from)))
3028 (unless bs-col-after-end
3029 ;; Set bs-col-after-end to non-nil in any case, since we
3030 ;; do not want to delete the backslash at the last line.
3031 (setq bs-col-after-end t)))
3033 (not c-auto-align-backslashes))
3035 ;; Compute the smallest column number past the ends of all
3037 (setq longest-line-col 0)
3039 (if bs-col-after-end
3040 ;; Include one more line in the max column
3041 ;; calculation, since the to line will be backslashed
3045 (while (and (>= (point) from)
3047 (if (eq (char-before) ?\\)
3049 (skip-chars-backward " \t")
3050 (setq longest-line-col (max longest-line-col
3051 (1+ (current-column))))
3055 ;; Try to align with surrounding backslashes.
3058 (if (and (not (bobp))
3059 (progn (backward-char)
3060 (eq (char-before) ?\\)))
3062 (setq column (1- (current-column)))
3063 (if (numberp bs-col-after-end)
3064 ;; Both a preceding and a following backslash.
3065 ;; Choose the greatest of them.
3066 (setq column (max column bs-col-after-end)))
3068 ;; No preceding backslash. Try to align with one
3069 ;; following the region. Disregard the backslash at the
3070 ;; to line since it's likely to be bogus (e.g. when
3071 ;; called from c-newline-and-indent).
3072 (if (numberp bs-col-after-end)
3073 (setq column bs-col-after-end))
3074 ;; Don't modify blank lines at start of region.
3076 (while (and (< (point) to) (bolp) (eolp))
3078 (if (and column (< column longest-line-col))
3079 ;; Don't try to align with surrounding backslashes if
3080 ;; any line is too long.
3083 ;; Impose minimum limit and tab width alignment only if
3084 ;; we can't align with surrounding backslashes.
3085 (if (> (% longest-line-col tab-width) 0)
3086 (setq longest-line-col
3087 (* (/ (+ longest-line-col tab-width -1)
3090 (setq column (max c-backslash-column
3092 ;; Always impose maximum limit.
3093 (setq column (min column c-backslash-max-column)))
3094 (if bs-col-after-end
3095 ;; Add backslashes on all lines if the macro continues
3096 ;; after the to line.
3098 (set-marker endmark to)
3099 (c-append-backslashes-forward endmark column point-pos))
3100 ;; Add backslashes on all lines except the last, and
3101 ;; remove any on the last line.
3106 (set-marker endmark (1- (point)))))
3108 (c-append-backslashes-forward endmark column point-pos)
3109 ;; The function above leaves point on the line
3110 ;; following endmark.
3111 (set-marker endmark (point)))
3112 (set-marker endmark to))
3113 (c-delete-backslashes-forward endmark point-pos)))))
3114 (set-marker endmark nil)
3115 (if (markerp point-pos)
3116 (set-marker point-pos nil))))
3118 (defun c-append-backslashes-forward (to-mark column point-pos)
3119 (let ((state (parse-partial-sexp (c-point 'bol) (point))))
3123 (<= (point) to-mark)
3125 (let ((start (point)) (inserted nil) end col)
3127 (unless (eq (char-before) ?\\)
3130 (setq state (parse-partial-sexp
3131 start (point) nil nil state))
3133 (setq col (current-column))
3135 ;; Avoid unnecessary changes of the buffer.
3136 (cond ((and (not inserted) (nth 3 state))
3137 ;; Don't realign backslashes in string literals
3138 ;; since that would change them.
3145 (skip-chars-backward
3146 " \t" (if (>= (point) point-pos) point-pos))
3150 ((and (= col column)
3151 (memq (char-before) '(?\ ?\t))))
3155 (or (/= (skip-chars-backward
3156 " \t" (if (>= (point) point-pos) point-pos))
3158 (/= (char-after) ?\ )))
3159 (delete-region (point) end)
3160 (indent-to column 1)))
3162 (zerop (forward-line 1)))
3163 (bolp))) ; forward-line has funny behavior at eob.
3165 ;; Make sure there are backslashes with at least one space in
3169 (<= (point) to-mark)
3171 (let ((start (point)))
3173 (setq state (parse-partial-sexp
3174 start (point) nil nil state))
3176 (if (eq (char-before) ?\\)
3177 (unless (nth 3 state)
3179 (unless (and (memq (char-before) '(?\ ?\t))
3180 (/= (point) point-pos))
3183 (if (and (memq (char-before) '(?\ ?\t))
3184 (/= (point) point-pos))
3188 (zerop (forward-line 1)))
3189 (bolp)))))) ; forward-line has funny behavior at eob.
3191 (defun c-delete-backslashes-forward (to-mark point-pos)
3193 (and (<= (point) to-mark)
3196 (if (eq (char-before) ?\\)
3199 (progn (backward-char)
3200 (skip-chars-backward " \t" (if (>= (point) point-pos)
3203 (zerop (forward-line 1)))
3204 (bolp)))) ; forward-line has funny behavior at eob.
3208 ;;; Line breaking and paragraph filling.
3210 (defvar c-auto-fill-prefix t)
3211 (defvar c-lit-limits nil)
3212 (defvar c-lit-type nil)
3214 ;; The filling code is based on a simple theory; leave the intricacies
3215 ;; of the text handling to the currently active mode for that
3216 ;; (e.g. adaptive-fill-mode or filladapt-mode) and do as little as
3217 ;; possible to make them work correctly wrt the comment and string
3218 ;; separators, one-line paragraphs etc. Unfortunately, when it comes
3219 ;; to it, there's quite a lot of special cases to handle which makes
3220 ;; the code anything but simple. The intention is that it will work
3221 ;; with any well-written text filling package that preserves a fill
3224 ;; We temporarily mask comment starters and enders as necessary for
3225 ;; the filling code to do its job on a seemingly normal text block.
3226 ;; We do _not_ mask the fill prefix, so it's up to the filling code to
3227 ;; preserve it correctly (especially important when filling C++ style
3228 ;; line comments). By default, we set up and use adaptive-fill-mode,
3229 ;; which is standard in all supported Emacs flavors.
3231 (defun c-guess-fill-prefix (lit-limits lit-type)
3232 ;; Determine the appropriate comment fill prefix for a block or line
3233 ;; comment. Return a cons of the prefix string and the column where
3234 ;; it ends. If fill-prefix is set, it'll override. Note that this
3235 ;; function also uses the value of point in some heuristics.
3237 ;; This function might do hidden buffer changes.
3239 (let* ((here (point))
3240 (prefix-regexp (concat "[ \t]*\\("
3241 c-current-comment-prefix
3243 (comment-start-regexp (if (eq lit-type 'c++)
3245 comment-start-skip))
3246 prefix-line comment-prefix res comment-text-end)
3250 (setq res (cons fill-prefix
3251 ;; Ugly way of getting the column after the fill
3252 ;; prefix; it'd be nice with a current-column
3253 ;; that works on strings..
3254 (let ((start (point)))
3257 (insert-and-inherit "\n" fill-prefix)
3259 (delete-region start (point)))))))
3263 ;; Set fallback for comment-prefix if none is found.
3264 (setq comment-prefix "// "
3265 comment-text-end (cdr lit-limits))
3268 (if (> (point) (car lit-limits))
3269 ;; The current line is not the comment starter, so the
3270 ;; comment has more than one line, and it can therefore be
3271 ;; used to find the comment fill prefix.
3272 (setq prefix-line (point))
3274 (goto-char (car lit-limits))
3275 (if (and (= (forward-line 1) 0)
3276 (< (point) (cdr lit-limits)))
3277 ;; The line after the comment starter is inside the
3278 ;; comment, so we can use it.
3279 (setq prefix-line (point))
3281 ;; The comment is only one line. Take the comment prefix
3282 ;; from it and keep the indentation.
3283 (goto-char (car lit-limits))
3284 (if (looking-at prefix-regexp)
3285 (goto-char (match-end 0))
3287 (skip-chars-forward " \t"))
3290 (if (eq (c-point 'boi) (car lit-limits))
3291 ;; There is only whitespace before the comment
3292 ;; starter; take the prefix straight from this line.
3293 (setq str (buffer-substring-no-properties
3294 (c-point 'bol) (point))
3295 col (current-column))
3297 ;; There is code before the comment starter, so we
3298 ;; have to temporarily insert and indent a new line to
3299 ;; get the right space/tab mix in the indentation.
3300 (let ((prefix-len (- (point) (car lit-limits)))
3304 (goto-char (car lit-limits))
3305 (indent-to (prog1 (current-column)
3308 (forward-char prefix-len)
3309 (setq str (buffer-substring-no-properties
3310 (c-point 'bol) (point))
3311 col (current-column)))
3312 (delete-region (car lit-limits) tmp))))
3315 (if (or (string-match "\\s \\'" str) (not (eolp)))
3317 ;; The prefix ends the line with no whitespace
3318 ;; after it. Default to a single space.
3319 (cons (concat str " ") (1+ col))))
3323 (setq comment-text-end
3325 (goto-char (- (cdr lit-limits) 2))
3326 (if (looking-at "\\*/") (point) (cdr lit-limits))))
3330 (if (and (> (point) (car lit-limits))
3331 (not (and (looking-at "[ \t]*\\*/")
3332 (eq (cdr lit-limits) (match-end 0)))))
3333 ;; The current line is not the comment starter and
3334 ;; contains more than just the ender, so it's good enough
3335 ;; to be used for the comment fill prefix.
3336 (setq prefix-line (point))
3337 (goto-char (car lit-limits))
3339 (cond ((or (/= (forward-line 1) 0)
3340 (>= (point) (cdr lit-limits))
3341 (and (looking-at "[ \t]*\\*/")
3342 (eq (cdr lit-limits) (match-end 0)))
3343 (and (looking-at prefix-regexp)
3344 (<= (1- (cdr lit-limits)) (match-end 0))))
3345 ;; The comment is either one line or the next line contains
3346 ;; just the comment ender. In this case we have no
3347 ;; information about a suitable comment prefix, so we resort
3348 ;; to c-block-comment-prefix.
3349 (setq comment-prefix (or c-block-comment-prefix "")))
3352 ;; The point was on the comment opener line, so we might want
3353 ;; to treat this as a not yet closed comment.
3355 (if (and (match-beginning 1)
3356 (/= (match-beginning 1) (match-end 1)))
3357 ;; Above `prefix-regexp' matched a nonempty prefix on the
3358 ;; second line, so let's use it. Normally it should do
3359 ;; to set `prefix-line' and let the code below pick up
3360 ;; the whole prefix, but if there's no text after the
3361 ;; match then it will probably fall back to no prefix at
3362 ;; all if the comment isn't closed yet, so in that case
3363 ;; it's better to force use of the prefix matched now.
3364 (if (= (match-end 0) (c-point 'eol))
3365 (setq comment-prefix (match-string 1))
3366 (setq prefix-line (point)))
3368 ;; There's no nonempty prefix on the line after the
3369 ;; comment opener. If the line is empty, or if the
3370 ;; text on it has less or equal indentation than the
3371 ;; comment starter we assume it's an unclosed
3372 ;; comment starter, i.e. that
3373 ;; `c-block-comment-prefix' should be used.
3374 ;; Otherwise we assume it's a closed comment where
3375 ;; the prefix really is the empty string.
3376 ;; E.g. this is an unclosed comment:
3387 ;; (Looking for the presence of the comment closer
3388 ;; rarely works since it's probably the closer of
3389 ;; some comment further down when the comment
3390 ;; really is unclosed.)
3391 (if (<= (save-excursion (back-to-indentation)
3393 (save-excursion (goto-char (car lit-limits))
3395 (setq comment-prefix (or c-block-comment-prefix ""))
3396 (setq prefix-line (point)))))
3399 ;; Otherwise the line after the comment starter is good
3400 ;; enough to find the prefix in.
3401 (setq prefix-line (point))))
3403 (when comment-prefix
3404 ;; Haven't got the comment prefix on any real line that we
3405 ;; can take it from, so we have to temporarily insert
3406 ;; `comment-prefix' on a line and indent it to find the
3407 ;; correct column and the correct mix of tabs and spaces.
3409 (let (tmp-pre tmp-post)
3413 (goto-char (car lit-limits))
3414 (if (looking-at comment-start-regexp)
3415 (goto-char (min (match-end 0)
3418 (skip-chars-forward " \t"))
3420 (when (eq (char-syntax (char-before)) ?\ )
3421 ;; If there's ws on the current line, we'll use it
3422 ;; instead of what's ending comment-prefix.
3423 (setq comment-prefix
3424 (concat (substring comment-prefix
3428 (buffer-substring-no-properties
3430 (skip-chars-backward " \t")
3434 (setq tmp-pre (point-marker))
3436 ;; We insert an extra non-whitespace character
3437 ;; before the line break and after comment-prefix in
3438 ;; case it's "" or ends with whitespace.
3439 (insert-and-inherit "x\n" comment-prefix "x")
3440 (setq tmp-post (point-marker))
3442 (indent-according-to-mode)
3444 (goto-char (1- tmp-post))
3445 (cons (buffer-substring-no-properties
3446 (c-point 'bol) (point))
3450 (delete-region tmp-pre tmp-post)
3451 (set-marker tmp-pre nil)
3452 (set-marker tmp-post nil))))))))))
3454 (or res ; Found a good prefix above.
3457 ;; prefix-line is the bol of a line on which we should try
3458 ;; to find the prefix.
3459 (let* (fb-string fb-endpos ; Contains any fallback prefix found.
3462 (when (and (looking-at prefix-regexp)
3463 (<= (match-end 0) comment-text-end))
3464 (unless (eq (match-end 0) (c-point 'eol))
3465 ;; The match is fine if there's text after it.
3466 (throw 'found (cons (buffer-substring-no-properties
3467 (match-beginning 0) (match-end 0))
3468 (progn (goto-char (match-end 0))
3469 (current-column)))))
3471 ;; This match is better than nothing, so let's
3472 ;; remember it in case nothing better is found
3474 (setq fb-string (buffer-substring-no-properties
3475 (match-beginning 0) (match-end 0))
3476 fb-endpos (match-end 0)))
3480 ;; Search for a line which has text after the prefix
3481 ;; so that we get the proper amount of whitespace
3482 ;; after it. We start with the current line, then
3483 ;; search backwards, then forwards.
3485 (goto-char prefix-line)
3486 (when (and (funcall test-line)
3487 (or (/= (match-end 1) (match-end 0))
3488 ;; The whitespace is sucked up by the
3489 ;; first [ \t]* glob if the prefix is empty.
3490 (and (= (match-beginning 1) (match-end 1))
3491 (/= (match-beginning 0) (match-end 0)))))
3492 ;; If the current line doesn't have text but do
3493 ;; have whitespace after the prefix, we'll use it.
3494 (throw 'found (cons fb-string
3495 (progn (goto-char fb-endpos)
3496 (current-column)))))
3498 (if (eq lit-type 'c++)
3499 ;; For line comments we can search up to and
3500 ;; including the first line.
3501 (while (and (zerop (forward-line -1))
3502 (>= (point) (car lit-limits)))
3503 (funcall test-line))
3504 ;; For block comments we must stop before the
3506 (while (and (zerop (forward-line -1))
3507 (> (point) (car lit-limits)))
3508 (funcall test-line)))
3510 (goto-char prefix-line)
3511 (while (and (zerop (forward-line 1))
3512 (< (point) (cdr lit-limits)))
3513 (funcall test-line))
3515 (goto-char prefix-line)
3519 ;; A good line wasn't found, but at least we have a
3520 ;; fallback that matches the comment prefix regexp.
3521 (cond ((or (string-match "\\s \\'" fb-string)
3523 (goto-char fb-endpos)
3525 ;; There are ws or text after the prefix, so
3527 (cons fb-string (current-column)))
3530 ;; Check if there's any whitespace padding
3531 ;; on the comment start line that we can
3532 ;; use after the prefix.
3533 (goto-char (car lit-limits))
3534 (if (looking-at comment-start-regexp)
3535 (goto-char (match-end 0))
3537 (skip-chars-forward " \t"))
3539 (eq (char-syntax (char-before)) ?\ )))
3541 (setq fb-string (buffer-substring-no-properties
3543 (skip-chars-backward " \t")
3546 (goto-char fb-endpos)
3547 (skip-chars-backward " \t")
3549 (let ((tmp (point)))
3550 ;; Got to mess in the buffer once again to
3551 ;; ensure the column gets correct. :P
3554 (insert-and-inherit fb-string)
3555 (cons (buffer-substring-no-properties
3559 (delete-region tmp (point)))))
3562 ;; Last resort: Just add a single space after
3564 (cons (concat fb-string " ")
3565 (progn (goto-char fb-endpos)
3566 (1+ (current-column)))))))
3568 ;; The line doesn't match the comment prefix regexp.
3570 ;; We have a fallback for line comments that we must use.
3571 (cons (concat (buffer-substring-no-properties
3572 prefix-line (c-point 'boi))
3574 (progn (back-to-indentation)
3575 (+ (current-column) (length comment-prefix))))
3577 ;; Assume we are dealing with a "free text" block
3578 ;; comment where the lines doesn't have any comment
3579 ;; prefix at all and we should just fill it as
3584 (defun c-mask-paragraph (fill-paragraph apply-outside-literal fun &rest args)
3585 ;; Calls FUN with ARGS ar arguments while the current paragraph is
3586 ;; masked to allow adaptive filling to work correctly. That
3587 ;; includes narrowing the buffer and, if point is inside a comment,
3588 ;; masking the comment starter and ender appropriately.
3590 ;; FILL-PARAGRAPH is non-nil if called for whole paragraph filling.
3591 ;; The position of point is then less significant when doing masking
3594 ;; If APPLY-OUTSIDE-LITERAL is nil then the function will be called
3595 ;; only if the point turns out to be inside a comment or a string.
3597 ;; Note that this function does not do any hidden buffer changes.
3600 ;; beg and end limits the region to narrow. end is a marker.
3602 ;; tmp-pre and tmp-post mark strings that are temporarily
3603 ;; inserted at the start and end of the region. tmp-pre is a
3604 ;; cons of the positions of the prepended string. tmp-post is
3605 ;; a marker pointing to the single character of the appended
3608 ;; If hang-ender-stuck isn't nil, the comment ender is
3609 ;; hanging. In that case it's set to the number of spaces
3610 ;; that should be between the text and the ender.
3612 ;; auto-fill-spaces is the exact sequence of whitespace between a
3613 ;; comment's last word and the comment ender, temporarily replaced
3614 ;; with 'x's before calling FUN when FILL-PARAGRAPH is nil.
3617 (c-lit-limits c-lit-limits)
3618 (c-lit-type c-lit-type))
3620 ;; Restore point on undo. It's necessary since we do a lot of
3621 ;; hidden inserts and deletes below that should be as transparent
3623 (if (and buffer-undo-list (not (eq buffer-undo-list t)))
3624 (setq buffer-undo-list (cons (point) buffer-undo-list)))
3626 (c-save-buffer-state ()
3628 ;; Widen to catch comment limits correctly.
3630 (unless c-lit-limits
3631 (setq c-lit-limits (c-literal-limits nil fill-paragraph)))
3632 (setq c-lit-limits (c-collect-line-comments c-lit-limits))
3634 (setq c-lit-type (c-literal-type c-lit-limits))))
3637 (unless (c-safe (backward-char)
3641 (forward-paragraph))
3642 (setq end (point-marker)))
3644 (unless (c-safe (forward-char)
3645 (backward-paragraph)
3648 (backward-paragraph))
3649 (setq beg (point))))
3655 ((eq c-lit-type 'c++) ; Line comment.
3657 ;; Limit to the comment or paragraph end, whichever
3659 (set-marker end (min end (cdr c-lit-limits)))
3661 (when (<= beg (car c-lit-limits))
3662 ;; The region includes the comment starter, so we must
3664 (goto-char (car c-lit-limits))
3665 (back-to-indentation)
3666 (if (eq (point) (car c-lit-limits))
3667 ;; Include the first line in the region.
3668 (setq beg (c-point 'bol))
3669 ;; The first line contains code before the
3670 ;; comment. We must fake a line that doesn't.
3673 (setq apply-outside-literal t))
3675 ((eq c-lit-type 'c) ; Block comment.
3676 (when (>= end (cdr c-lit-limits))
3677 ;; The region includes the comment ender which we might
3678 ;; want to keep together with the last word.
3679 (unless (save-excursion
3680 (goto-char (cdr c-lit-limits))
3682 (and (looking-at (concat "[ \t]*\\("
3683 c-current-comment-prefix
3685 (eq (cdr c-lit-limits) (match-end 0))
3686 ;; The comment ender is on a line of its
3687 ;; own. Keep it that way.
3688 (set-marker end (point))))
3690 ;; The comment ender should hang. Replace all space between
3691 ;; it and the last word either by one or two 'x's (when
3692 ;; FILL-PARAGRAPH is non-nil), or a row of x's the same width
3693 ;; as the whitespace (when auto filling), and include it in
3694 ;; the region. We'll change them back to whitespace
3695 ;; afterwards. The effect of this is to glue the comment
3696 ;; ender to the last word in the comment during filling.
3697 (let* ((ender-start (save-excursion
3698 (goto-char (cdr c-lit-limits))
3699 (skip-syntax-backward "^w ")
3701 (ender-column (save-excursion
3702 (goto-char ender-start)
3704 (point-rel (- ender-start here))
3708 (goto-char (cdr c-lit-limits))
3709 (setq tmp-post (point-marker))
3711 (set-marker end (point))
3712 (forward-line -1) ; last line of the comment
3713 (if (and (looking-at (concat "[ \t]*\\(\\("
3714 c-current-comment-prefix
3716 (eq ender-start (match-end 0)))
3717 ;; The comment ender is prefixed by nothing
3718 ;; but a comment line prefix. Remove it
3719 ;; along with surrounding ws.
3720 (setq spaces (- (match-end 1) (match-end 2)))
3721 (goto-char ender-start))
3722 (skip-chars-backward " \t\r\n") ; Surely this can be
3723 ; " \t"? "*/" is NOT alone on the line (ACM, 2005/8/18)
3725 (if (/= (point) ender-start)
3727 (if (<= here (point))
3728 ;; Don't adjust point below if it's
3729 ;; before the string we replace.
3730 (setq point-rel -1))
3731 ;; Keep one or two spaces between the
3732 ;; text and the ender, depending on how
3733 ;; many there are now.
3735 (setq spaces (- ender-column (current-column))))
3736 (setq auto-fill-spaces (c-delete-and-extract-region
3737 (point) ender-start))
3738 ;; paragraph filling condenses multiple spaces to
3739 ;; single or double spaces. auto-fill doesn't.
3744 (if sentence-end-double-space 2 1))
3746 ;; Insert the filler first to keep marks right.
3747 (insert-char ?x spaces t)
3748 (setq hang-ender-stuck spaces)
3750 (and (>= point-rel 0)
3751 (- (point) (min point-rel spaces)))))
3752 (setq point-rel nil)))
3755 ;; Point was in the middle of the string we
3756 ;; replaced above, so put it back in the same
3757 ;; relative position, counting from the end.
3758 (goto-char point-rel)))
3761 (when (<= beg (car c-lit-limits))
3762 ;; The region includes the comment starter.
3764 (goto-char (car c-lit-limits))
3765 (if (looking-at (concat "\\(" comment-start-skip "\\)$"))
3766 ;; Begin with the next line.
3767 (setq beg (c-point 'bonl))
3768 ;; Fake the fill prefix in the first line.
3771 (setq apply-outside-literal t))
3773 ((eq c-lit-type 'string) ; String.
3775 (when (>= end (cdr c-lit-limits))
3776 (goto-char (1- (cdr c-lit-limits)))
3777 (setq tmp-post (point-marker))
3779 (set-marker end (point)))
3780 (when (<= beg (car c-lit-limits))
3781 (goto-char (1+ (car c-lit-limits)))
3782 (setq beg (if (looking-at "\\\\$")
3783 ;; Leave the start line if it's
3784 ;; nothing but an escaped newline.
3787 (setq apply-outside-literal t))
3789 ((eq c-lit-type 'pound) ; Macro
3790 ;; Narrow to the macro limits if they are nearer than the
3791 ;; paragraph limits. Don't know if this is necessary but
3792 ;; do it for completeness sake (doing auto filling at all
3793 ;; inside macros is bogus to begin with since the line
3794 ;; continuation backslashes aren't handled).
3796 (c-save-buffer-state ()
3797 (c-beginning-of-macro)
3804 (set-marker end (point))))))
3807 ;; Try to avoid comments and macros in the paragraph to
3808 ;; avoid that the adaptive fill mode gets the prefix from
3810 (c-save-buffer-state nil
3813 (c-forward-syntactic-ws end)
3817 (c-backward-syntactic-ws beg)
3819 (set-marker end (point))))))
3822 ;; Temporarily insert the fill prefix after the comment
3823 ;; starter so that the first line looks like any other
3824 ;; comment line in the narrowed region.
3825 (setq fill (c-save-buffer-state nil
3826 (c-guess-fill-prefix c-lit-limits c-lit-type)))
3827 (unless (string-match (concat "\\`[ \t]*\\("
3828 c-current-comment-prefix
3831 ;; Oops, the prefix doesn't match the comment prefix
3832 ;; regexp. This could produce very confusing
3833 ;; results with adaptive fill packages together with
3834 ;; the insert prefix magic below, since the prefix
3835 ;; often doesn't appear at all. So let's warn about
3838 Warning: Regexp from `c-comment-prefix-regexp' doesn't match the comment prefix %S"
3840 ;; Find the right spot on the line, break it, insert
3841 ;; the fill prefix and make sure we're back in the
3842 ;; same column by temporarily prefixing the first word
3843 ;; with a number of 'x'.
3845 (goto-char (car c-lit-limits))
3846 (if (looking-at (if (eq c-lit-type 'c++)
3847 c-current-comment-prefix
3848 comment-start-skip))
3849 (goto-char (match-end 0))
3851 (skip-chars-forward " \t"))
3852 (while (and (< (current-column) (cdr fill))
3855 (let ((col (current-column)))
3856 (setq beg (1+ (point))
3857 tmp-pre (list (point)))
3860 (insert-and-inherit "\n" (car fill))
3861 (insert-char ?x (- col (current-column)) t))
3862 (setcdr tmp-pre (point))))))
3864 (when apply-outside-literal
3865 ;; `apply-outside-literal' is always set to t here if
3866 ;; we're inside a literal.
3870 ;; Kludge: If the function that adapts the fill prefix
3871 ;; doesn't produce the required comment starter for
3872 ;; line comments, then force it by setting fill-prefix.
3873 (when (and (eq c-lit-type 'c++)
3874 ;; Kludge the kludge: filladapt-mode doesn't
3875 ;; have this problem, but it currently
3876 ;; doesn't override fill-context-prefix
3878 (not (and (boundp 'filladapt-mode)
3882 (or (fill-context-prefix beg end)
3884 (c-save-buffer-state nil
3885 (car (or fill (c-guess-fill-prefix
3886 c-lit-limits c-lit-type)))))))
3888 ;; Save the relative position of point if it's outside the
3889 ;; region we're going to narrow. Want to restore it in that
3890 ;; case, but otherwise it should be moved according to the
3892 (point-rel (cond ((< (point) beg) (- (point) beg))
3893 ((> (point) end) (- (point) end)))))
3895 ;; Preparations finally done! Now we can call the
3899 (narrow-to-region beg end)
3902 ;; Restore point if it was outside the region.
3904 (goto-char (+ beg point-rel))
3905 (goto-char (+ end point-rel))))))))
3907 (when (consp tmp-pre)
3908 (delete-region (car tmp-pre) (cdr tmp-pre)))
3912 (goto-char tmp-post)
3914 (when hang-ender-stuck
3915 ;; Preserve point even if it's in the middle of the string
3916 ;; we replace; save-excursion doesn't work in that case.
3918 (goto-char tmp-post)
3919 (skip-syntax-backward "^w ")
3920 (forward-char (- hang-ender-stuck))
3921 (if (or fill-paragraph (not auto-fill-spaces))
3922 (insert-char ?\ hang-ender-stuck t)
3923 (insert auto-fill-spaces)
3924 (setq here (- here (- hang-ender-stuck (length auto-fill-spaces)))))
3925 (delete-char hang-ender-stuck)
3927 (set-marker tmp-post nil))
3929 (set-marker end nil))))
3931 (defun c-fill-paragraph (&optional arg)
3932 "Like \\[fill-paragraph] but handles C and C++ style comments.
3933 If any of the current line is a comment or within a comment, fill the
3934 comment or the paragraph of it that point is in, preserving the
3935 comment indentation or line-starting decorations (see the
3936 `c-comment-prefix-regexp' and `c-block-comment-prefix' variables for
3939 If point is inside multiline string literal, fill it. This currently
3940 does not respect escaped newlines, except for the special case when it
3941 is the very first thing in the string. The intended use for this rule
3942 is in situations like the following:
3944 char description[] = \"\\
3945 A very long description of something that you want to fill to make
3946 nicely formatted output.\"\;
3948 If point is in any other situation, i.e. in normal code, do nothing.
3950 Optional prefix ARG means justify paragraph as well."
3952 (let ((fill-paragraph-function
3953 ;; Avoid infinite recursion.
3954 (if (not (eq fill-paragraph-function 'c-fill-paragraph))
3955 fill-paragraph-function)))
3956 (c-mask-paragraph t nil 'fill-paragraph arg))
3957 ;; Always return t. This has the effect that if filling isn't done
3958 ;; above, it isn't done at all, and it's therefore effectively
3959 ;; disabled in normal code.
3962 (defun c-do-auto-fill ()
3963 ;; Do automatic filling if not inside a context where it should be
3965 (let ((c-auto-fill-prefix
3966 ;; The decision whether the line should be broken is actually
3967 ;; done in c-indent-new-comment-line, which do-auto-fill
3968 ;; calls to break lines. We just set this special variable
3969 ;; so that we'll know when we're called from there. It's
3970 ;; also used to detect whether fill-prefix is user set or
3971 ;; generated automatically by do-auto-fill.
3973 (c-mask-paragraph nil t 'do-auto-fill)))
3975 (defun c-indent-new-comment-line (&optional soft allow-auto-fill)
3976 "Break line at point and indent, continuing comment or macro if within one.
3977 If inside a comment and `comment-multi-line' is non-nil, the
3978 indentation and line prefix are preserved (see the
3979 `c-comment-prefix-regexp' and `c-block-comment-prefix' variables for
3980 details). If inside a single line comment and `comment-multi-line' is
3981 nil, a new comment of the same type is started on the next line and
3982 indented as appropriate for comments. If inside a macro, a line
3983 continuation backslash is inserted and aligned as appropriate, and the
3984 new line is indented according to `c-syntactic-indentation'.
3986 If a fill prefix is specified, it overrides all the above."
3987 ;; allow-auto-fill is used from c-context-line-break to allow auto
3988 ;; filling to break the line more than once. Since this function is
3989 ;; used from auto-fill itself, that's normally disabled to avoid
3990 ;; unnecessary recursion.
3992 (let ((fill-prefix fill-prefix)
3995 (delete-horizontal-space)
3997 (insert-and-inherit ?\n)
3998 (newline (if allow-auto-fill nil 1)))))
3999 ;; Already know the literal type and limits when called from
4000 ;; c-context-line-break.
4001 (c-lit-limits c-lit-limits)
4002 (c-lit-type c-lit-type)
4003 (c-macro-start c-macro-start))
4005 (c-save-buffer-state ()
4006 (when (not (eq c-auto-fill-prefix t))
4007 ;; Called from do-auto-fill.
4008 (unless c-lit-limits
4009 (setq c-lit-limits (c-literal-limits nil nil t)))
4011 (setq c-lit-type (c-literal-type c-lit-limits)))
4012 (if (memq (cond ((c-query-and-set-macro-start) 'cpp)
4013 ((null c-lit-type) 'code)
4016 (setq fill-prefix t) ; Used as flag in the cond.
4017 (if (and (null c-auto-fill-prefix)
4019 (<= (c-point 'bol) (car c-lit-limits)))
4020 ;; The adaptive fill function has generated a prefix, but
4021 ;; we're on the first line in a block comment so it'll be
4022 ;; wrong. Ignore it to guess a better one below.
4023 (setq fill-prefix nil)
4024 (when (and (eq c-lit-type 'c++)
4025 (not (string-match (concat "\\`[ \t]*"
4026 c-line-comment-starter)
4027 (or fill-prefix ""))))
4028 ;; Kludge: If the function that adapted the fill prefix
4029 ;; doesn't produce the required comment starter for line
4030 ;; comments, then we ignore it.
4031 (setq fill-prefix nil)))
4034 (cond ((eq fill-prefix t)
4035 ;; A call from do-auto-fill which should be ignored.
4038 ;; A fill-prefix overrides anything.
4039 (funcall do-line-break)
4040 (insert-and-inherit fill-prefix))
4041 ((c-save-buffer-state ()
4042 (unless c-lit-limits
4043 (setq c-lit-limits (c-literal-limits)))
4045 (setq c-lit-type (c-literal-type c-lit-limits)))
4046 (memq c-lit-type '(c c++)))
4047 ;; Some sort of comment.
4048 (if (or comment-multi-line
4050 (goto-char (car c-lit-limits))
4052 (< (point) (cdr c-lit-limits))))
4053 ;; Inside a comment that should be continued.
4054 (let ((fill (c-save-buffer-state nil
4055 (c-guess-fill-prefix
4057 (c-collect-line-comments c-lit-limits))
4061 (or (and (eq c-lit-type 'c)
4063 (goto-char (- (cdr c-lit-limits) 2))
4064 (if (looking-at "\\*/") (point))))
4065 (cdr c-lit-limits))))
4066 ;; Skip forward past the fill prefix in case
4067 ;; we're standing in it.
4069 ;; FIXME: This doesn't work well in cases like
4071 ;; /* Bla bla bla bla bla
4074 ;; If point is on the 'B' then the line will be
4075 ;; broken after "Bla b".
4076 (while (and (< (current-column) (cdr fill))
4079 (if (and (> (point) comment-text-end)
4080 (> (c-point 'bol) (car c-lit-limits)))
4082 ;; The skip takes us out of the (block)
4083 ;; comment; insert the fill prefix at bol
4084 ;; instead and keep the position.
4085 (setq pos (copy-marker pos t))
4087 (insert-and-inherit (car fill))
4088 (if soft (insert-and-inherit ?\n) (newline 1))
4090 (set-marker pos nil))
4091 ;; Don't break in the middle of a comment starter
4093 (cond ((> (point) comment-text-end)
4094 (goto-char comment-text-end))
4095 ((< (point) (+ (car c-lit-limits) 2))
4096 (goto-char (+ (car c-lit-limits) 2))))
4097 (funcall do-line-break)
4098 (insert-and-inherit (car fill))))
4099 ;; Inside a comment that should be broken.
4100 (let ((comment-start comment-start)
4101 (comment-end comment-end)
4103 (if (eq c-lit-type 'c)
4104 (unless (string-match "[ \t]*/\\*" comment-start)
4105 (setq comment-start "/* " comment-end " */"))
4106 (unless (string-match "[ \t]*//" comment-start)
4107 (setq comment-start "// " comment-end "")))
4108 (setq col (save-excursion
4109 (back-to-indentation)
4111 (funcall do-line-break)
4112 (when (and comment-end (not (equal comment-end "")))
4114 (insert-and-inherit comment-end)
4116 ;; c-comment-indent may look at the current
4117 ;; indentation, so let's start out with the same
4118 ;; indentation as the previous one.
4120 (insert-and-inherit comment-start)
4121 (indent-for-comment))))
4122 ((c-query-and-set-macro-start)
4124 (unless (looking-at "[ \t]*\\\\$")
4125 ;; Do not clobber the alignment of the line continuation
4126 ;; slash; c-backslash-region might look at it.
4127 (delete-horizontal-space))
4128 ;; Got an asymmetry here: In normal code this command
4129 ;; doesn't indent the next line syntactically, and otoh a
4130 ;; normal syntactically indenting newline doesn't continue
4132 (c-newline-and-indent (if allow-auto-fill nil 1)))
4134 ;; Somewhere else in the code.
4135 (let ((col (save-excursion
4137 (while (and (looking-at "[ \t]*\\\\?$")
4138 (= (forward-line -1) 0)))
4139 (current-indentation))))
4140 (funcall do-line-break)
4141 (indent-to col))))))
4143 (defalias 'c-comment-line-break-function 'c-indent-new-comment-line)
4144 (make-obsolete 'c-comment-line-break-function 'c-indent-new-comment-line)
4146 ;; advice for indent-new-comment-line for older Emacsen
4147 (unless (boundp 'comment-line-break-function)
4148 (defvar c-inside-line-break-advice nil)
4149 (defadvice indent-new-comment-line (around c-line-break-advice
4150 activate preactivate)
4151 "Call `c-indent-new-comment-line' if in CC Mode."
4152 (if (or c-inside-line-break-advice
4153 (not c-buffer-is-cc-mode))
4155 (let ((c-inside-line-break-advice t))
4156 (c-indent-new-comment-line (ad-get-arg 0))))))
4158 (defun c-context-line-break ()
4159 "Do a line break suitable to the context.
4161 When point is outside a comment or macro, insert a newline and indent
4162 according to the syntactic context, unless `c-syntactic-indentation'
4163 is nil, in which case the new line is indented as the previous
4164 non-empty line instead.
4166 When point is inside the content of a preprocessor directive, a line
4167 continuation backslash is inserted before the line break and aligned
4168 appropriately. The end of the cpp directive doesn't count as inside
4171 When point is inside a comment, continue it with the appropriate
4172 comment prefix (see the `c-comment-prefix-regexp' and
4173 `c-block-comment-prefix' variables for details). The end of a
4174 C++-style line comment doesn't count as inside it."
4177 (let* (c-lit-limits c-lit-type
4178 (c-macro-start c-macro-start))
4180 (if (c-save-buffer-state ()
4181 (setq c-lit-limits (c-literal-limits nil nil t)
4182 c-lit-type (c-literal-type c-lit-limits))
4183 (or (eq c-lit-type 'c)
4184 (and (eq c-lit-type 'c++)
4186 (skip-chars-forward " \t")
4188 (1- (cdr (setq c-lit-limits (c-collect-line-comments
4190 (and (or (not (looking-at "\\s *$"))
4191 (eq (char-before) ?\\))
4192 (c-query-and-set-macro-start)
4194 (goto-char c-macro-start)
4195 (if (looking-at c-opt-cpp-start)
4196 (goto-char (match-end 0)))
4200 (let ((comment-multi-line t)
4202 (c-indent-new-comment-line nil t))
4204 (delete-horizontal-space)
4207 ;; c-indent-line may look at the current indentation, so let's
4208 ;; start out with the same indentation as the previous line.
4209 (let ((col (save-excursion
4211 (while (and (looking-at "[ \t]*\\\\?$")
4212 (= (forward-line -1) 0)))
4213 (current-indentation))))
4216 (indent-according-to-mode))))
4218 (defun c-context-open-line ()
4219 "Insert a line break suitable to the context and leave point before it.
4220 This is the `c-context-line-break' equivalent to `open-line', which is
4221 normally bound to C-o. See `c-context-line-break' for the details."
4223 (let ((here (point)))
4226 ;; Temporarily insert a non-whitespace char to keep any
4227 ;; preceding whitespace intact.
4229 (c-context-line-break))
4234 (cc-provide 'cc-cmds)
4236 ;;; arch-tag: bf0611dc-d1f4-449e-9e45-4ec7c6936677
4237 ;;; cc-cmds.el ends here