WWWWWW

Current Directory: /usr/share/emacs/24.3/lisp/progmodes
Viewing File: /usr/share/emacs/24.3/lisp/progmodes/cc-cmds.elc
;ELC
;;; Compiled by mockbuild@buildfarm01-new.corp.cloudlinux.com on Tue Nov 11 12:53:22 2025
;;; from file /builddir/build/BUILD/emacs-24.3/lisp/progmodes/cc-cmds.el
;;; in Emacs version 24.3.1
;;; with all optimizations.

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

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

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


(byte-code "\300\301!\210\300\302!\210\300\303!\207" [require cc-defs cc-vars cc-engine] 2)
(defvar c-fix-backslashes t)
#@561 Indent the current line according to the syntactic context,
if `c-syntactic-indentation' is non-nil.  Optional SYNTAX is the
syntactic information for the current line.  Be silent about syntactic
errors if the optional argument QUIET is non-nil, even if
`c-report-syntactic-errors' is non-nil.  Normally the position of
point is used to decide where the old indentation is on a lines that
is otherwise empty (ignoring any line continuation backslash), but
that's not done if IGNORE-POINT-POS is non-nil.  Returns the amount of
indentation change (in columns).
(defalias 'c-indent-line #[(&optional syntax quiet ignore-point-pos) "\212\306\210`Sf)\307=\306\211\f\204C\212\310 \210\311\203\"\312\202#\313!)\203C`\314\225X\203C
\204<\212\315\225b\210iS)`\315\225|\210\316\203\273\306 \206V\317\320!\205V!\321 \"\316\211#$\316%\306\211&'\306\211()\306\211*+\322\216\204\204\323 \324!+\325,!\204\236-\203\236\326\327+#\210+\330 Z.\331	!\210\332\333!\210!*\206\266!!\202\334\315+\212\334y\315U\203\320\311\335!\204\277\330 +)+\330 Z\331	!\210)\203\376\203\376\n\203\363\212\nj\210\307c\210)\202\376
\203\376\336``\306\316$\210	,\207" [c-fix-backslashes shift-amt bs-col line-cont-backslash ignore-point-pos c-auto-align-backslashes nil 92 beginning-of-line looking-at "\\([ 	]*\\)\\\\$" "\\([ 	]*\\)$" 1 0 t boundp c-syntactic-context buffer-modified-p ((byte-code "\204
\301 \203
\302\303!\210\303\207" [modified buffer-modified-p set-buffer-modified-p nil] 2)) c-guess-basic-syntax c-get-syntactic-indentation c-echo-parsing-error message "syntax: %s, indent: %d" current-indentation c-shift-line-indentation run-hooks c-special-indent-hook -1 "\\s *\\\\?$" c-backslash-region c-syntactic-indentation syntax c-parsing-error modified buffer-undo-list inhibit-read-only inhibit-point-motion-hooks before-change-functions after-change-functions deactivate-mark buffer-file-name buffer-file-truename indent quiet c-echo-syntactic-information-p] 6 (#$ . 682)])
#@260 Insert a newline and indent the new line.
This function fixes line continuation backslashes if inside a macro,
and takes care to set the indentation before calling
`indent-according-to-mode', so that lineup functions like
`c-lineup-dont-change' works better.
(defalias 'c-newline-and-indent #[(&optional newline-arg) "9\203*\212\306 \307\211\307\310\211\310\211\310\311\216\312 \205%`.\202+\310\211\211\211\211 !\"#\212\313 \210` \314\315!\203O\316y\317U\204B\320 )\203ul\203m`Sf\321=\203m\307\211!\"\202u\322 Sf\321=\"\323$!\210j\210\203\251!\203\227\321c\210\316u\210\324``\310\307$\210\202\251\324 \"\203\243`\202\245 \310\307$\210%\205\354\306 \307\211\307\310\211\310\211\310\325\216\326 .\n&\327c\210\330 \210d`Z \331\216\316u\210\332 \210*\"\205\354\324``\310\307$.\207" [c-macro-start modified buffer-undo-list inhibit-read-only inhibit-point-motion-hooks before-change-functions buffer-modified-p t nil ((byte-code "\204
\301 \203
\302\303!\210\303\207" [modified buffer-modified-p set-buffer-modified-p nil] 2)) c-beginning-of-macro beginning-of-line looking-at "[ 	]*\\\\?$" -1 0 current-indentation 92 line-end-position newline c-backslash-region ((byte-code "\204
\301 \203
\302\303!\210\303\207" [modified buffer-modified-p set-buffer-modified-p nil] 2)) c-guess-basic-syntax 10 delete-horizontal-space ((byte-code "dZb\210\301\302!\207" [start delete-char -1] 2)) indent-according-to-mode after-change-functions deactivate-mark buffer-file-name buffer-file-truename col start insert-backslash has-backslash c-fix-backslashes newline-arg c-syntactic-indentation c-syntactic-context] 7 (#$ . 2716)])
#@119 Show syntactic information for current line.
With universal argument, inserts the analysis as a comment on that line.
(defalias 'c-show-syntactic-information #[(arg) "\306\307\301!\203\f	\202*\310 \311\211\311\306\211\306\211\306\312\216\313 .\n !:\204\263\306\211\211\"#$\314\315 \"\210\316\216 \203\253 \211A @\211$\211%A:\203a%A\242\202d%A)\211#\203\202\317#\211T\"&\320&\321\322#\210&)\"B\"$\211%\243\243\242)\211#\203C\317#\211T\"&\320&\321\323#\210&)\"B\"\202C\324\325!\210,\202\276\326 \210\327\330\331 \"!\210*\307\332!\205\311\311\211\207" [c-parsing-error c-syntactic-context modified buffer-undo-list inhibit-read-only inhibit-point-motion-hooks nil boundp buffer-modified-p t ((byte-code "\204
\301 \203
\302\303!\210\303\207" [modified buffer-modified-p set-buffer-modified-p nil] 2)) c-guess-basic-syntax message "Syntactic analysis: %s" ((byte-code "\203\301\211A@!\210\202\301\207" [ols delete-overlay] 3)) make-overlay overlay-put face highlight secondary-selection sit-for 10 indent-for-comment insert-and-inherit format "%s" zmacs-region-stays before-change-functions after-change-functions deactivate-mark buffer-file-name buffer-file-truename syntax arg ols pos elem langelem ol] 5 (#$ . 4415) "P"])
#@75 Insert a comment with the syntactic analysis on every line in the region.
(defalias 'c-syntactic-information-on-region #[(from to) "\212\214	}\210eb\210m?\205\302\303!\210\304y\210\202	*\207" [from to c-show-syntactic-information (0) nil] 2 (#$ . 5710) "*r"])
(defalias 'c-update-modeline #[nil "\306\307\203\n\310\202\311\203	\203\312\202\311\n\203 \313\202!\311\314\315!\2030\315J\2030\316\2021\311%\317\320\"\203@\321\322\"\202A\211G\322V\203P\f
P\202Q\f\323 *\207" [c-electric-flag c-auto-newline c-hungry-delete-key mode-name bare-mode-name fmt format "/%s%s%s%s" "l" "" "a" "h" boundp subword-mode "w" string-match "\\(^[^/]*\\)/" match-string 1 force-mode-line-update] 8])
#@784 Toggle syntactic indentation.
Optional numeric ARG, if supplied, turns on syntactic indentation when
positive, turns it off when negative, and just toggles it when zero or
left out.

When syntactic indentation is turned on (the default), the indentation
functions and the electric keys indent according to the syntactic
context keys, when applicable.

When it's turned off, the electric keys don't reindent, the indentation
functions indents every new line to the same level as the previous
nonempty line, and \[c-indent-command] adjusts the indentation in steps
specified by `c-basic-offset'.  The indentation style has no effect in
this mode, nor any of the indentation associated variables,
e.g. `c-special-indent-hook'.

This command sets the variable `c-syntactic-indentation'.
(defalias 'c-toggle-syntactic-indentation #[(&optional arg) "\303	\"\304\302!\205\305\211\207" [arg c-syntactic-indentation zmacs-region-stays c-calculate-state boundp t] 3 (#$ . 6427) "P"])
#@448 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.

Turning on auto-newline automatically enables electric indentation.

When the auto-newline feature is enabled (indicated by "/la" on the
mode line after the mode name) newlines are automatically inserted
after special characters such as brace, comma, semi-colon, and colon.
(defalias 'c-toggle-auto-newline #[(&optional arg) "\304	\205\n\"\211\203\305\306 \210\307\303!\205\305\211\207" [arg c-auto-newline c-electric-flag zmacs-region-stays c-calculate-state t c-update-modeline boundp] 4 (#$ . 7413) "P"])
(byte-code "\300\301\302\"\210\303\301\302\304#\207" [defalias c-toggle-auto-state c-toggle-auto-newline make-obsolete "22.1"] 4)
#@350 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 (indicated by "/h" on
the mode line after the mode name) the delete key gobbles all preceding
whitespace in one fell swoop.
(defalias 'c-toggle-hungry-state #[(&optional arg) "\303	\"\304 \210\305\302!\205\306\211\207" [arg c-hungry-delete-key zmacs-region-stays c-calculate-state c-update-modeline boundp t] 3 (#$ . 8241) "P"])
#@288 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-newline' and `c-toggle-hungry-state' for details.
(defalias 'c-toggle-auto-hungry-state #[(&optional arg) "\304	\"\304\n\"\305 \210\306\303!\205\307\211\207" [arg c-auto-newline c-hungry-delete-key zmacs-region-stays c-calculate-state c-update-modeline boundp t] 3 (#$ . 8807) "P"])
#@193 Toggle the electric indentation feature.
Optional numeric ARG, if supplied, turns on electric indentation when
positive, turns it off when negative, and just toggles it when zero or
left out.
(defalias 'c-toggle-electric-state #[(&optional arg) "\303	\"\304 \210\305\302!\205\306\211\207" [arg c-electric-flag zmacs-region-stays c-calculate-state c-update-modeline boundp t] 3 (#$ . 9341) "P"])
#@336 Delete the preceding character or whitespace.
If `c-hungry-delete-key' is non-nil (indicated by "/h" 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.
(defalias 'c-electric-backspace #[(arg) "\306 \307\211\307\310\211\310\211
\310\311\216?\206%\206%\312 .\n\2032\313!!\207\314 \207" [modified buffer-undo-list inhibit-read-only inhibit-point-motion-hooks before-change-functions after-change-functions buffer-modified-p t nil ((byte-code "\204
\301 \203
\302\303!\210\303\207" [modified buffer-modified-p set-buffer-modified-p nil] 2)) c-in-literal prefix-numeric-value c-hungry-delete-backwards deactivate-mark buffer-file-name buffer-file-truename c-hungry-delete-key arg c-backspace-function] 4 (#$ . 9748) "*P"])
#@144 Delete the preceding character or all preceding whitespace
back to the previous non-whitespace character.
See also \[c-hungry-delete-forward].
(defalias 'c-hungry-delete-backwards #[nil "`\302\303x\210l\203`Sf\304=\203\305u\210\202`U\204$`|\202'	\306!)\207" [here c-backspace-function " 	\n
\f" nil 92 -1 1] 2 (#$ . 10681) nil])
(defalias 'c-hungry-backspace 'c-hungry-delete-backwards)
#@333 Delete the following character or whitespace.
If `c-hungry-delete-key' is non-nil (indicated by "/h" 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) "\306 \307\211\307\310\211\310\211
\310\311\216?\206%\206%\312 .\n\2032\313!!\207\314 \207" [modified buffer-undo-list inhibit-read-only inhibit-point-motion-hooks before-change-functions after-change-functions buffer-modified-p t nil ((byte-code "\204
\301 \203
\302\303!\210\303\207" [modified buffer-modified-p set-buffer-modified-p nil] 2)) c-in-literal prefix-numeric-value c-hungry-delete-forward deactivate-mark buffer-file-name buffer-file-truename c-hungry-delete-key arg c-delete-function] 4 (#$ . 11087) "*P"])
#@140 Delete the following character or all following whitespace
up to the next non-whitespace character.
See also \[c-hungry-delete-backwards].
(defalias 'c-hungry-delete-forward #[nil "`\302\303w\210\303f\304=\203\303u\210l\204\305u\210`U\204#`|\202&	\306!)\207" [here c-delete-function " 	\n
\f" nil 92 -1 1] 2 (#$ . 12018) nil])
#@481 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 and returns non-nil, it
deletes forward.  Otherwise it deletes backward.

Note: This is the way in XEmacs to choose the correct action for the
[delete] key, whichever key that means.  Other flavors don't use this
function to control that.
(defalias 'c-electric-delete #[(arg) "\301\302!\203\302 \203\303!\207\304!\207" [arg fboundp delete-forward-p c-electric-delete-forward c-electric-backspace] 2 (#$ . 12362) "*P"])
#@485 Delete a non-whitespace char, or all whitespace up to the next non-whitespace char.
The direction of deletion depends on the configuration: If the
function `delete-forward-p' is defined and returns non-nil, it deletes
forward using `c-hungry-delete-forward'.  Otherwise it deletes
backward using `c-hungry-backspace'.

Note: This is the way in XEmacs to choose the correct action for the
[delete] key, whichever key that means.  Other flavors don't use this
function to control that.
(defalias 'c-hungry-delete #[nil "\300\301!\203\301 \203\302 \207\303 \207" [fboundp delete-forward-p c-hungry-delete-forward c-hungry-delete-backwards] 2 (#$ . 13035) nil])
#@219 Insert a "#".
If `c-electric-flag' is set, handle it specially according to the variable
`c-electric-pound-behavior'.  If a numeric ARG is supplied, or if point is
inside a literal or a macro, nothing special happens.
(defalias 'c-electric-pound #[(arg) "\306 \307\211\307\310\211\310\211\310\311\216\206L?\206L\312>?\206L\212\313\310x\210n)?\206L\212\314y\315U\205F\310\210`Sf\316=)\206L\317 .\n\203X\320\321!!\207d`Zn\322 \210\323 \210c\210?\205udZb*\207" [modified buffer-undo-list inhibit-read-only inhibit-point-motion-hooks before-change-functions after-change-functions buffer-modified-p t nil ((byte-code "\204
\301 \203
\302\303!\210\303\207" [modified buffer-modified-p set-buffer-modified-p nil] 2)) alignleft " 	" -1 0 92 c-in-literal self-insert-command prefix-numeric-value beginning-of-line delete-horizontal-space deactivate-mark buffer-file-name buffer-file-truename arg c-electric-flag c-electric-pound-behavior bolp pos last-command-event] 4 (#$ . 13704) "*P"])
(defalias 'c-point-syntax #[nil "\306 \307\211\307\310\211\310\211\310\211\310\311\216\310\211\312\216\310	B\313 \314\315\316\"\210\212\317\320!\206;e\321x\210l\203[`Sf\322=\203[`V\203[\323u\210\202=)\205d )\204` \212\323u\210\324 \205{\325 \210` W*\203\212\323u\210\314\322\316\"\210\310u\210\307\211!\"\326 *\310+.\f\207" [modified buffer-undo-list inhibit-read-only inhibit-point-motion-hooks before-change-functions after-change-functions buffer-modified-p t nil ((byte-code "\204
\301 \203
\302\303!\210\303\207" [modified buffer-modified-p set-buffer-modified-p nil] 2)) ((c-tnt-chng-cleanup -tnt-chng-keep -tnt-chng-state)) c-tnt-chng-record-state insert-char 10 1 line-beginning-position 0 " 	\n
\f" 92 -1 c-beginning-of-macro c-end-of-macro c-guess-basic-syntax deactivate-mark buffer-file-name buffer-file-truename c-echo-syntactic-information-p syntax -tnt-chng-state -tnt-chng-keep limit c-at-vsemi-p-fn pt c-auto-newline-analysis c-syntactic-indentation-in-macros] 4])
(defalias 'c-brace-newlines #[(syntax) "\306 \307\211\307\310\211\310\211\310\311\310\211\312\216\205,\212\310\313\314\217)?\205\216\315\236\203T\316\236\203D\317\202V\320\236\203O\321\202V\202V\211 \310!\203\202@ \236\211!\204\202A\211\204m!+@\236+\206\216\322\211A:\204\256\323A!\203\256\"A@`\")\202\261A.
\207" [modified buffer-undo-list inhibit-read-only inhibit-point-motion-hooks before-change-functions after-change-functions buffer-modified-p t nil (arglist-cont-nonempty 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 module-open module-close composition-open composition-close inexpr-class-open inexpr-class-close statement-cont) ((byte-code "\204
\301 \203
\302\303!\210\303\207" [modified buffer-modified-p set-buffer-modified-p nil] 2)) (byte-code "`Sf\300U\203\301u\210\202\302`\301\"b\210\303 \207" [123 -1 scan-sexps c-looking-at-special-brace-list] 3) ((error)) inexpr-class class-open ((inexpr-class-open)) class-close ((inexpr-class-close)) (ignore before after) functionp deactivate-mark buffer-file-name buffer-file-truename syms c-echo-syntactic-information-p symb-newlines c-special-brace-lists syntax c-hanging-braces-alist alist2 alist1 list alist match c-syntactic-context] 4])
(defalias 'c-try-one-liner #[nil "`d`Z\306\211\211\211\211\211\211\211\212\214\212\307y\210`)`}\210\306\310\311\217\2058\306u\210`S}\210\312\313!*\205\364\306\211 \314\216\306!B!\315 \316\224\316\225\317\224\317\225\320u\210\212\321 \205l`ZZ)
\f|\210|\210\212\306\210i)\n\203\274\322\316!\210\nb\210iT\nT\323\306x\210l\203\246`Sf\324=\203\246\320u\210\202\220\325\326\316\"\210	iZ\327!\203\274\325\330\316\"\210\316\"?\206\350\327\"!\206\350\"X\206\350\205\350Z\"W\205\350\nb\210\331\"Z!\210\332\211 +\205\364dZb.\n\207" [cmnt-gap cmnt-col cmnt-pos eol-col mend4 mbeg4 nil -2 (byte-code "\300`\301\"b\207" [scan-sexps -1] 3) ((error)) looking-at "\\([ 	]*\\([
\n][ 	]*\\)?\\)[^ 	
\n]+\\([ 	]+[^ 	
\n]+\\)*\\([ 	]*\\([
\n][ 	]*\\)?\\)\\'" ((c-tnt-chng-cleanup -tnt-chng-keep -tnt-chng-state)) c-tnt-chng-record-state 1 4 -1 c-backward-single-comment delete-char " 	\n
\f" 92 insert-char 125 zerop 32 backward-delete-char-untabify t mend1 mbeg1 pos here -tnt-chng-state -tnt-chng-keep buffer-undo-list c-max-one-liner-length] 10])
#@590 Insert a brace.

If `c-electric-flag' is non-nil, the brace is not inside a literal and a
numeric ARG hasn't been supplied, the command performs several electric
actions:

(a) If the auto-newline feature is turned on (indicated by "/la" on
the mode line) newlines are inserted before and after the brace as
directed by the settings in `c-hanging-braces-alist'.

(b) Any auto-newlines are indented.  The original line is also
reindented unless `c-syntactic-indentation' is nil.

(c) If auto-newline is turned on, various newline cleanups based on the
settings of `c-cleanup-list' are done.
(defalias 'c-electric-brace #[(arg) "\306\211\306\211\307 \310\211:;\310<\306\211=>\306\211?@\306A\311\216\312`\313 \"\314\f!.\n\315\316B!!\210C\203s\204sB\204s\317\320!\204YD\203s\321 \210\202s\306\211\211\211\211EFGHI\307 \310\211:;\310<\306\211=>\306\211?@\306A\310\211JK\322\216\323 G.\fD\203\233\324G!\210L\203r\325u\210\326 F\327F!H\330H>\203\311i\331 V\203\311D\203\306\332 \210\202\311\333 \210\306u\210\330H>\203\330F\202\332GE`d`Z\306\211MNOP\307 \310\211:;\310<\306\211=>\306\211?@\306A\334\216\335Q>\205cR\336=\205c\337EST\306UT\2039T@S\236\211U\2049TA\211T\204$U+\205c\325u\210\340\306x\210l\203X`Sf\341=\203X\325u\210\202B`Sf\342=\205c\314 ?.\n\203t`PS|\210dOZPPb\210\343 V\344\216R\336=\203\301\345Q>\203\301\346EST\306UT\203\260T@S\236\211U\204\260TA\211T\204\233U+\203\301\347 \203\301dOZP*R\342=\203Y\350Q>\203\345\351\352\306\310#\203\345\353\224\353\225|\210\354\355!\210\202Y\356Q>\203YPSb\210`M\340\306x\210l\203\n`Sf\341=\203\n\325u\210\202\364`N`Sf\357=\203Y\360\307 \310\211:;\310<\306\211=>\306\211?@\306A\361\216\362\363\310\".\n!\203Y\306f\364=\203Y\351\365\306\310#\203YNM|\210Nb\210\366c\210dOZb\210D\203g\324 \210,\367H>\203r\333 \210-R\336=\205\263W?\205\263\n\205\263\212\307 \310\211:;\310<\306\211=>\306\211?@\306A\370\216\214\f\206\250ed}\210\371 \210.\n )-\207" [blink-paren-function case-fold-search old-blink-paren literal safepos modified nil buffer-modified-p t ((byte-code "\204
\301 \203
\302\303!\210\303\207" [modified buffer-modified-p set-buffer-modified-p nil] 2)) c-safe-position c-parse-state c-in-literal self-insert-command prefix-numeric-value looking-at "[ 	]*\\\\?$" indent-according-to-mode ((byte-code "\204
\301 \203
\302\303!\210\303\207" [modified buffer-modified-p set-buffer-modified-p nil] 2)) c-guess-basic-syntax c-indent-line -1 c-point-syntax c-brace-newlines before current-indentation newline c-newline-and-indent ((byte-code "\204
\301 \203
\302\303!\210\303\207" [modified buffer-modified-p set-buffer-modified-p nil] 2)) empty-defun-braces 125 (defun-close class-close inline-close) " 	\n
\f" 92 123 match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) one-liner-defun (defun-close) c-try-one-liner brace-else-brace re-search-backward "}\\([ 	\n]\\|\\\\\n\\)*else\\([ 	\n]\\|\\\\\n\\)*{\\=" 0 insert-and-inherit "} else {" brace-elseif-brace 41 zerop ((byte-code "\204
\301 \203
\302\303!\210\303\207" [modified buffer-modified-p set-buffer-modified-p nil] 2)) c-backward-token-2 1 40 "}\\([ 	\n]\\|\\\\\n\\)*else\\([ 	\n]\\|\\\\\n\\)+if\\([ 	\n]\\|\\\\\n\\)*\\=" 32 after ((byte-code "\204
\301 \203
\302\303!\210\303\207" [modified buffer-modified-p set-buffer-modified-p nil] 2)) c-backward-sws buffer-undo-list inhibit-read-only inhibit-point-motion-hooks before-change-functions after-change-functions deactivate-mark buffer-file-name buffer-file-truename arg c-electric-flag c-syntactic-indentation syntax br-syntax ln-syntax newlines c-echo-syntactic-information-p c-syntactic-indentation-in-macros c-auto-newline-analysis c-auto-newline mend mbeg pos here c-cleanup-list last-command-event alist list match save-match-data-internal executing-kbd-macro] 6 (#$ . 18391) "*P"])
#@616 Insert a slash character.

If the slash is inserted immediately after the comment prefix in a c-style
comment, the comment might get closed by removing whitespace and possibly
inserting a "*".  See the variable `c-cleanup-list'.

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 or `c-electric-flag' is nil, indentation
is inhibited.
(defalias 'c-electric-slash #[(arg) "\306 \307\211\307\310\211\310\211\310\311\216\312 .\n\310\211 !\204l \313=\203l\314\">\203l#\315=\203l\316\317\320$!\321Q!\203l\212\214e`}\210\322 \210\316%\323P!*\203l\324y\210`\310\210`|\210\325\326\327\"\210!?\205\221&\205\221'\205\221#\315=\205\221`Sf \203\217\326\202\220\315=\330\331!!!\210\205\241\332 +\207" [modified buffer-undo-list inhibit-read-only inhibit-point-motion-hooks before-change-functions after-change-functions buffer-modified-p t nil ((byte-code "\204
\301 \203
\302\303!\210\303\207" [modified buffer-modified-p set-buffer-modified-p nil] 2)) c-in-literal c comment-close-slash 47 looking-at "[ 	]*\\(" regexp-quote "\\)?$" back-to-indentation "[ 	]*$" 0 insert-char 42 1 self-insert-command prefix-numeric-value indent-according-to-mode deactivate-mark buffer-file-name buffer-file-truename c-echo-syntactic-information-p indentp literal arg c-cleanup-list last-command-event comment-end c-current-comment-prefix c-syntactic-indentation c-electric-flag] 5 (#$ . 22382) "*P"])
#@341 Insert a star character.
If `c-electric-flag' and `c-syntactic-indentation' are both non-nil, and
the star is the second character of a C style comment starter on a
comment-only-line, indent the line as a comment.  If a numeric ARG is
supplied, point is inside a literal, or `c-syntactic-indentation' is nil,
this indentation is inhibited.
(defalias 'c-electric-star #[(arg) "\306\307!!\210\310 \311\211\311\312\211\312\211\312\313\216\205V\205V?\205V\314 \315=\205V`Sf\316=\205V\212\317u\210\320\312x\210`Sf\321=\203P\317u\210\322\312x\210n).\n\205a\312\323 )\207" [arg modified buffer-undo-list inhibit-read-only inhibit-point-motion-hooks before-change-functions self-insert-command prefix-numeric-value buffer-modified-p t nil ((byte-code "\204
\301 \203
\302\303!\210\303\207" [modified buffer-modified-p set-buffer-modified-p nil] 2)) c-in-literal c 42 -1 "*" 47 " 	" indent-according-to-mode after-change-functions deactivate-mark buffer-file-name buffer-file-truename c-syntactic-indentation c-electric-flag c-echo-syntactic-information-p] 4 (#$ . 24094) "*P"])
#@669 Insert a comma or semicolon.

If `c-electric-flag' is non-nil, point isn't inside a literal and a
numeric ARG hasn't been supplied, the command performs several electric
actions:

(a) When the auto-newline feature is turned on (indicated by "/la" on
the mode line) a newline might be inserted.  See the variable
`c-hanging-semi&comma-criteria' for how newline insertion is determined.

(b) Any auto-newlines are indented.  The original line is also
reindented unless `c-syntactic-indentation' is nil.

(c) If auto-newline is turned on, a comma following a brace list or a
semicolon following a defun might be cleaned up, depending on the
settings of `c-cleanup-list'.
(defalias 'c-electric-semi&comma #[(arg) "\306\211\306`\306\307 \310\211\310 \306\211!\"\306\211#$\306%\311\216\312\313 !\314!.\n\315\316&!!\210'\205	?\205&?\205(\203T\317\320!\204^)\205\321 \202d`Z*\307 \310\211\310 \306\211!\"\306\211#$\306%\322\216+\323=\203\216\324,>\204\234+\325=\205\301\326,>\205\301\327u\210\330\306x\210l\203\265`Sf\331=\203\265\327u\210\202\237`Sf\332=\205\301\314!?.\n\203\312`|\210d*Zb\210))\203\335\333 \321\n!\210-\306\211./00\203\f0@ \211/\204\3770A\2110\202\351\3060/\334=?.\202\347.\205\335 +-\207" [lim literal c-syntactic-context here c-echo-syntactic-information-p modified nil buffer-modified-p t ((byte-code "\204
\301 \203
\302\303!\210\303\207" [modified buffer-modified-p set-buffer-modified-p nil] 2)) c-most-enclosing-brace c-parse-state c-in-literal self-insert-command prefix-numeric-value looking-at "[ 	]*\\\\?$" c-indent-line ((byte-code "\204
\301 \203
\302\303!\210\303\207" [modified buffer-modified-p set-buffer-modified-p nil] 2)) 44 list-close-comma 59 defun-close-semi -1 " 	\n
\f" 92 125 c-guess-basic-syntax stop c-newline-and-indent buffer-undo-list inhibit-read-only inhibit-point-motion-hooks before-change-functions after-change-functions deactivate-mark buffer-file-name buffer-file-truename arg c-electric-flag c-auto-newline c-syntactic-indentation pos last-command-event c-cleanup-list c-hanging-semi&comma-criteria add-newline-p answer criteria] 4 (#$ . 25202) "*P"])
#@627 Insert a colon.

If `c-electric-flag' is non-nil, the colon is not inside a literal and a
numeric ARG hasn't been supplied, the command performs several electric
actions:

(a) If the auto-newline feature is turned on (indicated by "/la" on
the mode line) newlines are inserted before and after the colon based on
the settings in `c-hanging-colons-alist'.

(b) Any auto-newlines are indented.  The original line is also
reindented unless `c-syntactic-indentation' is nil.

(c) If auto-newline is turned on, whitespace between two colons will be
"cleaned up" leaving a scope operator, if this action is set in
`c-cleanup-list'.
(defalias 'c-electric-colon #[(arg) "\212\306\211\307 \210*\n\203\310\n!\203\311\225b\210`)\312 \313\211%\313&\306\211'(\306\211)*\306+\314\216\315!.\n,\306\211-.\306/\316\3170!!\2101\205\357,?\205\3570?\205\357\310\320!\204n2\205\357\321 \202\357d`Z`34\312 \313\211%\313&\306\211'(\306\211)*\306+\322\2165\205\324\3236>\205\324`Sf\324=\205\324\325u\210\326\306x\210l\203\277`Sf\327=\203\277\325u\210\202\251`Sf\324=\205\324\315 ?\205\324`\330Zf\324=?.\n\203\342`3S|\210\313.d4Zb\210*2\203\361\321 \210\312 \313\211%\313&\306\211'(\306\211)*\306+\313\21178\331 \2119:\332\216:\2037:@@\333=\203.:@\334\240\210:A\211:\2045\205\263\3359;<=\211>=?>\306@>\203k>@?\236\211@\204k>A\211>\204V@+@<\236+\206\263\336\337c\210\340\216\331 );<=\211>=?>\306@>\203\253>@?\236\211@\204\253>A\211>\204\226@+@<\236+-.\341->\203\337.\204\337\212\342\306x\210n)\204\337d`Z4\325u\210\343 \210d4Zb\210)\344-\243>\205\357.?\205\357\343 -\207" [end-of-defun-function beginning-of-defun-function defun-prompt-regexp bod modified buffer-undo-list nil beginning-of-defun looking-at 0 buffer-modified-p t ((byte-code "\204
\301 \203
\302\303!\210\303\207" [modified buffer-modified-p set-buffer-modified-p nil] 2)) c-in-literal self-insert-command prefix-numeric-value "[ 	]*\\\\?$" indent-according-to-mode ((byte-code "\204
\301 \203
\302\303!\210\303\207" [modified buffer-modified-p set-buffer-modified-p nil] 2)) scope-operator 58 -1 " 	\n
\f" 92 2 c-guess-basic-syntax ((byte-code "\204
\301 \203
\302\303!\210\303\207" [modified buffer-modified-p set-buffer-modified-p nil] 2)) substatement-label label (case-label label access-label) (member-init-intro inher-intro) 10 ((delete-char -1)) before ": 	" c-newline-and-indent after inhibit-read-only inhibit-point-motion-hooks before-change-functions after-change-functions deactivate-mark buffer-file-name buffer-file-truename literal newlines is-scope-op c-echo-syntactic-information-p arg c-electric-flag c-syntactic-indentation here pos c-auto-newline c-cleanup-list c-syntactic-indentation-in-macros c-auto-newline-analysis syntax elem c-hanging-colons-alist alist2 alist1 list alist match] 4 (#$ . 27405) "*P"])
#@491 Insert a "<" or ">" character.
If the current language uses angle bracket parens (e.g. template
arguments in C++), try to find out if the inserted character is a
paren and give it paren syntax if appropriate.

If `c-electric-flag' and `c-syntactic-indentation' are both non-nil, the
line will be reindented if the inserted character is a paren or if it
finishes a C++ style stream operator in C++ mode.  Exceptions are when a
numeric argument is supplied, or the point is inside a literal.
(defalias 'c-electric-lt-gt #[(arg) "\306\211\211\211\211\307\310
!!\210`\203\362\203\362 \203\362!\311=\203Y\312u\210`\313 \210`U\203>\314 \210\315\"!\206\361#\316=\205\361Sb\210\313 \210\315\317!\205\361\320\225Y\202\361#\316=\203tSb\210\313 \210\315\321!\203t\320\225Y\206\361\214~\210e}\210b\210\322\323\306\324#\210`Sf\311=\203\225\312u\210\315\325!\204~\306f\311=\205\360\315\325!?\205\360\326 \210\327\330!\320W\204\344#\331=\205\360`$\332\306x\320W\203\333\333\306x\320W\203\333\315%!\203\333\320\225$Y\203\333\324\202\340$b\210\306)\205\360\315\"!\206\360\315&!?)b\210	\205\334 \210`Sf\335=\205'?\205(\205( -\207" [case-fold-search found-delim close-paren-inserted final-pos c-echo-syntactic-information-p arg nil self-insert-command prefix-numeric-value 60 -1 c-beginning-of-current-token c-backward-token-2 looking-at c++-mode "<<" 0 ">>" c-syntactic-skip-backward "^<;}" t "\\s(" c-backward-sws skip-syntax-backward "w_" pike-mode "-!%&*+/<=>^|~[]()" "`" indent-according-to-mode 62 c-electric-flag c-syntactic-indentation c-recognize-<>-arglists last-command-event c-opt-<>-sexp-key c-buffer-is-cc-mode pos c-symbol-key c-keywords-regexp executing-kbd-macro blink-paren-function] 5 (#$ . 30328) "*P"])
#@465 Insert a parenthesis.

If `c-syntactic-indentation' and `c-electric-flag' are both non-nil, the
line is reindented unless a numeric ARG is supplied, or the parenthesis
is inserted inside a literal.

Whitespace between a function name and the parenthesis may get added or
removed; see the variable `c-cleanup-list'.

Also, if `c-electric-flag' and `c-auto-newline' are both non-nil, some
newline cleanups are done if appropriate; see the variable `c-cleanup-list'.
(defalias 'c-electric-paren #[(arg) "\306 \307\211\307\310\211\310\211*+\310,\311\216\312 .\n\310\211-./\313\3140!!\2100?\205\236/?\205\23612\31013\203K4\203K\315 \2104\203\3315\203\331\316\317!\203\331\3206>\203\2327\321=\203\232\322\323\310\307#\203\232\306 \307\211\307\310\211\310\211*+\310,\324\216\312 .\n\204\232\325\224\325\225|\210\326\327!\210\3306>\203\3317\321=\203\331\322\331\310\307#\203\331\306 \307\211\307\310\211\310\211*+\310,\332\216\312 .\n\204\331\325\224\325\225|\210\326\333!\210\310`S89\3346>\203=7\321=\203=\212\335u\210\336\310x\210`9\306 \307\211\307\310\211\310\211*+\310,\337\216\340 .\n\205'\341 \205&\342 \205&`9=?)\203=\21298|\2109b\210\343c\210)\202\207\306 \307\211\307\310\211\310\211*+\310,\344\216\3456>\205|7\346=\205|\212\310\347\350\217\210\316\351!\205{`8\336\310x\210`9\340 ).\n\203\20798|\210*:\346=\205\235;?\205\2352\205\2352 *+\207" [modified buffer-undo-list inhibit-read-only inhibit-point-motion-hooks before-change-functions after-change-functions buffer-modified-p t nil ((byte-code "\204
\301 \203
\302\303!\210\303\207" [modified buffer-modified-p set-buffer-modified-p nil] 2)) c-in-literal self-insert-command prefix-numeric-value indent-according-to-mode looking-at "[ 	]*\\\\?$" brace-elseif-brace 40 re-search-backward "}\\([ 	\n]\\|\\\\\n\\)*else\\([ 	\n]\\|\\\\\n\\)+if\\([ 	\n]\\|\\\\\n\\)*(\\=" ((byte-code "\204
\301 \203
\302\303!\210\303\207" [modified buffer-modified-p set-buffer-modified-p nil] 2)) 0 insert-and-inherit "} else if (" brace-catch-brace "}\\([ 	\n]\\|\\\\\n\\)*catch\\([ 	\n]\\|\\\\\n\\)*(\\=" ((byte-code "\204
\301 \203
\302\303!\210\303\207" [modified buffer-modified-p set-buffer-modified-p nil] 2)) "} catch (" space-before-funcall -1 " 	" ((byte-code "\204
\301 \203
\302\303!\210\303\207" [modified buffer-modified-p set-buffer-modified-p nil] 2)) c-on-identifier c-beginning-of-macro c-forward-over-cpp-define-id 32 ((byte-code "\204
\301 \203
\302\303!\210\303\207" [modified buffer-modified-p set-buffer-modified-p nil] 2)) compact-empty-funcall 41 (forward-char -2) ((error)) "()" deactivate-mark buffer-file-name buffer-file-truename case-fold-search c-echo-syntactic-information-p literal arg blink-paren-function old-blink-paren c-syntactic-indentation c-electric-flag c-auto-newline c-cleanup-list last-command-event end beg last-input-event executing-kbd-macro] 5 (#$ . 32106) "*P"])
#@408 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-electric-flag' and `c-syntactic-indentation' are both non-nil.
(defalias 'c-electric-continued-statement #[nil "\306\307 \310\211\310\306\211\306\211\306\311\216\205^\205^\312=?\205^\212\313\314!\210`)\212\315 \210`)U\205^\316\212\306\211\317 \210*\203Z\320!\203Z\321\225b\210`)!?.\n\205l\322\323!\210\324\216\325 ))\207" [c-echo-syntactic-information-p modified buffer-undo-list inhibit-read-only inhibit-point-motion-hooks before-change-functions nil buffer-modified-p t ((byte-code "\204
\301 \203
\302\303!\210\303\207" [modified buffer-modified-p set-buffer-modified-p nil] 2)) 95 skip-syntax-backward "w" back-to-indentation c-in-literal beginning-of-defun looking-at 0 insert-and-inherit " x" ((delete-char -2)) indent-according-to-mode after-change-functions deactivate-mark buffer-file-name buffer-file-truename c-electric-flag c-syntactic-indentation last-command-event end-of-defun-function beginning-of-defun-function defun-prompt-regexp] 4 (#$ . 35087)])
#@46 Compatibility alias for `c-forward-subword'.
(defalias 'c-forward-into-nomenclature #[(&optional arg) "\301\302!\210\303!\207" [arg require subword subword-forward] 2 (#$ . 36443) "p"])
(make-obsolete 'c-forward-into-nomenclature 'subword-forward "23.2")
#@47 Compatibility alias for `c-backward-subword'.
(defalias 'c-backward-into-nomenclature #[(&optional arg) "\301\302!\210\303!\207" [arg require subword subword-backward] 2 (#$ . 36705) "p"])
(make-obsolete 'c-backward-into-nomenclature 'subword-backward "23.2")
#@106 Insert a double colon scope operator at point.
No indentation or other "electric" behavior is performed.
(defalias 'c-scope-operator #[nil "\300\301!\207" [insert-and-inherit "::"] 2 (#$ . 36973) "*"])
(defalias 'c-in-function-trailer-p #[(&optional lim) "\205T\212\304\305	\"\210`\306`Sf\307=\205S\310	!@\311=\205S`\211\205S\312\313\314Q\315\211\211%\205S\316\224\205S`Sf\317=?\205S\312\320\315\211\211%\205S`Sf\321=\205S\n+\207" [c-opt-block-decls-with-vars-key lim bod eo-block c-syntactic-skip-backward "^;}" nil 125 c-beginning-of-decl-1 previous c-syntactic-re-search-forward "[;=([{]\\|\\(" "\\)" t 1 95 "[;=([{]" 123] 6])
(defalias 'c-where-wrt-brace-construct #[nil "\212\306\211\306`\307 \310\f!\211\203
f\311=\203\312\202\311\313 \203(\314\202\311
\204G\f:\203G\f@:\203G\f\211@A)=\203G\315\202\311
\203N
b\210l\203Vm\203\\\316\317!\204_\306u\210`\320
\205j\321
\f\"!@\212\322\323\306\324\211$\205\206`Sf\311=\206\206\205\206\325 )`U\203\222\326\202\311	\327=\203\256\n\203\252`=\203\246\330\202\311\331\202\311\326\202\311	\332=\203\305\n\204\301\313 \203\301\315\202\311\326\202\311\333\334	\".\207" [kluge-start decl-result brace-decl-p start paren-state least-enclosing nil c-parse-state c-least-enclosing-brace 123 in-block c-in-function-trailer-p in-trailer at-function-end looking-at "\\([;#]\\|\\'\\|\\s(\\|\\s)\\|\\s\"\\|\\s\\\\|\\s$\\|\\s<\\|\\s>\\|\\s!\\)" c-beginning-of-decl-1 c-safe-position c-syntactic-re-search-forward "[;{]" t c-in-knr-argdecl outwith-function same at-header in-header previous error "c-where-wrt-brace-construct: c-beginning-of-decl-1 returned %s" x c-recognize-knr-p] 6])
(defalias 'c-backward-to-nth-BOF-{ #[(n where) "o\204I\302=\203\303\304 !b\210	S\202I\305=\203)\306\307!\210\310u\210	S\202I\311>\203D\312\313!\210`Sf\314=\203I\315 \210	S\202I\316\317\"\210	\320V\203lo\204l\304 \210\312\313!\210`Sf\314=\203I\315 \210	S\211\202J	\207" [where n in-block c-least-enclosing-brace c-parse-state in-header c-syntactic-re-search-forward "{" -1 (at-header outwith-function at-function-end in-trailer) c-syntactic-skip-backward "^}" 125 backward-sexp error "Unknown `where' %s in c-backward-to-nth-EOF-{" 0] 4])
(defalias 'c-narrow-to-most-enclosing-decl-block #[(&optional inclusive) "\303 \304\211\205\f\305	!\211\205/\212\n\203 b\210\306 \210`\202\"Tb\210\304\307\310\217\206-d})*\207" [encl-decl paren-state inclusive c-parse-state nil c-most-enclosing-decl-block c-beginning-of-decl-1 (byte-code "\301 \210\203	`\207`S\207" [inclusive forward-list] 1) ((error))] 5])
(defalias 'c-widen-to-enclosing-decl-scope #[(paren-state orig-point-min orig-point-max) "\304\214	\n}\210\205\305!)\203+~\210T\212b\210\304\306\307\217\206$\n)}\210\2020	\n}\210\304)\207" [encl-decl orig-point-min orig-point-max paren-state nil c-most-enclosing-decl-block (byte-code "\300 \210`S\207" [forward-list] 1) ((error))] 4])
(defalias 'c-while-widening-to-decl-block '(macro . #[(condition) "\301\302\303BB\304BB\207" [condition while and ((eq c-defun-tactic 'go-outward) lim) ((setq paren-state (c-whack-state-after lim paren-state)) (setq lim (c-widen-to-enclosing-decl-scope paren-state orig-point-min orig-point-max)) (setq where 'in-block))] 4]))
#@476 Move backward to the beginning of a defun.
Every top level declaration that contains a brace paren block is
considered to be a defun.

With a positive argument, move backward that many defuns.  A negative
argument -N means move forward to the Nth following beginning.  Return
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\306	\307=\203\n\307=\204\203\f\204\310 \210\311 \312\211$%\312&\313\211'(\313\211)*\313\211+,\313-`.\314\315 !/e0d1\313\21123\313\21145\316\216\2146\317=\203m\320/01#2\321 \210\322 \2114\203}4@b\210\323 3\324W\203
3\325>\203\221T\324W\203\311\326[3\"[\211\324W\203\3116\317=\203\3112\203\311\3272/\"/\320/01#2\3303\202\227\324U\205z\331\332\313\333#\204\3736\317=\203\3732\203\373\3272/\"/\320/01#2\3303\202\317`Sf\334=\205z\335u\210\336 \210\312\202z\324V\203C\3373\"\211\324V\203C6\317=\203C2\203C\3272/\"/\320/01#2\3303\202\324=\203n\336 \210`4`\212\340 \210`)U\204_\341 \204O`\212\340 \210`)U\204n4b\210\342\343!\203w\312#\324U.\207" [arg this-command last-command transient-mark-mode mark-active modified 1 c-beginning-of-defun push-mark buffer-modified-p t nil copy-tree c-parse-state ((byte-code "\204
\301 \203
\302\303!\210\303\207" [modified buffer-modified-p set-buffer-modified-p nil] 2)) go-outward c-widen-to-enclosing-decl-scope c-beginning-of-macro c-literal-limits c-where-wrt-brace-construct 0 (at-function-end outwith-function) c-forward-to-nth-EOF-} c-whack-state-after in-block c-syntactic-re-search-forward "{" eob 123 -1 c-beginning-of-decl-1 c-backward-to-nth-BOF-{ back-to-indentation c-backward-single-comment boundp zmacs-region-stays buffer-undo-list inhibit-read-only inhibit-point-motion-hooks before-change-functions after-change-functions deactivate-mark buffer-file-name buffer-file-truename beginning-of-defun-function end-of-defun-function start paren-state orig-point-min orig-point-max lim where pos case-fold-search c-defun-tactic] 5 (#$ . 40274) "p"])
(defalias 'c-forward-to-nth-EOF-} #[(n where) "m\204H\302=\203\303\304 !b\210\305 \210	S\202H\306=\203)\307\310!\210	S\202H\311>\203C\312\313\314\315#\203H\316u\210\305 \210	S\202H\317\320\"\210	\321V\203gm\204g\312\313\314\315#\203`\316u\210\305 \210	S\211\202I	\207" [where n in-block c-least-enclosing-brace c-parse-state forward-sexp in-trailer c-syntactic-skip-backward "^}" (at-function-end outwith-function at-header in-header) c-syntactic-re-search-forward "{" nil eob -1 error "c-forward-to-nth-EOF-}: `where' is %s" 0] 5])
#@358 Move forward to the end of a top level declaration.
With argument, do it that many times.  Negative argument -N means move
back to Nth preceding end.  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\306	\307=\203\n\307=\204\203\f\204\310 \210\311 \312\211%&\312'\313\211()\313\211*+\313\211,-\313.`/\314\315 !0e1d2\313\21134\313\21156\316\216\2147\317=\203m\320012#3\321 \210\322 \2115\203}5@b\210\323 4\324W\203\3774\325>\203\221T\324W\203\311\326[4\"[\211\324W\203\3117\317=\203\3113\203\311\32730\"0\320012#3\3304\202\227\324U\2035\331\332!\210`Sf\333=\20457\317=\20353\2035\32730\"0\320012#3\3304\202\317\324V\2035\3344\"\211\324V\20357\317=\20353\2035\32730\"0\320012#3\3304\202\324=\203j\335 \203D\336\337!\210`5n\204V\340\341!\204V\342 \204Gn\204j\340\341!\203f\306y\210\202j5b\210\343\344!\203s\312$\324U.\207" [arg this-command last-command transient-mark-mode mark-active modified 1 c-end-of-defun push-mark buffer-modified-p t nil copy-tree c-parse-state ((byte-code "\204
\301 \203
\302\303!\210\303\207" [modified buffer-modified-p set-buffer-modified-p nil] 2)) go-outward c-widen-to-enclosing-decl-scope c-beginning-of-macro c-literal-limits c-where-wrt-brace-construct 0 (at-header outwith-function) c-backward-to-nth-BOF-{ c-whack-state-after in-block c-syntactic-skip-backward "^}" 125 c-forward-to-nth-EOF-} c-in-function-trailer-p c-syntactic-re-search-forward ";" looking-at "\\s *$" c-forward-single-comment boundp zmacs-region-stays buffer-undo-list inhibit-read-only inhibit-point-motion-hooks before-change-functions after-change-functions deactivate-mark buffer-file-name buffer-file-truename beginning-of-defun-function end-of-defun-function start paren-state orig-point-min orig-point-max lim where pos case-fold-search c-defun-tactic] 5 (#$ . 43076) "p"])
#@146 Return the name of the current defun, or NIL if there isn't one.
"Defun" here means a function, or other top level construct
with a brace block.
(defalias 'c-defun-name #[nil "\306 \307\211\307\310\211\310\21101\310\21123\310\21145\310\21167\3108\311\216\214~\210\212\312 \210\313 \2116\203>6@b\210\314 \2115\315=?\205D5\316=\204Y\317\3205\"\210\321 \210\3229!\203\221\323\324!\210\310f\325=\204r\322:!\203\221\326 ;\327\216\323 \210*\310f\325=\203\213\330 \210\322:!\210\331\332!\202D\322\333!\203\303\334\320!\210\335 \210\310f\336=\203\254\337\320!\210\323 \210\340`\323 \210\322\341!\203\273\342\310w\210\343 \210`\"\202D\322\344!\203\317\331\320!\202D\345\346 \236\203\212\347 \210`)\350:\351Q\310<=>\352:>\307\211\211%\203\331\332!<B<\352=>\307\211\211%\203\331\332!<B<\202\374\353\354<\237\"+\202D\352\355\310\307#\205D\356u\210\343 \210`Sf\357=\2039\330 \210\343 \210`7\330 \210\340`7\".\207" [modified buffer-undo-list inhibit-read-only inhibit-point-motion-hooks before-change-functions after-change-functions buffer-modified-p t nil ((byte-code "\204
\301 \203
\302\303!\210\303\207" [modified buffer-modified-p set-buffer-modified-p nil] 2)) c-beginning-of-macro c-literal-limits c-where-wrt-brace-construct outwith-function at-header c-backward-to-nth-BOF-{ 1 c-beginning-of-decl-1 looking-at c-forward-token-2 2 123 match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) c-backward-token-2 match-string-no-properties 0 "DEFUN\\_>" down-list c-forward-sws 34 forward-sexp buffer-substring-no-properties ":" "^," c-backward-sws "DEF[a-zA-Z0-9_]* *( *\\([^, ]*\\) *," objc-method-intro c-guess-basic-syntax c-end-of-statement "\\(?:" "\\)?:" c-syntactic-re-search-forward apply concat "[{(]" -1 61 deactivate-mark buffer-file-name buffer-file-truename beginning-of-defun-function end-of-defun-function where pos name-end case-fold-search c-type-prefix-key c-symbol-key save-match-data-internal stretches kw-re bound] 7 (#$ . 45197) nil])
(defalias 'c-declaration-limits #[(near) "\212\214\302=\2054\303\304!\210\214\303\305!\210\306\307\215)\2064	?\2054eb\2054\310\311\305\211#\2054\305f\312=\2054edB*\207" [c-defun-tactic near go-outward c-narrow-to-most-enclosing-decl-block t nil exit (byte-code "`\306 \307\211\211\307\310\311\217\204!\312\313`\"!\211\203!	@b\210\314 \2035\315\316`\212\317 \210\320y\210`)B\"\210`\321\n!@\322=\204F	`U\203w	b\210\323\324!\203Sm\203I\325\326!\203_\327u\210\202I
\203w\314 \203w\315\316`\212\317 \210\320y\210`)B\"\210m\203\200\315\316\307\"\210`\203\253\330 \210`Sf\331=\203\253\321 @\322=\203\253\212\332 \210`	V\205\247`\211)\204\256	b\210
?\205\266`\fV?\205``\212\333 \210`)U\204\314\334 \204\274`\212\333 \210`)U\204\333	\202\334`\203\346b\210\202\351\332 \210`n\204\372\325\335!\204\372\336 \204\353n\203`\202\325\335!\203\320y\210`\202	B-\207" [end-pos pos lim paren-state start near c-parse-state nil (byte-code "\302!b\210\303`\"\304\207" [paren-state lim c-least-enclosing-brace c-safe-position t] 3) ((error)) c-literal-limits c-safe-position c-beginning-of-macro throw exit c-end-of-macro 1 c-beginning-of-decl-1 previous forward-comment 5 looking-at "\\\\[\n
]" 2 c-backward-sws 125 c-end-of-decl-1 back-to-indentation c-backward-single-comment "\\s *$" c-forward-single-comment c-opt-block-decls-with-vars-key] 6) c-forward-decl-or-cast-1 -1 123] 4])
#@474 Put mark at end of the current top-level declaration or macro, point at beginning.
If point is not inside any then the closest following one is
chosen.  Each successive call of this command extends the marked
region by one function.

A mark is left where the command started, unless the region is already active
(in Transient Mark mode).

As opposed to \[c-beginning-of-defun] and \[c-end-of-defun], this
function does not require the declaration to contain a brace block.
(defalias 'c-mark-function #[nil "\306\211\307 \310\211\310\306\211\306\211\306\311\216\312!\203,\313\314\306\315 #\210\316\310!.\n	\204<\317\320!\202\223\321=\205G\321=\321=\205^?\205^\205]?\211\203h\322`!\210\203\210\323 \210\316\310!\211\204\323 \210\317\320!\210	Ab\210\323 \202\222	@b\210\322	A\306\310#**\207" [case-fold-search decl-limits modified buffer-undo-list inhibit-read-only inhibit-point-motion-hooks nil buffer-modified-p t ((byte-code "\204
\301 \203
\302\303!\210\303\207" [modified buffer-modified-p set-buffer-modified-p nil] 2)) looking-at c-backward-token-2 1 line-beginning-position c-declaration-limits error "Cannot find any declaration" c-mark-function push-mark exchange-point-and-mark before-change-functions after-change-functions deactivate-mark buffer-file-name buffer-file-truename c-syntactic-eol this-command last-command extend-region-p transient-mark-mode mark-active push-mark-p] 5 (#$ . 48688) nil])
#@71 Return the name of the current CPP macro, or NIL if we're not in one.
(defalias 'c-cpp-define-name #[nil "\302\212	\205\303 \205\304	!\205\305\306!*\207" [case-fold-search c-opt-cpp-macro-define-start nil c-beginning-of-macro looking-at match-string-no-properties 1] 2 (#$ . 50159) nil])
(defalias 'c-in-comment-line-prefix-p #[nil "`\212\302 \210\303\304w\210\305	!\205\306\224\306\225U?\205\306\225W*\207" [here c-current-comment-prefix beginning-of-line " 	" nil looking-at 0] 2])
(defalias 'c-narrow-to-comment-innards #[(range) "\304!\211\305=\203@\306\\\202@	\305=\2038ASf\307=\2034ASSf\310=\2034A\306Z\202Fd\202FAd=\203Cd\202FAS`V\203Pb\210`\nW\203Y\nb\210\n}+\207" [range lit-type beg end c-literal-type c 2 47 42] 3])
(defalias 'c-beginning-of-sentence-in-comment #[(range) "\306 \307\216`\214\310\n!\210`\311\312
\313\314R\315
\316Q\212\317\320!\210\321\311\322#V\2030b\210`Y\203H\317\323!\210\321\311\322#V\203Hb\210`)\324\325 \326#\203\231`\211\203\231\327\225b\203\231`Y\204\223n\204\200\212\324\311\322#\205|\330\224\330\225U?)\204\223\331 \203\210\332 \210\321!\210`Y\203\231\fb\210\202L\321!\210.`	W?\205\254\n@b\210\322+\207" [save-match-data-internal start-point range here last c-current-comment-prefix match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) c-narrow-to-comment-innards nil "\\=\\(^[ 	]*\\(" "\\)" "\\|[ 	\n
\f]\\)*" "^[ 	]*\\(" "\\)[ 	\n
\f]*\\=" forward-paragraph -1 re-search-forward t -2 re-search-backward sentence-end limit 0 1 c-in-comment-line-prefix-p beginning-of-line here-filler prefix-at-bol-here par-beg] 4])
(defalias 'c-end-of-sentence-in-comment #[(range) "\306 \307\216`\214\310\n!\210`\212\311\312!\210h\313=\203\314u\210`X\2032b\210\311\315!\210h\313=\2032\314u\210`)\316\317\320Q\321\322 \f\323#\203n`\324\316x\210n\204b\325\316\326#\203b\312\224\312\225U\203h`X\203n
b\210\202>`d=\203\215\324\316x\327U\203t\325\316\326#\203\215\312\224\312\225U\203t-`	V?\205\232\nAb\210\326+\207" [save-match-data-internal start-point range here par-end last match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) c-narrow-to-comment-innards forward-paragraph 1 10 -1 2 nil "^[ 	]*\\(" "\\)\\=" re-search-forward sentence-end limit " 	\n" re-search-backward t 0 c-current-comment-prefix prefix-at-bol-here] 4])
(defalias 'c-beginning-of-sentence-in-string #[(range) "\306 \307\216`\310AS\311\212\214@T\f}\210\312\313!\210\314
\310\315#	V\2030	b\210`	Y\203G\312\316!\210\314
\310\315#	V\203G	b\210`*\317\320#\203y`\211\203y\321\225b\203y`\fV\204s\314
\f\315#\210`	Y\203y\nb\210\202K\314
	\315#\210`	W?\205\213@b\210\315.	\207" [save-match-data-internal here last range end here-filler match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) nil "\\=\\([ 	\n
\f]\\|\\\\[\n
]\\)*" forward-paragraph -1 re-search-forward t -2 re-search-backward limit 0 c-string-par-start paragraph-start c-string-par-separate paragraph-separate par-beg c-sentence-end-with-esc-eol] 4])
(defalias 'c-end-of-sentence-in-string #[(range) "\306 \307\216`\310
\212\214@AS}\210\311\312!\210`\313\310x\314U\203\315\316\310\317#\204`	V\204L\nb\210\311\312!\210\313\310x\314U\203<\315\316\310\317#\204<`*\320\321#\203l`\322\310x\314U\203\\\315\316\310\317#\204\\`	V?\205yAb\210\317.\207" [save-match-data-internal here last c-string-par-start paragraph-start c-string-par-separate match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) nil forward-paragraph 1 " 	\n
\f" 0 re-search-backward "\\\\\\($\\)\\=" t re-search-forward limit " 	\n" paragraph-separate range par-end c-sentence-end-with-esc-eol] 4])
(defalias 'c-ascertain-preceding-literal #[nil "\212\304`\305\306 \203`\307 \210`B\2028\214e	}\210\310\n!\204-o?\2057\311u\210\310!\2057\312\225b\210`\305\313\314\217)*!)\207" [pos here c-ws*-string-limit-regexp c-string-limit-regexp c-collect-line-comments nil c-backward-single-comment c-forward-single-comment looking-at -1 0 (byte-code "\301`\302\"b\210`B\207" [pos scan-sexps -1] 3) ((error))] 4])
(defalias 'c-ascertain-following-literal #[nil "\212\302\303\304\303w\210\303f\305=\203\303u\210l\204\306u\210\307	!\203,`\303\310\311\217\206(dB\2026`\312 \2056`B)!)\207" [pos c-string-limit-regexp c-collect-line-comments nil " 	\n
\f" 92 -1 looking-at (byte-code "\300`\301\"b\210`\207" [scan-sexps 1] 3) ((error)) c-forward-single-comment] 5])
(defalias 'c-after-statement-terminator-p #[nil "\212\303u\210\304\305!\205\205\306f\307=\205\310 ?)\206S	\203%	 \206S\306\212\311 \2032\312 \210`)\n\205R\212\313\314!\203Bm\2038\304\315!\203N\316u\210\2028`\nY))\207" [c-special-brace-lists c-at-vsemi-p-fn eom -1 looking-at "[;{}]" nil 123 c-looking-at-special-brace-list c-beginning-of-macro c-end-of-macro forward-comment 5 "\\\\[\n
]" 2] 2])
(defalias 'c-back-over-illiterals #[(macro-start) "\303 \304\216`\305\306\307\215,\207" [save-match-data-internal last here match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) nil done (byte-code "`\306 \203b\210\307\310\311\"\210\202\212\312 \210\313\314\315#)\203B	\203)`	W\202+\316 \203Bb\210\307\310`\n=\206;	?\317B\"\210\202\203c \203c\nW\203cf\320>\204cb\210\307\310\321\"\210\202o\203x\nU\204pb\210\307\310\322\"\210\202\323u\210\324f\325=\203\243\f\203\222\326 \203\222\327\330!\210\202\nU\204\233b\210\307\310\331\"\210\202	\203\271`	=\203\271\307\310`\n=\317B\"\210\202\332\333!\203\354\nU\204\314f\334>\203\341`Sf\335=\203\324f\336=\203\323u\210\202b\210\307\310\337\"\210\202\332
!\203\375b\210\307\310\340\"\210\202\327\330!\210\202" [last macro-start here c-at-vsemi-p-fn c-special-brace-lists c-string-limit-regexp c-backward-single-comment throw done (t . literal) beginning-of-line re-search-forward "\\(^\\|[^\\]\\)[\n
]" t c-beginning-of-macro macro-boundary (41 125) (nil) (nil) -1 nil 123 c-looking-at-special-brace-list skip-syntax-backward "w_" (nil) looking-at "[;}]" (41 125) 125 59 (nil) (t . literal)] 4)] 2])
(defalias 'c-forward-over-illiterals #[(macro-end allow-early-stop) "`\302\303\304\215*\207" [last here nil done (byte-code "`\211	V\203\n\203\n \203\306\307\310\"\210\311\312w\210\312f\313=\203+\312u\210l\204\314u\210\203D`V\203Db\210\306\307`	=\315B\"\210\202\212\316 )\203Vb\210\306\307\317\"\210\202m\203k	U\204cb\210\306\307\320\"\210\202\312f\321=\203\241\f\203{\322 \204\241
\204\205	U\204\241\212\312\323\324\217?\206\222\312f\321U)\203\241b\210\306\307\325\"\210\202\f\203\304\312f\326=\203\304\212\312\327\330\217\205\266\322 )\203\304\312u\210\331\332!\210\202\312f\326=\203\334	U\204\334b\210\306\307\333\"\210\202$\203\204\312f\334=\203`\212\335 \210`)U\203`	U\203\312u\210\202\306\307\336\"\210\202\337\340!\203\341\225b\210\306\307\342\"\210\202\337%!\203/b\210\306\307\343\"\210\202\312u\210\331\332!\210\203`V\203b\210\306\307`	=\315B\"\210\202" [last here c-at-vsemi-p-fn macro-end c-special-brace-lists allow-early-stop throw done (nil) " 	\n
\f" nil 92 -1 macro-boundary c-forward-single-comment (t . literal) (nil) 123 c-looking-at-special-brace-list (byte-code "\300\301!\210\302\207" [up-list -1 t] 2) ((error)) (nil) 125 (byte-code "\300\301!\210\302\207" [up-list -1 t] 2) ((error)) skip-syntax-forward "w_" (nil) 35 back-to-indentation (t . macro-boundary) looking-at ";\\|};?" 0 (nil) (t . literal) c-opt-cpp-prefix c-string-limit-regexp] 5)] 2])
(defalias 'c-one-line-string-p #[(range) "\212@b\210\302	!\205\303Aw\210`A=)\207" [range c-string-limit-regexp looking-at "^\n"] 2])
#@859 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.

Note that for use in programs, `c-beginning-of-statement-1' is
usually better.  It has much better defined semantics than this one,
which is intended for interactive use, and might therefore change to
be more "DWIM:ey".
(defalias 'c-beginning-of-statement #[(&optional count lim sentence-flag) "\306W\203
\307[	\n#\207\310 \311\211\311*\312\211+,\312\211-.\312/\206+\313\3120\212o?\205;\314 \205;`)1\312\21123\315\316	!!4\317\216\306U\204	\203]`	V\203`0o\203i\306\2024\203%\n\203y\3204!\2034@b\210\321 4\2121\203\364`5o\204\360\312\21167\322\323!\2116\204\303`Sf\324=\203\254\323u\210\202\225`Sf\325=\203\303`SSf\324=\203\303\326u\210\202\2256*\203\325\327\330!\203\213\331u\210\202\360\327\332!\203\360`Sf\333=\203\360`5W\203\360\323u\210\202\213)\202\367\334 \210o\206\375\335 )?\202\374\3364!\337=\203\3404!\202\3414!\2112\203 \321 42\202\374\3421!2`0U\206\274\312f\343>\206\2742@\205\274\2121\203\261`5o\204\255\312\21167\322\323!\2116\204\200`Sf\324=\203i\323u\210\202R`Sf\325=\203\200`SSf\324=\203\200\326u\210\202R6*\203\222\327\330!\203H\331u\210\202\255\327\332!\203\255`Sf\333=\203\255`5W\203\255\323u\210\202H)\202\264\334 \210o\206\272\335 )?32A\344=\203\356\212\345 \210o?\205\353\346\312x\210l\203\345`Sf\333=\203\345\323u\210\202\317\314 \205\353`1)2A\347>\203\372\321 43\203`0\202`\306U\204MS\211\202N\350\351!\205\311\211).\207" [count lim sentence-flag modified buffer-undo-list inhibit-read-only 0 c-end-of-statement buffer-modified-p t nil 1 c-beginning-of-macro c-collect-line-comments c-literal-limits ((byte-code "\204
\301 \203
\302\303!\210\303\207" [modified buffer-modified-p set-buffer-modified-p nil] 2)) c-one-line-string-p c-ascertain-preceding-literal forward-comment -1 13 10 -2 looking-at "\\*/" 2 "[\n
]" 92 c-backward-sws c-after-statement-terminator-p c-literal-type string c-beginning-of-sentence-in-string c-beginning-of-sentence-in-comment c-back-over-illiterals (41 125) macro-boundary beginning-of-line " 	\n
\f" (macro-boundary literal) boundp zmacs-region-stays inhibit-point-motion-hooks before-change-functions after-change-functions deactivate-mark buffer-file-name buffer-file-truename last macro-fence res not-bos range start moved-comment open-paren-in-column-0-is-defun-start] 5 (#$ . 58073) (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) "\206\306\211\307W\203\310[	\n#\207\311 \312\211\312\313\211 !\313\211\"#\313\211$%\212m?\205>\314 \205>\315 \210`)&\313'\316\317	!!(\320\216\307U\204-	\203]`	W\203-`%m\203i\307\202 (\203\275\n\203y\321(!\203\216(Ab\210\322 ()\205\212) ?\202\323(!\324=\203\236\325(!\202\242\326(!\211'\203\254\322 ('\203 )\205\271) ?\202\327&`%V\"\211'A\330=\203\212&\203\375\313\210m?\205\331\313w\210\313f\332=\203\361\313u\210l\204\334\333u\210\314 \205\315 \210`\202m?\205\314 \205\315 \210`)&'A\334>\203\322 ('@\204`\307U\204MS\211\202N\335\336!\2057\312\211.\207" [count lim sentence-flag modified buffer-undo-list inhibit-read-only 1 0 c-beginning-of-statement buffer-modified-p t nil c-beginning-of-macro c-end-of-macro c-collect-line-comments c-literal-limits ((byte-code "\204
\301 \203
\302\303!\210\303\207" [modified buffer-modified-p set-buffer-modified-p nil] 2)) c-one-line-string-p c-ascertain-following-literal c-literal-type string c-end-of-sentence-in-string c-end-of-sentence-in-comment c-forward-over-illiterals macro-boundary " 	\n
\f" 92 -1 (macro-boundary literal) boundp zmacs-region-stays inhibit-point-motion-hooks before-change-functions after-change-functions deactivate-mark buffer-file-name buffer-file-truename here macro-fence res range c-at-vsemi-p-fn] 5 (#$ . 61157) (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" [mapc #[(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-calc-comment-indent #[(entry) "9\203	\236\206\306	\236\206\307A@AAi\211\310=\203)\n\\\202\202\f\311=\203D\2045
n\203=\202\202\nT]\202\202\f\312=\205\202\212\313 \210o?\205z\314u\210\315\316 \317\"\211:\205y@b\210\320\321!\205yn\203u\322\202y\nTi]))\206\202\323A!+\207" [entry c-indent-comment-alist col value action comment-column other (default column) space column align beginning-of-line -1 c-literal-limits line-beginning-position t looking-at "/[/*]" 0 c-calc-comment-indent lim] 4])
#@109 Used by `indent-for-comment' to create and indent comments.
See `c-indent-comment-alist' for a description.
(defalias 'c-comment-indent #[nil "\212\306\210\307 \310\211\310\306\211\306\211 \306!\311\312 \310\"\211\":\2039\"@b\210\313\314!\2039\315\306x\210`\206>\315\306x\210`)#\313\316!\203K\317\202\202\320 \210`#=\203Y\321\202\202\322 \210\306f\323=\203o`#S=\203o\324\202\202\313\325!\203\201\326\225#=\203\201\327\202\202\330$\306%\331\216$\332>\203\306&\203\306\333 'l\203\255\334\306(\211)(B'B'**:\203\270*\202\274*\211B*\335'!*\202\316#b\210\336$!.\207" [modified buffer-undo-list inhibit-read-only inhibit-point-motion-hooks before-change-functions after-change-functions nil buffer-modified-p t c-literal-limits line-beginning-position looking-at "/[/*]" " 	" "^/[/*]" anchored-comment beginning-of-line empty-line back-to-indentation 125 end-block "#[ 	]*\\(endif\\|else\\)" 0 cpp-end-block other ((byte-code "\204
\301 \203
\302\303!\210\303\207" [modified buffer-modified-p set-buffer-modified-p nil] 2)) (anchored-comment empty-line) c-guess-basic-syntax comment-intro c-get-syntactic-indentation c-calc-comment-indent deactivate-mark buffer-file-name buffer-file-truename lim eot line-type case-fold-search c-indent-comments-syntactically-p c-syntactic-context args symbol c-comment-only-line-offset] 4 (#$ . 64318)])
(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) "\303[\304\"\305 \210	b\210)\306\302!\205\307\211\207" [count new-point zmacs-region-stays c-scan-conditionals -1 push-mark boundp t] 3 (#$ . 65818) "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) "\303[\304\305#\306 \210	b\210)\307\302!\205\305\211\207" [count new-point zmacs-region-stays c-scan-conditionals -1 t push-mark boundp] 4 (#$ . 66366) "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) "\303\304\"\305 \210	b\210)\306\302!\205\307\211\207" [count new-point zmacs-region-stays c-scan-conditionals 1 push-mark boundp t] 3 (#$ . 66731) "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) "\303\304\305#\306 \210	b\210)\307\302!\205\305\211\207" [count new-point zmacs-region-stays c-scan-conditionals 1 t push-mark boundp] 4 (#$ . 67268) "p"])
#@428 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.

The optional arguments TARGET-DEPTH and WITH-ELSE are historical,
and have the same meanings as in `c-scan-conditionals'.  If you
are calling c-forward-conditional from a program, you might want
to call `c-scan-conditionals' directly instead.
(defalias 'c-backward-conditional #[(count &optional target-depth with-else) "\305[	\n#\306 \210b\210)\307\304!\205\310\211\207" [count target-depth with-else new-point zmacs-region-stays c-scan-conditionals push-mark boundp t] 4 (#$ . 67634) "p"])
#@643 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.

If there aren't enough conditionals after (or before) point, an
error is signaled.

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

The optional arguments TARGET-DEPTH and WITH-ELSE are historical,
and have the same meanings as in `c-scan-conditionals'.  If you
are calling c-forward-conditional from a program, you might want
to call `c-scan-conditionals' directly instead.
(defalias 'c-forward-conditional #[(count &optional target-depth with-else) "\304	\n#\305 \210b)\207" [count target-depth with-else new-point c-scan-conditionals push-mark] 4 (#$ . 68323) "p"])
#@733 Scan forward across COUNT preprocessor conditionals.
With a negative argument, scan backward across preprocessor
conditionals.  Return the end position.  Point is not moved.

If there aren't enough preprocessor conditionals, throw an error.

"#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.  E.g. if TARGET-DEPTH is -1, the end position will be
outside 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-scan-conditionals #[(count &optional target-depth with-else) "\306V\211\203\f\307\202
\310	\203\311\202\312\313\211\250\204.\203+\307\202,\306\212\306U\2042\306\211\313\212\204\314\313\315#\203\316 \210\317\320!\203\313\321\310! \322\230\203k\n[ \202\264\323\230\203x\n \202\264\306U\203\264!\203\226\306V\203\217\310\202\220\307\211 \202\242\324\230\203\264\n[\211 \203\264 \306V\306X=\203\264\313  \203\364\306U\203\314 \306V\306X=\203\323 \\ \\\211W\203\364 \306W\203\364\325	\203\361\326\202\362\327!\210	\203\373\310y\210 \203U\203`*\202?	\203?\310y\210\202?)\204#\325\330!\210\211b\210+\n\\\211\2020)\331\332!\203<\315\f-\207" [count forward increment search-function new case-fold-search 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" boundp zmacs-region-stays target-depth found subdepth depth directive dchange with-else] 5 (#$ . 69169)])
#@1304 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), but the line is always reindented.

If `c-syntactic-indentation' is t, indentation is done according to
the syntactic context.  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.

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

  [*] 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) "\203	\306K\202\n\307\203X\n\203X\212\310 \210i)\311\211\312 \210\212\310 \210i)
Z\212\313=\2035\314 \210`\315`\316\"b\210`\fb\210\316y\210`)\fV\205T\317\f
\320$+\202\251\204r\212\321\311x\210n)\204m \202\251	 \202\251\313=\203~	 \202\251\322 \313\211\313\311\211\311\211\311\323\216\324 .\n\203\247 \210	 )\207" [c-syntactic-indentation indent-function arg end beg shift-amt indent-according-to-mode #[nil "	\306\232\203\307\202\310	!\311\n_!\210\f\205a\212\312\210`Sf)\313=\205a9\203W\212\314 \315\211\315\312\211\312\211\312\316\216\317 \205P`.\211\202X\205a\320``\312\315$*\207" [c-macro-start arg steps c-basic-offset c-auto-align-backslashes modified (4) -1 prefix-numeric-value c-shift-line-indentation nil 92 buffer-modified-p t ((byte-code "\204
\301 \203
\302\303!\210\303\207" [modified buffer-modified-p set-buffer-modified-p nil] 2)) c-beginning-of-macro c-backslash-region buffer-undo-list inhibit-read-only inhibit-point-motion-hooks before-change-functions after-change-functions deactivate-mark buffer-file-name buffer-file-truename] 6] back-to-indentation nil c-indent-line t beginning-of-line scan-sexps 1 indent-code-rigidly "#" " 	" buffer-modified-p ((byte-code "\204
\301 \203
\302\303!\210\303\207" [modified buffer-modified-p set-buffer-modified-p nil] 2)) c-in-literal c-tab-always-indent c-insert-tab-function modified buffer-undo-list inhibit-read-only inhibit-point-motion-hooks before-change-functions after-change-functions deactivate-mark buffer-file-name buffer-file-truename] 6 (#$ . 71172) "P"])
#@168 Indent each line in the balanced expression following point syntactically.
If optional SHUTUP-P is non-nil, no errors are signaled if no
balanced expression is found.
(defalias 'c-indent-exp #[(&optional shutup-p) "\305 \306\307	\310\"\210\311\216\214e\312 }\210\306`\306\313\314\217\211\203(\306\315\316\217\211\204\n\2057\nSfz\317=\2057\nS+\211\204H\f?\205l\320\321!\202lb\210\306\322\323\217\211\204_\f?\205l\320\324!\202l\306y\210`W\205l\325`\",\207" [end here beg start shutup-p point-marker nil set-marker-insertion-type t ((byte-code "b\210\301\211\223\207" [here nil] 3)) line-end-position (scan-lists end 1 -1) ((error)) (byte-code "\301\302\211#\207" [beg scan-lists 1] 4) ((error)) 40 error "Cannot find start of balanced expression to indent" (byte-code "\300`\301\"\207" [scan-sexps 1] 3) ((error)) "Cannot find end of balanced expression to indent" c-indent-region] 4 (#$ . 74155) "*P"])
#@200 Indent the current top-level declaration or macro syntactically.
In the macro case this also has the effect of realigning any line
continuation backslashes, unless `c-auto-align-backslashes' is nil.
(defalias 'c-indent-defun #[nil "\306 \307\211\310\216\311 \312\211\312\307\211\307\211\307\313\216\314!\2035\315\316\307\317 #\210\202<\320\321\307\322 #\210\323\307!.\n	\205L\324	@	A\",\207" [case-fold-search decl-limits here modified buffer-undo-list inhibit-read-only point-marker nil ((byte-code "b\210\301\211\223\207" [here nil] 3)) buffer-modified-p t ((byte-code "\204
\301 \203
\302\303!\210\303\207" [modified buffer-modified-p set-buffer-modified-p nil] 2)) looking-at c-backward-token-2 1 line-beginning-position c-forward-token-2 0 line-end-position c-declaration-limits c-indent-region inhibit-point-motion-hooks before-change-functions after-change-functions deactivate-mark buffer-file-name buffer-file-truename c-syntactic-eol] 5 (#$ . 75090) "*"])
#@216 Indent syntactically every line whose first char is between START
and END inclusive.  If the optional argument QUIET is non-nil then no
syntactic errors are reported, even if `c-report-syntactic-errors' is
non-nil.
(defalias 'c-indent-region #[(start end &optional quiet) "\212b\210\306\307x\210`	b\210\310 \210\306\307w\210`\310 \210\311!\307\211\312 \313\211\313\307\211 !\307\211\"#\307$\314\216\212\315 .\205J\316 Sf\317=\205J	\307\211%&'()*\320\216\321	\322#\210n\203\345m\204\345`*W\203\345\323 \210\324\325!\204\252'\203\203\324\326!\204\252\312 \313\211\313\307\211 !\307\211\"#\307$\327\216\330 %.\n\331%\313\211#\210'\203\314+\203\337\316 Sf\317=\204\337\332'\333\334!\307#\210\307'\202\337\335%\236\203\337\316 Sf\317=\203\337`'\307y\210\202`'\203\371+\203\371\332'\333\336!\307\313$\210)\337,!.\206)\211))\207" [end start modified buffer-undo-list inhibit-read-only inhibit-point-motion-hooks " 	\n
\f" nil beginning-of-line copy-marker buffer-modified-p t ((byte-code "\204
\301 \203
\302\303!\210\303\207" [modified buffer-modified-p set-buffer-modified-p nil] 2)) c-beginning-of-macro line-end-position 92 ((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 looking-at "\\s *$" "\\s *\\\\$" ((byte-code "\204
\301 \203
\302\303!\210\303\207" [modified buffer-modified-p set-buffer-modified-p nil] 2)) c-guess-basic-syntax c-indent-line c-backslash-region line-beginning-position 2 cpp-macro 0 c-echo-parsing-error before-change-functions after-change-functions deactivate-mark buffer-file-name buffer-file-truename syntax c-fix-backslashes ml-macro-start c-echo-syntactic-information-p c-parsing-error endmark c-auto-align-backslashes quiet] 7 (#$ . 76092)])
(defalias 'c-fn-region-is-active-p #[nil "\207" [mark-active] 1])
#@280 Indent active region, current line, or block starting on this line.
In Transient Mark mode, when the region is active, reindent the region.
Otherwise, with a prefix argument, rigidly reindent the expression
starting on the current line.
Otherwise reindent just the current line.
(defalias 'c-indent-line-or-region #[(&optional arg region) "\203\302\303 \304 \"\207\305	!\207" [region arg c-indent-region region-beginning region-end c-indent-command] 3 (#$ . 78006) (list current-prefix-arg (use-region-p))])
(defvar c-progress-info nil)
(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])
#@693 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.  The backslash alignment is
done according to the settings in `c-backslash-column',
`c-backslash-max-column' and `c-auto-align-backslashes'.

This function does not modify blank lines at the start of the region.
If the region ends at the start of a line and the macro doesn't
continue below it, the backslash (if any) at the end of the previous
line is deleted.

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 &optional line-mode) "\306 \212\307\310x\210n\205\311\312!)\203\313 \202e\310\211\211\212
b\210\204-o\204\210\204;n\203;\314u\210`\203Q\f`\310\223\210b\210\315\f\"\210\202\210\310\210`Sf\316=\205p\317y\320U\205p\310\210`Sf\316=\205piS\203\211\310\321\322\217\206\201]\204\211\323\203\232\204\232b\210\202I\320
b\210\203\246\317y\210\310\210`Y\203\321`Sf\316=\203\273\314u\210\307\310x\210	iT]\324 \210o\204\321\314u\210\202\251b\210\324 \210o\204\372\314u\210`Sf\316=\203\372iS\247\203\363\n]b\210\202\247\203b\210`
W\203n\203l\203\317y\210\202\n\203%\n	W\203%\310\n\204D	\246\320V\203?\325	\314#\245_	]\n^\203[\f
\310\223\210\326\f\n#\210\202\210\212
b\210\324 \210o?\205l\f`S\310\223)\203~\326\f\n#\210\f`\310\223\210\202\203\f
\310\223\210\315\f\"\210)\f\310\211\223\210\327!\205\230\310\211\223-\207" [bs-col-after-end longest-line-col column point-pos endmark to make-marker " 	" nil looking-at "[ 	]*\\\\?$" point-marker -1 c-delete-backslashes-forward 92 1 0 (line-end-position 0) ((error)) t beginning-of-line + c-append-backslashes-forward markerp line-mode delete-flag from c-auto-align-backslashes tab-width c-backslash-column c-backslash-max-column] 5 (#$ . 79353) "*r\nP"])
(defalias 'c-append-backslashes-forward #[(to-mark column point-pos) "\306\307 `\"	\203\234`\nX\205`\310\211\211\310\210`Sf\311=\204)\311c\210\312\306`\310\211%\313u\210i
\204A\3148\204\215	W\203]`\315`Y\205Rx\210`|\210	j\210\202\215	U\203k`Sf\316>\204\215`\315`Y\205wx\313U\203\204\310f\317U\204\215`\f|\210\320	\321\"\210\322\321y!,\205n\205\202\n`\nX\205`\310\210\306`\310\211%`Sf\311=\203\327\3148\204\361\313u\210`Sf\323>\203\321`U\203\361\317c\210\202\361`Sf\324>\203\354`U\204\354\311c\210\202\361\317\311\261\210\322\321y!)\205n\205\202\234)\207" [state column to-mark col end inserted parse-partial-sexp line-beginning-position nil 92 t -1 3 " 	" (32 9) 32 indent-to 1 zerop (32 9) (32 9) start point-pos] 6])
(defalias 'c-delete-backslashes-forward #[(to-mark point-pos) "`X\2050\302\210`Sf\303=\203\"`\304u\210\305`	Y\205	x\210`|\210\306\307y!\2050n\2050\202\207" [to-mark point-pos nil 92 -1 " 	" zerop 1] 4])
(defvar c-auto-fill-prefix t)
(defvar c-lit-limits nil)
(defvar c-lit-type nil)
(defalias 'c-guess-fill-prefix #[(lit-limits lit-type) "`\306	\307Q\310=\203\n\202\f\311\211-.\311\211/01\20391`2\312\216\313\3141\"\210i*B/\202(\310=\203\370\212\315.3A0\316 \210`3@V\203Y`-\202\3643@b\210\317y\320U\203s`3AW\203s`-\202\3643@b\210\321\n!\203\205\320\225b\210\202\214\322u\210\323\311w\210\311\21145\212\324 \210`)3@=\203\254\325\326 `\"5i4\202\325`3@Z\31167\327\2163@b\210i\330c\210j\210`67u\210\325\326 `\"5i4+\331\3325\"\204\341l\204\35154B\202\3615\333P4TB/*)\202(\2123A\322Zb\210\321\334!\203\n`\202
3A)0\212\316 \210`3@V\2031\321\335!\203+3A\320\225=\2041`-\202'3@b\210\317y\320U\203d`3AY\204d\321\335!\203T3A\320\225=\204d\321\n!\203o3AS\320\225X\203o8\206j\336.\202\276`W\203\273\317\224\203\230\317\224\317\225U\204\230\320\225\337 U\203\222\340\317!.\202\276`-\202\276\212\324 \210i)\2123@b\210i)X\203\2658\206\260\336.\202\276`-\202\276`-.\203'\311\2119:\341\2163@b\210\321
!\203\340\320\2250^b\210\202\347\322u\210\323\311w\210`Sfz\342=\203.\320\331\343.\"O\325\212\323\311x\210`)`\"P.\344 :\313\345.\346#\210\344 9\347 \2109Sb\210\325\326 `\"i+B/)/\206\326\212\311\211;<\350=\351\352\215\206\325;\203\266\331\332;\"\204R<b\210l\204Y;iB\202\2633@b\210\321
!\203k\320\225b\210\202r\322u\210\323\311w\210l\203`Sfz\342=\203\250\325\212\323\311x\210`)`\";<b\210\323\311x\210`6\353\216\313;!\210\325\326 `\"i*B\202\263;\333P<b\210iTB\206\325.\203\324\325-\212\324 \210`)\".P\324 \210i.G\\B\202\325\354,.\207" [here c-current-comment-prefix prefix-regexp lit-type comment-start-skip comment-start-regexp "[ 	]*\\(" "\\)[ 	]*" c++ nil ((byte-code "`|\207" [start] 2)) insert-and-inherit "\n" "// " beginning-of-line 1 0 looking-at 2 " 	" back-to-indentation buffer-substring-no-properties line-beginning-position ((byte-code "@	|\207" [lit-limits tmp] 2)) 10 string-match "\\s \\'" " " "\\*/" "[ 	]*\\*/" #1="" line-end-position match-string ((byte-code "\203	|\210	\302\211\223\210\302\211\223\210\302\207" [tmp-post tmp-pre nil] 3)) 32 "\\s *\\'" point-marker "x\n" "x" indent-according-to-mode #[nil "\304!\2054\305\225	X\2054\305\225\306 =\204%\307\310\311\305\224\305\225\"\305\225b\210iB\"\210\n\2043\311\305\224\305\225\"\305\225\312\207" [prefix-regexp comment-text-end fb-string fb-endpos looking-at 0 line-end-position 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) ((byte-code "`|\207" [tmp] 2)) (#1# . 0) prefix-line comment-prefix res comment-text-end fill-prefix start lit-limits col str tmp prefix-len c-block-comment-prefix tmp-post tmp-pre fb-string fb-endpos test-line] 6])
(defalias 'c-mask-paragraph #[(fill-paragraph apply-outside-literal fun &rest args) "\306\211\211\211\211\211\211`	@ABCD\203*D\307=\204*`DBD\310 E\307\211DF\307G\306\211HI\306\211JK\306L\311\216\214~\210\204U\312\306M\"\313!	\204a\314!)\212\306\315\316\217\204p\nb\210\317 \210\320 A)\212\306\321\322\217\204\203\nb\210\323 \210`B.\324\216	\325=\203\301\212A\211A^\306\223\210B@X\203\272@b\210\326 \210`@=\203\267\327 B\202\272\307@)\307N\202	\330=\203+AAV\204\364AAU\203ASf\331=\203ASSf\332=\203A@Z\333V\203\212Ab\210\334 \210\335\336O\337QA\340Z\307#\205\335\341A\340Z\342#?\205A\327 \306\223)\204\212Ab\210\343\344!\210`)P\212Pb\210i)QP\nZR\212Pb\210\345\346 \327 \307#\205]\347\225b\205]\350\351!\205]\347\225PU)S\306T\212Ab\210\320 \352c\210A`\306\223\210\353y\210\350\354O\355Q!\203\223P\347\225=\203\223\356\225\340\225ZT\202\227Pb\210\357\306x\210`PU\204\364\n`X\203\253\353RT\204\266QiZT\360`P\"M\203\327TS\203\321U\203\321\340\202\322\356^\356]T\361\362T\307#\210TR\347Y\205\357`RT^ZR\202\367\306R)R\203Rb\210-B@X\203%\212@b\210\350\363V\364Q!\203!\327\340!B\202$\307@)\307N\202	\365=\203n\212AAY\203KASb\210\320 \352c\210A`\306\223\210B@X\203g@Tb\210\350\366!\203d\347\225T\202e`B)\307N\202	\367=\203\273\212\310 E\307\211DF\307G\306\211HI\306\211JK\306L\370\216\371 \210\334 \210`BV\203\243`B\372 \210\306y\210`AW\203\266A`\306\223\210.\202\310 E\307\211DF\307G\306\211HI\306\211JK\306L\373\216\212Bb\210\214eA\206\346d}\210\374 \210)\334 \210`BAb\210\214B\206\375ed}\210\375 \210)\306y\210A`\306\223\210.@\203\265\310 E\307\211DF\307G\306\211HI\306\211JK\306L\376\216\377	\".\nC\201\\\201]O\201^QC@\"\204X\201_\201`C@\"\210\212@b\210\350	\325=\203iO\202kV!\203v\347\225b\210\202\340u\210\201a\306w\210iCAW\203\221l\204\221\356u\210\202iW`TB`C@\201b\216\201c\201dC@\"\210\361\362WiZ\307#\210+N\205eX\206	\325=\205\201e\201Y!\205\321Y?\205\201\\\201f\201gBA\"\206\351\201h\"?\205\310 E\307\211DF\307G\306\211HI\306\211JK\306L\201i\216C\206\377	\"@.\n`BW\203(`BZ\2023`AV\2053`AZRX\214BA}\210\201jZ[\")R\203dR\347W\203]BR\\b\210\202dAR\\b\210*.\207" [c-lit-limits c-lit-type here auto-fill-spaces hang-ender-stuck tmp-post nil t buffer-modified-p ((byte-code "\204
\301 \203
\302\303!\210\303\207" [modified buffer-modified-p set-buffer-modified-p nil] 2)) c-literal-limits c-collect-line-comments 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	\203I\212	b\210\306\307!\210)\n\203D`	b\210\310\311!\210\n[u\210\f\2041
\204:\312\313\n\314#\210\202=
c\210\306\n!\210b\210	\315\211\223\210\315\211\223\207" [tmp-pre tmp-post hang-ender-stuck here fill-paragraph auto-fill-spaces delete-char 1 skip-syntax-backward "^w " insert-char 32 t nil end] 4)) c++ back-to-indentation line-beginning-position c 47 42 3 beginning-of-line search-forward-regexp "\\=[ 	]*\\(" "\\)" 2 "\\(\\s \\|\\sw\\)" limit skip-syntax-backward "^w " search-backward-regexp sentence-end 0 looking-at "[ 	]*" 10 -1 "[ 	]*\\(\\(" "\\)[ 	]*\\)" 1 " 	
\n" delete-and-extract-region insert-char 120 "\\(" "\\)$" string "\\\\$" pound ((byte-code "\204
\301 \203
\302\303!\210\303\207" [modified buffer-modified-p set-buffer-modified-p nil] 2)) c-beginning-of-macro c-end-of-macro ((byte-code "\204
\301 \203
\302\303!\210\303\207" [modified buffer-modified-p set-buffer-modified-p nil] 2)) c-forward-sws c-backward-sws ((byte-code "\204
\301 \203
\302\303!\210\303\207" [modified buffer-modified-p set-buffer-modified-p nil] 2)) c-guess-fill-prefix tmp-pre end beg fill buffer-undo-list modified inhibit-read-only inhibit-point-motion-hooks before-change-functions after-change-functions deactivate-mark buffer-file-name buffer-file-truename fill-paragraph apply-outside-literal c-current-comment-prefix ender-start ender-column point-rel sentence-ends-comment spaces sentence-end-double-space comment-start-skip col fill-prefix filladapt-mode fun args string-match "\\`[ 	]*\\(" "\\)[ 	]*\\'" message "Warning: Regexp from `c-comment-prefix-regexp' doesn't match the comment prefix %S" " 	" ((byte-code "`\241\207" [tmp-pre] 2)) insert-and-inherit "\n" boundp "\\`[ 	]*//" fill-context-prefix "" ((byte-code "\204
\301 \203
\302\303!\210\303\207" [modified buffer-modified-p set-buffer-modified-p nil] 2)) apply] 11])
#@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) "\302=?\205\303\304\305\306	$\210)\304\207" [fill-paragraph-function arg c-fill-paragraph c-mask-paragraph t nil fill-paragraph] 5 (#$ . 90299) "*P"])
(defalias 'c-do-auto-fill #[nil "\302\303\304\305#)\207" [fill-prefix c-auto-fill-prefix c-mask-paragraph nil t do-auto-fill] 4])
#@653 Break line at point and indent, continuing comment or macro 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 inside a macro, a line
continuation backslash is inserted and aligned as appropriate, and the
new line is indented according to `c-syntactic-indentation'.

If a fill prefix is specified, it overrides all the above.
(defalias 'c-indent-new-comment-line #[(&optional soft allow-auto-fill) "\306	\n\307 \310\21156\3107\311\21189\311\211:;\311<\312\216=\310=\204\272	\2048\313\311\211\310#\n\204@\314	!9\203p\212\307 \310\21156\3107\311\21189\311\211:;\311<\315\216\316 \205i`.\211\202q\203x\317\202\201\n\204\200\320\202\201\n>>\203\214\310\202\272=\204\244\n\321=\203\244\322 	@X\203\244\311\202\272\n\323=\203\272\324\325?P\206\264\326\"\204\272\311.\n\310=\206\254\203\317\f \210\327!\202\254\307 \310\21156\3107\311\21189\311\211:;\311<\330\216	\204\363\313 \n\204\373\314	!\n\331>.\n\203F@\204\212	@b\210\311\210`	AW)\203\345\307 \310\21156\3107\311\21189\311\211:;\311<\332\216\333\334	!\211\n\".\n`i\n\321=\203Y\212	A\335Zb\210\336\337!\205U`)\206[	AABCDiDAW\203ul\204u\340u\210\202c`AV\203\260\322 	@V\203\260\341C\310\"C\342 \210\327D@!\210E\203\240\327\343!\210\202\244\344\340!\210Cb\210C\311\211\223\202\341`AV\203\276Ab\210\202\315`	@\335\\W\203\315	@\335\\b\210\f \210\327D@!\210iBV\205\341\345B!,\202\254FG\311HGF\n\321=\203\324\346F\"\204\347F\350G\202\324\351F\"\204\352F\326G\212\353 \210i)H\f \210G\2037G\326\232\2047\354u\210\327G!\210\340u\210Hj\210\327F!\210\355 +\202\2549\203v\212\307 \310\21156\3107\311\21189\311\211:;\311<\356\216\316 \205o`.\211\202w\203\217\336\357!\204\203\360 \210\361I?\205\213\340!\202\254\212\342 \210\336\362!\203\240\354y\363U\204\223\364 )H\f \210Hj)-\207" [fill-prefix c-lit-limits c-lit-type c-macro-start do-line-break modified #[nil "\302 \210\203\303\304!\207\305	?\205\306!\207" [soft allow-auto-fill delete-horizontal-space insert-and-inherit 10 newline 1] 2] buffer-modified-p t nil ((byte-code "\204
\301 \203
\302\303!\210\303\207" [modified buffer-modified-p set-buffer-modified-p nil] 2)) c-literal-limits c-literal-type ((byte-code "\204
\301 \203
\302\303!\210\303\207" [modified buffer-modified-p set-buffer-modified-p nil] 2)) c-beginning-of-macro cpp code c line-beginning-position c++ string-match "\\`[ 	]*" "" insert-and-inherit ((byte-code "\204
\301 \203
\302\303!\210\303\207" [modified buffer-modified-p set-buffer-modified-p nil] 2)) (c c++) ((byte-code "\204
\301 \203
\302\303!\210\303\207" [modified buffer-modified-p set-buffer-modified-p nil] 2)) c-guess-fill-prefix c-collect-line-comments 2 looking-at "\\*/" 1 copy-marker beginning-of-line 10 newline move-to-column "[ 	]*/\\*" "/* " " */" "[ 	]*//" "// " back-to-indentation -1 indent-for-comment ((byte-code "\204
\301 \203
\302\303!\210\303\207" [modified buffer-modified-p set-buffer-modified-p nil] 2)) "[ 	]*\\\\$" delete-horizontal-space c-newline-and-indent "[ 	]*\\\\?$" 0 current-indentation buffer-undo-list inhibit-read-only inhibit-point-motion-hooks before-change-functions after-change-functions deactivate-mark buffer-file-name buffer-file-truename c-auto-fill-prefix c-ignore-auto-fill c-line-comment-starter comment-multi-line comment-text-end start-col pos fill soft comment-start comment-end col allow-auto-fill] 6 (#$ . 91465) nil])
(byte-code "\300\301\302\"\210\303\301\302\304#\210\305\306!\204)\307\310!\210\311\312\313\314\310$\210\315\312\316\317\320B#\210\321\312\310\"\210\310\207" [defalias c-comment-line-break-function c-indent-new-comment-line make-obsolete "21.1" boundp comment-line-break-function (lambda (#1=#:def-tmp-var) (defvar c-inside-line-break-advice #1#)) 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-set-advice-info-field cache #[(&optional soft) "\304	\204\n\n\204\305!\202\306\307!\210))\207" [ad-return-value c-inside-line-break-advice c-buffer-is-cc-mode soft nil ad-Orig-indent-new-comment-line t c-indent-new-comment-line] 2 #("Advice doc string" 0 17 (ad-advice-info indent-new-comment-line)) nil] (nil (c-line-break-advice) nil function t t) ad-activate] 5)
#@820 Do a line break suitable to the context.

When point is outside a comment or macro, insert a newline and indent
according to the syntactic context, unless `c-syntactic-indentation'
is nil, in which case the new line is indented as the previous
non-empty line instead.

When point is inside the content of a preprocessor directive, a line
continuation backslash is inserted before the line break and aligned
appropriately.  The end of the cpp directive doesn't count as inside
it.

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 it.

When point is inside a string, only insert a backslash when it is also
inside a preprocessor directive.
(defalias 'c-context-line-break #[nil "\306\211\n\306\307 \310\211\310\306\211 !\306\211\"#\306$\311\216\312\306\211\310#\313!\211\314=\2038\315!\n9\203f\212\307 \310\211\310\306\211 !\306\211\"#\306$\316\216\317 \205``.\202h\n\210.\n	\320=\204\263	\314=\203\204\212\321\306w\210`)ASW\204\263\n\247\203\301	\322=\204\301\323\324!\203\235`Sf\325=\203\301\212\nb\210\323%!\203\254\326\225b\210`)`X\203\301\310\306&'\327\306\310\"*\202	\322=\203\334\n\247\203\327`Sf\325=\204\327\325c\210\330 \202\331 \210\330 \210\212\332u\210\326y\210\323\333!\203\366\332y\326U\204\351\334 )\211(j\210)\335 ,\207" [c-lit-limits c-lit-type c-macro-start case-fold-search modified buffer-undo-list nil buffer-modified-p t ((byte-code "\204
\301 \203
\302\303!\210\303\207" [modified buffer-modified-p set-buffer-modified-p nil] 2)) c-literal-limits c-literal-type c++ c-collect-line-comments ((byte-code "\204
\301 \203
\302\303!\210\303\207" [modified buffer-modified-p set-buffer-modified-p nil] 2)) c-beginning-of-macro c " 	" string looking-at "\\s *$" 92 0 c-indent-new-comment-line newline delete-horizontal-space -1 "[ 	]*\\\\?$" current-indentation indent-according-to-mode inhibit-read-only inhibit-point-motion-hooks before-change-functions after-change-functions deactivate-mark buffer-file-name buffer-file-truename c-opt-cpp-start fill-prefix comment-multi-line col] 5 (#$ . 96325) "*"])
#@211 Insert a line break suitable to the context and leave point before it.
This is the `c-context-line-break' equivalent to `open-line', which is
normally bound to C-o.  See `c-context-line-break' for the details.
(defalias 'c-context-open-line #[nil "`\301\216\302c\210\303 *\207" [here ((byte-code "b\210\301\302!\207" [here delete-char 1] 2)) 120 c-context-line-break] 1 (#$ . 98600) "*"])
(provide 'cc-cmds)
F1l3 Manager
