| blob | e17656e54dd2def183c542bd99f1839dd56e3415 |
1 ;;; cc-cmds.el --- user level commands for CC Mode
3 ;; Copyright (C) 1985,1987,1992-2003, 2004, 2005 Free Software Foundation,
4 ;; Inc.
6 ;; Authors: 1998- Martin Stjernholm
7 ;; 1992-1999 Barry A. Warsaw
8 ;; 1987 Dave Detlefs and Stewart Clamen
9 ;; 1985 Richard M. Stallman
10 ;; Maintainer: bug-cc-mode@gnu.org
11 ;; Created: 22-Apr-1997 (split from cc-mode.el)
12 ;; Version: See cc-mode.el
13 ;; Keywords: c languages oop
15 ;; This file is part of GNU Emacs.
17 ;; GNU Emacs is free software; you can redistribute it and/or modify
18 ;; it under the terms of the GNU General Public License as published by
19 ;; the Free Software Foundation; either version 2, or (at your option)
20 ;; any later version.
22 ;; GNU Emacs is distributed in the hope that it will be useful,
23 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
24 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
25 ;; GNU General Public License for more details.
27 ;; You should have received a copy of the GNU General Public License
28 ;; along with this program; see the file COPYING. If not, write to
29 ;; the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
30 ;; Boston, MA 02110-1301, USA.
32 ;;; Commentary:
34 ;;; Code:
41 load-path)))
48 ;; Silence the compiler.
51 ; which looks at this.
54 \f
58 "Indent the current line according to the syntactic context,
59 if `c-syntactic-indentation' is non-nil. Optional SYNTAX is the
60 syntactic information for the current line. Be silent about syntactic
61 errors if the optional argument QUIET is non-nil, even if
62 `c-report-syntactic-errors' is non-nil. Normally the position of
63 point is used to decide where the old indentation is on a lines that
64 is otherwise empty \(ignoring any line continuation backslash), but
65 that's not done if IGNORE-POINT-POS is non-nil. Returns the amount of
66 indentation change \(in columns)."
72 bs-col
73 shift-amt)
81 ;; Delete all whitespace after point if there's only whitespace
82 ;; on the line, so that any code that does back-to-indentation
83 ;; or similar gets the current column in this case. If this
84 ;; removes a line continuation backslash it'll be restored
85 ;; at the end.
87 ;; Should try to keep the backslash alignment
88 ;; in this case.
100 c-syntactic-context))))
105 c-syntactic-context))
107 c-echo-syntactic-information-p
109 c-syntactic-context indent))
113 c-parsing-error)
114 c-parsing-error))
119 t
121 nil))))
130 ;; Realign the line continuation backslash.
132 shift-amt))
135 "Insert a newline and indent the new line.
136 This function fixes line continuation backslashes if inside a macro,
137 and takes care to set the indentation before calling
138 `indent-according-to-mode', so that lineup functions like
139 `c-lineup-dont-change' works better."
141 ;; TODO: Backslashes before eol in comments and literals aren't
142 ;; kept intact.
144 ;; Avoid calling c-backslash-region from c-indent-line if it's
145 ;; called during the newline call, which can happen due to
146 ;; c-electric-continued-statement, for example. We also don't
147 ;; want any backslash alignment from indent-according-to-mode.
149 has-backslash insert-backslash
150 start col)
160 has-backslash t)
167 ;; The backslash stayed on the previous line. Insert one
168 ;; before calling c-backslash-region, so that
169 ;; bs-col-after-end in it works better. Fixup the
170 ;; backslashes on the newly inserted line.
174 ;; The backslash moved to the new line, if there was any. Let
175 ;; c-backslash-region fix a backslash on the previous line,
176 ;; and the one that might be on the new line.
177 ;; c-auto-align-backslashes is intentionally ignored here;
178 ;; maybe the moved backslash should be left alone if it's set,
179 ;; but we fix both lines on the grounds that the old backslash
180 ;; has been moved anyway and is now in a different context.
183 ;; Reindent syntactically. The indentation done above is not
184 ;; wasted, since c-indent-line might look at the current
185 ;; indentation.
188 ;; We temporarily insert another line break, so that the
189 ;; lineup functions will see the line as empty. That makes
190 ;; e.g. c-lineup-cpp-define more intuitive since it then
191 ;; proceeds to the preceding line in this case.
202 ;; Must align the backslash again after reindentation. The
203 ;; c-backslash-region call above can't be optimized to ignore
204 ;; this line, since it then won't align correctly with the
205 ;; lines below if the first line in the macro is broken.
209 "Show syntactic information for current line.
210 With universal argument, inserts the analysis as a comment on that line."
214 ;; Use `c-syntactic-context' in the same way as
215 ;; `c-indent-line', to be consistent.
216 c-syntactic-context
229 ols))
233 ols)))
239 ))
243 "Insert a comment with the syntactic analysis on every line in the region."
253 \f
261 ;; cc-subword might not be loaded.
264 "w"
268 fmt))
272 "Toggle syntactic indentation.
273 Optional numeric ARG, if supplied, turns on syntactic indentation when
274 positive, turns it off when negative, and just toggles it when zero or
275 left out.
277 When syntactic indentation is turned on (the default), the indentation
278 functions and the electric keys indent according to the syntactic
279 context keys, when applicable.
281 When it's turned off, the electric keys don't reindent, the indentation
282 functions indents every new line to the same level as the previous
284 specified by `c-basic-offset'. The indentation style has no effect in
285 this mode, nor any of the indentation associated variables,
286 e.g. `c-special-indent-hook'.
288 This command sets the variable `c-syntactic-indentation'."
295 "Toggle auto-newline feature.
296 Optional numeric ARG, if supplied, turns on auto-newline when
297 positive, turns it off when negative, and just toggles it when zero or
298 left out.
300 Turning on auto-newline automatically enables electric indentation.
303 modeline after the mode name) newlines are automatically inserted
304 after special characters such as brace, comma, semi-colon, and colon."
316 "Toggle hungry-delete-key feature.
317 Optional numeric ARG, if supplied, turns on hungry-delete when
318 positive, turns it off when negative, and just toggles it when zero or
319 left out.
322 the modeline after the mode name) the delete key gobbles all preceding
323 whitespace in one fell swoop."
330 "Toggle auto-newline and hungry-delete-key features.
331 Optional numeric ARG, if supplied, turns on auto-newline and
332 hungry-delete when positive, turns them off when negative, and just
333 toggles them when zero or left out.
335 See `c-toggle-auto-newline' and `c-toggle-hungry-state' for details."
343 "Toggle the electric indentation feature.
344 Optional numeric ARG, if supplied, turns on electric indentation when
345 positive, turns it off when negative, and just toggles it when zero or
346 left out."
352 \f
353 ;; Electric keys
356 "Delete the preceding character or whitespace.
358 line) then all preceding whitespace is consumed. If however a prefix
359 argument is supplied, or `c-hungry-delete-key' is nil, or point is
360 inside a literal then the function in the variable
361 `c-backspace-function' is called."
365 arg
371 "Delete the preceding character or all preceding whitespace
372 back to the previous non-whitespace character.
382 "Delete the following character or whitespace.
384 line) then all following whitespace is consumed. If however a prefix
385 argument is supplied, or `c-hungry-delete-key' is nil, or point is
386 inside a literal then the function in the variable `c-delete-function'
387 is called."
391 arg
397 "Delete the following character or all following whitespace
398 up to the next non-whitespace character.
407 ;; This function is only used in XEmacs.
409 "Deletes preceding or following character or whitespace.
410 This function either deletes forward as `c-electric-delete-forward' or
411 backward as `c-electric-backspace', depending on the configuration: If
412 the function `delete-forward-p' is defined and returns non-nil, it
413 deletes forward. Otherwise it deletes backward.
415 Note: This is the way in XEmacs to choose the correct action for the
416 \[delete] key, whichever key that means. Other flavors don't use this
417 function to control that."
424 ;; This function is only used in XEmacs.
426 "Delete a non-whitespace char, or all whitespace up to the next non-whitespace char.
427 The direction of deletion depends on the configuration: If the
428 function `delete-forward-p' is defined and returns non-nil, it deletes
429 forward using `c-hungry-delete-forward'. Otherwise it deletes
430 backward using `c-hungry-backspace'.
432 Note: This is the way in XEmacs to choose the correct action for the
433 \[delete] key, whichever key that means. Other flavors don't use this
434 function to control that."
443 If `c-electric-flag' is set, handle it specially according to the variable
444 `c-electric-pound-behavior'. If a numeric ARG is supplied, or if point is
445 inside a literal or a macro, nothing special happens."
459 ;; do nothing special
461 ;; place the pound character at the left edge
469 )))
472 ;; Return the syntactic context of the construct at point. (This is NOT
473 ;; nec. the same as the s.c. of the line point is on). N.B. This won't work
474 ;; between the `#' of a cpp thing and what follows (see c-opt-cpp-prefix).
477 syntax)
479 ;; insert a newline to isolate the construct at point for syntactic
480 ;; analysis.
482 ;; In AWK (etc.) or in a macro, make sure this CR hasn't changed
483 ;; the syntax. (There might already be an escaped NL there.)
496 ;; Turn on syntactic macro analysis to help with auto
497 ;; newlines only.
499 nil))
500 syntax))
503 ;; A brace stands at point. SYNTAX is the syntactic context of this brace
504 ;; (not necessarily the same as the S.C. of the line it is on). Return
505 ;; NEWLINES, the list containing some combination of the symbols `before'
506 ;; and `after' saying where newlines should be inserted.
509 ;; This is the list of brace syntactic symbols that can hang.
510 ;; If any new ones are added to c-offsets-alist, they should be
511 ;; added here as well.
513 inline-open inline-close
514 brace-list-open brace-list-close
515 brace-list-intro brace-entry-open
516 block-open block-close
517 substatement-open statement-case-open
518 extern-lang-open extern-lang-close
519 namespace-open namespace-close
520 module-open module-close
521 composition-open composition-close
522 inexpr-class-open inexpr-class-close
523 ;; `statement-cont' is here for the case with a brace
524 ;; list opener inside a statement. C.f. CASE B.2 in
525 ;; `c-guess-continued-construct'.
526 statement-cont))
527 ;; shut this up too
532 ;; Do not try to insert newlines around a special
533 ;; (Pike-style) brace list.
540 nil
541 ;; Seek the matching entry in c-hanging-braces-alist.
543 syms
544 ;; Substitute inexpr-class and class-open or
545 ;; class-close with inexpr-class-open or
546 ;; inexpr-class-close.
553 syntax)
554 c-hanging-braces-alist)
557 ;; If syntax is a function symbol, then call it using the
558 ;; defined semantics.
568 ;; Point is just after a newly inserted }. If the non-whitespace
569 ;; content of the braces is a single line of code, compact the whole
570 ;; construct to a single line, if this line isn't too long. The Right
571 ;; Thing is done with comments.
572 ;;
573 ;; Point will be left after the }, regardless of whether the clean-up is
574 ;; done. Return NON-NIL if the clean-up happened, NIL if it didn't.
578 mbeg1 mend1 mbeg4 mend4
579 eol-col cmnt-pos cmnt-col cmnt-gap)
584 ;; Avoid backtracking over a very large block. The one we
585 ;; deal with here can never be more than three lines.
616 ;; Necessary to put the closing brace before any line
617 ;; oriented comment to keep it syntactically significant.
618 ;; This isn't necessary for block comments, but the result
619 ;; looks nicer anyway.
635 ;; Can we trim space before comment to make the line fit?
641 t))))
645 "Insert a brace.
647 If `c-electric-flag' is non-nil, the brace is not inside a literal and a
648 numeric ARG hasn't been supplied, the command performs several electric
649 actions:
652 the mode line) newlines are inserted before and after the brace as
653 directed by the settings in `c-hanging-braces-alist'.
655 \(b) Any auto-newlines are indented. The original line is also
656 reindented unless `c-syntactic-indentation' is nil.
658 \(c) If auto-newline is turned on, various newline cleanups based on the
659 settings of `c-cleanup-list' are done."
663 ;; We want to inhibit blinking the paren since this would be
664 ;; most disruptive. We'll blink it ourselves later on.
666 blink-paren-function)
672 ;; Insert the brace. Note that expand-abbrev might reindent
673 ;; the line here if there's a preceding "else" or something.
683 newlines
685 ; of the brace itself, of the line the brace ends up on.
697 ;; Insert the BEFORE newline, if wanted, and reindent the newline.
701 ;; Only a plain newline for now - it's indented
702 ;; after the cleanups when the line has its final
703 ;; appearance.
708 ;; `syntax' is the syntactic context of the line which ends up
709 ;; with the brace on it.
712 ;; Do all appropriate clean ups
715 mbeg mend
716 )
718 ;; `}': clean up empty defun braces
723 syntax)
728 ;; make sure matching open brace isn't in a comment
734 ;; `}': compact to a one-liner defun?
743 ;; `{': clean up brace-else-brace and brace-elseif-brace
750 "else"
752 "{"
754 nil t))
766 ; (progn
767 ; (setq tmp (point))
771 "else"
773 "if"
777 ;(eq (match-end 0) tmp);
778 )
785 ;; Indent the line after the cleanups since it might
786 ;; very well indent differently due to them, e.g. if
787 ;; c-indent-one-line-block is used together with the
788 ;; one-liner-defun cleanup.
792 ;; does a newline go after the brace?
795 ))))
797 ;; blink the paren
800 old-blink-paren
807 "Insert a slash character.
809 If the slash is inserted immediately after the comment prefix in a c-style
810 comment, the comment might get closed by removing whitespace and possibly
813 Indent the line as a comment, if:
816 token and we are on a comment-only-line, or
819 comment.
821 If a numeric ARG is supplied, point is inside a literal, or
822 `c-syntactic-indentation' is nil or `c-electric-flag' is nil, indentation
823 is inhibited."
826 indentp
827 ;; shut this up
830 ;; comment-close-slash cleanup? This DOESN'T need `c-electric-flag' or
831 ;; `c-syntactic-indentation' set.
836 ; (eq c-block-comment-ender "*/") ; C-style comments ALWAYS end in */
845 c-syntactic-indentation
846 c-electric-flag
854 "Insert a star character.
855 If `c-electric-flag' and `c-syntactic-indentation' are both non-nil, and
856 the star is the second character of a C style comment starter on a
857 comment-only-line, indent the line as a comment. If a numeric ARG is
858 supplied, point is inside a literal, or `c-syntactic-indentation' is nil,
859 this indentation is inhibited."
863 ;; if we are in a literal, or if arg is given do not reindent the
864 ;; current line, unless this star introduces a comment-only line.
867 c-electric-flag
880 ))
883 "Insert a comma or semicolon.
885 If `c-electric-flag' is non-nil, point isn't inside a literal and a
886 numeric ARG hasn't been supplied, the command performs several electric
887 actions:
890 the mode line) a newline might be inserted. See the variable
891 `c-hanging-semi&comma-criteria' for how newline insertion is determined.
893 \(b) Any auto-newlines are indented. The original line is also
894 reindented unless `c-syntactic-indentation' is nil.
896 \(c) If auto-newline is turned on, a comma following a brace list or a
897 semicolon following a defun might be cleaned up, depending on the
898 settings of `c-cleanup-list'."
902 ;; shut this up
912 ;; do all cleanups and newline insertions if c-auto-newline is on.
917 ;; clean ups: list-close-comma or defun-close-semi
930 ;; make sure matching open brace isn't in a comment
934 ;; reindent line
938 ;; check to see if a newline should be added
940 answer add-newline-p)
943 ;; only nil value means continue checking
947 ;; only 'stop specifically says do not add a newline
949 ))
952 )))))
955 "Insert a colon.
957 If `c-electric-flag' is non-nil, the colon is not inside a literal and a
958 numeric ARG hasn't been supplied, the command performs several electric
959 actions:
962 the mode line) newlines are inserted before and after the colon based on
963 the settings in `c-hanging-colons-alist'.
965 \(b) Any auto-newlines are indented. The original line is also
966 reindented unless `c-syntactic-indentation' is nil.
968 \(c) If auto-newline is turned on, whitespace between two colons will be
970 `c-cleanup-list'."
975 newlines is-scope-op
976 ;; shut this up
979 ;; Any electric action?
981 ;; Unless we're at EOL, only re-indentation happens.
986 ;; scope-operator clean-up?
1004 ;; indent the current line if it's done syntactically.
1006 ;; Cannot use the same syntax analysis as we find below,
1007 ;; since that's made with c-syntactic-indentation-in-macros
1008 ;; always set to t.
1011 ;; Calculate where, if anywhere, we want newlines.
1015 ;; Turn on syntactic macro analysis to help with auto newlines
1016 ;; only.
1019 ;; Translate substatement-label to label for this operation.
1024 ;; some language elements can only be determined by checking
1025 ;; the following line. Lets first look for ones that can be
1026 ;; found when looking on the line with the colon
1030 syntax c-hanging-colons-alist)
1037 c-hanging-colons-alist)))))
1038 ;; does a newline go before the colon? Watch out for already
1039 ;; non-hung colons. However, we don't unhang them because that
1040 ;; would be a cleanup (and anti-social).
1050 ;; does a newline go after the colon?
1054 ))))
1058 If the current language uses angle bracket parens (e.g. template
1059 arguments in C++), try to find out if the inserted character is a
1060 paren and give it paren syntax if appropriate.
1062 If `c-electric-flag' and `c-syntactic-indentation' are both non-nil, the
1063 line will be reindented if the inserted character is a paren or if it
1064 finishes a C++ style stream operator in C++ mode. Exceptions are when a
1065 numeric argument is supplied, or the point is inside a literal."
1069 final-pos close-paren-inserted)
1075 c-restricted-<>-arglists
1091 ;; It's a ">". Check if there's an earlier "<" which either has
1092 ;; open paren syntax already or that can be recognized as an arglist
1093 ;; together with this ">". Note that this won't work in cases like
1094 ;; "template <x, a < b, y>" but they ought to be rare.
1097 ;; Narrow to avoid that `c-forward-<>-arglist' below searches past
1098 ;; our position.
1108 ;; If the "<" already got open paren syntax we know we
1109 ;; have the matching closer. Handle it and exit the
1110 ;; loop.
1115 nil)
1116 t))
1126 c-restricted-<>-arglists
1138 ;; Loop here if the "<" we found above belongs to a nested
1139 ;; angle bracket sexp. When we start over we'll find the
1140 ;; previous or surrounding sexp.
1142 t
1144 nil)))))))
1147 ;; Indent the line if appropriate.
1161 blink-paren-function)
1162 ;; Note: Most paren blink functions, such as the standard
1163 ;; `blink-matching-open', currently doesn't handle paren chars
1164 ;; marked with text properties very well. Maybe we should avoid
1165 ;; this call for the time being?
1169 "Insert a parenthesis.
1171 If `c-syntactic-indentation' and `c-electric-flag' are both non-nil, the
1172 line is reindented unless a numeric ARG is supplied, or the parenthesis
1173 is inserted inside a literal.
1175 Whitespace between a function name and the parenthesis may get added or
1176 removed; see the variable `c-cleanup-list'.
1178 Also, if `c-electric-flag' and `c-auto-newline' are both non-nil, some
1179 newline cleanups are done if appropriate; see the variable `c-cleanup-list'."
1182 ;; shut this up
1188 ;; be most disruptive. We'll blink it ourselves
1189 ;; afterwards.
1191 blink-paren-function)
1195 ;; If we're at EOL, check for new-line clean-ups.
1199 ;; clean up brace-elseif-brace
1206 "else"
1208 "if"
1210 "("
1212 nil t)
1217 ;; clean up brace-catch-brace
1224 "catch"
1226 "("
1228 nil t)
1233 ;; Check for clean-ups at function calls. These two DON'T need
1234 ;; `c-electric-flag' or `c-syntactic-indentation' set.
1235 ;; Point is currently just after the inserted paren.
1239 ;; space-before-funcall clean-up?
1252 ;; compact-empty-funcall clean-up?
1266 old-blink-paren
1270 "Reindent the current line if appropriate.
1272 This function is used to reindent the line after a keyword which
1276 The line is reindented if there is nothing but whitespace before the
1277 keyword on the line, the keyword is not inserted inside a literal, and
1278 `c-electric-flag' and `c-syntactic-indentation' are both non-nil."
1283 c-syntactic-indentation
1290 ;; Have to temporarily insert a space so that
1291 ;; c-guess-basic-syntax recognizes the keyword. Follow the
1292 ;; space with a nonspace to avoid messing up any whitespace
1293 ;; sensitive meddling that might be done, e.g. by
1294 ;; `c-backslash-region'.
1300 \f
1302 "Compatibility alias for `c-forward-subword'."
1309 "Compatibility alias for `c-backward-subword'."
1316 "Insert a double colon scope operator at point.
1322 "Move backward to the beginning of a defun.
1323 Every top level declaration that contains a brace paren block is
1324 considered to be a defun.
1326 With a positive argument, move backward that many defuns. A negative
1327 argument -N means move forward to the Nth following beginning. Return
1328 t unless search stops due to beginning or end of buffer.
1330 Unlike the built-in `beginning-of-defun' this tries to be smarter
1331 about finding the char with open-parenthesis syntax that starts the
1332 defun."
1340 t)
1345 ;; Note: Partial code duplication in `c-end-of-defun' and
1346 ;; `c-declaration-limits'.
1351 ;; If we moved to the outermost enclosing paren
1352 ;; then we can use c-safe-position to set the
1353 ;; limit. Can't do that otherwise since the
1354 ;; earlier paren pair on paren-state might very
1355 ;; well be part of the declaration we should go
1356 ;; to.
1358 t)
1359 ;; At top level. Make sure we aren't inside a literal.
1367 ;; Didn't move. Might be due to bob or unbalanced
1368 ;; parens. Try to continue if it's the latter.
1371 ;; Didn't work, so it's bob then.
1376 ;; Check if the declaration contains a brace
1377 ;; block. If not, we try another one.
1382 ;; Might have stopped on the
1383 ;; ';' in a K&R argdecl. In
1384 ;; that case the declaration
1385 ;; should contain a block.
1389 ;; Check if `c-beginning-of-decl-1' put us after the block
1390 ;; in a declaration that doesn't end there. We're searching
1391 ;; back and forth over the block here, which can be
1392 ;; expensive.
1403 nil
1407 ;; Try to be line oriented; position point at the closest
1408 ;; preceding boi that isn't inside a comment, but if we hit
1409 ;; the previous declaration then we use the current point
1410 ;; instead.
1421 "Move forward to the end of a top level declaration.
1422 With argument, do it that many times. Negative argument -N means move
1423 back to Nth preceding end. Returns t unless search stops due to
1424 beginning or end of buffer.
1426 An end of a defun occurs right after the close-parenthesis that matches
1427 the open-parenthesis that starts a defun; see `beginning-of-defun'."
1435 t)
1440 ;; Note: Partial code duplication in `c-beginning-of-defun'
1441 ;; and `c-declaration-limits'.
1446 ;; If we moved to the outermost enclosing paren
1447 ;; then we can use c-safe-position to set the
1448 ;; limit. Can't do that otherwise since the
1449 ;; earlier paren pair on paren-state might very
1450 ;; well be part of the declaration we should go
1451 ;; to.
1453 t)
1454 ;; At top level. Make sure we aren't inside a literal.
1459 ;; Have to move to the start first so that `c-end-of-decl-1'
1460 ;; has the correct start position.
1464 ;; We moved back over the previous defun or a macro. Move
1465 ;; to the next token; it's the start of the next
1466 ;; declaration. We can also be directly after the block
1467 ;; in a `c-opt-block-decls-with-vars-key' declaration, but
1468 ;; then we won't move significantly far here.
1475 ;; Didn't move. Might be due to eob or unbalanced
1476 ;; parens. Try to continue if it's the latter.
1478 t
1479 ;; Didn't work, so it's eob then.
1484 ;; Check if the declaration contains a brace
1485 ;; block. If not, we try another one.
1491 ;; Try to be line oriented; position point after the next
1492 ;; newline that isn't inside a comment, but if we hit the
1493 ;; next declaration then we use the current point instead.
1508 ;; Return a cons of the beginning and end positions of the current
1509 ;; top level declaration or macro. If point is not inside any then
1510 ;; nil is returned, unless NEAR is non-nil in which case the closest
1511 ;; following one is chosen instead (if there is any). The end
1512 ;; position is at the next line, providing there is one before the
1513 ;; declaration.
1514 ;;
1515 ;; This function might do hidden buffer changes.
1518 ;; Note: Some code duplication in `c-beginning-of-defun' and
1519 ;; `c-end-of-defun'.
1523 lim pos end-pos)
1526 ;; If we moved to the outermost enclosing paren then we
1527 ;; can use c-safe-position to set the limit. Can't do
1528 ;; that otherwise since the earlier paren pair on
1529 ;; paren-state might very well be part of the
1530 ;; declaration we should go to.
1532 t)
1533 ;; At top level. Make sure we aren't inside a literal.
1549 ;; We moved back over the previous defun. Skip to the next
1550 ;; one. Not using c-forward-syntactic-ws here since we
1551 ;; should not skip a macro. We can also be directly after
1552 ;; the block in a `c-opt-block-decls-with-vars-key'
1553 ;; declaration, but then we won't move significantly far
1554 ;; here.
1568 ;; Check if `c-beginning-of-decl-1' put us after the block in a
1569 ;; declaration that doesn't end there. We're searching back and
1570 ;; forth over the block here, which can be expensive.
1582 nil
1586 nil
1588 ;; Try to be line oriented; position the limits at the
1589 ;; closest preceding boi, and after the next newline, that
1590 ;; isn't inside a comment, but if we hit a neighboring
1591 ;; declaration then we instead use the exact declaration
1592 ;; limit in that direction.
1598 pos
1614 pos)))))
1615 ))))
1618 "Put mark at end of the current top-level declaration or macro, point at beginning.
1619 If point is not inside any then the closest following one is chosen.
1622 function does not require the declaration to contain a brace block."
1627 ;; We try to be line oriented, unless there are several
1628 ;; declarations on the same line.
1638 \f
1640 ;; Point is within a comment. Is it also within a comment-prefix?
1641 ;; Space at BOL which precedes a comment-prefix counts as part of it.
1642 ;;
1643 ;; This function might do hidden buffer changes.
1653 ;; Narrow to the "inside" of the comment (block) defined by range, as
1654 ;; follows:
1655 ;;
1656 ;; A c-style block comment has its opening "/*" and its closing "*/" (if
1657 ;; present) removed. A c++-style line comment retains its opening "//" but
1658 ;; has any final NL removed. If POINT is currently outwith these innards,
1659 ;; move it to the appropriate boundary.
1660 ;;
1661 ;; This narrowing simplifies the sentence movement functions, since it
1662 ;; eliminates awkward things at the boundaries of the comment (block).
1663 ;;
1664 ;; This function might do hidden buffer changes.
1682 ;; Move backwards to the "beginning of a sentence" within the comment
1683 ;; defined by RANGE, a cons of its starting and ending positions. If we
1684 ;; find a BOS, return NIL. Otherwise, move point to just before the start
1685 ;; of the comment and return T.
1686 ;;
1687 ;; The BOS is either text which follows a regexp match of sentence-end,
1688 ;; or text which is a beginning of "paragraph".
1689 ;; Comment-prefixes are treated like WS when calculating BOSes or BOPs.
1690 ;;
1691 ;; This code was adapted from GNU Emacs's forward-sentence in paragraphs.el.
1692 ;; It is not a general function, but is intended only for calling from
1693 ;; c-move-over-sentence. Not all preconditions have been explicitly stated.
1694 ;;
1695 ;; This function might do hidden buffer changes.
1701 last
1707 ;; First, find the previous paragraph start, if any.
1711 ; paragraph-\(start\|separate\)
1720 ;; Now seek successively earlier sentence ends between PAR-BEG and
1721 ;; HERE, until the "start of sentence" following it is earlier than
1722 ;; HERE, or we hit PAR-BEG. Beware of comment prefices!
1740 nil
1742 t))))
1745 ;; Move forward to the "end of a sentence" within the comment defined by
1746 ;; RANGE, a cons of its starting and ending positions (enclosing the opening
1747 ;; comment delimiter and the terminating */ or newline). If we find an EOS,
1748 ;; return NIL. Otherwise, move point to just after the end of the comment
1749 ;; and return T.
1750 ;;
1751 ;; The EOS is just after the non-WS part of the next match of the regexp
1752 ;; sentence-end. Typically, this is just after one of [.!?]. If there is
1753 ;; no sentence-end match following point, any WS before the end of the
1754 ;; comment will count as EOS, providing we're not already in it.
1755 ;;
1756 ;; This code was adapted from GNU Emacs's forward-sentence in paragraphs.el.
1757 ;; It is not a general function, but is intended only for calling from
1758 ;; c-move-over-sentence.
1759 ;;
1760 ;; This function might do hidden buffer changes.
1763 ;; (lit-type (c-literal-type range)) ; Commented out, 2005/11/23, ACM
1764 )
1770 ;; The cc-mode values of paragraph-\(start\|separate\), set
1771 ;; in c-setup-paragraph-variables, are used in the
1772 ;; following.
1781 last
1784 ;; Go forward one "comment-prefix which looks like sentence-end"
1785 ;; each time round the following:
1796 ;; Take special action if we're up against the end of a comment (of
1797 ;; either sort): Leave point just after the last non-ws text.
1804 nil
1806 t))))
1809 ;; Move backwards to the "beginning of a sentence" within the string defined
1810 ;; by RANGE, a cons of its starting and ending positions (enclosing the
1811 ;; string quotes). If we find a BOS, return NIL. Otherwise, move point to
1812 ;; just before the start of the string and return T.
1813 ;;
1814 ;; The BOS is either the text which follows a regexp match of sentence-end
1815 ;; or text which is a beginning of "paragraph". For the purposes of
1816 ;; determining paragraph boundaries, escaped newlines are treated as
1817 ;; ordinary newlines.
1818 ;;
1819 ;; This code was adapted from GNU Emacs's forward-sentence in paragraphs.el.
1820 ;; It is not a general function, but is intended only for calling from
1821 ;; c-move-over-sentence.
1822 ;;
1823 ;; This function might do hidden buffer changes.
1829 ;; Enhance paragraph-start and paragraph-separate also to recognise
1830 ;; blank lines terminated by escaped EOLs. IT MAY WELL BE that
1831 ;; these values should be customizable user options, or something.
1840 ; paragraph-\(start\|separate\)
1848 ;; Now see if we can find a sentence end after PAR-BEG.
1856 ; than here, in case point starts
1857 ; beyond the closing quote.
1862 nil
1864 t))))
1867 ;; Move forward to the "end of a sentence" within the string defined by
1868 ;; RANGE, a cons of its starting and ending positions. If we find an EOS,
1869 ;; return NIL. Otherwise, move point to just after the end of the string
1870 ;; and return T.
1871 ;;
1872 ;; The EOS is just after the non-WS part of the next match of the regexp
1873 ;; sentence-end. Typically, this is just after one of [.!?]. If there is
1874 ;; no sentence-end match following point, any WS before the end of the
1875 ;; string will count as EOS, providing we're not already in it.
1876 ;;
1877 ;; This code was adapted from GNU Emacs's forward-sentence in paragraphs.el.
1878 ;; It is not a general function, but is intended only for calling from
1879 ;; c-move-over-sentence.
1880 ;;
1881 ;; This function might do hidden buffer changes.
1884 last
1885 ;; Enhance paragraph-start and paragraph-separate to recognise
1886 ;; blank lines terminated by escaped EOLs.
1894 ;; The above values of paragraph-\(start\|separate\) are used
1895 ;; in the following.
1898 ;; (re-search-backward filler-here nil t) would find an empty
1899 ;; string. Therefore we simulate it by the following:
1908 ;; Try to go forward a sentence.
1913 ;; Did we move a sentence, or did we hit the end of the string?
1915 nil
1917 t))))
1920 ;; Point is not in a literal (i.e. comment or string (include AWK regexp)).
1921 ;; If a literal is the next thing (aside from whitespace) to be found before
1922 ;; point, return a cons of its start.end positions (enclosing the
1923 ;; delimiters). Otherwise return NIL.
1924 ;;
1925 ;; This function might do hidden buffer changes.
1929 pos)
1933 ;; to prevent `looking-at' seeing a " at point.
1937 ;; An EOL can act as an "open string" terminator in AWK.
1948 ;; Point is not in a literal (i.e. comment or string (include AWK regexp)).
1949 ;; If a literal is the next thing (aside from whitespace) following point,
1950 ;; return a cons of its start.end positions (enclosing the delimiters).
1951 ;; Otherwise return NIL.
1952 ;;
1953 ;; This function might do hidden buffer changes.
1966 ;; Does point immediately follow a statement "terminator"? A virtual
1967 ;; semicolon is regarded here as such. So is a an opening brace ;-)
1968 ;;
1969 ;; This function might do hidden buffer changes.
1977 ;; The following (for macros) is not strict about exactly where we are
1978 ;; wrt white space at the end of the macro. Doesn't seem to matter too
1979 ;; much. ACM 2004/3/29.
1991 ;; Move backwards over code which isn't a literal (i.e. comment or string),
1992 ;; stopping before reaching BOB or a literal or the boundary of a
1993 ;; preprocessor statement or the "beginning of a statement". MACRO-START is
1994 ;; the position of the '#' beginning the current preprocessor directive, or
1995 ;; NIL if we're not in such.
1996 ;;
1997 ;; Return a cons (A.B), where
1998 ;; A is NIL if we moved back to a BOS (and know it), T otherwise (we
1999 ;; didn't move, or we hit a literal, or we're not sure about BOS).
2000 ;; B is MACRO-BOUNDARY if we are about to cross the boundary out of or
2001 ;; into a macro, otherwise LITERAL if we've hit a literal, otherwise NIL
2002 ;;
2003 ;; The total collection of returned values is as follows:
2004 ;; (nil . nil): Found a BOS whilst remaining inside the illiterals.
2005 ;; (t . literal): No BOS found: only a comment/string. We _might_ be at
2006 ;; a BOS - the caller must check this.
2007 ;; (nil . macro-boundary): only happens with non-nil macro-start. We've
2008 ;; moved and reached the opening # of the macro.
2009 ;; (t . macro-boundary): Every other circumstance in which we're at a
2010 ;; macro-boundary. We might be at a BOS.
2011 ;;
2012 ;; Point is left either at the beginning-of-statement, or at the last non-ws
2013 ;; code before encountering the literal/BOB or macro-boundary.
2014 ;;
2015 ;; Note that this function moves within either preprocessor commands
2016 ;; (macros) or normal code, but will not cross a boundary between the two,
2017 ;; or between two distinct preprocessor commands.
2018 ;;
2019 ;; Stop before `{' and after `;', `{', `}' and `};' when not followed by `}'
2020 ;; or `)', but on the other side of the syntactic ws. Move by sexps and
2021 ;; move into parens. Also stop before `#' when it's at boi on a line.
2022 ;;
2023 ;; This function might do hidden buffer changes.
2027 ; semicolon precedes it.
2032 ;; Stop at the token after a comment.
2037 ;; If we've gone back over a LF, we might have moved into or out of
2038 ;; a preprocessor line.
2046 ;; Return a car of NIL ONLY if we've hit the opening # of a macro.
2051 ;; Have we found a virtual semicolon? If so, stop, unless the next
2052 ;; statement is where we started from.
2059 ;; Hit the beginning of the buffer/region?
2065 ;; Move back a character.
2068 ;; Stop at "{" (unless it's a PIKE special brace list.)
2077 ;; Have we reached the start of a macro? This always counts as
2078 ;; BOS. (N.B. I don't think (eq (point) here) can ever be true
2079 ;; here. FIXME!!! ACM 2004/3/29)
2083 ;; Stop at token just after "}" or ";".
2085 ;; If we've gone back over ;, {, or }, we're done.
2094 ;; Stop at the token after a string.
2099 ;; Nothing special: go back word characters.
2101 ))))))
2104 ;; Move forwards over code, stopping before reaching EOB or a literal
2105 ;; (i.e. a comment/string) or the boundary of a preprocessor statement or
2106 ;; the "end of a statement". MACRO-END is the position of the EOL/EOB which
2107 ;; terminates the current preprocessor directive, or NIL if we're not in
2108 ;; such.
2109 ;;
2110 ;; ALLOW-EARLY-STOP is non-nil if it is permissible to return without moving
2111 ;; forward at all, should we encounter a `{'. This is an ugly kludge, but
2112 ;; seems unavoidable. Depending on the context this function is called
2113 ;; from, we _sometimes_ need to stop there. Currently (2004/4/3),
2114 ;; ALLOW-EARLY-STOP is applied only to open braces, not to virtual
2115 ;; semicolons, or anything else.
2116 ;;
2117 ;; Return a cons (A.B), where
2118 ;; A is NIL if we moved forward to an EOS, or stay at one (when
2119 ;; ALLOW-EARLY-STOP is set), T otherwise (we hit a literal).
2120 ;; B is 'MACRO-BOUNDARY if we are about to cross the boundary out of or
2121 ;; into a macro, otherwise 'LITERAL if we've hit a literal, otherwise NIL
2122 ;;
2123 ;; Point is left either after the end-of-statement, or at the last non-ws
2124 ;; code before encountering the literal, or the # of the preprocessor
2125 ;; statement, or at EOB [or just after last non-WS stuff??].
2126 ;;
2127 ;; As a clarification of "after the end-of-statement", if a comment or
2128 ;; whitespace follows a completed AWK statement, that statement is treated
2129 ;; as ending just after the last non-ws character before the comment.
2130 ;;
2131 ;; Note that this function moves within either preprocessor commands
2132 ;; (macros) or normal code, but not both within the same invocation.
2133 ;;
2134 ;; Stop before `{', `}', and `#' when it's at boi on a line, but on the
2135 ;; other side of the syntactic ws, and after `;', `}' and `};'. Only
2136 ;; stop before `{' if at top level or inside braces, though. Move by
2137 ;; sexps and move into parens. Also stop at eol of lines with `#' at
2138 ;; the boi.
2139 ;;
2140 ;; This function might do hidden buffer changes.
2142 last)
2147 ;; If we've moved forward to a virtual semicolon, we're done.
2154 ;; Gone past the end of a macro?
2159 ;; About to hit a comment?
2164 ;; End of buffer?
2170 ;; If we encounter a '{', stop just after the previous token.
2176 ;;;; NO! This seems to check that (i) EITHER we're at the top level; OR (ii) The next enclosing
2177 ;;;; level of bracketing is a '{'. HMM. Doesn't seem to make sense.
2178 ;;;; 2003/8/8 This might have something to do with the GCC extension "Statement Expressions", e.g.
2179 ;;;; while ({stmt1 ; stmt2 ; exp ;}). This form excludes such Statement Expressions.
2185 ;; End of a PIKE special brace list? If so, step over it and continue.
2194 ;; Have we got a '}' after having moved? If so, stop after the
2195 ;; previous token.
2201 ;; Stop if we encounter a preprocessor line.
2206 ;(throw 'done (cons (eq (point) here) 'macro-boundary))) ; Changed 2003/3/26
2209 ;; Stop after a ';', '}', or "};"
2214 ;; Found a string (this subsumes AWK regexps)?
2225 )))))
2228 ;; Is the literal defined by RANGE a string contained in a single line?
2229 ;;
2230 ;; This function might do hidden buffer changes.
2238 "Go to the beginning of the innermost C statement.
2239 With prefix arg, go back N - 1 statements. If already at the
2240 beginning of a statement then go to the beginning of the closest
2241 preceding one, moving into nested blocks if necessary (use
2243 comment or multiline string, move by sentences instead of statements.
2245 When called from a program, this function takes 3 optional args: the
2246 repetition count, a buffer position limit which is the farthest back
2247 to search for the syntactic context, and a flag saying whether to do
2248 sentence motion in or near comments and multiline strings.
2250 Note that for use in programs, `c-beginning-of-statement-1' is
2251 usually better. It has much better defined semantics than this one,
2252 which is intended for interactive use, and might therefore change to
2255 nil t))
2260 last ; start point for going back ONE chunk. Updated each chunk movement.
2263 res ; result from sub-function call
2264 not-bos ; "not beginning-of-statement"
2265 (range (c-collect-line-comments (c-literal-limits lim)))) ; (start.end) of current literal or NIL
2267 ;; Go back one statement at each iteration of the following loop.
2270 ;; Go back one "chunk" each time round the following loop, stopping
2271 ;; when we reach a statement boundary, etc.
2275 ; statement boundary, non-NIL otherwise.
2278 nil)
2282 ;; Single line string or sentence-flag is null => skip the
2283 ;; entire literal.
2288 ;; N.B. The following is essentially testing for an AWK regexp
2289 ;; at BOS:
2290 ;; Was the previous non-ws thing an end of statement?
2297 ;; Comment inside a statement or a multi-line string.
2303 res)))
2305 ;; Non-literal code.
2312 ;; We're at a tentative BOS. The next form goes
2313 ;; back over WS looking for an end of previous
2314 ;; statement.
2320 ;; Are we about to move backwards into or out of a
2321 ;; preprocessor command? If so, locate it's beginning.
2329 ;; Are we about to move backwards into a literal?
2332 not-bos))
2339 "Go to the end of the innermost C statement.
2340 With prefix arg, go forward N - 1 statements. Move forward to the end
2341 of the next statement if already at end, and move into nested blocks
2343 comment or multiline string, move by sentences instead of statements.
2345 When called from a program, this function takes 3 optional args: the
2346 repetition count, a buffer position limit which is the farthest back
2347 to search for the syntactic context, and a flag saying whether to do
2348 sentence motion in or near comments and multiline strings."
2350 nil t))
2360 res
2361 (range (c-collect-line-comments (c-literal-limits lim)))) ; (start.end) of current literal or NIL
2363 ;; Go back/forward one statement at each iteration of the following loop.
2368 ;; Go forward one "chunk" each time round the following loop, stopping
2369 ;; when we reach a statement boundary, etc.
2372 ; statement boundary, non-NIL otherwise.
2375 nil)
2379 ;; sentence-flag is null => skip the entire literal.
2380 ;; or a Single line string.
2385 ;; Is there a virtual semicolon here (e.g. for AWK)?
2388 ;; Comment or multi-line string.
2394 ;; If we've just come forward out of a literal, check for
2395 ;; vsemi. (N.B. AWK can't have a vsemi after a comment, but
2396 ;; some other language may do in the future)
2400 ;; Non-literal code.
2403 ;; Are we about to move forward into or out of a
2404 ;; preprocessor command?
2414 ;; Are we about to move forward into a literal?
2423 \f
2424 ;; set up electric character functions to work with pending-del,
2425 ;; (a.k.a. delsel) mode. All symbols get the t value except
2426 ;; the functions which delete, which gets 'supersede.
2433 c-electric-brace
2434 c-electric-slash
2435 c-electric-star
2436 c-electric-semi&comma
2437 c-electric-lt-gt
2438 c-electric-colon
2439 c-electric-paren))
2447 \f
2449 ;; This function might do hidden buffer changes.
2462 ;; Do not pad with one space if we're at bol.
2463 value
2474 ;; Found comment to align with.
2476 ;; Do not pad with one space if we're at bol.
2477 0
2479 ;; Recurse to handle value as a new spec.
2483 "Used by `indent-for-comment' to create and indent comments.
2484 See `c-indent-comment-alist' for a description."
2513 c-indent-comments-syntactically-p)
2515 ;; BOGOSITY ALERT: if we're looking at the eol, its
2516 ;; because indent-for-comment hasn't put the comment-start
2517 ;; in the buffer yet. this will screw up the syntactic
2518 ;; analysis so we kludge in the necessary info. Another
2519 ;; kludge is that if we're at the bol, then we really want
2520 ;; to ignore any anchoring as specified by
2521 ;; c-comment-only-line-offset since it doesn't apply here.
2526 c-comment-only-line-offset
2528 c-comment-only-line-offset))))
2533 \f
2534 ;; used by outline-minor-mode
2537 ;; in otherwise-hidden text.
2542 \f
2544 "Move back to the containing preprocessor conditional, leaving mark behind.
2545 A prefix argument acts as a repeat count. With a negative argument,
2546 move forward to the end of the containing preprocessor conditional.
2549 function stops at them when going backward, but not when going
2550 forward."
2558 directives."
2564 "Move forward into the next preprocessor conditional, leaving mark behind.
2565 A prefix argument acts as a repeat count. With a negative argument,
2566 move backward into the previous preprocessor conditional.
2569 function stops at them when going forward, but not when going
2570 backward."
2578 directives."
2584 "Move back across a preprocessor conditional, leaving mark behind.
2585 A prefix argument acts as a repeat count. With a negative argument,
2586 move forward across a preprocessor conditional."
2592 "Move forward across a preprocessor conditional, leaving mark behind.
2593 A prefix argument acts as a repeat count. With a negative argument,
2594 move backward across a preprocessor conditional.
2597 the nesting level isn't changed when tracking subconditionals.
2599 The optional argument TARGET-DEPTH specifies the wanted nesting depth
2600 after each scan. I.e. if TARGET-DEPTH is -1, the function will move
2601 out of the enclosing conditional. A non-integer non-nil TARGET-DEPTH
2602 counts as -1.
2605 are treated as conditional clause limits. Normally they are ignored."
2616 ;; subdepth is the depth in "uninteresting" subtrees,
2617 ;; i.e. those that takes us farther from the target
2618 ;; depth instead of closer.
2620 found)
2622 ;; Find the "next" significant line in the proper direction.
2624 ;; Rather than searching for a # sign that
2625 ;; comes at the beginning of a line aside from
2626 ;; whitespace, search first for a string
2627 ;; starting with # sign. Then verify what
2628 ;; precedes it. This is faster on account of
2629 ;; the fastmap feature of the regexp matcher.
2632 nil t))
2634 ;; Now verify it is really a preproc line.
2642 ;; When we're not in an "uninteresting"
2643 ;; subtree, we might want to act on "elif"
2644 ;; and "else" too.
2646 ;; Always move toward the target depth.
2651 ;; Ignore the change if it'd take us
2652 ;; into an "uninteresting" subtree.
2660 ;; If we are trying to move across, and we find an
2661 ;; end before we find a beginning, get an error.
2664 "No following conditional at this level"
2666 ;; When searching forward, start from next line so
2667 ;; that we don't find the same line again.
2669 ;; We found something if we've arrived at the
2670 ;; target depth.
2673 ;; else
2683 \f
2684 ;; commands to indent lines, regions, defuns, and expressions
2686 "Indent current line as C code, and/or insert some whitespace.
2688 If `c-tab-always-indent' is t, always just indent the current line.
2689 If nil, indent the current line only if point is at the left margin or
2690 in the line's indentation; otherwise insert some whitespace[*]. If
2691 other than nil or t, then some whitespace[*] is inserted only within
2692 literals (comments and strings), but the line is always reindented.
2694 If `c-syntactic-indentation' is t, indentation is done according to
2695 the syntactic context. A numeric argument, regardless of its value,
2696 means indent rigidly all the lines of the expression starting after
2697 point so that this line becomes properly indented. The relative
2698 indentation among the lines of the expression is preserved.
2700 If `c-syntactic-indentation' is nil, the line is just indented one
2701 step according to `c-basic-offset'. In this mode, a numeric argument
2702 indents a number of such steps, positive or negative, and an empty
2703 prefix argument is equivalent to -1.
2705 [*] The amount and kind of whitespace inserted is controlled by the
2706 variable `c-insert-tab-function', which is called to do the actual
2707 insertion of whitespace. Normally the function in this variable
2708 just inserts a tab character, or the equivalent number of spaces,
2709 depending on the variable `indent-tabs-mode'."
2718 -1
2726 ;; Realign the line continuation backslash if inside a macro.
2728 ))))
2730 ;; If c-syntactic-indentation and got arg, always indent this
2731 ;; line as C and shift remaining lines of expression the same
2732 ;; amount.
2736 beg end)
2741 shift-amt))
2753 ;; Else use c-tab-always-indent to determine behavior.
2755 ;; CASE 1: indent when at column zero or in line's indentation,
2756 ;; otherwise insert a tab
2763 ;; CASE 2: just indent the line
2766 ;; CASE 3: if in a literal, insert a tab, but always indent the
2767 ;; line
2772 )))))
2775 "Indent each line in the balanced expression following point syntactically.
2776 If optional SHUTUP-P is non-nil, no errors are signalled if no
2777 balanced expression is found."
2780 end)
2784 ;; Find the closest following open paren that
2785 ;; ends on another line.
2793 ;; sanity check
2809 "Indent the current top-level declaration or macro syntactically.
2810 In the macro case this also has the effect of realigning any line
2811 continuation backslashes, unless `c-auto-align-backslashes' is nil."
2817 ;; We try to be line oriented, unless there are several
2818 ;; declarations on the same line.
2830 "Indent syntactically every line whose first char is between START
2831 and END inclusive. If the optional argument QUIET is non-nil then no
2832 syntactic errors are reported, even if `c-report-syntactic-errors' is
2833 non-nil."
2839 ;; Advance to first nonblank line.
2847 ;; shut up any echo msgs on indiv lines
2852 start))
2854 syntax)
2861 ;; update progress
2863 ;; skip empty lines
2866 ;; Get syntax and indent.
2871 ;; Record macro start.
2880 ;; Fixup macro backslashes.
2892 c-parsing-error))))
2895 ;; Function version of the macro for use in places that aren't
2896 ;; compiled, e.g. in the menus.
2900 "When the region is active, indent it syntactically. Otherwise
2901 indent the current line syntactically."
2902 ;; Emacs has a variable called mark-active, XEmacs uses region-active-p
2908 \f
2909 ;; for progress reporting
2914 ;; Be silent
2916 ;; Start the progress update messages. If this Emacs doesn't have
2917 ;; a built-in timer, just be dumb about it.
2920 ;; If progress has already been initialized, do nothing. otherwise
2921 ;; initialize the counter with a vector of:
2922 ;; [start end lastsec context]
2929 context))
2931 ))
2935 nil
2940 ;; should we update? currently, update happens every 2 seconds,
2941 ;; what's the right value?
2947 )))
2951 nil
2960 \f
2961 ;;; This page handles insertion and removal of backslashes for C macros.
2964 "Insert, align, or delete end-of-line backslashes on the lines in the region.
2965 With no argument, inserts backslashes and aligns existing backslashes.
2966 With an argument, deletes the backslashes. The backslash alignment is
2967 done according to the settings in `c-backslash-column',
2968 `c-backslash-max-column' and `c-auto-align-backslashes'.
2970 This function does not modify blank lines at the start of the region.
2971 If the region ends at the start of a line and the macro doesn't
2972 continue below it, the backslash (if any) at the end of the previous
2973 line is deleted.
2975 You can put the region around an entire macro definition and use this
2976 command to conveniently insert and align the necessary backslashes."
2979 ;; Keep the backslash trimming functions from changing the
2980 ;; whitespace around point, since in this case it's only the
2981 ;; position of point that tells the indentation of the line.
2987 column longest-line-col bs-col-after-end)
2991 ;; Nothing to do if to is at bob, since we should back up
2992 ;; and there's no line to back up to.
2993 nil
2995 ;; Do not back up the to line if line-mode is set, to make
2996 ;; e.g. c-newline-and-indent consistent regardless whether
2997 ;; the (newline) call leaves point at bol or not.
3005 ;; Set bs-col-after-end to the column of any backslash
3006 ;; following the region, or nil if there is none.
3015 ;; Back up the to line if line-mode is set, since the line
3016 ;; after the newly inserted line break should not be
3017 ;; touched in c-newline-and-indent.
3020 ;; Set bs-col-after-end to non-nil in any case, since we
3021 ;; do not want to delete the backslash at the last line.
3026 ;; Compute the smallest column number past the ends of all
3027 ;; the lines.
3031 ;; Include one more line in the max column
3032 ;; calculation, since the to line will be backslashed
3033 ;; too.
3046 ;; Try to align with surrounding backslashes.
3055 ;; Both a preceding and a following backslash.
3056 ;; Choose the greatest of them.
3059 ;; No preceding backslash. Try to align with one
3060 ;; following the region. Disregard the backslash at the
3061 ;; to line since it's likely to be bogus (e.g. when
3062 ;; called from c-newline-and-indent).
3065 ;; Don't modify blank lines at start of region.
3070 ;; Don't try to align with surrounding backslashes if
3071 ;; any line is too long.
3074 ;; Impose minimum limit and tab width alignment only if
3075 ;; we can't align with surrounding backslashes.
3079 tab-width)
3080 tab-width)))
3082 longest-line-col)))
3083 ;; Always impose maximum limit.
3086 ;; Add backslashes on all lines if the macro continues
3087 ;; after the to line.
3091 ;; Add backslashes on all lines except the last, and
3092 ;; remove any on the last line.
3100 ;; The function above leaves point on the line
3101 ;; following endmark.
3126 ;; Avoid unnecessary changes of the buffer.
3128 ;; Don't realign backslashes in string literals
3129 ;; since that would change them.
3130 )
3156 ;; Make sure there are backslashes with at least one space in
3157 ;; front of them.
3192 point-pos))
3198 \f
3199 ;;; Line breaking and paragraph filling.
3205 ;; The filling code is based on a simple theory; leave the intricacies
3206 ;; of the text handling to the currently active mode for that
3207 ;; (e.g. adaptive-fill-mode or filladapt-mode) and do as little as
3208 ;; possible to make them work correctly wrt the comment and string
3209 ;; separators, one-line paragraphs etc. Unfortunately, when it comes
3210 ;; to it, there's quite a lot of special cases to handle which makes
3211 ;; the code anything but simple. The intention is that it will work
3212 ;; with any well-written text filling package that preserves a fill
3213 ;; prefix.
3214 ;;
3215 ;; We temporarily mask comment starters and enders as necessary for
3216 ;; the filling code to do its job on a seemingly normal text block.
3217 ;; We do _not_ mask the fill prefix, so it's up to the filling code to
3218 ;; preserve it correctly (especially important when filling C++ style
3219 ;; line comments). By default, we set up and use adaptive-fill-mode,
3220 ;; which is standard in all supported Emacs flavors.
3223 ;; Determine the appropriate comment fill prefix for a block or line
3224 ;; comment. Return a cons of the prefix string and the column where
3225 ;; it ends. If fill-prefix is set, it'll override. Note that this
3226 ;; function also uses the value of point in some heuristics.
3227 ;;
3228 ;; This function might do hidden buffer changes.
3232 c-current-comment-prefix
3235 prefix-regexp
3236 comment-start-skip))
3237 prefix-line comment-prefix res comment-text-end)
3242 ;; Ugly way of getting the column after the fill
3243 ;; prefix; it'd be nice with a current-column
3244 ;; that works on strings..
3254 ;; Set fallback for comment-prefix if none is found.
3260 ;; The current line is not the comment starter, so the
3261 ;; comment has more than one line, and it can therefore be
3262 ;; used to find the comment fill prefix.
3268 ;; The line after the comment starter is inside the
3269 ;; comment, so we can use it.
3272 ;; The comment is only one line. Take the comment prefix
3273 ;; from it and keep the indentation.
3282 ;; There is only whitespace before the comment
3283 ;; starter; take the prefix straight from this line.
3288 ;; There is code before the comment starter, so we
3289 ;; have to temporarily insert and indent a new line to
3290 ;; get the right space/tab mix in the indentation.
3292 tmp)
3308 ;; The prefix ends the line with no whitespace
3309 ;; after it. Default to a single space.
3311 )))))
3324 ;; The current line is not the comment starter and
3325 ;; contains more than just the ender, so it's good enough
3326 ;; to be used for the comment fill prefix.
3336 ;; The comment is either one line or the next line contains
3337 ;; just the comment ender. In this case we have no
3338 ;; information about a suitable comment prefix, so we resort
3339 ;; to c-block-comment-prefix.
3343 ;; The point was on the comment opener line, so we might want
3344 ;; to treat this as a not yet closed comment.
3348 ;; Above `prefix-regexp' matched a nonempty prefix on the
3349 ;; second line, so let's use it. Normally it should do
3350 ;; to set `prefix-line' and let the code below pick up
3351 ;; the whole prefix, but if there's no text after the
3352 ;; match then it will probably fall back to no prefix at
3353 ;; all if the comment isn't closed yet, so in that case
3354 ;; it's better to force use of the prefix matched now.
3359 ;; There's no nonempty prefix on the line after the
3360 ;; comment opener. If the line is empty, or if the
3361 ;; text on it has less or equal indentation than the
3362 ;; comment starter we assume it's an unclosed
3363 ;; comment starter, i.e. that
3364 ;; `c-block-comment-prefix' should be used.
3365 ;; Otherwise we assume it's a closed comment where
3366 ;; the prefix really is the empty string.
3367 ;; E.g. this is an unclosed comment:
3368 ;;
3369 ;; /*
3370 ;; foo
3371 ;;
3372 ;; But this is not:
3373 ;;
3374 ;; /*
3375 ;; foo
3376 ;; */
3377 ;;
3378 ;; (Looking for the presence of the comment closer
3379 ;; rarely works since it's probably the closer of
3380 ;; some comment further down when the comment
3381 ;; really is unclosed.)
3390 ;; Otherwise the line after the comment starter is good
3391 ;; enough to find the prefix in.
3395 ;; Haven't got the comment prefix on any real line that we
3396 ;; can take it from, so we have to temporarily insert
3397 ;; `comment-prefix' on a line and indent it to find the
3398 ;; correct column and the correct mix of tabs and spaces.
3407 comment-text-end))
3412 ;; If there's ws on the current line, we'll use it
3413 ;; instead of what's ending comment-prefix.
3418 comment-prefix))
3427 ;; We insert an extra non-whitespace character
3428 ;; before the line break and after comment-prefix in
3429 ;; case it's "" or ends with whitespace.
3448 ;; prefix-line is the bol of a line on which we should try
3449 ;; to find the prefix.
3456 ;; The match is fine if there's text after it.
3462 ;; This match is better than nothing, so let's
3463 ;; remember it in case nothing better is found
3464 ;; on another line.
3468 t))))
3471 ;; Search for a line which has text after the prefix
3472 ;; so that we get the proper amount of whitespace
3473 ;; after it. We start with the current line, then
3474 ;; search backwards, then forwards.
3479 ;; The whitespace is sucked up by the
3480 ;; first [ \t]* glob if the prefix is empty.
3483 ;; If the current line doesn't have text but do
3484 ;; have whitespace after the prefix, we'll use it.
3490 ;; For line comments we can search up to and
3491 ;; including the first line.
3495 ;; For block comments we must stop before the
3496 ;; block starter.
3507 nil)
3510 ;; A good line wasn't found, but at least we have a
3511 ;; fallback that matches the comment prefix regexp.
3516 ;; There are ws or text after the prefix, so
3517 ;; let's use it.
3521 ;; Check if there's any whitespace padding
3522 ;; on the comment start line that we can
3523 ;; use after the prefix.
3541 ;; Got to mess in the buffer once again to
3542 ;; ensure the column gets correct. :P
3553 ;; Last resort: Just add a single space after
3554 ;; the prefix.
3559 ;; The line doesn't match the comment prefix regexp.
3561 ;; We have a fallback for line comments that we must use.
3564 comment-prefix)
3568 ;; Assume we are dealing with a "free text" block
3569 ;; comment where the lines doesn't have any comment
3570 ;; prefix at all and we should just fill it as
3571 ;; normal text.
3573 ))
3576 ;; Calls FUN with ARGS ar arguments while the current paragraph is
3577 ;; masked to allow adaptive filling to work correctly. That
3578 ;; includes narrowing the buffer and, if point is inside a comment,
3579 ;; masking the comment starter and ender appropriately.
3580 ;;
3581 ;; FILL-PARAGRAPH is non-nil if called for whole paragraph filling.
3582 ;; The position of point is then less significant when doing masking
3583 ;; and narrowing.
3584 ;;
3585 ;; If APPLY-OUTSIDE-LITERAL is nil then the function will be called
3586 ;; only if the point turns out to be inside a comment or a string.
3587 ;;
3588 ;; Note that this function does not do any hidden buffer changes.
3591 ;; beg and end limits the region to narrow. end is a marker.
3592 beg end
3593 ;; tmp-pre and tmp-post mark strings that are temporarily
3594 ;; inserted at the start and end of the region. tmp-pre is a
3595 ;; cons of the positions of the prepended string. tmp-post is
3596 ;; a marker pointing to the single character of the appended
3597 ;; string.
3598 tmp-pre tmp-post
3599 ;; If hang-ender-stuck isn't nil, the comment ender is
3600 ;; hanging. In that case it's set to the number of spaces
3601 ;; that should be between the text and the ender.
3602 hang-ender-stuck
3603 ;; auto-fill-spaces is the exact sequence of whitespace between a
3604 ;; comment's last word and the comment ender, temporarily replaced
3605 ;; with 'x's before calling FUN when FILL-PARAGRAPH is nil.
3606 auto-fill-spaces
3611 ;; Restore point on undo. It's necessary since we do a lot of
3612 ;; hidden inserts and deletes below that should be as transparent
3613 ;; as possible.
3619 ;; Widen to catch comment limits correctly.
3648 ;; Limit to the comment or paragraph end, whichever
3649 ;; comes first.
3653 ;; The region includes the comment starter, so we must
3654 ;; check it.
3658 ;; Include the first line in the region.
3660 ;; The first line contains code before the
3661 ;; comment. We must fake a line that doesn't.
3668 ;; The region includes the comment ender which we might
3669 ;; want to keep together with the last word.
3674 c-current-comment-prefix
3677 ;; The comment ender is on a line of its
3678 ;; own. Keep it that way.
3681 ;; The comment ender should hang. Replace all space between
3682 ;; it and the last word either by one or two 'x's (when
3683 ;; FILL-PARAGRAPH is non-nil), or a row of x's the same width
3684 ;; as the whitespace (when auto filling), and include it in
3685 ;; the region. We'll change them back to whitespace
3686 ;; afterwards. The effect of this is to glue the comment
3687 ;; ender to the last word in the comment during filling.
3696 spaces)
3705 c-current-comment-prefix
3708 ;; The comment ender is prefixed by nothing
3709 ;; but a comment line prefix. Remove it
3710 ;; along with surrounding ws.
3714 ; " \t"? "*/" is NOT alone on the line (ACM, 2005/8/18)
3719 ;; Don't adjust point below if it's
3720 ;; before the string we replace.
3722 ;; Keep one or two spaces between the
3723 ;; text and the ender, depending on how
3724 ;; many there are now.
3729 ;; paragraph filling condenses multiple spaces to
3730 ;; single or double spaces. auto-fill doesn't.
3737 ;; Insert the filler first to keep marks right.
3746 ;; Point was in the middle of the string we
3747 ;; replaced above, so put it back in the same
3748 ;; relative position, counting from the end.
3750 ))
3753 ;; The region includes the comment starter.
3757 ;; Begin with the next line.
3759 ;; Fake the fill prefix in the first line.
3774 ;; Leave the start line if it's
3775 ;; nothing but an escaped newline.
3781 ;; Narrow to the macro limits if they are nearer than the
3782 ;; paragraph limits. Don't know if this is necessary but
3783 ;; do it for completeness sake (doing auto filling at all
3784 ;; inside macros is bogus to begin with since the line
3785 ;; continuation backslashes aren't handled).
3798 ;; Try to avoid comments and macros in the paragraph to
3799 ;; avoid that the adaptive fill mode gets the prefix from
3800 ;; them.
3813 ;; Temporarily insert the fill prefix after the comment
3814 ;; starter so that the first line looks like any other
3815 ;; comment line in the narrowed region.
3819 c-current-comment-prefix
3822 ;; Oops, the prefix doesn't match the comment prefix
3823 ;; regexp. This could produce very confusing
3824 ;; results with adaptive fill packages together with
3825 ;; the insert prefix magic below, since the prefix
3826 ;; often doesn't appear at all. So let's warn about
3827 ;; it.
3829 Warning: Regexp from `c-comment-prefix-regexp' doesn't match the comment prefix %S"
3831 ;; Find the right spot on the line, break it, insert
3832 ;; the fill prefix and make sure we're back in the
3833 ;; same column by temporarily prefixing the first word
3834 ;; with a number of 'x'.
3838 c-current-comment-prefix
3839 comment-start-skip))
3856 ;; `apply-outside-literal' is always set to t here if
3857 ;; we're inside a literal.
3861 ;; Kludge: If the function that adapts the fill prefix
3862 ;; doesn't produce the required comment starter for
3863 ;; line comments, then force it by setting fill-prefix.
3865 ;; Kludge the kludge: filladapt-mode doesn't
3866 ;; have this problem, but it currently
3867 ;; doesn't override fill-context-prefix
3868 ;; (version 2.12).
3870 filladapt-mode))
3877 c-lit-limits c-lit-type)))))))
3879 ;; Save the relative position of point if it's outside the
3880 ;; region we're going to narrow. Want to restore it in that
3881 ;; case, but otherwise it should be moved according to the
3882 ;; called function.
3886 ;; Preparations finally done! Now we can call the
3887 ;; actual function.
3893 ;; Restore point if it was outside the region.
3906 ;; Preserve point even if it's in the middle of the string
3907 ;; we replace; save-excursion doesn't work in that case.
3924 If any of the current line is a comment or within a comment, fill the
3925 comment or the paragraph of it that point is in, preserving the
3926 comment indentation or line-starting decorations (see the
3927 `c-comment-prefix-regexp' and `c-block-comment-prefix' variables for
3928 details).
3930 If point is inside multiline string literal, fill it. This currently
3931 does not respect escaped newlines, except for the special case when it
3932 is the very first thing in the string. The intended use for this rule
3933 is in situations like the following:
3936 A very long description of something that you want to fill to make
3939 If point is in any other situation, i.e. in normal code, do nothing.
3941 Optional prefix ARG means justify paragraph as well."
3944 ;; Avoid infinite recursion.
3946 fill-paragraph-function)))
3948 ;; Always return t. This has the effect that if filling isn't done
3949 ;; above, it isn't done at all, and it's therefore effectively
3950 ;; disabled in normal code.
3951 t)
3954 ;; Do automatic filling if not inside a context where it should be
3955 ;; ignored.
3957 ;; The decision whether the line should be broken is actually
3958 ;; done in c-indent-new-comment-line, which do-auto-fill
3959 ;; calls to break lines. We just set this special variable
3960 ;; so that we'll know when we're called from there. It's
3961 ;; also used to detect whether fill-prefix is user set or
3962 ;; generated automatically by do-auto-fill.
3963 fill-prefix))
3967 "Break line at point and indent, continuing comment or macro if within one.
3968 If inside a comment and `comment-multi-line' is non-nil, the
3969 indentation and line prefix are preserved (see the
3970 `c-comment-prefix-regexp' and `c-block-comment-prefix' variables for
3971 details). If inside a single line comment and `comment-multi-line' is
3972 nil, a new comment of the same type is started on the next line and
3973 indented as appropriate for comments. If inside a macro, a line
3974 continuation backslash is inserted and aligned as appropriate, and the
3975 new line is indented according to `c-syntactic-indentation'.
3977 If a fill prefix is specified, it overrides all the above."
3978 ;; allow-auto-fill is used from c-context-line-break to allow auto
3979 ;; filling to break the line more than once. Since this function is
3980 ;; used from auto-fill itself, that's normally disabled to avoid
3981 ;; unnecessary recursion.
3990 ;; Already know the literal type and limits when called from
3991 ;; c-context-line-break.
3998 ;; Called from do-auto-fill.
4006 c-ignore-auto-fill)
4011 ;; The adaptive fill function has generated a prefix, but
4012 ;; we're on the first line in a block comment so it'll be
4013 ;; wrong. Ignore it to guess a better one below.
4017 c-line-comment-starter)
4019 ;; Kludge: If the function that adapted the fill prefix
4020 ;; doesn't produce the required comment starter for line
4021 ;; comments, then we ignore it.
4023 )))
4026 ;; A call from do-auto-fill which should be ignored.
4027 )
4029 ;; A fill-prefix overrides anything.
4038 ;; Some sort of comment.
4044 ;; Inside a comment that should be continued.
4049 c-lit-type)))
4057 ;; Skip forward past the fill prefix in case
4058 ;; we're standing in it.
4059 ;;
4060 ;; FIXME: This doesn't work well in cases like
4061 ;;
4062 ;; /* Bla bla bla bla bla
4063 ;; bla bla
4064 ;;
4065 ;; If point is on the 'B' then the line will be
4066 ;; broken after "Bla b".
4073 ;; The skip takes us out of the (block)
4074 ;; comment; insert the fill prefix at bol
4075 ;; instead and keep the position.
4082 ;; Don't break in the middle of a comment starter
4083 ;; or ender.
4090 ;; Inside a comment that should be broken.
4093 col)
4107 ;; c-comment-indent may look at the current
4108 ;; indentation, so let's start out with the same
4109 ;; indentation as the previous one.
4114 ;; In a macro.
4116 ;; Do not clobber the alignment of the line continuation
4117 ;; slash; c-backslash-region might look at it.
4119 ;; Got an asymmetry here: In normal code this command
4120 ;; doesn't indent the next line syntactically, and otoh a
4121 ;; normal syntactically indenting newline doesn't continue
4122 ;; the macro.
4125 ;; Somewhere else in the code.
4137 ;; advice for indent-new-comment-line for older Emacsen
4141 activate preactivate)
4142 "Call `c-indent-new-comment-line' if in CC Mode."
4145 ad-do-it
4150 "Do a line break suitable to the context.
4152 When point is outside a comment or macro, insert a newline and indent
4153 according to the syntactic context, unless `c-syntactic-indentation'
4154 is nil, in which case the new line is indented as the previous
4155 non-empty line instead.
4157 When point is inside the content of a preprocessor directive, a line
4158 continuation backslash is inserted before the line break and aligned
4159 appropriately. The end of the cpp directive doesn't count as inside
4160 it.
4162 When point is inside a comment, continue it with the appropriate
4163 comment prefix (see the `c-comment-prefix-regexp' and
4164 `c-block-comment-prefix' variables for details). The end of a
4165 C++-style line comment doesn't count as inside it."
4180 c-lit-limits))))))
4198 ;; c-indent-line may look at the current indentation, so let's
4199 ;; start out with the same indentation as the previous line.
4210 "Insert a line break suitable to the context and leave point before it.
4211 This is the `c-context-line-break' equivalent to `open-line', which is
4212 normally bound to C-o. See `c-context-line-break' for the details."
4217 ;; Temporarily insert a non-whitespace char to keep any
4218 ;; preceding whitespace intact.
4224 \f
4227 ;;; arch-tag: bf0611dc-d1f4-449e-9e45-4ec7c6936677
4228 ;;; cc-cmds.el ends here