| blob | 561e6767e120381f33624967764699dd289475d2 |
1 ;;; cc-cmds.el --- user level commands for CC Mode
3 ;; Copyright (C) 1985, 1987, 1992-2017 Free Software Foundation, Inc.
5 ;; Authors: 2003- Alan Mackenzie
6 ;; 1998- Martin Stjernholm
7 ;; 1992-1999 Barry A. Warsaw
8 ;; 1987 Dave Detlefs
9 ;; 1987 Stewart Clamen
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
14 ;; Package: cc-mode
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/>.
31 ;;; Commentary:
33 ;;; Code:
40 load-path)))
47 ;; Silence the compiler.
49 ; which looks at this.
50 \f
51 ;; Indentation / Display syntax functions
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)."
69 bs-col
70 shift-amt)
75 ;; Don't use "\\s " - ^L doesn't count as WS
76 ;; here
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
84 ;; at the end.
86 ;; Should try to keep the backslash alignment
87 ;; in this case.
99 c-syntactic-context))))
104 c-syntactic-context))
106 c-echo-syntactic-information-p
108 c-syntactic-context indent))
112 c-parsing-error)
113 c-parsing-error))
118 t
120 nil))))
129 ;; Realign the line continuation backslash.
131 shift-amt))
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
141 ;; kept intact.
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.
148 has-backslash insert-backslash
149 start col)
159 has-backslash t)
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.
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.
182 ;; Reindent syntactically. The indentation done above is not
183 ;; wasted, since c-indent-line might look at the current
184 ;; indentation.
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.
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.
208 "Show syntactic information for current line.
209 With universal argument, inserts the analysis as a comment on that line."
213 ;; Use `c-syntactic-context' in the same way as
214 ;; `c-indent-line', to be consistent.
215 c-syntactic-context
228 ols))
232 ols)))
238 ))
242 "Insert a comment with the syntactic analysis on every line in the region."
252 \f
253 ;; Minor mode functions.
261 ;; (cc-)subword might not be loaded.
264 ;; FIXME: subword-mode already comes with its
265 ;; own lighter!
266 "w"
268 ;; FIXME: Derived modes might want to use something else
269 ;; than a string for `mode-name'.
272 mode-name)))
273 ;; (setq c-submode-indicators
274 ;; (if (> (length fmt) 1)
275 ;; fmt))
279 bare-mode-name))
283 "Toggle syntactic indentation.
284 Optional numeric ARG, if supplied, turns on syntactic indentation when
285 positive, turns it off when negative, and just toggles it when zero or
286 left out.
288 When syntactic indentation is turned on (the default), the indentation
289 functions and the electric keys indent according to the syntactic
290 context keys, when applicable.
292 When it's turned off, the electric keys don't reindent, the indentation
293 functions indents every new line to the same level as the previous
295 specified by `c-basic-offset'. The indentation style has no effect in
296 this mode, nor any of the indentation associated variables,
297 e.g. `c-special-indent-hook'.
299 This command sets the variable `c-syntactic-indentation'."
306 "Toggle auto-newline feature.
307 Optional numeric ARG, if supplied, turns on auto-newline when
308 positive, turns it off when negative, and just toggles it when zero or
309 left out.
311 Turning on auto-newline automatically enables electric indentation.
314 mode line after the mode name) newlines are automatically inserted
315 after special characters such as brace, comma, semi-colon, and colon."
327 "Toggle hungry-delete-key feature.
328 Optional numeric ARG, if supplied, turns on hungry-delete when
329 positive, turns it off when negative, and just toggles it when zero or
330 left out.
333 the mode line after the mode name) the delete key gobbles all preceding
334 whitespace in one fell swoop."
341 "Toggle auto-newline and hungry-delete-key features.
342 Optional numeric ARG, if supplied, turns on auto-newline and
343 hungry-delete when positive, turns them off when negative, and just
344 toggles them when zero or left out.
346 See `c-toggle-auto-newline' and `c-toggle-hungry-state' for details."
354 "Toggle the electric indentation feature.
355 Optional numeric ARG, if supplied, turns on electric indentation when
356 positive, turns it off when negative, and just toggles it when zero or
357 left out."
365 \f
366 ;; Electric keys
369 "Delete the preceding character or whitespace.
371 line) then all preceding whitespace is consumed. If however a prefix
372 argument is supplied, or `c-hungry-delete-key' is nil, or point is
373 inside a literal then the function in the variable
374 `c-backspace-function' is called."
378 arg
384 "Delete the preceding character or all preceding whitespace
385 back to the previous non-whitespace character.
397 "Delete the following character or whitespace.
399 line) then all following whitespace is consumed. If however a prefix
400 argument is supplied, or `c-hungry-delete-key' is nil, or point is
401 inside a literal then the function in the variable `c-delete-function'
402 is called."
406 arg
412 "Delete the following character or all following whitespace
413 up to the next non-whitespace character.
422 ;; This function is only used in XEmacs.
424 "Deletes preceding or following character or whitespace.
425 This function either deletes forward as `c-electric-delete-forward' or
426 backward as `c-electric-backspace', depending on the configuration: If
427 the function `delete-forward-p' is defined and returns non-nil, it
428 deletes forward. Otherwise it deletes backward.
430 Note: This is the way in XEmacs to choose the correct action for the
431 [delete] key, whichever key that means. Other flavors don't use this
432 function to control that."
439 ;; This function is only used in XEmacs.
441 "Delete a non-whitespace char, or all whitespace up to the next non-whitespace char.
442 The direction of deletion depends on the configuration: If the
443 function `delete-forward-p' is defined and returns non-nil, it deletes
444 forward using `c-hungry-delete-forward'. Otherwise it deletes
445 backward using `c-hungry-backspace'.
447 Note: This is the way in XEmacs to choose the correct action for the
448 [delete] key, whichever key that means. Other flavors don't use this
449 function to control that."
458 If `c-electric-flag' is set, handle it specially according to the variable
459 `c-electric-pound-behavior'. If a numeric ARG is supplied, or if point is
460 inside a literal or a macro, nothing special happens."
474 ;; do nothing special
476 ;; place the pound character at the left edge
484 )))
487 ;; Return the syntactic context of the construct at point. (This is NOT
488 ;; nec. the same as the s.c. of the line point is on). N.B. This won't work
489 ;; between the `#' of a cpp thing and what follows (see c-opt-cpp-prefix).
492 syntax)
494 ;; insert a newline to isolate the construct at point for syntactic
495 ;; analysis.
497 ;; In AWK (etc.) or in a macro, make sure this CR hasn't changed
498 ;; the syntax. (There might already be an escaped NL there.)
514 ;; Turn on syntactic macro analysis to help with auto
515 ;; newlines only.
517 nil))
518 syntax))
521 ;; A brace stands at point. SYNTAX is the syntactic context of this brace
522 ;; (not necessarily the same as the S.C. of the line it is on). Return
523 ;; NEWLINES, the list containing some combination of the symbols `before'
524 ;; and `after' saying where newlines should be inserted.
527 ;; This is the list of brace syntactic symbols that can hang.
528 ;; If any new ones are added to c-offsets-alist, they should be
529 ;; added here as well.
530 ;;
531 ;; The order of this list is important; if SYNTAX has several
532 ;; elements, the element that "wins" is the earliest in SYMS.
534 class-open class-close defun-open defun-close
535 inline-open inline-close
536 brace-list-open brace-list-close
537 brace-list-intro brace-entry-open
538 block-open block-close
539 substatement-open statement-case-open
540 extern-lang-open extern-lang-close
541 namespace-open namespace-close
542 module-open module-close
543 composition-open composition-close
544 inexpr-class-open inexpr-class-close
545 ;; `statement-cont' is here for the case with a brace
546 ;; list opener inside a statement. C.f. CASE B.2 in
547 ;; `c-guess-continued-construct'.
548 statement-cont))
549 ;; shut this up too
554 ;; Do not try to insert newlines around a special
555 ;; (Pike-style) brace list.
562 nil
563 ;; Seek the matching entry in c-hanging-braces-alist.
565 syms
566 ;; Substitute inexpr-class and class-open or
567 ;; class-close with inexpr-class-open or
568 ;; inexpr-class-close.
575 syntax)
576 c-hanging-braces-alist)
579 ;; If syntax is a function symbol, then call it using the
580 ;; defined semantics.
590 ;; Point is just after a newly inserted }. If the non-whitespace
591 ;; content of the braces is a single line of code, compact the whole
592 ;; construct to a single line, if this line isn't too long. The Right
593 ;; Thing is done with comments.
594 ;;
595 ;; Point will be left after the }, regardless of whether the clean-up is
596 ;; done. Return NON-NIL if the clean-up happened, NIL if it didn't.
600 mbeg1 mend1 mbeg4 mend4
601 eol-col cmnt-pos cmnt-col cmnt-gap)
606 ;; Avoid backtracking over a very large block. The one we
607 ;; deal with here can never be more than three lines.
638 ;; Necessary to put the closing brace before any line
639 ;; oriented comment to keep it syntactically significant.
640 ;; This isn't necessary for block comments, but the result
641 ;; looks nicer anyway.
657 ;; Can we trim space before comment to make the line fit?
663 t))))
667 "Insert a brace.
669 If `c-electric-flag' is non-nil, the brace is not inside a literal and a
670 numeric ARG hasn't been supplied, the command performs several electric
671 actions:
674 the mode line) newlines are inserted before and after the brace as
675 directed by the settings in `c-hanging-braces-alist'.
677 \(b) Any auto-newlines are indented. The original line is also
678 reindented unless `c-syntactic-indentation' is nil.
680 \(c) If auto-newline is turned on, various newline cleanups based on the
681 settings of `c-cleanup-list' are done."
685 ;; We want to inhibit blinking the paren since this would be
686 ;; most disruptive. We'll blink it ourselves later on.
688 blink-paren-function case-fold-search)
694 ;; Insert the brace. Note that expand-abbrev might reindent
695 ;; the line here if there's a preceding "else" or something.
705 newlines
707 ; of the brace itself, of the line the brace ends up on.
719 ;; Insert the BEFORE newline, if wanted, and reindent the newline.
723 ;; Only a plain newline for now - it's indented
724 ;; after the cleanups when the line has its final
725 ;; appearance.
730 ;; `syntax' is the syntactic context of the line which ends up
731 ;; with the brace on it.
734 ;; Do all appropriate clean ups
737 mbeg mend
738 )
740 ;; `}': clean up empty defun braces
745 syntax)
750 ;; make sure matching open brace isn't in a comment
756 ;; `}': compact to a one-liner defun?
765 ;; `{': clean up brace-else-brace and brace-elseif-brace
772 "else"
774 "{"
776 nil t))
788 ; (progn
789 ; (setq tmp (point))
793 "else"
795 "if"
799 ;(eq (match-end 0) tmp);
800 )
807 ;; Indent the line after the cleanups since it might
808 ;; very well indent differently due to them, e.g. if
809 ;; c-indent-one-line-block is used together with the
810 ;; one-liner-defun cleanup.
814 ;; does a newline go after the brace?
817 ))))
819 ;; blink the paren
822 old-blink-paren
829 "Insert a slash character.
831 If the slash is inserted immediately after the comment prefix in a c-style
832 comment, the comment might get closed by removing whitespace and possibly
835 Indent the line as a comment, if:
838 token and we are on a comment-only-line, or
841 comment.
843 If a numeric ARG is supplied, point is inside a literal, or
844 `c-syntactic-indentation' is nil or `c-electric-flag' is nil, indentation
845 is inhibited."
848 indentp
849 ;; shut this up
852 ;; comment-close-slash cleanup? This DOESN'T need `c-electric-flag' or
853 ;; `c-syntactic-indentation' set.
860 ; (eq c-block-comment-ender "*/") ; C-style comments ALWAYS end in */
871 c-syntactic-indentation
872 c-electric-flag
880 "Insert a star character.
881 If `c-electric-flag' and `c-syntactic-indentation' are both non-nil, and
882 the star is the second character of a C style comment starter on a
883 comment-only-line, indent the line as a comment. If a numeric ARG is
884 supplied, point is inside a literal, or `c-syntactic-indentation' is nil,
885 this indentation is inhibited."
889 ;; if we are in a literal, or if arg is given do not reindent the
890 ;; current line, unless this star introduces a comment-only line.
893 c-electric-flag
906 ))
909 "Insert a comma or semicolon.
911 If `c-electric-flag' is non-nil, point isn't inside a literal and a
912 numeric ARG hasn't been supplied, the command performs several electric
913 actions:
916 the mode line) a newline might be inserted. See the variable
917 `c-hanging-semi&comma-criteria' for how newline insertion is determined.
919 \(b) Any auto-newlines are indented. The original line is also
920 reindented unless `c-syntactic-indentation' is nil.
922 \(c) If auto-newline is turned on, a comma following a brace list or a
923 semicolon following a defun might be cleaned up, depending on the
924 settings of `c-cleanup-list'."
928 ;; shut this up
938 ;; do all cleanups and newline insertions if c-auto-newline is on.
943 ;; clean ups: list-close-comma or defun-close-semi
956 ;; make sure matching open brace isn't in a comment
960 ;; reindent line
964 ;; check to see if a newline should be added
966 answer add-newline-p)
969 ;; only nil value means continue checking
973 ;; only 'stop specifically says do not add a newline
975 ))
978 )))))
981 "Insert a colon.
983 If `c-electric-flag' is non-nil, the colon is not inside a literal and a
984 numeric ARG hasn't been supplied, the command performs several electric
985 actions:
988 the mode line) newlines are inserted before and after the colon based on
989 the settings in `c-hanging-colons-alist'.
991 \(b) Any auto-newlines are indented. The original line is also
992 reindented unless `c-syntactic-indentation' is nil.
994 \(c) If auto-newline is turned on, whitespace between two colons will be
996 `c-cleanup-list'."
1001 newlines is-scope-op
1002 ;; shut this up
1005 ;; Any electric action?
1007 ;; Unless we're at EOL, only re-indentation happens.
1012 ;; scope-operator clean-up?
1030 ;; indent the current line if it's done syntactically.
1032 ;; Cannot use the same syntax analysis as we find below,
1033 ;; since that's made with c-syntactic-indentation-in-macros
1034 ;; always set to t.
1037 ;; Calculate where, if anywhere, we want newlines.
1041 ;; Turn on syntactic macro analysis to help with auto newlines
1042 ;; only.
1045 ;; Translate substatement-label to label for this operation.
1050 ;; some language elements can only be determined by checking
1051 ;; the following line. Let's first look for ones that can be
1052 ;; found when looking on the line with the colon
1056 syntax c-hanging-colons-alist)
1063 c-hanging-colons-alist)))))
1064 ;; does a newline go before the colon? Watch out for already
1065 ;; non-hung colons. However, we don't unhang them because that
1066 ;; would be a cleanup (and anti-social).
1076 ;; does a newline go after the colon?
1080 ))))
1084 If the current language uses angle bracket parens (e.g. template
1085 arguments in C++), try to find out if the inserted character is a
1086 paren and give it paren syntax if appropriate.
1088 If `c-electric-flag' and `c-syntactic-indentation' are both non-nil, the
1089 line will be reindented if the inserted character is a paren or if it
1090 finishes a C++ style stream operator in C++ mode. Exceptions are when a
1091 numeric argument is supplied, or the point is inside a literal."
1095 final-pos found-delim case-fold-search)
1100 ;;;; 2010-01-31: There used to be code here to put a syntax-table text
1101 ;;;; property on the new < or > and its mate (if any) when they are template
1102 ;;;; parens. This is now done in an after-change function.
1104 ;; Indent the line if appropriate.
1108 ;; If a <, basically see if it's got "template" before it .....
1116 ;; ..... or is a C++ << operator.
1124 ;; It's a >. Either a template/generic terminator ...
1126 ;; or a C++ >> operator.
1139 blink-paren-function)
1140 ;; From now (2016-01-01), the syntax-table text properties on < and >
1141 ;; are applied in an after-change function, not during redisplay. Hence
1142 ;; we no longer need to call (sit-for 0) for blink paren to work.
1146 "Insert a parenthesis.
1148 If `c-syntactic-indentation' and `c-electric-flag' are both non-nil, the
1149 line is reindented unless a numeric ARG is supplied, or the parenthesis
1150 is inserted inside a literal.
1152 Whitespace between a function name and the parenthesis may get added or
1153 removed; see the variable `c-cleanup-list'.
1155 Also, if `c-electric-flag' and `c-auto-newline' are both non-nil, some
1156 newline cleanups are done if appropriate; see the variable `c-cleanup-list'."
1159 ;; shut this up
1161 case-fold-search)
1166 ;; be most disruptive. We'll blink it ourselves
1167 ;; afterwards.
1169 blink-paren-function)
1173 ;; If we're at EOL, check for new-line clean-ups.
1177 ;; clean up brace-elseif-brace
1184 "else"
1186 "if"
1188 "("
1190 nil t)
1195 ;; clean up brace-catch-brace
1202 "catch"
1204 "("
1206 nil t)
1211 ;; Check for clean-ups at function calls. These two DON'T need
1212 ;; `c-electric-flag' or `c-syntactic-indentation' set.
1213 ;; Point is currently just after the inserted paren.
1217 ;; space-before-funcall clean-up?
1225 ;; Don't add a space into #define FOO()....
1234 ;; compact-empty-funcall clean-up?
1248 old-blink-paren
1252 "Reindent the current line if appropriate.
1254 This function is used to reindent the line after a keyword which
1258 The line is reindented if there is nothing but whitespace before the
1259 keyword on the line, the keyword is not inserted inside a literal, and
1260 `c-electric-flag' and `c-syntactic-indentation' are both non-nil."
1265 c-syntactic-indentation
1272 ;; Have to temporarily insert a space so that
1273 ;; c-guess-basic-syntax recognizes the keyword. Follow the
1274 ;; space with a nonspace to avoid messing up any whitespace
1275 ;; sensitive meddling that might be done, e.g. by
1276 ;; `c-backslash-region'.
1282 \f
1289 ;; Recent Emacsen come with their own subword support. Use that.
1293 ;; Autoload directive for emacsen that doesn't have an older CC Mode
1294 ;; version in the dist.
1301 ;; "nomenclature" functions + c-scope-operator.
1303 "Compatibility alias for `c-forward-subword'."
1316 "Compatibility alias for `c-backward-subword'."
1325 'c-backward-into-nomenclature
1329 "Insert a double colon scope operator at point.
1334 \f
1335 ;; Movement (etc.) by defuns.
1337 ;; Return non-nil if point is between the closing brace and the semicolon of
1338 ;; a brace construct which needs a semicolon, e.g. within the "variables"
1339 ;; portion of a declaration like "struct foo {...} bar ;".
1340 ;;
1341 ;; Return the position of the main declaration. Otherwise, return nil.
1342 ;; Point is assumed to be at the top level and outside of any macro or
1343 ;; literal.
1344 ;;
1345 ;; If LIM is non-nil, it is the bound on a the backward search for the
1346 ;; beginning of the declaration.
1347 ;;
1348 ;; This function might do hidden buffer changes.
1353 bod)
1357 ;; Look for struct or union or ... If we find one, it might
1358 ;; be the return type of a function, or the like. Exclude
1359 ;; this case.
1362 c-opt-block-decls-with-vars-key
1364 eo-block t t t)
1369 bod)))))
1372 ;; Determine where we are with respect to functions (or other brace
1373 ;; constructs, included in the term "function" in the rest of this comment).
1374 ;; Point is assumed to be outside any macro or literal.
1375 ;; This is used by c-\(beginning\|end\)-of-defun.
1376 ;;
1377 ;; Return one of these symbols:
1378 ;; at-header : we're at the start of a function's header.
1379 ;; in-header : we're inside a function's header, this extending right
1380 ;; up to the brace. This bit includes any k&r declarations.
1381 ;; in-block : we're inside a function's brace block.
1382 ;; in-trailer : we're in the area between the "}" and ";" of something
1383 ;; like "struct foo {...} bar, baz;".
1384 ;; at-function-end : we're just after the closing brace (or semicolon) that
1385 ;; terminates the function.
1386 ;; outwith-function: we're not at or in any function. Being inside a
1387 ;; non-brace construct also counts as 'outwith-function'.
1388 ;;
1389 ;; This function might do hidden buffer changes.
1392 decl-result brace-decl-p
1409 ;; Find the start of the current declaration. NOTE: If we're in the
1410 ;; variables after a "struct/eval" type block, we don't get to the
1411 ;; real declaration here - we detect and correct for this later.
1413 ;;If we're in the parameters' parens, move back out of them.
1415 ;; Kluge so that c-beginning-of-decl-1 won't go back if we're already
1416 ;; at a declaration.
1424 ;; NOTE: If we're in a K&R region, this might be the start
1425 ;; of a parameter declaration, not the actual function.
1426 ;; It might also leave us at a label or "label" like
1427 ;; "private:".
1431 ;; Has the declaration we've gone back to got braces?
1438 ;; Might have stopped on the
1439 ;; ';' in a K&R argdecl. In
1440 ;; that case the declaration
1441 ;; should contain a block.
1451 'at-header
1457 'at-function-end
1460 "c-where-wrt-brace-construct: c-beginning-of-decl-1 returned %s"
1461 decl-result))))))))
1464 ;; Skip to the opening brace of the Nth function before point. If
1465 ;; point is inside a function, this counts as the first. Point must be
1466 ;; outside any comment/string or macro.
1467 ;;
1468 ;; N must be strictly positive.
1469 ;; WHERE describes the position of point, one of the symbols `at-header',
1470 ;; `in-header', `in-block', `in-trailer', `at-function-end',
1471 ;; `outwith-function' as returned by c-where-wrt-brace-construct.
1472 ;;
1473 ;; If we run out of functions, leave point at BOB. Return zero on success,
1474 ;; otherwise the number of {s still to go.
1475 ;;
1476 ;; This function may do hidden buffer changes
1478 ;; What we do to go back the first defun depends on where we start.
1494 ;; Each time round the loop, go back to a "{" at the outermost level.
1497 ; by a factor of ~6. Hmmm. 2006/4/5.
1502 n)
1505 ;; If we are inside a decl-block (in the sense of c-looking-at-decl-block),
1506 ;; i.e. something like namespace{} or extern{}, narrow to the insides of
1507 ;; that block (NOT including the enclosing braces) if INCLUSIVE is nil,
1508 ;; otherwise include the braces and the declaration which introduces them.
1509 ;; If the closing brace is missing, (point-max) is used instead. LEVEL, if
1510 ;; non-nil, says narrow to the LEVELth decl-block outward, default value
1511 ;; being 1.
1513 encl-decl)
1539 ;; Narrow the buffer to the innermost declaration scope (e.g. a class, a
1540 ;; namespace or the "whole buffer") recorded in PAREN-STATE, the bounding
1541 ;; braces NOT being included in the resulting region. On no account may the
1542 ;; final region exceed that bounded by ORIG-POINT-MIN, ORIG-POINT-MAX.
1543 ;; PAREN-STATE is a list of buffer positions in the style of
1544 ;; (c-parse-state), one of which will be that of the desired opening brace,
1545 ;; if there is one.
1546 ;;
1547 ;; Return the position of the enclosing opening brace, or nil
1561 orig-point-max)))
1562 encl-decl)
1564 nil)))
1568 ;; Repeatedly evaluate CONDITION until it returns nil. After each
1569 ;; evaluation, if `c-defun-tactic' is set appropriately, widen to innards
1570 ;; of the next enclosing declaration block (e.g. namespace, class), or the
1571 ;; buffer's original restriction.
1572 ;;
1573 ;; This is a very special purpose macro, which assumes the existence of
1574 ;; several variables. It is for use only in c-beginning-of-defun and
1575 ;; c-end-of-defun.
1579 lim)
1582 paren-state orig-point-min orig-point-max))
1586 "Move backward to the beginning of a defun.
1587 Every top level declaration that contains a brace paren block is
1588 considered to be a defun.
1590 With a positive argument, move backward that many defuns. A negative
1591 argument -N means move forward to the Nth following beginning. Return
1592 t unless search stops due to beginning or end of buffer.
1594 Unlike the built-in `beginning-of-defun' this tries to be smarter
1595 about finding the char with open-parenthesis syntax that starts the
1596 defun."
1608 end-of-defun-function
1612 lim ; Position of { which has been widened to.
1613 where pos case-fold-search)
1618 paren-state orig-point-min orig-point-max)))
1620 ;; Move back out of any macro/comment/string we happen to be in.
1628 ;; Move forward to the closing brace of a function.
1635 ;; Move forward to the next opening brace....
1642 ;; ... and backward to the function header.
1644 t))
1646 ;; Move backward to the opening brace of a function, making successively
1647 ;; larger portions of the buffer visible as necessary.
1653 ;; Go backward to this function's header.
1657 ;; We're now there, modulo comments and whitespace.
1658 ;; Try to be line oriented; position point at the closest
1659 ;; preceding boi that isn't inside a comment, but if we hit
1660 ;; the previous declaration then we use the current point
1661 ;; instead.
1671 ;; Skip to the closing brace of the Nth function after point. If
1672 ;; point is inside a function, this counts as the first. Point must be
1673 ;; outside any comment/string or macro.
1674 ;;
1675 ;; N must be strictly positive.
1676 ;; WHERE describes the position of point, one of the symbols `at-header',
1677 ;; `in-header', `in-block', `in-trailer', `at-function-end',
1678 ;; `outwith-function' as returned by c-where-wrt-brace-construct.
1679 ;;
1680 ;; If we run out of functions, leave point at EOB. Return zero on success,
1681 ;; otherwise the number of }s still to go.
1682 ;;
1683 ;; This function may do hidden buffer changes.
1686 ;; What we do to go forward over the first defun depends on where we
1687 ;; start. We go to the closing brace of that defun, even when we go
1688 ;; backwards to it (in a "struct foo {...} bar ;").
1704 ;; Each time round the loop, go forward to a "}" at the outermost level.
1706 ;(c-parse-state) ; This call speeds up the following one by a factor
1707 ; of ~6. Hmmm. 2006/4/5.
1712 n)
1715 "Move forward to the end of a top level declaration.
1716 With argument, do it that many times. Negative argument -N means move
1717 back to Nth preceding end. Returns t unless search stops due to
1718 beginning or end of buffer.
1720 An end of a defun occurs right after the close-parenthesis that matches
1721 the open-parenthesis that starts a defun; see `beginning-of-defun'."
1732 end-of-defun-function
1736 lim
1737 where pos case-fold-search)
1742 paren-state orig-point-min orig-point-max)))
1744 ;; Move back out of any macro/comment/string we happen to be in.
1752 ;; Move backwards to the } of a function
1764 ;; Move forward to the } of a function
1769 ;; Do we need to move forward from the brace to the semicolon?
1775 ;; We're there now, modulo comments and whitespace.
1776 ;; Try to be line oriented; position point after the next
1777 ;; newline that isn't inside a comment, but if we hit the
1778 ;; next declaration then we use the current point instead.
1792 "Return the name of the current defun, or NIL if there isn't one.
1794 with a brace block."
1798 where pos name-end case-fold-search)
1803 ;; Move back out of any macro/comment/string we happen to be in.
1810 ;; Move to the beginning of the current defun, if any, if we're not
1811 ;; already there.
1813 nil
1818 ;; Pick out the defun name, according to the type of defun.
1820 ;; struct, union, enum, or similar:
1832 ;; DEFUN ("file-name-directory", Ffile_name_directory, Sfile_name_directory, ...) ==> Ffile_name_directory
1833 ;; DEFUN(POSIX::STREAM-LOCK, stream lockp &key BLOCK SHARED START LENGTH) ==> POSIX::STREAM-LOCK
1849 ;; DEFCHECKER(sysconf_arg,prefix=_SC,default=, ...) ==> sysconf_arg
1850 ;; DEFFLAGSET(syslog_opt_flags,LOG_PID ...) ==> syslog_opt_flags
1853 ;; Objc selectors.
1865 ;; Normal function or initializer.
1877 ;; Return a cons of the beginning and end positions of the current
1878 ;; top level declaration or macro. If point is not inside any then
1879 ;; nil is returned, unless NEAR is non-nil in which case the closest
1880 ;; following one is chosen instead (if there is any). The end
1881 ;; position is at the next line, providing there is one before the
1882 ;; declaration.
1883 ;;
1884 ;; This function might do hidden buffer changes.
1889 lim pos end-pos encl-decl-block where)
1890 ;; Narrow enclosing brace blocks out, as required by the values of
1891 ;; `c-defun-tactic', `near', and the position of point.
1908 ;; Note: Some code duplication in `c-beginning-of-defun' and
1909 ;; `c-end-of-defun'.
1913 ;; If we moved to the outermost enclosing paren
1914 ;; then we can use c-safe-position to set the
1915 ;; limit. Can't do that otherwise since the
1916 ;; earlier paren pair on paren-state might very
1917 ;; well be part of the declaration we should go
1918 ;; to.
1920 t)
1921 ;; At top level. Make sure we aren't inside a literal.
1943 ;; We moved back over the previous defun. Skip to the next
1944 ;; one. Not using c-forward-syntactic-ws here since we
1945 ;; should not skip a macro. We can also be directly after
1946 ;; the block in a `c-opt-block-decls-with-vars-key'
1947 ;; declaration, but then we won't move significantly far
1948 ;; here.
1962 ;; Check if `c-beginning-of-decl-1' put us after the block in a
1963 ;; declaration that doesn't end there. We're searching back and
1964 ;; forth over the block here, which can be expensive.
1976 nil
1980 nil
1982 ;; Try to be line oriented; position the limits at the
1983 ;; closest preceding boi, and after the next newline, that
1984 ;; isn't inside a comment, but if we hit a neighboring
1985 ;; declaration then we instead use the exact declaration
1986 ;; limit in that direction.
1992 pos
2008 pos))))))
2016 "Put mark at end of the current top-level declaration or macro, point at beginning.
2017 If point is not inside any then the closest following one is
2018 chosen. Each successive call of this command extends the marked
2019 region by one function.
2021 A mark is left where the command started, unless the region is already active
2022 \(in Transient Mark mode).
2025 function does not require the declaration to contain a brace block."
2030 ;; We try to be line oriented, unless there are several
2031 ;; declarations on the same line.
2058 "Return the name of the current CPP macro, or NIL if we're not in one."
2067 \f
2068 ;; Movement by statements.
2070 ;; Point is within a comment. Is it also within a comment-prefix?
2071 ;; Space at BOL which precedes a comment-prefix counts as part of it.
2072 ;;
2073 ;; This function might do hidden buffer changes.
2083 ;; Narrow to the "inside" of the comment (block) defined by range, as
2084 ;; follows:
2085 ;;
2086 ;; A c-style block comment has its opening "/*" and its closing "*/" (if
2087 ;; present) removed. A c++-style line comment retains its opening "//" but
2088 ;; has any final NL removed. If POINT is currently outwith these innards,
2089 ;; move it to the appropriate boundary.
2090 ;;
2091 ;; This narrowing simplifies the sentence movement functions, since it
2092 ;; eliminates awkward things at the boundaries of the comment (block).
2093 ;;
2094 ;; This function might do hidden buffer changes.
2112 ;; Move backwards to the "beginning of a sentence" within the comment
2113 ;; defined by RANGE, a cons of its starting and ending positions. If we
2114 ;; find a BOS, return NIL. Otherwise, move point to just before the start
2115 ;; of the comment and return T.
2116 ;;
2117 ;; The BOS is either text which follows a regexp match of sentence-end,
2118 ;; or text which is a beginning of "paragraph".
2119 ;; Comment-prefixes are treated like WS when calculating BOSes or BOPs.
2120 ;;
2121 ;; This code was adapted from GNU Emacs's forward-sentence in paragraphs.el.
2122 ;; It is not a general function, but is intended only for calling from
2123 ;; c-move-over-sentence. Not all preconditions have been explicitly stated.
2124 ;;
2125 ;; This function might do hidden buffer changes.
2131 last
2137 ;; First, find the previous paragraph start, if any.
2141 ; paragraph-\(start\|separate\)
2150 ;; Now seek successively earlier sentence ends between PAR-BEG and
2151 ;; HERE, until the "start of sentence" following it is earlier than
2152 ;; HERE, or we hit PAR-BEG. Beware of comment prefixes!
2170 nil
2172 t))))
2175 ;; Move forward to the "end of a sentence" within the comment defined by
2176 ;; RANGE, a cons of its starting and ending positions (enclosing the opening
2177 ;; comment delimiter and the terminating */ or newline). If we find an EOS,
2178 ;; return NIL. Otherwise, move point to just after the end of the comment
2179 ;; and return T.
2180 ;;
2181 ;; The EOS is just after the non-WS part of the next match of the regexp
2182 ;; sentence-end. Typically, this is just after one of [.!?]. If there is
2183 ;; no sentence-end match following point, any WS before the end of the
2184 ;; comment will count as EOS, providing we're not already in it.
2185 ;;
2186 ;; This code was adapted from GNU Emacs's forward-sentence in paragraphs.el.
2187 ;; It is not a general function, but is intended only for calling from
2188 ;; c-move-over-sentence.
2189 ;;
2190 ;; This function might do hidden buffer changes.
2193 ;; (lit-type (c-literal-type range)) ; Commented out, 2005/11/23, ACM
2194 )
2200 ;; The cc-mode values of paragraph-\(start\|separate\), set
2201 ;; in c-setup-paragraph-variables, are used in the
2202 ;; following.
2211 last
2214 ;; Go forward one "comment-prefix which looks like sentence-end"
2215 ;; each time round the following:
2226 ;; Take special action if we're up against the end of a comment (of
2227 ;; either sort): Leave point just after the last non-ws text.
2234 nil
2236 t))))
2239 ;; Move backwards to the "beginning of a sentence" within the string defined
2240 ;; by RANGE, a cons of its starting and ending positions (enclosing the
2241 ;; string quotes). If we find a BOS, return NIL. Otherwise, move point to
2242 ;; just before the start of the string and return T.
2243 ;;
2244 ;; The BOS is either the text which follows a regexp match of sentence-end
2245 ;; or text which is a beginning of "paragraph". For the purposes of
2246 ;; determining paragraph boundaries, escaped newlines are treated as
2247 ;; ordinary newlines.
2248 ;;
2249 ;; This code was adapted from GNU Emacs's forward-sentence in paragraphs.el.
2250 ;; It is not a general function, but is intended only for calling from
2251 ;; c-move-over-sentence.
2252 ;;
2253 ;; This function might do hidden buffer changes.
2259 ;; Enhance paragraph-start and paragraph-separate also to recognize
2260 ;; blank lines terminated by escaped EOLs. IT MAY WELL BE that
2261 ;; these values should be customizable user options, or something.
2270 ; paragraph-\(start\|separate\)
2278 ;; Now see if we can find a sentence end after PAR-BEG.
2286 ; than here, in case point starts
2287 ; beyond the closing quote.
2292 nil
2294 t))))
2297 ;; Move forward to the "end of a sentence" within the string defined by
2298 ;; RANGE, a cons of its starting and ending positions. If we find an EOS,
2299 ;; return NIL. Otherwise, move point to just after the end of the string
2300 ;; and return T.
2301 ;;
2302 ;; The EOS is just after the non-WS part of the next match of the regexp
2303 ;; sentence-end. Typically, this is just after one of [.!?]. If there is
2304 ;; no sentence-end match following point, any WS before the end of the
2305 ;; string will count as EOS, providing we're not already in it.
2306 ;;
2307 ;; This code was adapted from GNU Emacs's forward-sentence in paragraphs.el.
2308 ;; It is not a general function, but is intended only for calling from
2309 ;; c-move-over-sentence.
2310 ;;
2311 ;; This function might do hidden buffer changes.
2314 last
2315 ;; Enhance paragraph-start and paragraph-separate to recognize
2316 ;; blank lines terminated by escaped EOLs.
2324 ;; The above values of paragraph-\(start\|separate\) are used
2325 ;; in the following.
2328 ;; (re-search-backward filler-here nil t) would find an empty
2329 ;; string. Therefore we simulate it by the following:
2338 ;; Try to go forward a sentence.
2343 ;; Did we move a sentence, or did we hit the end of the string?
2345 nil
2347 t))))
2350 ;; Point is not in a literal (i.e. comment or string (include AWK regexp)).
2351 ;; If a literal is the next thing (aside from whitespace) to be found before
2352 ;; point, return a cons of its start.end positions (enclosing the
2353 ;; delimiters). Otherwise return NIL.
2354 ;;
2355 ;; This function might do hidden buffer changes.
2359 pos)
2363 ;; to prevent `looking-at' seeing a " at point.
2367 ;; An EOL can act as an "open string" terminator in AWK.
2378 ;; Point is not in a literal (i.e. comment or string (include AWK regexp)).
2379 ;; If a literal is the next thing (aside from whitespace) following point,
2380 ;; return a cons of its start.end positions (enclosing the delimiters).
2381 ;; Otherwise return NIL.
2382 ;;
2383 ;; This function might do hidden buffer changes.
2396 ;; Does point immediately follow a statement "terminator"? A virtual
2397 ;; semicolon is regarded here as such. So is an opening brace ;-)
2398 ;;
2399 ;; This function might do hidden buffer changes.
2407 ;; The following (for macros) is not strict about exactly where we are
2408 ;; wrt white space at the end of the macro. Doesn't seem to matter too
2409 ;; much. ACM 2004/3/29.
2421 ;; Move backwards over code which isn't a literal (i.e. comment or string),
2422 ;; stopping before reaching BOB or a literal or the boundary of a
2423 ;; preprocessor statement or the "beginning of a statement". MACRO-START is
2424 ;; the position of the '#' beginning the current preprocessor directive, or
2425 ;; NIL if we're not in such.
2426 ;;
2427 ;; Return a cons (A.B), where
2428 ;; A is NIL if we moved back to a BOS (and know it), T otherwise (we
2429 ;; didn't move, or we hit a literal, or we're not sure about BOS).
2430 ;; B is MACRO-BOUNDARY if we are about to cross the boundary out of or
2431 ;; into a macro, otherwise LITERAL if we've hit a literal, otherwise NIL
2432 ;;
2433 ;; The total collection of returned values is as follows:
2434 ;; (nil . nil): Found a BOS whilst remaining inside the illiterals.
2435 ;; (t . literal): No BOS found: only a comment/string. We _might_ be at
2436 ;; a BOS - the caller must check this.
2437 ;; (nil . macro-boundary): only happens with non-nil macro-start. We've
2438 ;; moved and reached the opening # of the macro.
2439 ;; (t . macro-boundary): Every other circumstance in which we're at a
2440 ;; macro-boundary. We might be at a BOS.
2441 ;;
2442 ;; Point is left either at the beginning-of-statement, or at the last non-ws
2443 ;; code before encountering the literal/BOB or macro-boundary.
2444 ;;
2445 ;; Note that this function moves within either preprocessor commands
2446 ;; (macros) or normal code, but will not cross a boundary between the two,
2447 ;; or between two distinct preprocessor commands.
2448 ;;
2449 ;; Stop before `{' and after `;', `{', `}' and `};' when not followed by `}'
2450 ;; or `)', but on the other side of the syntactic ws. Move by sexps and
2451 ;; move into parens. Also stop before `#' when it's at boi on a line.
2452 ;;
2453 ;; This function might do hidden buffer changes.
2457 ; semicolon precedes it.
2462 ;; Stop at the token after a comment.
2467 ;; If we've gone back over a LF, we might have moved into or out of
2468 ;; a preprocessor line.
2476 ;; Return a car of NIL ONLY if we've hit the opening # of a macro.
2481 ;; Have we found a virtual semicolon? If so, stop, unless the next
2482 ;; statement is where we started from.
2489 ;; Hit the beginning of the buffer/region?
2495 ;; Move back a character.
2498 ;; Stop at "{" (unless it's a PIKE special brace list.)
2507 ;; Have we reached the start of a macro? This always counts as
2508 ;; BOS. (N.B. I don't think (eq (point) here) can ever be true
2509 ;; here. FIXME!!! ACM 2004/3/29)
2513 ;; Stop at token just after "}" or ";".
2515 ;; If we've gone back over ;, {, or }, we're done.
2524 ;; Stop at the token after a string.
2529 ;; Nothing special: go back word characters.
2531 ))))))
2534 ;; Move forwards over code, stopping before reaching EOB or a literal
2535 ;; (i.e. a comment/string) or the boundary of a preprocessor statement or
2536 ;; the "end of a statement". MACRO-END is the position of the EOL/EOB which
2537 ;; terminates the current preprocessor directive, or NIL if we're not in
2538 ;; such.
2539 ;;
2540 ;; ALLOW-EARLY-STOP is non-nil if it is permissible to return without moving
2541 ;; forward at all, should we encounter a `{'. This is an ugly kludge, but
2542 ;; seems unavoidable. Depending on the context this function is called
2543 ;; from, we _sometimes_ need to stop there. Currently (2004/4/3),
2544 ;; ALLOW-EARLY-STOP is applied only to open braces, not to virtual
2545 ;; semicolons, or anything else.
2546 ;;
2547 ;; Return a cons (A.B), where
2548 ;; A is NIL if we moved forward to an EOS, or stay at one (when
2549 ;; ALLOW-EARLY-STOP is set), T otherwise (we hit a literal).
2550 ;; B is 'MACRO-BOUNDARY if we are about to cross the boundary out of or
2551 ;; into a macro, otherwise 'LITERAL if we've hit a literal, otherwise NIL
2552 ;;
2553 ;; Point is left either after the end-of-statement, or at the last non-ws
2554 ;; code before encountering the literal, or the # of the preprocessor
2555 ;; statement, or at EOB [or just after last non-WS stuff??].
2556 ;;
2557 ;; As a clarification of "after the end-of-statement", if a comment or
2558 ;; whitespace follows a completed AWK statement, that statement is treated
2559 ;; as ending just after the last non-ws character before the comment.
2560 ;;
2561 ;; Note that this function moves within either preprocessor commands
2562 ;; (macros) or normal code, but not both within the same invocation.
2563 ;;
2564 ;; Stop before `{', `}', and `#' when it's at boi on a line, but on the
2565 ;; other side of the syntactic ws, and after `;', `}' and `};'. Only
2566 ;; stop before `{' if at top level or inside braces, though. Move by
2567 ;; sexps and move into parens. Also stop at eol of lines with `#' at
2568 ;; the boi.
2569 ;;
2570 ;; This function might do hidden buffer changes.
2572 last)
2577 ;; If we've moved forward to a virtual semicolon, we're done.
2584 ;; Gone past the end of a macro?
2589 ;; About to hit a comment?
2594 ;; End of buffer?
2600 ;; If we encounter a '{', stop just after the previous token.
2606 ;;;; NO! This seems to check that (i) EITHER we're at the top level; OR (ii) The next enclosing
2607 ;;;; level of bracketing is a '{'. HMM. Doesn't seem to make sense.
2608 ;;;; 2003/8/8 This might have something to do with the GCC extension "Statement Expressions", e.g.
2609 ;;;; while ({stmt1 ; stmt2 ; exp ;}). This form excludes such Statement Expressions.
2615 ;; End of a PIKE special brace list? If so, step over it and continue.
2624 ;; Have we got a '}' after having moved? If so, stop after the
2625 ;; previous token.
2631 ;; Stop if we encounter a preprocessor line. Continue if we
2632 ;; hit a naked #
2641 ;; Stop after a ';', '}', or "};"
2646 ;; Found a string (this subsumes AWK regexps)?
2657 )))))
2660 ;; Is the literal defined by RANGE a string contained in a single line?
2661 ;;
2662 ;; This function might do hidden buffer changes.
2670 "Go to the beginning of the innermost C statement.
2671 With prefix arg, go back N - 1 statements. If already at the
2672 beginning of a statement then go to the beginning of the closest
2673 preceding one, moving into nested blocks if necessary (use
2675 comment or multiline string, move by sentences instead of statements.
2677 When called from a program, this function takes 3 optional args: the
2678 repetition count, a buffer position limit which is the farthest back
2679 to search for the syntactic context, and a flag saying whether to do
2680 sentence motion in or near comments and multiline strings.
2682 Note that for use in programs, `c-beginning-of-statement-1' is
2683 usually better. It has much better defined semantics than this one,
2684 which is intended for interactive use, and might therefore change to
2687 nil t))
2692 last ; start point for going back ONE chunk. Updated each chunk movement.
2695 res ; result from sub-function call
2696 not-bos ; "not beginning-of-statement"
2697 (range (c-collect-line-comments (c-literal-limits lim)))) ; (start.end) of current literal or NIL
2699 ;; Go back one statement at each iteration of the following loop.
2702 ;; Go back one "chunk" each time round the following loop, stopping
2703 ;; when we reach a statement boundary, etc.
2707 ; statement boundary, non-NIL otherwise.
2710 nil)
2714 ;; Single line string or sentence-flag is null => skip the
2715 ;; entire literal.
2720 ;; N.B. The following is essentially testing for an AWK regexp
2721 ;; at BOS:
2722 ;; Was the previous non-ws thing an end of statement?
2729 ;; Comment inside a statement or a multi-line string.
2735 res)))
2737 ;; Non-literal code.
2744 ;; We're at a tentative BOS. The next form goes
2745 ;; back over WS looking for an end of previous
2746 ;; statement.
2752 ;; Are we about to move backwards into or out of a
2753 ;; preprocessor command? If so, locate its beginning.
2761 ;; Are we about to move backwards into a literal?
2764 not-bos))
2771 "Go to the end of the innermost C statement.
2772 With prefix arg, go forward N - 1 statements. Move forward to the end
2773 of the next statement if already at end, and move into nested blocks
2775 comment or multiline string, move by sentences instead of statements.
2777 When called from a program, this function takes 3 optional args: the
2778 repetition count, a buffer position limit which is the farthest back
2779 to search for the syntactic context, and a flag saying whether to do
2780 sentence motion in or near comments and multiline strings."
2782 nil t))
2792 res
2793 (range (c-collect-line-comments (c-literal-limits lim)))) ; (start.end) of current literal or NIL
2795 ;; Go back/forward one statement at each iteration of the following loop.
2800 ;; Go forward one "chunk" each time round the following loop, stopping
2801 ;; when we reach a statement boundary, etc.
2804 ; statement boundary, non-NIL otherwise.
2807 nil)
2811 ;; sentence-flag is null => skip the entire literal.
2812 ;; or a Single line string.
2817 ;; Is there a virtual semicolon here (e.g. for AWK)?
2820 ;; Comment or multi-line string.
2826 ;; If we've just come forward out of a literal, check for
2827 ;; vsemi. (N.B. AWK can't have a vsemi after a comment, but
2828 ;; some other language may do in the future)
2832 ;; Non-literal code.
2835 ;; Are we about to move forward into or out of a
2836 ;; preprocessor command?
2851 ;; Are we about to move forward into a literal?
2859 \f
2860 ;; set up electric character functions to work with pending-del,
2861 ;; (a.k.a. delsel) mode. All symbols get the t value except
2862 ;; the functions which delete, which gets 'supersede, and (from Emacs
2863 ;; 25) `c-electric-brace' and `c-electric-paren' get special handling
2864 ;; so as to work gracefully with `electric-pair-mode'.
2871 c-electric-slash
2872 c-electric-star
2873 c-electric-semi&comma
2874 c-electric-lt-gt
2875 c-electric-colon))
2880 'delete-selection-uses-region-p
2881 t))
2884 c-electric-paren))
2892 \f
2893 ;; Inserting/indenting comments
2895 ;; This function might do hidden buffer changes.
2908 ;; Do not pad with one space if we're at bol.
2909 value
2920 ;; Found comment to align with.
2922 ;; Do not pad with one space if we're at bol.
2923 0
2925 ;; Recurse to handle value as a new spec.
2929 "Used by `indent-for-comment' to create and indent comments.
2930 See `c-indent-comment-alist' for a description."
2958 case-fold-search)
2960 c-indent-comments-syntactically-p)
2962 ;; BOGOSITY ALERT: if we're looking at the eol, its
2963 ;; because indent-for-comment hasn't put the comment-start
2964 ;; in the buffer yet. this will screw up the syntactic
2965 ;; analysis so we kludge in the necessary info. Another
2966 ;; kludge is that if we're at the bol, then we really want
2967 ;; to ignore any anchoring as specified by
2968 ;; c-comment-only-line-offset since it doesn't apply here.
2973 c-comment-only-line-offset
2975 c-comment-only-line-offset))))
2980 \f
2981 ;; used by outline-minor-mode
2984 ;; in otherwise-hidden text.
2989 \f
2990 ;; Movement by CPP conditionals.
2992 "Move back to the containing preprocessor conditional, leaving mark behind.
2993 A prefix argument acts as a repeat count. With a negative argument,
2994 move forward to the end of the containing preprocessor conditional.
2997 function stops at them when going backward, but not when going
2998 forward."
3008 directives."
3016 "Move forward into the next preprocessor conditional, leaving mark behind.
3017 A prefix argument acts as a repeat count. With a negative argument,
3018 move backward into the previous preprocessor conditional.
3021 function stops at them when going forward, but not when going
3022 backward."
3032 directives."
3040 "Move back across a preprocessor conditional, leaving mark behind.
3041 A prefix argument acts as a repeat count. With a negative argument,
3042 move forward across a preprocessor conditional.
3044 The optional arguments TARGET-DEPTH and WITH-ELSE are historical,
3045 and have the same meanings as in `c-scan-conditionals'. If you
3046 are calling c-forward-conditional from a program, you might want
3047 to call `c-scan-conditionals' directly instead."
3055 "Move forward across a preprocessor conditional, leaving mark behind.
3056 A prefix argument acts as a repeat count. With a negative argument,
3057 move backward across a preprocessor conditional.
3059 If there aren't enough conditionals after \(or before) point, an
3060 error is signaled.
3063 the nesting level isn't changed when tracking subconditionals.
3065 The optional arguments TARGET-DEPTH and WITH-ELSE are historical,
3066 and have the same meanings as in `c-scan-conditionals'. If you
3067 are calling c-forward-conditional from a program, you might want
3068 to call `c-scan-conditionals' directly instead."
3075 "Scan forward across COUNT preprocessor conditionals.
3076 With a negative argument, scan backward across preprocessor
3077 conditionals. Return the end position. Point is not moved.
3079 If there aren't enough preprocessor conditionals, throw an error.
3082 the nesting level isn't changed when tracking subconditionals.
3084 The optional argument TARGET-DEPTH specifies the wanted nesting depth
3085 after each scan. E.g. if TARGET-DEPTH is -1, the end position will be
3086 outside the enclosing conditional. A non-integer non-nil TARGET-DEPTH
3087 counts as -1.
3090 are treated as conditional clause limits. Normally they are ignored."
3094 new case-fold-search)
3100 ;; subdepth is the depth in "uninteresting" subtrees,
3101 ;; i.e. those that takes us farther from the target
3102 ;; depth instead of closer.
3104 found)
3106 ;; Find the "next" significant line in the proper direction.
3108 ;; Rather than searching for a # sign that
3109 ;; comes at the beginning of a line aside from
3110 ;; whitespace, search first for a string
3111 ;; starting with # sign. Then verify what
3112 ;; precedes it. This is faster on account of
3113 ;; the fastmap feature of the regexp matcher.
3116 nil t))
3118 ;; Now verify it is really a preproc line.
3126 ;; When we're not in an "uninteresting"
3127 ;; subtree, we might want to act on "elif"
3128 ;; and "else" too.
3130 ;; Always move toward the target depth.
3135 ;; Ignore the change if it'd take us
3136 ;; into an "uninteresting" subtree.
3144 ;; If we are trying to move across, and we find an
3145 ;; end before we find a beginning, get an error.
3148 "No following conditional at this level"
3150 ;; When searching forward, start from next line so
3151 ;; that we don't find the same line again.
3153 ;; We found something if we've arrived at the
3154 ;; target depth.
3157 ;; else
3164 new))
3166 \f
3167 ;; commands to indent lines, regions, defuns, and expressions
3169 "Indent current line as C code, and/or insert some whitespace.
3171 If `c-tab-always-indent' is t, always just indent the current line.
3172 If nil, indent the current line only if point is at the left margin or
3173 in the line's indentation; otherwise insert some whitespace[*]. If
3174 other than nil or t, then some whitespace[*] is inserted only within
3175 literals (comments and strings), but the line is always reindented.
3177 If `c-syntactic-indentation' is t, indentation is done according to
3178 the syntactic context. A numeric argument, regardless of its value,
3179 means indent rigidly all the lines of the expression starting after
3180 point so that this line becomes properly indented. The relative
3181 indentation among the lines of the expression is preserved.
3183 If `c-syntactic-indentation' is nil, the line is just indented one
3184 step according to `c-basic-offset'. In this mode, a numeric argument
3185 indents a number of such steps, positive or negative, and an empty
3186 prefix argument is equivalent to -1.
3188 [*] The amount and kind of whitespace inserted is controlled by the
3189 variable `c-insert-tab-function', which is called to do the actual
3190 insertion of whitespace. Normally the function in this variable
3191 just inserts a tab character, or the equivalent number of spaces,
3192 depending on the variable `indent-tabs-mode'."
3201 -1
3209 ;; Realign the line continuation backslash if inside a macro.
3211 ))))
3213 ;; If c-syntactic-indentation and got arg, always indent this
3214 ;; line as C and shift remaining lines of expression the same
3215 ;; amount.
3219 beg end)
3224 shift-amt))
3236 ;; Else use c-tab-always-indent to determine behavior.
3238 ;; CASE 1: indent when at column zero or in line's indentation,
3239 ;; otherwise insert a tab
3246 ;; CASE 2: just indent the line
3249 ;; CASE 3: if in a literal, insert a tab, but always indent the
3250 ;; line
3255 )))))
3258 "Indent each line in the balanced expression following point syntactically.
3259 If optional SHUTUP-P is non-nil, no errors are signaled if no
3260 balanced expression is found."
3263 end)
3267 ;; Find the closest following open paren that
3268 ;; ends on another line.
3276 ;; sanity check
3292 "Indent the current top-level declaration or macro syntactically.
3293 In the macro case this also has the effect of realigning any line
3294 continuation backslashes, unless `c-auto-align-backslashes' is nil."
3300 ;; We try to be line oriented, unless there are several
3301 ;; declarations on the same line.
3313 "Indent syntactically every line whose first char is between START
3314 and END inclusive. If the optional argument QUIET is non-nil then no
3315 syntactic errors are reported, even if `c-report-syntactic-errors' is
3316 non-nil."
3322 ;; Advance to first nonblank line.
3330 ;; shut up any echo msgs on indiv lines
3336 start))
3338 syntax)
3346 ;; update progress
3348 ;; skip empty lines
3351 ;; Get syntax and indent.
3357 ;; End of current multi-line macro?
3360 ;; Fixup macro backslashes.
3363 ;; New multi-line macro?
3375 c-parsing-error))))
3378 ;; Function version of the macro for use in places that aren't
3379 ;; compiled, e.g. in the menus.
3383 "Indent active region, current line, or block starting on this line.
3384 In Transient Mark mode, when the region is active, reindent the region.
3385 Otherwise, with a prefix argument, rigidly reindent the expression
3386 starting on the current line.
3387 Otherwise reindent just the current line."
3393 \f
3394 ;; for progress reporting
3399 ;; Be silent
3401 ;; Start the progress update messages. If this Emacs doesn't have
3402 ;; a built-in timer, just be dumb about it.
3405 ;; If progress has already been initialized, do nothing. otherwise
3406 ;; initialize the counter with a vector of:
3407 ;; [start end lastsec context]
3414 context))
3416 ))
3420 nil
3425 ;; should we update? currently, update happens every 2 seconds,
3426 ;; what's the right value?
3432 )))
3436 nil
3445 \f
3446 ;;; This page handles insertion and removal of backslashes for C macros.
3449 "Insert, align, or delete end-of-line backslashes on the lines in the region.
3450 With no argument, inserts backslashes and aligns existing backslashes.
3451 With an argument, deletes the backslashes. The backslash alignment is
3452 done according to the settings in `c-backslash-column',
3453 `c-backslash-max-column' and `c-auto-align-backslashes'.
3455 This function does not modify blank lines at the start of the region.
3456 If the region ends at the start of a line and the macro doesn't
3457 continue below it, the backslash (if any) at the end of the previous
3458 line is deleted.
3460 You can put the region around an entire macro definition and use this
3461 command to conveniently insert and align the necessary backslashes."
3464 ;; Keep the backslash trimming functions from changing the
3465 ;; whitespace around point, since in this case it's only the
3466 ;; position of point that tells the indentation of the line.
3472 column longest-line-col bs-col-after-end)
3476 ;; Nothing to do if to is at bob, since we should back up
3477 ;; and there's no line to back up to.
3478 nil
3480 ;; Do not back up the to line if line-mode is set, to make
3481 ;; e.g. c-newline-and-indent consistent regardless whether
3482 ;; the (newline) call leaves point at bol or not.
3490 ;; Set bs-col-after-end to the column of any backslash
3491 ;; following the region, or nil if there is none.
3500 ;; Back up the to line if line-mode is set, since the line
3501 ;; after the newly inserted line break should not be
3502 ;; touched in c-newline-and-indent.
3505 ;; Set bs-col-after-end to non-nil in any case, since we
3506 ;; do not want to delete the backslash at the last line.
3511 ;; Compute the smallest column number past the ends of all
3512 ;; the lines.
3516 ;; Include one more line in the max column
3517 ;; calculation, since the to line will be backslashed
3518 ;; too.
3531 ;; Try to align with surrounding backslashes.
3540 ;; Both a preceding and a following backslash.
3541 ;; Choose the greatest of them.
3544 ;; No preceding backslash. Try to align with one
3545 ;; following the region. Disregard the backslash at the
3546 ;; to line since it's likely to be bogus (e.g. when
3547 ;; called from c-newline-and-indent).
3550 ;; Don't modify blank lines at start of region.
3555 ;; Don't try to align with surrounding backslashes if
3556 ;; any line is too long.
3559 ;; Impose minimum limit and tab width alignment only if
3560 ;; we can't align with surrounding backslashes.
3564 tab-width)
3565 tab-width)))
3567 longest-line-col)))
3568 ;; Always impose maximum limit.
3571 ;; Add backslashes on all lines if the macro continues
3572 ;; after the to line.
3576 ;; Add backslashes on all lines except the last, and
3577 ;; remove any on the last line.
3585 ;; The function above leaves point on the line
3586 ;; following endmark.
3611 ;; Avoid unnecessary changes of the buffer.
3613 ;; Don't realign backslashes in string literals
3614 ;; since that would change them.
3615 )
3641 ;; Make sure there are backslashes with at least one space in
3642 ;; front of them.
3677 point-pos))
3683 \f
3684 ;;; Line breaking and paragraph filling.
3690 ;; The filling code is based on a simple theory; leave the intricacies
3691 ;; of the text handling to the currently active mode for that
3692 ;; (e.g. adaptive-fill-mode or filladapt-mode) and do as little as
3693 ;; possible to make them work correctly wrt the comment and string
3694 ;; separators, one-line paragraphs etc. Unfortunately, when it comes
3695 ;; to it, there's quite a lot of special cases to handle which makes
3696 ;; the code anything but simple. The intention is that it will work
3697 ;; with any well-written text filling package that preserves a fill
3698 ;; prefix.
3699 ;;
3700 ;; We temporarily mask comment starters and enders as necessary for
3701 ;; the filling code to do its job on a seemingly normal text block.
3702 ;; We do _not_ mask the fill prefix, so it's up to the filling code to
3703 ;; preserve it correctly (especially important when filling C++ style
3704 ;; line comments). By default, we set up and use adaptive-fill-mode,
3705 ;; which is standard in all supported Emacs flavors.
3708 ;; Determine the appropriate comment fill prefix for a block or line
3709 ;; comment. Return a cons of the prefix string and the column where
3710 ;; it ends. If fill-prefix is set, it'll override. Note that this
3711 ;; function also uses the value of point in some heuristics.
3712 ;;
3713 ;; This function might do hidden buffer changes.
3717 c-current-comment-prefix
3720 prefix-regexp
3721 comment-start-skip))
3722 prefix-line comment-prefix res comment-text-end)
3727 ;; Ugly way of getting the column after the fill
3728 ;; prefix; it'd be nice with a current-column
3729 ;; that works on strings..
3739 ;; Set fallback for comment-prefix if none is found.
3745 ;; The current line is not the comment starter, so the
3746 ;; comment has more than one line, and it can therefore be
3747 ;; used to find the comment fill prefix.
3753 ;; The line after the comment starter is inside the
3754 ;; comment, so we can use it.
3757 ;; The comment is only one line. Take the comment prefix
3758 ;; from it and keep the indentation.
3767 ;; There is only whitespace before the comment
3768 ;; starter; take the prefix straight from this line.
3773 ;; There is code before the comment starter, so we
3774 ;; have to temporarily insert and indent a new line to
3775 ;; get the right space/tab mix in the indentation.
3777 tmp)
3793 ;; The prefix ends the line with no whitespace
3794 ;; after it. Default to a single space.
3796 )))))
3809 ;; The current line is not the comment starter and
3810 ;; contains more than just the ender, so it's good enough
3811 ;; to be used for the comment fill prefix.
3821 ;; The comment is either one line or the next line contains
3822 ;; just the comment ender. In this case we have no
3823 ;; information about a suitable comment prefix, so we resort
3824 ;; to c-block-comment-prefix.
3828 ;; The point was on the comment opener line, so we might want
3829 ;; to treat this as a not yet closed comment.
3833 ;; Above `prefix-regexp' matched a nonempty prefix on the
3834 ;; second line, so let's use it. Normally it should do
3835 ;; to set `prefix-line' and let the code below pick up
3836 ;; the whole prefix, but if there's no text after the
3837 ;; match then it will probably fall back to no prefix at
3838 ;; all if the comment isn't closed yet, so in that case
3839 ;; it's better to force use of the prefix matched now.
3844 ;; There's no nonempty prefix on the line after the
3845 ;; comment opener. If the line is empty, or if the
3846 ;; text on it has less or equal indentation than the
3847 ;; comment starter we assume it's an unclosed
3848 ;; comment starter, i.e. that
3849 ;; `c-block-comment-prefix' should be used.
3850 ;; Otherwise we assume it's a closed comment where
3851 ;; the prefix really is the empty string.
3852 ;; E.g. this is an unclosed comment:
3853 ;;
3854 ;; /*
3855 ;; foo
3856 ;;
3857 ;; But this is not:
3858 ;;
3859 ;; /*
3860 ;; foo
3861 ;; */
3862 ;;
3863 ;; (Looking for the presence of the comment closer
3864 ;; rarely works since it's probably the closer of
3865 ;; some comment further down when the comment
3866 ;; really is unclosed.)
3875 ;; Otherwise the line after the comment starter is good
3876 ;; enough to find the prefix in.
3880 ;; Haven't got the comment prefix on any real line that we
3881 ;; can take it from, so we have to temporarily insert
3882 ;; `comment-prefix' on a line and indent it to find the
3883 ;; correct column and the correct mix of tabs and spaces.
3892 comment-text-end))
3897 ;; If there's ws on the current line, we'll use it
3898 ;; instead of what's ending comment-prefix.
3903 comment-prefix))
3912 ;; We insert an extra non-whitespace character
3913 ;; before the line break and after comment-prefix in
3914 ;; case it's "" or ends with whitespace.
3933 ;; prefix-line is the bol of a line on which we should try
3934 ;; to find the prefix.
3941 ;; The match is fine if there's text after it.
3947 ;; This match is better than nothing, so let's
3948 ;; remember it in case nothing better is found
3949 ;; on another line.
3953 t))))
3956 ;; Search for a line which has text after the prefix
3957 ;; so that we get the proper amount of whitespace
3958 ;; after it. We start with the current line, then
3959 ;; search backwards, then forwards.
3964 ;; The whitespace is sucked up by the
3965 ;; first [ \t]* glob if the prefix is empty.
3968 ;; If the current line doesn't have text but do
3969 ;; have whitespace after the prefix, we'll use it.
3975 ;; For line comments we can search up to and
3976 ;; including the first line.
3980 ;; For block comments we must stop before the
3981 ;; block starter.
3992 nil)
3995 ;; A good line wasn't found, but at least we have a
3996 ;; fallback that matches the comment prefix regexp.
4001 ;; There are ws or text after the prefix, so
4002 ;; let's use it.
4006 ;; Check if there's any whitespace padding
4007 ;; on the comment start line that we can
4008 ;; use after the prefix.
4026 ;; Got to mess in the buffer once again to
4027 ;; ensure the column gets correct. :P
4038 ;; Last resort: Just add a single space after
4039 ;; the prefix.
4044 ;; The line doesn't match the comment prefix regexp.
4046 ;; We have a fallback for line comments that we must use.
4049 comment-prefix)
4053 ;; Assume we are dealing with a "free text" block
4054 ;; comment where the lines doesn't have any comment
4055 ;; prefix at all and we should just fill it as
4056 ;; normal text.
4058 ))
4061 ;; Calls FUN with ARGS ar arguments while the current paragraph is
4062 ;; masked to allow adaptive filling to work correctly. That
4063 ;; includes narrowing the buffer and, if point is inside a comment,
4064 ;; masking the comment starter and ender appropriately.
4065 ;;
4066 ;; FILL-PARAGRAPH is non-nil if called for whole paragraph filling.
4067 ;; The position of point is then less significant when doing masking
4068 ;; and narrowing.
4069 ;;
4070 ;; If APPLY-OUTSIDE-LITERAL is nil then the function will be called
4071 ;; only if the point turns out to be inside a comment or a string.
4072 ;;
4073 ;; Note that this function does not do any hidden buffer changes.
4076 ;; beg and end limit the region to narrow. end is a marker.
4077 beg end
4078 ;; tmp-pre and tmp-post mark strings that are temporarily
4079 ;; inserted at the start and end of the region. tmp-pre is a
4080 ;; cons of the positions of the prepended string. tmp-post is
4081 ;; a marker pointing to the single character of the appended
4082 ;; string.
4083 tmp-pre tmp-post
4084 ;; If hang-ender-stuck isn't nil, the comment ender is
4085 ;; hanging. In that case it's set to the number of spaces
4086 ;; that should be between the text and the ender.
4087 hang-ender-stuck
4088 ;; auto-fill-spaces is the exact sequence of whitespace between a
4089 ;; comment's last word and the comment ender, temporarily replaced
4090 ;; with 'x's before calling FUN when FILL-PARAGRAPH is nil.
4091 auto-fill-spaces
4096 ;; Restore point on undo. It's necessary since we do a lot of
4097 ;; hidden inserts and deletes below that should be as transparent
4098 ;; as possible.
4102 ;; Determine the limits and type of the containing literal (if any):
4103 ;; C-LIT-LIMITS, C-LIT-TYPE; and the limits of the current paragraph:
4104 ;; BEG and END.
4107 ;; Widen to catch comment limits correctly.
4132 ;; For each of the possible types of text (string, C comment ...)
4133 ;; determine BEG and END, the region we will narrow to. If we're in
4134 ;; a literal, constrain BEG and END to the limits of this literal.
4135 ;;
4136 ;; For some of these text types, particularly a block comment, we
4137 ;; may need to massage whitespace near literal delimiters, so that
4138 ;; these don't get filled inappropriately.
4143 ;; Limit to the comment or paragraph end, whichever
4144 ;; comes first.
4148 ;; The region includes the comment starter, so we must
4149 ;; check it.
4153 ;; Include the first line in the region.
4155 ;; The first line contains code before the
4156 ;; comment. We must fake a line that doesn't.
4167 ;; disallow "/*/"
4169 ;; There is a comment ender, and the region includes it. If
4170 ;; it's on its own line, it stays on its own line. If it's got
4171 ;; company on the line, it keeps (at least one word of) it.
4172 ;; "=====*/" counts as a comment ender here, but "===== */"
4173 ;; doesn't and "foo*/" doesn't.
4178 ;; The following conjunct was added to avoid an
4179 ;; "Invalid search bound (wrong side of point)"
4180 ;; error in the subsequent re-search. Maybe
4181 ;; another fix would be needed (2007-12-08).
4182 ; (or (<= (- (cdr c-lit-limits) 2) (point))
4183 ; 2010-10-17 Construct removed.
4184 ; (or (< (- (cdr c-lit-limits) 2) (point))
4192 ;; The comment ender IS on its own line. Exclude this
4193 ;; line from the filling.
4196 ;; The comment ender is hanging. Replace all space between it
4197 ;; and the last word either by one or two 'x's (when
4198 ;; FILL-PARAGRAPH is non-nil), or a row of x's the same width
4199 ;; as the whitespace (when auto filling), and include it in
4200 ;; the region. We'll change them back to whitespace
4201 ;; afterwards. The effect of this is to glue the comment
4202 ;; ender to the last word in the comment during filling.
4219 spaces)
4222 ;; Insert a CR after the "*/", adjust END
4230 c-current-comment-prefix
4233 ;; The comment ender is prefixed by nothing but a
4234 ;; comment line prefix. IS THIS POSSIBLE? (ACM,
4235 ;; 2006/4/28). Remove it along with surrounding ws.
4239 ; " \t"? "*/" is NOT alone on the line (ACM, 2005/8/18)
4241 ;; What's being tested here? 2006/4/20. FIXME!!!
4245 ;; Don't adjust point below if it's
4246 ;; before the string we replace.
4248 ;; Keep one or two spaces between the
4249 ;; text and the ender, depending on how
4250 ;; many there are now.
4255 ;; paragraph filling condenses multiple spaces to
4256 ;; single or double spaces. auto-fill doesn't.
4262 sentence-end-double-space)
4265 ;; Insert the filler first to keep marks right.
4274 ;; Point was in the middle of the string we
4275 ;; replaced above, so put it back in the same
4276 ;; relative position, counting from the end.
4278 ))
4281 ;; The region includes the comment starter.
4285 ;; Begin with the next line.
4287 ;; Fake the fill prefix in the first line.
4302 ;; Leave the start line if it's
4303 ;; nothing but an escaped newline.
4309 ;; Narrow to the macro limits if they are nearer than the
4310 ;; paragraph limits. Don't know if this is necessary but
4311 ;; do it for completeness sake (doing auto filling at all
4312 ;; inside macros is bogus to begin with since the line
4313 ;; continuation backslashes aren't handled).
4326 ;; Try to avoid comments and macros in the paragraph to
4327 ;; avoid that the adaptive fill mode gets the prefix from
4328 ;; them.
4341 ;; Temporarily insert the fill prefix after the comment
4342 ;; starter so that the first line looks like any other
4343 ;; comment line in the narrowed region.
4347 c-current-comment-prefix
4350 ;; Oops, the prefix doesn't match the comment prefix
4351 ;; regexp. This could produce very confusing
4352 ;; results with adaptive fill packages together with
4353 ;; the insert prefix magic below, since the prefix
4354 ;; often doesn't appear at all. So let's warn about
4355 ;; it.
4357 Warning: Regexp from `c-comment-prefix-regexp' doesn't match the comment prefix %S"
4359 ;; Find the right spot on the line, break it, insert
4360 ;; the fill prefix and make sure we're back in the
4361 ;; same column by temporarily prefixing the first word
4362 ;; with a number of 'x'.
4366 c-current-comment-prefix
4367 comment-start-skip))
4384 ;; `apply-outside-literal' is always set to t here if
4385 ;; we're inside a literal.
4389 ;; Kludge: If the function that adapts the fill prefix
4390 ;; doesn't produce the required comment starter for
4391 ;; line comments, then force it by setting fill-prefix.
4393 ;; Kludge the kludge: filladapt-mode doesn't
4394 ;; have this problem, but it currently
4395 ;; doesn't override fill-context-prefix
4396 ;; (version 2.12).
4398 filladapt-mode))
4405 c-lit-limits c-lit-type)))))))
4407 ;; Save the relative position of point if it's outside the
4408 ;; region we're going to narrow. Want to restore it in that
4409 ;; case, but otherwise it should be moved according to the
4410 ;; called function.
4414 ;; Preparations finally done! Now we can call the
4415 ;; actual function.
4421 ;; Restore point if it was outside the region.
4434 ;; Preserve point even if it's in the middle of the string
4435 ;; we replace; save-excursion doesn't work in that case.
4451 If any of the current line is a comment or within a comment, fill the
4452 comment or the paragraph of it that point is in, preserving the
4453 comment indentation or line-starting decorations (see the
4454 `c-comment-prefix-regexp' and `c-block-comment-prefix' variables for
4455 details).
4457 If point is inside multiline string literal, fill it. This currently
4458 does not respect escaped newlines, except for the special case when it
4459 is the very first thing in the string. The intended use for this rule
4460 is in situations like the following:
4463 A very long description of something that you want to fill to make
4466 If point is in any other situation, i.e. in normal code, do nothing.
4468 Optional prefix ARG means justify paragraph as well."
4471 ;; Avoid infinite recursion.
4473 fill-paragraph-function)))
4475 ;; Always return t. This has the effect that if filling isn't done
4476 ;; above, it isn't done at all, and it's therefore effectively
4477 ;; disabled in normal code.
4478 t)
4481 ;; Do automatic filling if not inside a context where it should be
4482 ;; ignored.
4484 ;; The decision whether the line should be broken is actually
4485 ;; done in c-indent-new-comment-line, which do-auto-fill
4486 ;; calls to break lines. We just set this special variable
4487 ;; so that we'll know when we're called from there. It's
4488 ;; also used to detect whether fill-prefix is user set or
4489 ;; generated automatically by do-auto-fill.
4490 fill-prefix))
4494 "Break line at point and indent, continuing comment or macro if within one.
4495 If inside a comment and `comment-multi-line' is non-nil, the
4496 indentation and line prefix are preserved (see the
4497 `c-comment-prefix-regexp' and `c-block-comment-prefix' variables for
4498 details). If inside a single line comment and `comment-multi-line' is
4499 nil, a new comment of the same type is started on the next line and
4500 indented as appropriate for comments. If inside a macro, a line
4501 continuation backslash is inserted and aligned as appropriate, and the
4502 new line is indented according to `c-syntactic-indentation'.
4504 If a fill prefix is specified, it overrides all the above."
4505 ;; allow-auto-fill is used from c-context-line-break to allow auto
4506 ;; filling to break the line more than once. Since this function is
4507 ;; used from auto-fill itself, that's normally disabled to avoid
4508 ;; unnecessary recursion.
4517 ;; Already know the literal type and limits when called from
4518 ;; c-context-line-break.
4525 ;; Called from do-auto-fill.
4533 c-ignore-auto-fill)
4538 ;; The adaptive fill function has generated a prefix, but
4539 ;; we're on the first line in a block comment so it'll be
4540 ;; wrong. Ignore it to guess a better one below.
4544 c-line-comment-starter)
4546 ;; Kludge: If the function that adapted the fill prefix
4547 ;; doesn't produce the required comment starter for line
4548 ;; comments, then we ignore it.
4550 )))
4553 ;; A call from do-auto-fill which should be ignored.
4554 )
4556 ;; A fill-prefix overrides anything.
4565 ;; Some sort of comment.
4571 ;; Inside a comment that should be continued.
4576 c-lit-type)))
4585 ;; Skip forward past the fill prefix in case
4586 ;; we're standing in it.
4587 ;;
4588 ;; FIXME: This doesn't work well in cases like
4589 ;;
4590 ;; /* Bla bla bla bla bla
4591 ;; bla bla
4592 ;;
4593 ;; If point is on the 'B' then the line will be
4594 ;; broken after "Bla b".
4595 ;;
4596 ;; If we have an empty comment, /* */, the next
4597 ;; lot of code pushes point to the */. We fix
4598 ;; this by never allowing point to end up to the
4599 ;; right of where it started.
4606 ;; The skip takes us out of the (block)
4607 ;; comment; insert the fill prefix at bol
4608 ;; instead and keep the position.
4615 ;; Don't break in the middle of a comment starter
4616 ;; or ender.
4625 ; middle of a TAB?
4626 ;; Inside a comment that should be broken.
4629 col)
4643 ;; c-comment-indent may look at the current
4644 ;; indentation, so let's start out with the same
4645 ;; indentation as the previous one.
4650 ;; In a macro.
4652 ;; Do not clobber the alignment of the line continuation
4653 ;; slash; c-backslash-region might look at it.
4655 ;; Got an asymmetry here: In normal code this command
4656 ;; doesn't indent the next line syntactically, and otoh a
4657 ;; normal syntactically indenting newline doesn't continue
4658 ;; the macro.
4661 ;; Somewhere else in the code.
4673 ;; advice for indent-new-comment-line for older Emacsen
4677 activate preactivate)
4678 "Call `c-indent-new-comment-line' if in CC Mode."
4681 ad-do-it
4686 "Do a line break suitable to the context.
4688 When point is outside a comment or macro, insert a newline and indent
4689 according to the syntactic context, unless `c-syntactic-indentation'
4690 is nil, in which case the new line is indented as the previous
4691 non-empty line instead.
4693 When point is inside the content of a preprocessor directive, a line
4694 continuation backslash is inserted before the line break and aligned
4695 appropriately. The end of the cpp directive doesn't count as inside
4696 it.
4698 When point is inside a comment, continue it with the appropriate
4699 comment prefix (see the `c-comment-prefix-regexp' and
4700 `c-block-comment-prefix' variables for details). The end of a
4701 C++-style line comment doesn't count as inside it.
4703 When point is inside a string, only insert a backslash when it is also
4704 inside a preprocessor directive."
4709 case-fold-search)
4726 ; it, not in a string, and not in the
4727 ; cpp keyword.
4749 ;; c-indent-line may look at the current indentation, so let's
4750 ;; start out with the same indentation as the previous line.
4761 "Insert a line break suitable to the context and leave point before it.
4762 This is the `c-context-line-break' equivalent to `open-line', which is
4763 normally bound to C-o. See `c-context-line-break' for the details."
4768 ;; Temporarily insert a non-whitespace char to keep any
4769 ;; preceding whitespace intact.
4775 \f
4778 ;; Local Variables:
4779 ;; indent-tabs-mode: t
4780 ;; tab-width: 8
4781 ;; End:
4782 ;;; cc-cmds.el ends here