;ELC   
;;; Compiled by pot@pot.cnuce.cnr.it on Tue Mar 18 15:50:10 2003
;;; from file /home/pot/gnu/emacs-pretest.new/lisp/progmodes/cc-cmds.el
;;; in Emacs version 21.3
;;; with bytecomp version 2.85.4.1
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.
(if (and (boundp 'emacs-version)
	 (< (aref emacs-version (1- (length emacs-version))) ?A)
	 (or (and (boundp 'epoch::version) epoch::version)
	     (string-lessp emacs-version "19.29")))
    (error "`cc-cmds.el' was compiled for Emacs 19.29 or later"))

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


(byte-code "\300\301!\210\300\302!\210\300\303!\210\300\304!\207" [require cc-defs cc-vars cc-langs cc-engine] 2)
(defalias 'c-calculate-state #[(arg prevstate) "\203 \302\303!\211!\203 	?\207\304V\207" [arg prevstate zerop prefix-numeric-value 0] 3])
#@393 Toggle auto-newline feature.
Optional numeric ARG, if supplied, turns on auto-newline when
positive, turns it off when negative, and just toggles it when zero or
left out.

When the auto-newline feature is enabled (as evidenced by the `/a' or
`/ah' on the modeline after the mode name) newlines are automatically
inserted after special characters such as brace, comma, semi-colon,
and colon.
(defalias 'c-toggle-auto-state #[(&optional arg) "\305	\"\211\203 \n\203 \306\202 \307\202 \n\205 \310\311 \210\312\304!\205' \313\211\207" [arg c-auto-newline c-hungry-delete-key c-auto-hungry-string zmacs-region-stays c-calculate-state "/ah" "/a" "/h" force-mode-line-update boundp t] 4 (#$ . 885) "P"])
#@365 Toggle hungry-delete-key feature.
Optional numeric ARG, if supplied, turns on hungry-delete when
positive, turns it off when negative, and just toggles it when zero or
left out.

When the hungry-delete-key feature is enabled (as evidenced by the
`/h' or `/ah' on the modeline after the mode name) the delete key
gobbles all preceding whitespace in one fell swoop.
(defalias 'c-toggle-hungry-state #[(&optional arg) "\305	\"\n\203 	\203 \306\202 \307\202 	\205 \310\311 \210\312\304!\205' \313\211\207" [arg c-hungry-delete-key c-auto-newline c-auto-hungry-string zmacs-region-stays c-calculate-state "/ah" "/a" "/h" force-mode-line-update boundp t] 3 (#$ . 1599) "P"])
#@286 Toggle auto-newline and hungry-delete-key features.
Optional numeric ARG, if supplied, turns on auto-newline and
hungry-delete when positive, turns them off when negative, and just
toggles them when zero or left out.

See `c-toggle-auto-state' and `c-toggle-hungry-state' for details.
(defalias 'c-toggle-auto-hungry-state #[(&optional arg) "\305	\"\305\n\"	\203 \n\203 \306\202 \307\202 \n\205 \310\311 \210\312\304!\205, \313\211\207" [arg c-auto-newline c-hungry-delete-key c-auto-hungry-string zmacs-region-stays c-calculate-state "/ah" "/a" "/h" force-mode-line-update boundp t] 3 (#$ . 2284) "P"])
#@388 Deletes preceding character or whitespace.
If `c-hungry-delete-key' is non-nil, as evidenced by the "/h" or
"/ah" string on the mode line, then all preceding whitespace is
consumed.  If however a prefix argument is supplied, or
`c-hungry-delete-key' is nil, or point is inside a literal then the
function in the variable `c-backspace-function' is called.

See also \[c-electric-delete].
(defalias 'c-electric-backspace #[(arg) "\203 	\204 \304 \203 \n\305	!!\207`\306\307x\210`U\204% `|\202( \n\310!)\207" [c-hungry-delete-key arg c-backspace-function here c-in-literal prefix-numeric-value " 	\n" nil 1] 3 (#$ . 2906) "*P"])
#@353 Deletes following character or whitespace.
If `c-hungry-delete-key' is non-nil, as evidenced by the "/h" or
"/ah" string on the mode line, then all following whitespace is
consumed.  If however a prefix argument is supplied, or
`c-hungry-delete-key' is nil, or point is inside a literal then the
function in the variable `c-delete-function' is called.
(defalias 'c-electric-delete-forward #[(arg) "\203 	\204 \304 \203 \n\305	!!\207`\306\307w\210`U\204% `|\202( \n\310!)\207" [c-hungry-delete-key arg c-delete-function here c-in-literal prefix-numeric-value " 	\n" nil 1] 3 (#$ . 3546) "*P"])
#@839 Deletes preceding or following character or whitespace.
This function either deletes forward as `c-electric-delete-forward' or
backward as `c-electric-backspace', depending on the configuration:

If the function `delete-forward-p' is defined (XEmacs 21) and returns
non-nil, it deletes forward.  Else, if the variable
`delete-key-deletes-forward' is defined (XEmacs 20) and is set to
non-nil, it deletes forward.  Otherwise it deletes backward.

Note: This is the way in XEmacs 20 and later to choose the correct
action for the [delete] key, whichever key that means.  In other
flavors this function isn't used, instead it's left to the user to
bind [delete] to either \[c-electric-delete-forward] or \[c-electric-backspace] as appropriate
(the keymap `function-key-map' is useful for that).  Emacs 21 handles
that automatically, though.
(defalias 'c-electric-delete #[(arg) "\302\303!\203 \303 \204 \304\300!\203 \203 \305	!\207\306	!\207" [delete-key-deletes-forward arg fboundp delete-forward-p boundp c-electric-delete-forward c-electric-backspace] 2 (#$ . 4153) "*P"])
#@211 Electric pound (`#') insertion.
Inserts a `#' character specially depending on the variable
`c-electric-pound-behavior'.  If a numeric ARG is supplied, or if
point is inside a literal, nothing special happens.
(defalias 'c-electric-pound #[(arg) "\204 \305	>\203 \212\306\307x\210n)\203 \310 \203 \311\312!!\207d`Zn\313 \210\314 \210\315\f\316\"\210\n?\2059 dZb*\207" [arg c-electric-pound-behavior bolp pos last-command-char alignleft " 	" nil c-in-literal self-insert-command prefix-numeric-value beginning-of-line delete-horizontal-space insert-char 1] 3 (#$ . 5239) "*P"])
#@513 Insert a brace.

If the auto-newline feature is turned on, as evidenced by the "/a"
or "/ah" string on the mode line, newlines are inserted before and
after braces based on the value of `c-hanging-braces-alist'.

Also, the line is re-indented unless a numeric ARG is supplied, there
are non-whitespace characters present on the line after the brace, the
brace is inserted inside a literal, or `c-syntactic-indentation' is
nil.

This function does various newline cleanups based on the value of
`c-cleanup-list'.
(defalias 'c-electric-brace #[(arg) "\306 \307`\"\310	!\211\204 \204 \311\312!\204\" \313\314!!\202\315@\316`A\316Bo?\205: `Sfz\317=C\316D\212\320\316x\210n)\204O \321 \210\322BE\323=\203Z `B\313\314!!\210\324 FG\205\245 \f\325F\236\203\214 \326F\236\203| \327\202\216 \330F\236\203\207 \331\202\216 F\202\216 FHIJK\332KJ\"@I\236+\206\245 \333LM\203\270 \212\316\334\335\217)\203\270 \316LLA:\204\327 \336LA!\203\327 FNLAL@A\"L)\337L>\203U\316dd`Z`OPQR\340y\210\212\341 \210`)R\342`\"\212\214O`}\210\316\343\344\217\203!`Sf\345>\203!~\210\316\346\347\217\203!\350`\351#*S\203*\352 \210)\353\212\354 \210`)Q\212\341 \210`)RZ$dPZb\210`OU\204Q\324 F,\202\230B\203p\212\355 \210\356 \210\342`\"C\204o\357\340!\210)\212\212\354 \210`)T\360\361T`S\"@!\203\214\324 F\202\227\354 \210\316\306 \316F*\212\341 \210`)RdQFN\352 \210\353\212\354 \210`)Q\212\341 \210`)RZ$+`d`Z\316\211\211UVWPOG\203(\362X>\203(E\363=\203(\364FYK\316ZK\203K@Y\236\211Z\204KA\211K\204\363Z+\203(\340u\210\365\316x\210`Sf\323=\203(\310 \204(`OS|\210G\203\266E\323=\203\266\310 \204\266\366X>\203d\367\370\316\322#\203d\371\224W\371\225V\371\225O=\203dWV|\210\372c\210\202\266\373X>\203\266OSb\210`V\365\316x\210`W`Sf\374=\203\266\375\376\322\"\371U\203\266\316f\377=\203\266`U\367\201] \316\322#\203\266\371\225U=\203\266WV|\210Wb\210\201^ c\210dPZb\210-\201_ L>\203\354\321 \210`\201` Z\211[f\323=\203\333\351\202\336\201a \\\350[\\#\352 \210+E\363=\205@\205\212\201b 	!\210@ ).	+\207" [c-state-cache safepos literal arg syms blink-paren-function c-parse-state c-safe-position c-in-literal looking-at "[ 	]*$" self-insert-command prefix-numeric-value (class-open class-close defun-open defun-close inline-open inline-close brace-list-open brace-list-close brace-list-intro brace-entry-open block-open block-close substatement-open statement-case-open extern-lang-open extern-lang-close namespace-open namespace-close inexpr-class-open inexpr-class-close) nil 32 " 	" newline t 123 c-guess-basic-syntax inexpr-class class-open ((inexpr-class-open)) class-close ((inexpr-class-close)) c-intersect-lists (ignore before after) (byte-code "`Sf\300U\203 \301u\210\202 \302`\301\"\206 eb\210\303 \207" [123 -1 scan-sexps c-looking-at-special-brace-list] 3) ((error)) functionp before -1 back-to-indentation c-whack-state (byte-code "\300\301!\210\302\207" [backward-up-list -1 t] 2) ((error)) (41 125) (byte-code "\300`\301\"\206 eb\210\302\207" [scan-sexps -1 t] 3) ((error)) c-hack-state open indent-according-to-mode c-adjust-state beginning-of-line delete-indentation just-one-space delete-char zerop parse-partial-sexp empty-defun-braces 125 (defun-close class-close inline-close) " 	\n" brace-else-brace re-search-backward "}[ 	\n]*else[ 	\n]*{" 0 "} else {" brace-elseif-brace 41 c-backward-token-1 1 40 old-blink-paren insertion-point delete-temp-newline preserve-p c-echo-syntactic-information-p last-command-char syntax c-auto-newline c-hanging-braces-alist alist2 alist1 list newlines c-special-brace-lists c-syntactic-context here pos old-point-max old-ind c-syntactic-indentation bol tmp mend mbeg c-cleanup-list alist match bufpos which "}[ 	\n]*else[ 	\n]+if[ 	\n]*" " " after 2 close c-backward-syntactic-ws] 6 (#$ . 5832) "*P"])
#@385 Insert a slash character.

Indent the line as a comment, if:

  1. The slash is second of a `//' line oriented comment introducing
     token and we are on a comment-only-line, or

  2. The slash is part of a `*/' token that closes a block oriented
     comment.

If a numeric ARG is supplied, point is inside a literal, or
`c-syntactic-indentation' is nil, indentation is inhibited.
(defalias 'c-electric-slash #[(arg) "`Sf	\205' \n?\205' \306=\205' \306=\203 \307 ?\206' \310=\205' \307 \311\312\313\n!!\210\f\2056 \314 +\207" [ch c-syntactic-indentation arg last-command-char indentp c-echo-syntactic-information-p 47 c-in-literal 42 nil self-insert-command prefix-numeric-value indent-according-to-mode] 3 (#$ . 9737) "*P"])
#@285 Insert a star character.
If the star is the second character of a C style comment introducing
construct, and we are on a comment-only-line, indent line as comment.
If a numeric ARG is supplied, point is inside a literal, or
`c-syntactic-indentation' is nil, indentation is inhibited.
(defalias 'c-electric-star #[(arg) "\303\304!!\210	\205? ?\205? \305 \306>\205? `Sf\307=\205? \212\310u\210\311\312x\210`Sf\313=\2031 \310u\210\314\312x\210n)\205? \312\315 )\207" [arg c-syntactic-indentation c-echo-syntactic-information-p self-insert-command prefix-numeric-value c-in-literal (c) 42 -1 "*" nil 47 " 	" indent-according-to-mode] 3 (#$ . 10480) "*P"])
#@607 Insert a comma or semicolon.
When the auto-newline feature is turned on, as evidenced by the "/a"
or "/ah" string on the mode line, a newline might be inserted.  See
the variable `c-hanging-semi&comma-criteria' for how newline insertion
is determined.

When semicolon is inserted, the line is re-indented unless a numeric
arg is supplied, point is inside a literal, or there are
non-whitespace characters on the line following the semicolon, or
`c-syntactic-indentation' is nil.

Based on the value of `c-cleanup-list', this function cleans up commas
following brace lists and semicolons following defuns.
(defalias 'c-electric-semi&comma #[(arg) "\306\307 !\310!`\311	\204 \f\204 \312\313!\204# \314\315\f!!\202\272 \314\315\f!!\210\2047 \205\272 \316 \202\272 d`Z\317=\203J \320>\204X \321=\203q \322>\203q \323u\210\324\311x\210`Sf\325=\203q \310!\204q `\n|\210dZb\210)\203\200 \316 \210\311\211\203\257 @ \211\204\242 A\211\202\214 \311\326=?\202\212 \205\271 \327 \210\316 +,\207" [lim literal here c-echo-syntactic-information-p arg c-auto-newline c-most-enclosing-brace c-parse-state c-in-literal nil looking-at "[ 	]*$" self-insert-command prefix-numeric-value indent-according-to-mode 44 list-close-comma 59 defun-close-semi -1 " 	\n" 125 stop newline c-syntactic-indentation pos last-command-char c-cleanup-list c-hanging-semi&comma-criteria add-newline-p answer criteria] 4 (#$ . 11142) "*P"])
#@522 Insert a colon.

If the auto-newline feature is turned on, as evidenced by the "/a"
or "/ah" string on the mode line, newlines are inserted before and
after colons based on the value of `c-hanging-colons-alist'.

Also, the line is re-indented unless a numeric ARG is supplied, there
are non-whitespace characters present on the line after the colon, the
colon is inserted inside a literal, or `c-syntactic-indentation' is
nil.

This function cleans up double colon scope operators based on the
value of `c-cleanup-list'.
(defalias 'c-electric-colon #[(arg) "\212\306\307!\203\\ \203\\ \310	\204U \214~\210\311`\312\307 \310\313%)o\203( e\211\202 	\204? \314\310x\315\n!\203; \316 \210`)\202 	\317U\204 	f\320=\204 	b\210\310\211\203 	b\210)\202_ \316 \210\203m \321!\203m \317\225b\210`)\322\f!\310%\310&\310'\310(\204\217 )\204\217 \321\323!\204\230 \324\325)!!\202r\324\325)!!\210d`Z`*+\203\340 \326,>\203\340 `Sf\327=\203\340 \312u\210\330\310x\210`Sf\327=\203\340 \322 \204\340 `\331Zf\327=\204\340 `*S|\210\313'd	Zb\210*\332 %+\205'\333%-./0\3340/\"@.\236+\206'\335\3131\336c\210\337\216\332 *-./0\3340/\"@.\236+&2\2036%3\340 \210)\341&>\203_'\204_\212\342\310x\210n)\204_d`Z\312u\210\343 \210\340 \210d	Zb\210)\344&\243>\205r'?\205r\343 \210\340 .\207" [c-enable-xemacs-performance-kludge-p pos distance defun-prompt-regexp bod literal fboundp buffer-syntactic-context-depth nil scan-lists -1 t "^{" zerop beginning-of-defun 0 123 looking-at c-in-literal "[ 	]*$" self-insert-command prefix-numeric-value scope-operator 58 " 	\n" 2 c-guess-basic-syntax (case-label label access-label) c-intersect-lists (member-init-intro inher-intro) "\n" ((delete-char -1)) indent-according-to-mode before ": 	" newline after syntax newlines is-scope-op c-echo-syntactic-information-p arg here c-auto-newline c-cleanup-list c-hanging-colons-alist alist2 alist1 list buffer-undo-list c-syntactic-indentation c-syntactic-context] 7 (#$ . 12605) "*P"])
#@343 Insert a less-than, or greater-than character.
The line will be re-indented if the character inserted is the second
of a C++ style stream operator and the buffer is in C++ mode.
Exceptions are when a numeric argument is supplied, point is inside a
literal, or `c-syntactic-indentation' is nil, in which case the line
will not be re-indented.
(defalias 'c-electric-lt-gt #[(arg) "\205 	?\205 `Sf\n=\205 \305 ?\306\307\310	!!\210\f\205# \311 *\207" [c-syntactic-indentation arg last-command-char c-echo-syntactic-information-p indentp c-in-literal nil self-insert-command prefix-numeric-value indent-according-to-mode] 3 (#$ . 14620) "*P"])
#@333 Insert a parenthesis.

Some newline cleanups are done if appropriate; see the variable
`c-cleanup-list'.

Also, the line is re-indented unless a numeric ARG is supplied, there
are non-whitespace characters present on the line after the
parenthesis, the parenthesis is inserted inside a literal, or
`c-syntactic-indentation' is nil.
(defalias 'c-electric-paren #[(arg) "\306	\204z \307\212\310\311!\203c \n\203c \306\204\\ \214~\210\312`\313\311 \306\314%)o\203/ e\211\202 \204F \315\306x\316\f!\203B \317 \210`)\202 \320U\204 f\321=\204 b\210\306\211\203 b\210)\202f \317 \210\203t \322!\203t \320\225b\210`)!\203\202 \323\324	!!\202\221()\306(\323\324	!!\210\322\325!\203*\203\235 \326 \210+\203`d`Z\306\211,-.\327/>\203\344 0\330=\203\344 \331\332\306\314#\203\344 \212\320\224-\320\225\211,.U)\203\344 \307 \204\344 -,|\210\333c\210\334/>\2030\330=\203\331\335\306\314#\203\212\320\224-\320\225\211,.U)\203\307 \204-,|\210\336c\210dZb\210,\306`S12\337/>\203W0\330=\203W\212\313u\210\340\306x\210`2\341 )\203W\21221|\2102b\210\342c\210)\202\207\343/>\203\2070\344=\203\207\212\306\345\346\217\210\322\347!\205}`1\340\306x\210`2\341 )\203\20721|\210*)\205\220) *)\207" [c-echo-syntactic-information-p arg c-enable-xemacs-performance-kludge-p pos distance defun-prompt-regexp nil c-in-literal fboundp buffer-syntactic-context-depth scan-lists -1 t "^{" zerop beginning-of-defun 0 123 looking-at self-insert-command prefix-numeric-value "[ 	]*$" indent-according-to-mode brace-elseif-brace 40 re-search-backward "}[ 	\n]*else[ 	\n]+if[ 	\n]*(" "} else if (" brace-catch-brace "}[ 	\n]*catch[ 	\n]*(" "} catch (" space-before-funcall " 	" c-on-identifier " " compact-empty-funcall 41 (forward-char -2) ((error)) "()" blink-paren-function old-blink-paren c-syntactic-indentation c-auto-newline mend mbeg here c-cleanup-list last-command-char end beg] 8 (#$ . 15272) "*P"])
#@380 Reindent the current line if appropriate.

This function is used to reindent the line after a keyword which
continues an earlier statement is typed, e.g. an "else" or the
"while" in a do-while block.

The line is reindented if there is nothing but whitespace before the
keyword on the line, the keyword is not inserted inside a literal, and
`c-syntactic-indentation' is non-nil.
(defalias 'c-electric-continued-statement #[nil "\306	\205\227 \n\307=?\205\227 \212\310\311!\210`)\212\312 \210`)U\205\227 \313\212\314\315!\203{ \203{ \306\f\204t \214~\210\316`\317\315 \306\320%)o\203G e\211\202- \f\204^ \321\306x\322!\203Z \323 \210`)\202, \f\324U\204, \ff\325=\204, \fb\210\306\211\2030 \fb\210)\202~ \323 \210\203\216 \326!\203\216 \324\225b\210`)!?\205\227 \327 )\207" [c-echo-syntactic-information-p c-syntactic-indentation last-command-char c-enable-xemacs-performance-kludge-p pos distance nil 95 skip-syntax-backward "w" back-to-indentation c-in-literal fboundp buffer-syntactic-context-depth scan-lists -1 t "^{" zerop beginning-of-defun 0 123 looking-at indent-according-to-mode defun-prompt-regexp] 8 (#$ . 17233)])
#@83 Move forward to end of a nomenclature section or word.
With arg, to it arg times.
(defalias 'c-forward-into-nomenclature #[(&optional arg) "\303	\304V\203 \305\306d\307	$\210\202* 	\304W\203* \310\311e\304#\203* \312u\210	T\211\202 )\313\302!\2054 \307\211\207" [case-fold-search arg zmacs-region-stays nil 0 re-search-forward "\\W*\\([A-Z]*[a-z0-9]*\\)" t re-search-backward "\\(\\(\\W\\|[a-z0-9]\\)[A-Z]+\\|\\W\\w+\\)" 1 boundp] 6 (#$ . 18378) "p"])
#@139 Move backward to beginning of a nomenclature section or word.
With optional ARG, move that many times.  If ARG is negative, move
forward.
(defalias 'c-backward-into-nomenclature #[(&optional arg) "\302[!\210\303\301!\205 \304\211\207" [arg zmacs-region-stays c-forward-into-nomenclature boundp t] 2 (#$ . 18842) "p"])
#@106 Insert a double colon scope operator at point.
No indentation or other "electric" behavior is performed.
(defalias 'c-scope-operator #[nil "\300c\207" ["::"] 1 (#$ . 19170) "*"])
#@362 Move backward to the beginning of a defun.
With argument, do it that many times.  Negative arg -N
means move forward to Nth following beginning of defun.
Returns t unless search stops due to beginning or end of buffer.

Unlike the built-in `beginning-of-defun' this tries to be smarter
about finding the char with open-parenthesis syntax that starts the
defun.
(defalias 'c-beginning-of-defun #[(&optional arg) "\204 \305\306W\203 \307[!\207\306V\203Z \310 \237\311\211\203: 	\204: @A	:\203 	@\311\202 	\203D 	b\210\202S \n\203N \nb\210\202S eb\210\306S+\202 \312\304!\203b \313\306U\207" [arg bod prevbod state zmacs-region-stays 1 0 c-end-of-defun c-parse-state nil boundp t] 3 (#$ . 19356) "p"])
#@349 Move forward to next end of defun.  With argument, do it that many times.
Negative argument -N means move back to Nth preceding end of defun.
Returns t unless search stops due to beginning or end of buffer.

An end of a defun occurs right after the close-parenthesis that matches
the open-parenthesis that starts a defun; see `beginning-of-defun'.
(defalias 'c-end-of-defun #[(&optional arg) "\204 \304\305W\203 \306[!\207\305V\203j `\307\307\310\311\217\203: `Sf\312=\204: \313u\210\314`\304\"\2065 db\210\202 \306\304!\210\212\307\210`)\314`\304\"\206M db\210	`W\203X \304y\210`\nX\203c db\210\305S*\202 \315\303!\203r \316\305U\207" [arg eol pos zmacs-region-stays 1 0 c-beginning-of-defun nil (byte-code "\300\301!\210\302\207" [down-list 1 t] 2) ((error)) 123 -1 scan-sexps boundp t] 3 (#$ . 20087) "p"])
#@638 Go to the beginning of the innermost C statement.
With prefix arg, go back N - 1 statements.  If already at the
beginning of a statement then go to the beginning of the closest
preceding one, moving into nested blocks if necessary (use
\[backward-sexp] to skip over a block).  If within or next to a
comment or multiline string, move by sentences instead of statements.

When called from a program, this function takes 3 optional args: the
repetition count, a buffer position limit which is the farthest back
to search for the syntactic context, and a flag saying whether to do
sentence motion in or near comments and multiline strings.
(defalias 'c-beginning-of-statement #[(&optional count lim sentence-flag) "\206 \306\307\310\311\n!!\312U\204Q\n\203 `\nV\203Q`\204L\f\203L\212\312V\203\333 \313`\312Y\203U \314!\205x l\203Q \315\316	`\"8\203Q \307\317\307\217\210\320\202x \321\307x\210o\203a \307\202x \322\323	\320#\210\314!\205x l\203w \314\313!\202x \320*\203\305 `\306`\312Y\203\242 \314!\203\276 l\203\276 \315\316	`\"8\203\276 \307\324\307\217\210\202\276 \321\307x\210o\204\276 \322\323	\320#\210\314!\203\276 l\203\276 \314\313!\210*`B\202G\321\307x\210``Sf\325=\205\327 \307\326\327\217\202G\321\307w\210\307f\325=\203\367 `\330`\306\"\206\357 db\210`B\202G`\306`\312Y\203\314!\205?l\203\315\316	`\"8\203\307\331\307\217\210\320\202?\321\307x\210o?\205?\322\323	\320#\210\314!\205?l\203>\314\313!\202?\320*\205F`B\310!)\312W\203Z	dU\203Z\307\203\f\203@fz\325U\203}\212@b\210\332Aw\210`AW)\203\333!\3344\335Q5\336=\203\224@T\202\251\212@b\210\3376!\210\312\225\3375!\210\312\225])7A\340=\203\267\341\202\270\306Z8\336=\203\305\342\202\306\3439\214\212	8^\211:b\210\344\313!\210\337;!\203\341\307y\210`7V\203\3739 \210`:Y\203\373\344\345!\2109 \210`7]*8}\210\307\346\347\217\210\350>\203\206`eU\204\206`dU\204\206\212\351 \210\3375!)\203\206`\312\224Y\203\206\306\224\306\225U\204\206`\312\225W\204u`\312\225U\203\206l\204u\212\344\313!\210`\312\224W)\203\206\212\351 \210\352<\212\313y\210`)\320#?\206q\312\225\212\307\210`)W)\203\206\211\312W\203\200\313\202\201\306\\\202\326\312W\203\263\340=\203\326`d=\203\326~\210\353\307x\312U\204\254`d=\204\254n\203\326Ab\210\202\326`e=\203\326\337\354!\203\326~\210@b\210\336=\203\326`	U\204\326T\307)\312V\203\362`	W\203\351S\202@b\210\307\202`	V\203\376T\202Ab\210\307-\2022\312V\203@\202Ab\210\307\2022	b\210\312V\203-\307\355\356\217\210\2022\307\357\360\217\210\361!\204 `	U\203 \312V\203He\202Idb\210\312\211\202 +\362\363!\205\\\320\2113\207" [count here lim range sentence-flag lit-type 1 nil c-collect-line-comments c-literal-limits 0 -1 forward-comment 7 parse-partial-sexp (forward-char 1) t " 	\n\f" re-search-forward "[\n]" (forward-char 1) 34 (byte-code "\301`\302\"\206 eb\210`B\207" [range scan-sexps -1] 3) ((error)) scan-sexps (forward-char 1) "^\n" c-literal-type "[ 	]*\\(" "\\)[ 	]*" string looking-at c 2 #[nil "\300\207" [nil] 1] #[nil "\301 \210\302!\205\f \303\225b\207" [line-prefix beginning-of-line looking-at 0] 2] forward-paragraph -2 (byte-code "\301\302W\203 \303\202\f \304!\207" [count forward-sentence 0 1 -1] 3) ((error)) (c c++) beginning-of-line re-search-backward " 	" "[ 	]*$" (byte-code "?d[\306\211\307\310\215\210\f\247\203 `\fW\203 \fb\210\202\" S,\306\207" [sentence-flag last-below-line last large-enough literal-pos count nil done (byte-code "`\306f\307=\204 \306f\310=\203K `\212\311 \210`)=\203K 	U\204K \n\2031 \306f\307=\2031 \312 \204K \306f\310=\203F \247\203F 	=\204F b\210\313\314\315\"\210\f\203\230 &`&\316Y\203w \317&!\203\224 l\203\224 \320\321	`\"8\203\224 \306\322\306\217\210\202\224 \323\306x\210o\204\224 \324\325	\315#\210\317&!\203\224 l\203\224 \317\326!\210*\202y\326&`&\316Y\203\301 \317&!\205\345 l\203\275 \320\321	`\"8\203\275 \306\327\306\217\210\315\202\345 \323\306x\210o\203\315 \306\202\345 \324\325	\315#\210\317&!\205\345 l\203\344 \317\326!\202\345 \315*\203y\212\330&`&\316Y\203\317&!\203/l\203/\320\321	`\"8\203/\306\331\306\217\210\202/\323\306x\210o\204/\324\325	\315#\210\317&!\203/l\203/\317\326!\210*`)&`&\316Y\203[\317&!\203xl\203x\320\321	`\"8\203x\306\332\306\217\210\202x\323\306x\210o\204x\324\325	\315#\210\317&!\203xl\203x\317\326!\210*\204\211\212\324\333\315#)\203\211o\203\246	U\203\233\313\314\315\"\210\202  b\210\313\314\315\"\210\202  \326u\210\334\335!\203\363\n\203\306\306f\307=\203\306\312 \203\306\336\337!\210\202  	U\204\323f\340>\203\350`Sf\341=\203  \306f\342=\203  \326u\210\202  b\210\313\314\315\"\210\202  \306fz\343U\203%`'\306u\210\344`\326\"\206	eb\210\212\345'w\210`'W\203!'T\313\314\315\"\210*\202  \336\337!\210\202  " [last here c-special-brace-lists last-below-line literal-pos large-enough nil 123 35 back-to-indentation c-looking-at-special-brace-list throw done t 0 forward-comment 7 parse-partial-sexp (forward-char 1) " 	\n\f" re-search-forward "[\n]" -1 (forward-char 1) 1 (forward-char 1) (forward-char 1) "\\(^\\|[^\\]\\)$" looking-at "[;{}]" skip-syntax-backward "w_" (41 125) 125 59 34 scan-sexps "^\n" count end] 4)] 4) ((error (byte-code "eb\210\301\301\207" [count 0] 1))) (byte-code "?d\305\306\307\215\210\247\203 `V\203 b\210\202 \fT+\305\207" [sentence-flag last large-enough literal-pos count nil done (byte-code "`	\203K \n`\306Y\203+ \307!\203G l\203G \310\311\f`\"8\203G \312\313\312\217\210\202G \314\312x\210o\204G \315\316\f\317#\210\307!\203G l\203G \307\320!\210*\202\345 \314\312w\210`\321`\306Y\203w \307!\205\232 l\203s \310\311\f`\"8\203s \312\322\312\217\210\317\202\232 \314\312x\210o\203\203 \312\202\232 \315\316\f\317#\210\307!\205\232 l\203\231 \307\320!\202\232 \317*\203\343 \n`\306Y\203\303 \307!\203\337 l\203\337 \310\311\f`\"8\203\337 \312\323\312\217\210\202\337 \314\312x\210o\204\337 \315\316\f\317#\210\307!\203\337 l\203\337 \307\320!\210*\202\345 \312\312f\324=\203\203\365 \325 \204\fU\204\212\312\326\327\217?\206\312f\324U)\203b\210\330\331\317\"\210\202  \203:\312f\332=\203:\212\312\333\334\217\205,\325 )\203:\321u\210\335\336!\210\202  \312f\332=\203R\fU\204Rb\210\330\331\317\"\210\202  \312f\337=\203\203`\212\340 \210`)U\203\203\fU\203x\315\341\312\317#\204{db\210\202{b\210\330\331\317\"\210\202  \342\343!\203\225\306\225b\210\330\331\317\"\210\202  \312fz\344U\203\303`'\345`\321\"\206\250db\210\212\346'x\210`'V\203\277'\330\331\317\"\210*\202  \321u\210\335\336!\210\202  " [last literal-pos large-enough count here c-special-brace-lists 0 forward-comment 7 parse-partial-sexp nil (forward-char 1) " 	\n\f" re-search-forward "[\n]" t -1 1 (forward-char 1) (forward-char 1) 123 c-looking-at-special-brace-list (byte-code "\300\301!\210\302\207" [up-list -1 t] 2) ((error)) throw done 125 (byte-code "\300\301!\210\302\207" [up-list -1 t] 2) ((error)) skip-syntax-forward "w_" 35 back-to-indentation "\\(^\\|[^\\]\\)$" looking-at ";\\|};?" 34 scan-sexps "^\n" beg] 4)] 3) ((error (byte-code "db\210\301\301\207" [count 0] 1))) zerop boundp zmacs-region-stays c-current-comment-prefix line-prefix comment-start-skip beg end beg-of-para pos paragraph-separate sentence-end] 6 (#$ . 20922) (list (prefix-numeric-value current-prefix-arg) nil t)])
#@590 Go to the end of the innermost C statement.
With prefix arg, go forward N - 1 statements.  Move forward to the end
of the next statement if already at end, and move into nested blocks
(use \[forward-sexp] to skip over a block).  If within or next to a
comment or multiline string, move by sentences instead of statements.

When called from a program, this function takes 3 optional args: the
repetition count, a buffer position limit which is the farthest back
to search for the syntactic context, and a flag saying whether to do
sentence motion in or near comments and multiline strings.
(defalias 'c-end-of-statement #[(&optional count lim sentence-flag) "\304\206 \305[	\n#\210\306\303!\205 \307\211\207" [count lim sentence-flag zmacs-region-stays c-beginning-of-statement 1 boundp t] 4 (#$ . 28360) (list (prefix-numeric-value current-prefix-arg) nil t)])
(byte-code "\300\301\302\"\210\303\304\305\306#\210\303\304\307\306#\210\303\310\305\306#\210\303\310\307\306#\210\303\311\305\306#\210\303\311\307\306#\207" [mapcar #[(sym) "\301\302\303#\210\301\304\303#\207" [sym put delete-selection t pending-delete] 4] (c-electric-pound c-electric-brace c-electric-slash c-electric-star c-electric-semi&comma c-electric-lt-gt c-electric-colon c-electric-paren) put c-electric-delete delete-selection supersede pending-delete c-electric-backspace c-electric-delete-forward] 4)
(defalias 'c-comment-indent #[nil "\306\307\310Q!\203 \311\207`\312\212\313 \210\306\314\310Q!\203% \315\316!\210iT\202\273 \306\317!\2041 \306\320!\2035 \321\202\273 \203o \212\322\312w\210\306!\206E l)\203o \323 \212\324 \210l)\203[ \325\312B\fB:\203d \202g \211B\326\f!*\202\273 \212\313 \210o\204z \327y\210\322\312w\210\306!i)\203\240 \nb\210\322\312x\210n\203\226 \311\202\230 iT	]]\202\273 \nb\210\322\312x\210\311U\203\266 n\203\266 \311\202\273 iT]+\207" [c-comment-start-regexp placeholder opoint c-indent-comments-syntactically-p syntax c-comment-only-line-offset looking-at "^\\(" "\\)" 0 nil beginning-of-line "[ 	]*}[ 	]*\\($\\|" search-forward "}" "[ 	]*#[ 	]*endif[ 	]*" "[ 	]*#[ 	]*else[ 	]*" 7 " 	" c-guess-basic-syntax back-to-indentation comment-intro c-get-syntactic-indentation -1 comment-column] 4])
(defalias 'c-outline-level #[nil "\301\212\302\301w\210i*\207" [buffer-invisibility-spec nil "	 "] 2])
#@344 Move back to the containing preprocessor conditional, leaving mark behind.
A prefix argument acts as a repeat count.  With a negative argument,
move forward to the end of the containing preprocessor conditional.

`#elif' is treated like `#else' followed by `#if', so the function
stops at them when going backward, but not when going forward.
(defalias 'c-up-conditional #[(count) "\302[\303\"\210\304\301!\205 \305\211\207" [count zmacs-region-stays c-forward-conditional -1 boundp t] 3 (#$ . 30697) "p"])
#@148 Move back to the containing preprocessor conditional, including `#else'.
Just like `c-up-conditional', except it also stops at `#else'
directives.
(defalias 'c-up-conditional-with-else #[(count) "\302[\303\304#\210\305\301!\205 \304\211\207" [count zmacs-region-stays c-forward-conditional -1 t boundp] 4 (#$ . 31214) "p"])
#@333 Move forward into the next preprocessor conditional, leaving mark behind.
A prefix argument acts as a repeat count.  With a negative argument,
move backward into the previous preprocessor conditional.

`#elif' is treated like `#else' followed by `#if', so the function
stops at them when going forward, but not when going backward.
(defalias 'c-down-conditional #[(count) "\302\303\"\210\304\301!\205 \305\211\207" [count zmacs-region-stays c-forward-conditional 1 boundp t] 3 (#$ . 31548) "p"])
#@149 Move forward into the next preprocessor conditional, including `#else'.
Just like `c-down-conditional', except it also stops at `#else'
directives.
(defalias 'c-down-conditional-with-else #[(count) "\302\303\304#\210\305\301!\205 \304\211\207" [count zmacs-region-stays c-forward-conditional 1 t boundp] 4 (#$ . 32054) "p"])
#@184 Move back across a preprocessor conditional, leaving mark behind.
A prefix argument acts as a repeat count.  With a negative argument,
move forward across a preprocessor conditional.
(defalias 'c-backward-conditional #[(count &optional target-depth with-else) "\304[	\n#\210\305\303!\205 \306\211\207" [count target-depth with-else zmacs-region-stays c-forward-conditional boundp t] 4 (#$ . 32389) "p"])
#@676 Move forward across a preprocessor conditional, leaving mark behind.
A prefix argument acts as a repeat count.  With a negative argument,
move backward across a preprocessor conditional.

`#elif' is treated like `#else' followed by `#if', except that the
nesting level isn't changed when tracking subconditionals.

The optional argument TARGET-DEPTH specifies the wanted nesting depth
after each scan.  I.e. if TARGET-DEPTH is -1, the function will move
out of the enclosing conditional.  A non-integer non-nil TARGET-DEPTH
counts as -1.

If the optional argument WITH-ELSE is non-nil, `#else' directives are
treated as conditional clause limits.  Normally they are ignored.
(defalias 'c-forward-conditional #[(count &optional target-depth with-else) "\306V\211\203\f \307\202 \310	\203 \311\202 \312\313\250\204) \203' \307\202( \306\212\306U\204(\306\211\313\212\204\314\313\315#\203\316 \210\317\320!\203\313\321\310! \322\230\203f \n[ \202\255 \323\230\203s \n \202\255 \306U\203\255 !\203\220 \306V\203\211 \310\202\212 \307\211 \202\234 \324\230\203\255 \n[\211 \203\255  \306V\306X=\203\255 \313  \203\353 \306U\203\304  \306V\306X=\203\313  \\ \\\211W\203\353  \306W\203\353 \325	\203\350 \326\202\351 \327!\210	\203\362 \310y\210 \203U\203`*\202: 	\203: \310y\210\202: )\204\325\330!\210\211b\210+\n\\\211\202+ )\331 \210\fb\210,\332\333!\205:\315\211\207" [count forward increment search-function new target-depth 0 -1 1 re-search-forward re-search-backward nil "#[ 	]*\\(if\\|elif\\|endif\\|else\\)" t beginning-of-line looking-at "^[ 	]*#[ 	]*\\(if\\|elif\\|endif\\|else\\)" match-string "if" "endif" "elif" error "No following conditional at this level" "No previous conditional at this level" "No containing preprocessor conditional" push-mark boundp zmacs-region-stays found subdepth depth directive dchange with-else] 5 (#$ . 32803) "p"])
#@1355 Indent current line as C code, and/or insert some whitespace.

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 some whitespace[*].  If
other than nil or t, then some whitespace[*] is inserted only within
literals (comments and strings) and inside preprocessor directives,
but the line is always reindented.

If `c-syntactic-indentation' is t, indentation is done according to
the syntactic context.  If it's nil, the line is just indented one
step according to `c-basic-offset'.  In this mode, a numeric argument
indents a number of such steps, positive or negative, and an empty
prefix argument is equivalent to -1.

If `c-syntactic-indentation' is t, then 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 is preserved.

  [*] The amount and kind of whitespace inserted is controlled by the
  variable `c-insert-tab-function', which is called to do the actual
  insertion of whitespace.  Normally the function in this variable
  just inserts a tab character, or the equivalent number of spaces,
  depending on the variable `indent-tabs-mode'.
(defalias 'c-indent-command #[(&optional arg) "\212\306\307!\203\\ \203\\ \310	\204U \214~\210\311`\312\307 \310\313%)o\203( e\211\202 	\204? \314\310x\315\n!\203; \316 \210`)\202 	\317U\204 	f\320=\204 	b\210\310\211\203 	b\210)\202_ \316 \210\203m \321!\203m \317\225b\210`)\f\203x \322K\202y \323\f\203\334 \203\334 \212\324 \210i)\310\211 !\325 \210\212\324 \210i)!Z!\212\"\313=\203\254 \326 \210` \327`\330\"\206\267 db\210` b\210\330y\210` ) V\205\330 \331 !\332$+\202\"\204\366 \212\333\310x\210n)\204\361 # \202 \202\"\313=\203 \202\334!\203# \210 *\207" [c-enable-xemacs-performance-kludge-p pos distance defun-prompt-regexp c-syntactic-indentation indent-function fboundp buffer-syntactic-context-depth nil scan-lists -1 t "^{" zerop beginning-of-defun 0 123 looking-at indent-according-to-mode #[nil "\204 \304\202 \305\232\203 \306\202 	\307\n_!)\207" [current-prefix-arg arg steps c-basic-offset 1 (4) -1 c-shift-line-indentation] 3] back-to-indentation c-indent-line beginning-of-line scan-sexps 1 indent-code-rigidly "#" " 	" c-in-literal bod current-prefix-arg end beg shift-amt c-tab-always-indent c-insert-tab-function] 7 (#$ . 34753) "p"])
#@169 Indent each line in the balanced expression following point syntactically.
If optional SHUTUP-P is non-nil, no errors are signalled if no
balanced expression is found.
(defalias 'c-indent-exp #[(&optional shutup-p) "\304 \305\306	\307\"\210\310\216\311\305w\210\214e\212\305\210`)}\210\305\312\313\217)\305\314\315\217\205( `\n\2048 ?\205Y \316\317!\202Y \nb\210\305y\210`\204O ?\205Y \316\320!\202Y \nW\205Y \321\n\",\207" [end here start shutup-p point-marker nil set-marker-insertion-type t ((byte-code "b\210\301\211\223\207" [here nil] 3)) " 	\n" (byte-code "\300`\301\302#S\207" [scan-lists 1 -1] 4) ((error)) (byte-code "\300`\301\"\206 db\210\302\207" [scan-sexps 1 t] 3) ((error)) error "Cannot find start of balanced expression to indent" "Cannot find end of balanced expression to indent" c-indent-region] 3 (#$ . 37340) "*P"])
#@87 Indent the current top-level function def, struct or class declaration
syntactically.
(defalias 'c-indent-defun #[nil "\306 \307\310\311 !\206 \212\312\313!\203j \203j \307\f\204c \214~\210\314`\315\313 \307\316%)o\2036 e\211\202 \f\204M \317\307x\320!\203I \321 \210`)\202 \f\322U\204 \ff\323=\204 \fb\210\307\211\203 \fb\210)\202m \321 \210\203} \324!\203} \322\225b\210`)b\210o\203\217 \307f\323=\204\217 \nb\210\325\326!\203\245 \203\245 \324!\203\245 \322\225b\210\327\216\330 ,\207" [brace c-echo-syntactic-information-p here c-enable-xemacs-performance-kludge-p pos distance point-marker nil c-least-enclosing-brace c-parse-state fboundp buffer-syntactic-context-depth scan-lists -1 t "^{" zerop beginning-of-defun 0 123 looking-at boundp defun-prompt-regexp ((byte-code "b\210\301\211\223\207" [here nil] 3)) c-indent-exp] 7 (#$ . 38199) "*"])
#@148 Indent every line whose first char is between START and END inclusive.
Be silent about syntactic errors if the optional argument QUIET is non-nil.
(defalias 'c-indent-region #[(start end &optional quiet) "\212b\210\306\307w\210\310 \210\311	!\307\211\312\216\313	\314#\210n\203> m\204> `\fW\203> \315 \210\306\307w\210\310 \210\316\307\317\"\210\307y\210\202 )\320!+\206G \211)\207" [start end c-echo-syntactic-information-p c-parsing-error endmark quiet " 	\n" nil beginning-of-line copy-marker ((byte-code "\301\211\223\210\302\303!\207" [endmark nil c-progress-fini c-indent-region] 3)) c-progress-init c-indent-region c-progress-update c-indent-line t c-echo-parsing-error] 4 (#$ . 39086)])
#@65 Put mark at end of current top-level defun, point at beginning.
(defalias 'c-mark-function #[nil "`\212`\304\305w\210\306 \210\305f\307=\203 \310`\311\"\206 db\210`W\203% db\210)`)\312 	@:\203: 	G\311U\204> 	\204\221 	\203f \313\314!\203f \212\315 \210\316\305x\210`)	@AU\203f `	@@b\210\317 \210\202\251 \212\320 \210`Sf)\307U\203\203 \320 \210\321\305x\210\317 \210\322 \210\202\251 \320 \210\311y\210`\317 \210\202\251 	\203\246 	@:\204\237 	@b\210	A\211\204\225 \317 \210\323!\210\323\n\305\324#+\207" [start state eod here "^}" nil c-beginning-of-defun-1 123 scan-sexps 1 c-parse-state looking-at "[ 	]*$" c-backward-syntactic-ws ";" c-beginning-of-statement-1 c-end-of-statement-1 "{" c-forward-syntactic-ws push-mark t] 5 (#$ . 39797) nil])
(defalias 'c-fn-region-is-active-p #[nil "\302\303!\203 \304\300!\203 \203 \303 \207\304\301!\203 	\207\305\306!\207" [zmacs-regions mark-active fboundp region-active-p boundp mark t] 2])
#@75 When the region is active, indent it.  Otherwise indent the current line.
(defalias 'c-indent-line-or-region #[nil "\302\303!\203 \304\300!\203 \203 \303 \202\" \304\301!\203 	\202\" \305\306!\203, \307\310 \311 \"\207\312 \207" [zmacs-regions mark-active fboundp region-active-p boundp mark t c-indent-region region-beginning region-end indent-according-to-mode] 3 (#$ . 40754) nil])
(byte-code "\301B\302\301!\204\f \303\303\207" [current-load-list c-progress-info boundp nil] 2)
(defalias 'c-progress-init #[(start end context) "?\206& \305\306!\204 \307\310!\207	\206& \311\n\212b\210\312 )\306 A@\f$\307\313!\207" [c-progress-interval c-progress-info start end context fboundp current-time message "Indenting region... (this may take a while)" vector point-marker "Indenting region..."] 5])
(defalias 'c-progress-update #[nil "\2053 	\2053 \306 A@\307H\310H\311H	\nZW\2052 \312\313`\fZ\314_\fZ\245\"\210\311I,\207" [c-progress-info c-progress-interval lastsecs end start now current-time 0 1 2 message "Indenting region... (%d%% complete)" 100] 5])
(defalias 'c-progress-fini #[(context) "\205 	\n\303H=\204 	\304=\205 \n\305H\306\211\223\210\306\307\310!\207" [c-progress-interval context c-progress-info 3 t 1 nil message "Indenting region... done"] 3])
#@519 Insert, align, or delete end-of-line backslashes on the lines in the region.
With no argument, inserts backslashes and aligns existing backslashes.
With an argument, deletes the backslashes.

This function does not modify blank lines at the start of the region.
If the region ends at the start of a line, it always deletes the
backslash (if any) at the end of the previous line.

You can put the region around an entire macro definition and use this
command to conveniently insert and align the necessary backslashes.
(defalias 'c-backslash-region #[(from to delete-flag) "\212b\210	\306 \n\f\307\223\210\2045 `\fW\2035 \307\210`Sf\310=\203* \311u\210\312\307x\210iT]\313y\210\202 \246\314V\203W \\\311\\\245_\211\315 W\203V )b\210`\nW\203j l\203j \313y\210\202Z `\nW\203\217 \204\206 \212\313y\210`\nW)\203\206 \316!\210\202\211 \317 \210\313y\210\202j \n\307\211\223+\207" [from c-backslash-column endmark column to delete-flag make-marker nil 92 -1 " 	" 1 0 window-width c-append-backslash c-delete-backslash tab-width adjusted] 4 (#$ . 42051) "*r\nP"])
(defalias 'c-append-backslash #[(column) "\301\210`Sf\302=\203 \303u\210\304 \210j\207j\210\305c\207" [column nil 92 -1 delete-horizontal-space "\\"] 2])
(defalias 'c-delete-backslash #[nil "\300\210n\206 \301u\210\302\303!\205 `T\304\300x\210`|\207" [nil -1 looking-at "\\\\" " 	"] 3])
(byte-code "\301B\304\301!\204\f \305\302B\304\302!\204 \306\303B\304\303!\204$ \306\306\207" [current-load-list c-auto-fill-prefix c-lit-limits c-lit-type boundp t nil] 2)
(defalias 'c-guess-fill-prefix #[(lit-limits lit-type) "`\306	\307Q\310=\203 \n\202 \f\311*\311+\311,\311-.\203@ .\312 \313`/01\314\216\315.\261\210i,B,\202\314\310=\203\345 \212\316+2A-\317 \210`2@V\203` `*\202\341 2@b\210\320y\321U\203z `2AW\203z `*\202\341 2@b\210\322\n!\203\214 \321\225b\210\202\223 \323u\210\324\311w\210\212\325 \210`)2@=\203\256 \326\212\317 \210`)`\"iB\202\337 \312 \313`2@Z\3113401\327\2162@b\210i\315c\210j\210`34u\210\326\212\317 \210`)`\"i-B,)\202\314\2122A\323Z-\317 \210`2@V\203\322\330!\2032A\321\225=\204`*\202\3132@b\210\320y\321U\203Q`2AY\204Q\322\330!\20302A\321\225=\204Q\322\n!\203@2AS\321\225X\204Q`W\203\310\321\224\203Q\322\331!\203\3105\206W\332+\312 \313\311\2116701\333\2162@b\210\322!\203z\321\225b\210\202\201\323u\210\324\311w\210`Sfz\334=\203\240+\321\335\336+\"O\326\212\324\311x\210`)`\"P+\337 7\340+\341\261\210\337 6\342 \2106Sb\210\326\212\317 \210`)`\"i-B,\202\313`*),\206|\212\3118\3119\343:\344\345\215\206{8\203\\\335\3468\"\203\37189b\210iB\202Y2@b\210\322!\203\321\225b\210\202\323u\210\324\311w\210`Sfz\334=\203N\326\212\324\311x\210`)`\"89b\210\324\311x\210\312 \313`301\347\2168c\210\326\212\317 \210`)`\"i,B\202Y8\350P9b\210iTB\206{+\203z\326*\212\325 \210`)\"+P\325 \210i+G\\B\202{\351,.\207" [here c-current-comment-prefix prefix-regexp lit-type comment-start-skip comment-start-regexp "[ 	]*\\(" "\\)[ 	]*" c++ nil buffer-modified-p t ((byte-code "`|\210\302	!\207" [start buffer-modified set-buffer-modified-p] 2)) 10 "// " beginning-of-line 1 0 looking-at 2 " 	" back-to-indentation buffer-substring-no-properties ((byte-code "@	|\210\303\n!\207" [lit-limits tmp buffer-modified set-buffer-modified-p] 2)) "[ 	]*\\*/" "[ 	]*$" "" ((byte-code "\203 	|\210	\303\211\223\210\303\211\223\210\304\n!\207" [tmp-post tmp-pre buffer-modified nil set-buffer-modified-p] 3)) 32 string-match "\\s *\\'" point-marker "x\n" 120 indent-according-to-mode #[nil "\304!\2058 \305\225	X\2058 \305\225\212\306\210`)=\204) \307\310\311\305\224\305\225\"\305\225b\210iB\"\210\n\2047 \311\305\224\305\225\"\305\225\312\207" [prefix-regexp comment-text-end fb-string fb-endpos looking-at 0 nil throw found buffer-substring-no-properties t] 5] found (byte-code "b\210	 \203* \306\225\307\225U\203  \306\224\306\225U\203* \307\224\307\225U\204* \310\311\nb\210iB\"\210\f\312=\203D \313\314y!\203X `@Y\203X 	 \210\2020 \313\314y!\203X `@V\203X 	 \210\202D b\210\313\306y!\203o `AW\203o 	 \210\202[ b\210\315\207" [prefix-line test-line fb-string fb-endpos lit-type lit-limits 1 0 throw found c++ zerop -1 nil] 4) "\\s \\'" ((byte-code "`|\210\302	!\207" [tmp buffer-modified set-buffer-modified-p] 2)) " " ("" . 0) prefix-line comment-prefix res comment-text-end fill-prefix start buffer-undo-list buffer-modified lit-limits tmp prefix-len c-block-comment-prefix tmp-post tmp-pre fb-string fb-endpos test-line] 5])
#@826 Like \[fill-paragraph] but handles C and C++ style comments.
If any of the current line is a comment or within a comment, fill the
comment or the paragraph of it that point is in, preserving the
comment indentation or line-starting decorations (see the
`c-comment-prefix-regexp' and `c-block-comment-prefix' variables for
details).

If point is inside multiline string literal, fill it.  This currently
does not respect escaped newlines, except for the special case when it
is the very first thing in the string.  The intended use for this rule
is in situations like the following:

char description[] = "\
A very long description of something that you want to fill to make
nicely formatted output.";

If point is in any other situation, i.e. in normal code, do nothing.

Optional prefix ARG means justify paragraph as well.
(defalias 'c-fill-paragraph #[(&optional arg) "\306\211\211\211\211\211\211\211`9:;<\203' <\307=\204' `<B<\214~\210\310\311\306\307\"!;\312;!:)\212\306\313\314\217\204G b\210\315 \210\316 )\212\306\317\320\217\204Y b\210\321 \210`)\322\216:\323=\203\227 \212\f\211;A^\306\223\210;@X\203\223 ;@b\210\324 \210`;@=\203\221 \212\325 \210`)\202\223 \307)\202\331:\326=\203\226\f;AY\203n\212;Ab\210\325 \210\327\330=\331Q!\205\306 ;A\332\225=\205\306 \f`\306\223)\204n\212;Ab\210\333\334!\210`)\211>Z?\306@\212;Ab\210\316 \335c\210\f`\306\223\210\336y\210\327\337=\340Q!\203>\332\225=\203\341\225\342\225Z@\202>b\210\343\306x\210`>U\204``X\203(\336?@\2043>`Z@@\342^\341]@\344@\345\"c\210`>@\\|\210@?\332Y\205[`?@^Z?\202c\306?)?\203m?b\210+;@X\203\331\212;@b\210\327\346A\347Q!\203\220\212\341y\210`)\202\222\307)\202\331:\350=\203\327\212\f;AY\203\267;ASb\210\316 \335c\210\f`\306\223\210;@X\203\323;@Tb\210\327\351!\203\321\332\225T\202\322`)\202\331\306\203J\352;:\"9\353\354=\355Q9@\"\204\371\356\3579@\"\210\212;@b\210\327:\323=\203\f=\202A!\203\332\225b\210\202 \342u\210\360\306w\210i9AW\203.\341u\210\202 iB`T`C\361\216\3359@\261\210\344BiZ\345\"c\210+\203\315C\362=?\205XCD\206\213:\323=\205\213\363\364!\205l4?\205\213\353\365\366\f\"\206z\367\"?\205\2139\206\212\352;:\"@W\203\227Z\202\240\fV\205\240\fZ?DC\214\f}\210\370E!\210)?\203\314?\332W\203\306?\\b\210\202\314\f?\\b\210+.\n\307\207" [here hang-ender-stuck tmp-post tmp-pre end beg nil t c-collect-line-comments c-literal-limits c-literal-type (byte-code "\301u\210\302 \210`Y\207" [here -1 forward-paragraph] 2) ((error)) forward-paragraph point-marker (byte-code "\301u\210\302 \210`X\207" [here nil backward-paragraph] 2) ((error)) backward-paragraph ((byte-code ":\203 @A|\210	\203; \212	b\210\305\306!\210)\n\2036 `	b\210\307\310!\210\n[u\210\311\n\312\"c\210\305\n!\210b\210	\313\211\223\210\f\313\211\223\207" [tmp-pre tmp-post hang-ender-stuck here end delete-char 1 skip-syntax-backward "^w " make-string 32 nil] 3)) c++ back-to-indentation beginning-of-line c looking-at "[ 	]*\\(" "\\)\\*/" 0 skip-syntax-backward "^w " 10 -1 "[ 	]*\\(\\(" "\\)[ 	]*\\)" 1 2 " 	\n" make-string 120 "\\(" "\\)$" string "\\\\$" c-guess-fill-prefix string-match "\\`[ 	]*\\(" "\\)[ 	]*\\'" message "Warning: Regexp from `c-comment-prefix-regexp' doesn't match the comment prefix %S" " 	" ((byte-code "`\241\207" [tmp-pre] 2)) c-fill-paragraph boundp filladapt-mode "\\`[ 	]*//" fill-context-prefix "" fill-paragraph fill lit-type lit-limits buffer-undo-list c-current-comment-prefix ender-start point-rel spaces comment-start-skip col fill-paragraph-function fill-prefix arg] 10 (#$ . 46620) "*P"])
(defalias 'c-do-auto-fill #[nil "\302 )\207" [fill-prefix c-auto-fill-prefix do-auto-fill] 1])
#@485 Break line at point and indent, continuing comment if within one.
If inside a comment and `comment-multi-line' is non-nil, the
indentation and line prefix are preserved (see the
`c-comment-prefix-regexp' and `c-block-comment-prefix' variables for
details).  If inside a single line comment and `comment-multi-line' is
nil, a new comment of the same type is started on the next line and
indented as appropriate for comments.

If a fill prefix is specified, it overrides all the above.
(defalias 'c-indent-new-comment-line #[(&optional soft) "\306	\n\f\307=\204k 	\204 \310\311\211\307#\n\204  \312	!\n\313=\203* \314\2023 \n\2042 \315\2023 \n>\203= \307\202k \f\204X \n\316=\203X \212\317 \210`)	@X\203X \311\202k \n\320=\203k \321\322\206e \323\"\204k \311\307=\206\272\203~  \210\324!\202\272	\204\210 \310\311\211\307#\n\204\220 \312	!\n\325>\203\236*\204\253 \212	@b\210\311\210`	AW)\203=\326\327	!\211\n\"`+,\212\330 \210`	@V\210\331-!)\2031i,AW\203\333 l\204\333 \332u\210\202\311 `\n\316=\203\364 \212\333u\210\331\334!)\203\364 	A\335Z\202\366 	AV\203&\336+\307\"+\317 \210\324,@!\210.\203\324\337!\210\202\340\332!\210+b\210+\311\211\223\2029 \210\324,@!\2029 \210\324,@!*\202\272/0\31110/\n\316=\203_\321\341/\"\204m\342/\3430\202m\321\344/\"\204m\345/\3230\212\330 \210i)1 \2100\203\2170\323\232\204\217\346u\210\3240!\210\332u\2101j\210\324/!\210\347 +\202\272\212\330 \210\331\350!\203\257\346y\351U\204\237i)1 \2101j),\207" [fill-prefix c-lit-limits c-lit-type do-line-break c-auto-fill-prefix c-ignore-auto-fill #[nil "\301\302x\210`\301\302w\210`|\210\203 \303\304!\207\305\306!\207" [soft " 	" nil insert-and-inherit 10 newline 1] 3] t c-literal-limits nil c-literal-type pound cpp code c beginning-of-line c++ string-match "\\`[ 	]*//" "" insert-and-inherit (c c++) c-guess-fill-prefix c-collect-line-comments back-to-indentation looking-at 1 -2 "\\*/" 2 copy-marker 10 newline "[ 	]*/\\*" "/* " " */" "[ 	]*//" "// " -1 indent-for-comment "^\\s *$" 0 comment-multi-line pos fill c-current-comment-prefix soft comment-start comment-end col] 4 (#$ . 50384) nil])
(byte-code "\302\303\304\"\210\305\303\304\"\210\306\307!\204( \301B\306\301!\204 \310\311\312\313\314\310$\210\315\312\310\"\210\310\207" [current-load-list c-inside-line-break-advice defalias c-comment-line-break-function c-indent-new-comment-line make-obsolete boundp comment-line-break-function nil ad-add-advice indent-new-comment-line (c-line-break-advice nil t (advice lambda nil "Call `c-indent-new-comment-line' if in CC Mode." (if (or c-inside-line-break-advice (not c-buffer-is-cc-mode)) ad-do-it (let ((c-inside-line-break-advice t)) (c-indent-new-comment-line (ad-get-arg 0)))))) around ad-activate] 5)
#@391 Do a line break suitable to the context.

When point is outside a comment, insert a newline and indent according
to the syntactic context.

When point is inside a comment, continue it with the appropriate
comment prefix (see the `c-comment-prefix-regexp' and
`c-block-comment-prefix' variables for details).  The end of a
C++-style line comment doesn't count as inside the comment, though.
(defalias 'c-context-line-break #[nil "\305\306\211\307#\310!\211\311=\204\" 	\312=\203, `\313!\211ASW\203, \307\306\314 *\202T `\315\306x\210`|\210\316 \210\212\317y\210\320 \210\321\322!\203K \317y\323U\204; i)\211j\210)\324 *\207" [c-lit-limits c-lit-type fill-prefix comment-multi-line col c-literal-limits nil t c-literal-type c c++ c-collect-line-comments c-indent-new-comment-line " 	" newline -1 back-to-indentation looking-at "^\\s *$" 0 indent-according-to-mode] 5 (#$ . 53171) "*"])
(provide 'cc-cmds)