| Current File : //proc/thread-self/root/kunden/usr/share/emacs/27.2/lisp/progmodes/cc-cmds.elc |
;ELC
;;; Compiled
;;; in Emacs version 27.2
;;; 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\254 \306 \206V \317\320!\205V !\321 \"\316\211 # $\316 %\322\216\306 &\204u \323 \324!&\325'!\204\217 (\203\217 \326\327&#\210&\330 Z.\331 !\210\332\333!\210!*\206\247 !!\202\315 \315 &\212\334y\315U\203\301 \311\335!\204\260 \330 &)&\330 Z\331 !\210)\203\357 \203\357 \n\203\344 \212\nj\210\307c\210)\202\357
\203\357 \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 #[nil "?\205 \301\302!\207" [#1=#:modified restore-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 #1# buffer-undo-list inhibit-read-only inhibit-modification-hooks indent quiet c-echo-syntactic-information-p] 6 (#$ . 530)])
#@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\216\311 \205 `.\202 \312\211\211\211\211 \212\313 \210`\314\315!\203@ \316y\317U\2043 \320 )\203i l\203] `Sf\321=\203] \307\211 \202i \322 \206c `Sf\321= \323 !\210
j\210\203\234 \203\212 \321c\210\316u\210\324``\312\307$\210\202\234 \324 \203\226 `\202\230 \312\307$\210 \205\321 \306 !\307\211\307 \325\216\326 - \"\327c\210\330 \210d`Z\331\216\316u\210\332 \210* \205\321 \324``\312\307$.\207" [c-macro-start #1=#:modified buffer-undo-list inhibit-read-only inhibit-modification-hooks col buffer-modified-p t #[nil "?\205 \301\302!\207" [#1# restore-buffer-modified-p nil] 2] c-beginning-of-macro nil beginning-of-line looking-at "[ ]*\\\\?$" -1 0 current-indentation 92 line-end-position newline c-backslash-region #[nil "?\205 \301\302!\207" [#2=#:modified restore-buffer-modified-p nil] 2] c-guess-basic-syntax 10 delete-horizontal-space #[nil "dZb\210\301\302!\207" [start delete-char -1] 2] indent-according-to-mode start insert-backslash has-backslash c-fix-backslashes newline-arg c-syntactic-indentation #2# c-syntactic-context] 7 (#$ . 2391)])
#@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 \312\216\313 - :\204\243 \306\211\211 \314\315\"\210\316\216\203\233 \211A\242\211 \211 A:\203Q A\242\202T A)\211 \203r \317 \211T\" !\320!\321\322#\210!) B \211 \243\243\242)\211 \2033 \317 \211T\" !\320!\321\323#\210!) B \2023 \324\325!\210,\202\256 \326 \210\327\330\331\"!\210*\307\332!\205\271 \311\211\207" [c-parsing-error c-syntactic-context #1=#:modified buffer-undo-list inhibit-read-only inhibit-modification-hooks nil boundp buffer-modified-p t #[nil "?\205 \301\302!\207" [#1# restore-buffer-modified-p nil] 2] c-guess-basic-syntax message "Syntactic analysis: %s" #[nil "\205 \301\211A\242!\210\202 \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 syntax arg ols pos elem langelem ol] 5 (#$ . 3854) "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 (#$ . 4964) "*r"])
(defvar c-block-comment-flag nil)
(make-variable-buffer-local 'c-block-comment-flag)
(defalias 'c-update-modeline #[nil "\306\307\203\n \310\202 \311 \203 \312\202 \313 \203 \n\203 \314\202! \313 \203) \315\202* \313\316\317!\2039 \317J\2039 \320\202: \313&\321\322\f\"\203J \323\324\f\"\202K \f \211 G\324V\203\\
P\202]
\325 *\207" [c-block-comment-flag c-electric-flag c-auto-newline c-hungry-delete-key mode-name bare-mode-name format "/%s%s%s%s%s" "*" "/" "l" "" "a" "h" boundp c-subword-mode "w" string-match "\\(^[^/]*\\)/" match-string 1 force-mode-line-update fmt] 9])
#@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 (#$ . 5825) "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 (#$ . 6811) "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 (#$ . 7639) "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 (#$ . 8205) "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\306!\203 \306 \203 \307\202 \310!\210\311\302!\205# \312\211\207" [arg c-electric-flag zmacs-region-stays c-calculate-state c-update-modeline fboundp electric-indent-local-mode 1 0 boundp t] 3 (#$ . 8739) "P"])
#@289 Toggle the comment style between block and line comments.
Optional numeric ARG, if supplied, switches to block comment
style when positive, to line comment style when negative, and
just toggles it when zero or left out.
This action does nothing when the mode only has one comment style.
(defalias 'c-toggle-comment-style #[(&optional arg) "\203 \203 \306\n \"\202 \203 \307\202 \310\211\203! \202\" \311P \203/ \311
P\2020 \312\203Q \203Q \203Q
\203Q \212\214~\210eb\210\313ed\"\210*\314 \210\315\316!\205^ \310\211\207" [c-line-comment-starter c-block-comment-starter arg c-block-comment-flag comment-start c-block-comment-ender c-calculate-state nil t " " "" font-lock-flush c-update-modeline boundp zmacs-region-stays comment-end c-mark-wrong-style-of-comment font-lock-mode] 4 (#$ . 9230) "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\216\f?\206
\206 \311 -\203! \f\312
!!\207\313 \207" [#1=#:modified buffer-undo-list inhibit-read-only inhibit-modification-hooks c-hungry-delete-key arg buffer-modified-p t #[nil "?\205 \301\302!\207" [#1# restore-buffer-modified-p nil] 2] c-in-literal prefix-numeric-value c-hungry-delete-backwards c-backspace-function] 4 (#$ . 10059) "*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 (#$ . 10818) 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\216\f?\206
\206 \311 -\203! \f\312
!!\207\313 \207" [#1=#:modified buffer-undo-list inhibit-read-only inhibit-modification-hooks c-hungry-delete-key arg buffer-modified-p t #[nil "?\205 \301\302!\207" [#1# restore-buffer-modified-p nil] 2] c-in-literal prefix-numeric-value c-hungry-delete-forward c-delete-function] 4 (#$ . 11224) "*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 (#$ . 11980) 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 (#$ . 12324) "*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 (#$ . 12997) nil])
#@75 Known unsafe functions when members of `post-self-insert-hook' in CC Mode
(defvar c--unsafe-post-self-insert-hook-functions '(electric-pair-post-self-insert-function) (#$ . 13665))
(defalias 'c--call-post-self-insert-hook-more-safely-1 #[nil "\304\211\203E \n@ >\204> \n@\305=\2037 \306\300!\211\2033 \n@ >\204, \307\301\n@\305#\210\nA\211\204 )\202> \307\301\n@\305#\210\nA\211\204 \310\301!*\207" [post-self-insert-hook dest src c--unsafe-post-self-insert-hook-functions nil t default-value add-hook run-hooks] 5])
(defalias 'c--call-post-self-insert-hook-more-safely '(macro . #[nil "\300\301!\203 \302\207\303\207" [boundp post-self-insert-hook (c--call-post-self-insert-hook-more-safely-1) (progn)] 2]))
#@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\216\f\206=
?\206= \311>?\206= \212\312\313x\210n)?\206= \212\314y\315U\2057 \313\210`Sf\316=)\206= \317 -\203N \313 \320\321\f!!\210)\202l d`Zn \322 \210\323 \210c\210\204k dZb\210*\324 \207" [#1=#:modified buffer-undo-list inhibit-read-only inhibit-modification-hooks arg c-electric-flag buffer-modified-p t #[nil "?\205 \301\302!\207" [#1# restore-buffer-modified-p nil] 2] alignleft " " nil -1 0 92 c-in-literal self-insert-command prefix-numeric-value beginning-of-line delete-horizontal-space c--call-post-self-insert-hook-more-safely-1 c-electric-pound-behavior post-self-insert-hook bolp pos last-command-event] 4 (#$ . 14390) "*P"])
(defalias 'c-point-syntax #[nil "\306 \307\211\307\310\216\311\211 \311\211 \312\216\311 B\313 \314\315\316\"\210\212\317\320!\206, e \321x\210l\203L `Sf\322=\203L `V\203L \323u\210\202. )\205U )\204p ` \212\323u\210\324 \205l \325 \210`W*\203{ \323u\210\314\322\316\"\210\311u\210\307\211 \326 *\311+
.\207" [#1=#:modified buffer-undo-list inhibit-read-only inhibit-modification-hooks c-echo-syntactic-information-p syntax buffer-modified-p t #[nil "?\205 \301\302!\207" [#1# restore-buffer-modified-p nil] 2] nil #[nil "\302 \"\207" [-tnt-chng-keep -tnt-chng-state c-tnt-chng-cleanup] 3] 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 -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\216\311 \312\211 \2059 \212\31316 `Sf\314U\203* \315u\210\2020 \316`\315\"b\210\317 0\2028 \210\312)?\205\232 \f\320\236\203` \321\236\203P \322\202b \323\236\203[ \324\202b \202b \211 \312 \203\216 @ \236\211 \204\216 A\211 \204y +@\236+\206\232 \325\211A:\204\272 \326A!\203\272 A@`\")\202\275 A.\207" [#1=#:modified buffer-undo-list inhibit-read-only inhibit-modification-hooks syms c-echo-syntactic-information-p buffer-modified-p t #[nil "?\205 \301\302!\207" [#1# restore-buffer-modified-p nil] 2] (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) nil (error) 123 -1 scan-sexps c-looking-at-special-brace-list inexpr-class class-open ((inexpr-class-open)) class-close ((inexpr-class-close)) (ignore before after) functionp 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\31012 \311`\312\"b0\2027 \210\306\202F \205F \306u\210` S}\210\313\314!*\205\306\211 \315\216\306!B!\316 \317\224 \317\225\320\224\320\225\312u\210\212\321 \205z ` ZZ)
\f|\210 |\210\212\306\210i)\n\203\312 \322\317!\210\nb\210iT\nT\323\306x\210l\203\264 `Sf\324=\203\264 \312u\210\202\236 \325\326\317\"\210 iZ\211\327U\203\312 \325\330\317\"\210\317\"?\206\366 \"\327U\206\366 \"X\206\366 \205\366 Z\"W\205\366 \nb\210\331 \"Z!\210\332\211 +\205d Zb.\n\207" [cmnt-gap cmnt-col cmnt-pos eol-col mend4 mbeg4 nil -2 (error) scan-sexps -1 looking-at "\\([ ]*\\([
\n][ ]*\\)?\\)[^
\n]+\\([ ]+[^
\n]+\\)*\\([ ]*\\([
\n][ ]*\\)?\\)\\'" #[nil "\302 \"\207" [-tnt-chng-keep -tnt-chng-state c-tnt-chng-cleanup] 3] c-tnt-chng-record-state 1 4 c-backward-single-comment delete-char " \n
\f " 92 insert-char 125 0 32 backward-delete-char-untabify t mend1 mbeg1 pos here -tnt-chng-state -tnt-chng-keep buffer-undo-list c-max-one-liner-length] 11])
(defalias 'c-do-brace-electrics #[(before after) "\306\211\211\211\211 \307 \310\211 0 1\310 2\311\216\310\211 3 4\312 .5\203, \313\n!\2106\205\361\314u\210\315 \316 !\204M \317 >\203M i\320 V\204T \321=\203b 5\203_ \322 \210\202b \323 \210\306u\210\317 >\203o \202p \n`d`Z\306\211 7 8 9 :\307 ;\310\211 0 1\310 2\324\216\325<>\205\351 =\326=\205\351 \327 > ?\306 @?\203\277 ?@>\236\211@\204\277 ?A\211?\204\252 @+\205\351 \314u\210\330\306x\210l\203\336 `Sf\331=\203\336 \314u\210\202\310 `Sf\332=\205\351 \333 ?-\203\371 `:S|\210d9Z::b\210\334 A\335\216=\326=\203E\336<>\203E\337 > ?\306 @?\2034?@>\236\211@\2044?A\211?\204 @+\203E\340 \203Ed9Z:*=\332=\203\316\341<>\203i\342\343\306\310#\203i\344\224\344\225|\210\345\346!\210\202\316\347<>\203\316:Sb\210`7\330\306x\210l\203\216`Sf\331=\203\216\314u\210\202x`8`Sf\350=\203\316\307 B\310\211 0 1\310 2\351\216\352\353\310\"-\344U\203\316\306f\354=\203\316\342\355\306\310#\203\31687|\2108b\210\356c\210d9Zb\2105\203\334\313 \210,/\204\350\357 >\204\357/\321=\205\361\323 -\207" [syntax br-syntax ln-syntax newlines c-echo-syntactic-information-p #1=#:modified nil buffer-modified-p t #[nil "?\205 \301\302!\207" [#1# restore-buffer-modified-p nil] 2] c-guess-basic-syntax c-indent-line -1 c-point-syntax c-brace-newlines before current-indentation assume newline c-newline-and-indent #[nil "?\205 \301\302!\207" [#2=#:modified restore-buffer-modified-p nil] 2] empty-defun-braces 125 (defun-close class-close inline-close) " \n
\f " 92 123 c-in-literal match-data #[nil "\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 #[nil "?\205 \301\302!\207" [#3=#:modified restore-buffer-modified-p nil] 2] c-backward-token-2 1 40 "}\\([ \n]\\|\\\\\n\\)*else\\([ \n]\\|\\\\\n\\)+if\\([ \n]\\|\\\\\n\\)*\\=" 32 after buffer-undo-list inhibit-read-only inhibit-modification-hooks c-syntactic-indentation-in-macros c-auto-newline-analysis c-syntactic-indentation c-auto-newline mend mbeg pos here #2# c-cleanup-list last-command-event alist list match save-match-data-internal #3#] 6])
#@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!\311\312!\205 \312 \306\211 ! \"\313 #\314\211 $ %\314 &\315\216\316`\317 \"\"\320\"!!-\306 '\321\322(!!\210)\323\324!\203u \203u \325 \314\306 ' ) *\326 \210\f\205m +\327=\205m \306f\330=\325 *W+!\204\267 (\204\267 ,\203\267 \204\267 \f\204\222 \331 \210\202\267 \203\241 \331 \210\332\333\306\"\210\202\267 \332\306\211\"\210\n\203\267 \212\306u\210\332\334\333\"\210)\331 \210+\330=\203\354 -\204\354 \203\354 \212\313 .\314\211 $ %\314 &\335\216\214\"\206\337 ed}\210\336 \210. \210)\337 . \207" [blink-paren-function electric-pair-deletion got-pair-} active-region at-eol case-fold-search nil looking-at "[ ]*\\\\?$" fboundp use-region-p buffer-modified-p t #[nil "?\205 \301\302!\207" [#1=#:modified restore-buffer-modified-p nil] 2] c-safe-position c-parse-state c-in-literal self-insert-command prefix-numeric-value boundp electric-pair-mode buffer-size electric-pair-post-self-insert-function 123 125 c-indent-line c-do-brace-electrics ignore assume #[nil "?\205 \301\302!\207" [#2=#:modified restore-buffer-modified-p nil] 2] c-backward-sws c--call-post-self-insert-hook-more-safely-1 old-blink-paren literal safepos #1# buffer-undo-list inhibit-read-only inhibit-modification-hooks post-self-insert-hook arg c-in-electric-pair-functionality size last-command-event c-electric-flag executing-kbd-macro #2#] 10 (#$ . 20982) "*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\216\311 -\312\211 \204\\ \313=\203\\ \314 >\203\\ \315=\203\\ \316\317\320 !\321Q!\203\\ \212\214e`}\210\322 \210\316!\323P!*\203\\ \324y\210`\312\210`|\210\325\326\327\"\210 ?\205\201 \"\205\201 #\205\201 \315=\205\201 `Sf \203 \326\202\200 \315=\312 $\330\331 !!\210)
\203\224 \332 \210\333 +\207" [#1=#:modified buffer-undo-list inhibit-read-only inhibit-modification-hooks c-echo-syntactic-information-p indentp buffer-modified-p t #[nil "?\205 \301\302!\207" [#1# restore-buffer-modified-p nil] 2] c-in-literal nil 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 c--call-post-self-insert-hook-more-safely-1 literal arg c-cleanup-list last-command-event comment-end c-current-comment-prefix c-syntactic-indentation c-electric-flag post-self-insert-hook] 5 (#$ . 23020) "*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\310 !!\210)\311 \312\211 \312 \313\216\205K \205K ?\205K \314 \315=\205K `Sf\316=\205K \212\317u\210\320\306x\210`Sf\321=\203E \317u\210\322\306x\210n)-\203V \306 \323 \210)\324 \207" [post-self-insert-hook arg #1=#:modified buffer-undo-list inhibit-read-only inhibit-modification-hooks nil self-insert-command prefix-numeric-value buffer-modified-p t #[nil "?\205 \301\302!\207" [#1# restore-buffer-modified-p nil] 2] c-in-literal c 42 -1 "*" 47 " " indent-according-to-mode c--call-post-self-insert-hook-more-safely-1 c-syntactic-indentation c-electric-flag c-echo-syntactic-information-p] 4 (#$ . 24643) "*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 !\311\216\312\313 !\314!-\306 \"\315\316#!!\210)$\203\371 \204\371 #\204\371 %\203F \317\320!\204Q &\203\371 \321 \210\202\371 d`Z '\307 (\310\211 \310 !\322\216)\323=\203s \324*>\204\201 )\325=\205\246 \326*>\205\246 \327u\210\330\306x\210l\203\232 `Sf\331=\203\232 \327u\210\202\204 `Sf\332=\205\246 \314!?-\203\256 ` |\210d'Zb\210)&\203\301 \333 \321\n!\210+\306\211 , - ..\203\360 .@ \211-\204\343 .A\211.\202\315 \306.-\334=?,\202\313 ,\203\370 \335 \210+\336 -\207" [lim literal c-syntactic-context here c-echo-syntactic-information-p #1=#:modified nil buffer-modified-p t #[nil "?\205 \301\302!\207" [#1# restore-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 #[nil "?\205 \301\302!\207" [#2=#:modified restore-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 c--call-post-self-insert-hook-more-safely-1 buffer-undo-list inhibit-read-only inhibit-modification-hooks post-self-insert-hook arg c-electric-flag c-auto-newline c-syntactic-indentation pos #2# last-command-event c-cleanup-list c-hanging-semi&comma-criteria add-newline-p answer criteria] 4 (#$ . 25661) "*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 '\314\216\315 !- (\306\211 ) *\306\211 + ,\316\317-!!\210).\203\304(\204\304-\204\304\310\320!\204a /\203\304\321 \210\202\304d`Z` 0 1\312 2\313\211 &\313 '\322\2163\205\271 \3234>\205\271 `Sf\324=\205\271 \325u\210\326\306x\210l\203\244 `Sf\327=\203\244 \325u\210\202\216 `Sf\324=\205\271 \315 ?\205\271 `\330Zf\324=?-\203\306 `0S|\210\313*d1Zb\210*/\203\325 \321 \210\312 5\313\211 &\313 '\331\216\313\211 6 7\332 \211 8\211 9\203\f9@@\333=\2039@\334\240\2109A\2119\204\364 3\205\210\3358: ; <\211 =< > =\306 ?=\203@=@>\236\211?\204@=A\211=\204+?+@;\236+\206\210\336\337c\210\340\216\332 ): ; <\211 =< > =\306 ?=\203\200=@>\236\211?\204\200=A\211=\204k?+@;\236+). \341)>\203\264*\204\264\212\342\306x\210n)\204\264d`Z 1\325u\210\343 \210d1Zb\210)\344)\243>\203\304*\204\304\343 \210\345 -\207" [end-of-defun-function beginning-of-defun-function defun-prompt-regexp bod #1=#:modified buffer-undo-list nil beginning-of-defun looking-at 0 buffer-modified-p t #[nil "?\205 \301\302!\207" [#1# restore-buffer-modified-p nil] 2] c-in-literal self-insert-command prefix-numeric-value "[ ]*\\\\?$" indent-according-to-mode #[nil "?\205 \301\302!\207" [#2=#:modified restore-buffer-modified-p nil] 2] scope-operator 58 -1 " \n
\f " 92 2 #[nil "?\205 \301\302!\207" [#3=#:modified restore-buffer-modified-p nil] 2] c-guess-basic-syntax substatement-label label (case-label label access-label) (member-init-intro inher-intro) 10 #[nil "\300\301!\207" [delete-char -1] 2] before ": " c-newline-and-indent after c--call-post-self-insert-hook-more-safely-1 inhibit-read-only inhibit-modification-hooks literal newlines is-scope-op c-echo-syntactic-information-p post-self-insert-hook arg c-electric-flag c-syntactic-indentation here pos #2# c-auto-newline c-cleanup-list #3# c-syntactic-indentation-in-macros c-auto-newline-analysis syntax elem c-hanging-colons-alist alist2 alist1 list alist match] 4 (#$ . 27731) "*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 \307\211\307\310\216\311 -\312\211\211\211\211\211 ! \" # $ %\312 &\313\314'!!\210)`!'\204 %\204 \315 \210\316(!\205a )\317=\203R \320\225!S=\202a !Sb\210\321\322 x\210`Sf\317=#!b\210*\203\355 +\203\355 ,\203\355 )\317=\203\267 \323u\210`\324 \210`U\203\232 \325 \210\316-!\203\232 \307\211$\206\341 .\326=\205\341 !Sb\210\324 \210\316\327!\205\341 \320\225!Y\202\341 \330!S\331\"\203\307 \307\211$\206\341 .\326=\205\341 !Sb\210\324 \210\316\332!\205\341 \320\225!Y!b\210
\203\355 \333 \210\334\335!\203 \203 $\204#\203 \312 &\336 \210)
\203#`Sf\337=\203#/\204#0\203#0 \210.\340 \207" [#1=#:modified buffer-undo-list inhibit-read-only inhibit-modification-hooks case-fold-search found-delim buffer-modified-p t #[nil "?\205 \301\302!\207" [#1# restore-buffer-modified-p nil] 2] c-in-literal nil self-insert-command prefix-numeric-value beginning-of-line looking-at 60 0 "^<>" line-beginning-position -1 c-beginning-of-current-token c-backward-token-2 c++-mode "<<" get-text-property syntax-table ">>" indent-according-to-mode boundp electric-pair-mode electric-pair-post-self-insert-function 62 c--call-post-self-insert-hook-more-safely-1 final-pos c-echo-syntactic-information-p include-delim template-delim literal post-self-insert-hook arg c-cpp-include-key last-command-event c-electric-flag c-syntactic-indentation c-recognize-<>-arglists c-opt-<>-sexp-key c-buffer-is-cc-mode executing-kbd-macro blink-paren-function] 8 (#$ . 30471) "*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\216\311 -\312\211 .\312 /\313\3140!!\210)0\204{.\204{1 2\312 13\203= 4\203= \315 \2104\203\261 5\203\261 \316\317!\203\261 \3206>\203 7\321=\203 \322\323\312\307#\203 \306 8\307\211\307\324\216\311 -\204 \325\224\325\225|\210\326\327!\210\3306>\203\261 7\321=\203\261 \322\331\312\307#\203\261 \306 9\307\211\307\332\216\311 -\204\261 \325\224\325\225|\210\326\333!\210\334\335!\203\303 \203\303 \312 /\336 \210)\312`S : ;\3376>\2037\321=\203\212\340u\210\341\312x\210`;\306 <\307\211\307\342\216\343 -\205\344 \205\345 \205`;=?)\203\212;:|\210;b\210\346c\210)\202a\306 =\307\211\307\347\216\3506>\205W7\351=\205W\212\3521?\353u0\202C\210\202D\210\316\354!\205V`:\341\312x\210`;\343 )-\203a;:|\210*>\351=\203w?\204w2\203w2 \210*\202\215\334\335!\203\215 \203\215\312 /\336 \210)\355 +\207" [#1=#:modified buffer-undo-list inhibit-read-only inhibit-modification-hooks case-fold-search c-echo-syntactic-information-p buffer-modified-p t #[nil "?\205 \301\302!\207" [#1# restore-buffer-modified-p nil] 2] c-in-literal nil 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\\)*(\\=" #[nil "?\205 \301\302!\207" [#2=#:modified restore-buffer-modified-p nil] 2] 0 insert-and-inherit "} else if (" brace-catch-brace "}\\([ \n]\\|\\\\\n\\)*catch\\([ \n]\\|\\\\\n\\)*(\\=" #[nil "?\205 \301\302!\207" [#3=#:modified restore-buffer-modified-p nil] 2] "} catch (" boundp electric-pair-mode electric-pair-post-self-insert-function space-before-funcall -1 " " #[nil "?\205 \301\302!\207" [#4=#:modified restore-buffer-modified-p nil] 2] c-on-identifier c-beginning-of-macro c-forward-over-cpp-define-id 32 #[nil "?\205 \301\302!\207" [#5=#:modified restore-buffer-modified-p nil] 2] compact-empty-funcall 41 (error) -2 "()" c--call-post-self-insert-hook-more-safely-1 literal post-self-insert-hook arg blink-paren-function old-blink-paren c-syntactic-indentation c-electric-flag c-auto-newline c-cleanup-list last-command-event #2# #3# end beg #4# #5# last-input-event executing-kbd-macro] 5 (#$ . 32510) "*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 \311\216
\205O \205O \312=?\205O \212\313\314!\210`)\212\315 \210`)U\205O \316\212\306\211 \317 \210*\203K \320!\203K \321\225b\210`)!?-\205\\ \322\323!\210\324\216\325 ))\207" [c-echo-syntactic-information-p #1=#:modified buffer-undo-list inhibit-read-only inhibit-modification-hooks c-electric-flag nil buffer-modified-p t #[nil "?\205 \301\302!\207" [#1# restore-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" #[nil "\300\301!\207" [delete-char -2] 2] indent-according-to-mode c-syntactic-indentation last-command-event end-of-defun-function beginning-of-defun-function defun-prompt-regexp] 4 (#$ . 35290)])
(byte-code "\302\303!\203N \302\304!\204N \305\304\303\306#\210\307\304\303\310#\210\311\304\303\306#\210\312\306\211\203D @\304N\203= \303N\204= \313\303\304N#\210 A\211\204& *\314\304\303\310#\210\202U \315\304\316\317\320$\210\306\207" [prop --dolist-tail-- fboundp subword-mode c-subword-mode defalias nil make-obsolete "24.3" defvaralias (saved-value saved-variable-comment) put make-obsolete-variable autoload "cc-subword" "Mode enabling subword movement and editing keys." t] 6)
#@46 Compatibility alias for `c-forward-subword'.
(defalias 'c-forward-into-nomenclature #[(&optional arg) "\301\302!\203 \303\304!\210\305!\207\303\306!\210\307!\207" [arg fboundp subword-mode require subword subword-forward cc-subword c-forward-subword] 2 (#$ . 36993) "p"])
(byte-code "\300\301\302\303!\203\f \304\202
\305\306#\207" [make-obsolete c-forward-into-nomenclature fboundp subword-mode subword-forward c-forward-subword "23.2"] 4)
#@47 Compatibility alias for `c-backward-subword'.
(defalias 'c-backward-into-nomenclature #[(&optional arg) "\301\302!\203 \303\304!\210\305!\207\303\306!\210\307!\207" [arg fboundp subword-mode require subword subword-backward cc-subword c-backward-subword] 2 (#$ . 37444) "p"])
(byte-code "\300\301\302\303!\203\f \304\202
\305\306#\207" [make-obsolete c-backward-into-nomenclature fboundp subword-mode subword-backward c-backward-subword "23.2"] 4)
#@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 (#$ . 37903) "*"])
(defalias 'c-in-function-trailer-p #[(&optional lim) "\205\216 \212\305\306 \"\210`\307`Sf\310=\205\215 \311 !@\312>\205\215 `\211\205\215 \313\314\315Q \316\211\211%\205\215 \317\224\205\215 `Sf\320=?\205\215 \313\321 \316\211\211%\205\215 `Sf\322=\205\215 \3231_ \324`\317\211#0\202a \210\307\211 \205j \fb\210\316)\205\210 `Sf\310=\205\210 \325 \210\313\321\307\316\211\211%\205\210 `Sf\326=?\205\215 \n+\207" [c-opt-block-decls-with-vars-key lim bod eo-block dest c-syntactic-skip-backward "^;}" nil 125 c-beginning-of-decl-1 (same previous) c-syntactic-re-search-forward "[;=([{]\\|\\(" "\\)" t 1 95 "[;=([{]" 123 (error) scan-lists c-forward-sws 40] 7])
(defalias 'c-where-wrt-brace-construct #[nil "\212\306\211\306`\307 \310\f!\211 \203
f\311=\203 \312\202 \313 \203( \314\202 `Sf\315=\203: \212\316u\210\313 )\204v
\204z \f:\203z \f@:\203z \f@A=\203z \212\317 \210\320 !?\206a \320!!)\204v \212\f@@b\210\321 \210\320\"!)\204z \322\202
\203\201
b\210l\203\211 m\203\217 \320\323!\204\222 \306u\210`\212\324\325\306\326\211$\205\255 `Sf\311=\206\255 #\205\255 \327 )\321
\205\270 \330
\f\"!@\211\331=\204\310 \320$!\203\312 \306 \331=\204\326 `U\203\332 \332\202 \333\267\202\n\203\362 ` =\203\356 \334\202 \335\202 \332\202 \n\204\313 \203\322\202 \332\202 \336\337 \".\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 59 -1 c-forward-sws looking-at c-beginning-of-decl-1 at-function-end "\\([;#]\\|\\'\\|\\s(\\|\\s)\\|\\s\"\\|\\s\\\\|\\s$\\|\\s<\\|\\s>\\|\\s!\\)" c-syntactic-re-search-forward "[;{]" t c-in-knr-argdecl c-safe-position label outwith-function #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (same 224 previous 246)) at-header in-header error "c-where-wrt-brace-construct: c-beginning-of-decl-1 returned %s" c-symbol-start c-keywords-regexp c-defun-type-name-decl-key c-recognize-knr-p c-protection-key] 6])
(defalias 'c-backward-to-nth-BOF-{ #[(n where) "o\204= \302\267\2028 \303\304 !b\210 S\202= \305\306!\210\307u\210 S\202= \310\311!\210`Sf\312=\203= \313 \210 S\202= \314\315\"\210 \316V\203` o\204` \304 \210\310\311!\210`Sf\312=\203= \313 \210 S\211\202> \207" [where n #s(hash-table size 6 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (in-block 10 in-header 22 at-header 35 outwith-function 35 at-function-end 35 in-trailer 35)) c-least-enclosing-brace c-parse-state c-syntactic-re-search-forward "{" -1 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 level) "\304 \305\n\206\n \306\211\307V\203= \310 !\211\2037 @:\203& A\211\202 @ AV\204 \nS\211\202\f \307\211\202\f \205t \212 \203P b\210\311 \210`\202R Tb\210\3121j \313 \210 \203d `\202f `S0\202n \210\202q \206r d})*\207" [encl-decl paren-state level inclusive c-parse-state nil 1 0 c-most-enclosing-decl-block c-beginning-of-decl-1 (error) forward-list] 3])
(defalias 'c-widen-to-enclosing-decl-scope #[(paren-state orig-point-min orig-point-max) "\304\214 \n}\210 \205 \305 !)\2038 ~\210T\212b\210\3061) \307 \210`S0\202- \210\2020 \2061 \n)}\210\202= \n}\210\304)\207" [encl-decl orig-point-min orig-point-max paren-state nil c-most-enclosing-decl-block (error) forward-list] 2])
(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]))
(put 'c-while-widening-to-decl-block 'edebug-form-spec t)
#@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 \310 \204 \311 \210\312 \313\211 \313 $\314\216\315\211 % &\316 'e (d )\315\211 * +\315\211 , -\214.\317=\203T \320'()#*\321 \210\322 \211,\203c ,b\210\323 +\324W\203\363 +\325>\203w T\324W\203\257 \326[+\"[\211\324W\203\257 .\317=\203\257 *\203\257 \327*'\"'\320'()#*\330+\202} \324U\205`\331\332\315\333#\204\341 .\317=\203\341 *\203\341 \327*'\"'\320'()#*\330+\202\265 `Sf\334=\205`\335u\210\336 \210\313\202`\324V\203)\337+\"\211\324V\203).\317=\203)*\203)\327*'\"'\320'()#*\330+\202\371 \324=\203T\336 \210`,`\212\340 \210`)U\204E\341 \2045`\212\340 \210`)U\204T,b\210\342\343!\203]\313#\324U.\207" [arg this-command last-command #1=#:modified buffer-undo-list inhibit-read-only 1 c-beginning-of-defun region-active-p push-mark buffer-modified-p t #[nil "?\205 \301\302!\207" [#1# restore-buffer-modified-p nil] 2] nil c-parse-state go-outward c-widen-to-enclosing-decl-scope c-beginning-of-macro c-literal-start c-where-wrt-brace-construct 0 (at-function-end outwith-function) c-forward-to-nth-EOF-\;-or-} 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 inhibit-modification-hooks beginning-of-defun-function end-of-defun-function paren-state orig-point-min orig-point-max lim where pos case-fold-search c-defun-tactic] 5 (#$ . 41956) "p"])
(defalias 'c-forward-to-nth-EOF-\;-or-} #[(n where) "m\2048 \302\267\2023 \303\304 !b\210\305 \210 S\2028 S\2028 \306\307\310\311#\2038 \312u\210\305 \210 S\2028 \313\314\"\210\315 \203D \306\316\310\311\317$\210 \320V\203c m\204c \306\307\310\311#\203D \312u\210\305 \210 S\211\202E \207" [where n #s(hash-table size 6 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (in-block 10 in-trailer 25 at-function-end 31 outwith-function 31 at-header 31 in-header 31)) c-least-enclosing-brace c-parse-state forward-sexp c-syntactic-re-search-forward "{" nil eob -1 error "c-forward-to-nth-EOF-\\;-or-}: `where' is %s" c-in-function-trailer-p ";" t 0] 6])
#@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 \310 \204 \311 \210\312 \313\211 \313 %\314\216\315\211 & '\316 (e )d *\315\211 + ,\315\211 - .\214/\317=\203T \320()*#+\321 \210\322 \211-\203c -b\210\323 ,\324W\203\345 ,\325>\203w T\324W\203\257 \326[,\"[\211\324W\203\257 /\317=\203\257 +\203\257 \327+(\"(\320()*#+\330,\202} \324U\203\331\332!\210`Sf\333=\204/\317=\203+\203\327+(\"(\320()*#+\330,\202\265 \324V\203\334,\"\211\324V\203/\317=\203+\203\327+(\"(\320()*#+\330,\202\353 \324=\203P\335 \203*\336\337!\210`-n\204<\340\341!\204<\342 \204-n\204P\340\341!\203L\306y\210\202P-b\210\343\344!\203Y\313$\324U.\207" [arg this-command last-command #1=#:modified buffer-undo-list inhibit-read-only 1 c-end-of-defun region-active-p push-mark buffer-modified-p t #[nil "?\205 \301\302!\207" [#1# restore-buffer-modified-p nil] 2] nil c-parse-state go-outward c-widen-to-enclosing-decl-scope c-beginning-of-macro c-literal-start 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-\;-or-} c-in-function-trailer-p c-syntactic-re-search-forward ";" looking-at "\\s *$" c-forward-single-comment boundp zmacs-region-stays inhibit-modification-hooks beginning-of-defun-function end-of-defun-function paren-state orig-point-min orig-point-max lim where pos case-fold-search c-defun-tactic] 5 (#$ . 44664) "p"])
#@173 Return the name of the current defun, at the current narrowing,
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-1 #[nil "\306 \307\211\307\310\216\311\211 \311\211 \311\211 ! \"\311\211 # $\311 %\212\312 \210\313 \211 \2034 b\210\314 \211 \315>?\205\340 \316=\204O \317\320 \"\210\321 \210\322&!\203] \323\225b\210\324 \210`#\322\325!\203\210 \326\320!\210\324 \210\311f\327=\203{ \330\320!\210\331 \210\332`\331 \210\333 \210`\"\202\340 \322'!\203\235 \323\225b\210\324 \210`$#b\210\334\212\333 \210`)\335\311#\211!:\203\267 !@b\210\336 \"\"\205\340 \"@\205\340 \"A@\205\340 \332\"@$=\203\330 #\202\333 \"@\"A@\".\207" [#1=#:modified buffer-undo-list inhibit-read-only inhibit-modification-hooks beginning-of-defun-function end-of-defun-function buffer-modified-p t #[nil "?\205 \301\302!\207" [#1# restore-buffer-modified-p nil] 2] nil c-beginning-of-macro c-literal-start c-where-wrt-brace-construct (outwith-function at-function-end) at-header c-backward-to-nth-BOF-{ 1 c-beginning-of-decl-1 looking-at 0 c-forward-sws "DEFUN\\s-*(" down-list 34 forward-sexp c-forward-token-2 buffer-substring-no-properties c-backward-sws c-forward-decl-or-cast-1 top c-forward-declarator where pos decl0 decl type-pos tag-pos case-fold-search c-typedef-key c-defun-type-name-decl-key] 5 (#$ . 46570)])
#@181 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, at the outermost level of nesting.
(defalias 'c-defun-name #[nil "\304 \305\211\305\306\216\214~\210\307 .\207" [#1=#:modified buffer-undo-list inhibit-read-only inhibit-modification-hooks buffer-modified-p t #[nil "?\205 \301\302!\207" [#1# restore-buffer-modified-p nil] 2] c-defun-name-1] 2 (#$ . 47986)])
(defalias 'c-declaration-limits-1 #[(near) "\212`\306 \307\211\211\211 \3102\225\3111a \312\f!b\210\313`\f\"\211\206% `Sf\314=\203\\ \212\3151: \316 \317\320#0\202< \210\307\211 *\205H *b\210*)\205V \306 +\313`+\"))\206[ e\3210\202c \210\307\204t \322\313`\f\"!\211\203t \nb\210\323 \203\210 \324\310`\212\325 \210\326y\210`)B\"\210`\212\323 )?\205\224 \327 \211\330=\204\362 ,\203\261 \331>\203\261 \212\332 !@\333>)\204\300 \332 !@\334=\204\300 \n`U\203\362 \nb\210\335\336!\203\315 m\203\303 \337\340!\203\331 \341u\210\202\303 ,\203\362 \323 \203\362 \324\310`\212\325 \210\326y\210`)B\"\210m\203\373 \324\310\307\"\210`-\203&\342 \210`Sf\314=\203&\332 @\334=\203&\212\343 \210`\nV\205\"`\211)\204)\nb\210,\2044`
V\2069\327 \330=??\205\224``\212\344 \210`)U\204O\345 \204?`\212\344 \210`)U\204^\n\202_` \203i b\210\202l\343 \210`n\204}\337\346!\204}\347 \204nn\203\205`\202\223\337\346!\203\222\326y\210`\202\223\nB0\206\265,?\205\265eb\205\265\350\317\307\211#\205\265\307f\351=\205\265edB.\207" [where end-pos pos lim paren-state start c-parse-state nil exit (error) c-least-enclosing-brace c-safe-position 125 (error) scan-lists -1 0 t c-literal-start c-beginning-of-macro throw c-end-of-macro 1 c-where-wrt-brace-construct at-header (at-function-end outwith-function) c-beginning-of-decl-1 (previous label) previous forward-comment 5 looking-at "\\\\[\n
]" 2 c-backward-sws c-end-of-decl-1 back-to-indentation c-backward-single-comment "\\s *$" c-forward-single-comment c-forward-decl-or-cast-1 123 dest paren-state-1 near c-opt-block-decls-with-vars-key] 7])
(defalias 'c-declaration-limits #[(near) "\214\303=\2036 \214\212\304 )\204' \214\305 \210\306 \307>)\203' \204' \305\310\311\"\210\202* \305 \210ed)B\211@\nA}\210)\312 !)\207" [c-defun-tactic near bounds go-outward c-beginning-of-macro c-narrow-to-most-enclosing-decl-block c-where-wrt-brace-construct (at-function-end outwith-function) nil 2 c-declaration-limits-1] 4])
(defalias 'c-defun-name-and-limits #[(near) "\214~\210\306=\203{ \307 \310\211\310 \311\216\312 e d \313\211 \313\211 \313 \314
#\211\203> S\315 \211\204f \306=\203f \203f \316
\"\314
#\317\202> \205v \320!B.
\202\242 \307 \310\211\310 \321\216\322 \323! \205\240 \205\240 B.)\207" [c-defun-tactic #1=#:modified buffer-undo-list inhibit-read-only inhibit-modification-hooks paren-state go-outward buffer-modified-p t #[nil "?\205 \301\302!\207" [#1# restore-buffer-modified-p nil] 2] c-parse-state nil c-widen-to-enclosing-decl-scope c-defun-name-1 c-whack-state-after in-block c-declaration-limits-1 #[nil "?\205 \301\302!\207" [#2=#:modified restore-buffer-modified-p nil] 2] c-defun-name c-declaration-limits orig-point-min orig-point-max lim name where limits fdoc near #2#] 5])
#@128 Display the name of the current CC mode defun and the position in it.
With a prefix arg, push the name onto the kill ring too.
(defalias 'c-display-defun-name #[(&optional arg) "\214~\210\306 \307\211\307\310\216\311\312!\211 @ \fA \313
\205G \314\315
\316@@]\"T\316@A\"$\210\203C \317
!\210\320\321\307\".\n\207" [#1=#:modified buffer-undo-list inhibit-read-only inhibit-modification-hooks name-and-limits name buffer-modified-p t #[nil "?\205 \301\302!\207" [#1# restore-buffer-modified-p nil] 2] c-defun-name-and-limits nil line-beginning-position message "%s. Line %s/%s." count-lines kill-new sit-for 3 limits point-bol arg] 8 (#$ . 51304) "P"])
(put 'c-display-defun-name 'isearch-scroll t)
#@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 \311\216\312!\203 \313\314\306\315 #\210\316\310!- \204, \317\320!\202} \321=\2057 \321= \321=\205I ?\205I \322 ?\211 \203R \323 \210\203r \324 \210\316\310!\211\204i \324 \210\317\320!\210 Ab\210\324 \202| @b\210\323 A\306\310#**\207" [case-fold-search decl-limits #1=#:modified buffer-undo-list inhibit-read-only inhibit-modification-hooks nil buffer-modified-p t #[nil "?\205 \301\302!\207" [#1# restore-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 region-active-p push-mark exchange-point-and-mark c-syntactic-eol this-command last-command extend-region-p push-mark-p] 5 (#$ . 52031) 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 (#$ . 53299)])
(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=\203@ A\206 `Sf\307=\203< AS\206. `Sf\310=\203< A\306Z\202N d\202N Ad=\203K d\202N AS` V\203X b\210`\nW\203a \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
\313Q \314
\315Q \212\316\317!\210\320\311\321# V\203/ b\210` Y\203G \316\322!\210\320\311\321# V\203G b\210`) \323\324 \325#\203\230 `\211\203\230 \326\225b\203\230 ` Y\204\222 n\204 \212\323\311\321#\205{ \327\224\327\225U?)\204\222 \330 \203\207 \331 \210\320!\210` Y\203\230 \fb\210\202K \320!\210.` W?\205\253 \n@b\210\321+\207" [save-match-data-internal start-point range here last c-current-comment-prefix match-data #[nil "\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 #[nil "\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 #[nil "\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 #[nil "\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\202G \214e }\210\310\n!\204- o?\205F \311u\210\310 !\205F \312\225b\210`\3131D \314`\311\"b\210`B0\202F \210\305)*!)\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 (error) scan-sexps] 4])
(defalias 'c-ascertain-following-literal #[nil "\212\302\303\304\303w\210\303f\305=\203 \303u\210l\204 \306u\210\307 !\203; `\3101/ \311`\312\"b\210`0\2023 \210\2026 \2067 dB\202E `\313 \205E `B)!)\207" [pos c-string-limit-regexp c-collect-line-comments nil " \n
\f " 92 -1 looking-at (error) scan-sexps 1 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!\203B m\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) "\306 \307\216`\310\3112`\312 \203 b\210\313\311\314\"\210\202
\212\315 \210\316\317 \320#)\203O \2036 ` W\2028 \321 \203O b\210\313\311`\n=\206H ?\322B\"\210\202
\f\203p \f \203p \nW\203p f\323>\204p b\210\313\311\324\"\210\202
o\203\205 \n U\204} b\210\313\311\325\"\210\202
\326u\210\310f\327=\203\260
\203\237 \330 \203\237 \331\332!\210\202
\n U\204\250 b\210\313\311\333\"\210\202
\203\306 ` =\203\306 \313\311`\n=\322B\"\210\202
\334\335!\203\371 \n U\204\331 f\336>\203\356 `Sf\337=\203
\310f\340=\203
\326u\210\202
b\210\313\311\341\"\210\202
\334#!\203 b\210\313\311\342\"\210\202
\331\332!\210\202
,\207" [save-match-data-internal last here macro-start c-at-vsemi-p-fn c-special-brace-lists match-data #[nil "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3] nil done c-backward-single-comment throw (t . literal) beginning-of-line re-search-forward "\\(^\\|[^\\]\\)[\n
]" t c-beginning-of-macro macro-boundary (41 125) (nil) (nil) -1 123 c-looking-at-special-brace-list skip-syntax-backward "w_" (nil) looking-at "[;}]" (41 125) 125 59 (nil) (t . literal) c-string-limit-regexp] 4])
(defalias 'c-forward-over-illiterals #[(macro-end allow-early-stop) "`\306\3072p`\211 V\203 \n\203 \n \203 \310\307\311\"\210\312\306w\210\306f\313=\2033 \306u\210l\204 \314u\210 \203L ` V\203L b\210\310\307` =\315B\"\210\202 \212\316 )\203^ b\210\310\307\317\"\210\202 m\203s U\204k b\210\310\307\320\"\210\202 \306f\321=\203\264 \f\203\203 \322 \204\264
\204\215 U\204\264 \212\3231\233 \324\314!\210\3250\202\235 \210\306?\206\245 \306f\321U)\203\264 b\210\310\307\326\"\210\202 \f\203\345 \306f\327=\203\345 \212\3301\315 \324\314!\210\3250\202\322 \210\306\202\327 \205\327 \322 )\203\345 \306u\210\331\332!\210\202 \306f\327=\203\375 U\204\375 b\210\310\307\333\"\210\202 $\203, \204,\306f\334=\203,`\212\335 \210`)U\203,` U\203$\306u\210\202 \310\307\336\"\210\202 \337\340!\203>\341\225b\210\310\307\342\"\210\202 \337%!\203Pb\210\310\307\343\"\210\202 \306u\210\331\332!\210 \203 ` V\203 b\210\310\307` =\315B\"\210\202 *\207" [last here c-at-vsemi-p-fn macro-end c-special-brace-lists allow-early-stop nil done throw (nil) " \n
\f " 92 -1 macro-boundary c-forward-single-comment (t . literal) (nil) 123 c-looking-at-special-brace-list (error) up-list t (nil) 125 (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])
(defalias 'c-one-line-string-p #[(range) "\212@b\210\302 !\205 \303Aw\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\216\206 \313\314 +\212o?\205. \315 \205. `) ,\314\211 - .\316\317 !! /\306U\204 \203N ` V\203`+o\203Z \306\202\370/\203\n\203j \320/!\203\364 /@b\210\321 /\212,\203\346 ` 0o\204\342 \314 1\322\323!\2111\204\265 `Sf\324=\203\232 \323u\210\202\203 `Sf\325=\203\265 `S\206\250 `Sf\324=\203\265 \326u\210\202\203 1)\203\307 \327\330!\203| \331u\210\202\342 \327\332!\203\342 `Sf\333=\203\342 `0W\203\342 \323u\210\202| )\202\351 \334 \210o\206\357 \335 )?\202\357\336/!\337=\203\340/!\202\341/!\211-\203\321 /-\202\357\342,!-`+U\206\257\314f\343>\206\257-@\205\257\212,\203\244` 0o\204\240\314 1\322\323!\2111\204s`Sf\324=\203X\323u\210\202A`Sf\325=\203s`S\206f`Sf\324=\203s\326u\210\202A1)\203\205\327\330!\203:\331u\210\202\240\327\332!\203\240`Sf\333=\203\240`0W\203\240\323u\210\202:)\202\247\334 \210o\206\255\335 )?.-A\344=\203\341\212\345 \210o?\205\336\346\314x\210l\203\330`Sf\333=\203\330\323u\210\202\302\315 \205\336`,)-A\347>\203\355\321 /.\203\370`+\202Q \306U\204> S\211\202? \350\351!\205\311\211). \207" [count lim sentence-flag #1=#:modified buffer-undo-list inhibit-read-only 0 c-end-of-statement buffer-modified-p t #[nil "?\205 \301\302!\207" [#1# restore-buffer-modified-p nil] 2] 1 nil c-beginning-of-macro c-collect-line-comments c-literal-limits 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-modification-hooks last macro-fence res not-bos range start moved-comment] 5 (#$ . 61021) (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\216\314 \212m?\2051 \315 \2051 \316 \210`) !\314 \"\317\320 !! #\307U\204 \203N ` W\203 ` m\203Z \307\202#\203\256 \n\203j \321#!\203 #Ab\210\322 #$\205{ $ ?\202\323#!\324=\203\217 \325#!\202\223 \326#!\211\"\203\235 \322 #\"\203$\205\252 $ ?\202\327!` V\"\211\"A\330=\203\377 \212!\203\356 \314\210m?\205\374 \331\314w\210\314f\332=\203\342 \314u\210l\204\315 \333u\210\315 \205\374 \316 \210`\202\374 m?\205\374 \315 \205\374 \316 \210`)!\"A\334>\203 \322 #\"@\204Q \307U\204> S\211\202? \335\336!\205(\312\211 . \207" [count lim sentence-flag #1=#:modified buffer-undo-list inhibit-read-only 1 0 c-beginning-of-statement buffer-modified-p t #[nil "?\205 \301\302!\207" [#1# restore-buffer-modified-p nil] 2] nil c-beginning-of-macro c-end-of-macro c-collect-line-comments c-literal-limits 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-modification-hooks here macro-fence res range c-at-vsemi-p-fn] 5 (#$ . 63896) (list (prefix-numeric-value current-prefix-arg) nil t)])
(byte-code "\300\301\302\"\210\300\303\304\"\210\305\306\307\310#\210\305\306\311\310#\210\305\312\307\310#\210\305\312\311\310#\210\305\313\307\310#\210\305\313\311\310#\207" [mapc #[(sym) "\301\302\303#\210\301\304\303#\207" [sym put delete-selection t pending-delete] 4] (c-electric-pound c-electric-slash c-electric-star c-electric-semi&comma c-electric-lt-gt c-electric-colon) #[(sym) "\301\302\303\304!\203
\304\202 \305#\210\301\306\305#\207" [sym put delete-selection fboundp delete-selection-uses-region-p t pending-delete] 5] (c-electric-brace 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 \307A@AAi\211 \310\267\202y \n \\\202z \204/
n\2037 \202z \nT ]\202z \212\311 \210o?\205n \312u\210\313\314 \315\"\211 :\205m @b\210\316\317!\205m n\203i \320\202m \nTi]))\206z \321A!\202z \322+\207" [entry c-indent-comment-alist col value action comment-column other (default column) #s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (space 35 column 41 align 62)) beginning-of-line -1 c-literal-limits line-beginning-position t looking-at "/[/*]" 0 c-calc-comment-indent nil 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\311\216\312\313 \310\"\211 :\203, \f@b\210\314\315!\203, \316\306x\210`\2061 \316\306x\210`) \314\317!\203= \320\202q \321 \210`
=\203J \322\202q \323 \210\306f\324=\203_ `
S=\203_ \325\202q \314\326!\203p \327\225
=\203p \330\202q \331 \306 \332>\203\263 !\203\263 \333 \"l\203\232 \334\306 #\211 $#B\"B\"*%:\203\245 %\202\251 %\211B %\335\"!*\202\272
b\210\336 !. \207" [#1=#:modified buffer-undo-list inhibit-read-only inhibit-modification-hooks lim eot nil buffer-modified-p t #[nil "?\205 \301\302!\207" [#1# restore-buffer-modified-p nil] 2] 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 (anchored-comment empty-line) c-guess-basic-syntax comment-intro c-get-syntactic-indentation c-calc-comment-indent line-type case-fold-search c-indent-comments-syntactically-p c-syntactic-context args symbol c-comment-only-line-offset] 4 (#$ . 67155)])
(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 (#$ . 68465) "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 (#$ . 69013) "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 (#$ . 69378) "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 (#$ . 69915) "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 (#$ . 70281) "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 (#$ . 70970) "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 \211b\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 (#$ . 71816)])
#@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\231 \204r \212\321\311x\210n)\204m \202\231 \202\231 \313=\203~ \202\231 \322 \313\211 \313 \323\216\324 -\203\227 \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\205R \212\312\210`Sf)\313=\205R 9\203H \212\314 \315\211 \315 \316\216\317 \205A `.\211\202I \205R \320``\312\315$*\207" [c-macro-start arg steps c-basic-offset c-auto-align-backslashes #1=#:modified (4) -1 prefix-numeric-value c-shift-line-indentation nil 92 buffer-modified-p t #[nil "?\205 \301\302!\207" [#1# restore-buffer-modified-p nil] 2] c-beginning-of-macro c-backslash-region buffer-undo-list inhibit-read-only inhibit-modification-hooks] 6] back-to-indentation nil c-indent-line t beginning-of-line scan-sexps 1 indent-code-rigidly "#" " " buffer-modified-p #[nil "?\205 \301\302!\207" [#2=#:modified restore-buffer-modified-p nil] 2] c-in-literal c-tab-always-indent c-insert-tab-function #2# buffer-undo-list inhibit-read-only inhibit-modification-hooks] 6 (#$ . 73819) "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`\3131# \314\315\316#0\202% \210\306\211\203> \31717 \314\n\315\211#0\2029 \210\306\211\204 \n\205Q \n\206G `Sfz\320=\205Q \nS+\211\204b \f?\205\220 \321\322!\202\220 b\210\3231q \324`\315\"0\202s \210\306\211\204\203 \f?\205\220 \321\325!\202\220 \306y\210`W\205\220 \326`\",\207" [end here beg start shutup-p point-marker nil set-marker-insertion-type t #[nil "b\210\301\211\223\207" [here nil] 3] line-end-position (error) scan-lists 1 -1 (error) 40 error "Cannot find start of balanced expression to indent" (error) scan-sexps "Cannot find end of balanced expression to indent" c-indent-region] 5 (#$ . 76460) "*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 \313\216\314!\203& \315\316\307\317 #\210\202- \320\321\307\322 #\210\323\307!- \205< \324 @ A\",\207" [case-fold-search decl-limits here #1=#:modified buffer-undo-list inhibit-read-only point-marker nil #[nil "b\210\301\211\223\207" [here nil] 3] buffer-modified-p t #[nil "?\205 \301\302!\207" [#1# restore-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-modification-hooks c-syntactic-eol] 5 (#$ . 77369) "*"])
#@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) "\212b\210\306\307x\210` b\210\310 \210\306\307w\210`\310 \210\311!\307\211\312 \313\211 \313 \314\216\212\315 .\205? \316 \2067 `Sf\317=\205? \307\211 ! \" # $ %\320\216\321 \322#\210n\203\323 m\204\323 `%W\203\323 \323 \210\324\325!\204\220 \"\203x \324\326!\204\220 \312 &\313\211 \313 \327\216\330 -\331 \313\211#\210\"\203\266 '\203\315 \316 \206\240 `Sf\317=\204\315 \332\"\333\334!\307#\210\307\"\202\315 \335 \236\203\315 \316 \206\303 `Sf\317=\203\315 `\"\307y\210\202U \"\203\347 '\203\347 \332\"\333\336!\307\313$\210)\337(!.\206\363 $\211$)\207" [end start #1=#:modified buffer-undo-list inhibit-read-only inhibit-modification-hooks " \n
\f " nil beginning-of-line copy-marker buffer-modified-p t #[nil "?\205 \301\302!\207" [#1# restore-buffer-modified-p nil] 2] c-beginning-of-macro line-end-position 92 #[nil "\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 *\\\\$" #[nil "?\205 \301\302!\207" [#2=#:modified restore-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 syntax c-fix-backslashes ml-macro-start c-echo-syntactic-information-p c-parsing-error endmark #2# c-auto-align-backslashes quiet] 7 (#$ . 78192)])
(defalias 'c-fn-region-is-active-p #[nil "\300 \207" [region-active-p] 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 (#$ . 79909) (list current-prefix-arg (region-active-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 )\313\314\315\"\f$\307\316!\207" [c-progress-interval c-progress-info start end context fboundp current-time message "Indenting region... (this may take a while)" vector point-marker time-convert nil integer "Indenting region..."] 6])
(defalias 'c-progress-update #[nil "\2054 \2054 \306\307\310\"\311H\312H\313H
\nZW\2053 \314\315\316\317`\fZ_ \fZ\"\"\210\313
I,\207" [c-progress-info c-progress-interval lastsecs end start now time-convert nil integer 0 1 2 message "Indenting region... (%d%% complete)" floor 100.0] 6])
(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\223\204; n\203; \314u\210`\203Q \f`\310\223\210b\210\315\f \"\210\202\223\310\210`Sf\316=\205p \317y\320U\205p \310\210`Sf\316=\205p iS\203\224 \3211\203 \322\320!0\202\207 \210\202\212 \206\214 ]\204\224 \323\203\245 \204\245 b\210\202T\320
b\210\203\261 \317y\210\310\210`Y\203\334 `Sf\316=\203\306 \314u\210\307\310x\210 iT]\324 \210o\204\334 \314u\210\202\264 b\210\324 \210o\204\314u\210`Sf\316=\203iS\247\203\376 \n]b\210\202$\247\203\fb\210`
W\203$n\203$l\203$\317y\210\202\n\2030\n W\2030\310\n\204O \246\320V\203J\325 \314# \245 _ ]\n ^\203f\f
\310\223\210\326\f\n #\210\202\223\212
b\210\324 \210o?\205w\f`S\310\223)\203\211\326\f\n #\210\f`\310\223\210\202\216\f
\310\223\210\315\f \"\210)\f\310\211\223\210\327 !\205\243 \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 (error) line-end-position 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 (#$ . 81320) "*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 \3148\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\321y\322U,\205 n\205 \202\n `\nX\205 ` \310\210\306`\310\211%`Sf\311=\203\327 \3148\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\321y\322U)\205 n\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 0 (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\306y\307U\2050 n\2050 \202 \207" [to-mark point-pos nil 92 -1 " " 1 0] 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 0 1\311\211 2 34\2039 4` 5\312\216\313\3144\"\210i*B2\202E \310=\203\370 \212\31516A3\316 \210`6@V\203Y `0\202\364 6@b\210\317y\320U\203s `6AW\203s `0\202\364 6@b\210\321\n!\203\205 \320\225b\210\202\214 \322u\210\323\311w\210\311\211 7 8\212\324 \210`)6@=\203\254 \325\326 `\"8i7\202\325 `6@Z\311 9 :\327\2166@b\210i\330c\210j\210`9:u\210\325\326 `\"8i7+\331\3328\"\204\341 l\204\351 87B\202\361 8\333P7TB2*)\202E\2126A\322Zb\210\321\334!\203\n`\202
6A)3\212\316 \210`6@V\2031\321\335!\203+6A\320\225=\2041`0\202D6@b\210\317y\320U\203d`6AY\204d\321\335!\203T6A\320\225=\204d\321\n!\203o6AS\320\225X\203o;\206j\3361\202\276`W\203\273\317\224\203\230\317\224\317\225U\204\230\320\225\337 U\203\222\340\317!1\202\276`0\202\276\212\324 \210i)\2126@b\210i)X\203\265;\206\260\3361\202\276`0\202\276`01\203D\311\211\211 < = >\341\2166@b\210\321
!\203\351\320\2253^b\210\321?!<\202\360\322u\210\323\311w\210`Sfz\342=\203#\3431\320\331\3441\"#\325\212\323\311x\210`)`\"P1<\203#\331\3451\"\204#1\333P1\346 >\313\3471\350#\210\346 =\351 \210=Sb\210\325\326 `\"i,B2)2\206t\212\311\211 @ A\352 B\3532\3300b\210B \203\206\317\225\320\225U\203z\317\224\317\225U\203\206\320\224\320\225U\204\206\354\353@Ab\210iB\"\210 \310=\203\242\355y\320U\203\270`6@Y\203\270B \210\202\214\355y\320U\203\270`6@V\203\270B \210\202\2420b\210\317y\320U\203\322`6AW\203\322B \210\202\2740b\210\3110\206s@\203T\331\332@\"\204\360Ab\210l\204\367@iB\202Q6@b\210\321
!\203 \320\225b\210\202\322u\210\323\311w\210l\203 `Sfz\342=\203F\325\212\323\311x\210`)`\"@Ab\210\323\311x\210` 9\356\216\313@!\210\325\326 `\"i*B\202Q@\333PAb\210iTB\206s1\203r\3250\212\324 \210`)\"1P\324 \210i1G\\B\202s\357,.\207" [here c-current-comment-prefix prefix-regexp lit-type comment-start-skip comment-start-regexp "[ ]*\\(" "\\)[ ]*" c++ nil #[nil "`|\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 #[nil "@ |\207" [lit-limits tmp] 2] 10 string-match "\\s \\'" " " "\\*/" "[ ]*\\*/" #1="" line-end-position match-string #[nil "\205 |\210 \302\211\223\210\302\211\223\207" [tmp-post tmp-pre nil] 3] 32 substring "\\s *\\'" "\\s \\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 throw -1 #[nil "`|\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 at-close tmp-post tmp-pre c-block-comment-ender-regexp fb-string fb-endpos test-line] 7])
(defalias 'c-mask-paragraph #[(fill-paragraph apply-outside-literal fun &rest args) "\306\211\211\211\211\211\211` @ A B CD\203* D\307=\204* `DBD\310 E\307\211 D F\307 G\311\216\214~\210\204F \312\306H\"\313! \204R \314!)\212\3151e \316u\210\317 \210`\nY0\202g \210\306\204p \nb\210\317 \210\320 A)\212\3211\207 \306u\210\322 \210`\nX0\202\211 \210\306\204\222 \nb\210\322 \210`B.\323\216 \324\267\202\261\212A\211A^\306\223\210B@X\203\311 @b\210\325 \210`@=\203\306 \326 B\202\311 \307@)\307I\202\366AAV\204AAU\203A\206\346 `Sf\327=\203AS\206\364 `Sf\330=\203A@Z\331V\203\212Ab\210\332 \210\333\334J\335QA\336Z\307#\205.\333\337A\336Z\340#?\205.A\326 \306\223)\204\212Ab\210\341\342!\210`) K\212Kb\210i) LK\nZ M\212Kb\210\343\344 \326 \307#\205n\345\225b\205n\346\347!\205n\345\225KU) N\306 O\212Ab\210\320 \350c\210A`\306\223\210\316y\210\346\351J\352Q!\203\244K\345\225=\203\244\353\225\336\225ZO\202\250Kb\210\354\306x\210`KU\204\n`X\203\274\316MO\204\307LiZO\355`K\"H\203\350ON\203\342P\203\342\336\202\343\353^\353]O\356\357O\307#\210OM\345Y\205 `MO^ZM\202\306M)M\203Mb\210-B@X\2036\212@b\210\346\360Q\361Q!\2032\326\336!B\2025\307@)\307I\202\366\212AAY\203VASb\210\320 \350c\210A`\306\223\210B@X\203r@Tb\210\346\362!\203o\345\225T\202p`B)\307I\202\366\212\310 R\307\211 D F\307 G\363\216\364 \210\332 \210`BV\203\231`B\365 \210\306y\210`AW\203\254A`\306\223\210.\202\366\310 S\307\211 D F\307 G\366\216\212Bb\210\214eA\206\315d}\210\367 \210)\332 \210`BAb\210\214B\206\344ed}\210\370 \210)\306y\210A`\306\223\210.@\203\204\310 T\307\211 D F\307 G\371\216\372 \"-C\373\374J\375QC@\"\204%\376\377C@\"\210\212@b\210\346 \201[ =\2038J\202:Q!\203E\345\225b\210\202N\336u\210\201\\ \306w\210iCAW\203`l\204`\353u\210\202Ni U`TB`C@\201] \216\201^ \201_ C@\"\210\356\357UiZ\307#\210+I\205$V\206\331 \201[ =\205\331\201` \201W !\205\242W?\205\331\373\201a \201b BA\"\206\270\201c \"?\205\331\310 X\307\211 D F\307 G\201d \216C\206\327\372 \"@-`BW\203\347`BZ\202\362`AV\205\362`AZ M V\214BA}\210\201e YZ\")M\203#M\345W\203 BM\\b\210\202#AM\\b\210*. \207" [c-lit-limits c-lit-type here auto-fill-spaces hang-ender-stuck tmp-post nil t buffer-modified-p #[nil "?\205 \301\302!\207" [#1=#:modified restore-buffer-modified-p nil] 2] c-literal-limits c-collect-line-comments c-literal-type (error) -1 forward-paragraph point-marker (error) backward-paragraph #[nil ":\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] #s(hash-table size 4 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (c++ 159 c 208 string 572 pound 633)) back-to-indentation line-beginning-position 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 "
\n" delete-and-extract-region insert-char 120 "\\(" "\\)$" "\\\\$" #[nil "?\205 \301\302!\207" [#2=#:modified restore-buffer-modified-p nil] 2] c-beginning-of-macro c-end-of-macro #[nil "?\205 \301\302!\207" [#3=#:modified restore-buffer-modified-p nil] 2] c-forward-sws c-backward-sws #[nil "?\205 \301\302!\207" [#4=#:modified restore-buffer-modified-p nil] 2] c-guess-fill-prefix string-match "\\`[ ]*\\(" "\\)[ ]*\\'" message "Warning: Regexp from `c-comment-prefix-regexp' doesn't match the comment prefix %S" tmp-pre end beg fill buffer-undo-list #1# inhibit-read-only inhibit-modification-hooks 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 #2# #3# #4# col fill-prefix filladapt-mode #5=#:modified fun args c++ " " #[nil "`\241\207" [tmp-pre] 2] insert-and-inherit "\n" boundp "\\`[ ]*//" fill-context-prefix "" #[nil "?\205 \301\302!\207" [#5# restore-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 (#$ . 91864) "*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\2168\310=\204\235 \204) \312\313\211\310#\n\2041 \314 ! 9\203S \212\307 9\310\211 5 6\310 7\315\216\316 \205L `.\211\202T \203[ \317\202d \n\204c \320\202d \n:>\203o \310\202\235 8\204\207 \n\321=\203\207 \322 @X\203\207 \313\202\235 \n\323=\203\235 \324\325;P\206\227 \326\"\204\235 \313-\310=\206e\203\261 \f \210\327!\202e\307 <\310\211 5 6\310 7\330\216 \204\307 \312 \n\204\317 \314 !\n\331>-\203
=\204\353 \212 @b\210\313\210` AW)\203\254\307 >\310\211 5 6\310 7\332\216\333\334 !\211\n\"-`\n\321=\203 \212 A\335Zb\210\336\337!\205`)\206 A ? @ AiAAW\2036l\2046\340u\210\202$`?V\203q\322 @V\203q\341@\310\"@\342 \210\327A@!\210B\203a\327\343!\210\202e\344\340!\210@b\210@\313\211\223\202\250`?V\203?b\210\202\216` @\335\\W\203\216 @\335\\b\210\f \210\327A@!\210\336C!\205\250`Sf\345>\205\250\346u+\202eDE\313 F E D\n\321=\203\316\324\347D\"\204\334\350D\351E\202\334\324\352D\"\204\334\353D\326E\212\354 \210i)F\f \210E\203\376E\326\232\204\376\346u\210\327E!\210\340u\210Fj\210\327D!\210\355 +\202e 9\203/\212\307 9\310\211 5 6\310 7\356\216\316 \205(`.\211\2020 \203H\336\357!\204<\360 \210\361G?\205D\340!\202e\212\342 \210\336\362!\203Y\346y\363U\204L\364 ) F\f \210Fj)-\207" [fill-prefix c-lit-limits c-lit-type c-macro-start do-line-break #1=#: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 "?\205 \301\302!\207" [#1# restore-buffer-modified-p nil] 2] c-literal-limits nil c-literal-type #[nil "?\205 \301\302!\207" [#2=#:modified restore-buffer-modified-p nil] 2] c-beginning-of-macro cpp code c line-beginning-position c++ string-match "\\`[ ]*" "" insert-and-inherit #[nil "?\205 \301\302!\207" [#3=#:modified restore-buffer-modified-p nil] 2] (c c++) #[nil "?\205 \301\302!\207" [#4=#:modified restore-buffer-modified-p nil] 2] c-guess-fill-prefix c-collect-line-comments 2 looking-at "\\*/" 1 copy-marker beginning-of-line 10 newline (32 9) -1 "[ ]*/\\*" "/* " " */" "[ ]*//" "// " back-to-indentation indent-for-comment #[nil "?\205 \301\302!\207" [#2# restore-buffer-modified-p nil] 2] "[ ]*\\\\$" delete-horizontal-space c-newline-and-indent "[ ]*\\\\?$" 0 current-indentation buffer-undo-list inhibit-read-only inhibit-modification-hooks c-auto-fill-prefix #2# c-ignore-auto-fill c-line-comment-starter #3# comment-multi-line #4# comment-text-end pos fill soft c-block-comment-ender-regexp comment-start comment-end col allow-auto-fill] 6 (#$ . 93030) nil])
(byte-code "\300\301\302\"\210\303\301\302\304#\210\305\306!\204- \307\310!\210\311\312\313\314\310$\210\312\315\316\317\320B#\266\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--addoit-function &optional soft) "\305 \204\n \n\204 \f!\202 \306\307\f!\210))\207" [ad-return-value c-inside-line-break-advice c-buffer-is-cc-mode ad--addoit-function soft nil t c-indent-new-comment-line] 2] (nil (c-line-break-advice) nil fun2 (&optional soft) nil) ad-set-advice-info-field cache ad-activate] 8)
#@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 \311\216\312\306\211\310#\313!\211\314=\203) \315!\n9\203I \212\307 \310\211 \310 \316\216\317 \205C `.\202K \n\210- \320=\204\225 \314=\203f \212\321\306w\210`)ASW\204\225 \n\247\203\243 \322=\204\243 \323\324!\203 `Sf\325=\203\243 \212\nb\210\323!!\203\216 \326\225b\210`)`X\203\243 \310\306 \" #\327\306\310\"*\202\343 \322=\203\276 \n\247\203\271 `Sf\325=\204\271 \325c\210\330 \202\343 \331 \210\330 \210\212\332u\210\326y\210\323\333!\203\330 \332y\326U\204\313 \334 )\211 $j\210)\335 ,\207" [c-lit-limits c-lit-type c-macro-start case-fold-search #1=#:modified buffer-undo-list nil buffer-modified-p t #[nil "?\205 \301\302!\207" [#1# restore-buffer-modified-p nil] 2] c-literal-limits c-literal-type c++ c-collect-line-comments #[nil "?\205 \301\302!\207" [#2=#:modified restore-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-modification-hooks #2# c-opt-cpp-start fill-prefix comment-multi-line col] 5 (#$ . 97405) "*"])
#@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 #[nil "b\210\301\302!\207" [here delete-char 1] 2] 120 c-context-line-break] 1 (#$ . 99448) "*"])
(provide 'cc-cmds)