1 ;;; cc-cmds.el --- user level commands for CC Mode
3 ;; Copyright (C) 1985, 1987, 1992-2014 Free Software Foundation, Inc.
5 ;; Authors: 2003- Alan Mackenzie
6 ;; 1998- Martin Stjernholm
7 ;; 1992-1999 Barry A. Warsaw
10 ;; 1985 Richard M. Stallman
11 ;; Maintainer: bug-cc-mode@gnu.org
12 ;; Created: 22-Apr-1997 (split from cc-mode.el)
13 ;; Keywords: c languages
16 ;; This file is part of GNU Emacs.
18 ;; GNU Emacs is free software: you can redistribute it and/or modify
19 ;; it under the terms of the GNU General Public License as published by
20 ;; the Free Software Foundation, either version 3 of the License, or
21 ;; (at your option) any later version.
23 ;; GNU Emacs is distributed in the hope that it will be useful,
24 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
25 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
26 ;; GNU General Public License for more details.
28 ;; You should have received a copy of the GNU General Public License
29 ;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
37 (if (and (boundp 'byte-compile-dest-file
)
38 (stringp byte-compile-dest-file
))
39 (cons (file-name-directory byte-compile-dest-file
) load-path
)
41 (load "cc-bytecomp" nil t
)))
45 (cc-require 'cc-engine
)
47 ;; Silence the compiler.
48 (cc-bytecomp-defvar filladapt-mode
) ; c-fill-paragraph contains a kludge
49 ; which looks at this.
51 ;; Indentation / Display syntax functions
52 (defvar c-fix-backslashes t
)
54 (defun c-indent-line (&optional syntax quiet ignore-point-pos
)
55 "Indent the current line according to the syntactic context,
56 if `c-syntactic-indentation' is non-nil. Optional SYNTAX is the
57 syntactic information for the current line. Be silent about syntactic
58 errors if the optional argument QUIET is non-nil, even if
59 `c-report-syntactic-errors' is non-nil. Normally the position of
60 point is used to decide where the old indentation is on a lines that
61 is otherwise empty \(ignoring any line continuation backslash), but
62 that's not done if IGNORE-POINT-POS is non-nil. Returns the amount of
63 indentation change \(in columns)."
65 (let ((line-cont-backslash (save-excursion
67 (eq (char-before) ?
\\)))
68 (c-fix-backslashes c-fix-backslashes
)
71 (when (and (not ignore-point-pos
)
74 (looking-at (if line-cont-backslash
75 ;; Don't use "\\s " - ^L doesn't count as WS
79 (<= (point) (match-end 1)))
80 ;; Delete all whitespace after point if there's only whitespace
81 ;; on the line, so that any code that does back-to-indentation
82 ;; or similar gets the current column in this case. If this
83 ;; removes a line continuation backslash it'll be restored
85 (unless c-auto-align-backslashes
86 ;; Should try to keep the backslash alignment
89 (goto-char (match-end 0))
90 (setq bs-col
(1- (current-column)))))
91 (delete-region (point) (match-end 0))
92 (setq c-fix-backslashes t
))
93 (if c-syntactic-indentation
95 (or (let ((c-parsing-error nil
)
98 (and (boundp 'c-syntactic-context
)
99 c-syntactic-context
))))
100 (c-save-buffer-state (indent)
101 (unless c-syntactic-context
102 (setq c-syntactic-context
(c-guess-basic-syntax)))
103 (setq indent
(c-get-syntactic-indentation
104 c-syntactic-context
))
105 (and (not (c-echo-parsing-error quiet
))
106 c-echo-syntactic-information-p
107 (message "syntax: %s, indent: %d"
108 c-syntactic-context indent
))
109 (setq shift-amt
(- indent
(current-indentation))))
110 (c-shift-line-indentation shift-amt
)
111 (run-hooks 'c-special-indent-hook
)
116 (while (and (= (forward-line -
1) 0)
117 (if (looking-at "\\s *\\\\?$")
119 (setq indent
(current-indentation))
121 (setq shift-amt
(- indent
(current-indentation)))
122 (c-shift-line-indentation shift-amt
)))
123 (when (and c-fix-backslashes line-cont-backslash
)
128 (when c-auto-align-backslashes
129 ;; Realign the line continuation backslash.
130 (c-backslash-region (point) (point) nil t
))))
133 (defun c-newline-and-indent (&optional newline-arg
)
134 "Insert a newline and indent the new line.
135 This function fixes line continuation backslashes if inside a macro,
136 and takes care to set the indentation before calling
137 `indent-according-to-mode', so that lineup functions like
138 `c-lineup-dont-change' works better."
140 ;; TODO: Backslashes before eol in comments and literals aren't
142 (let ((c-macro-start (c-query-macro-start))
143 ;; Avoid calling c-backslash-region from c-indent-line if it's
144 ;; called during the newline call, which can happen due to
145 ;; c-electric-continued-statement, for example. We also don't
146 ;; want any backslash alignment from indent-according-to-mode.
147 (c-fix-backslashes nil
)
148 has-backslash insert-backslash
153 (while (and (looking-at "[ \t]*\\\\?$")
154 (= (forward-line -
1) 0)))
155 (setq col
(current-indentation)))
157 (if (and (eolp) (eq (char-before) ?
\\))
158 (setq insert-backslash t
160 (setq has-backslash
(eq (char-before (c-point 'eol
)) ?
\\))))
161 (newline newline-arg
)
166 ;; The backslash stayed on the previous line. Insert one
167 ;; before calling c-backslash-region, so that
168 ;; bs-col-after-end in it works better. Fixup the
169 ;; backslashes on the newly inserted line.
172 (c-backslash-region (point) (point) nil t
))
173 ;; The backslash moved to the new line, if there was any. Let
174 ;; c-backslash-region fix a backslash on the previous line,
175 ;; and the one that might be on the new line.
176 ;; c-auto-align-backslashes is intentionally ignored here;
177 ;; maybe the moved backslash should be left alone if it's set,
178 ;; but we fix both lines on the grounds that the old backslash
179 ;; has been moved anyway and is now in a different context.
180 (c-backslash-region start
(if has-backslash
(point) start
) nil t
)))
181 (when c-syntactic-indentation
182 ;; Reindent syntactically. The indentation done above is not
183 ;; wasted, since c-indent-line might look at the current
185 (let ((c-syntactic-context (c-save-buffer-state nil
186 (c-guess-basic-syntax))))
187 ;; We temporarily insert another line break, so that the
188 ;; lineup functions will see the line as empty. That makes
189 ;; e.g. c-lineup-cpp-define more intuitive since it then
190 ;; proceeds to the preceding line in this case.
192 (delete-horizontal-space)
193 (setq start
(- (point-max) (point)))
197 (indent-according-to-mode))
198 (goto-char (- (point-max) start
))
201 ;; Must align the backslash again after reindentation. The
202 ;; c-backslash-region call above can't be optimized to ignore
203 ;; this line, since it then won't align correctly with the
204 ;; lines below if the first line in the macro is broken.
205 (c-backslash-region (point) (point) nil t
)))))
207 (defun c-show-syntactic-information (arg)
208 "Show syntactic information for current line.
209 With universal argument, inserts the analysis as a comment on that line."
211 (let* ((c-parsing-error nil
)
212 (syntax (if (boundp 'c-syntactic-context
)
213 ;; Use `c-syntactic-context' in the same way as
214 ;; `c-indent-line', to be consistent.
216 (c-save-buffer-state nil
217 (c-guess-basic-syntax)))))
218 (if (not (consp arg
))
220 (message "Syntactic analysis: %s" syntax
)
224 (setq elem
(pop syntax
))
225 (when (setq pos
(c-langelem-pos elem
))
226 (push (c-put-overlay pos
(1+ pos
)
229 (when (setq pos
(c-langelem-2nd-pos elem
))
230 (push (c-put-overlay pos
(1+ pos
)
231 'face
'secondary-selection
)
235 (c-delete-overlay (pop ols
)))))
237 (insert-and-inherit (format "%s" syntax
))
239 (c-keep-region-active))
241 (defun c-syntactic-information-on-region (from to
)
242 "Insert a comment with the syntactic analysis on every line in the region."
246 (narrow-to-region from to
)
247 (goto-char (point-min))
249 (c-show-syntactic-information '(0))
253 ;; Minor mode functions.
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 ;; subword might not be loaded.
262 (boundp 'subword-mode
)
263 (symbol-value 'subword-mode
))
266 ;; FIXME: Derived modes might want to use something else
267 ;; than a string for `mode-name'.
268 (bare-mode-name (if (string-match "\\(^[^/]*\\)/" mode-name
)
269 (match-string 1 mode-name
)
271 ;; (setq c-submode-indicators
272 ;; (if (> (length fmt) 1)
275 (if (> (length fmt
) 1)
276 (concat bare-mode-name fmt
)
278 (force-mode-line-update)))
280 (defun c-toggle-syntactic-indentation (&optional arg
)
281 "Toggle syntactic indentation.
282 Optional numeric ARG, if supplied, turns on syntactic indentation when
283 positive, turns it off when negative, and just toggles it when zero or
286 When syntactic indentation is turned on (the default), the indentation
287 functions and the electric keys indent according to the syntactic
288 context keys, when applicable.
290 When it's turned off, the electric keys don't reindent, the indentation
291 functions indents every new line to the same level as the previous
292 nonempty line, and \\[c-indent-command] adjusts the indentation in steps
293 specified by `c-basic-offset'. The indentation style has no effect in
294 this mode, nor any of the indentation associated variables,
295 e.g. `c-special-indent-hook'.
297 This command sets the variable `c-syntactic-indentation'."
299 (setq c-syntactic-indentation
300 (c-calculate-state arg c-syntactic-indentation
))
301 (c-keep-region-active))
303 (defun c-toggle-auto-newline (&optional arg
)
304 "Toggle auto-newline feature.
305 Optional numeric ARG, if supplied, turns on auto-newline when
306 positive, turns it off when negative, and just toggles it when zero or
309 Turning on auto-newline automatically enables electric indentation.
311 When the auto-newline feature is enabled (indicated by \"/la\" on the
312 mode line after the mode name) newlines are automatically inserted
313 after special characters such as brace, comma, semi-colon, and colon."
316 (c-calculate-state arg
(and c-auto-newline c-electric-flag
)))
317 (if c-auto-newline
(setq c-electric-flag t
))
319 (c-keep-region-active))
321 (defalias 'c-toggle-auto-state
'c-toggle-auto-newline
)
322 (make-obsolete 'c-toggle-auto-state
'c-toggle-auto-newline
"22.1")
324 (defun c-toggle-hungry-state (&optional arg
)
325 "Toggle hungry-delete-key feature.
326 Optional numeric ARG, if supplied, turns on hungry-delete when
327 positive, turns it off when negative, and just toggles it when zero or
330 When the hungry-delete-key feature is enabled (indicated by \"/h\" on
331 the mode line after the mode name) the delete key gobbles all preceding
332 whitespace in one fell swoop."
334 (setq c-hungry-delete-key
(c-calculate-state arg c-hungry-delete-key
))
336 (c-keep-region-active))
338 (defun c-toggle-auto-hungry-state (&optional arg
)
339 "Toggle auto-newline and hungry-delete-key features.
340 Optional numeric ARG, if supplied, turns on auto-newline and
341 hungry-delete when positive, turns them off when negative, and just
342 toggles them when zero or left out.
344 See `c-toggle-auto-newline' and `c-toggle-hungry-state' for details."
346 (setq c-auto-newline
(c-calculate-state arg c-auto-newline
))
347 (setq c-hungry-delete-key
(c-calculate-state arg c-hungry-delete-key
))
349 (c-keep-region-active))
351 (defun c-toggle-electric-state (&optional arg
)
352 "Toggle the electric indentation feature.
353 Optional numeric ARG, if supplied, turns on electric indentation when
354 positive, turns it off when negative, and just toggles it when zero or
357 (setq c-electric-flag
(c-calculate-state arg c-electric-flag
))
359 (when (fboundp 'electric-indent-local-mode
) ; Emacs 24.4 or later.
360 (electric-indent-local-mode (if c-electric-flag
1 0)))
361 (c-keep-region-active))
366 (defun c-electric-backspace (arg)
367 "Delete the preceding character or whitespace.
368 If `c-hungry-delete-key' is non-nil (indicated by \"/h\" on the mode
369 line) then all preceding whitespace is consumed. If however a prefix
370 argument is supplied, or `c-hungry-delete-key' is nil, or point is
371 inside a literal then the function in the variable
372 `c-backspace-function' is called."
374 (if (c-save-buffer-state ()
375 (or (not c-hungry-delete-key
)
378 (funcall c-backspace-function
(prefix-numeric-value arg
))
379 (c-hungry-delete-backwards)))
381 (defun c-hungry-delete-backwards ()
382 "Delete the preceding character or all preceding whitespace
383 back to the previous non-whitespace character.
384 See also \\[c-hungry-delete-forward]."
386 (let ((here (point)))
388 (if (/= (point) here
)
389 (delete-region (point) here
)
390 (funcall c-backspace-function
1))))
392 (defalias 'c-hungry-backspace
'c-hungry-delete-backwards
)
394 (defun c-electric-delete-forward (arg)
395 "Delete the following character or whitespace.
396 If `c-hungry-delete-key' is non-nil (indicated by \"/h\" on the mode
397 line) then all following whitespace is consumed. If however a prefix
398 argument is supplied, or `c-hungry-delete-key' is nil, or point is
399 inside a literal then the function in the variable `c-delete-function'
402 (if (c-save-buffer-state ()
403 (or (not c-hungry-delete-key
)
406 (funcall c-delete-function
(prefix-numeric-value arg
))
407 (c-hungry-delete-forward)))
409 (defun c-hungry-delete-forward ()
410 "Delete the following character or all following whitespace
411 up to the next non-whitespace character.
412 See also \\[c-hungry-delete-backwards]."
414 (let ((here (point)))
416 (if (/= (point) here
)
417 (delete-region (point) here
)
418 (funcall c-delete-function
1))))
420 ;; This function is only used in XEmacs.
421 (defun c-electric-delete (arg)
422 "Deletes preceding or following character or whitespace.
423 This function either deletes forward as `c-electric-delete-forward' or
424 backward as `c-electric-backspace', depending on the configuration: If
425 the function `delete-forward-p' is defined and returns non-nil, it
426 deletes forward. Otherwise it deletes backward.
428 Note: This is the way in XEmacs to choose the correct action for the
429 \[delete] key, whichever key that means. Other flavors don't use this
430 function to control that."
432 (if (and (fboundp 'delete-forward-p
)
434 (c-electric-delete-forward arg
)
435 (c-electric-backspace arg
)))
437 ;; This function is only used in XEmacs.
438 (defun c-hungry-delete ()
439 "Delete a non-whitespace char, or all whitespace up to the next non-whitespace char.
440 The direction of deletion depends on the configuration: If the
441 function `delete-forward-p' is defined and returns non-nil, it deletes
442 forward using `c-hungry-delete-forward'. Otherwise it deletes
443 backward using `c-hungry-backspace'.
445 Note: This is the way in XEmacs to choose the correct action for the
446 \[delete] key, whichever key that means. Other flavors don't use this
447 function to control that."
449 (if (and (fboundp 'delete-forward-p
)
451 (c-hungry-delete-forward)
452 (c-hungry-delete-backwards)))
454 (defun c-electric-pound (arg)
456 If `c-electric-flag' is set, handle it specially according to the variable
457 `c-electric-pound-behavior'. If a numeric ARG is supplied, or if point is
458 inside a literal or a macro, nothing special happens."
460 (if (c-save-buffer-state ()
462 (not c-electric-flag
)
463 (not (memq 'alignleft c-electric-pound-behavior
))
465 (skip-chars-backward " \t")
468 (and (= (forward-line -
1) 0)
470 (eq (char-before) ?
\\))))
472 ;; do nothing special
473 (self-insert-command (prefix-numeric-value arg
))
474 ;; place the pound character at the left edge
475 (let ((pos (- (point-max) (point)))
478 (delete-horizontal-space)
479 (insert (c-last-command-char))
481 (goto-char (- (point-max) pos
)))
484 (defun c-point-syntax ()
485 ;; Return the syntactic context of the construct at point. (This is NOT
486 ;; nec. the same as the s.c. of the line point is on). N.B. This won't work
487 ;; between the `#' of a cpp thing and what follows (see c-opt-cpp-prefix).
488 (c-save-buffer-state (;; shut this up too
489 (c-echo-syntactic-information-p nil
)
491 (c-tentative-buffer-changes
492 ;; insert a newline to isolate the construct at point for syntactic
495 ;; In AWK (etc.) or in a macro, make sure this CR hasn't changed
496 ;; the syntax. (There might already be an escaped NL there.)
499 (c-skip-ws-backward (c-point 'bopl
))
504 (and (c-beginning-of-macro)
505 (progn (c-end-of-macro)
510 (let ((c-syntactic-indentation-in-macros t
)
511 (c-auto-newline-analysis t
))
512 ;; Turn on syntactic macro analysis to help with auto
514 (setq syntax
(c-guess-basic-syntax))
518 (defun c-brace-newlines (syntax)
519 ;; A brace stands at point. SYNTAX is the syntactic context of this brace
520 ;; (not necessarily the same as the S.C. of the line it is on). Return
521 ;; NEWLINES, the list containing some combination of the symbols `before'
522 ;; and `after' saying where newlines should be inserted.
525 ;; This is the list of brace syntactic symbols that can hang.
526 ;; If any new ones are added to c-offsets-alist, they should be
527 ;; added here as well.
529 ;; The order of this list is important; if SYNTAX has several
530 ;; elements, the element that "wins" is the earliest in SYMS.
531 '(arglist-cont-nonempty ; e.g. an array literal.
532 class-open class-close defun-open defun-close
533 inline-open inline-close
534 brace-list-open brace-list-close
535 brace-list-intro brace-entry-open
536 block-open block-close
537 substatement-open statement-case-open
538 extern-lang-open extern-lang-close
539 namespace-open namespace-close
540 module-open module-close
541 composition-open composition-close
542 inexpr-class-open inexpr-class-close
543 ;; `statement-cont' is here for the case with a brace
544 ;; list opener inside a statement. C.f. CASE B.2 in
545 ;; `c-guess-continued-construct'.
548 (c-echo-syntactic-information-p nil
)
549 symb-newlines
) ; e.g. (substatement-open . (after))
552 ;; Do not try to insert newlines around a special
553 ;; (Pike-style) brace list.
554 (if (and c-special-brace-lists
556 (c-safe (if (= (char-before) ?
{)
559 (c-looking-at-special-brace-list))))
561 ;; Seek the matching entry in c-hanging-braces-alist.
564 ;; Substitute inexpr-class and class-open or
565 ;; class-close with inexpr-class-open or
566 ;; inexpr-class-close.
567 (if (assq 'inexpr-class syntax
)
568 (cond ((assq 'class-open syntax
)
569 '((inexpr-class-open)))
570 ((assq 'class-close syntax
)
571 '((inexpr-class-close)))
574 c-hanging-braces-alist
)
575 '(ignore before after
)))) ; Default, when not in c-h-b-l.
577 ;; If syntax is a function symbol, then call it using the
578 ;; defined semantics.
579 (if (and (not (consp (cdr symb-newlines
)))
580 (functionp (cdr symb-newlines
)))
581 (let ((c-syntactic-context syntax
))
582 (funcall (cdr symb-newlines
)
585 (cdr symb-newlines
))))
587 (defun c-try-one-liner ()
588 ;; Point is just after a newly inserted }. If the non-whitespace
589 ;; content of the braces is a single line of code, compact the whole
590 ;; construct to a single line, if this line isn't too long. The Right
591 ;; Thing is done with comments.
593 ;; Point will be left after the }, regardless of whether the clean-up is
594 ;; done. Return NON-NIL if the clean-up happened, NIL if it didn't.
597 (pos (- (point-max) (point)))
598 mbeg1 mend1 mbeg4 mend4
599 eol-col cmnt-pos cmnt-col cmnt-gap
)
604 ;; Avoid backtracking over a very large block. The one we
605 ;; deal with here can never be more than three lines.
606 (narrow-to-region (save-excursion
610 (and (c-safe (c-backward-sexp))
613 (narrow-to-region (point) (1- here
)) ; innards of {.}
615 (cc-eval-when-compile
617 "\\(" ; (match-beginning 1)
618 "[ \t]*\\([\r\n][ \t]*\\)?" ; WS with opt. NL
619 "\\)" ; (match-end 1)
620 "[^ \t\r\n]+\\([ \t]+[^ \t\r\n]+\\)*" ; non-WS
621 "\\(" ; (match-beginning 4)
622 "[ \t]*\\([\r\n][ \t]*\\)?" ; WS with opt. NL
623 "\\)\\'"))))))) ; (match-end 4) at EOB.
625 (if (c-tentative-buffer-changes
626 (setq mbeg1
(match-beginning 1) mend1
(match-end 1)
627 mbeg4
(match-beginning 4) mend4
(match-end 4))
628 (backward-char) ; back over the `}'
630 (setq cmnt-pos
(and (c-backward-single-comment)
631 (- (point) (- mend1 mbeg1
)))))
632 (delete-region mbeg4 mend4
)
633 (delete-region mbeg1 mend1
)
634 (setq eol-col
(save-excursion (end-of-line) (current-column)))
636 ;; Necessary to put the closing brace before any line
637 ;; oriented comment to keep it syntactically significant.
638 ;; This isn't necessary for block comments, but the result
639 ;; looks nicer anyway.
641 (delete-char 1) ; the `}' has blundered into a comment
643 (setq cmnt-col
(1+ (current-column)))
644 (setq cmnt-pos
(1+ cmnt-pos
)) ; we're inserting a `}'
646 (insert-char ?\
} 1) ; reinsert the `}' before the comment.
647 (setq cmnt-gap
(- cmnt-col
(current-column)))
648 (when (zerop cmnt-gap
)
649 (insert-char ?\
1) ; Put a space before a bare comment.
652 (or (null c-max-one-liner-length
)
653 (zerop c-max-one-liner-length
)
654 (<= eol-col c-max-one-liner-length
)
655 ;; Can we trim space before comment to make the line fit?
657 (< (- eol-col cmnt-gap
) c-max-one-liner-length
)
658 (progn (goto-char cmnt-pos
)
659 (backward-delete-char-untabify
660 (- eol-col c-max-one-liner-length
))
662 (goto-char (- (point-max) pos
))))))
664 (defun c-electric-brace (arg)
667 If `c-electric-flag' is non-nil, the brace is not inside a literal and a
668 numeric ARG hasn't been supplied, the command performs several electric
671 \(a) If the auto-newline feature is turned on (indicated by \"/la\" on
672 the mode line) newlines are inserted before and after the brace as
673 directed by the settings in `c-hanging-braces-alist'.
675 \(b) Any auto-newlines are indented. The original line is also
676 reindented unless `c-syntactic-indentation' is nil.
678 \(c) If auto-newline is turned on, various newline cleanups based on the
679 settings of `c-cleanup-list' are done."
682 (let (safepos literal
683 ;; We want to inhibit blinking the paren since this would be
684 ;; most disruptive. We'll blink it ourselves later on.
685 (old-blink-paren blink-paren-function
)
686 blink-paren-function case-fold-search
)
688 (c-save-buffer-state ()
689 (setq safepos
(c-safe-position (point) (c-parse-state))
690 literal
(c-in-literal safepos
)))
692 ;; Insert the brace. Note that expand-abbrev might reindent
693 ;; the line here if there's a preceding "else" or something.
694 (self-insert-command (prefix-numeric-value arg
))
696 (when (and c-electric-flag
(not literal
) (not arg
))
697 (if (not (looking-at "[ \t]*\\\\?$"))
698 (if c-syntactic-indentation
699 (indent-according-to-mode))
701 (let ( ;; shut this up too
702 (c-echo-syntactic-information-p nil
)
704 ln-syntax br-syntax syntax
) ; Syntactic context of the original line,
705 ; of the brace itself, of the line the brace ends up on.
706 (c-save-buffer-state ((c-syntactic-indentation-in-macros t
)
707 (c-auto-newline-analysis t
))
708 (setq ln-syntax
(c-guess-basic-syntax)))
709 (if c-syntactic-indentation
710 (c-indent-line ln-syntax
))
714 (setq br-syntax
(c-point-syntax)
715 newlines
(c-brace-newlines br-syntax
))
717 ;; Insert the BEFORE newline, if wanted, and reindent the newline.
718 (if (and (memq 'before newlines
)
719 (> (current-column) (current-indentation)))
720 (if c-syntactic-indentation
721 ;; Only a plain newline for now - it's indented
722 ;; after the cleanups when the line has its final
725 (c-newline-and-indent)))
728 ;; `syntax' is the syntactic context of the line which ends up
729 ;; with the brace on it.
730 (setq syntax
(if (memq 'before newlines
) br-syntax ln-syntax
))
732 ;; Do all appropriate clean ups
734 (pos (- (point-max) (point)))
738 ;; `}': clean up empty defun braces
739 (when (c-save-buffer-state ()
740 (and (memq 'empty-defun-braces c-cleanup-list
)
741 (eq (c-last-command-char) ?\
})
742 (c-intersect-lists '(defun-close class-close inline-close
)
747 (eq (char-before) ?\
{))
748 ;; make sure matching open brace isn't in a comment
749 (not (c-in-literal))))
750 (delete-region (point) (1- here
))
751 (setq here
(- (point-max) pos
)))
754 ;; `}': compact to a one-liner defun?
757 (and (eq (c-last-command-char) ?\
})
758 (memq 'one-liner-defun
c-cleanup-list)
759 (c-intersect-lists '(defun-close) syntax
)
761 (setq here
(- (point-max) pos
))))
763 ;; `{': clean up brace-else-brace and brace-elseif-brace
764 (when (eq (c-last-command-char) ?\
{)
766 ((and (memq 'brace-else-brace c-cleanup-list
)
769 "\\([ \t\n]\\|\\\\\n\\)*"
771 "\\([ \t\n]\\|\\\\\n\\)*"
775 (delete-region (match-beginning 0) (match-end 0))
776 (insert-and-inherit "} else {"))
777 ((and (memq 'brace-elseif-brace c-cleanup-list
)
779 (goto-char (1- here
))
783 (eq (char-before) ?\
)))
784 (zerop (c-save-buffer-state nil
(c-backward-token-2 1 t
)))
785 (eq (char-after) ?\
()
790 "\\([ \t\n]\\|\\\\\n\\)*"
792 "\\([ \t\n]\\|\\\\\n\\)+"
794 "\\([ \t\n]\\|\\\\\n\\)*"
797 ;(eq (match-end 0) tmp);
799 (delete-region mbeg mend
)
803 (goto-char (- (point-max) pos
))
805 ;; Indent the line after the cleanups since it might
806 ;; very well indent differently due to them, e.g. if
807 ;; c-indent-one-line-block is used together with the
808 ;; one-liner-defun cleanup.
809 (when c-syntactic-indentation
812 ;; does a newline go after the brace?
813 (if (memq 'after newlines
)
814 (c-newline-and-indent))
818 (and (eq (c-last-command-char) ?\
})
819 (not executing-kbd-macro
)
822 (c-save-buffer-state nil
823 (c-backward-syntactic-ws safepos
))
824 (funcall old-blink-paren
)))))
826 (defun c-electric-slash (arg)
827 "Insert a slash character.
829 If the slash is inserted immediately after the comment prefix in a c-style
830 comment, the comment might get closed by removing whitespace and possibly
831 inserting a \"*\". See the variable `c-cleanup-list'.
833 Indent the line as a comment, if:
835 1. The slash is second of a \"//\" line oriented comment introducing
836 token and we are on a comment-only-line, or
838 2. The slash is part of a \"*/\" token that closes a block oriented
841 If a numeric ARG is supplied, point is inside a literal, or
842 `c-syntactic-indentation' is nil or `c-electric-flag' is nil, indentation
845 (let ((literal (c-save-buffer-state () (c-in-literal)))
848 (c-echo-syntactic-information-p nil
))
850 ;; comment-close-slash cleanup? This DOESN'T need `c-electric-flag' or
851 ;; `c-syntactic-indentation' set.
854 (memq 'comment-close-slash c-cleanup-list
)
855 (eq (c-last-command-char) ?
/)
856 (looking-at (concat "[ \t]*\\("
857 (regexp-quote comment-end
) "\\)?$"))
858 ; (eq c-block-comment-ender "*/") ; C-style comments ALWAYS end in */
861 (narrow-to-region (point-min) (point))
862 (back-to-indentation)
863 (looking-at (concat c-current-comment-prefix
"[ \t]*$")))))
864 (delete-region (progn (forward-line 0) (point))
865 (progn (end-of-line) (point)))
866 (insert-char ?
* 1)) ; the / comes later. ; Do I need a t (retain sticky properties) here?
868 (setq indentp
(and (not arg
)
869 c-syntactic-indentation
871 (eq (c-last-command-char) ?
/)
872 (eq (char-before) (if literal ?
* ?
/))))
873 (self-insert-command (prefix-numeric-value arg
))
875 (indent-according-to-mode))))
877 (defun c-electric-star (arg)
878 "Insert a star character.
879 If `c-electric-flag' and `c-syntactic-indentation' are both non-nil, and
880 the star is the second character of a C style comment starter on a
881 comment-only-line, indent the line as a comment. If a numeric ARG is
882 supplied, point is inside a literal, or `c-syntactic-indentation' is nil,
883 this indentation is inhibited."
886 (self-insert-command (prefix-numeric-value arg
))
887 ;; if we are in a literal, or if arg is given do not reindent the
888 ;; current line, unless this star introduces a comment-only line.
889 (if (c-save-buffer-state ()
890 (and c-syntactic-indentation
893 (eq (c-in-literal) 'c
)
894 (eq (char-before) ?
*)
897 (skip-chars-backward "*")
898 (if (eq (char-before) ?
/)
900 (skip-chars-backward " \t")
902 (let (c-echo-syntactic-information-p) ; shut this up
903 (indent-according-to-mode))
906 (defun c-electric-semi&comma
(arg)
907 "Insert a comma or semicolon.
909 If `c-electric-flag' is non-nil, point isn't inside a literal and a
910 numeric ARG hasn't been supplied, the command performs several electric
913 \(a) When the auto-newline feature is turned on (indicated by \"/la\" on
914 the mode line) a newline might be inserted. See the variable
915 `c-hanging-semi&comma-criteria' for how newline insertion is determined.
917 \(b) Any auto-newlines are indented. The original line is also
918 reindented unless `c-syntactic-indentation' is nil.
920 \(c) If auto-newline is turned on, a comma following a brace list or a
921 semicolon following a defun might be cleaned up, depending on the
922 settings of `c-cleanup-list'."
924 (let* (lim literal c-syntactic-context
927 (c-echo-syntactic-information-p nil
))
929 (c-save-buffer-state ()
930 (setq lim
(c-most-enclosing-brace (c-parse-state))
931 literal
(c-in-literal lim
)))
933 (self-insert-command (prefix-numeric-value arg
))
935 (if (and c-electric-flag
(not literal
) (not arg
))
936 ;; do all cleanups and newline insertions if c-auto-newline is on.
937 (if (or (not c-auto-newline
)
938 (not (looking-at "[ \t]*\\\\?$")))
939 (if c-syntactic-indentation
941 ;; clean ups: list-close-comma or defun-close-semi
942 (let ((pos (- (point-max) (point))))
943 (if (c-save-buffer-state ()
945 (eq (c-last-command-char) ?
,)
946 (memq 'list-close-comma c-cleanup-list
))
948 (eq (c-last-command-char) ?\
;)
949 (memq 'defun-close-semi c-cleanup-list
)))
953 (eq (char-before) ?
}))
954 ;; make sure matching open brace isn't in a comment
955 (not (c-in-literal lim
))))
956 (delete-region (point) here
))
957 (goto-char (- (point-max) pos
)))
959 (when c-syntactic-indentation
960 (setq c-syntactic-context
(c-guess-basic-syntax))
961 (c-indent-line c-syntactic-context
))
962 ;; check to see if a newline should be added
963 (let ((criteria c-hanging-semi
&comma-criteria
)
964 answer add-newline-p
)
966 (setq answer
(funcall (car criteria
)))
967 ;; only nil value means continue checking
969 (setq criteria
(cdr criteria
))
971 ;; only 'stop specifically says do not add a newline
972 (setq add-newline-p
(not (eq answer
'stop
)))
975 (c-newline-and-indent))
978 (defun c-electric-colon (arg)
981 If `c-electric-flag' is non-nil, the colon is not inside a literal and a
982 numeric ARG hasn't been supplied, the command performs several electric
985 \(a) If the auto-newline feature is turned on (indicated by \"/la\" on
986 the mode line) newlines are inserted before and after the colon based on
987 the settings in `c-hanging-colons-alist'.
989 \(b) Any auto-newlines are indented. The original line is also
990 reindented unless `c-syntactic-indentation' is nil.
992 \(c) If auto-newline is turned on, whitespace between two colons will be
993 \"cleaned up\" leaving a scope operator, if this action is set in
997 (let* ((bod (c-point 'bod
))
998 (literal (c-save-buffer-state () (c-in-literal bod
)))
1001 (c-echo-syntactic-information-p nil
))
1002 (self-insert-command (prefix-numeric-value arg
))
1003 ;; Any electric action?
1004 (if (and c-electric-flag
(not literal
) (not arg
))
1005 ;; Unless we're at EOL, only re-indentation happens.
1006 (if (not (looking-at "[ \t]*\\\\?$"))
1007 (if c-syntactic-indentation
1008 (indent-according-to-mode))
1010 ;; scope-operator clean-up?
1011 (let ((pos (- (point-max) (point)))
1013 (if (c-save-buffer-state () ; Why do we need this? [ACM, 2003-03-12]
1015 (memq 'scope-operator c-cleanup-list
)
1016 (eq (char-before) ?
:)
1019 (c-skip-ws-backward)
1020 (eq (char-before) ?
:))
1021 (not (c-in-literal))
1022 (not (eq (char-after (- (point) 2)) ?
:))))
1024 (delete-region (point) (1- here
))
1025 (setq is-scope-op t
)))
1026 (goto-char (- (point-max) pos
)))
1028 ;; indent the current line if it's done syntactically.
1029 (if c-syntactic-indentation
1030 ;; Cannot use the same syntax analysis as we find below,
1031 ;; since that's made with c-syntactic-indentation-in-macros
1033 (indent-according-to-mode))
1035 ;; Calculate where, if anywhere, we want newlines.
1036 (c-save-buffer-state
1037 ((c-syntactic-indentation-in-macros t
)
1038 (c-auto-newline-analysis t
)
1039 ;; Turn on syntactic macro analysis to help with auto newlines
1041 (syntax (c-guess-basic-syntax))
1043 ;; Translate substatement-label to label for this operation.
1045 (if (eq (car (car elem
)) 'substatement-label
)
1046 (setcar (car elem
) 'label
))
1047 (setq elem
(cdr elem
)))
1048 ;; some language elements can only be determined by checking
1049 ;; the following line. Let's first look for ones that can be
1050 ;; found when looking on the line with the colon
1053 (or (c-lookup-lists '(case-label label access-label
)
1054 syntax c-hanging-colons-alist
)
1055 (c-lookup-lists '(member-init-intro inher-intro
)
1059 (c-guess-basic-syntax)
1061 c-hanging-colons-alist
)))))
1062 ;; does a newline go before the colon? Watch out for already
1063 ;; non-hung colons. However, we don't unhang them because that
1064 ;; would be a cleanup (and anti-social).
1065 (if (and (memq 'before newlines
)
1068 (skip-chars-backward ": \t")
1070 (let ((pos (- (point-max) (point))))
1072 (c-newline-and-indent)
1073 (goto-char (- (point-max) pos
))))
1074 ;; does a newline go after the colon?
1075 (if (and (memq 'after
(cdr-safe newlines
))
1077 (c-newline-and-indent))
1080 (defun c-electric-lt-gt (arg)
1081 "Insert a \"<\" or \">\" character.
1082 If the current language uses angle bracket parens (e.g. template
1083 arguments in C++), try to find out if the inserted character is a
1084 paren and give it paren syntax if appropriate.
1086 If `c-electric-flag' and `c-syntactic-indentation' are both non-nil, the
1087 line will be reindented if the inserted character is a paren or if it
1088 finishes a C++ style stream operator in C++ mode. Exceptions are when a
1089 numeric argument is supplied, or the point is inside a literal."
1092 (let ((c-echo-syntactic-information-p nil
)
1093 final-pos found-delim case-fold-search
)
1095 (self-insert-command (prefix-numeric-value arg
))
1096 (setq final-pos
(point))
1098 ;;;; 2010-01-31: There used to be code here to put a syntax-table text
1099 ;;;; property on the new < or > and its mate (if any) when they are template
1100 ;;;; parens. This is now done in an after-change function.
1102 ;; Indent the line if appropriate.
1103 (when (and c-electric-flag c-syntactic-indentation c-recognize-
<>-arglists
)
1105 (if (eq (c-last-command-char) ?
<)
1106 ;; If a <, basically see if it's got "template" before it .....
1110 (progn (c-beginning-of-current-token) (point))))
1112 (c-backward-token-2)
1113 (looking-at c-opt-
<>-sexp-key
)))
1114 ;; ..... or is a C++ << operator.
1115 (and (c-major-mode-is 'c
++-mode
)
1117 (goto-char (1- final-pos
))
1118 (c-beginning-of-current-token)
1120 (>= (match-end 0) final-pos
)))
1122 ;; It's a >. Either a C++ >> operator. ......
1123 (or (and (c-major-mode-is 'c
++-mode
)
1125 (goto-char (1- final-pos
))
1126 (c-beginning-of-current-token)
1128 (>= (match-end 0) final-pos
))
1129 ;; ...., or search back for a < which isn't already marked as an
1130 ;; opening template delimiter.
1133 ;; Narrow to avoid `c-forward-<>-arglist' below searching past
1135 (narrow-to-region (point-min) final-pos
)
1136 (goto-char final-pos
)
1140 (c-syntactic-skip-backward "^<;}" nil t
)
1141 (eq (char-before) ?
<))
1144 (looking-at "\\s\("))))
1145 (and (eq (char-after) ?
<)
1146 (not (looking-at "\\s\("))
1147 (progn (c-backward-syntactic-ws)
1148 (c-simple-skip-symbol-backward))
1149 (or (looking-at c-opt-
<>-sexp-key
)
1150 (not (looking-at c-keywords-regexp
)))))))))
1152 (goto-char final-pos
)
1154 (indent-according-to-mode)
1155 (when (and (eq (char-before) ?
>)
1156 (not executing-kbd-macro
)
1157 blink-paren-function
)
1158 ;; Currently (2014-10-19), the syntax-table text properties on < and >
1159 ;; are only applied in code called during Emacs redisplay. We thus
1160 ;; explicitly cause a redisplay so that these properties have been
1161 ;; applied when `blink-paren-function' gets called.
1163 (funcall blink-paren-function
)))))
1165 (defun c-electric-paren (arg)
1166 "Insert a parenthesis.
1168 If `c-syntactic-indentation' and `c-electric-flag' are both non-nil, the
1169 line is reindented unless a numeric ARG is supplied, or the parenthesis
1170 is inserted inside a literal.
1172 Whitespace between a function name and the parenthesis may get added or
1173 removed; see the variable `c-cleanup-list'.
1175 Also, if `c-electric-flag' and `c-auto-newline' are both non-nil, some
1176 newline cleanups are done if appropriate; see the variable `c-cleanup-list'."
1178 (let ((literal (c-save-buffer-state () (c-in-literal)))
1180 (c-echo-syntactic-information-p nil
)
1182 (self-insert-command (prefix-numeric-value arg
))
1184 (if (and (not arg
) (not literal
))
1185 (let* ( ;; We want to inhibit blinking the paren since this will
1186 ;; be most disruptive. We'll blink it ourselves
1188 (old-blink-paren blink-paren-function
)
1189 blink-paren-function
)
1190 (if (and c-syntactic-indentation c-electric-flag
)
1191 (indent-according-to-mode))
1193 ;; If we're at EOL, check for new-line clean-ups.
1194 (when (and c-electric-flag c-auto-newline
1195 (looking-at "[ \t]*\\\\?$"))
1197 ;; clean up brace-elseif-brace
1199 (and (memq 'brace-elseif-brace c-cleanup-list
)
1200 (eq (c-last-command-char) ?\
()
1203 "\\([ \t\n]\\|\\\\\n\\)*"
1205 "\\([ \t\n]\\|\\\\\n\\)+"
1207 "\\([ \t\n]\\|\\\\\n\\)*"
1211 (not (c-save-buffer-state () (c-in-literal))))
1212 (delete-region (match-beginning 0) (match-end 0))
1213 (insert-and-inherit "} else if ("))
1215 ;; clean up brace-catch-brace
1217 (and (memq 'brace-catch-brace c-cleanup-list
)
1218 (eq (c-last-command-char) ?\
()
1221 "\\([ \t\n]\\|\\\\\n\\)*"
1223 "\\([ \t\n]\\|\\\\\n\\)*"
1227 (not (c-save-buffer-state () (c-in-literal))))
1228 (delete-region (match-beginning 0) (match-end 0))
1229 (insert-and-inherit "} catch (")))
1231 ;; Check for clean-ups at function calls. These two DON'T need
1232 ;; `c-electric-flag' or `c-syntactic-indentation' set.
1233 ;; Point is currently just after the inserted paren.
1234 (let (beg (end (1- (point))))
1237 ;; space-before-funcall clean-up?
1238 ((and (memq 'space-before-funcall c-cleanup-list
)
1239 (eq (c-last-command-char) ?\
()
1242 (skip-chars-backward " \t")
1244 (and (c-save-buffer-state () (c-on-identifier))
1245 ;; Don't add a space into #define FOO()....
1246 (not (and (c-beginning-of-macro)
1247 (c-forward-over-cpp-define-id)
1248 (eq (point) beg
))))))
1250 (delete-region beg end
)
1254 ;; compact-empty-funcall clean-up?
1255 ((c-save-buffer-state ()
1256 (and (memq 'compact-empty-funcall c-cleanup-list
)
1257 (eq (c-last-command-char) ?\
))
1259 (c-safe (backward-char 2))
1260 (when (looking-at "()")
1262 (skip-chars-backward " \t")
1264 (c-on-identifier)))))
1265 (delete-region beg end
))))
1266 (and (eq last-input-event ?\
))
1267 (not executing-kbd-macro
)
1269 (funcall old-blink-paren
))))))
1271 (defun c-electric-continued-statement ()
1272 "Reindent the current line if appropriate.
1274 This function is used to reindent the line after a keyword which
1275 continues an earlier statement is typed, e.g. an \"else\" or the
1276 \"while\" in a do-while block.
1278 The line is reindented if there is nothing but whitespace before the
1279 keyword on the line, the keyword is not inserted inside a literal, and
1280 `c-electric-flag' and `c-syntactic-indentation' are both non-nil."
1281 (let (;; shut this up
1282 (c-echo-syntactic-information-p nil
))
1283 (when (c-save-buffer-state ()
1284 (and c-electric-flag
1285 c-syntactic-indentation
1286 (not (eq (c-last-command-char) ?_
))
1288 (skip-syntax-backward "w")
1291 (not (c-in-literal (c-point 'bod
)))))
1292 ;; Have to temporarily insert a space so that
1293 ;; c-guess-basic-syntax recognizes the keyword. Follow the
1294 ;; space with a nonspace to avoid messing up any whitespace
1295 ;; sensitive meddling that might be done, e.g. by
1296 ;; `c-backslash-region'.
1297 (insert-and-inherit " x")
1299 (indent-according-to-mode)
1300 (delete-char -
2)))))
1304 (declare-function subword-forward
"subword" (&optional arg
))
1305 (declare-function subword-backward
"subword" (&optional arg
))
1307 ;; "nomenclature" functions + c-scope-operator.
1308 (defun c-forward-into-nomenclature (&optional arg
)
1309 "Compatibility alias for `c-forward-subword'."
1312 (subword-forward arg
))
1313 (make-obsolete 'c-forward-into-nomenclature
'subword-forward
"23.2")
1315 (defun c-backward-into-nomenclature (&optional arg
)
1316 "Compatibility alias for `c-backward-subword'."
1319 (subword-backward arg
))
1320 (make-obsolete 'c-backward-into-nomenclature
'subword-backward
"23.2")
1322 (defun c-scope-operator ()
1323 "Insert a double colon scope operator at point.
1324 No indentation or other \"electric\" behavior is performed."
1326 (insert-and-inherit "::"))
1329 ;; Movement (etc.) by defuns.
1330 (defun c-in-function-trailer-p (&optional lim
)
1331 ;; Return non-nil if point is between the closing brace and the semicolon of
1332 ;; a brace construct which needs a semicolon, e.g. within the "variables"
1333 ;; portion of a declaration like "struct foo {...} bar ;".
1335 ;; Return the position of the main declaration. Otherwise, return nil.
1336 ;; Point is assumed to be at the top level and outside of any macro or
1339 ;; If LIM is non-nil, it is the bound on a the backward search for the
1340 ;; beginning of the declaration.
1342 ;; This function might do hidden buffer changes.
1343 (and c-opt-block-decls-with-vars-key
1345 (c-syntactic-skip-backward "^;}" lim
)
1346 (let ((eo-block (point))
1348 (and (eq (char-before) ?\
})
1349 (eq (car (c-beginning-of-decl-1 lim
)) 'previous
)
1351 ;; Look for struct or union or ... If we find one, it might
1352 ;; be the return type of a function, or the like. Exclude
1354 (c-syntactic-re-search-forward
1355 (concat "[;=\(\[{]\\|\\("
1356 c-opt-block-decls-with-vars-key
1359 (match-beginning 1) ; Is there a "struct" etc., somewhere?
1360 (not (eq (char-before) ?_
))
1361 (c-syntactic-re-search-forward "[;=\(\[{]" eo-block t t t
)
1362 (eq (char-before) ?\
{)
1365 (defun c-where-wrt-brace-construct ()
1366 ;; Determine where we are with respect to functions (or other brace
1367 ;; constructs, included in the term "function" in the rest of this comment).
1368 ;; Point is assumed to be outside any macro or literal.
1369 ;; This is used by c-\(beginning\|end\)-of-defun.
1371 ;; Return one of these symbols:
1372 ;; at-header : we're at the start of a function's header.
1373 ;; in-header : we're inside a function's header, this extending right
1374 ;; up to the brace. This bit includes any k&r declarations.
1375 ;; in-block : we're inside a function's brace block.
1376 ;; in-trailer : we're in the area between the "}" and ";" of something
1377 ;; like "struct foo {...} bar, baz;".
1378 ;; at-function-end : we're just after the closing brace (or semicolon) that
1379 ;; terminates the function.
1380 ;; outwith-function: we're not at or in any function. Being inside a
1381 ;; non-brace construct also counts as 'outwith-function'.
1383 ;; This function might do hidden buffer changes.
1386 decl-result brace-decl-p
1388 (paren-state (c-parse-state))
1389 (least-enclosing (c-least-enclosing-brace paren-state
)))
1392 ((and least-enclosing
1393 (eq (char-after least-enclosing
) ?\
{))
1395 ((c-in-function-trailer-p)
1397 ((and (not least-enclosing
)
1399 (consp (car paren-state
))
1400 (eq start
(cdar paren-state
)))
1403 ;; Find the start of the current declaration. NOTE: If we're in the
1404 ;; variables after a "struct/eval" type block, we don't get to the
1405 ;; real declaration here - we detect and correct for this later.
1407 ;;If we're in the parameters' parens, move back out of them.
1408 (if least-enclosing
(goto-char least-enclosing
))
1409 ;; Kluge so that c-beginning-of-decl-1 won't go back if we're already
1410 ;; at a declaration.
1411 (if (or (and (eolp) (not (eobp))) ; EOL is matched by "\\s>"
1413 "\\([;#]\\|\\'\\|\\s(\\|\\s)\\|\\s\"\\|\\s\\\\|\\s$\\|\\s<\\|\\s>\\|\\s!\\)")))
1415 (setq kluge-start
(point))
1417 (car (c-beginning-of-decl-1
1418 ;; NOTE: If we're in a K&R region, this might be the start
1419 ;; of a parameter declaration, not the actual function.
1420 (and least-enclosing
; LIMIT for c-b-of-decl-1
1421 (c-safe-position least-enclosing paren-state
)))))
1423 ;; Has the declaration we've gone back to got braces?
1426 (and (c-syntactic-re-search-forward "[;{]" nil t t
)
1427 (or (eq (char-before) ?\
{)
1428 (and c-recognize-knr-p
1429 ;; Might have stopped on the
1430 ;; ';' in a K&R argdecl. In
1431 ;; that case the declaration
1432 ;; should contain a block.
1433 (c-in-knr-argdecl))))))
1436 ((= (point) kluge-start
) ; might be BOB or unbalanced parens.
1438 ((eq decl-result
'same
)
1440 (if (eq (point) start
)
1444 ((eq decl-result
'previous
)
1445 (if (and (not brace-decl-p
)
1446 (c-in-function-trailer-p))
1450 "c-where-wrt-brace-construct: c-beginning-of-decl-1 returned %s"
1453 (defun c-backward-to-nth-BOF-{ (n where
)
1454 ;; Skip to the opening brace of the Nth function before point. If
1455 ;; point is inside a function, this counts as the first. Point must be
1456 ;; outside any comment/string or macro.
1458 ;; N must be strictly positive.
1459 ;; WHERE describes the position of point, one of the symbols `at-header',
1460 ;; `in-header', `in-block', `in-trailer', `at-function-end',
1461 ;; `outwith-function' as returned by c-where-wrt-brace-construct.
1463 ;; If we run out of functions, leave point at BOB. Return zero on success,
1464 ;; otherwise the number of {s still to go.
1466 ;; This function may do hidden buffer changes
1468 ;; What we do to go back the first defun depends on where we start.
1470 ((eq where
'in-block
)
1471 (goto-char (c-least-enclosing-brace (c-parse-state)))
1473 ((eq where
'in-header
)
1474 (c-syntactic-re-search-forward "{")
1477 ((memq where
'(at-header outwith-function at-function-end in-trailer
))
1478 (c-syntactic-skip-backward "^}")
1479 (when (eq (char-before) ?\
})
1482 (t (error "Unknown `where' %s in c-backward-to-nth-EOF-{" where
)))
1484 ;; Each time round the loop, go back to a "{" at the outermost level.
1485 (while (and (> n
0) (not (bobp)))
1486 (c-parse-state) ; This call speeds up the following one
1487 ; by a factor of ~6. Hmmm. 2006/4/5.
1488 (c-syntactic-skip-backward "^}")
1489 (when (eq (char-before) ?\
})
1494 (defun c-narrow-to-most-enclosing-decl-block (&optional inclusive
)
1495 ;; If we are inside a decl-block (in the sense of c-looking-at-decl-block),
1496 ;; i.e. something like namespace{} or extern{}, narrow to the insides of
1497 ;; that block (NOT including the enclosing braces) if INCLUSIVE is nil,
1498 ;; otherwise include the braces. If the closing brace is missing,
1499 ;; (point-max) is used instead.
1500 (let ((paren-state (c-parse-state))
1502 (setq encl-decl
(and paren-state
(c-most-enclosing-decl-block paren-state
)))
1507 (progn (goto-char encl-decl
)
1508 (c-beginning-of-decl-1)
1512 (goto-char encl-decl
)
1513 (or (c-safe (forward-list)
1519 (defun c-widen-to-enclosing-decl-scope (paren-state orig-point-min orig-point-max
)
1520 ;; Narrow the buffer to the innermost declaration scope (e.g. a class, a
1521 ;; namespace or the "whole buffer") recorded in PAREN-STATE, the bounding
1522 ;; braces NOT being included in the resulting region. On no account may the
1523 ;; final region exceed that bounded by ORIG-POINT-MIN, ORIG-POINT-MAX.
1524 ;; PAREN-STATE is a list of buffer positions in the style of
1525 ;; (c-parse-state), one of which will be that of the desired opening brace,
1528 ;; Return the position of the enclosing opening brace, or nil
1529 (let (encl-decl) ; putative position of decl-scope's opening brace.
1531 (narrow-to-region orig-point-min orig-point-max
)
1532 (setq encl-decl
(and paren-state
1533 (c-most-enclosing-decl-block paren-state
))))
1537 (narrow-to-region (1+ encl-decl
)
1539 (goto-char encl-decl
)
1540 (or (c-safe (forward-list)
1544 (narrow-to-region orig-point-min orig-point-max
)
1548 (defmacro c-while-widening-to-decl-block
(condition)
1549 ;; Repeatedly evaluate CONDITION until it returns nil. After each
1550 ;; evaluation, if `c-defun-tactic' is set appropriately, widen to innards
1551 ;; of the next enclosing declaration block (e.g. namespace, class), or the
1552 ;; buffer's original restriction.
1554 ;; This is a very special purpose macro, which assumes the existence of
1555 ;; several variables. It is for use only in c-beginning-of-defun and
1559 (eq c-defun-tactic
'go-outward
)
1561 (setq paren-state
(c-whack-state-after lim paren-state
))
1562 (setq lim
(c-widen-to-enclosing-decl-scope
1563 paren-state orig-point-min orig-point-max
))
1564 (setq where
'in-block
))))
1566 (defun c-beginning-of-defun (&optional arg
)
1567 "Move backward to the beginning of a defun.
1568 Every top level declaration that contains a brace paren block is
1569 considered to be a defun.
1571 With a positive argument, move backward that many defuns. A negative
1572 argument -N means move forward to the Nth following beginning. Return
1573 t unless search stops due to beginning or end of buffer.
1575 Unlike the built-in `beginning-of-defun' this tries to be smarter
1576 about finding the char with open-parenthesis syntax that starts the
1580 (or arg
(setq arg
1))
1582 (or (not (eq this-command
'c-beginning-of-defun
))
1583 (eq last-command
'c-beginning-of-defun
)
1584 (and transient-mark-mode mark-active
)
1587 (c-save-buffer-state
1588 (beginning-of-defun-function end-of-defun-function
1590 (paren-state (copy-tree (c-parse-state))) ; This must not share list
1591 ; structure with other users of c-state-cache.
1592 (orig-point-min (point-min)) (orig-point-max (point-max))
1593 lim
; Position of { which has been widened to.
1594 where pos case-fold-search
)
1597 (if (eq c-defun-tactic
'go-outward
)
1598 (setq lim
(c-widen-to-enclosing-decl-scope ; e.g. class, namespace.
1599 paren-state orig-point-min orig-point-max
)))
1601 ;; Move back out of any macro/comment/string we happen to be in.
1602 (c-beginning-of-macro)
1603 (setq pos
(c-literal-limits))
1604 (if pos
(goto-char (car pos
)))
1606 (setq where
(c-where-wrt-brace-construct))
1609 ;; Move forward to the closing brace of a function.
1611 (if (memq where
'(at-function-end outwith-function
))
1612 (setq arg
(1+ arg
)))
1614 (c-while-widening-to-decl-block
1615 (< (setq arg
(- (c-forward-to-nth-EOF-} (- arg
) where
))) 0)))
1616 ;; Move forward to the next opening brace....
1617 (when (and (= arg
0)
1619 (c-while-widening-to-decl-block
1620 (not (c-syntactic-re-search-forward "{" nil
'eob
)))
1621 (eq (char-before) ?
{)))
1623 ;; ... and backward to the function header.
1624 (c-beginning-of-decl-1)
1627 ;; Move backward to the opening brace of a function, making successively
1628 ;; larger portions of the buffer visible as necessary.
1630 (c-while-widening-to-decl-block
1631 (> (setq arg
(c-backward-to-nth-BOF-{ arg where
)) 0)))
1634 ;; Go backward to this function's header.
1635 (c-beginning-of-decl-1)
1638 ;; We're now there, modulo comments and whitespace.
1639 ;; Try to be line oriented; position point at the closest
1640 ;; preceding boi that isn't inside a comment, but if we hit
1641 ;; the previous declaration then we use the current point
1643 (while (and (/= (point) (c-point 'boi
))
1644 (c-backward-single-comment)))
1645 (if (/= (point) (c-point 'boi
))
1648 (c-keep-region-active)
1651 (defun c-forward-to-nth-EOF-} (n where
)
1652 ;; Skip to the closing brace of the Nth function after point. If
1653 ;; point is inside a function, this counts as the first. Point must be
1654 ;; outside any comment/string or macro.
1656 ;; N must be strictly positive.
1657 ;; WHERE describes the position of point, one of the symbols `at-header',
1658 ;; `in-header', `in-block', `in-trailer', `at-function-end',
1659 ;; `outwith-function' as returned by c-where-wrt-brace-construct.
1661 ;; If we run out of functions, leave point at EOB. Return zero on success,
1662 ;; otherwise the number of }s still to go.
1664 ;; This function may do hidden buffer changes.
1667 ;; What we do to go forward over the first defun depends on where we
1668 ;; start. We go to the closing brace of that defun, even when we go
1669 ;; backwards to it (in a "struct foo {...} bar ;").
1671 ((eq where
'in-block
)
1672 (goto-char (c-least-enclosing-brace (c-parse-state)))
1675 ((eq where
'in-trailer
)
1676 (c-syntactic-skip-backward "^}")
1678 ((memq where
'(at-function-end outwith-function at-header in-header
))
1679 (when (c-syntactic-re-search-forward "{" nil
'eob
)
1683 (t (error "c-forward-to-nth-EOF-}: `where' is %s" where
)))
1685 ;; Each time round the loop, go forward to a "}" at the outermost level.
1686 (while (and (> n
0) (not (eobp)))
1687 ;(c-parse-state) ; This call speeds up the following one by a factor
1688 ; of ~6. Hmmm. 2006/4/5.
1689 (when (c-syntactic-re-search-forward "{" nil
'eob
)
1695 (defun c-end-of-defun (&optional arg
)
1696 "Move forward to the end of a top level declaration.
1697 With argument, do it that many times. Negative argument -N means move
1698 back to Nth preceding end. Returns t unless search stops due to
1699 beginning or end of buffer.
1701 An end of a defun occurs right after the close-parenthesis that matches
1702 the open-parenthesis that starts a defun; see `beginning-of-defun'."
1704 (or arg
(setq arg
1))
1706 (or (not (eq this-command
'c-end-of-defun
))
1707 (eq last-command
'c-end-of-defun
)
1708 (and transient-mark-mode mark-active
)
1711 (c-save-buffer-state
1712 (beginning-of-defun-function end-of-defun-function
1714 (paren-state (copy-tree (c-parse-state))) ; This must not share list
1715 ; structure with other users of c-state-cache.
1716 (orig-point-min (point-min)) (orig-point-max (point-max))
1718 where pos case-fold-search
)
1721 (if (eq c-defun-tactic
'go-outward
)
1722 (setq lim
(c-widen-to-enclosing-decl-scope ; e.g. class, namespace
1723 paren-state orig-point-min orig-point-max
)))
1725 ;; Move back out of any macro/comment/string we happen to be in.
1726 (c-beginning-of-macro)
1727 (setq pos
(c-literal-limits))
1728 (if pos
(goto-char (car pos
)))
1730 (setq where
(c-where-wrt-brace-construct))
1733 ;; Move backwards to the } of a function
1735 (if (memq where
'(at-header outwith-function
))
1736 (setq arg
(1+ arg
)))
1738 (c-while-widening-to-decl-block
1739 (< (setq arg
(- (c-backward-to-nth-BOF-{ (- arg
) where
))) 0)))
1741 (c-while-widening-to-decl-block
1742 (progn (c-syntactic-skip-backward "^}")
1743 (not (eq (char-before) ?
}))))))
1745 ;; Move forward to the } of a function
1747 (c-while-widening-to-decl-block
1748 (> (setq arg
(c-forward-to-nth-EOF-} arg where
)) 0))))
1750 ;; Do we need to move forward from the brace to the semicolon?
1752 (if (c-in-function-trailer-p) ; after "}" of struct/enum, etc.
1753 (c-syntactic-re-search-forward ";"))
1756 ;; We're there now, modulo comments and whitespace.
1757 ;; Try to be line oriented; position point after the next
1758 ;; newline that isn't inside a comment, but if we hit the
1759 ;; next declaration then we use the current point instead.
1760 (while (and (not (bolp))
1761 (not (looking-at "\\s *$"))
1762 (c-forward-single-comment)))
1764 ((looking-at "\\s *$")
1769 (c-keep-region-active)
1772 (defun c-defun-name ()
1773 "Return the name of the current defun, or NIL if there isn't one.
1774 \"Defun\" here means a function, or other top level construct
1775 with a brace block."
1777 (c-save-buffer-state
1778 (beginning-of-defun-function end-of-defun-function
1779 where pos name-end case-fold-search
)
1784 ;; Move back out of any macro/comment/string we happen to be in.
1785 (c-beginning-of-macro)
1786 (setq pos
(c-literal-limits))
1787 (if pos
(goto-char (car pos
)))
1789 (setq where
(c-where-wrt-brace-construct))
1791 ;; Move to the beginning of the current defun, if any, if we're not
1793 (if (eq where
'outwith-function
)
1795 (unless (eq where
'at-header
)
1796 (c-backward-to-nth-BOF-{ 1 where
)
1797 (c-beginning-of-decl-1))
1799 ;; Pick out the defun name, according to the type of defun.
1801 ;; struct, union, enum, or similar:
1802 ((and (looking-at c-type-prefix-key
)
1803 (progn (c-forward-token-2 2) ; over "struct foo "
1804 (or (eq (char-after) ?\
{)
1805 (looking-at c-symbol-key
)))) ; "struct foo bar ..."
1806 (save-match-data (c-forward-token-2))
1807 (when (eq (char-after) ?\
{)
1808 (c-backward-token-2)
1809 (looking-at c-symbol-key
))
1810 (match-string-no-properties 0))
1812 ((looking-at "DEFUN\\_>")
1813 ;; DEFUN ("file-name-directory", Ffile_name_directory, Sfile_name_directory, ...) ==> Ffile_name_directory
1814 ;; DEFUN(POSIX::STREAM-LOCK, stream lockp &key BLOCK SHARED START LENGTH) ==> POSIX::STREAM-LOCK
1816 (c-forward-syntactic-ws)
1817 (when (eq (char-after) ?
\")
1819 (c-forward-token-2)) ; over the comma and following WS.
1820 (buffer-substring-no-properties
1824 (when (looking-at ":") ; CLISP: DEFUN(PACKAGE:LISP-SYMBOL,...)
1825 (skip-chars-forward "^,"))
1826 (c-backward-syntactic-ws)
1829 ((looking-at "DEF[a-zA-Z0-9_]* *( *\\([^, ]*\\) *,")
1830 ;; DEFCHECKER(sysconf_arg,prefix=_SC,default=, ...) ==> sysconf_arg
1831 ;; DEFFLAGSET(syslog_opt_flags,LOG_PID ...) ==> syslog_opt_flags
1832 (match-string-no-properties 1))
1835 ((assq 'objc-method-intro
(c-guess-basic-syntax))
1836 (let ((bound (save-excursion (c-end-of-statement) (point)))
1837 (kw-re (concat "\\(?:" c-symbol-key
"\\)?:"))
1839 (when (c-syntactic-re-search-forward c-symbol-key bound t t t
)
1840 (push (match-string-no-properties 0) stretches
)
1841 (while (c-syntactic-re-search-forward kw-re bound t t t
)
1842 (push (match-string-no-properties 0) stretches
)))
1843 (apply 'concat
(nreverse stretches
))))
1846 ;; Normal function or initializer.
1847 (when (c-syntactic-re-search-forward "[{(]" nil t
)
1849 (c-backward-syntactic-ws)
1850 (when (eq (char-before) ?\
=) ; struct foo bar = {0, 0} ;
1851 (c-backward-token-2)
1852 (c-backward-syntactic-ws))
1853 (setq name-end
(point))
1854 (c-backward-token-2)
1855 (buffer-substring-no-properties (point) name-end
)))))))))
1857 (defun c-declaration-limits (near)
1858 ;; Return a cons of the beginning and end positions of the current
1859 ;; top level declaration or macro. If point is not inside any then
1860 ;; nil is returned, unless NEAR is non-nil in which case the closest
1861 ;; following one is chosen instead (if there is any). The end
1862 ;; position is at the next line, providing there is one before the
1865 ;; This function might do hidden buffer changes.
1868 (when (eq c-defun-tactic
'go-outward
)
1869 (c-narrow-to-most-enclosing-decl-block t
) ; e.g. class, namespace
1870 (or (save-restriction
1871 (c-narrow-to-most-enclosing-decl-block nil
)
1873 ;; Note: Some code duplication in `c-beginning-of-defun' and
1874 ;; `c-end-of-defun'.
1876 (let ((start (point))
1877 (paren-state (c-parse-state))
1880 (goto-char (c-least-enclosing-brace paren-state
))
1881 ;; If we moved to the outermost enclosing paren
1882 ;; then we can use c-safe-position to set the
1883 ;; limit. Can't do that otherwise since the
1884 ;; earlier paren pair on paren-state might very
1885 ;; well be part of the declaration we should go
1887 (setq lim
(c-safe-position (point) paren-state
))
1889 ;; At top level. Make sure we aren't inside a literal.
1890 (setq pos
(c-literal-limits
1891 (c-safe-position (point) paren-state
)))
1892 (if pos
(goto-char (car pos
))))
1894 (when (c-beginning-of-macro)
1903 (when (or (eq (car (c-beginning-of-decl-1 lim
)) 'previous
)
1905 ;; We moved back over the previous defun. Skip to the next
1906 ;; one. Not using c-forward-syntactic-ws here since we
1907 ;; should not skip a macro. We can also be directly after
1908 ;; the block in a `c-opt-block-decls-with-vars-key'
1909 ;; declaration, but then we won't move significantly far
1912 (c-forward-comments)
1914 (when (and near
(c-beginning-of-macro))
1922 (if (eobp) (throw 'exit nil
))
1924 ;; Check if `c-beginning-of-decl-1' put us after the block in a
1925 ;; declaration that doesn't end there. We're searching back and
1926 ;; forth over the block here, which can be expensive.
1928 (if (and c-opt-block-decls-with-vars-key
1930 (c-backward-syntactic-ws)
1931 (eq (char-before) ?
}))
1932 (eq (car (c-beginning-of-decl-1))
1936 (and (> (point) pos
)
1937 (setq end-pos
(point)))))
1941 (if (and (not near
) (> (point) start
))
1944 ;; Try to be line oriented; position the limits at the
1945 ;; closest preceding boi, and after the next newline, that
1946 ;; isn't inside a comment, but if we hit a neighboring
1947 ;; declaration then we instead use the exact declaration
1948 ;; limit in that direction.
1951 (while (and (/= (point) (c-point 'boi
))
1952 (c-backward-single-comment)))
1953 (if (/= (point) (c-point 'boi
))
1961 (while (and (not (bolp))
1962 (not (looking-at "\\s *$"))
1963 (c-forward-single-comment)))
1966 ((looking-at "\\s *$")
1972 (goto-char (point-min))
1973 (c-forward-decl-or-cast-1 -
1 nil nil
)
1974 (eq (char-after) ?\
{)
1975 (cons (point-min) (point-max))))))))
1977 (defun c-mark-function ()
1978 "Put mark at end of the current top-level declaration or macro, point at beginning.
1979 If point is not inside any then the closest following one is
1980 chosen. Each successive call of this command extends the marked
1981 region by one function.
1983 A mark is left where the command started, unless the region is already active
1984 \(in Transient Mark mode).
1986 As opposed to \\[c-beginning-of-defun] and \\[c-end-of-defun], this
1987 function does not require the declaration to contain a brace block."
1990 (let (decl-limits case-fold-search
)
1991 (c-save-buffer-state nil
1992 ;; We try to be line oriented, unless there are several
1993 ;; declarations on the same line.
1994 (if (looking-at c-syntactic-eol
)
1995 (c-backward-token-2 1 nil
(c-point 'bol
)))
1996 (setq decl-limits
(c-declaration-limits t
)))
1998 (if (not decl-limits
)
1999 (error "Cannot find any declaration")
2000 (let* ((extend-region-p
2001 (and (eq this-command
'c-mark-function
)
2002 (eq last-command
'c-mark-function
)))
2003 (push-mark-p (and (eq this-command
'c-mark-function
)
2004 (not extend-region-p
)
2005 (not (and transient-mark-mode mark-active
)))))
2006 (if push-mark-p
(push-mark (point)))
2009 (exchange-point-and-mark)
2010 (setq decl-limits
(c-declaration-limits t
))
2011 (when (not decl-limits
)
2012 (exchange-point-and-mark)
2013 (error "Cannot find any declaration"))
2014 (goto-char (cdr decl-limits
))
2015 (exchange-point-and-mark))
2016 (goto-char (car decl-limits
))
2017 (push-mark (cdr decl-limits
) nil t
))))))
2019 (defun c-cpp-define-name ()
2020 "Return the name of the current CPP macro, or NIL if we're not in one."
2022 (let (case-fold-search)
2024 (and c-opt-cpp-macro-define-start
2025 (c-beginning-of-macro)
2026 (looking-at c-opt-cpp-macro-define-start
)
2027 (match-string-no-properties 1)))))
2030 ;; Movement by statements.
2031 (defun c-in-comment-line-prefix-p ()
2032 ;; Point is within a comment. Is it also within a comment-prefix?
2033 ;; Space at BOL which precedes a comment-prefix counts as part of it.
2035 ;; This function might do hidden buffer changes.
2036 (let ((here (point)))
2039 (skip-chars-forward " \t")
2040 (and (looking-at c-current-comment-prefix
)
2041 (/= (match-beginning 0) (match-end 0))
2042 (< here
(match-end 0))))))
2044 (defun c-narrow-to-comment-innards (range)
2045 ;; Narrow to the "inside" of the comment (block) defined by range, as
2048 ;; A c-style block comment has its opening "/*" and its closing "*/" (if
2049 ;; present) removed. A c++-style line comment retains its opening "//" but
2050 ;; has any final NL removed. If POINT is currently outwith these innards,
2051 ;; move it to the appropriate boundary.
2053 ;; This narrowing simplifies the sentence movement functions, since it
2054 ;; eliminates awkward things at the boundaries of the comment (block).
2056 ;; This function might do hidden buffer changes.
2057 (let* ((lit-type (c-literal-type range
))
2058 (beg (if (eq lit-type
'c
) (+ (car range
) 2) (car range
)))
2059 (end (if (eq lit-type
'c
)
2060 (if (and (eq (char-before (cdr range
)) ?
/)
2061 (eq (char-before (1- (cdr range
))) ?
*))
2064 (if (eq (cdr range
) (point-max))
2066 (- (cdr range
) 1)))))
2068 (goto-char end
)) ; This would be done automatically by ...
2070 (goto-char beg
)) ; ... narrow-to-region but is not documented.
2071 (narrow-to-region beg end
)))
2073 (defun c-beginning-of-sentence-in-comment (range)
2074 ;; Move backwards to the "beginning of a sentence" within the comment
2075 ;; defined by RANGE, a cons of its starting and ending positions. If we
2076 ;; find a BOS, return NIL. Otherwise, move point to just before the start
2077 ;; of the comment and return T.
2079 ;; The BOS is either text which follows a regexp match of sentence-end,
2080 ;; or text which is a beginning of "paragraph".
2081 ;; Comment-prefixes are treated like WS when calculating BOSes or BOPs.
2083 ;; This code was adapted from GNU Emacs's forward-sentence in paragraphs.el.
2084 ;; It is not a general function, but is intended only for calling from
2085 ;; c-move-over-sentence. Not all preconditions have been explicitly stated.
2087 ;; This function might do hidden buffer changes.
2089 (let ((start-point (point)))
2091 (c-narrow-to-comment-innards range
) ; This may move point back.
2092 (let* ((here (point))
2094 (here-filler ; matches WS and comment-prefixes at point.
2095 (concat "\\=\\(^[ \t]*\\(" c-current-comment-prefix
"\\)"
2096 "\\|[ \t\n\r\f]\\)*"))
2097 (prefix-at-bol-here ; matches WS and prefix at BOL, just before point
2098 (concat "^[ \t]*\\(" c-current-comment-prefix
"\\)[ \t\n\r\f]*\\="))
2099 ;; First, find the previous paragraph start, if any.
2100 (par-beg ; point where non-WS/non-prefix text of paragraph starts.
2102 (forward-paragraph -
1) ; uses cc-mode values of
2103 ; paragraph-\(start\|separate\)
2104 (if (> (re-search-forward here-filler nil t
) here
)
2106 (when (>= (point) here
)
2107 (forward-paragraph -
2)
2108 (if (> (re-search-forward here-filler nil t
) here
)
2112 ;; Now seek successively earlier sentence ends between PAR-BEG and
2113 ;; HERE, until the "start of sentence" following it is earlier than
2114 ;; HERE, or we hit PAR-BEG. Beware of comment prefixes!
2115 (while (and (re-search-backward (c-sentence-end) par-beg
'limit
)
2117 (goto-char (match-end 0)) ; tentative beginning of sentence
2118 (or (>= (point) here
)
2119 (and (not (bolp)) ; Found a non-blank comment-prefix?
2121 (if (re-search-backward prefix-at-bol-here nil t
)
2122 (/= (match-beginning 1) (match-end 1)))))
2123 (progn ; Skip the crud to find a real b-o-s.
2124 (if (c-in-comment-line-prefix-p)
2125 (beginning-of-line))
2126 (re-search-forward here-filler
) ; always succeeds.
2127 (>= (point) here
))))
2129 (re-search-forward here-filler
)))
2131 (if (< (point) start-point
)
2133 (goto-char (car range
))
2136 (defun c-end-of-sentence-in-comment (range)
2137 ;; Move forward to the "end of a sentence" within the comment defined by
2138 ;; RANGE, a cons of its starting and ending positions (enclosing the opening
2139 ;; comment delimiter and the terminating */ or newline). If we find an EOS,
2140 ;; return NIL. Otherwise, move point to just after the end of the comment
2143 ;; The EOS is just after the non-WS part of the next match of the regexp
2144 ;; sentence-end. Typically, this is just after one of [.!?]. If there is
2145 ;; no sentence-end match following point, any WS before the end of the
2146 ;; comment will count as EOS, providing we're not already in it.
2148 ;; This code was adapted from GNU Emacs's forward-sentence in paragraphs.el.
2149 ;; It is not a general function, but is intended only for calling from
2150 ;; c-move-over-sentence.
2152 ;; This function might do hidden buffer changes.
2154 (let ((start-point (point))
2155 ;; (lit-type (c-literal-type range)) ; Commented out, 2005/11/23, ACM
2158 (c-narrow-to-comment-innards range
) ; This might move point forwards.
2159 (let* ((here (point))
2160 (par-end ; EOL position of last text in current/next paragraph.
2162 ;; The cc-mode values of paragraph-\(start\|separate\), set
2163 ;; in c-setup-paragraph-variables, are used in the
2165 (forward-paragraph 1)
2166 (if (eq (preceding-char) ?
\n) (forward-char -
1))
2167 (when (<= (point) here
) ; can happen, e.g., when HERE is at EOL.
2169 (forward-paragraph 2)
2170 (if (eq (preceding-char) ?
\n) (forward-char -
1)))
2175 (concat "^[ \t]*\\(" c-current-comment-prefix
"\\)\\=")))
2176 ;; Go forward one "comment-prefix which looks like sentence-end"
2177 ;; each time round the following:
2178 (while (and (re-search-forward (c-sentence-end) par-end
'limit
)
2181 (skip-chars-backward " \t\n")
2182 (or (and (not (bolp))
2183 (re-search-backward prefix-at-bol-here nil t
)
2184 (/= (match-beginning 1) (match-end 1)))
2185 (<= (point) here
))))
2188 ;; Take special action if we're up against the end of a comment (of
2189 ;; either sort): Leave point just after the last non-ws text.
2190 (if (eq (point) (point-max))
2191 (while (or (/= (skip-chars-backward " \t\n") 0)
2192 (and (re-search-backward prefix-at-bol-here nil t
)
2193 (/= (match-beginning 1) (match-end 1))))))))
2195 (if (> (point) start-point
)
2197 (goto-char (cdr range
))
2200 (defun c-beginning-of-sentence-in-string (range)
2201 ;; Move backwards to the "beginning of a sentence" within the string defined
2202 ;; by RANGE, a cons of its starting and ending positions (enclosing the
2203 ;; string quotes). If we find a BOS, return NIL. Otherwise, move point to
2204 ;; just before the start of the string and return T.
2206 ;; The BOS is either the text which follows a regexp match of sentence-end
2207 ;; or text which is a beginning of "paragraph". For the purposes of
2208 ;; determining paragraph boundaries, escaped newlines are treated as
2209 ;; ordinary newlines.
2211 ;; This code was adapted from GNU Emacs's forward-sentence in paragraphs.el.
2212 ;; It is not a general function, but is intended only for calling from
2213 ;; c-move-over-sentence.
2215 ;; This function might do hidden buffer changes.
2217 (let* ((here (point)) last
2218 (end (1- (cdr range
)))
2219 (here-filler ; matches WS and escaped newlines at point.
2220 "\\=\\([ \t\n\r\f]\\|\\\\[\n\r]\\)*")
2221 ;; Enhance paragraph-start and paragraph-separate also to recognize
2222 ;; blank lines terminated by escaped EOLs. IT MAY WELL BE that
2223 ;; these values should be customizable user options, or something.
2224 (paragraph-start c-string-par-start
)
2225 (paragraph-separate c-string-par-separate
)
2227 (par-beg ; beginning of current (or previous) paragraph.
2230 (narrow-to-region (1+ (car range
)) end
)
2231 (forward-paragraph -
1) ; uses above values of
2232 ; paragraph-\(start\|separate\)
2233 (if (> (re-search-forward here-filler nil t
) here
)
2235 (when (>= (point) here
)
2236 (forward-paragraph -
2)
2237 (if (> (re-search-forward here-filler nil t
) here
)
2240 ;; Now see if we can find a sentence end after PAR-BEG.
2241 (while (and (re-search-backward c-sentence-end-with-esc-eol par-beg
'limit
)
2243 (goto-char (match-end 0))
2247 here-filler end t
) ; always succeeds. Use end rather
2248 ; than here, in case point starts
2249 ; beyond the closing quote.
2250 (>= (point) here
))))
2252 (re-search-forward here-filler here t
)
2253 (if (< (point) here
)
2255 (goto-char (car range
))
2258 (defun c-end-of-sentence-in-string (range)
2259 ;; Move forward to the "end of a sentence" within the string defined by
2260 ;; RANGE, a cons of its starting and ending positions. If we find an EOS,
2261 ;; return NIL. Otherwise, move point to just after the end of the string
2264 ;; The EOS is just after the non-WS part of the next match of the regexp
2265 ;; sentence-end. Typically, this is just after one of [.!?]. If there is
2266 ;; no sentence-end match following point, any WS before the end of the
2267 ;; string will count as EOS, providing we're not already in it.
2269 ;; This code was adapted from GNU Emacs's forward-sentence in paragraphs.el.
2270 ;; It is not a general function, but is intended only for calling from
2271 ;; c-move-over-sentence.
2273 ;; This function might do hidden buffer changes.
2275 (let* ((here (point))
2277 ;; Enhance paragraph-start and paragraph-separate to recognize
2278 ;; blank lines terminated by escaped EOLs.
2279 (paragraph-start c-string-par-start
)
2280 (paragraph-separate c-string-par-separate
)
2282 (par-end ; EOL position of last text in current/next paragraph.
2285 (narrow-to-region (car range
) (1- (cdr range
)))
2286 ;; The above values of paragraph-\(start\|separate\) are used
2287 ;; in the following.
2288 (forward-paragraph 1)
2290 ;; (re-search-backward filler-here nil t) would find an empty
2291 ;; string. Therefore we simulate it by the following:
2292 (while (or (/= (skip-chars-backward " \t\n\r\f") 0)
2293 (re-search-backward "\\\\\\($\\)\\=" nil t
)))
2294 (unless (> (point) here
)
2296 (forward-paragraph 1)
2297 (while (or (/= (skip-chars-backward " \t\n\r\f") 0)
2298 (re-search-backward "\\\\\\($\\)\\=" nil t
))))
2300 ;; Try to go forward a sentence.
2301 (when (re-search-forward c-sentence-end-with-esc-eol par-end
'limit
)
2303 (while (or (/= (skip-chars-backward " \t\n") 0)
2304 (re-search-backward "\\\\\\($\\)\\=" nil t
))))
2305 ;; Did we move a sentence, or did we hit the end of the string?
2306 (if (> (point) here
)
2308 (goto-char (cdr range
))
2311 (defun c-ascertain-preceding-literal ()
2312 ;; Point is not in a literal (i.e. comment or string (include AWK regexp)).
2313 ;; If a literal is the next thing (aside from whitespace) to be found before
2314 ;; point, return a cons of its start.end positions (enclosing the
2315 ;; delimiters). Otherwise return NIL.
2317 ;; This function might do hidden buffer changes.
2319 (c-collect-line-comments
2320 (let ((here (point))
2322 (if (c-backward-single-comment)
2323 (cons (point) (progn (c-forward-single-comment) (point)))
2325 ;; to prevent `looking-at' seeing a " at point.
2326 (narrow-to-region (point-min) here
)
2329 ;; An EOL can act as an "open string" terminator in AWK.
2330 (looking-at c-ws
*-string-limit-regexp
)
2332 (progn (backward-char)
2333 (looking-at c-string-limit-regexp
))))
2334 (goto-char (match-end 0)) ; just after the string terminator.
2336 (c-safe (c-backward-sexp 1) ; move back over the string.
2337 (cons (point) pos
)))))))))
2339 (defun c-ascertain-following-literal ()
2340 ;; Point is not in a literal (i.e. comment or string (include AWK regexp)).
2341 ;; If a literal is the next thing (aside from whitespace) following point,
2342 ;; return a cons of its start.end positions (enclosing the delimiters).
2343 ;; Otherwise return NIL.
2345 ;; This function might do hidden buffer changes.
2347 (c-collect-line-comments
2350 (if (looking-at c-string-limit-regexp
) ; string-delimiter.
2351 (cons (point) (or (c-safe (progn (c-forward-sexp 1) (point)))
2354 (if (c-forward-single-comment)
2355 (cons pos
(point))))))))
2357 (defun c-after-statement-terminator-p () ; Should we pass in LIM here?
2358 ;; Does point immediately follow a statement "terminator"? A virtual
2359 ;; semicolon is regarded here as such. So is an opening brace ;-)
2361 ;; This function might do hidden buffer changes.
2364 (and (looking-at "[;{}]")
2365 (not (and c-special-brace-lists
; Pike special brace lists.
2366 (eq (char-after) ?
{)
2367 (c-looking-at-special-brace-list)))))
2369 ;; The following (for macros) is not strict about exactly where we are
2370 ;; wrt white space at the end of the macro. Doesn't seem to matter too
2371 ;; much. ACM 2004/3/29.
2374 (if (c-beginning-of-macro)
2375 (setq eom
(progn (c-end-of-macro)
2379 (c-forward-comments)
2380 (>= (point) eom
))))))
2382 (defun c-back-over-illiterals (macro-start)
2383 ;; Move backwards over code which isn't a literal (i.e. comment or string),
2384 ;; stopping before reaching BOB or a literal or the boundary of a
2385 ;; preprocessor statement or the "beginning of a statement". MACRO-START is
2386 ;; the position of the '#' beginning the current preprocessor directive, or
2387 ;; NIL if we're not in such.
2389 ;; Return a cons (A.B), where
2390 ;; A is NIL if we moved back to a BOS (and know it), T otherwise (we
2391 ;; didn't move, or we hit a literal, or we're not sure about BOS).
2392 ;; B is MACRO-BOUNDARY if we are about to cross the boundary out of or
2393 ;; into a macro, otherwise LITERAL if we've hit a literal, otherwise NIL
2395 ;; The total collection of returned values is as follows:
2396 ;; (nil . nil): Found a BOS whilst remaining inside the illiterals.
2397 ;; (t . literal): No BOS found: only a comment/string. We _might_ be at
2398 ;; a BOS - the caller must check this.
2399 ;; (nil . macro-boundary): only happens with non-nil macro-start. We've
2400 ;; moved and reached the opening # of the macro.
2401 ;; (t . macro-boundary): Every other circumstance in which we're at a
2402 ;; macro-boundary. We might be at a BOS.
2404 ;; Point is left either at the beginning-of-statement, or at the last non-ws
2405 ;; code before encountering the literal/BOB or macro-boundary.
2407 ;; Note that this function moves within either preprocessor commands
2408 ;; (macros) or normal code, but will not cross a boundary between the two,
2409 ;; or between two distinct preprocessor commands.
2411 ;; Stop before `{' and after `;', `{', `}' and `};' when not followed by `}'
2412 ;; or `)', but on the other side of the syntactic ws. Move by sexps and
2413 ;; move into parens. Also stop before `#' when it's at boi on a line.
2415 ;; This function might do hidden buffer changes.
2417 (let ((here (point))
2418 last
) ; marks the position of non-ws code, what'll be BOS if, say, a
2419 ; semicolon precedes it.
2421 (while t
;; We go back one "token" each iteration of the loop.
2424 ;; Stop at the token after a comment.
2425 ((c-backward-single-comment) ; Also functions as backwards-ws.
2427 (throw 'done
'(t . literal
)))
2429 ;; If we've gone back over a LF, we might have moved into or out of
2430 ;; a preprocessor line.
2431 ((and (save-excursion
2433 (re-search-forward "\\(^\\|[^\\]\\)[\n\r]" last t
))
2435 (< (point) macro-start
)
2436 (c-beginning-of-macro)))
2438 ;; Return a car of NIL ONLY if we've hit the opening # of a macro.
2439 (throw 'done
(cons (or (eq (point) here
)
2443 ;; Have we found a virtual semicolon? If so, stop, unless the next
2444 ;; statement is where we started from.
2445 ((and (c-at-vsemi-p)
2447 (not (memq (char-after last
) '(?\
) ?
})))) ; we've moved back from ) or }
2449 (throw 'done
'(nil . nil
)))
2451 ;; Hit the beginning of the buffer/region?
2455 (throw 'done
'(nil . nil
)))
2457 ;; Move back a character.
2458 ((progn (backward-char) nil
))
2460 ;; Stop at "{" (unless it's a PIKE special brace list.)
2461 ((eq (char-after) ?\
{)
2462 (if (and c-special-brace-lists
2463 (c-looking-at-special-brace-list))
2464 (skip-syntax-backward "w_") ; Speedup only.
2467 (throw 'done
'(nil . nil
))))
2469 ;; Have we reached the start of a macro? This always counts as
2470 ;; BOS. (N.B. I don't think (eq (point) here) can ever be true
2471 ;; here. FIXME!!! ACM 2004/3/29)
2472 ((and macro-start
(eq (point) macro-start
))
2473 (throw 'done
(cons (eq (point) here
) 'macro-boundary
)))
2475 ;; Stop at token just after "}" or ";".
2476 ((looking-at "[;}]")
2477 ;; If we've gone back over ;, {, or }, we're done.
2478 (if (or (= here last
)
2479 (memq (char-after last
) '(?\
) ?
}))) ; we've moved back from ) or }
2480 (if (and (eq (char-before) ?
}) ; If };, treat them as a unit.
2481 (eq (char-after) ?\
;))
2483 (goto-char last
) ; To the statement starting after the ; or }.
2484 (throw 'done
'(nil . nil
))))
2486 ;; Stop at the token after a string.
2487 ((looking-at c-string-limit-regexp
) ; Just gone back over a string terminator?
2489 (throw 'done
'(t . literal
)))
2491 ;; Nothing special: go back word characters.
2492 (t (skip-syntax-backward "w_")) ; Speedup only.
2495 (defun c-forward-over-illiterals (macro-end allow-early-stop
)
2496 ;; Move forwards over code, stopping before reaching EOB or a literal
2497 ;; (i.e. a comment/string) or the boundary of a preprocessor statement or
2498 ;; the "end of a statement". MACRO-END is the position of the EOL/EOB which
2499 ;; terminates the current preprocessor directive, or NIL if we're not in
2502 ;; ALLOW-EARLY-STOP is non-nil if it is permissible to return without moving
2503 ;; forward at all, should we encounter a `{'. This is an ugly kludge, but
2504 ;; seems unavoidable. Depending on the context this function is called
2505 ;; from, we _sometimes_ need to stop there. Currently (2004/4/3),
2506 ;; ALLOW-EARLY-STOP is applied only to open braces, not to virtual
2507 ;; semicolons, or anything else.
2509 ;; Return a cons (A.B), where
2510 ;; A is NIL if we moved forward to an EOS, or stay at one (when
2511 ;; ALLOW-EARLY-STOP is set), T otherwise (we hit a literal).
2512 ;; B is 'MACRO-BOUNDARY if we are about to cross the boundary out of or
2513 ;; into a macro, otherwise 'LITERAL if we've hit a literal, otherwise NIL
2515 ;; Point is left either after the end-of-statement, or at the last non-ws
2516 ;; code before encountering the literal, or the # of the preprocessor
2517 ;; statement, or at EOB [or just after last non-WS stuff??].
2519 ;; As a clarification of "after the end-of-statement", if a comment or
2520 ;; whitespace follows a completed AWK statement, that statement is treated
2521 ;; as ending just after the last non-ws character before the comment.
2523 ;; Note that this function moves within either preprocessor commands
2524 ;; (macros) or normal code, but not both within the same invocation.
2526 ;; Stop before `{', `}', and `#' when it's at boi on a line, but on the
2527 ;; other side of the syntactic ws, and after `;', `}' and `};'. Only
2528 ;; stop before `{' if at top level or inside braces, though. Move by
2529 ;; sexps and move into parens. Also stop at eol of lines with `#' at
2532 ;; This function might do hidden buffer changes.
2533 (let ((here (point))
2536 (while t
;; We go one "token" forward each time round this loop.
2539 ;; If we've moved forward to a virtual semicolon, we're done.
2540 (if (and (> last here
) ; Should we check ALLOW-EARLY-STOP, here? 2004/4/3
2542 (throw 'done
'(nil . nil
)))
2546 ;; Gone past the end of a macro?
2547 ((and macro-end
(> (point) macro-end
))
2549 (throw 'done
(cons (eq (point) here
) 'macro-boundary
)))
2551 ;; About to hit a comment?
2552 ((save-excursion (c-forward-single-comment))
2554 (throw 'done
'(t . literal
)))
2560 (throw 'done
'(nil . nil
)))
2562 ;; If we encounter a '{', stop just after the previous token.
2563 ((and (eq (char-after) ?
{)
2564 (not (and c-special-brace-lists
2565 (c-looking-at-special-brace-list)))
2566 (or allow-early-stop
(/= here last
))
2567 (save-excursion ; Is this a check that we're NOT at top level?
2568 ;;;; NO! This seems to check that (i) EITHER we're at the top level; OR (ii) The next enclosing
2569 ;;;; level of bracketing is a '{'. HMM. Doesn't seem to make sense.
2570 ;;;; 2003/8/8 This might have something to do with the GCC extension "Statement Expressions", e.g.
2571 ;;;; while ({stmt1 ; stmt2 ; exp ;}). This form excludes such Statement Expressions.
2572 (or (not (c-safe (up-list -
1) t
))
2573 (= (char-after) ?
{))))
2575 (throw 'done
'(nil . nil
)))
2577 ;; End of a PIKE special brace list? If so, step over it and continue.
2578 ((and c-special-brace-lists
2579 (eq (char-after) ?
})
2581 (and (c-safe (up-list -
1) t
)
2582 (c-looking-at-special-brace-list))))
2584 (skip-syntax-forward "w_")) ; Speedup only.
2586 ;; Have we got a '}' after having moved? If so, stop after the
2588 ((and (eq (char-after) ?
})
2591 (throw 'done
'(nil . nil
)))
2593 ;; Stop if we encounter a preprocessor line. Continue if we
2595 ((and c-opt-cpp-prefix
2597 (eq (char-after) ?
#)
2598 (= (point) (c-point 'boi
)))
2599 (if (= (point) here
) ; Not a macro, therefore naked #.
2601 (throw 'done
'(t . macro-boundary
))))
2603 ;; Stop after a ';', '}', or "};"
2604 ((looking-at ";\\|};?")
2605 (goto-char (match-end 0))
2606 (throw 'done
'(nil . nil
)))
2608 ;; Found a string (this subsumes AWK regexps)?
2609 ((looking-at c-string-limit-regexp
)
2611 (throw 'done
'(t . literal
)))
2614 (forward-char) ; Can't fail - we checked (eobp) earlier on.
2615 (skip-syntax-forward "w_") ; Speedup only.
2616 (when (and macro-end
(> (point) macro-end
))
2618 (throw 'done
(cons (eq (point) here
) 'macro-boundary
))))
2621 (defun c-one-line-string-p (range)
2622 ;; Is the literal defined by RANGE a string contained in a single line?
2624 ;; This function might do hidden buffer changes.
2626 (goto-char (car range
))
2627 (and (looking-at c-string-limit-regexp
)
2628 (progn (skip-chars-forward "^\n" (cdr range
))
2629 (eq (point) (cdr range
))))))
2631 (defun c-beginning-of-statement (&optional count lim sentence-flag
)
2632 "Go to the beginning of the innermost C statement.
2633 With prefix arg, go back N - 1 statements. If already at the
2634 beginning of a statement then go to the beginning of the closest
2635 preceding one, moving into nested blocks if necessary (use
2636 \\[backward-sexp] to skip over a block). If within or next to a
2637 comment or multiline string, move by sentences instead of statements.
2639 When called from a program, this function takes 3 optional args: the
2640 repetition count, a buffer position limit which is the farthest back
2641 to search for the syntactic context, and a flag saying whether to do
2642 sentence motion in or near comments and multiline strings.
2644 Note that for use in programs, `c-beginning-of-statement-1' is
2645 usually better. It has much better defined semantics than this one,
2646 which is intended for interactive use, and might therefore change to
2647 be more \"DWIM:ey\"."
2648 (interactive (list (prefix-numeric-value current-prefix-arg
)
2651 (c-end-of-statement (- count
) lim sentence-flag
)
2652 (c-save-buffer-state
2653 ((count (or count
1))
2654 last
; start point for going back ONE chunk. Updated each chunk movement.
2656 (save-excursion (and (not (bobp)) (c-beginning-of-macro) (point))))
2657 res
; result from sub-function call
2658 not-bos
; "not beginning-of-statement"
2659 (range (c-collect-line-comments (c-literal-limits lim
)))) ; (start.end) of current literal or NIL
2661 ;; Go back one statement at each iteration of the following loop.
2662 (while (and (/= count
0)
2663 (or (not lim
) (> (point) lim
)))
2664 ;; Go back one "chunk" each time round the following loop, stopping
2665 ;; when we reach a statement boundary, etc.
2668 (cond ; Each arm of this cond returns NIL on reaching a desired
2669 ; statement boundary, non-NIL otherwise.
2674 (range ; point is within or approaching a literal.
2676 ;; Single line string or sentence-flag is null => skip the
2678 ((or (null sentence-flag
)
2679 (c-one-line-string-p range
))
2680 (goto-char (car range
))
2681 (setq range
(c-ascertain-preceding-literal))
2682 ;; N.B. The following is essentially testing for an AWK regexp
2684 ;; Was the previous non-ws thing an end of statement?
2687 (c-backward-comments)
2688 (c-backward-syntactic-ws))
2689 (not (or (bobp) (c-after-statement-terminator-p)))))
2691 ;; Comment inside a statement or a multi-line string.
2692 (t (when (setq res
; returns non-nil when we go out of the literal
2693 (if (eq (c-literal-type range
) 'string
)
2694 (c-beginning-of-sentence-in-string range
)
2695 (c-beginning-of-sentence-in-comment range
)))
2696 (setq range
(c-ascertain-preceding-literal)))
2699 ;; Non-literal code.
2700 (t (setq res
(c-back-over-illiterals macro-fence
))
2701 (setq not-bos
; "not reached beginning-of-statement".
2702 (or (= (point) last
)
2703 (memq (char-after) '(?\
) ?\
}))
2706 ;; We're at a tentative BOS. The next form goes
2707 ;; back over WS looking for an end of previous
2709 (not (save-excursion
2711 (c-backward-comments)
2712 (c-backward-syntactic-ws))
2713 (or (bobp) (c-after-statement-terminator-p)))))))
2714 ;; Are we about to move backwards into or out of a
2715 ;; preprocessor command? If so, locate its beginning.
2716 (when (eq (cdr res
) 'macro-boundary
)
2721 (progn (c-skip-ws-backward) (c-beginning-of-macro))
2723 ;; Are we about to move backwards into a literal?
2724 (when (memq (cdr res
) '(macro-boundary literal
))
2725 (setq range
(c-ascertain-preceding-literal)))
2727 (setq last
(point)))
2729 (if (/= count
0) (setq count
(1- count
))))
2730 (c-keep-region-active))))
2732 (defun c-end-of-statement (&optional count lim sentence-flag
)
2733 "Go to the end of the innermost C statement.
2734 With prefix arg, go forward N - 1 statements. Move forward to the end
2735 of the next statement if already at end, and move into nested blocks
2736 \(use \\[forward-sexp] to skip over a block). If within or next to a
2737 comment or multiline string, move by sentences instead of statements.
2739 When called from a program, this function takes 3 optional args: the
2740 repetition count, a buffer position limit which is the farthest back
2741 to search for the syntactic context, and a flag saying whether to do
2742 sentence motion in or near comments and multiline strings."
2743 (interactive (list (prefix-numeric-value current-prefix-arg
)
2745 (setq count
(or count
1))
2746 (if (< count
0) (c-beginning-of-statement (- count
) lim sentence-flag
)
2748 (c-save-buffer-state
2749 (here ; start point for going forward ONE statement. Updated each statement.
2752 (and (not (eobp)) (c-beginning-of-macro)
2753 (progn (c-end-of-macro) (point)))))
2755 (range (c-collect-line-comments (c-literal-limits lim
)))) ; (start.end) of current literal or NIL
2757 ;; Go back/forward one statement at each iteration of the following loop.
2758 (while (and (/= count
0)
2759 (or (not lim
) (< (point) lim
)))
2760 (setq here
(point)) ; ONLY HERE is HERE updated
2762 ;; Go forward one "chunk" each time round the following loop, stopping
2763 ;; when we reach a statement boundary, etc.
2765 (cond ; Each arm of this cond returns NIL on reaching a desired
2766 ; statement boundary, non-NIL otherwise.
2771 (range ; point is within a literal.
2773 ;; sentence-flag is null => skip the entire literal.
2774 ;; or a Single line string.
2775 ((or (null sentence-flag
)
2776 (c-one-line-string-p range
))
2777 (goto-char (cdr range
))
2778 (setq range
(c-ascertain-following-literal))
2779 ;; Is there a virtual semicolon here (e.g. for AWK)?
2780 (not (c-at-vsemi-p)))
2782 ;; Comment or multi-line string.
2783 (t (when (setq res
; gets non-nil when we go out of the literal
2784 (if (eq (c-literal-type range
) 'string
)
2785 (c-end-of-sentence-in-string range
)
2786 (c-end-of-sentence-in-comment range
)))
2787 (setq range
(c-ascertain-following-literal)))
2788 ;; If we've just come forward out of a literal, check for
2789 ;; vsemi. (N.B. AWK can't have a vsemi after a comment, but
2790 ;; some other language may do in the future)
2792 (not (c-at-vsemi-p))))))
2794 ;; Non-literal code.
2795 (t (setq res
(c-forward-over-illiterals macro-fence
2797 ;; Are we about to move forward into or out of a
2798 ;; preprocessor command?
2799 (when (eq (cdr res
) 'macro-boundary
)
2806 (progn (c-skip-ws-forward)
2807 (c-beginning-of-macro))
2808 (progn (c-end-of-macro)
2811 (c-beginning-of-macro)
2812 (progn (c-end-of-macro) (point)))))))
2813 ;; Are we about to move forward into a literal?
2814 (when (memq (cdr res
) '(macro-boundary literal
))
2815 (setq range
(c-ascertain-following-literal)))
2818 (if (/= count
0) (setq count
(1- count
))))
2819 (c-keep-region-active))))
2822 ;; set up electric character functions to work with pending-del,
2823 ;; (a.k.a. delsel) mode. All symbols get the t value except
2824 ;; the functions which delete, which gets 'supersede.
2828 (put sym
'delete-selection t
) ; for delsel (Emacs)
2829 (put sym
'pending-delete t
))) ; for pending-del (XEmacs)
2834 c-electric-semi
&comma
2838 (put 'c-electric-delete
'delete-selection
'supersede
) ; delsel
2839 (put 'c-electric-delete
'pending-delete
'supersede
) ; pending-del
2840 (put 'c-electric-backspace
'delete-selection
'supersede
) ; delsel
2841 (put 'c-electric-backspace
'pending-delete
'supersede
) ; pending-del
2842 (put 'c-electric-delete-forward
'delete-selection
'supersede
) ; delsel
2843 (put 'c-electric-delete-forward
'pending-delete
'supersede
) ; pending-del
2846 ;; Inserting/indenting comments
2847 (defun c-calc-comment-indent (entry)
2848 ;; This function might do hidden buffer changes.
2850 (setq entry
(or (assq entry c-indent-comment-alist
)
2851 (assq 'other c-indent-comment-alist
)
2852 '(default .
(column . nil
)))))
2853 (let ((action (car (cdr entry
)))
2854 (value (cdr (cdr entry
)))
2855 (col (current-column)))
2856 (cond ((eq action
'space
)
2858 ((eq action
'column
)
2859 (unless value
(setq value comment-column
))
2861 ;; Do not pad with one space if we're at bol.
2863 (max (1+ col
) value
)))
2869 (let ((lim (c-literal-limits (c-point 'bol
) t
)))
2871 (goto-char (car lim
))
2872 (when (looking-at "/[/*]") ; FIXME!!! Adapt for AWK! (ACM, 2005/11/18)
2873 ;; Found comment to align with.
2875 ;; Do not pad with one space if we're at bol.
2877 (max (1+ col
) (current-column))))))))
2878 ;; Recurse to handle value as a new spec.
2879 (c-calc-comment-indent (cdr entry
)))))))
2881 (defun c-comment-indent ()
2882 "Used by `indent-for-comment' to create and indent comments.
2883 See `c-indent-comment-alist' for a description."
2886 (c-save-buffer-state
2887 ((eot (let ((lim (c-literal-limits (c-point 'bol
) t
)))
2888 (or (when (consp lim
)
2889 (goto-char (car lim
))
2890 (when (looking-at "/[/*]")
2891 (skip-chars-backward " \t")
2894 (skip-chars-backward " \t")
2897 (cond ((looking-at "^/[/*]")
2899 ((progn (beginning-of-line)
2902 ((progn (back-to-indentation)
2903 (and (eq (char-after) ?
})
2904 (eq (point) (1- eot
))))
2906 ((and (looking-at "#[ \t]*\\(endif\\|else\\)")
2907 (eq (match-end 0) eot
))
2912 (if (and (memq line-type
'(anchored-comment empty-line
))
2913 c-indent-comments-syntactically-p
)
2914 (let ((c-syntactic-context (c-guess-basic-syntax)))
2915 ;; BOGOSITY ALERT: if we're looking at the eol, its
2916 ;; because indent-for-comment hasn't put the comment-start
2917 ;; in the buffer yet. this will screw up the syntactic
2918 ;; analysis so we kludge in the necessary info. Another
2919 ;; kludge is that if we're at the bol, then we really want
2920 ;; to ignore any anchoring as specified by
2921 ;; c-comment-only-line-offset since it doesn't apply here.
2923 (c-add-syntax 'comment-intro
))
2924 (let ((c-comment-only-line-offset
2925 (if (consp c-comment-only-line-offset
)
2926 c-comment-only-line-offset
2927 (cons c-comment-only-line-offset
2928 c-comment-only-line-offset
))))
2929 (c-get-syntactic-indentation c-syntactic-context
)))
2931 (c-calc-comment-indent line-type
)))))
2934 ;; used by outline-minor-mode
2935 (defun c-outline-level ()
2936 (let (buffer-invisibility-spec);; This so that `current-column' DTRT
2937 ;; in otherwise-hidden text.
2939 (skip-chars-forward "\t ")
2943 ;; Movement by CPP conditionals.
2944 (defun c-up-conditional (count)
2945 "Move back to the containing preprocessor conditional, leaving mark behind.
2946 A prefix argument acts as a repeat count. With a negative argument,
2947 move forward to the end of the containing preprocessor conditional.
2949 \"#elif\" is treated like \"#else\" followed by \"#if\", so the
2950 function stops at them when going backward, but not when going
2953 (let ((new-point (c-scan-conditionals (- count
) -
1)))
2955 (goto-char new-point
))
2956 (c-keep-region-active))
2958 (defun c-up-conditional-with-else (count)
2959 "Move back to the containing preprocessor conditional, including \"#else\".
2960 Just like `c-up-conditional', except it also stops at \"#else\"
2963 (let ((new-point (c-scan-conditionals (- count
) -
1 t
)))
2965 (goto-char new-point
))
2966 (c-keep-region-active))
2968 (defun c-down-conditional (count)
2969 "Move forward into the next preprocessor conditional, leaving mark behind.
2970 A prefix argument acts as a repeat count. With a negative argument,
2971 move backward into the previous preprocessor conditional.
2973 \"#elif\" is treated like \"#else\" followed by \"#if\", so the
2974 function stops at them when going forward, but not when going
2977 (let ((new-point (c-scan-conditionals count
1)))
2979 (goto-char new-point
))
2980 (c-keep-region-active))
2982 (defun c-down-conditional-with-else (count)
2983 "Move forward into the next preprocessor conditional, including \"#else\".
2984 Just like `c-down-conditional', except it also stops at \"#else\"
2987 (let ((new-point (c-scan-conditionals count
1 t
)))
2989 (goto-char new-point
))
2990 (c-keep-region-active))
2992 (defun c-backward-conditional (count &optional target-depth with-else
)
2993 "Move back across a preprocessor conditional, leaving mark behind.
2994 A prefix argument acts as a repeat count. With a negative argument,
2995 move forward across a preprocessor conditional.
2997 The optional arguments TARGET-DEPTH and WITH-ELSE are historical,
2998 and have the same meanings as in `c-scan-conditionals'. If you
2999 are calling c-forward-conditional from a program, you might want
3000 to call `c-scan-conditionals' directly instead."
3002 (let ((new-point (c-scan-conditionals (- count
) target-depth with-else
)))
3004 (goto-char new-point
))
3005 (c-keep-region-active))
3007 (defun c-forward-conditional (count &optional target-depth with-else
)
3008 "Move forward across a preprocessor conditional, leaving mark behind.
3009 A prefix argument acts as a repeat count. With a negative argument,
3010 move backward across a preprocessor conditional.
3012 If there aren't enough conditionals after \(or before) point, an
3015 \"#elif\" is treated like \"#else\" followed by \"#if\", except that
3016 the nesting level isn't changed when tracking subconditionals.
3018 The optional arguments TARGET-DEPTH and WITH-ELSE are historical,
3019 and have the same meanings as in `c-scan-conditionals'. If you
3020 are calling c-forward-conditional from a program, you might want
3021 to call `c-scan-conditionals' directly instead."
3023 (let ((new-point (c-scan-conditionals count target-depth with-else
)))
3025 (goto-char new-point
)))
3027 (defun c-scan-conditionals (count &optional target-depth with-else
)
3028 "Scan forward across COUNT preprocessor conditionals.
3029 With a negative argument, scan backward across preprocessor
3030 conditionals. Return the end position. Point is not moved.
3032 If there aren't enough preprocessor conditionals, throw an error.
3034 \"#elif\" is treated like \"#else\" followed by \"#if\", except that
3035 the nesting level isn't changed when tracking subconditionals.
3037 The optional argument TARGET-DEPTH specifies the wanted nesting depth
3038 after each scan. E.g. if TARGET-DEPTH is -1, the end position will be
3039 outside the enclosing conditional. A non-integer non-nil TARGET-DEPTH
3042 If the optional argument WITH-ELSE is non-nil, \"#else\" directives
3043 are treated as conditional clause limits. Normally they are ignored."
3044 (let* ((forward (> count
0))
3045 (increment (if forward -
1 1))
3046 (search-function (if forward
're-search-forward
're-search-backward
))
3047 new case-fold-search
)
3048 (unless (integerp target-depth
)
3049 (setq target-depth
(if target-depth -
1 0)))
3053 ;; subdepth is the depth in "uninteresting" subtrees,
3054 ;; i.e. those that takes us farther from the target
3055 ;; depth instead of closer.
3059 ;; Find the "next" significant line in the proper direction.
3060 (while (and (not found
)
3061 ;; Rather than searching for a # sign that
3062 ;; comes at the beginning of a line aside from
3063 ;; whitespace, search first for a string
3064 ;; starting with # sign. Then verify what
3065 ;; precedes it. This is faster on account of
3066 ;; the fastmap feature of the regexp matcher.
3067 (funcall search-function
3068 "#[ \t]*\\(if\\|elif\\|endif\\|else\\)"
3071 ;; Now verify it is really a preproc line.
3072 (if (looking-at "^[ \t]*#[ \t]*\\(if\\|elif\\|endif\\|else\\)")
3073 (let (dchange (directive (match-string 1)))
3074 (cond ((string= directive
"if")
3075 (setq dchange
(- increment
)))
3076 ((string= directive
"endif")
3077 (setq dchange increment
))
3079 ;; When we're not in an "uninteresting"
3080 ;; subtree, we might want to act on "elif"
3082 (if (cond (with-else
3083 ;; Always move toward the target depth.
3085 (if (> target-depth
0) 1 -
1)))
3086 ((string= directive
"elif")
3087 (setq dchange
(- increment
))))
3088 ;; Ignore the change if it'd take us
3089 ;; into an "uninteresting" subtree.
3090 (if (eq (> dchange
0) (<= target-depth
0))
3091 (setq dchange nil
)))))
3093 (when (or (/= subdepth
0)
3094 (eq (> dchange
0) (<= target-depth
0)))
3095 (setq subdepth
(+ subdepth dchange
)))
3096 (setq depth
(+ depth dchange
))
3097 ;; If we are trying to move across, and we find an
3098 ;; end before we find a beginning, get an error.
3099 (if (and (< depth target-depth
) (< dchange
0))
3101 "No following conditional at this level"
3102 "No previous conditional at this level"))))
3103 ;; When searching forward, start from next line so
3104 ;; that we don't find the same line again.
3105 (if forward
(forward-line 1))
3106 ;; We found something if we've arrived at the
3108 (if (and dchange
(= depth target-depth
))
3109 (setq found
(point))))
3111 (if forward
(forward-line 1)))))
3113 (error "No containing preprocessor conditional"))
3114 (goto-char (setq new found
)))
3115 (setq count
(+ count increment
))))
3116 (c-keep-region-active)
3120 ;; commands to indent lines, regions, defuns, and expressions
3121 (defun c-indent-command (&optional arg
)
3122 "Indent current line as C code, and/or insert some whitespace.
3124 If `c-tab-always-indent' is t, always just indent the current line.
3125 If nil, indent the current line only if point is at the left margin or
3126 in the line's indentation; otherwise insert some whitespace[*]. If
3127 other than nil or t, then some whitespace[*] is inserted only within
3128 literals (comments and strings), but the line is always reindented.
3130 If `c-syntactic-indentation' is t, indentation is done according to
3131 the syntactic context. A numeric argument, regardless of its value,
3132 means indent rigidly all the lines of the expression starting after
3133 point so that this line becomes properly indented. The relative
3134 indentation among the lines of the expression is preserved.
3136 If `c-syntactic-indentation' is nil, the line is just indented one
3137 step according to `c-basic-offset'. In this mode, a numeric argument
3138 indents a number of such steps, positive or negative, and an empty
3139 prefix argument is equivalent to -1.
3141 [*] The amount and kind of whitespace inserted is controlled by the
3142 variable `c-insert-tab-function', which is called to do the actual
3143 insertion of whitespace. Normally the function in this variable
3144 just inserts a tab character, or the equivalent number of spaces,
3145 depending on the variable `indent-tabs-mode'."
3148 (let ((indent-function
3149 (if c-syntactic-indentation
3150 (symbol-function 'indent-according-to-mode
)
3152 (let ((c-macro-start c-macro-start
)
3153 (steps (if (equal arg
'(4))
3155 (prefix-numeric-value arg
))))
3156 (c-shift-line-indentation (* steps c-basic-offset
))
3157 (when (and c-auto-align-backslashes
3160 (eq (char-before) ?
\\))
3161 (c-query-and-set-macro-start))
3162 ;; Realign the line continuation backslash if inside a macro.
3163 (c-backslash-region (point) (point) nil t
)))
3165 (if (and c-syntactic-indentation arg
)
3166 ;; If c-syntactic-indentation and got arg, always indent this
3167 ;; line as C and shift remaining lines of expression the same
3169 (let ((shift-amt (save-excursion
3170 (back-to-indentation)
3174 (setq shift-amt
(- (save-excursion
3175 (back-to-indentation)
3179 (if (eq c-tab-always-indent t
)
3180 (beginning-of-line)) ; FIXME!!! What is this here for? ACM 2005/10/31
3188 (indent-code-rigidly beg end shift-amt
"#")))
3189 ;; Else use c-tab-always-indent to determine behavior.
3191 ;; CASE 1: indent when at column zero or in line's indentation,
3192 ;; otherwise insert a tab
3193 ((not c-tab-always-indent
)
3195 (skip-chars-backward " \t")
3197 (funcall c-insert-tab-function
)
3198 (funcall indent-function
)))
3199 ;; CASE 2: just indent the line
3200 ((eq c-tab-always-indent t
)
3201 (funcall indent-function
))
3202 ;; CASE 3: if in a literal, insert a tab, but always indent the
3205 (if (c-save-buffer-state () (c-in-literal))
3206 (funcall c-insert-tab-function
))
3207 (funcall indent-function
)
3210 (defun c-indent-exp (&optional shutup-p
)
3211 "Indent each line in the balanced expression following point syntactically.
3212 If optional SHUTUP-P is non-nil, no errors are signaled if no
3213 balanced expression is found."
3215 (let ((here (point-marker))
3217 (set-marker-insertion-type here t
)
3219 (let ((start (save-restriction
3220 ;; Find the closest following open paren that
3221 ;; ends on another line.
3222 (narrow-to-region (point-min) (c-point 'eol
))
3223 (let (beg (end (point)))
3224 (while (and (setq beg
(c-down-list-forward end
))
3225 (setq end
(c-up-list-forward beg
))))
3227 (eq (char-syntax (char-before beg
)) ?\
()
3232 (error "Cannot find start of balanced expression to indent"))
3234 (setq end
(c-safe (scan-sexps (point) 1)))
3237 (error "Cannot find end of balanced expression to indent"))
3240 (c-indent-region (point) end
)))))
3242 (set-marker here nil
))))
3244 (defun c-indent-defun ()
3245 "Indent the current top-level declaration or macro syntactically.
3246 In the macro case this also has the effect of realigning any line
3247 continuation backslashes, unless `c-auto-align-backslashes' is nil."
3249 (let ((here (point-marker)) decl-limits case-fold-search
)
3252 (c-save-buffer-state nil
3253 ;; We try to be line oriented, unless there are several
3254 ;; declarations on the same line.
3255 (if (looking-at c-syntactic-eol
)
3256 (c-backward-token-2 1 nil
(c-point 'bol
))
3257 (c-forward-token-2 0 nil
(c-point 'eol
)))
3258 (setq decl-limits
(c-declaration-limits nil
)))
3260 (c-indent-region (car decl-limits
)
3261 (cdr decl-limits
))))
3263 (set-marker here nil
))))
3265 (defun c-indent-region (start end
&optional quiet
)
3266 "Indent syntactically every line whose first char is between START
3267 and END inclusive. If the optional argument QUIET is non-nil then no
3268 syntactic errors are reported, even if `c-report-syntactic-errors' is
3272 (skip-chars-backward " \t\n\r\f\v")
3275 ;; Advance to first nonblank line.
3277 (skip-chars-forward " \t\n\r\f\v")
3278 (setq start
(point))
3280 (setq c-parsing-error
3281 (or (let ((endmark (copy-marker end
))
3282 (c-parsing-error nil
)
3283 ;; shut up any echo msgs on indiv lines
3284 (c-echo-syntactic-information-p nil
)
3285 (ml-macro-start ; Start pos of multi-line macro.
3286 (and (c-save-buffer-state ()
3287 (save-excursion (c-beginning-of-macro)))
3288 (eq (char-before (c-point 'eol
)) ?
\\)
3290 (c-fix-backslashes nil
)
3294 (c-progress-init start end
'c-indent-region
)
3296 (while (and (bolp) ;; One line each time round the loop.
3298 (< (point) endmark
))
3302 (unless (or (looking-at "\\s *$")
3303 (and ml-macro-start
(looking-at "\\s *\\\\$")))
3304 ;; Get syntax and indent.
3305 (c-save-buffer-state nil
3306 (setq syntax
(c-guess-basic-syntax)))
3307 (c-indent-line syntax t t
))
3310 ;; End of current multi-line macro?
3311 (when (and c-auto-align-backslashes
3312 (not (eq (char-before (c-point 'eol
)) ?
\\)))
3313 ;; Fixup macro backslashes.
3314 (c-backslash-region ml-macro-start
(c-point 'bonl
) nil
)
3315 (setq ml-macro-start nil
))
3316 ;; New multi-line macro?
3317 (if (and (assq 'cpp-macro syntax
)
3318 (eq (char-before (c-point 'eol
)) ?
\\))
3319 (setq ml-macro-start
(point))))
3323 (if (and ml-macro-start c-auto-align-backslashes
)
3324 (c-backslash-region ml-macro-start
(c-point 'bopl
) nil t
)))
3325 (set-marker endmark nil
)
3326 (c-progress-fini 'c-indent-region
))
3327 (c-echo-parsing-error quiet
))
3330 (defun c-fn-region-is-active-p ()
3331 ;; Function version of the macro for use in places that aren't
3332 ;; compiled, e.g. in the menus.
3333 (c-region-is-active-p))
3335 (defun c-indent-line-or-region (&optional arg region
)
3336 "Indent active region, current line, or block starting on this line.
3337 In Transient Mark mode, when the region is active, reindent the region.
3338 Otherwise, with a prefix argument, rigidly reindent the expression
3339 starting on the current line.
3340 Otherwise reindent just the current line."
3342 (list current-prefix-arg
(use-region-p)))
3344 (c-indent-region (region-beginning) (region-end))
3345 (c-indent-command arg
)))
3347 ;; for progress reporting
3348 (defvar c-progress-info nil
)
3350 (defun c-progress-init (start end context
)
3353 ((not c-progress-interval
))
3354 ;; Start the progress update messages. If this Emacs doesn't have
3355 ;; a built-in timer, just be dumb about it.
3356 ((not (fboundp 'current-time
))
3357 (message "Indenting region... (this may take a while)"))
3358 ;; If progress has already been initialized, do nothing. otherwise
3359 ;; initialize the counter with a vector of:
3360 ;; [start end lastsec context]
3362 (t (setq c-progress-info
(vector start
3366 (nth 1 (current-time))
3368 (message "Indenting region..."))
3371 (defun c-progress-update ()
3372 (if (not (and c-progress-info c-progress-interval
))
3374 (let ((now (nth 1 (current-time)))
3375 (start (aref c-progress-info
0))
3376 (end (aref c-progress-info
1))
3377 (lastsecs (aref c-progress-info
2)))
3378 ;; should we update? currently, update happens every 2 seconds,
3379 ;; what's the right value?
3380 (if (< c-progress-interval
(- now lastsecs
))
3382 (message "Indenting region... (%d%% complete)"
3383 (/ (* 100 (- (point) start
)) (- end start
)))
3384 (aset c-progress-info
2 now
)))
3387 (defun c-progress-fini (context)
3388 (if (not c-progress-interval
)
3390 (if (or (eq context
(aref c-progress-info
3))
3393 (set-marker (aref c-progress-info
1) nil
)
3394 (setq c-progress-info nil
)
3395 (message "Indenting region... done")))))
3399 ;;; This page handles insertion and removal of backslashes for C macros.
3401 (defun c-backslash-region (from to delete-flag
&optional line-mode
)
3402 "Insert, align, or delete end-of-line backslashes on the lines in the region.
3403 With no argument, inserts backslashes and aligns existing backslashes.
3404 With an argument, deletes the backslashes. The backslash alignment is
3405 done according to the settings in `c-backslash-column',
3406 `c-backslash-max-column' and `c-auto-align-backslashes'.
3408 This function does not modify blank lines at the start of the region.
3409 If the region ends at the start of a line and the macro doesn't
3410 continue below it, the backslash (if any) at the end of the previous
3413 You can put the region around an entire macro definition and use this
3414 command to conveniently insert and align the necessary backslashes."
3415 (interactive "*r\nP")
3416 (let ((endmark (make-marker))
3417 ;; Keep the backslash trimming functions from changing the
3418 ;; whitespace around point, since in this case it's only the
3419 ;; position of point that tells the indentation of the line.
3420 (point-pos (if (save-excursion
3421 (skip-chars-backward " \t")
3422 (and (bolp) (looking-at "[ \t]*\\\\?$")))
3425 column longest-line-col bs-col-after-end
)
3428 (if (and (not line-mode
) (bobp))
3429 ;; Nothing to do if to is at bob, since we should back up
3430 ;; and there's no line to back up to.
3432 (when (and (not line-mode
) (bolp))
3433 ;; Do not back up the to line if line-mode is set, to make
3434 ;; e.g. c-newline-and-indent consistent regardless whether
3435 ;; the (newline) call leaves point at bol or not.
3440 (set-marker endmark
(point))
3442 (c-delete-backslashes-forward endmark point-pos
))
3443 ;; Set bs-col-after-end to the column of any backslash
3444 ;; following the region, or nil if there is none.
3445 (setq bs-col-after-end
3446 (and (progn (end-of-line)
3447 (eq (char-before) ?
\\))
3448 (= (forward-line 1) 0)
3449 (progn (end-of-line)
3450 (eq (char-before) ?
\\))
3451 (1- (current-column))))
3453 ;; Back up the to line if line-mode is set, since the line
3454 ;; after the newly inserted line break should not be
3455 ;; touched in c-newline-and-indent.
3456 (setq to
(max from
(or (c-safe (c-point 'eopl
)) from
)))
3457 (unless bs-col-after-end
3458 ;; Set bs-col-after-end to non-nil in any case, since we
3459 ;; do not want to delete the backslash at the last line.
3460 (setq bs-col-after-end t
)))
3462 (not c-auto-align-backslashes
))
3464 ;; Compute the smallest column number past the ends of all
3466 (setq longest-line-col
0)
3468 (if bs-col-after-end
3469 ;; Include one more line in the max column
3470 ;; calculation, since the to line will be backslashed
3474 (while (and (>= (point) from
)
3476 (if (eq (char-before) ?
\\)
3478 (skip-chars-backward " \t")
3479 (setq longest-line-col
(max longest-line-col
3480 (1+ (current-column))))
3484 ;; Try to align with surrounding backslashes.
3487 (if (and (not (bobp))
3488 (progn (backward-char)
3489 (eq (char-before) ?
\\)))
3491 (setq column
(1- (current-column)))
3492 (if (numberp bs-col-after-end
)
3493 ;; Both a preceding and a following backslash.
3494 ;; Choose the greatest of them.
3495 (setq column
(max column bs-col-after-end
)))
3497 ;; No preceding backslash. Try to align with one
3498 ;; following the region. Disregard the backslash at the
3499 ;; to line since it's likely to be bogus (e.g. when
3500 ;; called from c-newline-and-indent).
3501 (if (numberp bs-col-after-end
)
3502 (setq column bs-col-after-end
))
3503 ;; Don't modify blank lines at start of region.
3505 (while (and (< (point) to
) (bolp) (eolp))
3507 (if (and column
(< column longest-line-col
))
3508 ;; Don't try to align with surrounding backslashes if
3509 ;; any line is too long.
3512 ;; Impose minimum limit and tab width alignment only if
3513 ;; we can't align with surrounding backslashes.
3514 (if (> (% longest-line-col tab-width
) 0)
3515 (setq longest-line-col
3516 (* (/ (+ longest-line-col tab-width -
1)
3519 (setq column
(max c-backslash-column
3521 ;; Always impose maximum limit.
3522 (setq column
(min column c-backslash-max-column
)))
3523 (if bs-col-after-end
3524 ;; Add backslashes on all lines if the macro continues
3525 ;; after the to line.
3527 (set-marker endmark to
)
3528 (c-append-backslashes-forward endmark column point-pos
))
3529 ;; Add backslashes on all lines except the last, and
3530 ;; remove any on the last line.
3535 (set-marker endmark
(1- (point)))))
3537 (c-append-backslashes-forward endmark column point-pos
)
3538 ;; The function above leaves point on the line
3539 ;; following endmark.
3540 (set-marker endmark
(point)))
3541 (set-marker endmark to
))
3542 (c-delete-backslashes-forward endmark point-pos
)))))
3543 (set-marker endmark nil
)
3544 (if (markerp point-pos
)
3545 (set-marker point-pos nil
))))
3547 (defun c-append-backslashes-forward (to-mark column point-pos
)
3548 (let ((state (parse-partial-sexp (c-point 'bol
) (point))))
3552 (<= (point) to-mark
)
3554 (let ((start (point)) (inserted nil
) end col
)
3556 (unless (eq (char-before) ?
\\)
3559 (setq state
(parse-partial-sexp
3560 start
(point) nil nil state
))
3562 (setq col
(current-column))
3564 ;; Avoid unnecessary changes of the buffer.
3565 (cond ((and (not inserted
) (nth 3 state
))
3566 ;; Don't realign backslashes in string literals
3567 ;; since that would change them.
3574 (skip-chars-backward
3575 " \t" (if (>= (point) point-pos
) point-pos
))
3579 ((and (= col column
)
3580 (memq (char-before) '(?\ ?
\t))))
3584 (or (/= (skip-chars-backward
3585 " \t" (if (>= (point) point-pos
) point-pos
))
3587 (/= (char-after) ?\
)))
3588 (delete-region (point) end
)
3589 (indent-to column
1)))
3591 (zerop (forward-line 1)))
3592 (bolp))) ; forward-line has funny behavior at eob.
3594 ;; Make sure there are backslashes with at least one space in
3598 (<= (point) to-mark
)
3600 (let ((start (point)))
3602 (setq state
(parse-partial-sexp
3603 start
(point) nil nil state
))
3605 (if (eq (char-before) ?
\\)
3606 (unless (nth 3 state
)
3608 (unless (and (memq (char-before) '(?\ ?
\t))
3609 (/= (point) point-pos
))
3612 (if (and (memq (char-before) '(?\ ?
\t))
3613 (/= (point) point-pos
))
3617 (zerop (forward-line 1)))
3618 (bolp)))))) ; forward-line has funny behavior at eob.
3620 (defun c-delete-backslashes-forward (to-mark point-pos
)
3622 (and (<= (point) to-mark
)
3625 (if (eq (char-before) ?
\\)
3628 (progn (backward-char)
3629 (skip-chars-backward " \t" (if (>= (point) point-pos
)
3632 (zerop (forward-line 1)))
3633 (bolp)))) ; forward-line has funny behavior at eob.
3637 ;;; Line breaking and paragraph filling.
3639 (defvar c-auto-fill-prefix t
)
3640 (defvar c-lit-limits nil
)
3641 (defvar c-lit-type nil
)
3643 ;; The filling code is based on a simple theory; leave the intricacies
3644 ;; of the text handling to the currently active mode for that
3645 ;; (e.g. adaptive-fill-mode or filladapt-mode) and do as little as
3646 ;; possible to make them work correctly wrt the comment and string
3647 ;; separators, one-line paragraphs etc. Unfortunately, when it comes
3648 ;; to it, there's quite a lot of special cases to handle which makes
3649 ;; the code anything but simple. The intention is that it will work
3650 ;; with any well-written text filling package that preserves a fill
3653 ;; We temporarily mask comment starters and enders as necessary for
3654 ;; the filling code to do its job on a seemingly normal text block.
3655 ;; We do _not_ mask the fill prefix, so it's up to the filling code to
3656 ;; preserve it correctly (especially important when filling C++ style
3657 ;; line comments). By default, we set up and use adaptive-fill-mode,
3658 ;; which is standard in all supported Emacs flavors.
3660 (defun c-guess-fill-prefix (lit-limits lit-type
)
3661 ;; Determine the appropriate comment fill prefix for a block or line
3662 ;; comment. Return a cons of the prefix string and the column where
3663 ;; it ends. If fill-prefix is set, it'll override. Note that this
3664 ;; function also uses the value of point in some heuristics.
3666 ;; This function might do hidden buffer changes.
3668 (let* ((here (point))
3669 (prefix-regexp (concat "[ \t]*\\("
3670 c-current-comment-prefix
3672 (comment-start-regexp (if (eq lit-type
'c
++)
3674 comment-start-skip
))
3675 prefix-line comment-prefix res comment-text-end
)
3679 (setq res
(cons fill-prefix
3680 ;; Ugly way of getting the column after the fill
3681 ;; prefix; it'd be nice with a current-column
3682 ;; that works on strings..
3683 (let ((start (point)))
3686 (insert-and-inherit "\n" fill-prefix
)
3688 (delete-region start
(point)))))))
3692 ;; Set fallback for comment-prefix if none is found.
3693 (setq comment-prefix
"// "
3694 comment-text-end
(cdr lit-limits
))
3697 (if (> (point) (car lit-limits
))
3698 ;; The current line is not the comment starter, so the
3699 ;; comment has more than one line, and it can therefore be
3700 ;; used to find the comment fill prefix.
3701 (setq prefix-line
(point))
3703 (goto-char (car lit-limits
))
3704 (if (and (= (forward-line 1) 0)
3705 (< (point) (cdr lit-limits
)))
3706 ;; The line after the comment starter is inside the
3707 ;; comment, so we can use it.
3708 (setq prefix-line
(point))
3710 ;; The comment is only one line. Take the comment prefix
3711 ;; from it and keep the indentation.
3712 (goto-char (car lit-limits
))
3713 (if (looking-at prefix-regexp
)
3714 (goto-char (match-end 0))
3716 (skip-chars-forward " \t"))
3719 (if (eq (c-point 'boi
) (car lit-limits
))
3720 ;; There is only whitespace before the comment
3721 ;; starter; take the prefix straight from this line.
3722 (setq str
(buffer-substring-no-properties
3723 (c-point 'bol
) (point))
3724 col
(current-column))
3726 ;; There is code before the comment starter, so we
3727 ;; have to temporarily insert and indent a new line to
3728 ;; get the right space/tab mix in the indentation.
3729 (let ((prefix-len (- (point) (car lit-limits
)))
3733 (goto-char (car lit-limits
))
3734 (indent-to (prog1 (current-column)
3737 (forward-char prefix-len
)
3738 (setq str
(buffer-substring-no-properties
3739 (c-point 'bol
) (point))
3740 col
(current-column)))
3741 (delete-region (car lit-limits
) tmp
))))
3744 (if (or (string-match "\\s \\'" str
) (not (eolp)))
3746 ;; The prefix ends the line with no whitespace
3747 ;; after it. Default to a single space.
3748 (cons (concat str
" ") (1+ col
))))
3752 (setq comment-text-end
3754 (goto-char (- (cdr lit-limits
) 2))
3755 (if (looking-at "\\*/") (point) (cdr lit-limits
))))
3759 (if (and (> (point) (car lit-limits
))
3760 (not (and (looking-at "[ \t]*\\*/")
3761 (eq (cdr lit-limits
) (match-end 0)))))
3762 ;; The current line is not the comment starter and
3763 ;; contains more than just the ender, so it's good enough
3764 ;; to be used for the comment fill prefix.
3765 (setq prefix-line
(point))
3766 (goto-char (car lit-limits
))
3768 (cond ((or (/= (forward-line 1) 0)
3769 (>= (point) (cdr lit-limits
))
3770 (and (looking-at "[ \t]*\\*/")
3771 (eq (cdr lit-limits
) (match-end 0)))
3772 (and (looking-at prefix-regexp
)
3773 (<= (1- (cdr lit-limits
)) (match-end 0))))
3774 ;; The comment is either one line or the next line contains
3775 ;; just the comment ender. In this case we have no
3776 ;; information about a suitable comment prefix, so we resort
3777 ;; to c-block-comment-prefix.
3778 (setq comment-prefix
(or c-block-comment-prefix
"")))
3781 ;; The point was on the comment opener line, so we might want
3782 ;; to treat this as a not yet closed comment.
3784 (if (and (match-beginning 1)
3785 (/= (match-beginning 1) (match-end 1)))
3786 ;; Above `prefix-regexp' matched a nonempty prefix on the
3787 ;; second line, so let's use it. Normally it should do
3788 ;; to set `prefix-line' and let the code below pick up
3789 ;; the whole prefix, but if there's no text after the
3790 ;; match then it will probably fall back to no prefix at
3791 ;; all if the comment isn't closed yet, so in that case
3792 ;; it's better to force use of the prefix matched now.
3793 (if (= (match-end 0) (c-point 'eol
))
3794 (setq comment-prefix
(match-string 1))
3795 (setq prefix-line
(point)))
3797 ;; There's no nonempty prefix on the line after the
3798 ;; comment opener. If the line is empty, or if the
3799 ;; text on it has less or equal indentation than the
3800 ;; comment starter we assume it's an unclosed
3801 ;; comment starter, i.e. that
3802 ;; `c-block-comment-prefix' should be used.
3803 ;; Otherwise we assume it's a closed comment where
3804 ;; the prefix really is the empty string.
3805 ;; E.g. this is an unclosed comment:
3816 ;; (Looking for the presence of the comment closer
3817 ;; rarely works since it's probably the closer of
3818 ;; some comment further down when the comment
3819 ;; really is unclosed.)
3820 (if (<= (save-excursion (back-to-indentation)
3822 (save-excursion (goto-char (car lit-limits
))
3824 (setq comment-prefix
(or c-block-comment-prefix
""))
3825 (setq prefix-line
(point)))))
3828 ;; Otherwise the line after the comment starter is good
3829 ;; enough to find the prefix in.
3830 (setq prefix-line
(point))))
3832 (when comment-prefix
3833 ;; Haven't got the comment prefix on any real line that we
3834 ;; can take it from, so we have to temporarily insert
3835 ;; `comment-prefix' on a line and indent it to find the
3836 ;; correct column and the correct mix of tabs and spaces.
3838 (let (tmp-pre tmp-post
)
3842 (goto-char (car lit-limits
))
3843 (if (looking-at comment-start-regexp
)
3844 (goto-char (min (match-end 0)
3847 (skip-chars-forward " \t"))
3849 (when (eq (char-syntax (char-before)) ?\
)
3850 ;; If there's ws on the current line, we'll use it
3851 ;; instead of what's ending comment-prefix.
3852 (setq comment-prefix
3853 (concat (substring comment-prefix
3857 (buffer-substring-no-properties
3859 (skip-chars-backward " \t")
3863 (setq tmp-pre
(point-marker))
3865 ;; We insert an extra non-whitespace character
3866 ;; before the line break and after comment-prefix in
3867 ;; case it's "" or ends with whitespace.
3868 (insert-and-inherit "x\n" comment-prefix
"x")
3869 (setq tmp-post
(point-marker))
3871 (indent-according-to-mode)
3873 (goto-char (1- tmp-post
))
3874 (cons (buffer-substring-no-properties
3875 (c-point 'bol
) (point))
3879 (delete-region tmp-pre tmp-post
)
3880 (set-marker tmp-pre nil
)
3881 (set-marker tmp-post nil
))))))))))
3883 (or res
; Found a good prefix above.
3886 ;; prefix-line is the bol of a line on which we should try
3887 ;; to find the prefix.
3888 (let* (fb-string fb-endpos
; Contains any fallback prefix found.
3891 (when (and (looking-at prefix-regexp
)
3892 (<= (match-end 0) comment-text-end
))
3893 (unless (eq (match-end 0) (c-point 'eol
))
3894 ;; The match is fine if there's text after it.
3895 (throw 'found
(cons (buffer-substring-no-properties
3896 (match-beginning 0) (match-end 0))
3897 (progn (goto-char (match-end 0))
3898 (current-column)))))
3900 ;; This match is better than nothing, so let's
3901 ;; remember it in case nothing better is found
3903 (setq fb-string
(buffer-substring-no-properties
3904 (match-beginning 0) (match-end 0))
3905 fb-endpos
(match-end 0)))
3909 ;; Search for a line which has text after the prefix
3910 ;; so that we get the proper amount of whitespace
3911 ;; after it. We start with the current line, then
3912 ;; search backwards, then forwards.
3914 (goto-char prefix-line
)
3915 (when (and (funcall test-line
)
3916 (or (/= (match-end 1) (match-end 0))
3917 ;; The whitespace is sucked up by the
3918 ;; first [ \t]* glob if the prefix is empty.
3919 (and (= (match-beginning 1) (match-end 1))
3920 (/= (match-beginning 0) (match-end 0)))))
3921 ;; If the current line doesn't have text but do
3922 ;; have whitespace after the prefix, we'll use it.
3923 (throw 'found
(cons fb-string
3924 (progn (goto-char fb-endpos
)
3925 (current-column)))))
3927 (if (eq lit-type
'c
++)
3928 ;; For line comments we can search up to and
3929 ;; including the first line.
3930 (while (and (zerop (forward-line -
1))
3931 (>= (point) (car lit-limits
)))
3932 (funcall test-line
))
3933 ;; For block comments we must stop before the
3935 (while (and (zerop (forward-line -
1))
3936 (> (point) (car lit-limits
)))
3937 (funcall test-line
)))
3939 (goto-char prefix-line
)
3940 (while (and (zerop (forward-line 1))
3941 (< (point) (cdr lit-limits
)))
3942 (funcall test-line
))
3944 (goto-char prefix-line
)
3948 ;; A good line wasn't found, but at least we have a
3949 ;; fallback that matches the comment prefix regexp.
3950 (cond ((or (string-match "\\s \\'" fb-string
)
3952 (goto-char fb-endpos
)
3954 ;; There are ws or text after the prefix, so
3956 (cons fb-string
(current-column)))
3959 ;; Check if there's any whitespace padding
3960 ;; on the comment start line that we can
3961 ;; use after the prefix.
3962 (goto-char (car lit-limits
))
3963 (if (looking-at comment-start-regexp
)
3964 (goto-char (match-end 0))
3966 (skip-chars-forward " \t"))
3968 (eq (char-syntax (char-before)) ?\
)))
3970 (setq fb-string
(buffer-substring-no-properties
3972 (skip-chars-backward " \t")
3975 (goto-char fb-endpos
)
3976 (skip-chars-backward " \t")
3978 (let ((tmp (point)))
3979 ;; Got to mess in the buffer once again to
3980 ;; ensure the column gets correct. :P
3983 (insert-and-inherit fb-string
)
3984 (cons (buffer-substring-no-properties
3988 (delete-region tmp
(point)))))
3991 ;; Last resort: Just add a single space after
3993 (cons (concat fb-string
" ")
3994 (progn (goto-char fb-endpos
)
3995 (1+ (current-column)))))))
3997 ;; The line doesn't match the comment prefix regexp.
3999 ;; We have a fallback for line comments that we must use.
4000 (cons (concat (buffer-substring-no-properties
4001 prefix-line
(c-point 'boi
))
4003 (progn (back-to-indentation)
4004 (+ (current-column) (length comment-prefix
))))
4006 ;; Assume we are dealing with a "free text" block
4007 ;; comment where the lines doesn't have any comment
4008 ;; prefix at all and we should just fill it as
4013 (defun c-mask-paragraph (fill-paragraph apply-outside-literal fun
&rest args
)
4014 ;; Calls FUN with ARGS ar arguments while the current paragraph is
4015 ;; masked to allow adaptive filling to work correctly. That
4016 ;; includes narrowing the buffer and, if point is inside a comment,
4017 ;; masking the comment starter and ender appropriately.
4019 ;; FILL-PARAGRAPH is non-nil if called for whole paragraph filling.
4020 ;; The position of point is then less significant when doing masking
4023 ;; If APPLY-OUTSIDE-LITERAL is nil then the function will be called
4024 ;; only if the point turns out to be inside a comment or a string.
4026 ;; Note that this function does not do any hidden buffer changes.
4029 ;; beg and end limit the region to narrow. end is a marker.
4031 ;; tmp-pre and tmp-post mark strings that are temporarily
4032 ;; inserted at the start and end of the region. tmp-pre is a
4033 ;; cons of the positions of the prepended string. tmp-post is
4034 ;; a marker pointing to the single character of the appended
4037 ;; If hang-ender-stuck isn't nil, the comment ender is
4038 ;; hanging. In that case it's set to the number of spaces
4039 ;; that should be between the text and the ender.
4041 ;; auto-fill-spaces is the exact sequence of whitespace between a
4042 ;; comment's last word and the comment ender, temporarily replaced
4043 ;; with 'x's before calling FUN when FILL-PARAGRAPH is nil.
4046 (c-lit-limits c-lit-limits
)
4047 (c-lit-type c-lit-type
))
4049 ;; Restore point on undo. It's necessary since we do a lot of
4050 ;; hidden inserts and deletes below that should be as transparent
4052 (if (and buffer-undo-list
(not (eq buffer-undo-list t
)))
4053 (setq buffer-undo-list
(cons (point) buffer-undo-list
)))
4055 ;; Determine the limits and type of the containing literal (if any):
4056 ;; C-LIT-LIMITS, C-LIT-TYPE; and the limits of the current paragraph:
4058 (c-save-buffer-state ()
4060 ;; Widen to catch comment limits correctly.
4062 (unless c-lit-limits
4063 (setq c-lit-limits
(c-literal-limits nil fill-paragraph
)))
4064 (setq c-lit-limits
(c-collect-line-comments c-lit-limits
))
4066 (setq c-lit-type
(c-literal-type c-lit-limits
))))
4069 (unless (c-safe (backward-char)
4073 (forward-paragraph))
4074 (setq end
(point-marker)))
4076 (unless (c-safe (forward-char)
4077 (backward-paragraph)
4080 (backward-paragraph))
4081 (setq beg
(point))))
4085 ;; For each of the possible types of text (string, C comment ...)
4086 ;; determine BEG and END, the region we will narrow to. If we're in
4087 ;; a literal, constrain BEG and END to the limits of this literal.
4089 ;; For some of these text types, particularly a block comment, we
4090 ;; may need to massage whitespace near literal delimiters, so that
4091 ;; these don't get filled inappropriately.
4094 ((eq c-lit-type
'c
++) ; Line comment.
4096 ;; Limit to the comment or paragraph end, whichever
4098 (set-marker end
(min end
(cdr c-lit-limits
)))
4100 (when (<= beg
(car c-lit-limits
))
4101 ;; The region includes the comment starter, so we must
4103 (goto-char (car c-lit-limits
))
4104 (back-to-indentation)
4105 (if (eq (point) (car c-lit-limits
))
4106 ;; Include the first line in the region.
4107 (setq beg
(c-point 'bol
))
4108 ;; The first line contains code before the
4109 ;; comment. We must fake a line that doesn't.
4112 (setq apply-outside-literal t
))
4114 ((eq c-lit-type
'c
) ; Block comment.
4116 (or (> end
(cdr c-lit-limits
))
4117 (and (= end
(cdr c-lit-limits
))
4118 (eq (char-before end
) ?
/)
4119 (eq (char-before (1- end
)) ?
*)
4121 (> (- (cdr c-lit-limits
) (car c-lit-limits
)) 3)))
4122 ;; There is a comment ender, and the region includes it. If
4123 ;; it's on its own line, it stays on its own line. If it's got
4124 ;; company on the line, it keeps (at least one word of) it.
4125 ;; "=====*/" counts as a comment ender here, but "===== */"
4126 ;; doesn't and "foo*/" doesn't.
4129 (goto-char (cdr c-lit-limits
))
4131 ;; The following conjunct was added to avoid an
4132 ;; "Invalid search bound (wrong side of point)"
4133 ;; error in the subsequent re-search. Maybe
4134 ;; another fix would be needed (2007-12-08).
4135 ; (or (<= (- (cdr c-lit-limits) 2) (point))
4136 ; 2010-10-17 Construct removed.
4137 ; (or (< (- (cdr c-lit-limits) 2) (point))
4139 (search-forward-regexp
4140 (concat "\\=[ \t]*\\(" c-current-comment-prefix
"\\)")
4141 (- (cdr c-lit-limits
) 2) t
)
4142 (not (search-forward-regexp
4144 (- (cdr c-lit-limits
) 2) 'limit
))
4145 ;; The comment ender IS on its own line. Exclude this
4146 ;; line from the filling.
4147 (set-marker end
(c-point 'bol
))));)
4149 ;; The comment ender is hanging. Replace all space between it
4150 ;; and the last word either by one or two 'x's (when
4151 ;; FILL-PARAGRAPH is non-nil), or a row of x's the same width
4152 ;; as the whitespace (when auto filling), and include it in
4153 ;; the region. We'll change them back to whitespace
4154 ;; afterwards. The effect of this is to glue the comment
4155 ;; ender to the last word in the comment during filling.
4156 (let* ((ender-start (save-excursion
4157 (goto-char (cdr c-lit-limits
))
4158 (skip-syntax-backward "^w ")
4160 (ender-column (save-excursion
4161 (goto-char ender-start
)
4163 (point-rel (- ender-start here
))
4164 (sentence-ends-comment
4166 (goto-char ender-start
)
4167 (and (search-backward-regexp
4168 (c-sentence-end) (c-point 'bol
) t
)
4169 (goto-char (match-end 0))
4170 (looking-at "[ \t]*")
4171 (= (match-end 0) ender-start
))))
4175 ;; Insert a CR after the "*/", adjust END
4176 (goto-char (cdr c-lit-limits
))
4177 (setq tmp-post
(point-marker))
4179 (set-marker end
(point))
4181 (forward-line -
1) ; last line of the comment
4182 (if (and (looking-at (concat "[ \t]*\\(\\("
4183 c-current-comment-prefix
4185 (eq ender-start
(match-end 0)))
4186 ;; The comment ender is prefixed by nothing but a
4187 ;; comment line prefix. IS THIS POSSIBLE? (ACM,
4188 ;; 2006/4/28). Remove it along with surrounding ws.
4189 (setq spaces
(- (match-end 1) (match-end 2)))
4190 (goto-char ender-start
))
4191 (skip-chars-backward " \t\r\n") ; Surely this can be
4192 ; " \t"? "*/" is NOT alone on the line (ACM, 2005/8/18)
4194 ;; What's being tested here? 2006/4/20. FIXME!!!
4195 (if (/= (point) ender-start
)
4197 (if (<= here
(point))
4198 ;; Don't adjust point below if it's
4199 ;; before the string we replace.
4200 (setq point-rel -
1))
4201 ;; Keep one or two spaces between the
4202 ;; text and the ender, depending on how
4203 ;; many there are now.
4205 (setq spaces
(- ender-column
(current-column))))
4206 (setq auto-fill-spaces
(c-delete-and-extract-region
4207 (point) ender-start
))
4208 ;; paragraph filling condenses multiple spaces to
4209 ;; single or double spaces. auto-fill doesn't.
4214 (if (and sentence-ends-comment
4215 sentence-end-double-space
)
4218 ;; Insert the filler first to keep marks right.
4219 (insert-char ?x spaces t
)
4220 (setq hang-ender-stuck spaces
)
4222 (and (>= point-rel
0)
4223 (- (point) (min point-rel spaces
)))))
4224 (setq point-rel nil
)))
4227 ;; Point was in the middle of the string we
4228 ;; replaced above, so put it back in the same
4229 ;; relative position, counting from the end.
4230 (goto-char point-rel
)))
4233 (when (<= beg
(car c-lit-limits
))
4234 ;; The region includes the comment starter.
4236 (goto-char (car c-lit-limits
))
4237 (if (looking-at (concat "\\(" comment-start-skip
"\\)$"))
4238 ;; Begin with the next line.
4239 (setq beg
(c-point 'bonl
))
4240 ;; Fake the fill prefix in the first line.
4243 (setq apply-outside-literal t
))
4245 ((eq c-lit-type
'string
) ; String.
4247 (when (>= end
(cdr c-lit-limits
))
4248 (goto-char (1- (cdr c-lit-limits
)))
4249 (setq tmp-post
(point-marker))
4251 (set-marker end
(point)))
4252 (when (<= beg
(car c-lit-limits
))
4253 (goto-char (1+ (car c-lit-limits
)))
4254 (setq beg
(if (looking-at "\\\\$")
4255 ;; Leave the start line if it's
4256 ;; nothing but an escaped newline.
4259 (setq apply-outside-literal t
))
4261 ((eq c-lit-type
'pound
) ; Macro
4262 ;; Narrow to the macro limits if they are nearer than the
4263 ;; paragraph limits. Don't know if this is necessary but
4264 ;; do it for completeness sake (doing auto filling at all
4265 ;; inside macros is bogus to begin with since the line
4266 ;; continuation backslashes aren't handled).
4268 (c-save-buffer-state ()
4269 (c-beginning-of-macro)
4276 (set-marker end
(point))))))
4279 ;; Try to avoid comments and macros in the paragraph to
4280 ;; avoid that the adaptive fill mode gets the prefix from
4282 (c-save-buffer-state nil
4285 (c-forward-syntactic-ws end
)
4289 (c-backward-syntactic-ws beg
)
4291 (set-marker end
(point))))))
4294 ;; Temporarily insert the fill prefix after the comment
4295 ;; starter so that the first line looks like any other
4296 ;; comment line in the narrowed region.
4297 (setq fill
(c-save-buffer-state nil
4298 (c-guess-fill-prefix c-lit-limits c-lit-type
)))
4299 (unless (string-match (concat "\\`[ \t]*\\("
4300 c-current-comment-prefix
4303 ;; Oops, the prefix doesn't match the comment prefix
4304 ;; regexp. This could produce very confusing
4305 ;; results with adaptive fill packages together with
4306 ;; the insert prefix magic below, since the prefix
4307 ;; often doesn't appear at all. So let's warn about
4310 Warning: Regexp from `c-comment-prefix-regexp' doesn't match the comment prefix %S"
4312 ;; Find the right spot on the line, break it, insert
4313 ;; the fill prefix and make sure we're back in the
4314 ;; same column by temporarily prefixing the first word
4315 ;; with a number of 'x'.
4317 (goto-char (car c-lit-limits
))
4318 (if (looking-at (if (eq c-lit-type
'c
++)
4319 c-current-comment-prefix
4320 comment-start-skip
))
4321 (goto-char (match-end 0))
4323 (skip-chars-forward " \t"))
4324 (while (and (< (current-column) (cdr fill
))
4327 (let ((col (current-column)))
4328 (setq beg
(1+ (point))
4329 tmp-pre
(list (point)))
4332 (insert-and-inherit "\n" (car fill
))
4333 (insert-char ?x
(- col
(current-column)) t
))
4334 (setcdr tmp-pre
(point))))))
4336 (when apply-outside-literal
4337 ;; `apply-outside-literal' is always set to t here if
4338 ;; we're inside a literal.
4342 ;; Kludge: If the function that adapts the fill prefix
4343 ;; doesn't produce the required comment starter for
4344 ;; line comments, then force it by setting fill-prefix.
4345 (when (and (eq c-lit-type
'c
++)
4346 ;; Kludge the kludge: filladapt-mode doesn't
4347 ;; have this problem, but it currently
4348 ;; doesn't override fill-context-prefix
4350 (not (and (boundp 'filladapt-mode
)
4354 (or (fill-context-prefix beg end
)
4356 (c-save-buffer-state nil
4357 (car (or fill
(c-guess-fill-prefix
4358 c-lit-limits c-lit-type
)))))))
4360 ;; Save the relative position of point if it's outside the
4361 ;; region we're going to narrow. Want to restore it in that
4362 ;; case, but otherwise it should be moved according to the
4364 (point-rel (cond ((< (point) beg
) (- (point) beg
))
4365 ((> (point) end
) (- (point) end
)))))
4367 ;; Preparations finally done! Now we can call the
4371 (narrow-to-region beg end
)
4374 ;; Restore point if it was outside the region.
4376 (goto-char (+ beg point-rel
))
4377 (goto-char (+ end point-rel
))))))))
4379 (when (consp tmp-pre
)
4380 (delete-region (car tmp-pre
) (cdr tmp-pre
)))
4384 (goto-char tmp-post
)
4386 (when hang-ender-stuck
4387 ;; Preserve point even if it's in the middle of the string
4388 ;; we replace; save-excursion doesn't work in that case.
4390 (goto-char tmp-post
)
4391 (skip-syntax-backward "^w ")
4392 (forward-char (- hang-ender-stuck
))
4393 (if (or fill-paragraph
(not auto-fill-spaces
))
4394 (insert-char ?\ hang-ender-stuck t
)
4395 (insert auto-fill-spaces
))
4396 (delete-char hang-ender-stuck
)
4398 (set-marker tmp-post nil
))
4400 (set-marker end nil
))))
4402 (defun c-fill-paragraph (&optional arg
)
4403 "Like \\[fill-paragraph] but handles C and C++ style comments.
4404 If any of the current line is a comment or within a comment, fill the
4405 comment or the paragraph of it that point is in, preserving the
4406 comment indentation or line-starting decorations (see the
4407 `c-comment-prefix-regexp' and `c-block-comment-prefix' variables for
4410 If point is inside multiline string literal, fill it. This currently
4411 does not respect escaped newlines, except for the special case when it
4412 is the very first thing in the string. The intended use for this rule
4413 is in situations like the following:
4415 char description[] = \"\\
4416 A very long description of something that you want to fill to make
4417 nicely formatted output.\"\;
4419 If point is in any other situation, i.e. in normal code, do nothing.
4421 Optional prefix ARG means justify paragraph as well."
4423 (let ((fill-paragraph-function
4424 ;; Avoid infinite recursion.
4425 (if (not (eq fill-paragraph-function
'c-fill-paragraph
))
4426 fill-paragraph-function
)))
4427 (c-mask-paragraph t nil
'fill-paragraph arg
))
4428 ;; Always return t. This has the effect that if filling isn't done
4429 ;; above, it isn't done at all, and it's therefore effectively
4430 ;; disabled in normal code.
4433 (defun c-do-auto-fill ()
4434 ;; Do automatic filling if not inside a context where it should be
4436 (let ((c-auto-fill-prefix
4437 ;; The decision whether the line should be broken is actually
4438 ;; done in c-indent-new-comment-line, which do-auto-fill
4439 ;; calls to break lines. We just set this special variable
4440 ;; so that we'll know when we're called from there. It's
4441 ;; also used to detect whether fill-prefix is user set or
4442 ;; generated automatically by do-auto-fill.
4444 (c-mask-paragraph nil t
'do-auto-fill
)))
4446 (defun c-indent-new-comment-line (&optional soft allow-auto-fill
)
4447 "Break line at point and indent, continuing comment or macro if within one.
4448 If inside a comment and `comment-multi-line' is non-nil, the
4449 indentation and line prefix are preserved (see the
4450 `c-comment-prefix-regexp' and `c-block-comment-prefix' variables for
4451 details). If inside a single line comment and `comment-multi-line' is
4452 nil, a new comment of the same type is started on the next line and
4453 indented as appropriate for comments. If inside a macro, a line
4454 continuation backslash is inserted and aligned as appropriate, and the
4455 new line is indented according to `c-syntactic-indentation'.
4457 If a fill prefix is specified, it overrides all the above."
4458 ;; allow-auto-fill is used from c-context-line-break to allow auto
4459 ;; filling to break the line more than once. Since this function is
4460 ;; used from auto-fill itself, that's normally disabled to avoid
4461 ;; unnecessary recursion.
4463 (let ((fill-prefix fill-prefix
)
4466 (delete-horizontal-space)
4468 (insert-and-inherit ?
\n)
4469 (newline (if allow-auto-fill nil
1)))))
4470 ;; Already know the literal type and limits when called from
4471 ;; c-context-line-break.
4472 (c-lit-limits c-lit-limits
)
4473 (c-lit-type c-lit-type
)
4474 (c-macro-start c-macro-start
))
4476 (c-save-buffer-state ()
4477 (when (not (eq c-auto-fill-prefix t
))
4478 ;; Called from do-auto-fill.
4479 (unless c-lit-limits
4480 (setq c-lit-limits
(c-literal-limits nil nil t
)))
4482 (setq c-lit-type
(c-literal-type c-lit-limits
)))
4483 (if (memq (cond ((c-query-and-set-macro-start) 'cpp
)
4484 ((null c-lit-type
) 'code
)
4487 (setq fill-prefix t
) ; Used as flag in the cond.
4488 (if (and (null c-auto-fill-prefix
)
4490 (<= (c-point 'bol
) (car c-lit-limits
)))
4491 ;; The adaptive fill function has generated a prefix, but
4492 ;; we're on the first line in a block comment so it'll be
4493 ;; wrong. Ignore it to guess a better one below.
4494 (setq fill-prefix nil
)
4495 (when (and (eq c-lit-type
'c
++)
4496 (not (string-match (concat "\\`[ \t]*"
4497 c-line-comment-starter
)
4498 (or fill-prefix
""))))
4499 ;; Kludge: If the function that adapted the fill prefix
4500 ;; doesn't produce the required comment starter for line
4501 ;; comments, then we ignore it.
4502 (setq fill-prefix nil
)))
4505 (cond ((eq fill-prefix t
)
4506 ;; A call from do-auto-fill which should be ignored.
4509 ;; A fill-prefix overrides anything.
4510 (funcall do-line-break
)
4511 (insert-and-inherit fill-prefix
))
4512 ((c-save-buffer-state ()
4513 (unless c-lit-limits
4514 (setq c-lit-limits
(c-literal-limits)))
4516 (setq c-lit-type
(c-literal-type c-lit-limits
)))
4517 (memq c-lit-type
'(c c
++)))
4518 ;; Some sort of comment.
4519 (if (or comment-multi-line
4521 (goto-char (car c-lit-limits
))
4523 (< (point) (cdr c-lit-limits
))))
4524 ;; Inside a comment that should be continued.
4525 (let ((fill (c-save-buffer-state nil
4526 (c-guess-fill-prefix
4528 (c-collect-line-comments c-lit-limits
))
4531 (start-col (current-column))
4533 (or (and (eq c-lit-type
'c
)
4535 (goto-char (- (cdr c-lit-limits
) 2))
4536 (if (looking-at "\\*/") (point))))
4537 (cdr c-lit-limits
))))
4538 ;; Skip forward past the fill prefix in case
4539 ;; we're standing in it.
4541 ;; FIXME: This doesn't work well in cases like
4543 ;; /* Bla bla bla bla bla
4546 ;; If point is on the 'B' then the line will be
4547 ;; broken after "Bla b".
4549 ;; If we have an empty comment, /* */, the next
4550 ;; lot of code pushes point to the */. We fix
4551 ;; this by never allowing point to end up to the
4552 ;; right of where it started.
4553 (while (and (< (current-column) (cdr fill
))
4556 (if (and (> (point) comment-text-end
)
4557 (> (c-point 'bol
) (car c-lit-limits
)))
4559 ;; The skip takes us out of the (block)
4560 ;; comment; insert the fill prefix at bol
4561 ;; instead and keep the position.
4562 (setq pos
(copy-marker pos t
))
4564 (insert-and-inherit (car fill
))
4565 (if soft
(insert-and-inherit ?
\n) (newline 1))
4567 (set-marker pos nil
))
4568 ;; Don't break in the middle of a comment starter
4570 (cond ((> (point) comment-text-end
)
4571 (goto-char comment-text-end
))
4572 ((< (point) (+ (car c-lit-limits
) 2))
4573 (goto-char (+ (car c-lit-limits
) 2))))
4574 (funcall do-line-break
)
4575 (insert-and-inherit (car fill
))
4576 (if (> (current-column) start-col
)
4577 (move-to-column start-col
)))) ; can this hit the
4579 ;; Inside a comment that should be broken.
4580 (let ((comment-start comment-start
)
4581 (comment-end comment-end
)
4583 (if (eq c-lit-type
'c
)
4584 (unless (string-match "[ \t]*/\\*" comment-start
)
4585 (setq comment-start
"/* " comment-end
" */"))
4586 (unless (string-match "[ \t]*//" comment-start
)
4587 (setq comment-start
"// " comment-end
"")))
4588 (setq col
(save-excursion
4589 (back-to-indentation)
4591 (funcall do-line-break
)
4592 (when (and comment-end
(not (equal comment-end
"")))
4594 (insert-and-inherit comment-end
)
4596 ;; c-comment-indent may look at the current
4597 ;; indentation, so let's start out with the same
4598 ;; indentation as the previous one.
4600 (insert-and-inherit comment-start
)
4601 (indent-for-comment))))
4602 ((c-query-and-set-macro-start)
4604 (unless (looking-at "[ \t]*\\\\$")
4605 ;; Do not clobber the alignment of the line continuation
4606 ;; slash; c-backslash-region might look at it.
4607 (delete-horizontal-space))
4608 ;; Got an asymmetry here: In normal code this command
4609 ;; doesn't indent the next line syntactically, and otoh a
4610 ;; normal syntactically indenting newline doesn't continue
4612 (c-newline-and-indent (if allow-auto-fill nil
1)))
4614 ;; Somewhere else in the code.
4615 (let ((col (save-excursion
4617 (while (and (looking-at "[ \t]*\\\\?$")
4618 (= (forward-line -
1) 0)))
4619 (current-indentation))))
4620 (funcall do-line-break
)
4621 (indent-to col
))))))
4623 (defalias 'c-comment-line-break-function
'c-indent-new-comment-line
)
4624 (make-obsolete 'c-comment-line-break-function
'c-indent-new-comment-line
"21.1")
4626 ;; advice for indent-new-comment-line for older Emacsen
4627 (unless (boundp 'comment-line-break-function
)
4628 (defvar c-inside-line-break-advice nil
)
4629 (defadvice indent-new-comment-line
(around c-line-break-advice
4630 activate preactivate
)
4631 "Call `c-indent-new-comment-line' if in CC Mode."
4632 (if (or c-inside-line-break-advice
4633 (not c-buffer-is-cc-mode
))
4635 (let ((c-inside-line-break-advice t
))
4636 (c-indent-new-comment-line (ad-get-arg 0))))))
4638 (defun c-context-line-break ()
4639 "Do a line break suitable to the context.
4641 When point is outside a comment or macro, insert a newline and indent
4642 according to the syntactic context, unless `c-syntactic-indentation'
4643 is nil, in which case the new line is indented as the previous
4644 non-empty line instead.
4646 When point is inside the content of a preprocessor directive, a line
4647 continuation backslash is inserted before the line break and aligned
4648 appropriately. The end of the cpp directive doesn't count as inside
4651 When point is inside a comment, continue it with the appropriate
4652 comment prefix (see the `c-comment-prefix-regexp' and
4653 `c-block-comment-prefix' variables for details). The end of a
4654 C++-style line comment doesn't count as inside it.
4656 When point is inside a string, only insert a backslash when it is also
4657 inside a preprocessor directive."
4660 (let* (c-lit-limits c-lit-type
4661 (c-macro-start c-macro-start
)
4664 (c-save-buffer-state ()
4665 (setq c-lit-limits
(c-literal-limits nil nil t
)
4666 c-lit-type
(c-literal-type c-lit-limits
))
4667 (when (eq c-lit-type
'c
++)
4668 (setq c-lit-limits
(c-collect-line-comments c-lit-limits
)))
4669 (c-query-and-set-macro-start))
4672 ((or (eq c-lit-type
'c
)
4673 (and (eq c-lit-type
'c
++) ; C++ comment, but not at the very end of it.
4675 (skip-chars-forward " \t")
4677 (1- (cdr c-lit-limits
))))
4678 (and (numberp c-macro-start
) ; Macro, but not at the very end of
4679 ; it, not in a string, and not in the
4681 (not (eq c-lit-type
'string
))
4682 (or (not (looking-at "\\s *$"))
4683 (eq (char-before) ?
\\))
4685 (goto-char c-macro-start
)
4686 (if (looking-at c-opt-cpp-start
)
4687 (goto-char (match-end 0)))
4690 (let ((comment-multi-line t
)
4692 (c-indent-new-comment-line nil t
)))
4694 ((eq c-lit-type
'string
)
4695 (if (and (numberp c-macro-start
)
4696 (not (eq (char-before) ?
\\)))
4700 (t (delete-horizontal-space)
4702 ;; c-indent-line may look at the current indentation, so let's
4703 ;; start out with the same indentation as the previous line.
4704 (let ((col (save-excursion
4707 (while (and (looking-at "[ \t]*\\\\?$")
4708 (= (forward-line -
1) 0)))
4709 (current-indentation))))
4711 (indent-according-to-mode)))))
4713 (defun c-context-open-line ()
4714 "Insert a line break suitable to the context and leave point before it.
4715 This is the `c-context-line-break' equivalent to `open-line', which is
4716 normally bound to C-o. See `c-context-line-break' for the details."
4718 (let ((here (point)))
4721 ;; Temporarily insert a non-whitespace char to keep any
4722 ;; preceding whitespace intact.
4724 (c-context-line-break))
4729 (cc-provide 'cc-cmds
)
4731 ;;; cc-cmds.el ends here