(defvar c++-mode-abbrev-table nil "\ Abbrev table in use in C++-mode buffers.") (define-abbrev-table (quote c++-mode-abbrev-table) nil) (defvar c++-mode-map nil "\ Keymap used in C++ mode.") (if c++-mode-map nil (setq c++-mode-map (make-sparse-keymap)) (define-key c++-mode-map " " (quote reindent-then-newline-and-indent)) (define-key c++-mode-map "{" (quote c++-electric-brace)) (define-key c++-mode-map "}" (quote c++-electric-brace)) (define-key c++-mode-map ";" (quote c++-electric-semi)) (define-key c++-mode-map "#" (quote c++-electric-pound)) (define-key c++-mode-map "" (quote mark-c-function)) (define-key c++-mode-map "" (quote c++-indent-exp)) (define-key c++-mode-map " " (quote c++-indent-command)) (define-key c++-mode-map " " (quote c++-insert-header)) (define-key c++-mode-map "" (quote c++-macroize-region)) (define-key c++-mode-map "" (quote c++-comment-region)) (define-key c++-mode-map "" (quote c++-uncomment-region)) (define-key c++-mode-map "" (quote c++-match-paren)) (define-key c++-mode-map "" (quote c++-beginning-of-defun)) (define-key c++-mode-map "" (quote c++-end-of-defun)) (define-key c++-mode-map "" (quote c++-indent-defun)) (define-key c++-mode-map "/" (quote c++-electric-slash)) (define-key c++-mode-map "*" (quote c++-electric-star)) (define-key c++-mode-map ":" (quote c++-electric-colon)) (define-key c++-mode-map "" (quote c++-electric-delete)) (define-key c++-mode-map "" (quote c++-toggle-auto-hungry-state)) (define-key c++-mode-map "" (quote c++-toggle-hungry-state)) (define-key c++-mode-map "" (quote c++-toggle-auto-state)) (define-key c++-mode-map "'" (quote c++-tame-comments)) (define-key c++-mode-map "'" (quote c++-tame-insert)) (define-key c++-mode-map "[" (quote c++-tame-insert)) (define-key c++-mode-map "]" (quote c++-tame-insert)) (define-key c++-mode-map "(" (quote c++-tame-insert)) (define-key c++-mode-map ")" (quote c++-tame-insert)) (define-key c++-mode-map "" (quote c++-submit-bug-report)) (define-key c++-mode-map "" (quote c++-version))) (defvar c++-mode-syntax-table nil "\ Syntax table in use in C++-mode buffers.") (if c++-mode-syntax-table nil (setq c++-mode-syntax-table (copy-syntax-table c-mode-syntax-table)) (modify-syntax-entry 47 ". 12" c++-mode-syntax-table) (modify-syntax-entry 10 ">" c++-mode-syntax-table) (modify-syntax-entry 39 "\"" c++-mode-syntax-table)) (defvar c++-tab-always-indent (if (boundp (quote c-tab-always-indent)) c-tab-always-indent t) "\ *Controls the operation of the TAB key. t means always just reindent 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 the line is first reindented, then if the indentation hasn't changed, a tab is inserted. This last mode is useful if you like to add tabs after the # of preprocessor commands.") (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 does not affect braces which close a top-level construct (e.g. function).") (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 an line following an empty argument list. Nil indicates to just after the paren.") (defvar c++-comment-only-line-offset 0 "\ *Indentation offset for line which contains only C or C++ style comments.") (defvar c++-cleanup-brace-else-brace-p nil "\ *Controls whether } else { style should remain on a single line. When t, cleans up this style (when only whitespace intervenes).") (defvar c++-cleanup-empty-defun-braces-p nil "\ *Controls whether braces for an empty defun are placed on separate lines. This only has effect if c++-auto-newline is non-nil. If this is the case, and c++-cleanup-empty-defun-braces-p is also non-nil, then typing the closing brace of an empty defun marries the the two braces onto the same line.") (defvar c++-hanging-braces t "\ *Controls the insertion of newlines before open (left) braces. This variable only has effect when auto-newline is on. 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 (quote 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 (quote none) "\ *Initial state of auto/hungry mode 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 states. Legal values are: 'none -- auto-newline and hungry-delete-key cannot be enabled. 'auto-only -- only auto-newline state can be toggled. 'hungry-only -- only hungry-delete-key state 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++-mailer (quote mail) "\ *Mail package to use to generate bug report mail buffer.") (defconst c++-mode-help-address "c++-mode-help@anthem.nlm.nih.gov" "\ Address accepting submission of bug reports.") (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 (quote (40 41 39 123 125 91 93)) "\ *Utilize a backslashing workaround of an emacs scan-lists 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 all characters which can potentially cause problems if they exist unbalanced within comments. Setting this variable to nil will defeat this feature, but be forewarned! Un-escaped characters in comment regions will break many things such as some indenting and blinking of parenthesis. Note further that only the default set of characters can be automatically escaped when typed in, but entering \\[c++-tame-comments] will escape all character in the set.") (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 each line to allow the user to do whatever special indentation adjustments are desired. If you have non-standard indentation, you will likely need to have c++-relative-offset-p set to nil.") (defvar c++-delete-function (quote 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++-hungry-delete-key nil "\ Internal state of hungry delete key.") (defvar c++-auto-newline nil "\ Internal state of auto newline feature.") (make-variable-buffer-local (quote c++-auto-newline)) (make-variable-buffer-local (quote c++-hungry-delete-key)) (defun c++-mode nil "\ Major mode for editing C++ code. $Revision: 2.118 $ Do a \"\\[describe-function] c++-dump-state\" for information on submitting bug reports. 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. Comments are delimited with /* ... */ {or with // ... } 5. Paragraphs are separated by blank lines only. 6. Delete converts tabs to spaces as it moves back. 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-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-continued-statement-offset Extra indentation given to a substatement, such as the then-clause of an if or body of a while. c-continued-brace-offset Extra indentation given to a brace that starts a substatement. This is in addition to c-continued-statement-offset. c-brace-offset Extra indentation for line if it starts with an open brace. 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-argdecl-indent Indentation level of declarations of C function arguments. c-label-offset Extra indentation for line that is a label, or case or ``default:'', or ``public:'' or ``private:'', or ``protected:''. c++-tab-always-indent Controls the operation of the TAB key. t means always just reindent 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 the line is first reindented, then if the indentation hasn't changed, a tab is inserted. This last mode is useful if you like to add tabs after the # of preprocessor commands. Default is value for c-tab-always-indent. c++-block-close-brace-offset Extra indentation give to braces which close a block. This does not affect braces which close top-level constructs (e.g. functions). 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++-member-init-indent Indentation level of member initializations in function declarations, if they are on a separate line beginning with a colon. c++-friend-offset Offset of C++ friend class declarations relative to member declarations. c++-access-specifier-offset Extra indentation given to public, protected, and private keyword lines. c++-empty-arglist-indent If non-nil, a function declaration or invocation which ends a line with a left paren is indented this many extra spaces, instead of flush with the left paren. If nil, it lines up with the left paren. 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++-comment-only-line-offset Extra indentation for a line containing only a C or C++ style comment. c++-cleanup-brace-else-brace-p Controls whether } else { style (with only whitespace intervening) should be cleaned up so that it sits on only a single line. c++-cleanup-empty-defun-braces-p Controls whether braces for an empty defun are placed on separate lines. This only has effect if c++-auto-newline is non-nil. If this is the case, and c++-cleanup-empty-defun-braces-p is also non-nil, then typing the closing brace of an empty defun marries the the two braces onto the same line. c++-hanging-braces Controls open brace hanging behavior when using auto-newline. Nil says no braces hang, t says all open braces hang. Not 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++-auto-hungry-initial-state Initial state of auto/hungry mode when a C++ buffer is first visited. c++-auto-hungry-toggle Enable/disable toggling of auto/hungry states. c++-mailer Mailer to use when sending bug reports. c++-mode-help-address Address to send bug report via email. 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. c++-default-macroize-column Column to insert backslashes when macroizing a region. 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. Otherwise, this variable contains a list of characters to escape. 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. Auto-newlining is no longer an all or nothing proposition. To be specific 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, hungry-delete) can be toggled on and off on the fly. Hungry-delete is the optional behavior of the delete key. When hungry-delete is enabled, hitting the delete key once consumes all preceeding whitespace, unless point is within a literal (defined as a C or C++ comment, or string). Inside literals, and with hungry-delete disabled, the delete key just calls backward-delete-char-untabify. Behavior is controlled by 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. 'auto-only -- function affects only auto-newline state. 'hungry-only -- function affects only hungry-delete state. 'auto-hungry (or t) -- function affects both states. Thus if c++-auto-hungry-initial-state is 'hungry-only, then only hungry state is turned on when the buffer is first visited. If c++-auto-hungry-toggle is 'auto-hungry, and both auto-newline and hungry-delete state are on, then hitting \"\\[c++-toggle-auto-hungry-state]\" will toggle both states. Hitting \"\\[c++-toggle-hungry-state]\" will always toggle hungry-delete state and hitting \"\\[c++-toggle-auto-state]\" will always toggle auto-newline state, regardless of the value of c++-auto-hungry-toggle. Hungry-delete state, when on, makes the delete key consume all preceding whitespace. 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. Report bugs by entering \"\\[c++-submit-bug-report]\". 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." (interactive) (byte-code "Ɉ ! ! !PL!L!L!L!L!L!L!L!L!L!L  \" ) ! > >\"" [c++-mode-map c++-mode-syntax-table major-mode mode-name local-abbrev-table c++-mode-abbrev-table page-delimiter paragraph-start t nil mode-line-format modeline c++-auto-hungry-initial-state kill-all-local-variables use-local-map set-syntax-table c++-mode "C++" make-local-variable "^$\\|" paragraph-separate paragraph-ignore-fill-prefix require-final-newline parse-sexp-ignore-comments indent-line-function c++-indent-line comment-start "// " comment-end "" comment-column 32 comment-start-skip "/\\*+ *\\|// *" comment-indent-hook c++-comment-indent mapcar (lambda (element) (byte-code " = Ă C\"" [modeline element append 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 (auto-only auto-hungry t) (hungry-only auto-hungry t)] 20)) (defun c++-comment-indent nil "\ Used by indent-for-comment to decide how much to indent a comment in C++ code based on its context." (byte-code "! Ƃ6!i!ƂiT`! #2!bi3 )])" [cur-pt comment-start-skip t comment-column looking-at "^\\(/\\*\\|//\\)" 0 skip-chars-backward " " zerop beginning-of-line re-search-forward match-beginning] 9)) (defun c++-set-auto-hungry-state (auto-p hungry-p) "\ Set auto/hungry to state indicated by AUTO-P and HUNGRY-P. Update mode line to indicate state to user." (byte-code "   !" [c++-auto-newline auto-p c++-hungry-delete-key hungry-p set-buffer-modified-p buffer-modified-p] 3)) (defun c++-toggle-auto-state (arg) "\ Toggle auto-newline state. 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." (interactive "P") (byte-code "È ? ?& !! ?& W%Â& \")" [auto arg c++-auto-newline nil t c++-hungry-delete-key zerop prefix-numeric-value 0 c++-set-auto-hungry-state] 5)) (defun c++-toggle-hungry-state (arg) "\ Toggle hungry-delete-key state. 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." (interactive "P") (byte-code "È ? ?& !! ?& W%Â& \")" [hungry arg c++-hungry-delete-key nil t c++-auto-newline zerop prefix-numeric-value 0 c++-set-auto-hungry-state] 5)) (defun c++-toggle-auto-hungry-state (arg) "\ Toggle auto-newline and hungry-delete-key state. Actual toggling of these states is controlled by c++-auto-hungry-toggle variable. Optional argument has the following meanings when supplied: Universal argument \\[universal-argument] resets state to c++-auto-hungry-initial-state. negative number turn off both auto-newline and hungry-delete-key. positive number turn on both auto-newline and hungry-delete-key. zero toggle both states regardless of c++-auto-hungry-toggle-p." (interactive "P") (byte-code "Ɉ !EE ?' >\"?$J <3 >J!??J WIɂJ ?b >] ?_ !z ? Wɂ  \"-" [numarg arg apl t hpl auto c++-auto-hungry-toggle c++-auto-newline c++-auto-hungry-initial-state nil hungry c++-hungry-delete-key prefix-numeric-value auto-only auto-hungry hungry-only zerop 0 c++-set-auto-hungry-state] 6)) (defun c++-tame-insert (arg) "\ Safely inserts certain troublesome characters in comment regions. Because of a syntax bug in emacs' scan-lists function, 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. See also the variable c++-untame-characters." (interactive "p") (byte-code "È > c !" [last-command-char c++-untame-characters arg nil c++-in-comment-p "\\" self-insert-command] 3)) (defun c++-electric-delete (arg) "\ 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." (interactive "P") (byte-code "ƈ?  !\"Q  !, !,!hU)?)M`!` \"E` \"I \")Q \"" [c++-hungry-delete-key arg c++-delete-function bod here t nil funcall prefix-numeric-value c++-point-bod c++-in-comment-p c++-in-open-string-p skip-chars-backward " " 35 " " /= delete-region 1] 13)) (defun c++-electric-pound (arg) (interactive "p") (byte-code "ň !4 n >  \"! ?. b \"*" [arg here bolp c++-electric-pound-behavior last-command-char nil c++-in-open-string-p c++-in-comment-p self-insert-command point-marker alignleft beginning-of-line insert-before-markers make-string set-marker] 10)) (defun c++-electric-brace (arg) "\ Insert character and correct line's indentation." (interactive "P") (byte-code "Ȉ  ?MlM!n)M U 6=66!?<ȉ J! )*0  >Z !_c   U!hU ? ?` \" b \") c     U#! ! ) !? !?  \"! b \" b \"+ \"  `Zb  bZ \")) +Tb!)Bb !!)G !!+" [insertpos last-command-char bod arg c++-auto-newline open-brace-p c++-hanging-braces t nil c++-untame-characters here c++-cleanup-empty-defun-braces-p mbeg mend c++-cleanup-brace-else-brace-p status c++-point-bod skip-chars-backward " " 123 c++-at-top-level-p forward-line -1 c++-indent-line c++-in-comment-p "\\" point-marker 125 " " c++-in-open-string-p delete-region set-marker re-search-backward "}[ ]*else[ ]*{" match-beginning 0 match-end insert-before-markers "} else {" 2 delete-char self-insert-command prefix-numeric-value] 35)) (defun c++-electric-slash (arg) "\ Slash as first non-whitespace character on line indents as comment unless we're inside a C style comment, or a string, does not do indentation. if first non-whitespace character on line is not a slash, then we just insert the slash. in this case use indent-for-comment if you want to add a comment to the end of a line." (interactive "P") (byte-code "hU h> ! !!)" [c++-auto-newline nil arg 47 (47 42) c++-electric-terminator self-insert-command prefix-numeric-value] 4)) (defun c++-electric-star (arg) "\ Works with c++-electric-slash to auto indent C style comment lines." (interactive "P") (byte-code "hU !) !!" [c++-auto-newline nil arg 47 c++-electric-terminator self-insert-command prefix-numeric-value] 4)) (defun c++-electric-semi (arg) "\ Insert character and correct line's indentation." (interactive "P") (byte-code "ˆ`!hU`\")) !" [insertion-point arg nil skip-chars-backward " " 125 delete-region c++-electric-terminator] 4)) (defun c++-electric-colon (arg) "\ Electrify colon. De-auto-newline double colons. No auto-new-lines for member initialization list." (interactive "P") (byte-code "È` !hU !? !?/ `\"` bЏ !hUGÉ b!? !hU b >x!n)?x `) >É) b!+" [c++-auto-newline insertion-point bod nil t c++-hanging-member-init-colon arg c++-point-bod skip-chars-backward " " 58 c++-in-comment-p c++-in-open-string-p delete-region premature-end (byte-code "!" [backward-sexp 1] 2) ((error (byte-code "" [nil] 1))) c++-backward-to-noncomment 63 c++-at-top-level-p 41 (nil before) " " (nil after) c++-electric-terminator] 12)) (defun c++-electric-terminator (arg) "\ Insert character and correct line's indentation." (interactive "P") (byte-code "ƈ` ?`l` !gU^ =C!?C!!` W)C!!)^ ` \" 8] 8] 8))? c ? `S\" Tb!)b !!) !!*" [insertpos end arg last-command-char pps c++-auto-newline nil beginning-of-line skip-chars-forward " " 35 58 looking-at "case[ ]" forward-word 1 end-of-line ":" c++-beginning-of-defun parse-partial-sexp 3 4 5 c++-indent-line c++-in-parens-p make-marker set-marker newline delete-char -1 self-insert-command prefix-numeric-value] 21)) (defun c++-indent-command (&optional whole-exp) "\ Indent current line as C++ code, or in some cases insert a tab character. If c++-tab-always-indent is 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. 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." (interactive "P") (byte-code "Lj  C! = `!` b!`) V? $+ =l!n)^!^` \"g!i =x!!!!hU)` `)  !  V` U ) +!)" [bod whole-exp shift-amt beg end c++-tab-always-indent t nil here boi indent-p c++-point-bod c++-indent-line beginning-of-line forward-sexp 1 forward-line indent-code-rigidly "#" skip-chars-backward " " looking-at "[ ]*$" /= c++-point-boi insert-tab c++-in-open-string-p c++-in-comment-p 35 back-to-indentation] 22)) (defun c++-indent-exp nil "\ Indent each line of the C++ grouping following point." (interactive) (byte-code "C`C`     !)m?> ?b ?ZmYЉ?` ` `%b+@AA@AA@YAA@ 8 8!ЉLXЉ ^ 8VA A S  \"  WB B T  @?5 A@4!`)\"!!lF^@O@Y @f\"c@ ! gU !h>? @!i #  !  @ )@@[! \")! Z !!!!) \\] !  \\ gU Z gU( \\ i UAgUA` `\" j!^ `)#^@ 7)." [indent-stack nil contain-stack case-fold-search restart outer-loop-done inner-loop-done state ostate this-indent last-sexp last-depth at-else at-brace opoint next-depth t start line-end end c-continued-statement-offset c-continued-brace-offset val c-indent-level c-label-offset c++-friend-offset c-brace-offset comment-start-skip 0 forward-sexp 1 end-of-line forward-char parse-partial-sexp 4 c++-indent-line 3 forward-line 6 /= setcar -1 skip-chars-forward " " 123 looking-at "else\\W" c++-backward-to-noncomment (nil 44 59 125 58 123) c-backward-to-start-of-continued-exp + c-backward-to-start-of-if current-indentation c++-calculate-indent "\\(public\\|private\\|protected\\):" "case[ ]" "[A-Za-z]" ":[^:]" "friend[ ]" 125 35 delete-region beginning-of-line re-search-forward indent-for-comment] 35)) (defun c++-fill-C-comment nil "\ Fill a C style comment." (interactive) (byte-code "Ĉ ! `)#!b ) !+!!!!!))" [save fill-prefix comment-start-skip t nil beginning-of-line 1 re-search-forward end-of-line match-end 0 set-fill-prefix looking-at forward-line -1 insert-string " " fill-paragraph delete-char] 13)) (defun c++-insert-header nil "\ Insert header denoting C++ code at top of buffer." (interactive) (byte-code "eb$)" [nil insert "// " "This may look like C code, but it is really " "-*- C++ -*-" " "] 5)) (defun c++-tame-comments nil "\ Backslashifies all untamed in comment regions found in the buffer. This is the best available workaround for an emacs syntax bug in scan-lists which exists at least as recently as v18.58. Untamed characters to escape are defined in the variable c++-untame-characters." (interactive) (byte-code "ˆ #P m?9!g!?' 'h\",cm?5!))" [charset c++-untame-characters nil "^" mapconcat (lambda (char) (byte-code ">!P!" [char (92 94 45) "\\" char-to-string] 3)) "" beginning-of-buffer skip-chars-forward zerop c++-in-comment-p /= 92 "\\" forward-char 1] 9)) (defun c++-match-paren nil "\ Jumps to the paren matching the one under point, if there is one." (interactive) (byte-code "!! #! !#!" [t nil looking-at "[([{]" forward-sexp 1 backward-char "[])}]" forward-char backward-sexp message "Could not find matching paren."] 8)) (defun c++-at-top-level-p (&optional wrt) "\ Return t if point is not inside a containing C++ expression, nil if it is embedded in an expression. If optional WRT is supplied non-nil, returns t if point at the top level with respect to the containing class definition (useful for inline functions)." (byte-code "`` `W,``# A@ ?SS @US bgUSϏb#.)" [indent-point case-fold-search nil state containing-sexp parse-start here wrt c++-beginning-of-defun parse-partial-sexp 0 1 123 scanlist-err (byte-code "`#" [scan-lists -1] 4) ((error (byte-code "e" [] 1))) re-search-forward "\\<\\(class\\|struct\\)\\>" move] 6)) (defun c++-in-literal (&optional lim) "\ 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 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 "`  b`W#'!!\" \"> `X;҂ \"R#?OՂ \"gUq!`Xm‚nڂ`\"#)?ڂ \"#?ڂ‰ ,)" [here state nil match backlim lim t c++-point-bod re-search-forward "\\(/[/*]\\)\\|[\"']" move buffer-substring match-beginning 0 match-end string= "//" end-of-line c++ "/*" "*/" c "\"" 34 forward-char 1 string narrow-to-region "[^\\]\"" "'" "[^\\]'"] 19)) (defun c++-in-open-string-p (&optional lim) "\ Return non-nil if in an open string as defined by mode's syntax. Optional LIM is passed to c++-in-literal." (byte-code "!=" [lim c++-in-literal string] 3)) (defun c++-in-comment-p (&optional lim) "\ Return t if in a C or C++ style comment as defined by mode's syntax. Optional LIM is passed to c++-in-literal." (byte-code "!> " [lim t c++-in-literal (c c++)] 3)) (defun c++-in-parens-p (&optional lim) "\ Return t if inside a paren expression. Optional LIM is used as the backward limit of the search." (byte-code "  ŏ)" [backlim lim c++-point-bod nil (byte-code "`\"db`#efU))" [backlim narrow-to-region scan-lists -1 1 40] 5) ((error (byte-code "" [nil] 1)))] 4)) (defun c++-indent-line (&optional bod) "\ 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." (byte-code " \"d`Z ` =. I =; I!G؉I ?Z!Zi\")u  Ul r  \\I! < @!  \\I!  \\I!!!!)  \\]I!!? )I!  \\IgU Z! [!)\\IgU= Z! )5[7\\IgUI \\! iZ !kdZ`VhdZb `\" jdZ`VdZb!) ." [bod indent nil beg shift-amt comcol case-fold-search pos t comment-column c++-comment-only-line-offset c++-access-specifier-offset c-label-offset c++-friend-offset c-indent-level c++-block-close-brace-offset c-brace-offset c++-point-bod c++-calculate-indent beginning-of-line current-indentation calculate-c-indent-within-comment looking-at "[ ]*#" 0 back-to-indentation "//\\|/\\*" /= skip-chars-forward " " "\\(public\\|private\\|protected\\):" "default:" "case\\b" "[A-Za-z]" forward-sexp 1 ":[^:]" "else\\b" "else\\s_" c-backward-to-start-of-if "friend[ ]" 41 forward-char c++-at-top-level-p 125 123 zerop delete-region run-hooks c++-special-indent-hook] 31)) (defun c++-calculate-indent (&optional parse-start bod) "\ 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." (byte-code " ` %b(b`WR``#  !?M`  A@*)!^‚!i˂b ! !i!i Ui! ?ڂb!!ڂgUڂe!o?!!!hUhU!!)b!gUhU!!hU%!!gU)A !!9ڂ>ZhUJhUQڂ !!b!iڂgU| \\!!iZQ!b!hU!biڂgUZlڂ Z\\ f\" 8? Tb!?)  b !`\\ T^bi Tb!ib !h>?@ !bA!)A߁B!iCi! !hD>)\\E!i!!@ !E!ڊb!gUgU! [)#b!F!G !H!i) b!I!) bJ i\\ b}!!KLMNOP%!tgQU3!pR!ISTU#pV!W!pW!e!pXYU# `W|i)Cn!\\!nڂh=Z! #.)" [indent-point case-fold-search nil state do-indentation containing-sexp inclass-shift bod parse-start here pps t comment-start-skip comment-column c-indent-level c++-member-init-indent c-argdecl-indent c++-continued-member-init-offset c++-empty-arglist-indent c++-always-arglist-indent-p c-continued-statement-offset c-continued-brace-offset c++-relative-offset-p c-brace-offset c-brace-imaginary-offset beginning-of-line 0 c++-point-bod parse-partial-sexp c++-in-comment-p c++-in-open-string-p skip-chars-forward " " looking-at zerop c++-at-top-level-p "/[/*]" 123 c++-backward-to-noncomment forward-char -1 skip-chars-backward 41 116 forward-word "\\" 58 59 backward-char 1 forward-line "\\<\\(public\\|protected\\|private\\)\\>:" 125 current-indentation "\\(class\\|struct\\)" "[ ]+" "\\(\\w+[ ]*:[ ]*\\)?" " " 44 match-end /= 2 "\\( \\| \\)*[^/ ]" (nil 44 59 125 58 123) c-backward-to-start-of-continued-exp "[ ]*\\(<<\\|>>\\)" "^><" + (nil 44 59 125 58 123) "\\(do\\|else\\|for\\|if\\|while\\)\\b" "while\\b" c++-backward-to-start-of-do "do\\b" "case\\b" back-to-indentation concat "#\\|/\\*\\|//" "\\|\\(case\\|default\\)[ ]" "\\|[a-zA-Z0-9_$]*:[^:]" "\\|friend[ ]" "\\(class\\|struct\\)[ ]" 35 "/\\*" search-forward "*/" move "//\\|friend[ ]\\(class\\|struct\\)[ ]" "\\(case\\|default\\)\\b" re-search-forward ":[^:]" forward-sexp] 85)) (defun c++-backward-to-noncomment (lim) "\ Skip backwards to first preceding non-comment character. Search no farther back than LIM." (byte-code " ?p \" =8 ]` b #2!b4 b*l=S #M!bPʼnlhU`!hUi!lʼn*" [literal stop lim sblim here t nil skip-chars-backward " " c++-in-literal c++ c++-point-bol search-forward "//" move match-beginning 0 c search-backward "/*" 47 forward-char -1 42] 12)) (defun c++-backward-to-start-of-do (&optional limit) "\ Move to the start of the last ``unbalanced'' do." (byte-code "  !?ɏ *" [limit do-level case-fold-search nil c++-point-bod 1 zerop err (byte-code "! /!T/!#S/` W/ȉ b" [do-level limit backward-sexp 1 c++-in-comment-p looking-at "while\\b" "do\\b" 0] 6) ((error (byte-code "b‰" [limit do-level 0] 2)))] 6)) (defun c++-auto-newline nil "\ 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." (byte-code "  !?!? ?)" [bod c++-auto-newline c++-point-bod c++-in-comment-p c++-in-open-string-p newline] 5)) (defun c++-point-bol nil "\ Returns the value of the point at beginning of the current line." (byte-code " `)" [beginning-of-line] 2)) (defun c++-point-bod nil "\ Returns the value of point at c++-beginning-of-defun." (byte-code " `)" [c++-beginning-of-defun] 2)) (defun c++-point-boi nil "\ Returns the value of point at back-to-indentation." (byte-code " `)" [back-to-indentation] 2)) (defun c++-macroize-region (from to arg) "\ Insert backslashes at end of every line in region. Useful for defining cpp macros. If called with negative argument, will remove trailing backslashes, so that indentation will work right." (interactive "r p") (byte-code "ňb!e`\" be`\") W1 V!! T*)" [from line to-line to arg nil beginning-of-line 1 count-lines c++-backslashify-current-line 0 forward-line] 8)) (defun c++-backslashify-current-line (doit) "\ Backslashifies current line." (byte-code "!I!!)?Fi Y cFi X/c !i WCc 4cY!!Y! " [doit c++-default-macroize-column t end-of-line 1 forward-char -1 looking-at "\\\\" " \\" " " delete-char " " "\\" skip-chars-backward " " kill-line] 11)) (defun c++-comment-region nil "\ Comment out all lines in a region between mark and current point by inserting \"// \" (comment-start)in front of each line." (interactive) (byte-code " =! `W``V(`) ! b` !WJ c !2)," [m nil start end mymark comment-start mark error "Mark is not set!" copy-marker marker-position beginning-of-line forward-line 1] 10)) (defun c++-uncomment-region nil "\ Uncomment all lines in region between mark and current point by deleting the leading \"// \" from each line, if any." (interactive) (byte-code " =! `W``V(`) !G! b` !Wd P!Y\" ! !<)." [m nil start end mymark len comment-start char mark error "Mark is not set!" copy-marker string-to-char marker-position beginning-of-line looking-at " *" zap-to-char 1 delete-char forward-line] 14)) (defvar c++-match-header-strongly nil "\ *If NIL, use c++-defun-header-weak to identify beginning of definitions, if nonNIL, use c++-defun-header-strong") (defvar c++-defun-header-strong-struct-equivs "\\(class\\|struct\\|enum\\)" "\ Regexp to match names of structure declaration blocks in C++") (defconst c++-defun-header-strong (let* ((id "\\(\\w\\|_\\)+") (op-sym1 "[---+*/%^&|~!=<>]\\|[---+*/%^&|<>=!]=\\|<<=?\\|>>=?") (op-sym2 "&&\\|||\\|\\+\\+\\|--\\|()\\|\\[\\]") (op-sym (concat "\\(" op-sym1 "\\|" op-sym2 "\\)")) (middle "[^\\*]*\\(\\*+[^/\\*][^\\*]*\\)*") (c-comment (concat "/\\*" middle "\\*+/")) (wh (concat "\\(\\s \\| \\|//.*$\\|" c-comment "\\)")) (wh-opt (concat wh "*")) (wh-nec (concat wh "+")) (oper (concat "\\(" "operator" "\\(" wh-opt op-sym "\\|" wh-nec id "\\)" "\\)")) (dcl-list "([^():]*)") (func-name (concat "\\(" oper "\\|" id "::" id "\\|" id "\\)")) (inits (concat "\\(:" "\\(" wh-opt id "(.*\\()" wh-opt "," "\\)\\)*" wh-opt id "(.*)" wh-opt "{" "\\|" wh-opt "{\\)")) (type-name (concat "\\(" c++-defun-header-strong-struct-equivs wh-nec "\\)?" id)) (type (concat "\\(const" wh-nec "\\)?" "\\(" type-name "\\|" type-name wh-opt "\\*+" "\\|" type-name wh-opt "&" "\\)")) (modifier "\\(inline\\|virtual\\|overload\\|auto\\|static\\)") (modifiers (concat "\\(" modifier wh-nec "\\)*")) (func-header (concat modifiers type wh-nec func-name wh-opt dcl-list wh-opt inits)) (inherit (concat "\\(:" wh-opt "\\(public\\|private\\)?" wh-nec id "\\)")) (cs-header (concat c++-defun-header-strong-struct-equivs wh-nec id wh-opt inherit "?" wh-opt "{"))) (concat "^\\(" func-header "\\|" cs-header "\\)")) "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.") (defun c++-beginning-of-defun (&optional arg) (interactive "p") (byte-code "ň? ʉ   U\"V\"o)ł !?}`#:` #E!bbWbVwbUsɂtł|b+ !o?Wʂ! $!b)" [arg c++-defun-header c++-match-header-strongly c++-defun-header-strong c++-defun-header-weak nil curr-pos open-pos beg-pos t 1 0 looking-at search-forward "{" move re-search-backward match-beginning forward-char -1] 11)) (defun c++-end-of-defun (arg) (interactive "p") (byte-code "ň m Vł| V#!)!` WC m=Ȃ>Z[D ! WMoTǂy#f! !`Us#y!))" [c++-defun-header c++-match-header-strongly c++-defun-header-strong c++-defun-header-weak arg nil pos t 0 looking-at forward-char 1 c++-beginning-of-defun re-search-forward move -1 forward-sexp beginning-of-line 2 c++-end-of-defun] 11)) (defun c++-indent-defun nil "\ Indents the current function def, struct or class decl." (interactive) (byte-code "ˆ`!!  ` W& !! \")b)" [restore end nil c++-end-of-defun 1 beginning-of-line point-marker c++-beginning-of-defun c++-indent-line forward-line set-marker] 10)) (defconst c++-version "$Revision: 2.118 $" "\ c++-mode version number.") (defun c++-version nil "\ Echo the current version of c++-mode." (interactive) (byte-code "\"" [c++-version nil message "Using c++-mode.el %s"] 3)) (defun c++-dump-state nil "\ Inserts into the c++-mode-state-buffer the current state of c++-mode into the bug report mail buffer. Use \\[c++-submit-bug-report] to submit a bug report." (byte-code "p&q 5 !% \" # \"c*" [buffer varlist c++-special-indent-hook c++-version list c++-continued-member-init-offset c++-member-init-indent c++-friend-offset c++-access-specifier-offset c++-empty-arglist-indent c++-always-arglist-indent-p c++-comment-only-line-offset c++-cleanup-brace-else-brace-p c++-cleanup-empty-defun-braces-p c++-hanging-braces c++-hanging-member-init-colon c++-auto-hungry-initial-state c++-auto-hungry-toggle c++-hungry-delete-key c++-auto-newline c++-default-macroize-column c++-match-header-strongly c++-defun-header-strong-struct-equivs c++-tab-always-indent c++-untame-characters c++-relative-offset-p c++-electric-pound-behavior c++-delete-function c-indent-level c-continued-statement-offset c-continued-brace-offset c-brace-offset c-brace-imaginary-offset c-argdecl-indent c-label-offset tab-width insert "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ " "c++-special-indent-hook is set to '" symbol-name ". Perhaps this is your problem? " "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ " emacs-version " " "c++-mode.el " " current state: ============== (setq " mapcar (lambda (varsym) (byte-code " ! ! <9Ȃ!&*" [val varsym sym eval symbol-name insert " " " " "'" "" prin1-to-string " "] 10)) " ) "] 33)) (defun c++-submit-bug-report nil "\ Submit via mail a bug report using the mailer in c++-mailer." (interactive) (byte-code "ƈp !p! !* cd#\" \" d#?:db #db=!`!c " [curbuf mailbuf c++-mailer c++-mode-help-address c++-version mail-header-separator nil funcall pop-to-buffer re-search-forward "^subject:[ ]+" move insert "Bug in c++-mode.el " " " forward-line 1 set-mark " " c++-dump-state exchange-point-and-mark] 12)) (provide (quote c++-mode))