;ELC
;;; Compiled by mockbuild@buildfarm06-new.corp.cloudlinux.com on Fri Oct 11 10:09:17 2024
;;; from file /builddir/build/BUILD/emacs-24.3/lisp/progmodes/cc-vars.el
;;; in Emacs version 24.3.1
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.

;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


(byte-code "\300\301!\210\302\303N\204\304\302\305\306\307\310\311\312\313\302&	\210\300\207" [require cc-defs other widget-type define-widget sexp "Matches everything, but doesn't let the user edit the value.\nUseful as last item in a `choice' widget." :tag "Other" :format "%t%n" :value] 10)
#@281 Create an uneditable symbol for customization buffers.
SYM is the name of the symbol, LEN the length of the field (in
characters) the symbol will be displayed in.  LEN must be big
enough.

This returns a (const ....) structure, suitable for embedding
within a customization type.
(defalias 'c-constant-symbol #[(sym len) "9\204\n\305\306\"\210\307!\211G	\310\311\312\n\313#\314\"Q\315\316\317\f\320\257+\207" [sym name l len disp error "c-constant-symbol: %s is not a symbol" symbol-name ":" make-string - 1 32 const :size :format :value] 8 (#$ . 857)])
(byte-code "\300\301\302\303\304\305\306\307\310\311\312\313\314\315\316\317&\210\300\320\321\322\304\305\306\323\312\324&	\210\300\325\321\326\306\327\330\331\312\332\314\333\316\334&
\207" [define-widget c-const-symbol item "An uneditable lisp symbol.  This is obsolete -\nuse c-constant-symbol instead." :value nil :tag "Symbol" :format "%t: %v\n%d" :match #[(widget value) "9\207" [value] 1] :value-to-internal #[(widget value) "9\203\304!\202\f\305	\306\"\n\203 \307\nGZ\310\"P*\207" [value widget l s symbol-name widget-get :size make-string 32] 4] :value-to-external #[(widget value) ";\203\301\302\303\"\210\304\305\"!\207\207" [value intern string-match "\\`[^ ]*" match-string 0] 4] c-integer-or-nil sexp "An integer or the value nil." "Optional integer" #[(widget value) "\250\206?\207" [value] 1] c-symbol-list "A single symbol or a list of symbols." "Symbols separated by spaces" :validate widget-field-validate #[(widget value) "9\206\301\302\215\207" [value ok (byte-code "<\203@9\204\301\302\303\"\210A\211\202
?\207" [value throw ok nil] 4)] 2] #[(widget value) "\204\301\2079\203\302!\207:\203\303\304\305#\207\207" [value "" symbol-name mapconcat #[(symbol) "\301!\207" [symbol symbol-name] 2] " "] 4] #[(widget value) ";\2032\303\211\304\305	#\203 \306\307\310\"!\nB\310\225\202	\n\203.\nA\204.\n@\2020\n\237*\207\207" [value end list nil string-match "\\S +" intern match-string 0] 4]] 16)
#@30 List of the style variables.
(defvar c-style-variables '(c-basic-offset c-comment-only-line-offset c-indent-comment-alist c-indent-comments-syntactically-p c-block-comment-prefix c-comment-prefix-regexp c-doc-comment-style c-cleanup-list c-hanging-braces-alist c-hanging-colons-alist c-hanging-semi&comma-criteria c-backslash-column c-backslash-max-column c-special-indent-hook c-label-minimum-indentation c-offsets-alist) (#$ . 2904))
(defvar c-fallback-style nil)
(defalias 'c-set-stylevar-fallback #[(name val) "\303\304	#\210	B\nB\211\207" [name val c-fallback-style put c-stylevar-fallback] 4])
(put 'c-set-stylevar-fallback 'byte-optimizer 'byte-compile-inline-expand)
#@548 Define a style variable NAME with VAL and DOC.
More precisely, convert the given `:type FOO', mined out of ARGS,
to an aggregate `:type (radio STYLE (PREAMBLE FOO))', append some
some boilerplate documentation to DOC, arrange for the fallback
value of NAME to be VAL, and call `custom-declare-variable' to
do the rest of the work.

STYLE stands for the choice where the value is taken from some
style setting.  PREAMBLE is optionally prepended to FOO; that is,
if FOO contains :tag or :value, the respective two-element list
component is ignored.
(defalias 'defcustom-c-stylevar '(macro . #[(name val doc &rest args) "\306P\307\310\n\311\"!\211:\203\202C\211@\fA\312\310\313\"?\205)\314\310\315\"?\2058\315\307!D#\316\317\320
BED\321\322\316DE\323\316D\324	\325\n\311#BBBBE.\207" [doc expanded-doc args typ type head "\n\nThis is a style variable.  Apart from the valid values described\nabove, it can be set to the symbol `set-from-style'.  In that case,\nit takes its value from the style system (see `c-default-style' and\n`c-style-alist') when a CC Mode buffer is initialized.  Otherwise,\nthe value set here overrides the style system (there is a variable\n`c-old-style-variable-behavior' that changes this, though)." eval plist-get :type append :tag (:tag "Override style settings") :value quote radio (const :tag "Use style settings" set-from-style) progn c-set-stylevar-fallback custom-declare-variable ''set-from-style plist-put tail val newt aggregate name] 11 (#$ . 3589)]))
(put 'defcustom-c-stylevar 'edebug-form-spec '(symbolp form stringp &rest))
#@91 Return non-nil if OFFSET is a valid offset for a syntactic symbol.
See `c-offsets-alist'.
(defalias 'c-valid-offset #[(offset) "\301=\206z\302=\206z\303=\206z\304=\206z\305=\206z\306=\206z\250\206z\307!\206z9\203:\310!\206z\311!\203NG\312U\203N\313\234\250\206z:\205z@\314=?\205z@\315>\203eA:\203x\316@!\203xA\211\202f?\207" [offset + - ++ -- * / functionp boundp vectorp 1 0 quote (first min max add) c-valid-offset] 3 (#$ . 5195)])
(byte-code "\304\305\306\307\310\311\312\313&\210\304\314\306\315\310\311\312\313&\210\304\316\306\317\310\311\312\313&\210\320\321\322	\323#\210	B\nB\211*\210\304\320\324\325\310\326\312\313&\210\304\327\330\331\310\332\312\313&\210\304\333\334\335\310\336\312\313&\210\304\337\330\340\310\311\312\313&\210\341\337!\210\322\337\342\343#\210\304\344\330\345\310\311\312\313&\210\322\344\342\343#\210\304\346\347\350\351\352\310\353\312\313&	\210\354\355\322	\323#\210	B\nB\211*\210\304\354\324\356\310\357\312\313&\210\360\361\322	\323#\210	B\nB\211*\210\304\360\324\362\310\363\312\313&\210\364\306\322	\323#\210	B\nB\211*\210\304\364\324\365\310\366\312\313&\210\367\370\371\372#\210\371\373\370!\203\364\370J\202\365\374\322	\323#\210	B\nB\211*\210\304\371\324\375\310\376\312\313&\210\377\201@\322	\323#\210	B\nB\211*\210\304\377\324\201A\310\201B\312\313&\210\201C\201D\322	\323#\210	B\nB\211*\210\304\201C\324\201E\310\201F\312\313&\210\304\201G\201H\201I\310\201J\312\313&\210\201K\201L\322	\323#\210	B\nB\211*\210\304\201K\324\201M\310\201N\312\313&\210\201O\201P\322	\323#\210	B\nB\211*\210\304\201O\324\201Q\310\201R\312\313&\210\304\201S\201T\201U\310\201V\312\313&\210\201W\306\322	\323#\210	B\nB\211*\210\304\201W\324\201X\310\201Y\312\313&\210\201Z\201[\322	\323#\210	B\nB\211*\210\304\201Z\324\201\\\310\201]\312\313&\210\201^\201_\322	\323#\210	B\nB\211*\210\304\201^\324\201`\310\201a\312\313&\210\201b\201c\322	\323#\210	B\nB\211*\210\304\201b\324\201d\310\201e\312\313&\210\304\201f\330\201g\310\311\312\313&\210\304\201h\201i\201j\310\336\312\313&\210\304\201k\201l\201m\310\336\312\313&\210\304\201n\201o\201p\310\201q\201r\201s\201t\201u\201v\201s\201t\201w\257\257\201r\201s\201t\201x\201v\201s\201t\201w\257\257\201r\201s\201t\201y\201v\201s\201t\201w\257\257\201r\201s\201t\201z\201v\201s\201t\201w\257\257\201r\201s\201t\201{\201v\201s\201t\201w\257\257\201r\201s\201t\201|\201v\201s\201t\201w\257\257\201r\201s\201t\201}\201v\201s\201t\201w\257\257\257\312\313&\210\304\201~\306\201\310\201\200\312\313&\210\304\201\201\306\201\202\310\201\203\312\313&\210\201\204\201\205\322	\323#\210	B\nB\211*\210\304\201\204\324\201\206\310\201\207\312\313&\210\304\201\210\201\211\201\212\310\201V\312\313&\210\304\201\213\201\214\201\215\310\201V\312\313&\210\304\201\216\321\201\217\310\201V\312\313&\210\304\201\220\321\201\221\310\201V\312\313&\210\304\201\222\201\223\201\224\310\201\225\312\313&\210\201\226\201\227\322	\323#\210	B\nB\211*\210\304\201\226\306\201\230\310\201q\201s\201\231\201\232\201\233\201\226\323N\"BBB\312\313&\207" [val name c-fallback-style require-final-newline custom-declare-variable c-strict-syntax-p nil "*If non-nil, all syntactic symbols must be found in `c-offsets-alist'.\nIf the syntactic symbol for a particular line does not match a symbol\nin the offsets alist, or if no non-nil offset value can be determined\nfor a symbol, an error is generated, otherwise no error is reported\nand the syntactic symbol is ignored.\n\nThis variable is considered obsolete; it doesn't work well with lineup\nfunctions that return nil to support the feature of using lists on\nsyntactic symbols in `c-offsets-alist'.  Please keep it set to nil." :type boolean :group c c-echo-syntactic-information-p "*If non-nil, syntactic info is echoed when the line is indented." c-report-syntactic-errors "*If non-nil, certain syntactic errors are reported with a ding\nand a message, for example when an \"else\" is indented for which\nthere's no corresponding \"if\".\n\nNote however that CC Mode doesn't make any special effort to check for\nsyntactic errors; that's the job of the compiler.  The reason it can\nreport cases like the one above is that it can't find the correct\nanchoring position to indent the line in that case." c-basic-offset 4 put c-stylevar-fallback 'set-from-style "*Amount of basic offset used by + and - symbols in `c-offsets-alist'.\nAlso used as the indentation step when `c-syntactic-indentation' is\nnil.\n\nThis is a style variable.  Apart from the valid values described\nabove, it can be set to the symbol `set-from-style'.  In that case,\nit takes its value from the style system (see `c-default-style' and\n`c-style-alist') when a CC Mode buffer is initialized.  Otherwise,\nthe value set here overrides the style system (there is a variable\n`c-old-style-variable-behavior' that changes this, though)." (radio #1=(const :tag "Use style settings" set-from-style) (integer :tag #2="Override style settings" :value 4)) c-tab-always-indent t "*Controls the operation of the TAB key.\nIf t, hitting TAB always just indents the current line.  If nil, hitting\nTAB indents the current line if point is at the left margin or in the\nline's indentation, otherwise it calls `c-insert-tab-function' to\ninsert a `real' tab character.  If some other value (neither nil nor t),\nthen inserts a tab only within literals (comments and strings), but\nalways reindents the line.\n\nNote: the variable `c-comment-only-line-offset' also controls the\nindentation of lines containing only comments." (radio (const :tag "TAB key always indents, never inserts TAB" t) (const :tag "TAB key indents in left margin, otherwise inserts TAB" nil) (other :tag "TAB key inserts TAB in literals, otherwise indents" other)) c-insert-tab-function 'insert-tab "*Function used when inserting a tab for \\[c-indent-command].\nOnly used when `c-tab-always-indent' indicates a `real' tab character\nshould be inserted.  Value must be a function taking no arguments.\nThe default, `insert-tab', inserts either a tab or the equivalent\nnumber of spaces depending on the value of `indent-tabs-mode'." function c-syntactic-indentation "*Whether the indentation should be controlled by the syntactic context.\n\nIf t, the indentation functions indent according to the syntactic\ncontext, using the style settings specified by `c-offsets-alist'.\n\nIf nil, every line is just indented to the same level as the previous\none, and the \\[c-indent-command] command adjusts the indentation in\nsteps specified by `c-basic-offset'.  The indentation style has no\neffect in this mode, nor any of the indentation associated variables,\ne.g. `c-special-indent-hook'." make-variable-buffer-local safe-local-variable booleanp c-syntactic-indentation-in-macros "*Enable syntactic analysis inside macros.\nIf this is nil, all lines inside macro definitions are analyzed as\n`cpp-macro-cont'.  Otherwise they are analyzed syntactically, just\nlike normal code, and `cpp-define-intro' is used to create the\nadditional indentation of the bodies of \"#define\" macros.\n\nHaving this enabled simplifies editing of large multiline macros, but\nit might complicate editing if CC Mode doesn't recognize the context\nof the macro content.  The default context inside the macro is the\nsame as the top level, so if it contains \"bare\" statements they\nmight be indented wrongly, although there are special cases that\nhandle this in most cases.  If this problem occurs, it's usually\ncountered easily by surrounding the statements by a block (or even\nbetter with the \"do { ... } while (0)\" trick)." c-defun-tactic 'go-outward "*Whether functions are recognized inside, e.g., a class.\nThis is used by `c-beginning-of-defun' and like functions.\n\nIts value is one of:\n t           -- Functions are recognized only at the top level.\n go-outward  -- Nested functions are also recognized.  Should a function\n                command hit the beginning/end of a nested scope, it will\n                carry on at the less nested level." :version "24.1" (radio (const :tag "Functions are at the top-level" t) (const :tag "Functions are also recognized inside declaration scopes" go-outward)) c-comment-only-line-offset 0 "*Extra offset for line which contains only the start of a comment.\nCan contain an integer or a cons cell of the form:\n\n (NON-ANCHORED-OFFSET . ANCHORED-OFFSET)\n\nWhere NON-ANCHORED-OFFSET is the amount of offset given to\nnon-column-zero anchored comment-only lines, and ANCHORED-OFFSET is\nthe amount of offset to give column-zero anchored comment-only lines.\nJust an integer as value is equivalent to (<val> . -1000).\n\nNote that this variable only has effect when the `c-lineup-comment'\nlineup function is used on the `comment-intro' syntactic symbol (the\ndefault).\n\nThis is a style variable.  Apart from the valid values described\nabove, it can be set to the symbol `set-from-style'.  In that case,\nit takes its value from the style system (see `c-default-style' and\n`c-style-alist') when a CC Mode buffer is initialized.  Otherwise,\nthe value set here overrides the style system (there is a variable\n`c-old-style-variable-behavior' that changes this, though)." (radio #1# (choice :tag #2# :value 0 (integer :tag "Non-anchored offset" 0) (cons :tag "Non-anchored & anchored offset" :value (0 . 0) (integer :tag "Non-anchored offset") (integer :tag "Anchored offset")))) c-indent-comment-alist #3=((anchored-comment column . 0) (end-block space . 1) (cpp-end-block space . 2)) "*Specifies how \\[indent-for-comment] calculates the comment start column.\nThis is an association list that contains entries of the form:\n\n (LINE-TYPE . INDENT-SPEC)\n\nLINE-TYPE specifies a type of line as described below, and INDENT-SPEC\nsays what \\[indent-for-comment] should do when used on that type of line.\n\nThe recognized values for LINE-TYPE are:\n\n empty-line        -- The line is empty.\n anchored-comment  -- The line contains a comment that starts in column 0.\n end-block         -- The line contains a solitary block closing brace.\n cpp-end-block     -- The line contains a preprocessor directive that\n                      closes a block, i.e. either \"#endif\" or \"#else\".\n other             -- The line does not match any other entry\n                      currently on the list.\n\nAn INDENT-SPEC is a cons cell of the form:\n\n (ACTION . VALUE)\n\nACTION says how \\[indent-for-comment] should align the comment, and\nVALUE is interpreted depending on ACTION.  ACTION can be any of the\nfollowing:\n\n space   -- Put VALUE spaces between the end of the line and the start\n            of the comment.\n column  -- Start the comment at the column VALUE.  If the line is\n            longer than that, the comment is preceded by a single\n            space.  If VALUE is nil, `comment-column' is used.\n align   -- Align the comment with one on the previous line, if there\n            is any.  If the line is too long, the comment is preceded\n            by a single space.  If there isn't a comment start on the\n            previous line, the behavior is specified by VALUE, which\n            in turn is interpreted as an INDENT-SPEC.\n\nIf a LINE-TYPE is missing, then \\[indent-for-comment] indents the comment\naccording to `comment-column'.\n\nNote that a non-nil value on `c-indent-comments-syntactically-p'\noverrides this variable, so empty lines are indented syntactically\nin that case, i.e. as if \\[c-indent-command] was used instead.\n\nThis is a style variable.  Apart from the valid values described\nabove, it can be set to the symbol `set-from-style'.  In that case,\nit takes its value from the style system (see `c-default-style' and\n`c-style-alist') when a CC Mode buffer is initialized.  Otherwise,\nthe value set here overrides the style system (there is a variable\n`c-old-style-variable-behavior' that changes this, though)." (radio #1# (set :tag #2# :value #3# (cons :format #6="%v" (const :size 20 :format "empty-line:         " :value empty-line) (choice :format #7="%[Choice%] %v" :value #8=(column) #4=(cons :tag "space" :format "%v" :value (space . 1) (const :format "space  " space) (integer :format "%v")) #5=(cons :tag "column" :format "%v" (const :format "column " column) (c-integer-or-nil :format "%v")) (cons :tag #9="align" :format #10="%v" #11=(const :format "align  " align) (choice :format #12="%[Choice%] %v" :value #13=(column) #4# #5#)))) (cons :format #6# (const :size 20 :format "anchored-comment:   " :value anchored-comment) (choice :format #7# :value #8# #4# #5# (cons :tag #9# :format #10# #11# (choice :format #12# :value #13# #4# #5#)))) (cons :format #6# (const :size 20 :format "end-block:          " :value end-block) (choice :format #7# :value #8# #4# #5# (cons :tag #9# :format #10# #11# (choice :format #12# :value #13# #4# #5#)))) (cons :format #6# (const :size 20 :format "cpp-end-block:      " :value cpp-end-block) (choice :format #7# :value #8# #4# #5# (cons :tag #9# :format #10# #11# (choice :format #12# :value #13# #4# #5#)))) (cons :format #6# (const :size 20 :format "other:              " :value other) (choice :format #7# :value #8# #4# #5# (cons :tag #9# :format #10# #11# (choice :format #12# :value #13# #4# #5#)))))) c-indent-comments-syntactically-p "*Specifies how \\[indent-for-comment] should handle comment-only lines.\nWhen this variable is non-nil, comment-only lines are indented\naccording to syntactic analysis via `c-offsets-alist'.  Otherwise, the\ncomment is indented as if it was preceded by code.  Note that this\nvariable does not affect how the normal line indentation treats\ncomment-only lines.\n\nThis is a style variable.  Apart from the valid values described\nabove, it can be set to the symbol `set-from-style'.  In that case,\nit takes its value from the style system (see `c-default-style' and\n`c-style-alist') when a CC Mode buffer is initialized.  Otherwise,\nthe value set here overrides the style system (there is a variable\n`c-old-style-variable-behavior' that changes this, though)." (radio #1# (boolean :tag #2# :value nil)) make-obsolete-variable c-comment-continuation-stars c-block-comment-prefix "21.1" boundp #14="* " "*Specifies the line prefix of continued C-style block comments.\nYou should set this variable to the literal string that gets inserted\nat the front of continued block style comment lines.  This should\neither be the empty string, or some characters without preceding\nspaces.  To adjust the alignment under the comment starter, put an\nappropriate value on the `c' syntactic symbol (see the\n`c-offsets-alist' variable).\n\nIt's only used when a one-line block comment is broken into two or\nmore lines for the first time; otherwise the appropriate prefix is\nadapted from the comment.  This variable is not used for C++ line\nstyle comments.\n\nThis is a style variable.  Apart from the valid values described\nabove, it can be set to the symbol `set-from-style'.  In that case,\nit takes its value from the style system (see `c-default-style' and\n`c-style-alist') when a CC Mode buffer is initialized.  Otherwise,\nthe value set here overrides the style system (there is a variable\n`c-old-style-variable-behavior' that changes this, though)." (radio #1# (string :tag #2# :value #14#)) c-comment-prefix-regexp #15=((pike-mode . "//+!?\\|\\**") (awk-mode . "#+") (other . "//+\\|\\**")) "*Regexp to match the line prefix inside comments.\nThis regexp is used to recognize the fill prefix inside comments for\ncorrect paragraph filling and other things.\n\nIf this variable is a string, it will be used in all CC Mode major\nmodes.  It can also be an association list, to associate specific\nregexps to specific major modes.  The symbol for the major mode is\nlooked up in the association list, and its value is used as the line\nprefix regexp.  If it's not found, then the symbol `other' is looked\nup and its value is used instead.\n\nThe regexp should match the prefix used in both C++ style line\ncomments and C style block comments, but it does not need to match a\nblock comment starter.  In other words, it should at least match\n\"//\" for line comments and the string in `c-block-comment-prefix',\nwhich is sometimes inserted by CC Mode inside block comments.  It\nshould not match any surrounding whitespace.\n\nNote that CC Mode uses this variable to set many other variables that\nhandle the paragraph filling.  That's done at mode initialization or\nwhen you switch to a style which sets this variable.  Thus, if you\nchange it in some other way, e.g. interactively in a CC Mode buffer,\nyou will need to do \\[c-setup-paragraph-variables] afterwards so that\nthe other variables are updated with the new value.\n\nNote also that when CC Mode starts up, all variables are initialized\nbefore the mode hooks are run.  It's therefore necessary to make a\ncall to `c-setup-paragraph-variables' explicitly if you change this\nvariable in a mode hook.\n\nThis is a style variable.  Apart from the valid values described\nabove, it can be set to the symbol `set-from-style'.  In that case,\nit takes its value from the style system (see `c-default-style' and\n`c-style-alist') when a CC Mode buffer is initialized.  Otherwise,\nthe value set here overrides the style system (there is a variable\n`c-old-style-variable-behavior' that changes this, though)." (radio #1# (radio :tag #2# :value #15# (regexp :tag "Regexp for all modes") (list :tag "Mode-specific regexps" (set :inline t :format "%v" (cons :format "%v" (const :format "C     " c-mode) (regexp :format "%v")) (cons :format "%v" (const :format "C++   " c++-mode) (regexp :format "%v")) (cons :format "%v" (const :format "ObjC  " objc-mode) (regexp :format "%v")) (cons :format "%v" (const :format "Java  " java-mode) (regexp :format "%v")) (cons :format "%v" (const :format "IDL   " idl-mode) (regexp :format "%v")) (cons :format "%v" (const :format "Pike  " pike-mode) (regexp :format "%v")) (cons :format "%v" (const :format "AWK   " awk-mode) (regexp :format "%v"))) (cons :format "    %v" (const :format "Other " other) (regexp :format "%v"))))) c-doc-comment-style #16=((java-mode . javadoc) (pike-mode . autodoc) (c-mode . gtkdoc)) "*Specifies documentation comment style(s) to recognize.\nThis is primarily used to fontify doc comments and the markup within\nthem, e.g. Javadoc comments.\n\nThe value can be any of the following symbols for various known doc\ncomment styles:\n\n javadoc -- Javadoc style for \"/** ... */\" comments (default in Java mode).\n autodoc -- Pike autodoc style for \"//! ...\" comments (default in Pike mode).\n gtkdoc  -- GtkDoc style for \"/** ... **/\" comments (default in C mode).\n\nThe value may also be a list of doc comment styles, in which case all\nof them are recognized simultaneously (presumably with markup cues\nthat don't conflict).\n\nThe value may also be an association list to specify different doc\ncomment styles for different languages.  The symbol for the major mode\nis then looked up in the alist, and the value of that element is\ninterpreted as above if found.  If it isn't found then the symbol\n`other' is looked up and its value is used instead.\n\nNote that CC Mode uses this variable to set other variables that\nhandle fontification etc.  That's done at mode initialization or when\nyou switch to a style which sets this variable.  Thus, if you change\nit in some other way, e.g. interactively in a CC Mode buffer, you will\nneed to do \\[java-mode] (or whatever mode you're currently using) to\nreinitialize.\n\nNote also that when CC Mode starts up, the other variables are\nmodified before the mode hooks are run.  If you change this variable\nin a mode hook, you have to call `c-setup-doc-comment-style'\nafterwards to redo that work.\n\nThis is a style variable.  Apart from the valid values described\nabove, it can be set to the symbol `set-from-style'.  In that case,\nit takes its value from the style system (see `c-default-style' and\n`c-style-alist') when a CC Mode buffer is initialized.  Otherwise,\nthe value set here overrides the style system (there is a variable\n`c-old-style-variable-behavior' that changes this, though)." (radio #1# (radio :tag #2# :value #16# (c-symbol-list :tag "Doc style(s) in all modes") (list :tag "Mode-specific doc styles" (set :inline t :format "%v" (cons :format "%v" (const :format "C     " c-mode) (c-symbol-list :format "%v")) (cons :format "%v" (const :format "C++   " c++-mode) (c-symbol-list :format "%v")) (cons :format "%v" (const :format "ObjC  " objc-mode) (c-symbol-list :format "%v")) (cons :format "%v" (const :format "Java  " java-mode) (c-symbol-list :format "%v")) (cons :format "%v" (const :format "IDL   " idl-mode) (c-symbol-list :format "%v")) (cons :format "%v" (const :format "Pike  " pike-mode) (c-symbol-list :format "%v")) (cons :format "%v" (const :format "AWK   " awk-mode) (c-symbol-list :format "%v")) (cons :format "%v" (const :format "Other " other) (c-symbol-list :format "%v")))))) c-ignore-auto-fill '(string cpp code) "*List of contexts in which automatic filling never occurs.\nIf Auto Fill mode is active, it will be temporarily disabled if point\nis in any context on this list.  It's e.g. useful to enable Auto Fill\nin comments only, but not in strings or normal code.  The valid\ncontexts are:\n\n string  -- inside a string or character literal\n c       -- inside a C style block comment\n c++     -- inside a C++ style line comment\n cpp     -- inside a preprocessor directive\n code    -- anywhere else, i.e. in normal code" (set (const :tag "String literals" string) (const :tag "C style block comments" c) (const :tag "C++ style line comments" c++) (const :tag "Preprocessor directives" cpp) (const :tag "Normal code" code)) c-cleanup-list #17=(scope-operator) "*List of various C/C++/ObjC constructs to \"clean up\".\nThe following clean ups only take place when the auto-newline feature\nis turned on, as evidenced by the `/la' appearing next to the mode\nname:\n\n brace-else-brace    -- Clean up \"} else {\" constructs by placing\n                        entire construct on a single line.  This clean\n                        up only takes place when there is nothing but\n                        white space between the braces and the `else'.\n                        Clean up occurs when the open brace after the\n                        `else' is typed.\n brace-elseif-brace  -- Similar to brace-else-brace, but clean up\n                        \"} else if (...) {\" constructs.  Clean up\n                        occurs after the open parenthesis and the open\n                        brace.\n brace-catch-brace   -- Similar to brace-elseif-brace, but clean up\n                        \"} catch (...) {\" constructs.\n empty-defun-braces  -- Clean up empty defun braces by placing the\n                        braces on the same line.  Clean up occurs when\n                        the defun closing brace is typed.\n one-liner-defun     -- If the code inside a function body can fit in\n                        a single line, then remove any newlines\n                        between that line and the defun braces so that\n                        the whole body becomes a single line.\n                        `c-max-one-liner-length' gives the maximum\n                        length allowed for the resulting line.  Clean\n                        up occurs when the closing brace is typed.\n defun-close-semi    -- Clean up the terminating semi-colon on defuns\n                        by placing the semi-colon on the same line as\n                        the closing brace.  Clean up occurs when the\n                        semi-colon is typed.\n list-close-comma    -- Clean up commas following braces in array\n                        and aggregate initializers.  Clean up occurs\n                        when the comma is typed.\n scope-operator      -- Clean up double colons which may designate\n                        a C++ scope operator split across multiple\n                        lines.  Note that certain C++ constructs can\n                        generate ambiguous situations.  This clean up\n                        only takes place when there is nothing but\n                        whitespace between colons.  Clean up occurs\n                        when the second colon is typed.\n\nThe following clean ups always take place when they are on this list,\nregardless of the auto-newline feature, since they typically don't\ninvolve auto-newline inserted newlines:\n\n space-before-funcall -- Insert exactly one space before the opening\n                        parenthesis of a function call.  Clean up\n                        occurs when the opening parenthesis is typed.\n compact-empty-funcall -- Clean up any space before the function call\n                        opening parenthesis if and only if the\n                        argument list is empty.  This is typically\n                        useful together with `space-before-funcall' to\n                        get the style \"foo (bar)\" and \"foo()\".\n                        Clean up occurs when the closing parenthesis\n                        is typed.\n comment-close-slash -- When a slash is typed after the comment prefix\n                        on a bare line in a c-style comment, the comment\n                        is closed by cleaning up preceding space and\n                        inserting a star if needed.\n\nThis is a style variable.  Apart from the valid values described\nabove, it can be set to the symbol `set-from-style'.  In that case,\nit takes its value from the style system (see `c-default-style' and\n`c-style-alist') when a CC Mode buffer is initialized.  Otherwise,\nthe value set here overrides the style system (there is a variable\n`c-old-style-variable-behavior' that changes this, though)." (radio #1# (set :tag #2# :value #17# (const :tag "Put \"} else {\" on one line (brace-else-brace)" brace-else-brace) (const :tag "Put \"} else if (...) {\" on one line (brace-elseif-brace)" brace-elseif-brace) (const :tag "Put \"} catch (...) {\" on one line (brace-catch-brace)" brace-catch-brace) (const :tag "Put empty defun braces on one line (empty-defun-braces)" empty-defun-braces) (const :tag "Put short function bodies on one line (one-liner-defun)" one-liner-defun) (const :tag "Put \"};\" ending defuns on one line (defun-close-semi)" defun-close-semi) (const :tag "Put \"},\" in aggregates on one line (list-close-comma)" list-close-comma) (const :tag "Put C++ style \"::\" on one line (scope-operator)" scope-operator) (const :tag "Put a space before funcall parens, e.g. \"foo (bar)\" (space-before-funcall)" space-before-funcall) (const :tag "Remove space before empty funcalls, e.g. \"foo()\" (compact-empty-funcall)" compact-empty-funcall) (const :tag "Make / on a bare line of a C-style comment close it (comment-close-slash)" comment-close-slash))) c-hanging-braces-alist #18=((brace-list-open) (brace-entry-open) (statement-cont) (substatement-open after) (block-close . c-snug-do-while) (extern-lang-open after) (namespace-open after) (module-open after) (composition-open after) (inexpr-class-open after) (inexpr-class-close before) (arglist-cont-nonempty)) "*Controls the insertion of newlines before and after braces\nwhen the auto-newline feature is active.  This variable contains an\nassociation list with elements of the following form:\n(SYNTACTIC-SYMBOL . ACTION).\n\nWhen a brace (either opening or closing) is inserted, the syntactic\ncontext it defines is looked up in this list, and if found, the\nassociated ACTION is used to determine where newlines are inserted.\nIf the context is not found, the default is to insert a newline both\nbefore and after the brace.\n\nSYNTACTIC-SYMBOL can be statement-cont, brace-list-intro,\ninexpr-class-open, inexpr-class-close, and any of the *-open and\n*-close symbols.  See `c-offsets-alist' for details, except for\ninexpr-class-open and inexpr-class-close, which doesn't have any\ncorresponding symbols there.  Those two symbols are used for the\nopening and closing braces, respectively, of anonymous inner classes\nin Java.\n\nACTION can be either a function symbol or a list containing any\ncombination of the symbols `before' or `after'.  If the list is empty,\nno newlines are inserted either before or after the brace.\n\nWhen ACTION is a function symbol, the function is called with a two\narguments: the syntactic symbol for the brace and the buffer position\nat which the brace was inserted.  The function must return a list as\ndescribed in the preceding paragraph.  Note that during the call to\nthe function, the variable `c-syntactic-context' is set to the entire\nsyntactic context for the brace line.\n\nThis is a style variable.  Apart from the valid values described\nabove, it can be set to the symbol `set-from-style'.  In that case,\nit takes its value from the style system (see `c-default-style' and\n`c-style-alist') when a CC Mode buffer is initialized.  Otherwise,\nthe value set here overrides the style system (there is a variable\n`c-old-style-variable-behavior' that changes this, though)." (radio #1# (set :tag #2# :value #18# (cons :format #19="%v" (const :size 24 :format "defun-open:             " :value defun-open) #20=(choice :format "%[Choice%] %v" :value (before after) (set :menu-tag "Before/after" :format "Newline  %v brace\n" (const :format "%v,  " before) (const :format "%v " after)) (function :menu-tag "Function" :format "Run function: %v"))) (cons :format #19# (const :size 24 :format "defun-close:            " :value defun-close) #20#) (cons :format #19# (const :size 24 :format "class-open:             " :value class-open) #20#) (cons :format #19# (const :size 24 :format "class-close:            " :value class-close) #20#) (cons :format #19# (const :size 24 :format "inline-open:            " :value inline-open) #20#) (cons :format #19# (const :size 24 :format "inline-close:           " :value inline-close) #20#) (cons :format #19# (const :size 24 :format "block-open:             " :value block-open) #20#) (cons :format #19# (const :size 24 :format "block-close:            " :value block-close) #20#) (cons :format #19# (const :size 24 :format "statement-cont:         " :value statement-cont) #20#) (cons :format #19# (const :size 24 :format "substatement-open:      " :value substatement-open) #20#) (cons :format #19# (const :size 24 :format "statement-case-open:    " :value statement-case-open) #20#) (cons :format #19# (const :size 24 :format "brace-list-open:        " :value brace-list-open) #20#) (cons :format #19# (const :size 24 :format "brace-list-close:       " :value brace-list-close) #20#) (cons :format #19# (const :size 24 :format "brace-list-intro:       " :value brace-list-intro) #20#) (cons :format #19# (const :size 24 :format "brace-entry-open:       " :value brace-entry-open) #20#) (cons :format #19# (const :size 24 :format "extern-lang-open:       " :value extern-lang-open) #20#) (cons :format #19# (const :size 24 :format "extern-lang-close:      " :value extern-lang-close) #20#) (cons :format #19# (const :size 24 :format "namespace-open:         " :value namespace-open) #20#) (cons :format #19# (const :size 24 :format "namespace-close:        " :value namespace-close) #20#) (cons :format #19# (const :size 24 :format "module-open:            " :value module-open) #20#) (cons :format #19# (const :size 24 :format "module-close:           " :value module-close) #20#) (cons :format #19# (const :size 24 :format "composition-open:       " :value composition-open) #20#) (cons :format #19# (const :size 24 :format "composition-close:      " :value composition-close) #20#) (cons :format #19# (const :size 24 :format "inexpr-class-open:      " :value inexpr-class-open) #20#) (cons :format #19# (const :size 24 :format "inexpr-class-close:     " :value inexpr-class-close) #20#) (cons :format #19# (const :size 24 :format "arglist-cont-nonempty:  " :value arglist-cont-nonempty) #20#))) c-max-one-liner-length 80 "Maximum length of line that clean-up \"one-liner-defun\" will compact to.\nZero or nil means no limit." integer c-hanging-colons-alist "*Controls the insertion of newlines before and after certain colons.\nThis variable contains an association list with elements of the\nfollowing form: (SYNTACTIC-SYMBOL . ACTION).\n\nSYNTACTIC-SYMBOL can be any of: case-label, label, access-label,\nmember-init-intro, or inher-intro.\n\nSee the variable `c-hanging-braces-alist' for the semantics of this\nvariable.  Note however that making ACTION a function symbol is\ncurrently not supported for this variable.\n\nThis is a style variable.  Apart from the valid values described\nabove, it can be set to the symbol `set-from-style'.  In that case,\nit takes its value from the style system (see `c-default-style' and\n`c-style-alist') when a CC Mode buffer is initialized.  Otherwise,\nthe value set here overrides the style system (there is a variable\n`c-old-style-variable-behavior' that changes this, though)." (radio #1# (set :tag #2# :value nil (cons :format #21="%v" (const :size 20 :format "case-label:         " :value case-label) #22=(set :format "Newline  %v  colon\n" (const :format "%v,  " before) (const :format "%v" after))) (cons :format #21# (const :size 20 :format "label:              " :value label) #22#) (cons :format #21# (const :size 20 :format "access-label:       " :value access-label) #22#) (cons :format #21# (const :size 20 :format "member-init-intro:  " :value member-init-intro) #22#) (cons :format #21# (const :size 20 :format "inher-intro:        " :value inher-intro) #22#))) c-hanging-semi&comma-criteria #23=(c-semi&comma-inside-parenlist) "*List of functions that decide whether to insert a newline or not.\nThe functions in this list are called, in order, whenever the\nauto-newline minor mode is activated (as evidenced by a `/a' or `/ah'\nstring in the mode line), and a semicolon or comma is typed (see\n`c-electric-semi&comma').  Each function in this list is called with\nno arguments, and should return one of the following values:\n\n  nil             -- no determination made, continue checking\n  'stop           -- do not insert a newline, and stop checking\n  (anything else) -- insert a newline, and stop checking\n\nIf every function in the list is called with no determination made,\nthen no newline is inserted.\n\nThis is a style variable.  Apart from the valid values described\nabove, it can be set to the symbol `set-from-style'.  In that case,\nit takes its value from the style system (see `c-default-style' and\n`c-style-alist') when a CC Mode buffer is initialized.  Otherwise,\nthe value set here overrides the style system (there is a variable\n`c-old-style-variable-behavior' that changes this, though)." (radio #1# (repeat :tag #2# :value #23# function)) c-backslash-column 48 "*Minimum alignment column for line continuation backslashes.\nThis is used by the functions that automatically insert or align the\nline continuation backslashes in multiline macros.  If any line in the\nmacro exceeds this column then the next tab stop from that line is\nused as alignment column instead.  See also `c-backslash-max-column'.\n\nThis is a style variable.  Apart from the valid values described\nabove, it can be set to the symbol `set-from-style'.  In that case,\nit takes its value from the style system (see `c-default-style' and\n`c-style-alist') when a CC Mode buffer is initialized.  Otherwise,\nthe value set here overrides the style system (there is a variable\n`c-old-style-variable-behavior' that changes this, though)." (radio #1# (integer :tag #2# :value 48)) c-backslash-max-column 72 "*Maximum alignment column for line continuation backslashes.\nThis is used by the functions that automatically insert or align the\nline continuation backslashes in multiline macros.  If any line in the\nmacro exceeds this column then the backslashes for the other lines\nwill be aligned at this column.\n\nThis is a style variable.  Apart from the valid values described\nabove, it can be set to the symbol `set-from-style'.  In that case,\nit takes its value from the style system (see `c-default-style' and\n`c-style-alist') when a CC Mode buffer is initialized.  Otherwise,\nthe value set here overrides the style system (there is a variable\n`c-old-style-variable-behavior' that changes this, though)." (radio #1# (integer :tag #2# :value 72)) c-auto-align-backslashes "*Align automatically inserted line continuation backslashes.\nWhen line continuation backslashes are inserted automatically for line\nbreaks in multiline macros, e.g. by \\[c-context-line-break], they are\naligned with the other backslashes in the same macro if this flag is\nset.  Otherwise the inserted backslashes are preceded by a single\nspace." c-backspace-function 'backward-delete-char-untabify "*Function called by `c-electric-backspace' when deleting backwards." c-delete-function 'delete-char "*Function called by `c-electric-delete-forward' when deleting forwards." c-require-final-newline '((c-mode . t) (c++-mode . t) (objc-mode . t)) "*Controls whether a final newline is ensured when the file is saved.\nThe value is an association list that for each language mode specifies\nthe value to give to `require-final-newline' at mode initialization;\nsee that variable for details about the value.  If a language isn't\npresent on the association list, CC Mode won't touch\n`require-final-newline' in buffers for that language." set cons :format "%v" (const :format "C     " c-mode) symbol :value (const :format "C++   " c++-mode) (const :format "ObjC  " objc-mode) (const :format "Java  " java-mode) (const :format "IDL   " idl-mode) (const :format "Pike  " pike-mode) (const :format "AWK   " awk-mode) c-electric-pound-behavior "*List of behaviors for electric pound insertion.\nOnly currently supported behavior is `alignleft'." (set (const alignleft)) c-special-indent-hook "*Hook for user defined special indentation adjustments.\nThis hook gets called after each line is indented by the mode.  It is only\ncalled if `c-syntactic-indentation' is non-nil." hook c-label-minimum-indentation 1 "*Minimum indentation for lines inside code blocks.\nThis variable typically only affects code using the `gnu' style, which\nmandates a minimum of one space in front of every line inside code\nblocks.  Specifically, the function `c-gnu-impose-minimum' on your\n`c-special-indent-hook' is what enforces this.\n\nThis is a style variable.  Apart from the valid values described\nabove, it can be set to the symbol `set-from-style'.  In that case,\nit takes its value from the style system (see `c-default-style' and\n`c-style-alist') when a CC Mode buffer is initialized.  Otherwise,\nthe value set here overrides the style system (there is a variable\n`c-old-style-variable-behavior' that changes this, though)." (radio #1# (integer :tag #2# :value 1)) c-progress-interval 5 "*Interval used to update progress status during long re-indentation.\nIf a number, percentage complete gets updated after each interval of\nthat many seconds.  To inhibit all messages during indentation, set\nthis variable to nil." c-objc-method-arg-min-delta-to-bracket 2 "*Minimum number of chars to the opening bracket.\n\nConsider this ObjC snippet:\n\n	[foo blahBlah: fred\n	|<-x->|barBaz: barney\n\nIf `x' is less than this number then `c-lineup-ObjC-method-call-colons'\nwill defer the indentation decision to the next function.  By default\nthis is `c-lineup-ObjC-method-call', which would align it like:\n\n	[foo blahBlahBlah: fred\n	     thisIsTooDamnLong: barney\n\nThis behavior can be overridden by customizing the indentation of\n`objc-method-call-cont' in the \"objc\" style." c-objc-method-arg-unfinished-offset "*Offset relative to bracket if first selector is on a new line.\n\n    [aaaaaaaaa\n    |<-x->|bbbbbbb:  cccccc\n             ddddd: eeee];" c-objc-method-parameter-offset "*Offset for selector parameter on a new line (relative to first selector.\n\n    [aaaaaaa bbbbbbbbbb:\n	     |<-x->|cccccccc\n                    ddd: eeee\n                   ffff: ggg];" c-default-style '((java-mode . "java") (awk-mode . "awk") (other . "gnu")) "*Style which gets installed by default when a file is visited.\n\nThe value of this variable can be any style defined in\n`c-style-alist', including styles you add.  The value can also be an\nassociation list of major mode symbols to style names.\n\nWhen the value is a string, all CC Mode major modes will install this\nstyle by default.\n\nWhen the value is an alist, the major mode symbol is looked up in it\nand the associated style is installed.  If the major mode is not\nlisted in the alist, then the symbol `other' is looked up in it, and\nif found, the style in that entry is used.  If `other' is not found in\nthe alist, then \"gnu\" style is used.\n\nThe default style gets installed before your mode hooks run, so you\ncan always override the use of `c-default-style' by making calls to\n`c-set-style' in the appropriate mode hook." (radio (string :tag "Style in all modes") (set :tag "Mode-specific styles" (cons :format "%v" (const :format "C     " c-mode) (string :format "%v")) (cons :format "%v" (const :format "C++   " c++-mode) (string :format "%v")) (cons :format "%v" (const :format "ObjC  " objc-mode) (string :format "%v")) (cons :format "%v" (const :format "Java  " java-mode) (string :format "%v")) (cons :format "%v" (const :format "IDL   " idl-mode) (string :format "%v")) (cons :format "%v" (const :format "Pike  " pike-mode) (string :format "%v")) (cons :format "%v" (const :format "AWK   " awk-mode) (string :format "%v")) (cons :format "%v" (const :format "Other " other) (string :format "%v")))) c-offsets-alist ((string . c-lineup-dont-change) (c . c-lineup-C-comments) (defun-open . 0) (defun-close . 0) (defun-block-intro . +) (class-open . 0) (class-close . 0) (inline-open . +) (inline-close . 0) (func-decl-cont . +) (knr-argdecl-intro . +) (knr-argdecl . 0) (topmost-intro . 0) (topmost-intro-cont . c-lineup-topmost-intro-cont) (annotation-top-cont . 0) (annotation-var-cont . +) (member-init-intro . +) (member-init-cont . c-lineup-multi-inher) (inher-intro . +) (inher-cont . c-lineup-multi-inher) (block-open . 0) (block-close . 0) (brace-list-open . 0) (brace-list-close . 0) (brace-list-intro . +) (brace-list-entry . 0) (brace-entry-open . 0) (statement . 0) (statement-cont . +) (statement-block-intro . +) (statement-case-intro . +) (statement-case-open . 0) (substatement . +) (substatement-open . +) (substatement-label . 2) (case-label . 0) (access-label . -) (label . 2) (do-while-closure . 0) (else-clause . 0) (catch-clause . 0) (comment-intro c-lineup-knr-region-comment c-lineup-comment) (arglist-intro . +) (arglist-cont c-lineup-gcc-asm-reg 0) (arglist-cont-nonempty c-lineup-gcc-asm-reg c-lineup-arglist) (arglist-close . +) (stream-op . c-lineup-streamop) (inclass . +) (cpp-macro . [0]) (cpp-macro-cont . +) (cpp-define-intro c-lineup-cpp-define +) (friend . 0) (objc-method-intro . [0]) (objc-method-args-cont . c-lineup-ObjC-method-args) (objc-method-call-cont c-lineup-ObjC-method-call-colons c-lineup-ObjC-method-call +) (extern-lang-open . 0) (namespace-open . 0) (module-open . 0) (composition-open . 0) (extern-lang-close . 0) (namespace-close . 0) (module-close . 0) (composition-close . 0) (inextern-lang . +) (innamespace . +) (inmodule . +) (incomposition . +) (template-args-cont c-lineup-template-args +) (inlambda . c-lineup-inexpr-block) (lambda-intro-cont . +) (inexpr-statement . +) (inexpr-class . +)) "Association list of syntactic element symbols and indentation offsets.\nAs described below, each cons cell in this list has the form:\n\n    (SYNTACTIC-SYMBOL . OFFSET)\n\nWhen a line is indented, CC Mode first determines the syntactic\ncontext of it by generating a list of symbols called syntactic\nelements.  The global variable `c-syntactic-context' is bound to the\nthat list.  Each element in the list is in turn a list where the first\nelement is a syntactic symbol which tells what kind of construct the\nindentation point is located within.  More elements in the syntactic\nelement lists are optional.  If there is one more and it isn't nil,\nthen it's the anchor position for that construct.\n\nAfter generating the syntactic context for the line, CC Mode\ncalculates the absolute indentation: First the base indentation is\nfound by using the anchor position for the first syntactic element\nthat provides one.  If none does, zero is used as base indentation.\nThen CC Mode looks at each syntactic element in the context in turn.\nIt compares the car of the syntactic element against the\nSYNTACTIC-SYMBOL's in `c-offsets-alist'.  When it finds a match, it\nadds OFFSET to the base indentation.  The sum of this calculation is\nthe absolute offset for line being indented.\n\nIf the syntactic element does not match any in the `c-offsets-alist',\nthe element is ignored.\n\nOFFSET can specify an offset in several different ways:\n\n  If OFFSET is nil then it's ignored.\n\n  If OFFSET is an integer then it's used as relative offset, i.e. it's\n  added to the base indentation.\n\n  If OFFSET is one of the symbols `+', `-', `++', `--', `*', or `/'\n  then a positive or negative multiple of `c-basic-offset' is added to\n  the base indentation; 1, -1, 2, -2, 0.5, and -0.5, respectively.\n\n  If OFFSET is a symbol with a value binding then that value, which\n  must be an integer, is used as relative offset.\n\n  If OFFSET is a vector then its first element, which must be an\n  integer, is used as an absolute indentation column.  This overrides\n  the previous base indentation and the relative offsets applied to\n  it, and it becomes the new base indentation.\n\n  If OFFSET is a function or a lambda expression then it's called with\n  a single argument containing the cons of the syntactic symbol and\n  the anchor position (or nil if there is none).  The return value\n  from the function is then reinterpreted as an offset specification.\n\n  If OFFSET is a list then its elements are evaluated recursively as\n  offset specifications.  If the first element is any of the symbols\n  below then it isn't evaluated but instead specifies how the\n  remaining offsets in the list should be combined.  If it's something\n  else then the list is combined according the method `first'.  The\n  valid combination methods are:\n\n  `first' -- Use the first offset (that doesn't evaluate to nil).\n  `min'   -- Use the minimum of all the offsets.  All must be either\n             relative or absolute - they can't be mixed.\n  `max'   -- Use the maximum of all the offsets.  All must be either\n             relative or absolute - they can't be mixed.\n  `add'   -- Add all the evaluated offsets together.  Exactly one of\n             them may be absolute, in which case the result is\n             absolute.  Any relative offsets that preceded the\n             absolute one in the list will be ignored in that case.\n\n`c-offsets-alist' is a style variable.  This means that the offsets on\nthis variable are normally taken from the style system in CC Mode\n(see `c-default-style' and `c-style-alist').  However, any offsets\nput explicitly on this list will override the style system when a CC\nMode buffer is initialized (there is a variable\n`c-old-style-variable-behavior' that changes this, though).\n\nHere is the current list of valid syntactic element symbols:\n\n string                 -- Inside multi-line string.\n c                      -- Inside a multi-line C style block comment.\n defun-open             -- Brace that opens a function definition.\n defun-close            -- Brace that closes a function definition.\n defun-block-intro      -- The first line in a top-level defun.\n class-open             -- Brace that opens a class definition.\n class-close            -- Brace that closes a class definition.\n inline-open            -- Brace that opens an in-class inline method.\n inline-close           -- Brace that closes an in-class inline method.\n func-decl-cont         -- The region between a function definition's\n                           argument list and the function opening brace\n                           (excluding K&R argument declarations).  In C, you\n                           cannot put anything but whitespace and comments\n                           between them; in C++ and Java, throws declarations\n                           and other things can appear in this context.\n knr-argdecl-intro      -- First line of a K&R C argument declaration.\n knr-argdecl		-- Subsequent lines in a K&R C argument declaration.\n topmost-intro		-- The first line in a topmost construct definition.\n topmost-intro-cont	-- Topmost definition continuation lines.\n annotation-top-cont    -- Topmost definition continuation line where only\n 			   annotations are on previous lines.\n annotation-var-cont    -- A continuation of a C (or like) statement where\n 			   only annotations are on previous lines.\n member-init-intro	-- First line in a member initialization list.\n member-init-cont	-- Subsequent member initialization list lines.\n inher-intro		-- First line of a multiple inheritance list.\n inher-cont             -- Subsequent multiple inheritance lines.\n block-open             -- Statement block open brace.\n block-close            -- Statement block close brace.\n brace-list-open        -- Open brace of an enum or static array list.\n brace-list-close       -- Close brace of an enum or static array list.\n brace-list-intro       -- First line in an enum or static array list.\n brace-list-entry       -- Subsequent lines in an enum or static array list.\n brace-entry-open       -- Subsequent lines in an enum or static array\n                           list that start with an open brace.\n statement              -- A C (or like) statement.\n statement-cont         -- A continuation of a C (or like) statement.\n statement-block-intro  -- The first line in a new statement block.\n statement-case-intro   -- The first line in a case \"block\".\n statement-case-open    -- The first line in a case block starting with brace.\n substatement           -- The first line after an if/while/for/do/else.\n substatement-open      -- The brace that opens a substatement block.\n substatement-label     -- Labeled line after an if/while/for/do/else.\n case-label             -- A \"case\" or \"default\" label.\n access-label           -- C++ private/protected/public access label.\n label                  -- Any ordinary label.\n do-while-closure       -- The \"while\" that ends a do/while construct.\n else-clause            -- The \"else\" of an if/else construct.\n catch-clause           -- The \"catch\" or \"finally\" of a try/catch construct.\n comment-intro          -- A line containing only a comment introduction.\n arglist-intro          -- The first line in an argument list.\n arglist-cont           -- Subsequent argument list lines when no\n                           arguments follow on the same line as the\n                           arglist opening paren.\n arglist-cont-nonempty  -- Subsequent argument list lines when at\n                           least one argument follows on the same\n                           line as the arglist opening paren.\n arglist-close          -- The solo close paren of an argument list.\n stream-op              -- Lines continuing a stream operator construct.\n inclass                -- The construct is nested inside a class definition.\n                           Used together with e.g. `topmost-intro'.\n cpp-macro              -- The start of a C preprocessor macro definition.\n cpp-macro-cont         -- Inside a multi-line C preprocessor macro definition.\n friend                 -- A C++ friend declaration.\n objc-method-intro      -- The first line of an Objective-C method definition.\n objc-method-args-cont  -- Lines continuing an Objective-C method definition.\n objc-method-call-cont  -- Lines continuing an Objective-C method call.\n extern-lang-open       -- Brace that opens an \"extern\" block.\n extern-lang-close      -- Brace that closes an \"extern\" block.\n inextern-lang          -- Analogous to the `inclass' syntactic symbol,\n                           but used inside \"extern\" blocks.\n namespace-open, namespace-close, innamespace\n                        -- Similar to the three `extern-lang' symbols, but for\n                           C++ \"namespace\" blocks.\n module-open, module-close, inmodule\n                        -- Similar to the three `extern-lang' symbols, but for\n                           CORBA IDL \"module\" blocks.\n composition-open, composition-close, incomposition\n                        -- Similar to the three `extern-lang' symbols, but for\n                           CORBA CIDL \"composition\" blocks.\n template-args-cont     -- C++ template argument list continuations.\n inlambda               -- In the header or body of a lambda function.\n lambda-intro-cont      -- Continuation of the header of a lambda function.\n inexpr-statement       -- The statement is inside an expression.\n inexpr-class           -- The class is inside an expression.  Used e.g. for\n                           Java anonymous classes." "%{%t%}:\n Override style setting\n |  Syntax                     Offset\n%v" mapcar #[(elt) "\301\302\303\304\305@\306\"\307BBBBBB\207" [elt cons :format "%v" :value c-constant-symbol 25 ((sexp :format "%v" :validate (lambda (widget) (unless (c-valid-offset (widget-value widget)) (widget-put widget :error "Invalid offset") widget))))] 8]] 21)
(defconst c-inside-block-syms '(defun-block-intro block-open block-close statement statement-cont statement-block-intro statement-case-intro statement-case-open substatement substatement-open substatement-label case-label label do-while-closure else-clause catch-clause inlambda annotation-var-cont))
(byte-code "\300\301\302\303\304\305\306\307\310\311&	\210\300\312\313\314\304\315\310\311&\210\300\316\313\317\304\315\310\311&\210\300\320\313\321\304\315\310\311&\210\300\322\313\323\304\315\310\311&\210\300\324\313\325\304\315\310\311&\210\300\326\313\327\304\315\310\311&\210\300\330\313\331\304\315\310\311&\210\300\332\313\333\304\315\310\311&\210\300\334\313\335\304\315\310\311&\210\300\336\313\337\304\305\310\311&\207" [custom-declare-variable c-style-variables-are-local-p t "*Whether style variables should be buffer local by default.\nIf non-nil, then all indentation style related variables will be made\nbuffer local by default.  If nil, they will remain global.  Variables\nare made buffer local when this file is loaded, and once buffer\nlocalized, they cannot be made global again.\n\nThis variable must be set appropriately before CC Mode is loaded.\n\nThe list of variables to buffer localize are:\n    c-basic-offset\n    c-comment-only-line-offset\n    c-indent-comment-alist\n    c-indent-comments-syntactically-p\n    c-block-comment-prefix\n    c-comment-prefix-regexp\n    c-doc-comment-style\n    c-cleanup-list\n    c-hanging-braces-alist\n    c-hanging-colons-alist\n    c-hanging-semi&comma-criteria\n    c-backslash-column\n    c-backslash-max-column\n    c-label-minimum-indentation\n    c-offsets-alist\n    c-special-indent-hook\n    c-indentation-style" :type boolean :safe booleanp :group c c-mode-hook nil "*Hook called by `c-mode'." hook c++-mode-hook "*Hook called by `c++-mode'." objc-mode-hook "*Hook called by `objc-mode'." java-mode-hook "*Hook called by `java-mode'." idl-mode-hook "*Hook called by `idl-mode'." pike-mode-hook "*Hook called by `pike-mode'." awk-mode-hook "*Hook called by `awk-mode'." c-mode-common-hook "*Hook called by all CC Mode modes for common initializations." c-initialization-hook "*Hook called when the CC Mode package gets initialized.\nThis hook is only run once per Emacs session and can be used as a\n`load-hook' or in place of using `eval-after-load'." c-enable-xemacs-performance-kludge-p "*Enables a XEmacs only hack that may improve speed for some coding styles.\nFor styles that hang top-level opening braces (as is common with JDK\nJava coding styles) this can improve performance between 3 and 60\ntimes for core indentation functions (e.g. `c-parse-state').  For\nstyles that conform to the Emacs recommendation of putting these\nbraces in column zero, this can degrade performance about as much.\nThis variable only has effect in XEmacs."] 10)
#@743 *Enables the old style variable behavior when non-nil.

Normally the values of the style variables will override the style
settings specified by the variables `c-default-style' and
`c-style-alist'.  However, in CC Mode 5.25 and earlier, it was the
other way around, meaning that changes made to the style variables
from e.g. Customize would not take effect unless special precautions
were taken.  That was confusing, especially for novice users.

It's believed that despite this change, the new behavior will still
produce the same results for most old CC Mode configurations, since
all style variables are per default set in a special non-override
state.  Set this variable only if your configuration has stopped
working due to this change.
(defvar c-old-style-variable-behavior nil (#$ . -61967))
(define-widget 'c-extra-types-widget 'radio "Internal CC Mode widget for the `*-font-lock-extra-types' variables." :args '((const :tag "none" nil) (repeat :tag "types" regexp)))
(defalias 'c-make-font-lock-extra-types-blurb #[(mode1 mode2 example) "\303\304	\305\n\306\260\207" [mode1 example mode2 "*List of extra types (aside from the type keywords) to recognize in " " mode.\nEach list item should be a regexp matching a single identifier.\n" "\n\nNote that items on this list that don't include any regexp special\ncharacters are automatically optimized using `regexp-opt', so you\nshould not use `regexp-opt' explicitly to build regexps here.\n\nOn decoration level 3 (and higher, where applicable), a method is used\nthat finds most types and declarations by syntax alone.  This variable\nis still used as a first step, but other types are recognized\ncorrectly anyway in most cases.  Therefore this variable should be\nfairly restrictive and not contain patterns that are uncertain.\n\nNote that this variable is only consulted when the major mode is\ninitialized.  If you change it later you have to reinitialize CC Mode\nby doing \\[" "].\n\nDespite the name, this variable is not only used for font locking but\nalso elsewhere in CC Mode to tell types from other identifiers."] 7])
(byte-code "\302\303\304\305\306\307\310#\311\312\313\314&\210\302\315\316\305\317\320\321#\311\312\313\314&\210\302\322\323\305\324\325\326\327	\330\260#\311\312\313\314&\210\302\331\332\305\333\334\326\327	\335\260#\311\312\313\314&\210\302\336\337\305\340\341\342#\311\312\313\314&\210\302\343\344\305\345\346\326\327	\330\260#\311\312\313\314&\207" [c-upper c-lower custom-declare-variable c-font-lock-extra-types '("\\sw+_t" "bool" "complex" "imaginary" "FILE" "lconv" "tm" "va_list" "jmp_buf" "Lisp_Object") c-make-font-lock-extra-types-blurb "C" "c-mode" "For example, a value of (\"FILE\" \"\\\\sw+_t\") means the word \"FILE\"\nand words ending in \"_t\" are treated as type names." :type c-extra-types-widget :group c c++-font-lock-extra-types '("\\sw+_t" "FILE" "lconv" "tm" "va_list" "jmp_buf" "istream" "istreambuf" "ostream" "ostreambuf" "ifstream" "ofstream" "fstream" "strstream" "strstreambuf" "istrstream" "ostrstream" "ios" "string" "rope" "list" "slist" "deque" "vector" "bit_vector" "set" "multiset" "map" "multimap" "hash" "hash_set" "hash_multiset" "hash_map" "hash_multimap" "stack" "queue" "priority_queue" "type_info" "iterator" "const_iterator" "reverse_iterator" "const_reverse_iterator" "reference" "const_reference") "C++" "c++-mode" "For example, a value of (\"string\") means the word \"string\" is treated\nas a type name." objc-font-lock-extra-types (list (concat "[" c-upper "]\\sw*[" c-lower "]\\sw*")) "ObjC" "objc-mode" "For example, a value of (\"[" "]\\\\sw*[" "]\\\\sw*\") means\ncapitalized words are treated as type names (the requirement for a\nlower case char is to avoid recognizing all-caps macro and constant\nnames)." java-font-lock-extra-types (list (concat "[" c-upper "]\\sw*[" c-lower "]\\sw")) "Java" "java-mode" "]\\\\sw*\") means\ncapitalized words are treated as type names (the requirement for a\nlower case char is to avoid recognizing all-caps constant names)." idl-font-lock-extra-types nil "IDL" "idl-mode" "" pike-font-lock-extra-types (list (concat "[" c-upper "]\\sw*[" c-lower "]\\sw*")) "Pike" "pike-mode"] 11)
(defvar c-macro-with-semi-re nil)
(make-variable-buffer-local 'c-macro-with-semi-re)
(defalias 'c-make-macro-with-semi-re #[nil "\205)	;\203\303	!\202)	:\203\304\305	!\306Q\202)	\204%\307\202)\310\311	\"\211\207" [c-opt-cpp-macro-define c-macro-names-with-semicolon c-macro-with-semi-re copy-sequence "\\<" regexp-opt "\\>" nil error "c-make-macro-with-semi-re: invalid c-macro-names-with-semicolon: %s"] 3])
#@577 List of #defined symbols whose expansion ends with a semicolon.
Alternatively it can be a string, a regular expression which
matches all such symbols.

The "symbols" must be syntactically valid identifiers in the
target language (C, C++, Objective C), or (as the case may be)
the regular expression must match only valid identifiers.

If you change this variable's value, call the function
`c-make-macros-with-semi-re' to set the necessary internal
variables.

Note that currently (2008-11-04) this variable is a prototype,
and is likely to disappear or change its form soon.
(defvar c-macro-names-with-semicolon '("Q_OBJECT" "Q_PROPERTY" "Q_DECLARE" "Q_ENUMS") (#$ . 66577))
(make-variable-buffer-local 'c-macro-names-with-semicolon)
#@380 Variable interface for setting style via File Local Variables.
In a file's Local Variable section, you can set this variable to a
string suitable for `c-set-style'.  When the file is visited, CC Mode
will set the style of the file to this value automatically.

Note that file style settings are applied before file offset settings
as designated in the variable `c-file-offsets'.
(defvar c-file-style nil (#$ . 67319))
(make-variable-buffer-local 'c-file-style)
#@405 Variable interface for setting offsets via File Local Variables.
In a file's Local Variable section, you can set this variable to an
association list similar to the values allowed in `c-offsets-alist'.
When the file is visited, CC Mode will institute these offset settings
automatically.

Note that file offset settings are applied after file style settings
as designated in the variable `c-file-style'.
(defvar c-file-offsets nil (#$ . 67787))
(byte-code "\300\301!\210\302\303\304\305#\210\302\306\304\307#\207" [make-variable-buffer-local c-file-offsets put c-syntactic-context variable-documentation "Variable containing the syntactic analysis list for a line of code.\n\nIt is a list with one element for each syntactic symbol pertinent to the\nline, for example \"((defun-block-intro 1) (comment-intro))\".\n\nIt is dynamically bound when calling (i) a brace hanging \"action\nfunction\"; (ii) a semicolon/comma hanging \"criteria function\"; (iii) a\n\"line-up function\"; (iv) a c-special-indent-hook function.  It is also\nused internally by CC Mode.\n\nc-syntactic-context is always bound dynamically.  It must NEVER be set\nstatically (e.g. with `setq')." c-syntactic-element "Variable containing the current syntactic element during calls to\nthe lineup functions.  The value is one of the elements in the list in\n`c-syntactic-context' and is a list with the symbol name in the first\nposition, followed by zero or more elements containing any additional\ninfo associated with the syntactic symbol.  There are accessor functions\n`c-langelem-sym', `c-langelem-pos', `c-langelem-col', and\n`c-langelem-2nd-pos' to access the list.\n\nSpecifically, the element returned by `c-langelem-pos' is the anchor\nposition, or nil if there isn't any.  See the comments in the\n`c-offsets-alist' variable and the CC Mode manual for more detailed info\nabout the data each syntactic symbol provides.\n\nThis is always bound dynamically.  It should never be set\nstatically (e.g. with `setq')."] 4)
#@166 Name of the currently installed style.
Don't change this directly; call `c-set-style' instead, or set the variable
`c-file-style' in the file's Local Variable list.
(defvar c-indentation-style nil (#$ . 69792))
#@95 The current comment prefix regexp.
Set from `c-comment-prefix-regexp' at mode initialization.
(defvar c-current-comment-prefix nil (#$ . 70009))
(make-variable-buffer-local 'c-current-comment-prefix)
#@92 Value of paragraph-start used when scanning strings.
It treats escaped EOLs as whitespace.
(defvar c-string-par-start "\f\\|[ 	]*\\\\?$" (#$ . 70215))
#@95 Value of paragraph-separate used when scanning strings.
It treats escaped EOLs as whitespace.
(defvar c-string-par-separate "[ 	\f]*\\\\?$" (#$ . 70372))
#@96 Value used like sentence-end used when scanning strings.
It treats escaped EOLs as whitespace.
(defvar c-sentence-end-with-esc-eol (byte-code "\301\302\300 )\303\304\305\303\260\207" [sentence-end "\\(\\(" nil "\\)" "\\|" "[.?!][]\"')}]* ?\\\\\\($\\)[ 	\n]*"] 6) (#$ . 70532))
(provide 'cc-vars)