1 ;;; cc-vars.el --- user customization variables for CC Mode
3 ;; Copyright (C) 1985, 1987, 1992-2013 Free Software Foundation, Inc.
5 ;; Authors: 2002- Alan Mackenzie
6 ;; 1998- Martin Stjernholm
7 ;; 1992-1999 Barry A. Warsaw
10 ;; 1985 Richard M. Stallman
11 ;; Maintainer: bug-cc-mode@gnu.org
12 ;; Created: 22-Apr-1997 (split from cc-mode.el)
13 ;; Keywords: c languages
16 ;; This file is part of GNU Emacs.
18 ;; GNU Emacs is free software: you can redistribute it and/or modify
19 ;; it under the terms of the GNU General Public License as published by
20 ;; the Free Software Foundation, either version 3 of the License, or
21 ;; (at your option) any later version.
23 ;; GNU Emacs is distributed in the hope that it will be useful,
24 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
25 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
26 ;; GNU General Public License for more details.
28 ;; You should have received a copy of the GNU General Public License
29 ;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
37 (if (and (boundp 'byte-compile-dest-file
)
38 (stringp byte-compile-dest-file
))
39 (cons (file-name-directory byte-compile-dest-file
) load-path
)
41 (load "cc-bytecomp" nil t
)))
45 ;; Silence the compiler.
46 (cc-bytecomp-defun get-char-table) ; XEmacs
54 ;; This widget exists in newer versions of the Custom library
55 (or (get 'other
'widget-type
)
56 (define-widget 'other
'sexp
57 "Matches everything, but doesn't let the user edit the value.
58 Useful as last item in a `choice' widget."
63 ;; The next defun will supersede c-const-symbol.
65 (defun c-constant-symbol (sym len
)
66 "Create an uneditable symbol for customization buffers.
67 SYM is the name of the symbol, LEN the length of the field (in
68 characters) the symbol will be displayed in. LEN must be big
71 This returns a (const ....) structure, suitable for embedding
72 within a customization type."
73 (or (symbolp sym
) (error "c-constant-symbol: %s is not a symbol" sym
))
74 (let* ((name (symbol-name sym
))
76 (disp (concat name
":" (make-string (- len l
1) ?\
))))
82 (define-widget 'c-const-symbol
'item
83 "An uneditable lisp symbol. This is obsolete -
84 use c-constant-symbol instead."
88 :match
(lambda (widget value
) (symbolp value
))
90 (lambda (widget value
)
91 (let ((s (if (symbolp value
)
94 (l (widget-get widget
:size
)))
96 (setq s
(concat s
(make-string (- l
(length s
)) ?\
))))
99 (lambda (widget value
)
102 (string-match "\\`[^ ]*" value
)
103 (match-string 0 value
)))
106 (define-widget 'c-integer-or-nil
'sexp
107 "An integer or the value nil."
109 :tag
"Optional integer"
110 :match
(lambda (widget value
) (or (integerp value
) (null value
))))
112 (define-widget 'c-symbol-list
'sexp
113 "A single symbol or a list of symbols."
114 :tag
"Symbols separated by spaces"
115 :validate
'widget-field-validate
117 (lambda (widget value
)
121 (unless (symbolp (car value
))
123 (setq value
(cdr value
)))
126 (lambda (widget value
)
132 (mapconcat (lambda (symbol)
133 (symbol-name symbol
))
139 (lambda (widget value
)
142 (while (string-match "\\S +" value end
)
143 (setq list
(cons (intern (match-string 0 value
)) list
)
145 (if (and list
(not (cdr list
)))
150 (defvar c-style-variables
151 '(c-basic-offset c-comment-only-line-offset c-indent-comment-alist
152 c-indent-comments-syntactically-p c-block-comment-prefix
153 c-comment-prefix-regexp c-doc-comment-style c-cleanup-list
154 c-hanging-braces-alist c-hanging-colons-alist
155 c-hanging-semi
&comma-criteria c-backslash-column c-backslash-max-column
156 c-special-indent-hook c-label-minimum-indentation c-offsets-alist
)
157 "List of the style variables.")
159 (defvar c-fallback-style nil
)
161 (defsubst c-set-stylevar-fallback
(name val
)
162 (put name
'c-stylevar-fallback val
)
163 (setq c-fallback-style
(cons (cons name val
) c-fallback-style
)))
165 (defmacro defcustom-c-stylevar
(name val doc
&rest args
)
166 "Define a style variable NAME with VAL and DOC.
167 More precisely, convert the given `:type FOO', mined out of ARGS,
168 to an aggregate `:type (radio STYLE (PREAMBLE FOO))', append some
169 some boilerplate documentation to DOC, arrange for the fallback
170 value of NAME to be VAL, and call `custom-declare-variable' to
171 do the rest of the work.
173 STYLE stands for the choice where the value is taken from some
174 style setting. PREAMBLE is optionally prepended to FOO; that is,
175 if FOO contains :tag or :value, the respective two-element list
176 component is ignored."
177 (declare (debug (symbolp form stringp
&rest
)))
178 (let* ((expanded-doc (concat doc
"
180 This is a style variable. Apart from the valid values described
181 above, it can be set to the symbol `set-from-style'. In that case,
182 it takes its value from the style system (see `c-default-style' and
183 `c-style-alist') when a CC Mode buffer is initialized. Otherwise,
184 the value set here overrides the style system (there is a variable
185 `c-old-style-variable-behavior' that changes this, though)."))
186 (typ (eval (plist-get args
:type
)))
187 (type (if (consp typ
) typ
(list typ
)))
190 (newt (append (unless (plist-get tail
:tag
)
191 '(:tag
"Override style settings"))
192 (unless (plist-get tail
:value
)
193 `(:value
,(eval val
)))
196 (const :tag
"Use style settings" set-from-style
)
199 (c-set-stylevar-fallback ',name
,val
)
200 (custom-declare-variable
201 ',name
''set-from-style
203 ,@(plist-put args
:type aggregate
)))))
205 (defun c-valid-offset (offset)
206 "Return non-nil if OFFSET is a valid offset for a syntactic symbol.
207 See `c-offsets-alist'."
216 (and (symbolp offset
) (boundp offset
))
217 (and (vectorp offset
)
218 (= (length offset
) 1)
219 (integerp (elt offset
0)))
221 (not (eq (car offset
) 'quote
)) ; Detect misquoted lists.
223 (when (memq (car offset
) '(first min max add
))
224 (setq offset
(cdr offset
)))
225 (while (and (consp offset
)
226 (c-valid-offset (car offset
)))
227 (setq offset
(cdr offset
)))
234 (defcustom c-strict-syntax-p nil
235 "*If non-nil, all syntactic symbols must be found in `c-offsets-alist'.
236 If the syntactic symbol for a particular line does not match a symbol
237 in the offsets alist, or if no non-nil offset value can be determined
238 for a symbol, an error is generated, otherwise no error is reported
239 and the syntactic symbol is ignored.
241 This variable is considered obsolete; it doesn't work well with lineup
242 functions that return nil to support the feature of using lists on
243 syntactic symbols in `c-offsets-alist'. Please keep it set to nil."
247 (defcustom c-echo-syntactic-information-p nil
248 "*If non-nil, syntactic info is echoed when the line is indented."
252 (defcustom c-report-syntactic-errors nil
253 "*If non-nil, certain syntactic errors are reported with a ding
254 and a message, for example when an \"else\" is indented for which
255 there's no corresponding \"if\".
257 Note however that CC Mode doesn't make any special effort to check for
258 syntactic errors; that's the job of the compiler. The reason it can
259 report cases like the one above is that it can't find the correct
260 anchoring position to indent the line in that case."
264 (defcustom-c-stylevar c-basic-offset
4
265 "*Amount of basic offset used by + and - symbols in `c-offsets-alist'.
266 Also used as the indentation step when `c-syntactic-indentation' is
270 ;;;###autoload(put 'c-basic-offset 'safe-local-variable 'integerp)
272 (defcustom c-tab-always-indent t
273 "*Controls the operation of the TAB key.
274 If t, hitting TAB always just indents the current line. If nil, hitting
275 TAB indents the current line if point is at the left margin or in the
276 line's indentation, otherwise it calls `c-insert-tab-function' to
277 insert a `real' tab character. If some other value (neither nil nor t),
278 then inserts a tab only within literals (comments and strings), but
279 always reindents the line.
281 Note: the variable `c-comment-only-line-offset' also controls the
282 indentation of lines containing only comments."
284 (const :tag
"TAB key always indents, never inserts TAB" t
)
285 (const :tag
"TAB key indents in left margin, otherwise inserts TAB" nil
)
286 (other :tag
"TAB key inserts TAB in literals, otherwise indents" other
))
289 (defcustom c-insert-tab-function
'insert-tab
290 "*Function used when inserting a tab for \\[c-indent-command].
291 Only used when `c-tab-always-indent' indicates a `real' tab character
292 should be inserted. Value must be a function taking no arguments.
293 The default, `insert-tab', inserts either a tab or the equivalent
294 number of spaces depending on the value of `indent-tabs-mode'."
298 (defcustom c-syntactic-indentation t
299 "*Whether the indentation should be controlled by the syntactic context.
301 If t, the indentation functions indent according to the syntactic
302 context, using the style settings specified by `c-offsets-alist'.
304 If nil, every line is just indented to the same level as the previous
305 one, and the \\[c-indent-command] command adjusts the indentation in
306 steps specified by `c-basic-offset'. The indentation style has no
307 effect in this mode, nor any of the indentation associated variables,
308 e.g. `c-special-indent-hook'."
311 (make-variable-buffer-local 'c-syntactic-indentation
)
312 (put 'c-syntactic-indentation
'safe-local-variable
'booleanp
)
314 (defcustom c-syntactic-indentation-in-macros t
315 "*Enable syntactic analysis inside macros.
316 If this is nil, all lines inside macro definitions are analyzed as
317 `cpp-macro-cont'. Otherwise they are analyzed syntactically, just
318 like normal code, and `cpp-define-intro' is used to create the
319 additional indentation of the bodies of \"#define\" macros.
321 Having this enabled simplifies editing of large multiline macros, but
322 it might complicate editing if CC Mode doesn't recognize the context
323 of the macro content. The default context inside the macro is the
324 same as the top level, so if it contains \"bare\" statements they
325 might be indented wrongly, although there are special cases that
326 handle this in most cases. If this problem occurs, it's usually
327 countered easily by surrounding the statements by a block \(or even
328 better with the \"do { ... } while \(0)\" trick)."
331 (put 'c-syntactic-indentation-in-macros
'safe-local-variable
'booleanp
)
333 (defcustom c-defun-tactic
'go-outward
334 "*Whether functions are recognized inside, e.g., a class.
335 This is used by `c-beginning-of-defun' and like functions.
338 t -- Functions are recognized only at the top level.
339 go-outward -- Nested functions are also recognized. Should a function
340 command hit the beginning/end of a nested scope, it will
341 carry on at the less nested level."
344 (const :tag
"Functions are at the top-level" t
)
345 (const :tag
"Functions are also recognized inside declaration scopes" go-outward
))
348 (defcustom-c-stylevar c-comment-only-line-offset
0
349 "*Extra offset for line which contains only the start of a comment.
350 Can contain an integer or a cons cell of the form:
352 (NON-ANCHORED-OFFSET . ANCHORED-OFFSET)
354 Where NON-ANCHORED-OFFSET is the amount of offset given to
355 non-column-zero anchored comment-only lines, and ANCHORED-OFFSET is
356 the amount of offset to give column-zero anchored comment-only lines.
357 Just an integer as value is equivalent to (<val> . -1000).
359 Note that this variable only has effect when the `c-lineup-comment'
360 lineup function is used on the `comment-intro' syntactic symbol (the
362 :type
'(choice (integer :tag
"Non-anchored offset" 0)
363 (cons :tag
"Non-anchored & anchored offset"
365 (integer :tag
"Non-anchored offset")
366 (integer :tag
"Anchored offset")))
369 (defcustom-c-stylevar c-indent-comment-alist
370 '((anchored-comment .
(column .
0))
371 (end-block .
(space .
1))
372 (cpp-end-block .
(space .
2)))
373 "*Specifies how \\[indent-for-comment] calculates the comment start column.
374 This is an association list that contains entries of the form:
376 (LINE-TYPE . INDENT-SPEC)
378 LINE-TYPE specifies a type of line as described below, and INDENT-SPEC
379 says what \\[indent-for-comment] should do when used on that type of line.
381 The recognized values for LINE-TYPE are:
383 empty-line -- The line is empty.
384 anchored-comment -- The line contains a comment that starts in column 0.
385 end-block -- The line contains a solitary block closing brace.
386 cpp-end-block -- The line contains a preprocessor directive that
387 closes a block, i.e. either \"#endif\" or \"#else\".
388 other -- The line does not match any other entry
389 currently on the list.
391 An INDENT-SPEC is a cons cell of the form:
395 ACTION says how \\[indent-for-comment] should align the comment, and
396 VALUE is interpreted depending on ACTION. ACTION can be any of the
399 space -- Put VALUE spaces between the end of the line and the start
401 column -- Start the comment at the column VALUE. If the line is
402 longer than that, the comment is preceded by a single
403 space. If VALUE is nil, `comment-column' is used.
404 align -- Align the comment with one on the previous line, if there
405 is any. If the line is too long, the comment is preceded
406 by a single space. If there isn't a comment start on the
407 previous line, the behavior is specified by VALUE, which
408 in turn is interpreted as an INDENT-SPEC.
410 If a LINE-TYPE is missing, then \\[indent-for-comment] indents the comment
411 according to `comment-column'.
413 Note that a non-nil value on `c-indent-comments-syntactically-p'
414 overrides this variable, so empty lines are indented syntactically
415 in that case, i.e. as if \\[c-indent-command] was used instead."
417 (let ((space '(cons :tag
"space"
420 (const :format
"space " space
)
421 (integer :format
"%v")))
422 (column '(cons :tag
"column"
424 (const :format
"column " column
)
425 (c-integer-or-nil :format
"%v"))))
429 ,(c-constant-symbol elt
20)
431 :format
"%[Choice%] %v"
432 :value
(column . nil
)
437 (const :format
"align " align
)
439 :format
"%[Choice%] %v"
440 :value
(column . nil
)
443 '(empty-line anchored-comment end-block cpp-end-block other
))))
446 (defcustom-c-stylevar c-indent-comments-syntactically-p nil
447 "*Specifies how \\[indent-for-comment] should handle comment-only lines.
448 When this variable is non-nil, comment-only lines are indented
449 according to syntactic analysis via `c-offsets-alist'. Otherwise, the
450 comment is indented as if it was preceded by code. Note that this
451 variable does not affect how the normal line indentation treats
456 (make-obsolete-variable 'c-comment-continuation-stars
457 'c-block-comment-prefix
"21.1")
459 ;; Although c-comment-continuation-stars is obsolete, we look at it in
460 ;; some places in CC Mode anyway, so make the compiler ignore it
461 ;; during our compilation.
462 ;; [This is unclean; better to use `symbol-value'. --ttn]
463 ;;(cc-bytecomp-obsolete-var c-comment-continuation-stars)
464 ;;(cc-bytecomp-defvar c-comment-continuation-stars)
466 (defcustom-c-stylevar c-block-comment-prefix
467 (if (boundp 'c-comment-continuation-stars
)
468 (symbol-value 'c-comment-continuation-stars
)
470 "*Specifies the line prefix of continued C-style block comments.
471 You should set this variable to the literal string that gets inserted
472 at the front of continued block style comment lines. This should
473 either be the empty string, or some characters without preceding
474 spaces. To adjust the alignment under the comment starter, put an
475 appropriate value on the `c' syntactic symbol (see the
476 `c-offsets-alist' variable).
478 It's only used when a one-line block comment is broken into two or
479 more lines for the first time; otherwise the appropriate prefix is
480 adapted from the comment. This variable is not used for C++ line
485 (defcustom-c-stylevar c-comment-prefix-regexp
486 '((pike-mode .
"//+!?\\|\\**")
488 (other .
"//+\\|\\**"))
489 "*Regexp to match the line prefix inside comments.
490 This regexp is used to recognize the fill prefix inside comments for
491 correct paragraph filling and other things.
493 If this variable is a string, it will be used in all CC Mode major
494 modes. It can also be an association list, to associate specific
495 regexps to specific major modes. The symbol for the major mode is
496 looked up in the association list, and its value is used as the line
497 prefix regexp. If it's not found, then the symbol `other' is looked
498 up and its value is used instead.
500 The regexp should match the prefix used in both C++ style line
501 comments and C style block comments, but it does not need to match a
502 block comment starter. In other words, it should at least match
503 \"//\" for line comments and the string in `c-block-comment-prefix',
504 which is sometimes inserted by CC Mode inside block comments. It
505 should not match any surrounding whitespace.
507 Note that CC Mode uses this variable to set many other variables that
508 handle the paragraph filling. That's done at mode initialization or
509 when you switch to a style which sets this variable. Thus, if you
510 change it in some other way, e.g. interactively in a CC Mode buffer,
511 you will need to do \\[c-setup-paragraph-variables] afterwards so that
512 the other variables are updated with the new value.
514 Note also that when CC Mode starts up, all variables are initialized
515 before the mode hooks are run. It's therefore necessary to make a
516 call to `c-setup-paragraph-variables' explicitly if you change this
517 variable in a mode hook."
519 (regexp :tag
"Regexp for all modes")
521 :tag
"Mode-specific regexps"
523 :inline t
:format
"%v"
525 (const :format
"C " c-mode
) (regexp :format
"%v"))
527 (const :format
"C++ " c
++-mode
) (regexp :format
"%v"))
529 (const :format
"ObjC " objc-mode
) (regexp :format
"%v"))
531 (const :format
"Java " java-mode
) (regexp :format
"%v"))
533 (const :format
"IDL " idl-mode
) (regexp :format
"%v"))
535 (const :format
"Pike " pike-mode
) (regexp :format
"%v"))
537 (const :format
"AWK " awk-mode
) (regexp :format
"%v")))
539 (const :format
"Other " other
) (regexp :format
"%v"))))
542 (defcustom-c-stylevar c-doc-comment-style
543 '((java-mode . javadoc
)
544 (pike-mode . autodoc
)
546 "*Specifies documentation comment style(s) to recognize.
547 This is primarily used to fontify doc comments and the markup within
548 them, e.g. Javadoc comments.
550 The value can be any of the following symbols for various known doc
553 javadoc -- Javadoc style for \"/** ... */\" comments (default in Java mode).
554 autodoc -- Pike autodoc style for \"//! ...\" comments (default in Pike mode).
555 gtkdoc -- GtkDoc style for \"/** ... **/\" comments (default in C mode).
557 The value may also be a list of doc comment styles, in which case all
558 of them are recognized simultaneously (presumably with markup cues
559 that don't conflict).
561 The value may also be an association list to specify different doc
562 comment styles for different languages. The symbol for the major mode
563 is then looked up in the alist, and the value of that element is
564 interpreted as above if found. If it isn't found then the symbol
565 `other' is looked up and its value is used instead.
567 Note that CC Mode uses this variable to set other variables that
568 handle fontification etc. That's done at mode initialization or when
569 you switch to a style which sets this variable. Thus, if you change
570 it in some other way, e.g. interactively in a CC Mode buffer, you will
571 need to do \\[java-mode] (or whatever mode you're currently using) to
574 Note also that when CC Mode starts up, the other variables are
575 modified before the mode hooks are run. If you change this variable
576 in a mode hook, you have to call `c-setup-doc-comment-style'
577 afterwards to redo that work."
578 ;; Symbols other than those documented above may be used on this
579 ;; variable. If a variable exists that has that name with
580 ;; "-font-lock-keywords" appended, its value is prepended to the
581 ;; font lock keywords list. If it's a function then it's called and
582 ;; the result is prepended.
584 (c-symbol-list :tag
"Doc style(s) in all modes")
586 :tag
"Mode-specific doc styles"
588 :inline t
:format
"%v"
590 (const :format
"C " c-mode
)
591 (c-symbol-list :format
"%v"))
593 (const :format
"C++ " c
++-mode
)
594 (c-symbol-list :format
"%v"))
596 (const :format
"ObjC " objc-mode
)
597 (c-symbol-list :format
"%v"))
599 (const :format
"Java " java-mode
)
600 (c-symbol-list :format
"%v"))
602 (const :format
"IDL " idl-mode
)
603 (c-symbol-list :format
"%v"))
605 (const :format
"Pike " pike-mode
)
606 (c-symbol-list :format
"%v"))
608 (const :format
"AWK " awk-mode
)
609 (c-symbol-list :format
"%v"))
611 (const :format
"Other " other
)
612 (c-symbol-list :format
"%v")))))
615 (defcustom c-ignore-auto-fill
'(string cpp code
)
616 "*List of contexts in which automatic filling never occurs.
617 If Auto Fill mode is active, it will be temporarily disabled if point
618 is in any context on this list. It's e.g. useful to enable Auto Fill
619 in comments only, but not in strings or normal code. The valid
622 string -- inside a string or character literal
623 c -- inside a C style block comment
624 c++ -- inside a C++ style line comment
625 cpp -- inside a preprocessor directive
626 code -- anywhere else, i.e. in normal code"
628 (const :tag
"String literals" string
)
629 (const :tag
"C style block comments" c
)
630 (const :tag
"C++ style line comments" c
++)
631 (const :tag
"Preprocessor directives" cpp
)
632 (const :tag
"Normal code" code
))
635 (defcustom-c-stylevar c-cleanup-list
'(scope-operator)
636 "*List of various C/C++/ObjC constructs to \"clean up\".
637 The following clean ups only take place when the auto-newline feature
638 is turned on, as evidenced by the `/la' appearing next to the mode
641 brace-else-brace -- Clean up \"} else {\" constructs by placing
642 entire construct on a single line. This clean
643 up only takes place when there is nothing but
644 white space between the braces and the `else'.
645 Clean up occurs when the open brace after the
647 brace-elseif-brace -- Similar to brace-else-brace, but clean up
648 \"} else if (...) {\" constructs. Clean up
649 occurs after the open parenthesis and the open
651 brace-catch-brace -- Similar to brace-elseif-brace, but clean up
652 \"} catch (...) {\" constructs.
653 empty-defun-braces -- Clean up empty defun braces by placing the
654 braces on the same line. Clean up occurs when
655 the defun closing brace is typed.
656 one-liner-defun -- If the code inside a function body can fit in
657 a single line, then remove any newlines
658 between that line and the defun braces so that
659 the whole body becomes a single line.
660 `c-max-one-liner-length' gives the maximum
661 length allowed for the resulting line. Clean
662 up occurs when the closing brace is typed.
663 defun-close-semi -- Clean up the terminating semi-colon on defuns
664 by placing the semi-colon on the same line as
665 the closing brace. Clean up occurs when the
667 list-close-comma -- Clean up commas following braces in array
668 and aggregate initializers. Clean up occurs
669 when the comma is typed.
670 scope-operator -- Clean up double colons which may designate
671 a C++ scope operator split across multiple
672 lines. Note that certain C++ constructs can
673 generate ambiguous situations. This clean up
674 only takes place when there is nothing but
675 whitespace between colons. Clean up occurs
676 when the second colon is typed.
678 The following clean ups always take place when they are on this list,
679 regardless of the auto-newline feature, since they typically don't
680 involve auto-newline inserted newlines:
682 space-before-funcall -- Insert exactly one space before the opening
683 parenthesis of a function call. Clean up
684 occurs when the opening parenthesis is typed.
685 compact-empty-funcall -- Clean up any space before the function call
686 opening parenthesis if and only if the
687 argument list is empty. This is typically
688 useful together with `space-before-funcall' to
689 get the style \"foo (bar)\" and \"foo()\".
690 Clean up occurs when the closing parenthesis
692 comment-close-slash -- When a slash is typed after the comment prefix
693 on a bare line in a c-style comment, the comment
694 is closed by cleaning up preceding space and
695 inserting a star if needed."
697 (const :tag
"Put \"} else {\" on one line (brace-else-brace)"
699 (const :tag
"Put \"} else if (...) {\" on one line (brace-elseif-brace)"
701 (const :tag
"Put \"} catch (...) {\" on one line (brace-catch-brace)"
703 (const :tag
"Put empty defun braces on one line (empty-defun-braces)"
705 (const :tag
"Put short function bodies on one line (one-liner-defun)"
707 (const :tag
"Put \"};\" ending defuns on one line (defun-close-semi)"
709 (const :tag
"Put \"},\" in aggregates on one line (list-close-comma)"
711 (const :tag
"Put C++ style \"::\" on one line (scope-operator)"
713 (const :tag
"Put a space before funcall parens, e.g. \"foo (bar)\" (space-before-funcall)"
714 space-before-funcall
)
715 (const :tag
"Remove space before empty funcalls, e.g. \"foo()\" (compact-empty-funcall)"
716 compact-empty-funcall
)
717 (const :tag
"Make / on a bare line of a C-style comment close it (comment-close-slash)"
718 comment-close-slash
))
721 (defcustom-c-stylevar c-hanging-braces-alist
'((brace-list-open)
724 (substatement-open after
)
725 (block-close . c-snug-do-while
)
726 (extern-lang-open after
)
727 (namespace-open after
)
729 (composition-open after
)
730 (inexpr-class-open after
)
731 (inexpr-class-close before
)
732 (arglist-cont-nonempty))
733 "*Controls the insertion of newlines before and after braces
734 when the auto-newline feature is active. This variable contains an
735 association list with elements of the following form:
736 \(SYNTACTIC-SYMBOL . ACTION).
738 When a brace (either opening or closing) is inserted, the syntactic
739 context it defines is looked up in this list, and if found, the
740 associated ACTION is used to determine where newlines are inserted.
741 If the context is not found, the default is to insert a newline both
742 before and after the brace.
744 SYNTACTIC-SYMBOL can be statement-cont, brace-list-intro,
745 inexpr-class-open, inexpr-class-close, and any of the *-open and
746 *-close symbols. See `c-offsets-alist' for details, except for
747 inexpr-class-open and inexpr-class-close, which doesn't have any
748 corresponding symbols there. Those two symbols are used for the
749 opening and closing braces, respectively, of anonymous inner classes
752 ACTION can be either a function symbol or a list containing any
753 combination of the symbols `before' or `after'. If the list is empty,
754 no newlines are inserted either before or after the brace.
756 When ACTION is a function symbol, the function is called with a two
757 arguments: the syntactic symbol for the brace and the buffer position
758 at which the brace was inserted. The function must return a list as
759 described in the preceding paragraph. Note that during the call to
760 the function, the variable `c-syntactic-context' is set to the entire
761 syntactic context for the brace line."
766 ,(c-constant-symbol elt
24)
767 (choice :format
"%[Choice%] %v"
768 :value
(before after
)
769 (set :menu-tag
"Before/after"
770 :format
"Newline %v brace\n"
771 (const :format
"%v, " before
)
772 (const :format
"%v " after
))
773 (function :menu-tag
"Function"
774 :format
"Run function: %v"))))
775 '(defun-open defun-close
776 class-open class-close
777 inline-open inline-close
778 block-open block-close
779 statement-cont substatement-open statement-case-open
780 brace-list-open brace-list-close
781 brace-list-intro brace-entry-open
782 extern-lang-open extern-lang-close
783 namespace-open namespace-close
784 module-open module-close
785 composition-open composition-close
786 inexpr-class-open inexpr-class-close
787 arglist-cont-nonempty
)))
790 (defcustom c-max-one-liner-length
80
791 "Maximum length of line that clean-up \"one-liner-defun\" will compact to.
792 Zero or nil means no limit."
796 (defcustom-c-stylevar c-hanging-colons-alist nil
797 "*Controls the insertion of newlines before and after certain colons.
798 This variable contains an association list with elements of the
799 following form: (SYNTACTIC-SYMBOL . ACTION).
801 SYNTACTIC-SYMBOL can be any of: case-label, label, access-label,
802 member-init-intro, or inher-intro.
804 See the variable `c-hanging-braces-alist' for the semantics of this
805 variable. Note however that making ACTION a function symbol is
806 currently not supported for this variable."
811 ,(c-constant-symbol elt
20)
812 (set :format
"Newline %v colon\n"
813 (const :format
"%v, " before
)
814 (const :format
"%v" after
))))
815 '(case-label label access-label member-init-intro inher-intro
)))
818 (defcustom-c-stylevar c-hanging-semi
&comma-criteria
819 '(c-semi&comma-inside-parenlist
)
820 "*List of functions that decide whether to insert a newline or not.
821 The functions in this list are called, in order, whenever the
822 auto-newline minor mode is activated (as evidenced by a `/a' or `/ah'
823 string in the mode line), and a semicolon or comma is typed (see
824 `c-electric-semi&comma'). Each function in this list is called with
825 no arguments, and should return one of the following values:
827 nil -- no determination made, continue checking
828 'stop -- do not insert a newline, and stop checking
829 (anything else) -- insert a newline, and stop checking
831 If every function in the list is called with no determination made,
832 then no newline is inserted."
833 :type
'(repeat function
)
836 (defcustom-c-stylevar c-backslash-column
48
837 "*Minimum alignment column for line continuation backslashes.
838 This is used by the functions that automatically insert or align the
839 line continuation backslashes in multiline macros. If any line in the
840 macro exceeds this column then the next tab stop from that line is
841 used as alignment column instead. See also `c-backslash-max-column'."
844 ;;;###autoload(put 'c-backslash-column 'safe-local-variable 'integerp)
846 (defcustom-c-stylevar c-backslash-max-column
72
847 "*Maximum alignment column for line continuation backslashes.
848 This is used by the functions that automatically insert or align the
849 line continuation backslashes in multiline macros. If any line in the
850 macro exceeds this column then the backslashes for the other lines
851 will be aligned at this column."
855 (defcustom c-auto-align-backslashes t
856 "*Align automatically inserted line continuation backslashes.
857 When line continuation backslashes are inserted automatically for line
858 breaks in multiline macros, e.g. by \\[c-context-line-break], they are
859 aligned with the other backslashes in the same macro if this flag is
860 set. Otherwise the inserted backslashes are preceded by a single
865 (defcustom c-backspace-function
'backward-delete-char-untabify
866 "*Function called by `c-electric-backspace' when deleting backwards."
870 (defcustom c-delete-function
'delete-char
871 "*Function called by `c-electric-delete-forward' when deleting forwards."
875 (defcustom c-require-final-newline
876 ;; C and C++ mandate that all nonempty files should end with a
877 ;; newline. Objective-C refers to C for all things it doesn't
878 ;; specify, so the same holds there. The other languages do not
879 ;; require it (at least not explicitly in a normative text).
883 "*Controls whether a final newline is ensured when the file is saved.
884 The value is an association list that for each language mode specifies
885 the value to give to `require-final-newline' at mode initialization;
886 see that variable for details about the value. If a language isn't
887 present on the association list, CC Mode won't touch
888 `require-final-newline' in buffers for that language."
889 :type
`(set (cons :format
"%v"
890 (const :format
"C " c-mode
)
891 (symbol :format
"%v" :value
,require-final-newline
))
893 (const :format
"C++ " c
++-mode
)
894 (symbol :format
"%v" :value
,require-final-newline
))
896 (const :format
"ObjC " objc-mode
)
897 (symbol :format
"%v" :value
,require-final-newline
))
899 (const :format
"Java " java-mode
)
900 (symbol :format
"%v" :value
,require-final-newline
))
902 (const :format
"IDL " idl-mode
)
903 (symbol :format
"%v" :value
,require-final-newline
))
905 (const :format
"Pike " pike-mode
)
906 (symbol :format
"%v" :value
,require-final-newline
))
908 (const :format
"AWK " awk-mode
)
909 (symbol :format
"%v" :value
,require-final-newline
)))
912 (defcustom c-electric-pound-behavior nil
913 "*List of behaviors for electric pound insertion.
914 Only currently supported behavior is `alignleft'."
915 :type
'(set (const alignleft
))
918 (defcustom c-special-indent-hook nil
919 "*Hook for user defined special indentation adjustments.
920 This hook gets called after each line is indented by the mode. It is only
921 called if `c-syntactic-indentation' is non-nil."
925 (defcustom-c-stylevar c-label-minimum-indentation
1
926 "*Minimum indentation for lines inside code blocks.
927 This variable typically only affects code using the `gnu' style, which
928 mandates a minimum of one space in front of every line inside code
929 blocks. Specifically, the function `c-gnu-impose-minimum' on your
930 `c-special-indent-hook' is what enforces this."
934 (defcustom c-progress-interval
5
935 "*Interval used to update progress status during long re-indentation.
936 If a number, percentage complete gets updated after each interval of
937 that many seconds. To inhibit all messages during indentation, set
938 this variable to nil."
942 (defcustom c-objc-method-arg-min-delta-to-bracket
2
943 "*Minimum number of chars to the opening bracket.
945 Consider this ObjC snippet:
948 |<-x->|barBaz: barney
950 If `x' is less than this number then `c-lineup-ObjC-method-call-colons'
951 will defer the indentation decision to the next function. By default
952 this is `c-lineup-ObjC-method-call', which would align it like:
954 [foo blahBlahBlah: fred
955 thisIsTooDamnLong: barney
957 This behavior can be overridden by customizing the indentation of
958 `objc-method-call-cont' in the \"objc\" style."
962 (defcustom c-objc-method-arg-unfinished-offset
4
963 "*Offset relative to bracket if first selector is on a new line.
966 |<-x->|bbbbbbb: cccccc
971 (defcustom c-objc-method-parameter-offset
4
972 "*Offset for selector parameter on a new line (relative to first selector.
981 (defcustom c-default-style
'((java-mode .
"java") (awk-mode .
"awk")
983 "*Style which gets installed by default when a file is visited.
985 The value of this variable can be any style defined in
986 `c-style-alist', including styles you add. The value can also be an
987 association list of major mode symbols to style names.
989 When the value is a string, all CC Mode major modes will install this
992 When the value is an alist, the major mode symbol is looked up in it
993 and the associated style is installed. If the major mode is not
994 listed in the alist, then the symbol `other' is looked up in it, and
995 if found, the style in that entry is used. If `other' is not found in
996 the alist, then \"gnu\" style is used.
998 The default style gets installed before your mode hooks run, so you
999 can always override the use of `c-default-style' by making calls to
1000 `c-set-style' in the appropriate mode hook."
1002 (string :tag
"Style in all modes")
1003 (set :tag
"Mode-specific styles"
1005 (const :format
"C " c-mode
) (string :format
"%v"))
1007 (const :format
"C++ " c
++-mode
) (string :format
"%v"))
1009 (const :format
"ObjC " objc-mode
) (string :format
"%v"))
1011 (const :format
"Java " java-mode
) (string :format
"%v"))
1013 (const :format
"IDL " idl-mode
) (string :format
"%v"))
1015 (const :format
"Pike " pike-mode
) (string :format
"%v"))
1017 (const :format
"AWK " awk-mode
) (string :format
"%v"))
1019 (const :format
"Other " other
) (string :format
"%v"))))
1022 ;; *) At the start of a statement or declaration means in more detail:
1023 ;; At the closest preceding statement/declaration that starts at boi
1024 ;; and doesn't have a label or comment at that position. If there's
1025 ;; no such statement within the same block, then back up to the
1026 ;; surrounding block or statement, add the appropriate
1027 ;; statement-block-intro, defun-block-intro or substatement syntax
1028 ;; symbol and continue searching.
1029 (c-set-stylevar-fallback 'c-offsets-alist
1030 '((string . c-lineup-dont-change
)
1031 ;; Anchor pos: Beg of previous line.
1032 (c . c-lineup-C-comments
)
1033 ;; Anchor pos: Beg of the comment.
1035 ;; Anchor pos: When inside a class: Boi at the func decl start.
1036 ;; When at top level: Bol at the func decl start. When inside
1037 ;; a code block (only possible in Pike): At the func decl
1040 ;; Anchor pos: At the defun block open if it's at boi,
1041 ;; otherwise boi at the func decl start.
1042 (defun-block-intro .
+)
1043 ;; Anchor pos: At the block open(*).
1045 ;; Anchor pos: Boi at the class decl start.
1047 ;; Anchor pos: Boi at the class decl start.
1049 ;; Anchor pos: None for functions (inclass got the relpos
1050 ;; then), boi at the lambda start for lambdas.
1052 ;; Anchor pos: Inexpr functions: At the lambda block open if
1053 ;; it's at boi, else at the statement(*) at boi of the start of
1054 ;; the lambda construct. Otherwise: At the inline block open
1055 ;; if it's at boi, otherwise boi at the func decl start.
1056 (func-decl-cont .
+)
1057 ;; Anchor pos: Boi at the func decl start.
1058 (knr-argdecl-intro .
+)
1059 ;; Anchor pos: Boi at the topmost intro line.
1061 ;; Anchor pos: At the beginning of the first K&R argdecl.
1063 ;; Anchor pos: Bol at the last line of previous construct.
1064 (topmost-intro-cont . c-lineup-topmost-intro-cont
)
1065 ;;Anchor pos: Bol at the topmost annotation line
1066 (annotation-top-cont .
0)
1067 ;;Anchor pos: Bol at the topmost annotation line
1068 (annotation-var-cont .
+)
1069 ;; Anchor pos: Boi at the topmost intro line.
1070 (member-init-intro .
+)
1071 ;; Anchor pos: Boi at the func decl arglist open.
1072 (member-init-cont . c-lineup-multi-inher
)
1073 ;; Anchor pos: Beg of the first member init.
1075 ;; Anchor pos: Boi at the class decl start.
1076 (inher-cont . c-lineup-multi-inher
)
1077 ;; Anchor pos: Java: At the implements/extends keyword start.
1078 ;; Otherwise: At the inher start colon, or boi at the class
1079 ;; decl start if the first inherit clause hangs and it's not a
1080 ;; func-local inherit clause (when does that occur?).
1082 ;; Anchor pos: Inexpr statement: At the statement(*) at boi of
1083 ;; the start of the inexpr construct. Otherwise: None.
1085 ;; Anchor pos: Inexpr statement: At the inexpr block open if
1086 ;; it's at boi, else at the statement(*) at boi of the start of
1087 ;; the inexpr construct. Block hanging on a case/default
1088 ;; label: At the closest preceding label that starts at boi.
1089 ;; Otherwise: At the block open(*).
1090 (brace-list-open .
0)
1091 ;; Anchor pos: Boi at the brace list decl start, but a starting
1092 ;; "typedef" token is ignored.
1093 (brace-list-close .
0)
1094 ;; Anchor pos: At the brace list decl start(*).
1095 (brace-list-intro .
+)
1096 ;; Anchor pos: At the brace list decl start(*).
1097 (brace-list-entry .
0)
1098 ;; Anchor pos: At the first non-ws char after the open paren if
1099 ;; the first token is on the same line, otherwise boi at that
1101 (brace-entry-open .
0)
1102 ;; Anchor pos: Same as brace-list-entry.
1104 ;; Anchor pos: After a `;' in the condition clause of a for
1105 ;; statement: At the first token after the starting paren.
1106 ;; Otherwise: At the preceding statement(*).
1107 (statement-cont .
+)
1108 ;; Anchor pos: After the first token in the condition clause of
1109 ;; a for statement: At the first token after the starting
1110 ;; paren. Otherwise: At the containing statement(*).
1111 (statement-block-intro .
+)
1112 ;; Anchor pos: In inexpr statement block: At the inexpr block
1113 ;; open if it's at boi, else at the statement(*) at boi of the
1114 ;; start of the inexpr construct. In a block hanging on a
1115 ;; case/default label: At the closest preceding label that
1116 ;; starts at boi. Otherwise: At the start of the containing
1118 (statement-case-intro .
+)
1119 ;; Anchor pos: At the case/default label(*).
1120 (statement-case-open .
0)
1121 ;; Anchor pos: At the case/default label(*).
1123 ;; Anchor pos: At the containing statement(*).
1124 (substatement-open .
+)
1125 ;; Anchor pos: At the containing statement(*).
1126 (substatement-label .
2)
1127 ;; Anchor pos: At the containing statement(*).
1129 ;; Anchor pos: At the start of the switch block(*).
1131 ;; Anchor pos: Same as inclass.
1133 ;; Anchor pos: At the start of the containing block(*).
1134 (do-while-closure .
0)
1135 ;; Anchor pos: At the corresponding while statement(*).
1137 ;; Anchor pos: At the corresponding if statement(*).
1139 ;; Anchor pos: At the previous try or catch statement clause(*).
1140 (comment-intro .
(c-lineup-knr-region-comment c-lineup-comment
))
1141 ;; Anchor pos: None.
1143 ;; Anchor pos: At the containing statement(*).
1144 ;; 2nd pos: At the open paren.
1145 (arglist-cont .
(c-lineup-gcc-asm-reg 0))
1146 ;; Anchor pos: At the first token after the open paren.
1147 (arglist-cont-nonempty .
(c-lineup-gcc-asm-reg c-lineup-arglist
))
1148 ;; Anchor pos: At the containing statement(*).
1149 ;; 2nd pos: At the open paren.
1151 ;; Anchor pos: At the containing statement(*).
1152 ;; 2nd pos: At the open paren.
1153 (stream-op . c-lineup-streamop
)
1154 ;; Anchor pos: Boi at the first stream op in the statement.
1156 ;; Anchor pos: At the class open brace if it's at boi,
1157 ;; otherwise boi at the class decl start.
1159 ;; Anchor pos: None.
1160 (cpp-macro-cont . +)
1161 ;; Anchor pos: At the macro start (always at boi).
1162 (cpp-define-intro . (c-lineup-cpp-define +))
1163 ;; Anchor pos: None.
1165 ;; Anchor pos: None.
1166 (objc-method-intro . [0])
1168 (objc-method-args-cont . c-lineup-ObjC-method-args
)
1169 ;; Anchor pos: At the method start (always at boi).
1170 (objc-method-call-cont .
(c-lineup-ObjC-method-call-colons
1171 c-lineup-ObjC-method-call
+))
1172 ;; Anchor pos: At the open bracket.
1173 (extern-lang-open .
0)
1174 (namespace-open .
0)
1176 (composition-open .
0)
1177 ;; Anchor pos: Boi at the extern/namespace/etc keyword.
1178 (extern-lang-close .
0)
1179 (namespace-close .
0)
1181 (composition-close .
0)
1182 ;; Anchor pos: Boi at the corresponding extern/namespace/etc keyword.
1187 ;; Anchor pos: At the extern/namespace/etc block open brace if
1188 ;; it's at boi, otherwise boi at the keyword.
1189 (template-args-cont .
(c-lineup-template-args +))
1190 ;; Anchor pos: Boi at the decl start. This might be changed;
1191 ;; the logical position is clearly the opening '<'.
1192 (inlambda . c-lineup-inexpr-block
)
1193 ;; Anchor pos: None.
1194 (lambda-intro-cont .
+)
1195 ;; Anchor pos: Boi at the lambda start.
1196 (inexpr-statement .
+)
1197 ;; Anchor pos: None.
1199 ;; Anchor pos: None.
1201 (defcustom c-offsets-alist nil
1202 "Association list of syntactic element symbols and indentation offsets.
1203 As described below, each cons cell in this list has the form:
1205 (SYNTACTIC-SYMBOL . OFFSET)
1207 When a line is indented, CC Mode first determines the syntactic
1208 context of it by generating a list of symbols called syntactic
1209 elements. The global variable `c-syntactic-context' is bound to the
1210 that list. Each element in the list is in turn a list where the first
1211 element is a syntactic symbol which tells what kind of construct the
1212 indentation point is located within. More elements in the syntactic
1213 element lists are optional. If there is one more and it isn't nil,
1214 then it's the anchor position for that construct.
1216 After generating the syntactic context for the line, CC Mode
1217 calculates the absolute indentation: First the base indentation is
1218 found by using the anchor position for the first syntactic element
1219 that provides one. If none does, zero is used as base indentation.
1220 Then CC Mode looks at each syntactic element in the context in turn.
1221 It compares the car of the syntactic element against the
1222 SYNTACTIC-SYMBOL's in `c-offsets-alist'. When it finds a match, it
1223 adds OFFSET to the base indentation. The sum of this calculation is
1224 the absolute offset for line being indented.
1226 If the syntactic element does not match any in the `c-offsets-alist',
1227 the element is ignored.
1229 OFFSET can specify an offset in several different ways:
1231 If OFFSET is nil then it's ignored.
1233 If OFFSET is an integer then it's used as relative offset, i.e. it's
1234 added to the base indentation.
1236 If OFFSET is one of the symbols `+', `-', `++', `--', `*', or `/'
1237 then a positive or negative multiple of `c-basic-offset' is added to
1238 the base indentation; 1, -1, 2, -2, 0.5, and -0.5, respectively.
1240 If OFFSET is a symbol with a value binding then that value, which
1241 must be an integer, is used as relative offset.
1243 If OFFSET is a vector then its first element, which must be an
1244 integer, is used as an absolute indentation column. This overrides
1245 the previous base indentation and the relative offsets applied to
1246 it, and it becomes the new base indentation.
1248 If OFFSET is a function or a lambda expression then it's called with
1249 a single argument containing the cons of the syntactic symbol and
1250 the anchor position (or nil if there is none). The return value
1251 from the function is then reinterpreted as an offset specification.
1253 If OFFSET is a list then its elements are evaluated recursively as
1254 offset specifications. If the first element is any of the symbols
1255 below then it isn't evaluated but instead specifies how the
1256 remaining offsets in the list should be combined. If it's something
1257 else then the list is combined according the method `first'. The
1258 valid combination methods are:
1260 `first' -- Use the first offset (that doesn't evaluate to nil).
1261 `min' -- Use the minimum of all the offsets. All must be either
1262 relative or absolute - they can't be mixed.
1263 `max' -- Use the maximum of all the offsets. All must be either
1264 relative or absolute - they can't be mixed.
1265 `add' -- Add all the evaluated offsets together. Exactly one of
1266 them may be absolute, in which case the result is
1267 absolute. Any relative offsets that preceded the
1268 absolute one in the list will be ignored in that case.
1270 `c-offsets-alist' is a style variable. This means that the offsets on
1271 this variable are normally taken from the style system in CC Mode
1272 \(see `c-default-style' and `c-style-alist'). However, any offsets
1273 put explicitly on this list will override the style system when a CC
1274 Mode buffer is initialized \(there is a variable
1275 `c-old-style-variable-behavior' that changes this, though).
1277 Here is the current list of valid syntactic element symbols:
1279 string -- Inside multi-line string.
1280 c -- Inside a multi-line C style block comment.
1281 defun-open -- Brace that opens a function definition.
1282 defun-close -- Brace that closes a function definition.
1283 defun-block-intro -- The first line in a top-level defun.
1284 class-open -- Brace that opens a class definition.
1285 class-close -- Brace that closes a class definition.
1286 inline-open -- Brace that opens an in-class inline method.
1287 inline-close -- Brace that closes an in-class inline method.
1288 func-decl-cont -- The region between a function definition's
1289 argument list and the function opening brace
1290 (excluding K&R argument declarations). In C, you
1291 cannot put anything but whitespace and comments
1292 between them; in C++ and Java, throws declarations
1293 and other things can appear in this context.
1294 knr-argdecl-intro -- First line of a K&R C argument declaration.
1295 knr-argdecl -- Subsequent lines in a K&R C argument declaration.
1296 topmost-intro -- The first line in a topmost construct definition.
1297 topmost-intro-cont -- Topmost definition continuation lines.
1298 annotation-top-cont -- Topmost definition continuation line where only
1299 annotations are on previous lines.
1300 annotation-var-cont -- A continuation of a C (or like) statement where
1301 only annotations are on previous lines.
1302 member-init-intro -- First line in a member initialization list.
1303 member-init-cont -- Subsequent member initialization list lines.
1304 inher-intro -- First line of a multiple inheritance list.
1305 inher-cont -- Subsequent multiple inheritance lines.
1306 block-open -- Statement block open brace.
1307 block-close -- Statement block close brace.
1308 brace-list-open -- Open brace of an enum or static array list.
1309 brace-list-close -- Close brace of an enum or static array list.
1310 brace-list-intro -- First line in an enum or static array list.
1311 brace-list-entry -- Subsequent lines in an enum or static array list.
1312 brace-entry-open -- Subsequent lines in an enum or static array
1313 list that start with an open brace.
1314 statement -- A C (or like) statement.
1315 statement-cont -- A continuation of a C (or like) statement.
1316 statement-block-intro -- The first line in a new statement block.
1317 statement-case-intro -- The first line in a case \"block\".
1318 statement-case-open -- The first line in a case block starting with brace.
1319 substatement -- The first line after an if/while/for/do/else.
1320 substatement-open -- The brace that opens a substatement block.
1321 substatement-label -- Labeled line after an if/while/for/do/else.
1322 case-label -- A \"case\" or \"default\" label.
1323 access-label -- C++ private/protected/public access label.
1324 label -- Any ordinary label.
1325 do-while-closure -- The \"while\" that ends a do/while construct.
1326 else-clause -- The \"else\" of an if/else construct.
1327 catch-clause -- The \"catch\" or \"finally\" of a try/catch construct.
1328 comment-intro -- A line containing only a comment introduction.
1329 arglist-intro -- The first line in an argument list.
1330 arglist-cont -- Subsequent argument list lines when no
1331 arguments follow on the same line as the
1332 arglist opening paren.
1333 arglist-cont-nonempty -- Subsequent argument list lines when at
1334 least one argument follows on the same
1335 line as the arglist opening paren.
1336 arglist-close -- The solo close paren of an argument list.
1337 stream-op -- Lines continuing a stream operator construct.
1338 inclass -- The construct is nested inside a class definition.
1339 Used together with e.g. `topmost-intro'.
1340 cpp-macro -- The start of a C preprocessor macro definition.
1341 cpp-macro-cont -- Inside a multi-line C preprocessor macro definition.
1342 friend -- A C++ friend declaration.
1343 objc-method-intro -- The first line of an Objective-C method definition.
1344 objc-method-args-cont -- Lines continuing an Objective-C method definition.
1345 objc-method-call-cont -- Lines continuing an Objective-C method call.
1346 extern-lang-open -- Brace that opens an \"extern\" block.
1347 extern-lang-close -- Brace that closes an \"extern\" block.
1348 inextern-lang -- Analogous to the `inclass' syntactic symbol,
1349 but used inside \"extern\" blocks.
1350 namespace-open, namespace-close, innamespace
1351 -- Similar to the three `extern-lang' symbols, but for
1352 C++ \"namespace\" blocks.
1353 module-open, module-close, inmodule
1354 -- Similar to the three `extern-lang' symbols, but for
1355 CORBA IDL \"module\" blocks.
1356 composition-open, composition-close, incomposition
1357 -- Similar to the three `extern-lang' symbols, but for
1358 CORBA CIDL \"composition\" blocks.
1359 template-args-cont -- C++ template argument list continuations.
1360 inlambda -- In the header or body of a lambda function.
1361 lambda-intro-cont -- Continuation of the header of a lambda function.
1362 inexpr-statement -- The statement is inside an expression.
1363 inexpr-class -- The class is inside an expression. Used e.g. for
1364 Java anonymous classes."
1366 `(set :format
"%{%t%}:
1367 Override style setting
1374 ,(c-constant-symbol (car elt
) 25)
1378 (unless (c-valid-offset (widget-value widget
))
1379 (widget-put widget
:error
"Invalid offset")
1381 (get 'c-offsets-alist
'c-stylevar-fallback
)))
1384 ;; The syntactic symbols that can occur inside code blocks. Used by
1385 ;; `c-gnu-impose-minimum'.
1386 (defconst c-inside-block-syms
1387 '(defun-block-intro block-open block-close statement statement-cont
1388 statement-block-intro statement-case-intro statement-case-open
1389 substatement substatement-open substatement-label case-label label
1390 do-while-closure else-clause catch-clause inlambda annotation-var-cont
))
1392 (defcustom c-style-variables-are-local-p t
1393 "*Whether style variables should be buffer local by default.
1394 If non-nil, then all indentation style related variables will be made
1395 buffer local by default. If nil, they will remain global. Variables
1396 are made buffer local when this file is loaded, and once buffer
1397 localized, they cannot be made global again.
1399 This variable must be set appropriately before CC Mode is loaded.
1401 The list of variables to buffer localize are:
1403 c-comment-only-line-offset
1404 c-indent-comment-alist
1405 c-indent-comments-syntactically-p
1406 c-block-comment-prefix
1407 c-comment-prefix-regexp
1410 c-hanging-braces-alist
1411 c-hanging-colons-alist
1412 c-hanging-semi&comma-criteria
1414 c-backslash-max-column
1415 c-label-minimum-indentation
1417 c-special-indent-hook
1418 c-indentation-style"
1423 (defcustom c-mode-hook nil
1424 "*Hook called by `c-mode'."
1428 (defcustom c
++-mode-hook nil
1429 "*Hook called by `c++-mode'."
1433 (defcustom objc-mode-hook nil
1434 "*Hook called by `objc-mode'."
1438 (defcustom java-mode-hook nil
1439 "*Hook called by `java-mode'."
1443 (defcustom idl-mode-hook nil
1444 "*Hook called by `idl-mode'."
1448 (defcustom pike-mode-hook nil
1449 "*Hook called by `pike-mode'."
1453 (defcustom awk-mode-hook nil
1454 "*Hook called by `awk-mode'."
1458 (defcustom c-mode-common-hook nil
1459 "*Hook called by all CC Mode modes for common initializations."
1463 (defcustom c-initialization-hook nil
1464 "*Hook called when the CC Mode package gets initialized.
1465 This hook is only run once per Emacs session and can be used as a
1466 `load-hook' or in place of using `eval-after-load'."
1470 (defcustom c-enable-xemacs-performance-kludge-p nil
1471 "*Enables a XEmacs only hack that may improve speed for some coding styles.
1472 For styles that hang top-level opening braces (as is common with JDK
1473 Java coding styles) this can improve performance between 3 and 60
1474 times for core indentation functions (e.g. `c-parse-state'). For
1475 styles that conform to the Emacs recommendation of putting these
1476 braces in column zero, this can degrade performance about as much.
1477 This variable only has effect in XEmacs."
1481 (defvar c-old-style-variable-behavior nil
1482 "*Enables the old style variable behavior when non-nil.
1484 Normally the values of the style variables will override the style
1485 settings specified by the variables `c-default-style' and
1486 `c-style-alist'. However, in CC Mode 5.25 and earlier, it was the
1487 other way around, meaning that changes made to the style variables
1488 from e.g. Customize would not take effect unless special precautions
1489 were taken. That was confusing, especially for novice users.
1491 It's believed that despite this change, the new behavior will still
1492 produce the same results for most old CC Mode configurations, since
1493 all style variables are per default set in a special non-override
1494 state. Set this variable only if your configuration has stopped
1495 working due to this change.")
1497 (define-widget 'c-extra-types-widget
'radio
1498 "Internal CC Mode widget for the `*-font-lock-extra-types' variables."
1499 :args
'((const :tag
"none" nil
)
1500 (repeat :tag
"types" regexp
)))
1502 (defun c-make-font-lock-extra-types-blurb (mode1 mode2 example
)
1504 *List of extra types (aside from the type keywords) to recognize in "
1506 Each list item should be a regexp matching a single identifier.
1509 Note that items on this list that don't include any regexp special
1510 characters are automatically optimized using `regexp-opt', so you
1511 should not use `regexp-opt' explicitly to build regexps here.
1513 On decoration level 3 (and higher, where applicable), a method is used
1514 that finds most types and declarations by syntax alone. This variable
1515 is still used as a first step, but other types are recognized
1516 correctly anyway in most cases. Therefore this variable should be
1517 fairly restrictive and not contain patterns that are uncertain.
1519 Note that this variable is only consulted when the major mode is
1520 initialized. If you change it later you have to reinitialize CC Mode
1521 by doing \\[" mode2
"].
1523 Despite the name, this variable is not only used for font locking but
1524 also elsewhere in CC Mode to tell types from other identifiers."))
1526 ;; Note: Most of the variables below are also defined in font-lock.el
1527 ;; in older versions of Emacs, so depending on the load order we might
1528 ;; not install the values below. There's no kludge to cope with this
1529 ;; (as opposed to the *-font-lock-keywords-* variables) since the old
1530 ;; values work fairly well anyway.
1532 (defcustom c-font-lock-extra-types
1535 "bool" "complex" "imaginary"
1536 ;; Standard library types (except those matched by the _t pattern):
1537 "FILE" "lconv" "tm" "va_list" "jmp_buf"
1538 ;; I do not appreciate the following very Emacs-specific luggage
1539 ;; in the default value, but otoh it can hardly get in the way for
1540 ;; other users, and removing it would cause unnecessary grief for
1541 ;; the old timers that are used to it. /mast
1543 (c-make-font-lock-extra-types-blurb "C" "c-mode"
1544 "For example, a value of (\"FILE\" \"\\\\sw+_t\") means the word \"FILE\"
1545 and words ending in \"_t\" are treated as type names.")
1546 :type
'c-extra-types-widget
1549 (defcustom c
++-font-lock-extra-types
1551 ;; C library types (except those matched by the _t pattern):
1552 "FILE" "lconv" "tm" "va_list" "jmp_buf"
1553 ;; Some standard C++ types that came from font-lock.el.
1554 ;; Experienced C++ users says there's no clear benefit in
1555 ;; extending this to all the types in the standard library, at
1556 ;; least not when they'll be recognized without "std::" too.
1557 "istream" "istreambuf"
1558 "ostream" "ostreambuf"
1559 "ifstream" "ofstream" "fstream"
1560 "strstream" "strstreambuf" "istrstream" "ostrstream"
1564 "deque" "vector" "bit_vector"
1568 "hash_set" "hash_multiset"
1569 "hash_map" "hash_multimap"
1570 "stack" "queue" "priority_queue"
1572 "iterator" "const_iterator" "reverse_iterator" "const_reverse_iterator"
1573 "reference" "const_reference")
1574 (c-make-font-lock-extra-types-blurb "C++" "c++-mode"
1575 "For example, a value of (\"string\") means the word \"string\" is treated
1577 :type
'c-extra-types-widget
1580 (defcustom objc-font-lock-extra-types
1581 (list (concat "[" c-upper
"]\\sw*[" c-lower
"]\\sw*"))
1582 (c-make-font-lock-extra-types-blurb "ObjC" "objc-mode" (concat
1583 "For example, a value of (\"[" c-upper
"]\\\\sw*[" c-lower
"]\\\\sw*\") means
1584 capitalized words are treated as type names (the requirement for a
1585 lower case char is to avoid recognizing all-caps macro and constant
1587 :type
'c-extra-types-widget
1590 (defcustom java-font-lock-extra-types
1591 (list (concat "[" c-upper
"]\\sw*[" c-lower
"]\\sw"))
1592 (c-make-font-lock-extra-types-blurb "Java" "java-mode" (concat
1593 "For example, a value of (\"[" c-upper
"]\\\\sw*[" c-lower
"]\\\\sw*\") means
1594 capitalized words are treated as type names (the requirement for a
1595 lower case char is to avoid recognizing all-caps constant names)."))
1596 :type
'c-extra-types-widget
1599 (defcustom idl-font-lock-extra-types nil
1600 (c-make-font-lock-extra-types-blurb "IDL" "idl-mode" "")
1601 :type
'c-extra-types-widget
1604 (defcustom pike-font-lock-extra-types
1605 (list (concat "[" c-upper
"]\\sw*[" c-lower
"]\\sw*"))
1606 (c-make-font-lock-extra-types-blurb "Pike" "pike-mode" (concat
1607 "For example, a value of (\"[" c-upper
"]\\\\sw*[" c-lower
"]\\\\sw*\") means
1608 capitalized words are treated as type names (the requirement for a
1609 lower case char is to avoid recognizing all-caps macro and constant
1611 :type
'c-extra-types-widget
1615 ;; Non-customizable variables, still part of the interface to CC Mode
1616 (defvar c-macro-with-semi-re nil
1617 ;; Regular expression which matches a (#define'd) symbol whose expansion
1618 ;; ends with a semicolon.
1620 ;; This variable should be set by `c-make-macros-with-semi-re' rather than
1623 (make-variable-buffer-local 'c-macro-with-semi-re
)
1625 (defun c-make-macro-with-semi-re ()
1626 ;; Convert `c-macro-names-with-semicolon' into the regexp
1627 ;; `c-macro-with-semi-re' (or just copy it if it's already a re).
1628 (setq c-macro-with-semi-re
1630 c-opt-cpp-macro-define
1632 ((stringp c-macro-names-with-semicolon
)
1633 (copy-sequence c-macro-names-with-semicolon
))
1634 ((consp c-macro-names-with-semicolon
)
1637 (regexp-opt c-macro-names-with-semicolon
)
1638 "\\>")) ; N.B. the PAREN param of regexp-opt isn't supported by
1640 ((null c-macro-names-with-semicolon
)
1642 (t (error "c-make-macro-with-semi-re: invalid \
1643 c-macro-names-with-semicolon: %s"
1644 c-macro-names-with-semicolon
))))))
1646 (defvar c-macro-names-with-semicolon
1647 '("Q_OBJECT" "Q_PROPERTY" "Q_DECLARE" "Q_ENUMS")
1648 "List of #defined symbols whose expansion ends with a semicolon.
1649 Alternatively it can be a string, a regular expression which
1650 matches all such symbols.
1652 The \"symbols\" must be syntactically valid identifiers in the
1653 target language \(C, C++, Objective C), or \(as the case may be)
1654 the regular expression must match only valid identifiers.
1656 If you change this variable's value, call the function
1657 `c-make-macros-with-semi-re' to set the necessary internal
1660 Note that currently \(2008-11-04) this variable is a prototype,
1661 and is likely to disappear or change its form soon.")
1662 (make-variable-buffer-local 'c-macro-names-with-semicolon
)
1664 (defvar c-file-style nil
1665 "Variable interface for setting style via File Local Variables.
1666 In a file's Local Variable section, you can set this variable to a
1667 string suitable for `c-set-style'. When the file is visited, CC Mode
1668 will set the style of the file to this value automatically.
1670 Note that file style settings are applied before file offset settings
1671 as designated in the variable `c-file-offsets'.")
1672 (make-variable-buffer-local 'c-file-style
)
1673 ;;;###autoload(put 'c-file-style 'safe-local-variable 'string-or-null-p)
1675 (defvar c-file-offsets nil
1676 "Variable interface for setting offsets via File Local Variables.
1677 In a file's Local Variable section, you can set this variable to an
1678 association list similar to the values allowed in `c-offsets-alist'.
1679 When the file is visited, CC Mode will institute these offset settings
1682 Note that file offset settings are applied after file style settings
1683 as designated in the variable `c-file-style'.")
1684 (make-variable-buffer-local 'c-file-offsets
)
1686 ;; It isn't possible to specify a doc-string without specifying an
1687 ;; initial value with `defvar', so the following two variables have been
1688 ;; given doc-strings by setting the property `variable-documentation'
1689 ;; directly. It's really good not to have an initial value for
1690 ;; variables like these that always should be dynamically bound, so it's
1691 ;; worth the inconvenience.
1693 (cc-bytecomp-defvar c-syntactic-context
)
1694 (defvar c-syntactic-context
)
1695 (put 'c-syntactic-context
'variable-documentation
1696 "Variable containing the syntactic analysis list for a line of code.
1698 It is a list with one element for each syntactic symbol pertinent to the
1699 line, for example \"((defun-block-intro 1) (comment-intro))\".
1701 It is dynamically bound when calling \(i) a brace hanging \"action
1702 function\"; \(ii) a semicolon/comma hanging \"criteria function\"; \(iii) a
1703 \"line-up function\"; \(iv) a c-special-indent-hook function. It is also
1704 used internally by CC Mode.
1706 c-syntactic-context is always bound dynamically. It must NEVER be set
1707 statically (e.g. with `setq').")
1710 (cc-bytecomp-defvar c-syntactic-element
)
1711 (defvar c-syntactic-element
)
1712 (put 'c-syntactic-element
'variable-documentation
1713 "Variable containing the current syntactic element during calls to
1714 the lineup functions. The value is one of the elements in the list in
1715 `c-syntactic-context' and is a list with the symbol name in the first
1716 position, followed by zero or more elements containing any additional
1717 info associated with the syntactic symbol. There are accessor functions
1718 `c-langelem-sym', `c-langelem-pos', `c-langelem-col', and
1719 `c-langelem-2nd-pos' to access the list.
1721 Specifically, the element returned by `c-langelem-pos' is the anchor
1722 position, or nil if there isn't any. See the comments in the
1723 `c-offsets-alist' variable and the CC Mode manual for more detailed info
1724 about the data each syntactic symbol provides.
1726 This is always bound dynamically. It should never be set
1727 statically (e.g. with `setq').")
1729 (defvar c-indentation-style nil
1730 "Name of the currently installed style.
1731 Don't change this directly; call `c-set-style' instead, or set the variable
1732 `c-file-style' in the file's Local Variable list.")
1734 (defvar c-current-comment-prefix nil
1735 "The current comment prefix regexp.
1736 Set from `c-comment-prefix-regexp' at mode initialization.")
1737 (make-variable-buffer-local 'c-current-comment-prefix
)
1739 ;; N.B. The next three variables are initialized in
1740 ;; c-setup-paragraph-variables. Their initializations here are "just in
1741 ;; case". ACM, 2004/2/15. They are NOT buffer local (yet?).
1742 (defvar c-string-par-start
1743 ;; (concat "\\(" (default-value 'paragraph-start) "\\)\\|[ \t]*\\\\$")
1745 "Value of paragraph-start used when scanning strings.
1746 It treats escaped EOLs as whitespace.")
1748 (defvar c-string-par-separate
1749 ;; (concat "\\(" (default-value 'paragraph-separate) "\\)\\|[ \t]*\\\\$")
1751 "Value of paragraph-separate used when scanning strings.
1752 It treats escaped EOLs as whitespace.")
1754 (defvar c-sentence-end-with-esc-eol
1755 (concat "\\(\\(" (c-default-value-sentence-end) "\\)"
1756 ;; N.B.: "$" would be illegal when not enclosed like "\\($\\)".
1757 "\\|" "[.?!][]\"')}]* ?\\\\\\($\\)[ \t\n]*"
1759 "Value used like sentence-end used when scanning strings.
1760 It treats escaped EOLs as whitespace.")
1763 (cc-provide 'cc-vars
)
1765 ;;; cc-vars.el ends here