;ELC ;;; compiled by jwz@thalidomide on Fri Dec 31 01:58:15 1993 ;;; from file /th/jwz/emacs19/lisp/modes/c++-mode.el ;;; emacs version 19.9 Lucid (beta9). ;;; bytecomp version 2.22; 22-dec-93. ;;; optimization is on. ;;; this file uses opcodes which do not exist in Emacs 18. (if (and (boundp 'emacs-version) (or (and (boundp 'epoch::version) epoch::version) (string-lessp emacs-version "19"))) (error "This file was compiled for Emacs 19.")) (byte-code "!#ć" [fboundp c-mode load "c-mode" nil t] 4) (defconst c++-emacs-features (byte-code "``\"GU #H\"\"U!) \n*D" [no-dual-comments v18 scanner mse-spec parse-partial-sexp 8 copy-syntax-table table modify-syntax-entry 97 ". 12345678" logand lsh -16 255 8-bit 1-bit fboundp forward-comment v19 old-v19] 4) "\ A list of needed features extant in the Emacs you are using. There are many flavors of Emacs out on the net, each with different features supporting those needed by c++-mode. Here's the current known list, along with the values for this variable: Vanilla GNU 18/Epoch 4: (no-dual-comments v18) GNU 18/Epoch 4 (patch1): (8-bit old-v19) GNU 18/Epoch 4 (patch2): (8-bit v19) Lemacs 19.4 - 19.7: (8-bit old-v19) Lemacs 19.8 and over: (8-bit v19) FSF 19: (1-bit v19) FSF 19 (patched): (8-bit v19)") (defvar c++-mode-abbrev-table nil "\ Abbrev table in use in c++-mode buffers.") (define-abbrev-table 'c++-mode-abbrev-table nil) (defvar c++-mode-map nil "\ Keymap used in c++-mode.") (byte-code " ########################3>########@A#BC#" [c++-mode-map make-sparse-keymap define-key "\n" reindent-then-newline-and-indent " " newline-and-indent "{" c++-electric-brace "}" ";" c++-electric-semi "#" c++-electric-pound "" mark-c-function "" c++-indent-exp " " c++-indent-command " " c++-insert-header "" c++-macroize-region "" c++-comment-region "" c++-uncomment-region "" c++-match-paren "" c++-beginning-of-defun "" c++-end-of-defun "" c++-indent-defun "/" c++-electric-slash "*" c++-electric-star ":" c++-electric-colon "" c++-electric-delete "" c++-toggle-auto-hungry-state "" c++-toggle-hungry-state "" c++-toggle-auto-state v18 c++-emacs-features "'" c++-tame-comments "'" c++-tame-insert "[" "]" "(" ")" "" c++-submit-bug-report "" c++-version "" c++-forward-sexp "" c++-backward-sexp] 4) (defvar c++-mode-syntax-table nil "\ Syntax table used in c++-mode buffers.") (defvar c++-c-mode-syntax-table nil "\ Syntax table used in c++-c-mode buffers.") (byte-code " ##########>###>###### ############" [c++-mode-syntax-table make-syntax-table modify-syntax-entry 92 "\\" 43 "." 45 61 37 60 62 38 124 39 "\"" 8-bit c++-emacs-features 47 ". 1456" 42 ". 23" 10 "> b" 1-bit ". 124" ". 23b" ">" c++-c-mode-syntax-table ". 14"] 4) (defvar c++-tab-always-indent (byte-code "! ‡" [boundp c-tab-always-indent t] 2) "\ *Controls the operation of the TAB key. If t (the default), always just indent the current line. If nil, indent the current line only if point is at the left margin or in the line's indentation; otherwise insert a tab. If not-nil-or-t, then tab is inserted only within literals (comments and strings) and inside preprocessor directives, but line is always reindented.") (defvar c++-always-arglist-indent-p nil "\ *Control indentation of continued arglists. When non-nil, arglists continued on subsequent lines will always indent `c++-empty-arglist-indent' spaces, otherwise, they will indent to just under previous line's argument indentation.") (defvar c++-block-close-brace-offset 0 "\ *Extra indentation given to close braces which close a block. This variable can be either an integer or a list. If an integer, it describes the extra offset given a block closing brace (and a closing paren if `c++-paren-as-block-close-p' is non-nil), treating all closing parens the same. If a list of the form (OTHERS . TOPLEVEL), OTHERS is an integer describing the offset given to all but top-level (e.g. function) closing braces, while TOPLEVEL is an integer describing offset given only to braces which close top-level constructs.") (defvar c++-paren-as-block-close-p nil "\ *Treat a parenthesis which is the first non-whitespace on a line as a paren which closes a block. When non-nil, `c-indent-level' is subtracted, and `c++-block-close-brace-offset' is added to the line's offset.") (defvar c++-continued-member-init-offset nil "\ *Extra indent for continuation lines of member inits; nil means to align with previous initializations rather than with the colon on the first line.") (defvar c++-member-init-indent 0 "\ *Indentation level of member initializations in function declarations.") (defvar c++-friend-offset -4 "\ *Offset of C++ friend class declarations relative to member declarations.") (defvar c++-access-specifier-offset c-label-offset "\ *Extra indentation given to public, protected, and private labels.") (defvar c++-empty-arglist-indent nil "\ *Indicates how far to indent a line following an empty argument list. Nil means indent to just after the paren.") (defvar c++-comment-only-line-offset 0 "\ *Indentation offset for line which contains only C or C++ style comments. This variable can take either a single integer or a list of integers. If a single integer this is the extra indentation offset to apply to all comment-only lines, except those which start in column zero. If a list is used, the first integer is for all non-column-zero comment-only lines and the second integer is for all column-zero lines. You can also use a list containing only 1 integer, in which case, this value is used for all comment-only lines. For example: value meaning ===== ======= 0 comment-only lines do not indent 4 non-col0 lines indent 4 spaces, col0 lines don't indent '(4) all comment-only lines indent 4 spaces '(4 1) non-col0 lines indent 4 spaces, col0 lines indent 1 space") (defvar c++-C-block-comments-indent-p nil "\ *4 styles of C block comments are supported. If this variable is nil, then styles 1-3 are supported. If this variable is non-nil, style 4 is supported. style 1: style 2: style 3: style 4: /* /* /* /* blah * blah ** blah blah blah * blah ** blah blah */ */ */ */ ") (defvar c++-cleanup-list nil "\ *List of various C++ constructs to ``clean up''. These cleanups only take place when the auto-newline feature is turned on, as evidenced by the `/a' or `/ah' appearing next to the mode name. Current legal values are: `brace-else-brace' -- clean up ``} else {'' constructs by placing entire construct on a single line. This cleanup only takes place when there is nothing but white space between the braces and the else. `empty-defun-braces' -- cleans up empty C++ function braces by placing them on the same line. `defun-close-semi' -- cleans up the terminating semi-colon on class definitions and functions by placing the semi on the same line as the closing brace.") (defvar c++-hanging-braces t "\ *Controls the insertion of newlines before open (left) braces. This variable only has effect when auto-newline is on, as evidenced by the `/a' or `/ah' appearing next to the mode name. If nil, open braces do not hang (i.e. a newline is inserted before all open braces). If t, all open braces hang -- no newline is inserted before open braces. If not nil or t, newlines are only inserted before top-level open braces; all other braces hang.") (defvar c++-hanging-member-init-colon 'before "\ *Defines how colons which introduce member initializations are formatted. Legal values are: t -- no newlines inserted before or after colon nil -- newlines inserted before and after colon `after' -- newlines inserted only after colon `before` -- newlines inserted only before colon") (defvar c++-auto-hungry-initial-state 'none "\ *Initial state of auto/hungry features when buffer is first visited. Legal values are: `none' -- no auto-newline and no hungry-delete-key. `auto-only' -- auto-newline, but no hungry-delete-key. `hungry-only' -- no auto-newline, but hungry-delete-key. `auto-hungry' -- both auto-newline and hungry-delete-key enabled. Nil is synonymous for `none' and t is synonymous for `auto-hungry'.") (defvar c++-auto-hungry-toggle t "\ *Enable/disable toggling of auto/hungry features. Legal values are: `none' -- auto-newline and hungry-delete-key cannot be enabled. `auto-only' -- only auto-newline feature can be toggled. `hungry-only' -- only hungry-delete-key feature can be toggled. `auto-hungry' -- both auto-newline and hungry-delete-key can be toggled. Nil is synonymous for `none' and t is synonymous for `auto-hungry'.") (defvar c++-relative-offset-p t "\ *Control the calculation for indentation. When non-nil (the default), indentation is calculated relative to the first statement in the block. When nil, the indentation is calculated without regard to how the first statement is indented.") (defvar c++-untame-characters (byte-code " >‡" [v18 c++-emacs-features (39)] 2) "\ *Utilize a backslashing workaround of an Emacs syntax parsing bug. If non-nil, this variable should contain a list of characters which will be prepended by a backslash in comment regions. By default, the list contains only the most troublesome character, the single quote. To be completely safe, set this variable to: '(?( ?) ?' ?{ ?} ?[ ?]) This is the full list of characters which can potentially cause problems if they exist unbalanced within comments. Setting this variable to nil will defeat this feature, but be forewarned! Such un-escaped characters in comment regions can potentially break many things such as some indenting and blinking of parenthesis. Note further that only the default set of characters will be escaped automatically as they are typed. But, executing `c++-tame-comments' (\\[c++-tame-comments]) will escape all characters which are members of this set, and which are found in comments throughout the file. Finally, c++-mode can tell if you're running a patched Emacs. If so, taming characters isn't necessary and this variable is automatically set to nil.") (defvar c++-default-macroize-column 78 "\ *Column to insert backslashes.") (defvar c++-special-indent-hook nil "\ *Hook for user defined special indentation adjustments. This hook gets called after a line is indented by the mode. By supplying a hook, you can make adjustments to the line's standard indentation. If you do use this hook, you will likely need to also set `c++-relative-offset-p' to nil. The call to this hook is wrapped in a `save-excursion' so you don't need to worry about restoring point and mark inside the hook function.") (defvar c++-delete-function 'backward-delete-char-untabify "\ *Function called by `c++-electric-delete' when deleting a single char.") (defvar c++-electric-pound-behavior nil "\ *List of behaviors for electric pound insertion. Only currently supported behavior is `alignleft'.") (defvar c++-backscan-limit 2000 "\ *Limit in characters for looking back while skipping syntactic ws. If you typically write really big methods, and start noticing incorrect indentations, try cranking this value up. The larger this value is, though, the slower parts of c++-mode can become. Setting this variable to nil defeats backscan limits.") (defvar c++-hungry-delete-key nil "\ Internal state of hungry delete key feature.") (defvar c++-auto-newline nil "\ Internal state of auto newline feature.") (byte-code "!!" [make-variable-buffer-local c++-auto-newline c++-hungry-delete-key] 2) (defconst c++-access-key "\\<\\(public\\|protected\\|private\\)\\>:" "\ Regexp which describes access specification keywords.") (defconst c++-class-key (concat "\\(\\(extern\\|typedef\\)\\s +\\)?" "\\(template\\s *<[^>]*>\\s *\\)?" "\\<\\(class\\|struct\\|union\\)\\>") "\ Regexp which describes a class declaration, including templates.") (defconst c++-inher-key (concat "\\(\\\\s +\\)?" c++-class-key "[ ]+\\(\\(\\w\\|_\\)+[ ]*:[ ]*\\)?") "\ Regexp which describes a class inheritance declaration.") (fset 'c++-mode #[nil " \n! ! \n!PL! L!L!L!L!L!L!L!L!L!L!<\"!\"\")!!(>(>\"" [kill-all-local-variables use-local-map c++-mode-map set-syntax-table c++-mode-syntax-table c++-mode major-mode "C++" mode-name c++-mode-abbrev-table local-abbrev-table make-local-variable paragraph-start "^$\\|" page-delimiter paragraph-separate paragraph-ignore-fill-prefix t require-final-newline parse-sexp-ignore-comments nil indent-line-function c++-indent-line comment-start "// " comment-end "" comment-column 32 comment-start-skip "/\\*+ *\\|// *" comment-indent-hook c++-comment-indent mode-line-format modeline mapcar #[(element) " \n=Ī\nC\"" [append modeline element mode-name (mode-name (c++-hungry-delete-key (c++-auto-newline "/ah" "/h") (c++-auto-newline "/a")))] 4] run-hooks c++-mode-hook c++-set-auto-hungry-state c++-auto-hungry-initial-state (auto-only auto-hungry t) (hungry-only auto-hungry t)] 4 "\ Major mode for editing C++ code. 2.353 To submit a problem report, enter `\\[c++-submit-bug-report]' from a c++-mode buffer. This automatically sets up a mail buffer with version information already added. You just need to add a description of the problem and send the message. 1. Very much like editing C code, 2. Expression and list commands understand all C++ brackets, 3. Tab at left margin indents for C++ code, 4. Both C++ and C style block comments are recognized, 5. Paragraphs are separated by blank lines only, 6. Hungry delete key and auto newline features are optional. IMPORTANT NOTE: You may notice that some characters (by default, only single quote) will get escaped with a backslash when typed in a comment region. This is a necessary workaround of a bug present in GNU Emacs 18 and derivatives. Enter `\\[describe-variable] c++-untame-characters RET' for more information. If you are running a patched Emacs, no characters will be escaped in comment regions, and many functions will run much faster. Key bindings: \\{c++-mode-map} These variables control indentation style. Those with names like c- are inherited from c-mode. Those with names like c++- are unique for this mode, or have extended functionality from their c-mode cousins. c-argdecl-indent Indentation level of declarations of C function arguments. c-brace-imaginary-offset An open brace following other text is treated as if it were this far to the right of the start of its line. c-brace-offset Extra indentation for line if it starts with an open brace. c-continued-brace-offset Extra indentation given to a brace that starts a substatement. This is in addition to `c-continued-statement-offset'. c-continued-statement-offset Extra indentation given to a substatement, such as the then-clause of an if or body of a while. c-indent-level Indentation of C statements within surrounding block. The surrounding block's indentation is the indentation of the line on which the open-brace appears. c-label-offset Extra indentation for line that is a label, or case or ``default:'' c++-C-block-comments-indent-p Style of C block comments to support. c++-access-specifier-offset Extra indentation given to public, protected, and private keyword lines. c++-always-arglist-indent-p Control indentation of continued arglists. When non-nil, arglists continued on subsequent lines will always indent `c++-empty-arglist-indent' spaces, otherwise, they will indent to just under previous line's argument indentation. c++-auto-hungry-initial-state Initial state of auto/hungry feature when a C++ buffer is first visited. c++-auto-hungry-toggle Enable/disable toggling of auto/hungry features. c++-backscan-limit Limit in characters for looking back while skipping syntactic whitespace. This variable is only used in an un-patched Emacs to help improve performance at the expense of some accuracy. Patched Emacses are both fast and accurate. c++-block-close-brace-offset Extra indentation give to braces which close a block. c++-cleanup-list A list of construct ``clean ups'' which c++-mode will perform when auto-newline feature is on. Current legal values are: `brace-else-brace', `empty-defun-braces', `defun-close-semi'. c++-comment-only-line-offset Extra indentation for a line containing only a C or C++ style comment. Can be an integer or list, specifying the various styles of comment-only line special indentations. c++-continued-member-init-offset Extra indentation for continuation lines of member initializations; nil means to align with previous initializations rather than with the colon. c++-default-macroize-column Column to insert backslashes when macroizing a region. c++-delete-function Function called by `c++-electric-delete' when deleting a single char. c++-electric-pound-behavior List of behaviors for electric pound insertion. c++-empty-arglist-indent Extra indentation to apply to a line following an empty argument list. nil means to line it up with the left paren. c++-friend-offset Offset of C++ friend class declarations relative to member declarations. c++-hanging-braces Controls open brace hanging behavior when using auto-newline feature. nil says no braces hang, t says all open braces hang. non-nil-or-t means top-level open braces don't hang, all others do. c++-hanging-member-init-colon Defines how colons which introduce member initialization lists are formatted. t means no newlines are inserted either before or after the colon. nil means newlines are inserted both before and after the colon. `before' inserts newlines only before the colon, and `after' inserts newlines only after colon. c++-member-init-indent Indentation level of member initializations in function declarations, if they are on a separate line beginning with a colon. c++-paren-as-block-close-p If non-nil, treat a parenthesis which is the first non-whitespace on a line as a paren which closes a block (i.e. treat it similar to right curly brace). c++-relative-offset-p Control the calculation for indentation. When non-nil (the default), indentation is calculated relative to the first statement in the block. When nil, the indentation is calculated without regard to how the first statement is indented. Useful when using a `c++-special-indent-hook'. c++-special-indent-hook Hook for user defined special indentation adjustments. You can use this hook, which gets called after a line is indented by the mode, to customize indentations of the line. c++-tab-always-indent Controls the operation of the TAB key. t means always just indent the current line. nil means indent the current line only if point is at the left margin or in the line's indentation; otherwise insert a tab. If not-nil-or-t, then tab is inserted only within literals (comments and strings) and inside preprocessor directives, but the line is always reindented. Default is value for `c-tab-always-indent'. c++-untame-characters When non-nil, inserts backslash escapes before certain untamed characters in comment regions. It is recommended that you keep the default setting to workaround a nasty Emacs bug, unless you are running a patched Emacs. Auto-newlining is no longer an all or nothing proposition. In my opinion, I don't believe it is possible to implement a perfect auto-newline algorithm. Sometimes you want it and sometimes you don't. So now auto-newline (and its companion feature, hungry-delete-key) can be toggled on and off on the fly. Hungry-delete-key is the optional behavior of the delete key so that, when enabled, hitting the delete key once consumes all preceding whitespace, unless point is within a literal (defined as a C or C++ comment, or string). Inside literals, and with hungry-delete-key disabled, the delete key just calls the function in variable `c++-delete-function'. Selection and toggling of these features is controlled by the variables `c++-auto-hungry-initial-state' and `c++-auto-hungry-toggle'. Legal values for both variables are: `none' (or nil) -- no auto-newline or hungry-delete-key. `auto-only' -- function affects only auto-newline feature. `hungry-only' -- function affects only hungry-delete-key feature. `auto-hungry' (or t) -- function affects both features. Thus if `c++-auto-hungry-initial-state' is `hungry-only', then only hungry-delete-key feature is turned on when the buffer is first visited. If `c++-auto-hungry-toggle' is `auto-hungry', and both auto-newline and hungry-delete-key features are on, then hitting `\\[c++-toggle-auto-hungry-state]' will toggle both features. Hitting `\\[c++-toggle-hungry-state]' will always toggle hungry-delete-key feature and hitting `\\[c++-toggle-auto-state]' will always toggle auto-newline feature, regardless of the value of `c++-auto-hungry-toggle'. Settings for K&R, BSD, and Stroustrup indentation styles are c-indent-level 5 8 4 c-continued-statement-offset 5 8 4 c-continued-brace-offset 0 c-brace-offset -5 -8 0 c-brace-imaginary-offset 0 c-argdecl-indent 0 8 4 c-label-offset -5 -8 -4 c++-access-specifier-offset -5 -8 -4 c++-empty-arglist-indent 4 c++-friend-offset 0 Turning on C++ mode calls the value of the variable `c++-mode-hook' with no args, if that value is non-nil." nil]) (fset 'c++-c-mode #[nil "  \n !!" [c++-mode c++-c-mode major-mode "C" mode-name c-mode-abbrev-table local-abbrev-table "/* " comment-start " */" comment-end set-syntax-table c++-c-mode-syntax-table run-hooks c++-c-mode-hook] 2 "\ Major mode for editing K&R and ANSI C code. 2.353 This mode is based on c++-mode. Documentation for this mode is available by doing a `\\[describe-function] c++-mode'." nil]) (fset 'c++-comment-indent #[nil "!‡xiUªiTyoyw!iWi)`y\n#”bi)]])" [looking-at "^\\(/\\*\\|//\\)" 0 " " nil -1 "/\\*\\|//" comment-column cur-pt re-search-forward comment-start-skip t] 6 "\ Used by `indent-for-comment' to decide how much to indent a comment in C++ code based on its context."]) (fset 'c++-set-auto-hungry-state #[(auto-p hungry-p) "\n !" [auto-p c++-auto-newline hungry-p c++-hungry-delete-key set-buffer-modified-p buffer-modified-p] 2 "\ Set auto/hungry to state indicated by AUTO-P and HUNGRY-P. Update mode line to indicate state to user."]) (fset 'c++-toggle-auto-state #[(arg) " ?!U ?WĪ\")" [arg c++-auto-newline prefix-numeric-value 0 nil t auto c++-set-auto-hungry-state c++-hungry-delete-key] 3 "\ Toggle auto-newline feature. This function ignores `c++-auto-hungry-toggle' variable. Optional numeric ARG, if supplied turns on auto-newline when positive, turns off auto-newline when negative and toggles when zero." "P"]) (fset 'c++-toggle-hungry-state #[(arg) " ?!U ?WĪ\")" [arg c++-hungry-delete-key prefix-numeric-value 0 nil t hungry c++-set-auto-hungry-state c++-auto-newline] 3 "\ Toggle hungry-delete-key feature. This function ignores `c++-auto-hungry-toggle' variable. Optional numeric ARG, if supplied turns on hungry-delete-key when positive, turns off hungry-delete-key when negative and toggles when zero." "P"]) (fset 'c++-toggle-auto-hungry-state #[(arg) " !EE  >\n?\n < >\nU\n? Wͪ  >? < >\nU? Wͪ\"-" [prefix-numeric-value arg numarg auto-only auto-hungry t apl hungry-only hpl c++-auto-hungry-toggle c++-auto-newline c++-auto-hungry-initial-state 0 nil auto c++-hungry-delete-key hungry c++-set-auto-hungry-state] 3 "\ Toggle auto-newline and hungry-delete-key features. Actual toggling of these features is controlled by `c++-auto-hungry-toggle' variable. Optional argument has the following meanings when supplied: Universal argument \\[universal-argument] resets features to c++-auto-hungry-initial-state. negative number turn off both auto-newline and hungry-delete-key features. positive number turn on both auto-newline and hungry-delete-key features. zero toggle both features regardless of `c++-auto-hungry-toggle-p'." "P"]) (fset 'c++-tame-insert #[(arg) " > >c!" [last-command-char c++-untame-characters c++-in-literal (c c++) "\\" self-insert-command arg] 2 "\ Safely inserts certain troublesome characters in comment regions. Because of syntax bugs in Emacs, characters with string or parenthesis syntax must be escaped with a backslash or lots of things get messed up. Unfortunately, setting `parse-sexp-ignore-comments' to non-nil does not fix the problem, but this function is unnecessary if you are running a patched Emacs. See also the variable `c++-untame-characters'." "p"]) (fset 'c++-electric-delete #[(arg) " \n !!! !>xhU))` x` U` |\n!)\n!" [c++-hungry-delete-key arg c++-delete-function prefix-numeric-value c++-point bod c++-in-literal (c c++ string) " " nil 35 here " \n" 1] 3 "\ If `c++-hungry-delete-key' is non-nil, consumes all preceding whitespace unless ARG is supplied, or point is inside a C or C++ style comment or string. If ARG is supplied, this just calls `backward-delete-char-untabify' passing along ARG. If `c++-hungry-delete-key' is nil, just call `backward-delete-char-untabify'." "P"]) (fset 'c++-electric-pound #[(arg) " > ! on >y   \"c  \"! bω+" [c++-in-literal (c c++ string) self-insert-command arg point-marker bolp bobp here alignleft c++-electric-pound-behavior 0 delete-horizontal-space make-string last-command-char insert-before-markers nil] 4 "\ Electric pound command." "p"]) (fset 'c++-electric-brace #[(arg) " ! 2wl)2xn) U  \n=\n \" y )* > !>c Un c > \" UuxhU >`S|b) > U#)U !>|!bb+ `Zb bZ* Tb!) b !!) !!+" [nil last-command-char c++-point bod insertpos arg " " c++-auto-newline 123 open-brace-p c++-hanging-braces t c++-at-top-level-p c++-indent-line -1 c++-untame-characters c++-in-literal (c c++) "\\" point-marker here empty-defun-braces c++-cleanup-list 125 " \n" (c c++ string) mend mbeg brace-else-brace re-search-backward "}[ \n]*else[ \n]*{" status 0 (c c++ string) insert-before-markers "} else {" 2 delete-char self-insert-command prefix-numeric-value] 4 "\ Insert character and correct line's indentation." "P"]) (fset 'c++-electric-slash #[(arg) "` !!\nSf U\nb )*" [nil char here self-insert-command prefix-numeric-value arg 47 c++-indent-line] 3 "\ Insert slash, and if slash is second of a double-slash comment introducing construct, indent line as comment. This only indents if we're on a comment-only line, otherwise use `indent-for-comment' (\\[indent-for-comment])." "P"]) (fset 'c++-electric-star #[(arg) "` !!\nSf > >xhUuxn)\nb )*" [nil char here self-insert-command prefix-numeric-value arg c++-in-literal (c) (47 42 9 32 10) "* " 47 -1 " " c++-indent-line] 3 "\ Works with `c++-electric-slash' to auto indent C style comment lines." "P"]) (fset 'c++-electric-semi #[(arg) " !! >xhU `| b ʉ) !" [c++-in-literal self-insert-command prefix-numeric-value arg point-marker here defun-close-semi c++-cleanup-list c++-auto-newline " \n" nil 125 c++-electric-terminator] 3 "\ Insert character and correct line's indentation." "P"]) (fset 'c++-electric-colon #[(arg) " !! `!xhU!>`|`bΏx!hUb\"!hUb> xn) `) >)b !+" [c++-in-literal self-insert-command prefix-numeric-value arg c++-auto-newline c++-point bod insertion-point " \n" nil 58 (c c++ string) premature-end (backward-sexp 1) ((error)) "-" c++-backward-syntactic-ws 63 c++-at-top-level-p t 41 c++-hanging-member-init-colon (nil before) " " (nil after) c++-electric-terminator] 4 "\ Electrify colon. De-auto-newline double colons. No auto-new-lines for member initialization list." "P"]) (fset 'c++-electric-terminator #[(arg) "` wl)ywgU=!vw` W)!) ` \"888*)c  `S \n\nTb!)\n\nb !!) !!*" [nil end insertpos arg " " 0 35 last-command-char 58 looking-at "case[ ]" 1 ":" c++-beginning-of-defun t parse-sexp-ignore-comments parse-partial-sexp pps 3 4 5 c++-indent-line c++-auto-newline c++-in-parens-p make-marker newline delete-char -1 self-insert-command prefix-numeric-value] 4 "\ Insert character and correct line's indentation." "P"]) (fset 'c++-indent-command #[(&optional whole-exp) "!\n !ĉ=y`!`by`) V $+xn)!`!Un ! = ! !>xhU)` `) ! V`U) + !)" [c++-point bod whole-exp c++-indent-line nil end beg shift-amt c++-tab-always-indent t 0 forward-sexp 1 indent-code-rigidly "#" " " looking-at "[ ]*$" boi insert-tab c++-in-literal (c c++ string) 35 back-to-indentation indent-p here] 5 "\ Indent current line as C++ code, or in some cases insert a tab character. If `c++-tab-always-indent' is t, always just indent the current line. If nil, indent the current line only if point is at the left margin or in the line's indentation; otherwise insert a tab. If not-nil-or-t, then tab is inserted only within literals (comments and strings) and inside preprocessor directives, but line is always reindented. A numeric argument, regardless of its value, means indent rigidly all the lines of the expression starting after point so that this line becomes properly indented. The relative indentation among the lines of the expression are preserved." "P"]) (fset 'c++-indent-exp #[nil "C`C` \n   !)m??   m  ` =y ox`mu` % b+ @ AA@ AA@Y AA@  8  8y  X9 8VAASg U  WBBTh@ A@!`)yw >d#`)%`%W yr)l9@@Y@\n@@[!''\n))!\n*\\\n!!!!)\n.\\]\n/!wi0Yin\n@!h>)ª4\\\"\n!\n6\\\ngU\n8Z\ngU\n:@\"ª8\\\\\n@! ?h>?yw>!?)\n4!@@@!@`WhAUy kyy!w`)`Z*\\\\\nB! \ni\nUgCU`y`|\nj/!9/DE!#9F y9." [nil t 0 next-depth opoint parse-sexp-ignore-comments at-brace at-else last-depth last-sexp this-indent ostate state inner-loop-done outer-loop-done restart case-fold-search contain-stack indent-stack forward-sexp 1 c++-in-literal c c++-indent-line " " end line-end start parse-partial-sexp 4 3 6 -1 (c) re-search-forward "\\*/" move eoc c++-calculate-indent val looking-at c++-access-key c++-access-specifier-offset "\\(case[ ]+.*\\|default[ ]*\\):" "[A-Za-z]" ":[^:]" c-label-offset comment-start-skip comment-column c++-comment-offset c++-backward-syntactic-ws (nil 44 59 125 58 123) c-continued-statement-offset "friend[ ]" c++-friend-offset 125 c-indent-level 123 c-brace-offset c++-at-top-level-p c++-in-parens-p (nil 0 59 125 58 123) c++-class-key "[ ]*:" lim 44 "\\(<<\\|>>\\)" 35 c++-point eol indent-for-comment] 17 "\ Indent each line of the C++ grouping following point." nil]) (fset 'c++-insert-header #[nil "ebñ)" ["// " "This may look like C code, but it is really " "-*- C++ -*-" "\n\n"] 4 "\ Insert header denoting C++ code at top of buffer." nil]) (fset 'c++-tame-comments #[nil " #P m? wgU >hUcmbu]*" ["^" mapconcat #[(char) ">!P!" [char (92 94 45) "\\" char-to-string] 3] c++-untame-characters "" charset beginning-of-buffer nil 0 c++-in-literal (c c++) 92 "\\" 1] 5 "\ Backslashifies all untamed in comment regions found in the buffer. This is a workaround for Emacs syntax bugs. This function is unnecessary (and un-used automatically) if you are running a patched Emacs. Untamed characters to escape are defined in the variable `c++-untame-characters'." nil]) (fset 'c++-match-paren #[nil " >!! !u!!)" [v19 c++-emacs-features parse-sexp-ignore-comments looking-at "[([{]" forward-sexp 1 backward-char "[])}]" nil backward-sexp message "Could not find matching paren."] 2 "\ Jumps to the paren matching the one under point, if there is one." nil]) (fset 'c++-forward-sexp #[(&optional arg) " > !)" [v19 c++-emacs-features parse-sexp-ignore-comments forward-sexp arg] 2 "\ Safe forward-sexp call." "_p"]) (fset 'c++-backward-sexp #[(&optional arg) " > !)" [v19 c++-emacs-features parse-sexp-ignore-comments backward-sexp arg] 2 "\ Safe backward-sexp call." "_p"]) (fset 'c++-backward-syntactic-ws-v18 #[(&optional lim) "!É`ZV`Z ?x!=xxgU`TfUZ`XUxxe =xxgUhU`Xxxgo\"u =y`XhU`ZfUxxgUhU`XxxgouՉ+" [lim c++-point bod nil stop literal c++-backscan-limit " \n " c++-in-literal c++ "^/" "/" 47 c "^*" "*" 42 -1 pound 0 2 t] 4 "\ Skip backwards over syntactic whitespace. Syntactic whitespace is defined as lexical whitespace, C and C++ style comments, and preprocessor directives. Search no farther back than optional LIM. If LIM is omitted, `beginning-of-defun' is used."]) (fset 'c++-fast-backward-syntactic-ws-1 #[(&optional lim) "\n!\n`WɎ\n`}\n=###? !u!f Ub`\nXVP)." [t nil lim c++-point bod char boi donep parse-sexp-ignore-comments ((byte-code "= ###" [major-mode c++-mode modify-syntax-entry 35 "." c++-mode-syntax-table 10 " " c++-c-mode-syntax-table] 4)) major-mode c++-mode modify-syntax-entry 35 "< b" c++-mode-syntax-table 10 "> b" c++-c-mode-syntax-table backward-syntactic-ws looking-at "#\\|/\\*\\|//\\|\n" 1] 7 "\ Skip backwards over syntactic whitespace. Syntactic whitespace is defined as lexical whitespace, C and C++ style comments, and preprocessor directives. Search no farther back than optional LIM. If LIM is omitted, `beginning-of-defun' is used."]) (fset 'c++-fast-backward-syntactic-ws-2 #[(&optional lim) "!`WĎ`} =\n# # # `U?`!r)+" [lim c++-point bod here ((byte-code "= ###" [major-mode c++-mode modify-syntax-entry 35 "." c++-mode-syntax-table 10 " " c++-c-mode-syntax-table] 4)) major-mode c++-mode modify-syntax-entry 35 "< b" c++-mode-syntax-table 10 "> b" c++-c-mode-syntax-table forward-comment -1] 5 "\ Skip backwards over syntactic whitespace. Syntactic whitespace is defined as lexical whitespace, C and C++ style comments, and preprocessor directives. Search no farther back than optional LIM. If LIM is omitted, `beginning-of-defun' is used."]) (fset 'c++-in-literal-v18 #[(&optional lim) "` !b`W#˔˕{ ̘`Xͪ Θ#?Ъ ј`}#)?Ӫ Ԙ`}#)?Ӫ \"`Xت\n-" [here nil state match lim c++-point bod backlim re-search-forward "\\(/[/*]\\)\\|[\"']\\|\\(^[ ]*#\\)" move 0 "//" c++ "/*" "*/" c "\"" "\\([^\\]\\|^\\)\\(\\\\\\\\\\)*\"" string "'" "\\([^\\]\\|^\\)\\(\\\\\\\\\\)?'" string-match "[ ]*#" pound] 5 "\ Determine if point is in a C++ ``literal''. Return `c' if in a C-style comment, `c++' if in a C++ style comment, `string' if in a string literal, `pound' if on a preprocessor line, or nil if not in a comment at all. Optional LIM is used as the backward limit of the search. If omitted, or nil, `c++-beginning-of-defun' is used."]) (fset 'c++-in-literal-8-bit #[(&optional lim) "!` `\"8ʪ88ͪΪ by!Ҫ-" [lim c++-point bod backlim here t parse-sexp-ignore-comments parse-partial-sexp state 3 string 4 7 c++ c 0 looking-at "[ ]*#" pound nil] 3 "\ Determine if point is in a C++ ``literal''. Return `c' if in a C-style comment, `c++' if in a C++ style comment, `string' if in a string literal, `pound' if on a preprocessor line, or nil if not in a comment at all. Optional LIM is used as the backward limit of the search. If omitted, or nil, `c++-beginning-of-defun' is used."]) (fset 'c++-in-literal-1-bit #[(&optional lim) "!` `\"8ʪ88ͪΪ by!Ҫ-" [lim c++-point bod backlim here t parse-sexp-ignore-comments parse-partial-sexp state 3 string 4 7 c c++ 0 looking-at "[ ]*#" pound nil] 3 "\ Determine if point is in a C++ ``literal''. Return `c' if in a C-style comment, `c++' if in a C++ style comment, `string' if in a string literal, `pound' if on a preprocessor line, or nil if not in a comment at all. Optional LIM is used as the backward limit of the search. If omitted, or nil, `c++-beginning-of-defun' is used."]) (byte-code " >M >MM >M >MM" [old-v19 c++-emacs-features c++-backward-syntactic-ws c++-fast-backward-syntactic-ws-1 v19 c++-fast-backward-syntactic-ws-2 c++-backward-syntactic-ws-v18 8-bit c++-in-literal c++-in-literal-8-bit 1-bit c++-in-literal-1-bit c++-in-literal-v18] 2) (fset 'c++-parse-state #[(&optional limit) "d`W`#s +" [limit t nil state parse-sexp-ignore-comments parse-partial-sexp 0] 4 "\ Determinate the syntactic state of the code at point. Iteratively uses `parse-partial-sexp' from point to LIMIT and returns the result of `parse-partial-sexp' at point. LIMIT is optional and defaults to `point-max'."]) (fset 'c++-at-top-level-p #[(wrt &optional bod) "` ! b!A@@\n= ?̪ ? ̪ bPe#! ! !!xh>)Vg>? ! A@?8 ." [nil bod c++-point foundp paren-depth containing-sexp state case-fold-search indent-point c++-parse-state major-mode c++-c-mode 0 wrt c++-in-parens-p re-search-backward "[;}]\\|" c++-class-key t c++-in-literal looking-at " \n" (44 60) (125 59) 2] 8 "\ Return t if point is not inside a containing C++ expression, nil if it is embedded in an expression. When WRT is non-nil, returns nil if not at the top level with respect to an enclosing class, or the depth of class nesting at point. With WRT nil, returns nil if not at the ``real'' top level. Optional BOD is the beginning of defun."]) (fset 'c++-in-parens-p #[(&optional lim) "!ŏ)" [lim c++-point bod var (byte-code "`}db`#efU*" [lim scan-lists -1 1 40] 4) ((error))] 3 "\ Return t if inside a paren expression. Optional LIM is used as the backward limit of the search."]) (fset 'c++-in-function-p #[(&optional containing) "`b `hUv! \nbhU*" [containing c++-backward-syntactic-ws here 116 -1 looking-at "\\" 41] 2 "\ Return t if inside a C++ function definition. Optional CONTAINING is position of containing s-exp open brace. If not supplied, point is used as search start."]) (fset 'c++-indent-line #[(&optional bod) "!\" d`Z\n < @ A  y` = 2 = 2!2 !)wiYi2n \"2w < @! \\2! \\2!!!!) \\]!! wi)! %\\gU' (Zu\")\\gU (Zu\")\\gU ,\\w iZUd\nZ`Vd\nZb `| jd\nZ`Vd\nZb!)." [bod c++-point c++-calculate-indent nil indent beg shift-amt close-paren top-close-paren case-fold-search pos c++-block-close-brace-offset 0 current-indentation t c++-calculate-c-indent-within-comment looking-at "[ ]*#" back-to-indentation "//\\|/\\*" " " comment-column c++-comment-offset c++-access-key c++-access-specifier-offset "default[ ]*:" c-label-offset "case[ ]+.*:" "[A-Za-z]" forward-sexp 1 ":[^:]" "else\\b" "else\\s_" c++-backward-to-start-of-if "{ " "\\" c++-friend-offset 41 c++-paren-as-block-close-p c-indent-level c++-at-top-level-p 125 123 c-brace-offset run-hooks c++-special-indent-hook] 5 "\ Indent current line as C++ code. Return the amount the indentation changed by. Optional BOD is the point of the beginning of the C++ definition."]) (fset 'c++-cont-indent #[(ipnt char lim) " b! >?!` b!\nbwi!) iy!h >)!yu!!!Ί bwgUgUu\"[)\\\\+" [(nil 0 44 59 125 58 123) nil here streamop-pos charlist ipnt c++-backward-syntactic-ws lim char c-backward-to-start-of-continued-exp looking-at "[ ]*\\(<<\\|>>\\)" "^><\n" "\\(<<\\|>>\\)" 0 c-continued-statement-offset "\\(do\\|else\\|for\\|if\\|while\\)\\b" -1 " " 123 c-continued-brace-offset 125 1 c++-at-top-level-p] 5 "\ Calculate the indentation for a continued statement. IPNT is the indentation point; CHAR is the character before the indentation point, excluding any intervening whitespace; LIM is the minimum point to search backwards to."]) (fset 'c++-calculate-indent #[(&optional parse-start bod) "y`\n! \n   b\nb`! A@  !b! A@ `*\n! b\n!h) >C >҂C\n\"\\ _ S]_)bwgU!o bwgU !hU!xhUˊywmuhUgU?)hU!&&xhU) ?uxn?y+!?)yw,! \nbyw!y Z !0\\hUhUy!) \nb Z\n`Wh>y\n!m5=hU)!b\n!hU7\\yw\n!>!gU\n!hU)0 0\\uwiZ5=+!UbigU Zlbyo)b\n!hU\n`WhUy\n!my!\n)?)7 \n`WywngU\n!hU)uw\n`;\n!hU\n`Wyw`;\n!f;b)iZ\\C fU<= 8 Tb!) byw`<\\ T^biC TbwiC@ #CbAwB!C !D!i ) CbAwE!) bF i\\C bGuAwHIJKLM!gNUyWO!PQR#BSLMQ!y0E!y$TUR#`WiV \n#\\)nUW7\\xnh=X! \\\\." [0 nil bod c++-point inclass-unshift inclass-depth inclass-shift char-before-ip streamop-pos containing-sexp in-meminit-p literal do-indentation state case-fold-search indent-point parse-start c++-parse-state t c++-match-header-strongly c++-in-literal c++-backward-syntactic-ws (string) (c c++) c++-at-top-level-p c-indent-level c-brace-imaginary-offset shift/level " " 123 c++-in-function-p 58 c++-member-init-indent c-argdecl-indent 59 backward-char 1 44 bol "^:" c++-in-parens-p -1 looking-at c++-inher-key c++-access-key ":[ ]*\\<\\(public\\|protected\\|private\\)\\>" current-indentation ":[ ]*$" c++-continued-member-init-offset 125 41 "[ ]*\\" (44 59) major-mode c++-c-mode c-continued-statement-offset (c c++) "/[/*]" "[ ]*:" ipnt c++-empty-arglist-indent c++-always-arglist-indent-p 2 "[ ]*[/\n]" c++-cont-indent " \n" "while\\b" c++-backward-to-start-of-do "do\\b" "\\(case[ ]+.*\\|default[ ]*\\):" back-to-indentation c++-relative-offset-p "#\\|/\\*\\|//" "\\|\\(case[ ]+.*\\|default[ ]*\\):" "\\|[a-zA-Z0-9_$]*:[^:]" "\\|friend[ ]" c++-class-key "[ ]" 35 "/\\*" search-forward "*/" move "//\\|friend[ ]" re-search-forward ":[^:]" c++-compound-offset c-brace-offset forward-sexp] 15 "\ Return appropriate indentation for current line as C++ code. In usual case returns an integer: the column to indent to. Returns nil if line starts inside a string, t if in a comment. Optional PARSE-START is the location to start parsing, and optional BOD is the beginning of the C++ definition."]) (fset 'c++-calculate-c-indent-within-comment #[nil "yw!ĕĔZx`yw #Ĕ Ī\nUͪ\nUĪĕĔZ\\bi," [nil indent stars end 0 " " looking-at "\\*\\*?" " \n" re-search-forward "/\\*[ ]*" t c++-C-block-comments-indent-p 1 2] 4 "\ Return the indentation amount for line, assuming that the current line is to be regarded as part of a block comment."]) (fset 'c++-comment-offset #[(col0-line-p indent) "\n < A@ @\\ < @ \\ )" [0 offset col0-line-p c++-comment-only-line-offset indent] 2 "\ Calculates and returns the comment-only line offset. Offset is based on the value of `c++-comment-only-line-offset', the argument COL0-LINE-P, and the current indentation INDENT."]) (fset 'c++-compound-offset #[(char-before-ip containing-sexp bod) "U‡ U by`!hU)y!‡  b `W h> bn!!e b ] *‡" [char-before-ip 44 0 containing-sexp bod -1 lim nil c++-backward-syntactic-ws 61 looking-at "\\(^\\|[ ]*\\)enum[ ]" t in-enum-p parse-sexp-ignore-comments (41 34 59 125) forward-sexp "\\(enum[ \n]\\|\\[.*\\]\\)" c-continued-statement-offset] 2 "\ Calculates any addition offset due a comma separated compound statement. CHAR-BEFORE-IP is the character before the indentation point and CONTAINING-SEXP is the buffer position of the open brace or paren. BOD is the `beginning-of-defun' point."]) (fset 'c++-backward-to-start-of-do #[(&optional limit) "\n!U?ʏr+" [1 nil limit c++-point bod case-fold-search do-level 0 err (byte-code "! !>!T!S` W b" [backward-sexp 1 c++-in-literal limit (c c++) looking-at "while\\b" do-level "do\\b" 0] 2) ((error (byte-code "b" [limit 0 do-level] 1)))] 4 "\ Move to the start of the last ``unbalanced'' do."]) (fset 'c++-backward-to-start-of-if #[(&optional limit) "\n!o?U? !!Tb!SV`\nWQ\nbI+" [1 nil limit c++-point bod case-fold-search if-level 0 c++-backward-syntactic-ws c++-backward-sexp looking-at "else\\b" "if\\b"] 4 "\ Move to the start of the last ``unbalanced'' if."]) (fset 'c++-auto-newline #[nil "!\n !? ?)" [c++-point bod c++-auto-newline c++-in-literal newline] 2 "\ Insert a newline iff we're not in a literal. Literals are defined as being inside a C or C++ style comment or open string according to mode's syntax."]) (fset 'c++-point #[(position) "` =y = = = `\nb *" [nil bufpos here position bol 0 eol bod c++-beginning-of-defun boi back-to-indentation] 2 "\ Returns the value of point at certain commonly referenced POSITIONs. POSITION can be one of the following symbols: `bol' -- beginning of line `eol' -- end of line `bod' -- beginning of defun `boi' -- back to indentation This function does not modify point or mark."]) (fset 'c++-macroize-region #[(from to arg) "bye`\" be`\") W?!y Tm+" [from 0 count-lines to to-line line c++-backslashify-current-line arg 1] 5 "\ Insert backslashes at end of every line in region. Useful for defining cpp macros. If called with a prefix argument, it will remove trailing backslashes." "r\nP"]) (fset 'c++-backslashify-current-line #[(doit) " u!)?i Yci Xcs!i Wcscu!x " [1 doit -1 looking-at "\\\\" c++-default-macroize-column " \\" " " nil delete-char " " "\\" " " kill-line] 2 "\ Backslashifies current line."]) (fset 'c++-comment-region #[(beg end) "by`\nbny`}ebm cyu =c*" [beg 0 end 1 comment-start major-mode c++-c-mode comment-end] 2 "\ Comment out all lines in a region between mark and current point by inserting `comment-start' in front of each line." "*r"]) (fset 'c++-uncomment-region #[(beg end) "by`\nby`}eb =!\n!˰!P m? !|yk+" [beg 0 end 1 major-mode c++-c-mode "\\s *\\(" regexp-quote comment-start "\\|" comment-end "\\)" "\\s *" comment-regexp looking-at] 5 "\ Uncomment all lines in region between mark and current point by deleting the leading ``// '' from each line, if any." "*r"]) (defvar c++-match-header-strongly nil "\ *If nil, use `c++-defun-header-weak' to identify beginning of definitions, if non-nil, use `c++-defun-header-strong'.") (defvar c++-defun-header-strong-struct-equivs "\\(class\\|struct\\|union\\|enum\\)" "\ Regexp to match names of structure declaration blocks in C++") (defconst c++-defun-header-strong (byte-code " Ȱ   QQPP  ȉ\n Ȱ   \"# %%%%Ȱ)++R-)\". Ȱ0# 02.2Ȱ." ["\\(\\w\\|_\\)+" id "[---+*/%^&|~!=<>]\\|[---+*/%^&|<>=!]=\\|<<=?\\|>>=?" op-sym1 "&&\\|||\\|\\+\\+\\|--\\|()\\|\\[\\]" op-sym2 "\\(" "\\|" "\\)" op-sym "[^\\*]*\\(\\*+[^/\\*][^\\*]*\\)*" middle "/\\*" "\\*+/" c-comment "\\(\\s \\|\n\\|//.*$\\|" wh "*" wh-opt "+" wh-nec "operator" oper "([^():]*)" dcl-list "::" func-name "\\(:" "(.*\\()" "," "\\)\\)*" "(.*)" "{" "{\\)" inits c++-defun-header-strong-struct-equivs "\\)?" type-name "\\(const" "\\*+" "&" type "\\(inline\\|virtual\\|overload\\|auto\\|static\\)" modifier "\\)*" modifiers func-header "\\(public\\|protected\\|private\\)?" inherit "?" cs-header "^\\("] 17) "\ Strongly-defined regexp to match beginning of structure or function definition.") (defconst c++-defun-header-weak "^{\\|^[_a-zA-Z].*{" "\ Weakly-defined regexp to match beginning of structure or function definition.") (fset 'c++-beginning-of-defun #[(&optional arg) "\n UVoǪ !`#` #Ɣ   WV bUЪb+ !oWu $Ɣb)" [arg 1 c++-match-header-strongly c++-defun-header-strong c++-defun-header-weak c++-defun-header 0 nil looking-at search-forward "{" move re-search-backward beg-pos open-pos curr-pos t -1] 6 "\ Find the beginning of the C++ function or class." "_p"]) (fset 'c++-end-of-defun #[(arg) " \nmV?V !u`\nWmǪZ[!Wo #u y\n`U #!)*" [c++-match-header-strongly c++-defun-header-strong c++-defun-header-weak t parse-sexp-ignore-comments c++-defun-header arg 0 looking-at 1 pos c++-beginning-of-defun re-search-forward nil move -1 forward-sexp c++-end-of-defun] 4 "\ Find the end of the C++ function or class." "_p"]) (fset 'c++-indent-defun #[nil "`!y  ` W yyp ȉ)b)" [restore c++-end-of-defun 1 0 point-marker end c++-beginning-of-defun c++-indent-line nil] 3 "\ Indents the current function def, struct or class declaration." nil]) (defconst c++-version "2.353" "\ c++-mode version number.") (defconst c++-mode-help-address "c++-mode-help@anthem.nlm.nih.gov" "\ Address accepting submission of bug reports.") (fset 'c++-version #[nil "\n\"" [message "Using c++-mode.el %s" c++-version] 3 "\ Echo the current version of c++-mode." nil]) (fset 'c++-submit-bug-report #[nil "!!  =˪Ͱ#$" [require reporter y-or-n-p "Do you want to submit a report on c++-mode? " reporter-submit-bug-report c++-mode-help-address "c++-mode.el " c++-version " (editing " major-mode c++-mode "C++" "C" " code)" c++-emacs-features c++-C-block-comments-indent-p c++-access-specifier-offset c++-always-arglist-indent-p c++-auto-hungry-initial-state c++-auto-hungry-toggle c++-auto-newline c++-backscan-limit c++-block-close-brace-offset c++-cleanup-list c++-comment-only-line-offset c++-continued-member-init-offset c++-default-macroize-column c++-defun-header-strong-struct-equivs c++-delete-function c++-electric-pound-behavior c++-empty-arglist-indent c++-friend-offset c++-hanging-braces c++-hanging-member-init-colon c++-hungry-delete-key c++-match-header-strongly c++-member-init-indent c++-paren-as-block-close-p c++-relative-offset-p c++-tab-always-indent c++-untame-characters c-argdecl-indent c-brace-imaginary-offset c-brace-offset c-continued-brace-offset c-continued-statement-offset c-indent-level c-label-offset tab-width #[nil "\"ưc" [c++-special-indent-hook "\n@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n" "c++-special-indent-hook is set to '" format "%s" ".\nPerhaps this is your problem?\n" "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n\n" "\n"] 5]] 38 "\ Submit via mail a bug report on c++-mode." nil]) (provide 'c++-mode)