;ELC
;;; Compiled
;;; in Emacs version 28.2
;;; with all optimizations.



(defvar c--cl-library (byte-code "\300\301!\203\302\207\303\207" [locate-library "cl-lib" cl-lib cl] 2))
(byte-code "\301!\210\301\302!\207" [c--cl-library require regexp-opt] 2)
#@25 CC Mode version number.
(defconst c-version "5.35.1" (#$ . 266))
(defconst c-version-sym (intern c-version))
#@400 Non-nil for all buffers with a major mode derived from CC Mode.
Otherwise, this variable is nil.  I.e. this variable is non-nil for
`c-mode', `c++-mode', `objc-mode', `java-mode', `idl-mode',
`pike-mode', `awk-mode', and any other non-CC Mode mode that calls
`c-initialize-cc-mode'.  The value is the mode symbol itself
(i.e. `c-mode' etc) of the original CC Mode mode, or just t if it's
not known.
(defvar c-buffer-is-cc-mode nil (#$ . 382))
(byte-code "\300\301!\210\302\301\303\304#\207" [make-variable-buffer-local c-buffer-is-cc-mode put permanent-local t] 4)
(defvar c-syntax-table-hwm most-positive-fixnum)
(defvar c-inside-eval-when-compile nil)
#@255 Like `progn', but evaluates the body at compile time.
The result of the body appears to the compiler as a quoted constant.

This variant works around bugs in `eval-when-compile' in various
(X)Emacs versions.  See cc-defs.el for details.

(fn &rest BODY)
(defalias 'cc-eval-when-compile '(macro . #[128 "\203\301
B\207\302\303\304\305\306BBDDD\207" [c-inside-eval-when-compile progn eval-when-compile eval quote let ((c-inside-eval-when-compile t))] 7 (#$ . 1043)]))
(byte-code "\300\301\302\303#\304\301\305\306#\210\307\310!\204\"\311\310\312\"\210\300\310\313\314#\210\304\310\315\316#\210\307\317!\2049\311\317\320\"\210\300\317\313\314#\210\304\317\315\316#\210\307\321!\204P\311\321\322\"\210\300\321\313\314#\210\304\321\315\316#\210\300\207" [function-put cc-eval-when-compile lisp-indent-function 0 put edebug-form-spec t fboundp cadar defalias #[257 "\211@A@\207" #1=[] 2 "\n\n(fn ELT)"] speed -1 byte-optimizer byte-compile-inline-expand caddr #[257 "\211AA@\207" #1# 2 "\n\n(fn ELT)"] cdddr #[257 "\211AAA\207" #1# 2 "\n\n(fn ELT)"]] 5)
#@18 

(fn FUN LISZT)
(defalias 'c--mapcan '(macro . #[514 "\301\302!\203\303\302K!\203\302E\207\304=\203\305E\207\306\307\310EE\207" [c--cl-library fboundp mapcan subrp cl-lib cl-mapcan apply 'nconc mapcar] 7 (#$ . 2104)]))
(put 'c--mapcan 'edebug-form-spec t)
#@39 

(fn LISZT1 LISZT2 &rest OTHER-ARGS)
(defalias 'c--set-difference '(macro . #[642 "\301=\203\302BBB\207\303BBB\207" [c--cl-library cl-lib cl-set-difference set-difference] 7 (#$ . 2380)]))
(put 'c--set-difference 'edebug-form-spec '(form form &rest [symbolp form]))
#@39 

(fn LISZT1 LISZT2 &rest OTHER-ARGS)
(defalias 'c--intersection '(macro . #[642 "\301=\203\302BBB\207\303BBB\207" [c--cl-library cl-lib cl-intersection intersection] 7 (#$ . 2662)]))
(put 'c--intersection 'edebug-form-spec '(form form &rest [symbolp form]))
#@35 

(fn FORM &optional ENVIRONMENT)
(defalias 'c--macroexpand-all '(macro . #[513 "\300\301!\203\301E\207\302E\207" [fboundp macroexpand-all cl-macroexpand-all] 5 (#$ . 2936)]))
(put 'c--macroexpand-all 'edebug-form-spec t)
#@29 

(fn CL-SEQ &rest CL-KEYS)
(defalias 'c--delete-duplicates '(macro . #[385 "\301=\203\f\302BB\207\303BB\207" [c--cl-library cl-lib cl-delete-duplicates delete-duplicates] 5 (#$ . 3170)]))
(put 'c--delete-duplicates 'edebug-form-spec '(form &rest [symbolp form]))
#@147 Declare the region BEG...END's fontification as out-of-date.
On XEmacs and older Emacsen, this refontifies that region immediately.

(fn BEG END)
(defalias 'c-font-lock-flush '(macro . #[514 "\300\301!\203\301E\207\302E\207" [fboundp font-lock-flush font-lock-fontify-region] 5 (#$ . 3447)]))
(put 'c-font-lock-flush 'edebug-form-spec t)
#@26 

(fn FORMAT &rest ARGS)
(defalias 'c-benign-error '(macro . #[385 "\300\301BB\302BB\207" [progn message ((ding))] 6 (#$ . 3797)]))
(put 'c-benign-error 'edebug-form-spec t)
#@918 Return the value of certain commonly referenced POSITIONs relative to POINT.
The current point is used if POINT isn't specified.  POSITION can be
one of the following symbols:

`bol'   -- beginning of line
`boll'  -- beginning of logical line (i.e. without preceding escaped NL)
`eol'   -- end of line
`eoll'  -- end of logical line (i.e. without escaped NL)
`bod'   -- beginning of defun
`eod'   -- end of defun
`boi'   -- beginning of indentation
`ionl'  -- indentation of next line
`iopl'  -- indentation of previous line
`bonl'  -- beginning of next line
`eonl'  -- end of next line
`bopl'  -- beginning of previous line
`eopl'  -- end of previous line
`bosws' -- beginning of syntactic whitespace
`eosws' -- end of syntactic whitespace

If the referenced position doesn't exist, the closest accessible point
to it is returned.  This function does not modify the point or the mark.

(fn POSITION &optional POINT)
(defalias 'c-point '(macro . #[513 "
\242\300=\203/
\301!\211\302\267\202*
\303\304!\203
\204\305\207\306\307\205&\310DC\311\"B\207\306\307\2054\310DC\312\"B\207\303\313!\203D
\204D\314\207\306\307\205N\310DC\315\"B\207\306\307\205\\\310DC\316\"B\207\306\307\205j\310DC\317\"B\207\306\307\205x\310DC\320\"B\207\306\307\205\206\310DC\321\"B\207\303\304!\203\226
\204\226\322\207\306\307\205\240\310DC\323\"B\207\303\304!\203\260
\204\260\324\207\306\307\205\272\310DC\325\"B\207\303\313!\203\312
\204\312\326\207\306\307\205\324\310DC\327\"B\207\303\313!\203\344
\204\344\330\207\306\307\205\356\310DC\331\"B\207\306\307\205\374\310DC\332\"B\207\306\307\205\n
\310DC\333\"B\207\306\307\205
\310DC\334\"B\207\306\307\205&
\310DC\335\"B\207\336\337\"\207\340\341!\210\306\307\205=
\310DC\342\343DC\344BB\345B\"B\207" [quote eval #s(hash-table size 15 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (bol 16 boll 42 eol 56 eoll 82 boi 96 bod 110 eod 124 bopl 138 bonl 164 eopl 190 eonl 216 iopl 242 ionl 256 bosws 270 eosws 284)) fboundp line-beginning-position (line-beginning-position) save-excursion append goto-char ((beginning-of-line) (point)) ((while (progn (beginning-of-line) (when (not (bobp)) (eq (char-before (1- (point))) 92))) (backward-char)) (point)) line-end-position (line-end-position) ((end-of-line) (point)) ((while (and (not (eobp)) (progn (end-of-line) (c-is-escaped (point)))) (forward-line)) (end-of-line) (point)) ((back-to-indentation) (point)) ((c-beginning-of-defun-1) (point)) ((c-end-of-defun-1) (point)) (line-beginning-position 0) ((forward-line -1) (point)) (line-beginning-position 2) ((forward-line 1) (point)) (line-end-position 0) ((beginning-of-line) (or (bobp) (backward-char)) (point)) (line-end-position 2) ((forward-line 1) (end-of-line) (point)) ((forward-line -1) (back-to-indentation) (point)) ((forward-line 1) (back-to-indentation) (point)) ((c-backward-syntactic-ws) (point)) ((c-forward-syntactic-ws) (point)) error "Unknown buffer position requested: %s" message "Warning: c-point long expansion" let position ((cond ((eq position 'bol) (beginning-of-line)) ((eq position 'eol) (end-of-line)) ((eq position 'boi) (back-to-indentation)) ((eq position 'bod) (c-beginning-of-defun-1)) ((eq position 'eod) (c-end-of-defun-1)) ((eq position 'bopl) (forward-line -1)) ((eq position 'bonl) (forward-line 1)) ((eq position 'eopl) (progn (beginning-of-line) (or (bobp) (backward-char)))) ((eq position 'eonl) (progn (forward-line 1) (end-of-line))) ((eq position 'iopl) (progn (forward-line -1) (back-to-indentation))) ((eq position 'ionl) (progn (forward-line 1) (back-to-indentation))) ((eq position 'bosws) (c-backward-syntactic-ws)) ((eq position 'eosws) (c-forward-syntactic-ws)) (t (error "Unknown buffer position requested: %s" position)))) ((point))] 8 (#$ . 3980)]))
(put 'c-point 'edebug-form-spec t)
(defconst c-use-category (byte-code "\302\303\304\"r\211q\210\305\306\"\216\304\211\307\310 !\210\311c\210\312eeT\313\314$\210\312\315e\\\316e\\\313\317$\210eb\210\320 \210`\316e\\U,\207" [lookup-syntax-properties parse-sexp-lookup-properties generate-new-buffer " *temp*" t make-closure #[0 "\301\300!\205	\302\300!\207" [V0 buffer-name kill-buffer] 2] set-syntax-table make-syntax-table "<()>" put-text-property category c-<-as-paren-syntax 3 4 c->-as-paren-syntax forward-sexp] 6))
#@12 

(fn POS)
(defalias 'c-is-escaped '(macro . #[257 "\300\301D\302BB\207" [save-excursion goto-char ((not (zerop (logand (skip-chars-backward "\\\\") 1))))] 4 (#$ . 8320)]))
(put 'c-is-escaped 'edebug-form-spec t)
#@20 

(fn POS BEG END)
(defalias 'c-will-be-escaped '(macro . #[771 "\300\301\302D\303B\304D\305\306\307\304	D\310BBB\311BBBBBD\207" [save-excursion let -end- (count) goto-char (setq count (skip-chars-backward "\\\\" -end-)) when (eq (point) -end-) ((setq count (+ count (skip-chars-backward "\\\\")))) ((not (zerop (logand count 1))))] 12 (#$ . 8540)]))
(put 'c-will-be-escaped 'edebug-form-spec t)
#@12 

(fn BEG)
(defalias 'c-will-be-unescaped '(macro . #[257 "\300\301\302\303D\304BBBD\207" [save-excursion let (count) goto-char ((setq count (skip-chars-backward "\\\\")) (zerop (logand count 1)))] 6 (#$ . 8946)]))
(put 'c-will-be-unescaped 'edebug-form-spec t)
#@45 

(fn POSITION PROP &optional OBJECT LIMIT)
(defalias 'c-next-single-property-change '(macro . #[1026 "\203\301\302!\203\302\257\207\303\257\207" [c-use-extents fboundp next-single-char-property-change next-single-property-change] 9 (#$ . 9215)]))
(put 'c-next-single-property-change 'edebug-form-spec t)
#@45 

(fn POSITION PROP &optional OBJECT LIMIT)
(defalias 'c-previous-single-property-change '(macro . #[1026 "\203\301\302!\203\302\257\207\303\257\207" [c-use-extents fboundp previous-single-char-property-change previous-single-property-change] 9 (#$ . 9541)]))
(put 'c-previous-single-property-change 'edebug-form-spec t)
(defalias 'c-region-is-active-p '(macro . #[0 "\300\301!\203\302\207\303\207" [fboundp region-active-p (region-active-p) mark-active] 2]))
#@17 

(fn ACTIVATE)
(defalias 'c-set-region-active '(macro . #[257 "\300\301!\203\f\302
\303BB\207\304\305E\207" [fboundp zmacs-activate-region if ((zmacs-activate-region) (zmacs-deactivate-region)) setq mark-active] 4 (#$ . 10024)]))
(put 'c-set-region-active 'edebug-form-spec t)
#@19 

(fn MAP PARENT)
(defalias 'c-set-keymap-parent '(macro . #[514 "\300\301!\203\301E\207\300\302!\203\302E\207\303\304!\207" [fboundp set-keymap-parents set-keymap-parent error "CC Mode is incompatible with this version of Emacs"] 5 (#$ . 10310)]))
(put 'c-set-keymap-parent 'edebug-form-spec t)
#@70 Delete the text between START and END and return it.

(fn START END)
(defalias 'c-delete-and-extract-region '(macro . #[514 "\300\301!\203\301E\207\302\303E\304EE\207" [fboundp delete-and-extract-region prog1 buffer-substring delete-region] 7 (#$ . 10620)]))
(put 'c-delete-and-extract-region 'edebug-form-spec t)
#@19 

(fn &rest BODY)
(defalias 'c-safe '(macro . #[128 "\300\301\302B\303BBB\207" [condition-case nil progn ((error nil))] 5 (#$ . 10948)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put c-safe lisp-indent-function 0 put edebug-form-spec t] 5)
#@16 

(fn INTEGER)
(defalias 'c-int-to-char '(macro . #[257 "\300\301!\203\n\301
D\207\207" [fboundp int-to-char] 3 (#$ . 11216)]))
(put 'c-int-to-char 'edebug-form-spec t)
#@12 

(fn ARG)
(defalias 'c-characterp '(macro . #[257 "\300
D\207" [integerp] 3 (#$ . 11392)]))
(put 'c-characterp 'edebug-form-spec t)
(defalias 'c-last-command-char '(macro . #[0 "\300\207" [last-command-event] 1]))
(defalias 'c-sentence-end '(macro . #[0 "\300\301!\203\302\207\301\207" [fboundp sentence-end (sentence-end)] 2]))
(defalias 'c-default-value-sentence-end '(macro . #[0 "\300\301!\203\302\207\303\207" [fboundp sentence-end (let (sentence-end) (sentence-end)) (default-value 'sentence-end)] 2]))
(defconst c-c++-raw-string-opener-re "R\"\\([^ ()\\\n
	]\\{0,16\\}\\)(")
(defconst c-c++-raw-string-opener-1-re "\"\\([^ ()\\\n
	]\\{0,16\\}\\)(")
(defalias 'c-sub-at-c++-raw-string-opener '(macro . #[0 "\300\207" [(save-excursion (and (if (eq (char-after) 82) (progn (forward-char) t) (eq (char-before) 82)) (looking-at c-c++-raw-string-opener-1-re)))] 1]))
#@22 

(fn &optional POS)
(defalias 'c-at-c++-raw-string-opener '(macro . #[256 "\211\203\f\300\301D\302BB\207\303\207" [save-excursion goto-char ((c-sub-at-c++-raw-string-opener)) (c-sub-at-c++-raw-string-opener)] 4 (#$ . 12271)]))
(put 'c-at-c++-raw-string-opener 'edebug-form-spec t)
#@1211 Bind variables according to VARLIST (in `let*' style) and eval BODY,
then restore the buffer state under the assumption that no significant
modification has been made in BODY.  A change is considered
significant if it affects the buffer text in any way that isn't
completely restored again.  Changes in text properties like `face' or
`syntax-table' are considered insignificant.  This macro allows text
properties to be changed, even in a read-only buffer.

This macro should be placed around all calculations which set
"insignificant" text properties in a buffer, even when the buffer is
known to be writable.  That way, these text properties remain set
even if the user undoes the command which set them.

This macro should ALWAYS be placed around "temporary" internal buffer
changes (like adding a newline to calculate a text-property then
deleting it again), so that the user never sees them on his
`buffer-undo-list'.  See also `c-tentative-buffer-changes'.

However, any user-visible changes to the buffer (like auto-newlines)
must not be within a `c-save-buffer-state', since the user then
wouldn't be able to undo them.

The return value is the value of the last form in BODY.

(fn VARLIST &rest BODY)
(defalias 'c-save-buffer-state '(macro . #[385 "\300\301!\203\301\302BBD\207\302\303\304\305\306\307\310\311\312\313BBBBBBBBB\314\315B\316BBE\207" [fboundp with-silent-modifications let* (modified (buffer-modified-p)) (buffer-undo-list t) (inhibit-read-only t) (inhibit-point-motion-hooks t) before-change-functions after-change-functions deactivate-mark buffer-file-name buffer-file-truename unwind-protect progn ((and (not modified) (buffer-modified-p) (set-buffer-modified-p nil)))] 13 (#$ . 12563)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put c-save-buffer-state edebug-form-spec let* function-put lisp-indent-function 1] 4)
#@706 Eval BODY and optionally restore the buffer contents to the state it
was in before BODY.  Any changes are kept if the last form in BODY
returns non-nil.  Otherwise it's undone using the undo facility, and
various other buffer state that might be affected by the changes is
restored.  That includes the current buffer, point, mark, mark
activation (similar to `save-excursion'), and the modified state.
The state is also restored if BODY exits nonlocally.

If BODY makes a change that unconditionally is undone then wrap this
macro inside `c-save-buffer-state'.  That way the change can be done
even when the buffer is read-only, and without interference from
various buffer change hooks.

(fn &rest BODY)
(defalias 'c-tentative-buffer-changes '(macro . #[128 "\300\301\302\303\304\305\306\307\310\311\312\313\fB\257	\314BBE\207" [let (-tnt-chng-keep -tnt-chng-state (old-undo-list buffer-undo-list)) unwind-protect setq buffer-undo-list (if (eq old-undo-list t) nil (cons nil buffer-undo-list)) old-undo-list (if (eq old-undo-list t) t buffer-undo-list) -tnt-chng-state (c-tnt-chng-record-state old-undo-list) -tnt-chng-keep progn ((c-tnt-chng-cleanup -tnt-chng-keep -tnt-chng-state))] 14 (#$ . 14439)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put c-tentative-buffer-changes lisp-indent-function 0 put edebug-form-spec t] 5)
#@22 

(fn OLD-UNDO-LIST)
(defalias 'c-tnt-chng-record-state #[257 "\300
p`\301\302!\303 \304 &\207" [vector mark t region-active-p buffer-modified-p] 8 (#$ . 15794)])
#@25 

(fn KEEP SAVED-STATE)
(defalias 'c-tnt-chng-cleanup #[514 "\211\303\234
=\203\211A\211\207\2037\211\304=\203#\305\306!\210\307 \210\304\211\207\211A=\2042\211A\262
\202$\211A\241\207\304
\304=?\205A
A

=\204R\310\311\"\211\202D)\266\211\304=\203]\304\312\311\234!\205\210
\311\234q\210
\313\234b\210\314\315\234!\210
\316\234
\317\234?\205\210\320 \205\210\321\322!\207" [buffer-undo-list undo-in-progress mark-active 0 t message "Can't save additional undo list in c-tnt-chng-cleanup" ding primitive-undo 1 buffer-live-p 2 set-mark 3 4 5 buffer-modified-p set-buffer-modified-p nil] 9 (#$ . 15964)])
#@646 Forward skip over syntactic whitespace.
Syntactic whitespace is defined as whitespace characters, comments,
and preprocessor directives.  However if point starts inside a comment
or preprocessor directive, the content of it is not treated as
whitespace.

LIMIT sets an upper limit of the forward movement, if specified.  If
LIMIT or the end of the buffer is reached inside a comment or
preprocessor directive, the point will be left there.  If point starts
on the wrong side of LIMIT, it stays unchanged.

Note that this function might do hidden buffer changes.  See the
comment at the start of cc-engine.el for more info.

(fn &optional LIMIT)
(defalias 'c-forward-syntactic-ws '(macro . #[256 "\211\203\300\301\302\303\304BBE\305\306\307\303\310BBE\311BBE\207\312\207" [when < (point) or ((point-max)) save-restriction narrow-to-region (point-min) ((point-max)) ((c-forward-sws)) (c-forward-sws)] 9 (#$ . 16603)]))
(put 'c-forward-syntactic-ws 'edebug-form-spec t)
#@660 Backward skip over syntactic whitespace.
Syntactic whitespace is defined as whitespace characters, comments,
and preprocessor directives.  However if point starts inside a comment
or preprocessor directive, the content of it is not treated as
whitespace.

LIMIT sets a lower limit of the backward movement, if specified.  If
LIMIT is reached inside a line comment or preprocessor directive then
the point is moved into it past the whitespace at the end.  If point
starts on the wrong side of LIMIT, it stays unchanged.

Note that this function might do hidden buffer changes.  See the
comment at the start of cc-engine.el for more info.

(fn &optional LIMIT)
(defalias 'c-backward-syntactic-ws '(macro . #[256 "\211\203\300\301\302\303\304BBE\305\306\303\307BB\310BB\311BBE\207\312\207" [when > (point) or ((point-min)) save-restriction narrow-to-region ((point-min)) ((point-max)) ((c-backward-sws)) (c-backward-sws)] 8 (#$ . 17582)]))
(put 'c-backward-syntactic-ws 'edebug-form-spec t)
#@386 Move forward across COUNT balanced expressions.
A negative COUNT means move backward.  Signal an error if the move
fails for any reason.

This is like `forward-sexp' except that it isn't interactive and does
not do any user friendly adjustments of the point and that it isn't
susceptible to user configurations such as disabling of signals in
certain situations.

(fn &optional COUNT)
(defalias 'c-forward-sexp '(macro . #[256 "\211\204\300\262
\301\302\303ED\207" [1 goto-char scan-sexps (point)] 5 (#$ . 18581)]))
(put 'c-forward-sexp 'edebug-form-spec t)
#@68 See `c-forward-sexp' and reverse directions.

(fn &optional COUNT)
(defalias 'c-backward-sexp '(macro . #[256 "\211\204\300\262
\301
\247\203
[\202\302DD\207" [1 c-forward-sexp -] 4 (#$ . 19148)]))
(put 'c-backward-sexp 'edebug-form-spec t)
#@211 Like `scan-lists' but returns nil instead of signaling errors
for unbalanced parens.

A limit for the search may be given.  FROM is assumed to be on the
right side of it.

(fn FROM COUNT DEPTH &optional LIMIT)
(defalias 'c-safe-scan-lists '(macro . #[1027 "\300\301FD
\203B\302\303\247\203+\304W\203#\305\306BB\202>\305\307E\202>\310\311\312BB\305\313BB\305\314	EFEE\207\207" [c-safe scan-lists save-restriction when 0 narrow-to-region ((point-max)) (point-min) if < (0) ((point-max)) (point-min)] 14 (#$ . 19403)]))
(put 'c-safe-scan-lists 'edebug-form-spec t)
#@283 Move forward across one balanced group of parentheses starting at POS or point.
Return POINT when we succeed, NIL when we fail.  In the latter
case, leave point unmoved.

A LIMIT for the search may be given.  The start position is assumed to be
before it.

(fn &optional POS LIMIT)
(defalias 'c-go-list-forward '(macro . #[512 "\300\301\302\206\303\304\305\257DC\306BB\207" [let dest c-safe-scan-lists (point) 1 0 ((when dest (goto-char dest) dest))] 9 (#$ . 19994)]))
(put 'c-go-list-forward 'edebug-form-spec t)
#@283 Move backward across one balanced group of parentheses starting at POS or point.
Return POINT when we succeed, NIL when we fail.  In the latter
case, leave point unmoved.

A LIMIT for the search may be given.  The start position is assumed to be
after it.

(fn &optional POS LIMIT)
(defalias 'c-go-list-backward '(macro . #[512 "\300\301\302\206\303\304\305\257DC\306BB\207" [let dest c-safe-scan-lists (point) -1 0 ((when dest (goto-char dest) dest))] 9 (#$ . 20521)]))
(put 'c-go-list-backward 'edebug-form-spec t)
#@249 Return the first position after the list sexp containing POS,
or nil if no such position exists.  The point is used if POS is left out.

A limit for the search may be given.  The start position is assumed to
be before it.

(fn &optional POS LIMIT)
(defalias 'c-up-list-forward '(macro . #[512 "\300\206\301\302\211\257\207" [c-safe-scan-lists (point) 1] 7 (#$ . 21051)]))
(put 'c-up-list-forward 'edebug-form-spec t)
#@252 Return the position of the start of the list sexp containing POS,
or nil if no such position exists.  The point is used if POS is left out.

A limit for the search may be given.  The start position is assumed to
be after it.

(fn &optional POS LIMIT)
(defalias 'c-up-list-backward '(macro . #[512 "\300\206\301\302\303\257\207" [c-safe-scan-lists (point) -1 1] 7 (#$ . 21480)]))
(put 'c-up-list-backward 'edebug-form-spec t)
#@251 Return the first position inside the first list sexp after POS,
or nil if no such position exists.  The point is used if POS is left out.

A limit for the search may be given.  The start position is assumed to
be before it.

(fn &optional POS LIMIT)
(defalias 'c-down-list-forward '(macro . #[512 "\300\206\301\302\303\257\207" [c-safe-scan-lists (point) 1 -1] 7 (#$ . 21917)]))
(put 'c-down-list-forward 'edebug-form-spec t)
#@249 Return the last position inside the last list sexp before POS,
or nil if no such position exists.  The point is used if POS is left out.

A limit for the search may be given.  The start position is assumed to
be after it.

(fn &optional POS LIMIT)
(defalias 'c-down-list-backward '(macro . #[512 "\300\206\301\302\211\257\207" [c-safe-scan-lists (point) -1] 7 (#$ . 22355)]))
(put 'c-down-list-backward 'edebug-form-spec t)
#@320 Move the point to the first position after the list sexp containing POS,
or containing the point if POS is left out.  Return t if such a
position exists, otherwise nil is returned and the point isn't moved.

A limit for the search may be given.  The start position is assumed to
be before it.

(fn &optional POS LIMIT)
(defalias 'c-go-up-list-forward '(macro . #[512 "\300\301\302EDC\303BB\207" [let dest c-up-list-forward ((when dest (goto-char dest) t))] 7 (#$ . 22791)]))
(put 'c-go-up-list-forward 'edebug-form-spec t)
#@323 Move the point to the position of the start of the list sexp containing POS,
or containing the point if POS is left out.  Return t if such a
position exists, otherwise nil is returned and the point isn't moved.

A limit for the search may be given.  The start position is assumed to
be after it.

(fn &optional POS LIMIT)
(defalias 'c-go-up-list-backward '(macro . #[512 "\300\301\302EDC\303BB\207" [let dest c-up-list-backward ((when dest (goto-char dest) t))] 7 (#$ . 23323)]))
(put 'c-go-up-list-backward 'edebug-form-spec t)
#@318 Move the point to the first position inside the first list sexp after POS,
or before the point if POS is left out.  Return t if such a position
exists, otherwise nil is returned and the point isn't moved.

A limit for the search may be given.  The start position is assumed to
be before it.

(fn &optional POS LIMIT)
(defalias 'c-go-down-list-forward '(macro . #[512 "\300\301\302EDC\303BB\207" [let dest c-down-list-forward ((when dest (goto-char dest) t))] 7 (#$ . 23861)]))
(put 'c-go-down-list-forward 'edebug-form-spec t)
#@316 Move the point to the last position inside the last list sexp before POS,
or before the point if POS is left out.  Return t if such a position
exists, otherwise nil is returned and the point isn't moved.

A limit for the search may be given.  The start position is assumed to
be after it.

(fn &optional POS LIMIT)
(defalias 'c-go-down-list-backward '(macro . #[512 "\300\301\302EDC\303BB\207" [let dest c-down-list-backward ((when dest (goto-char dest) t))] 7 (#$ . 24397)]))
(put 'c-go-down-list-backward 'edebug-form-spec t)
(defalias 'c-beginning-of-defun-1 '(macro . #[0 "\300\301\302\303\304!\305BB\303\304!\205\306\307BBB\310BB\207" [progn if and fboundp buffer-syntactic-context-depth (c-enable-xemacs-performance-kludge-p) (let (beginning-of-defun-function end-of-defun-function pos) (while (not pos) (save-restriction (widen) (setq pos (c-safe-scan-lists (point) -1 (buffer-syntactic-context-depth)))) (cond ((bobp) (setq pos (point-min))) ((not pos) (let ((distance (skip-chars-backward "^{"))) (when (zerop distance) (beginning-of-defun) (setq pos (point))))) ((= pos 0)) ((not (eq (char-after pos) 123)) (goto-char pos) (setq pos nil)))) (goto-char pos)) ((let (beginning-of-defun-function end-of-defun-function) (beginning-of-defun))) ((and defun-prompt-regexp (looking-at defun-prompt-regexp) (goto-char (match-end 0))))] 5]))
#@22 

(fn &optional POS)
(defalias 'c-at-vsemi-p '(macro . #[256 "\300\301\302\301\205\nCBBE\207" [if c-at-vsemi-p-fn funcall] 6 (#$ . 25749)]))
(put 'c-at-vsemi-p 'edebug-form-spec t)
(defalias 'c-vsemi-status-unknown-p '(macro . #[0 "\300\207" [(if c-vsemi-status-unknown-p-fn (funcall c-vsemi-status-unknown-p-fn))] 1]))
#@25 

(fn TABLE &rest CODE)
(defalias 'c-with-syntax-table '(macro . #[385 "\300\301\302\303\304DBB\305BBE\207" [let ((c-with-syntax-table-orig-table (syntax-table))) unwind-protect progn set-syntax-table ((set-syntax-table c-with-syntax-table-orig-table))] 8 (#$ . 26078)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put c-with-syntax-table lisp-indent-function 1 put edebug-form-spec t] 5)
#@149 Skip over any whitespace following point.
This function skips over horizontal and vertical whitespace and line
continuations.

(fn &optional LIMIT)
(defalias 'c-skip-ws-forward '(macro . #[256 "\211\203\300\301\302\303BBDC\304BB\207\305\207" [let limit or ((point-max)) ((while (progn (skip-chars-forward " 	\n
\f" limit) (when (and (eq (char-after) 92) (< (point) limit)) (forward-char) (or (eolp) (progn (backward-char) nil)))))) (while (progn (skip-chars-forward " 	\n
\f") (when (eq (char-after) 92) (forward-char) (or (eolp) (progn (backward-char) nil)))))] 6 (#$ . 26496)]))
(put 'c-skip-ws-forward 'edebug-form-spec t)
#@149 Skip over any whitespace preceding point.
This function skips over horizontal and vertical whitespace and line
continuations.

(fn &optional LIMIT)
(defalias 'c-skip-ws-backward '(macro . #[256 "\211\203\300\301\302\303BBDC\304BB\207\305\207" [let limit or ((point-min)) ((while (progn (skip-chars-backward " 	\n
\f" limit) (and (eolp) (eq (char-before) 92) (> (point) limit))) (backward-char))) (while (progn (skip-chars-backward " 	\n
\f") (and (eolp) (eq (char-before) 92))) (backward-char))] 6 (#$ . 27134)]))
(put 'c-skip-ws-backward 'edebug-form-spec t)
(defvar c-langs-are-parametric nil)
#@126 Return non-nil if the current CC Mode major mode is MODE.
MODE is either a mode symbol or a list of mode symbols.

(fn MODE)
(defalias 'c-major-mode-is '(macro . #[257 "\203\301
D\207\211\242\302=\203%\303
!\211<\203\304\305\302DE\207\306\305\302DE\207\307\310DC\311BB\207" [c-langs-are-parametric c-lang-major-mode-is quote eval memq c-buffer-is-cc-mode eq let mode ((if (listp mode) (memq c-buffer-is-cc-mode mode) (eq c-buffer-is-cc-mode mode)))] 6 (#$ . 27742)]))
(put 'c-major-mode-is 'edebug-form-spec t)
(defconst c-use-extents (byte-code "\300\301!\205'\300\302!\205'\300\303!\205'\300\304!\205'\300\305!\205'\300\306!\205'\300\307!\207" [fboundp extent-at set-extent-property set-extent-properties make-extent extent-property delete-extent map-extents] 2))
(defconst c-<-as-paren-syntax '(4 . 62))
(put 'c-<-as-paren-syntax 'syntax-table c-<-as-paren-syntax)
(defconst c->-as-paren-syntax '(5 . 60))
(byte-code "\301\300\302#\210\303\304\305\"\207" [c->-as-paren-syntax put syntax-table defalias c-put-char-property-fun ignore] 4)
#@27 

(fn POS PROPERTY VALUE)
(defalias 'c-put-char-property '(macro . #[771 "\301!\262\204\302\303!\204\304\305DF\207\306\307DC\310\311\312!\205*\313=\205*\314\315\307\316\305	D\257C\"BB\207" [c-use-extents eval boundp text-property-default-nonsticky c-put-char-property-fun quote let -pos- append fboundp syntax-ppss syntax-table ((setq c-syntax-table-hwm (min c-syntax-table-hwm -pos-))) put-text-property (1+ -pos-)] 12 (#$ . 28804)]))
(put 'c-put-char-property 'edebug-form-spec t)
#@21 

(fn POS PROPERTY)
(defalias 'c-get-char-property '(macro . #[514 "\301
!\262
\203!\302\303\304\305\306DFDC\307\303\310\303\306DEEE\207\311\306DE\207" [c-use-extents eval let ext extent-at nil quote if extent-property get-text-property] 10 (#$ . 29311)]))
(byte-code "\300\301\302\303#\210\304\305\306\"\207" [put c-get-char-property edebug-form-spec t defalias c-clear-char-property-fun nil] 4)
#@21 

(fn POS PROPERTY)
(defalias 'c-clear-char-property '(macro . #[514 "\301
!\262
\203\302\303\304\305\306DFDC\307BB\207\310\311!\203A\302\312DC\313\314\315!\2052\316=\2052\317\320\312\321\306\322BDFC\"BB\207\323\306DE\207" [c-use-extents eval let ext extent-at nil quote ((if ext (delete-extent ext))) boundp text-property-default-nonsticky pos append fboundp syntax-ppss syntax-table ((setq c-syntax-table-hwm (min c-syntax-table-hwm pos))) remove-text-properties (1+ pos) (nil) c-clear-char-property-fun] 12 (#$ . 29723)]))
(put 'c-clear-char-property 'edebug-form-spec t)
#@25 

(fn FROM TO PROPERTY)
(defalias 'c-min-property-position '(macro . #[771 "\300\301D\302D\303BB\304\305\306\307\301EE\310B\311\312\313\314\301	\315BBBE\316BB\317B\320BBBE\207" [let -from- -to- (pos) cond and (< -from- -to-) get-text-property (-from-) < setq pos next-single-property-change (nil -to-) (-to-) (pos) ((most-positive-fixnum))] 14 (#$ . 30319)]))
(put 'c-min-property-position 'edebug-form-spec t)
#@25 

(fn FROM TO PROPERTY)
(defalias 'c-clear-char-properties '(macro . #[771 "\301
!\262
\302\303D\304\305\303\306DFDD\307\310\311\203,\312\313\314\304\303\314\211\306
D\257\202R\315\316!\203H\317=\203H\311\320\321\304\303\306\322BDFE\202R\321\304\303\306	\323BDF\324BB\325BBBE\207" [c-use-extents eval let* -to- ret c-min-property-position quote if (< ret -to-) progn map-extents (lambda (ext ignored) (delete-extent ext)) nil fboundp syntax-ppss syntax-table (setq c-syntax-table-hwm (min c-syntax-table-hwm ret)) remove-text-properties (nil) (nil) (ret) (nil)] 17 (#$ . 30741)]))
(put 'c-clear-char-properties 'edebug-form-spec t)
#@16 

(fn FROM TO)
(defalias 'c-clear-syn-tab-properties '(macro . #[514 "\300\301D\302DD\303BB\207" [let -from- -to- ((when (and c-min-syn-tab-mkr c-max-syn-tab-mkr (< -from- c-max-syn-tab-mkr) (> -to- c-min-syn-tab-mkr)) (let ((pos -from-)) (while (and (< pos -to-) (setq pos (c-min-property-position pos -to- 'c-fl-syn-tab)) (< pos -to-)) (c-clear-syn-tab pos) (setq pos (1+ pos))))) (c-clear-char-properties -from- -to- 'syntax-table))] 6 (#$ . 31396)]))
(put 'c-clear-syn-tab-properties 'edebug-form-spec t)
#@329 Search forward for a text-property PROPERTY having value VALUE.
LIMIT bounds the search.  The comparison is done with `equal'.

Leave point just after the character, and set the match data on
this character, and return point.  If VALUE isn't found, Return
nil; point is then left undefined.

(fn PROPERTY VALUE &optional LIMIT)
(defalias 'c-search-forward-char-property '(macro . #[770 "\300\301\302\303\304\305\206\f\306E\307\310\311\305E	EDE\312\305\313\305\n\314\n\206&\315\257EE\316\304\305\2063\317E\320BBF\207" [let ((place (point))) while and < place (point-max) not equal c-get-char-property setq c-next-single-property-change nil (point-max) when (point-max) ((goto-char place) (search-forward-regexp "\\(\n\\|.\\)") (point))] 14 (#$ . 31914)]))
(put 'c-search-forward-char-property 'edebug-form-spec t)
#@327 Search backward for a text-property PROPERTY having value VALUE.
LIMIT bounds the search.  The comparison is done with `equal'.

Leave point just before the character, set the match data on this
character, and return point.  If VALUE isn't found, Return nil;
point is then left undefined.

(fn PROPERTY VALUE &optional LIMIT)
(defalias 'c-search-backward-char-property '(macro . #[770 "\301\302\303\304\305\306\206\f\307E\310\311\312\313E	EDE\314\306\203)\315\316!\203)\316\202*\317\306\n\320\n\2064\321\257EE\322\305\306\206A\323E\324BBF\207" [c-use-extents let ((place (point))) while and > place (point-min) not equal c-get-char-property (1- place) setq fboundp previous-single-char-property-change previous-single-property-change nil (point-min) when (point-min) ((goto-char place) (search-backward-regexp "\\(\n\\|.\\)") (point))] 14 (#$ . 32747)]))
(put 'c-search-backward-char-property 'edebug-form-spec t)
#@281 Remove all text-properties PROPERTY from the region (FROM, TO)
which have the value VALUE, as tested by `equal'.  These
properties are assumed to be over individual characters, having
been put there by `c-put-char-property'.  POINT remains unchanged.

(fn FROM TO PROPERTY VALUE)
(defalias 'c-clear-char-property-with-value-function #[1028 "\301
W\203\302\"\232\204\303\301$\262\202
W\205K\304\305!\2033\306=\2033^\303\301$\262
\307\301D#\210\211\262\202\207" [c-syntax-table-hwm nil get-text-property next-single-property-change fboundp syntax-ppss syntax-table remove-text-properties] 11 (#$ . 33685)])
#@281 Remove all text-properties PROPERTY from the region [FROM, TO)
which have the value VALUE, as tested by `equal'.  These
properties are assumed to be over individual characters, having
been put there by `c-put-char-property'.  POINT remains unchanged.

(fn FROM TO PROPERTY VALUE)
(defalias 'c-clear-char-property-with-value '(macro . #[1028 "\203\301\302DC\303\304\305\306BBBBBBE\207\307\257\207" [c-use-extents let -property- map-extents (lambda (ext val) (if (equal (extent-property ext -property-) val) (delete-extent ext))) nil (nil -property-) c-clear-char-property-with-value-function] 13 (#$ . 34332)]))
(put 'c-clear-char-property-with-value 'edebug-form-spec t)
#@399 Search forward for a text-property PROPERTY having value VALUE on a
character with value CHAR.
LIMIT bounds the search.  The value comparison is done with `equal'.
PROPERTY must be a constant.

Leave point just after the character, and set the match data on
this character, and return point.  If the search fails, return
nil; point is then left undefined.

(fn PROPERTY VALUE CHAR &optional LIMIT)
(defalias 'c-search-forward-char-property-with-value-on-char '(macro . #[1027 "\300\301\302\303\304DED\305\306\307BBD\310DE\311\312\313\314\315\316\317\fE\320BBDE\321BB\322BBB\207" [let char-skip concat "^" char-to-string -limit- or ((point-max)) -value- while and (progn (skip-chars-forward char-skip -limit-) (< (point) -limit-)) not equal c-get-char-property (point) (-value-) ((forward-char)) ((when (< (point) -limit-) (search-forward-regexp "\\(\n\\|.\\)") (point)))] 14 (#$ . 35025)]))
(put 'c-search-forward-char-property-with-value-on-char 'edebug-form-spec t)
#@401 Search backward for a text-property PROPERTY having value VALUE on a
character with value CHAR.
LIMIT bounds the search.  The value comparison is done with `equal'.
PROPERTY must be a constant.

Leave point just before the character, and set the match data on
this character, and return point.  If the search fails, return
nil; point is then left undefined.

(fn PROPERTY VALUE CHAR &optional LIMIT)
(defalias 'c-search-backward-char-property-with-value-on-char '(macro . #[1027 "\300\301\302\303\304DED\305\306\307BBD\310DE\311\312\313\314\315\316\317\fE\320BBDE\321BB\322BBB\207" [let char-skip concat "^" char-to-string -limit- or ((point-min)) -value- while and (progn (skip-chars-backward char-skip -limit-) (> (point) -limit-)) not equal c-get-char-property (1- (point)) (-value-) ((backward-char)) ((when (> (point) -limit-) (search-backward-regexp "\\(\n\\|.\\)") (point)))] 14 (#$ . 36006)]))
(put 'c-search-backward-char-property-with-value-on-char 'edebug-form-spec t)
#@392 Search forward for a character CHAR without text property PROPERTY having
a value CHAR.
LIMIT bounds the search.  The value comparison is done with `equal'.
PROPERTY must be a constant.

Leave point just after the character, and set the match data on
this character, and return point.  If the search fails, return
nil; point is then left undefined.

(fn PROPERTY VALUE CHAR &optional LIMIT)
(defalias 'c-search-forward-char-property-without-value-on-char '(macro . #[1027 "\300\301\302\303\304DED\305\306\307BBD\310DE\311\312\313\314\315\316E\317BBE\320BB\321BBB\207" [let char-skip concat "^" char-to-string -limit- or ((point-max)) -value- while and (progn (skip-chars-forward char-skip -limit-) (< (point) -limit-)) equal c-get-char-property (point) (-value-) ((forward-char)) ((when (< (point) -limit-) (search-forward-regexp "\\(\n\\|.\\)") (point)))] 13 (#$ . 36999)]))
(put 'c-search-forward-char-property-without-value-on-char 'edebug-form-spec t)
#@364 Remove all text-properties PROPERTY with value VALUE on
characters with value CHAR from the region [FROM, TO), as tested
by `equal'.  These properties are assumed to be over individual
characters, having been put there by c-put-char-property.  POINT
remains unchanged.  Return the position of the first removed
property, or nil.

(fn FROM TO PROPERTY VALUE CHAR)
(defalias 'c-clear-char-property-with-value-on-char-function #[1285 "\301
W\203 \302\"\232\204 \303\301	$\262\202
W\203P
f=\203I\304\211T\301D#\210\211\204I
\262
\305=\203I^
T\262\202\207" [c-syntax-table-hwm nil get-text-property next-single-property-change remove-text-properties syntax-table] 12 (#$ . 37969)])
#@364 Remove all text-properties PROPERTY with value VALUE on
characters with value CHAR from the region [FROM, TO), as tested
by `equal'.  These properties are assumed to be over individual
characters, having been put there by c-put-char-property.  POINT
remains unchanged.  Return the position of the first removed
property, or nil.

(fn FROM TO PROPERTY VALUE CHAR)
(defalias 'c-clear-char-property-with-value-on-char '(macro . #[1285 "\203#\301\302D\303D\304BB\305\306\307		\310BBBBBB\311BBB\207\312\257\207" [c-use-extents let -property- -char- ((first (1+ (point-max)))) map-extents (lambda (ext val) (when (and (equal (extent-property ext -property-) val) (eq (char-after (extent-start-position ext)) -char-)) (setq first (min first (extent-start-position ext))) (delete-extent ext))) nil (nil -property-) ((and (<= first (point-max)) first)) c-clear-char-property-with-value-on-char-function] 14 (#$ . 38686)]))
(put 'c-clear-char-property-with-value-on-char 'edebug-form-spec t)
#@138 Put the text property PROPERTY with value VALUE on characters
with value CHAR in the region [FROM to).

(fn FROM TO PROPERTY VALUE CHAR)
(defalias 'c-put-char-properties-on-char '(macro . #[1285 "\300\301\302\303\304DED\305DD\306\307D\310\311\312\313\314!\205&\315\n!\316=\205&\317\320\321\f\fF\322B\"BBEE\207" [let skip-string concat "^" list -to- save-excursion goto-char while (progn (skip-chars-forward skip-string -to-) (< (point) -to-)) append fboundp syntax-ppss eval syntax-table ((setq c-syntax-table-hwm (min c-syntax-table-hwm (point)))) c-put-char-property (point) ((forward-char))] 17 (#$ . 39689)]))
(put 'c-put-char-properties-on-char 'edebug-form-spec t)
#@31 

(fn FROM TO PROPERTY VALUE)
(defalias 'c-put-overlay '(macro . #[1028 "\300\301!\203\302\303\301EDC\304\303F\305BBB\207\302\306\307EDC\310\306F\311BBB\207" [fboundp make-overlay let ol overlay-put (ol) ext make-extent set-extent-property (ext)] 10 (#$ . 40376)]))
(put 'c-put-overlay 'edebug-form-spec t)
#@16 

(fn OVERLAY)
(defalias 'c-delete-overlay '(macro . #[257 "\300\301!\203\n\302
D\207\303
D\207" [fboundp make-overlay delete-overlay delete-extent] 3 (#$ . 40703)]))
(put 'c-delete-overlay 'edebug-form-spec t)
(defalias 'c-end-of-defun-1 #[0 "`\303\304w\210\304\211\305 \210*\n\203\306\n!\203\307\225b\210\304f\310=\203(\311`\312\"b\210`
W\2050db\207" [end-of-defun-function beginning-of-defun-function defun-prompt-regexp "^}" nil beginning-of-defun looking-at 0 123 scan-sexps 1] 4])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put c-end-of-defun-1 speed -1 put byte-optimizer byte-compile-inline-expand] 5)
#@12 

(fn POS)
(defalias 'c-mark-<-as-paren '(macro . #[257 "\203\n\301
\302BB\207\301
\303BB\207" [c-use-category c-put-char-property ('category 'c-<-as-paren-syntax) ('syntax-table c-<-as-paren-syntax)] 4 (#$ . 41347)]))
(put 'c-mark-<-as-paren 'edebug-form-spec t)
#@12 

(fn POS)
(defalias 'c-mark->-as-paren '(macro . #[257 "\203\n\301
\302BB\207\301
\303BB\207" [c-use-category c-put-char-property ('category 'c->-as-paren-syntax) ('syntax-table c->-as-paren-syntax)] 4 (#$ . 41619)]))
(put 'c-mark->-as-paren 'edebug-form-spec t)
#@12 

(fn POS)
(defalias 'c-unmark-<->-as-paren '(macro . #[257 "\301
\203\n\302\202\303E\207" [c-use-category c-clear-char-property 'category 'syntax-table] 4 (#$ . 41891)]))
(put 'c-unmark-<->-as-paren 'edebug-form-spec t)
(defalias 'c-suppress-<->-as-parens #[0 "\300\301\302\303#\210\300\304\302\303#\207" [put c-<-as-paren-syntax syntax-table nil c->-as-paren-syntax] 4])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put c-suppress-<->-as-parens speed -1 put byte-optimizer byte-compile-inline-expand] 5)
(defalias 'c-restore-<->-as-parens #[0 "\302\300\303#\210\302\301\303	#\207" [c-<-as-paren-syntax c->-as-paren-syntax put syntax-table] 4])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put c-restore-<->-as-parens speed -1 put byte-optimizer byte-compile-inline-expand] 5)
#@20 

(fn &rest FORMS)
(defalias 'c-with-<->-as-parens-suppressed '(macro . #[128 "\300\301\302BB\303BB\207" [unwind-protect progn (c-suppress-<->-as-parens) ((c-restore-<->-as-parens))] 5 (#$ . 42714)]))
(put 'c-with-<->-as-parens-suppressed 'edebug-form-spec '(body))
#@13 

(fn FROM)
(defalias 'c-sc-scan-lists-no-category+1+1 '(macro . #[257 "\300\301\302\303BBDC\304BB\207" [let pos scan-lists (1 1) ((while (eq (char-before pos) 62) (setq pos (scan-lists pos 1 1))) pos)] 6 (#$ . 42987)]))
(put 'c-sc-scan-lists-no-category+1+1 'edebug-form-spec t)
#@13 

(fn FROM)
(defalias 'c-sc-scan-lists-no-category+1-1 '(macro . #[257 "\300\301\302\303BBDC\304BB\207" [let pos scan-lists (1 -1) ((while (eq (char-before pos) 60) (setq pos (scan-lists pos 1 1)) (setq pos (scan-lists pos 1 -1))) pos)] 6 (#$ . 43274)]))
(put 'c-sc-scan-lists-no-category+1-1 'edebug-form-spec t)
#@13 

(fn FROM)
(defalias 'c-sc-scan-lists-no-category-1+1 '(macro . #[257 "\300\301\302\303BBDC\304BB\207" [let pos scan-lists (-1 1) ((while (eq (char-after pos) 60) (setq pos (scan-lists pos -1 1))) pos)] 6 (#$ . 43595)]))
(put 'c-sc-scan-lists-no-category-1+1 'edebug-form-spec t)
#@13 

(fn FROM)
(defalias 'c-sc-scan-lists-no-category-1-1 '(macro . #[257 "\300\301\302\303BBDC\304BB\207" [let pos scan-lists (-1 -1) ((while (eq (char-after pos) 62) (setq pos (scan-lists pos -1 1)) (setq pos (scan-lists pos -1 -1))) pos)] 6 (#$ . 43883)]))
(put 'c-sc-scan-lists-no-category-1-1 'edebug-form-spec t)
#@25 

(fn FROM COUNT DEPTH)
(defalias 'c-sc-scan-lists '(macro . #[771 "\203\n\301F\207
\302=\203\211\302=\203\303D\207
\302=\203*\211\304=\203*\305D\207
\304=\203:\211\302=\203:\306D\207
\304=\203J\211\304=\203J\307D\207\310\311!\207" [c-use-category scan-lists 1 c-sc-scan-lists-no-category+1+1 -1 c-sc-scan-lists-no-category+1-1 c-sc-scan-lists-no-category-1+1 c-sc-scan-lists-no-category-1-1 error "Invalid parameter(s) to c-sc-scan-lists"] 7 (#$ . 44206)]))
(put 'c-sc-scan-lists 'edebug-form-spec t)
#@48 

(fn FROM TO TARGETDEPTH STOPBEFORE OLDSTATE)
(defalias 'c-sc-parse-partial-sexp-no-category #[1285 "\300%`W\203A`Sf\301=\204`Sf\302=\203A\211`Sf\303>\203,
@T\202/
@S\240\210\300`%\262
\202\207" [parse-partial-sexp 60 62 (62 41 125 93)] 12 (#$ . 44733)])
#@58 

(fn FROM TO &optional TARGETDEPTH STOPBEFORE OLDSTATE)
(defalias 'c-sc-parse-partial-sexp '(macro . #[1282 "\203
\301\257\207\302\257\207" [c-use-category parse-partial-sexp c-sc-parse-partial-sexp-no-category] 11 (#$ . 45017)]))
(put 'c-sc-parse-partial-sexp 'edebug-form-spec t)
#@66 Are we looking at a character which isn't alphanumeric or space?
(defalias 'c-looking-at-non-alphnumspace '(macro . #[0 "\301>\203\302\207\303\207" [c-emacs-features gen-comment-delim (looking-at "\\([;#]\\|\\'\\|\\s(\\|\\s)\\|\\s\"\\|\\s\\\\|\\s$\\|\\s<\\|\\s>\\|\\s!\\)") (or (looking-at "\\([;#]\\|\\'\\|\\s(\\|\\s)\\|\\s\"\\|\\s\\\\|\\s$\\|\\s<\\|\\s>\\)" (let ((prop (c-get-char-property (point) 'syntax-table))) (eq prop '(14)))))] 2 (#$ . 45320)]))
#@19 

(fn LIST ALIST)
(defalias 'c-intersect-lists #[514 "\300\203@\236\211\262\204A\262\202
\207" [nil] 5 (#$ . 45785)])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put c-intersect-lists speed -1 put byte-optimizer byte-compile-inline-expand] 5)
#@27 

(fn LIST ALIST1 ALIST2)
(defalias 'c-lookup-lists #[771 "\300\203@\236\211\262\204A\262\202\266\202@
\236\207" [nil] 8 (#$ . 46063)])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put c-lookup-lists speed -1 put byte-optimizer byte-compile-inline-expand] 5)
#@230 Return the syntactic symbol in LANGELEM.

LANGELEM is either a cons cell on the "old" form given as the first
argument to lineup functions or a syntactic element on the "new"
form as used in `c-syntactic-element'.

(fn LANGELEM)
(defalias 'c-langelem-sym #[257 "\211@\207" [] 2 (#$ . 46360)])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put c-langelem-sym speed -1 put byte-optimizer byte-compile-inline-expand] 5)
#@254 Return the anchor position in LANGELEM, or nil if there is none.

LANGELEM is either a cons cell on the "old" form given as the first
argument to lineup functions or a syntactic element on the "new"
form as used in `c-syntactic-element'.

(fn LANGELEM)
(defalias 'c-langelem-pos #[257 "\211A:\203\n\211A\242\207\211A\207" [] 2 (#$ . 46800)])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put c-langelem-pos speed -1 put byte-optimizer byte-compile-inline-expand] 5)
#@339 Return the column of the anchor position in LANGELEM.
Also move the point to that position unless PRESERVE-POINT is non-nil.

LANGELEM is either a cons cell on the "old" form given as the first
argument to lineup functions or a syntactic element on the "new"
form as used in `c-syntactic-element'.

(fn LANGELEM &optional PRESERVE-POINT)
(defalias 'c-langelem-col #[513 "
\211A:\203\211A\242\262
\202\211A\262
`
\203$
b\210i\203%
b\210\207\300\207" [0] 6 (#$ . 47290)])
#@308 Return the secondary position in LANGELEM, or nil if there is none.

LANGELEM is typically a syntactic element on the "new" form as used
in `c-syntactic-element'.  It may also be a cons cell as passed in the
first argument to lineup functions, but then the returned value always
will be nil.

(fn LANGELEM)
(defalias 'c-langelem-2nd-pos #[257 "\211\243\243\242\207" [] 2 (#$ . 47774)])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put c-langelem-2nd-pos speed -1 put byte-optimizer byte-compile-inline-expand] 5)
(defalias 'c-keep-region-active #[0 "\301\300!\205	\302\211\207" [zmacs-region-stays boundp t] 2])
(byte-code "\300\301\302\303#\304\301\305\306#\210\304\307\310\311#\210\304\312\310\313#\210\304\314\310\315#\210\304\316\310\317#\210\304\320\310\321#\210\304\322\310\323#\210\304\324\310\325#\207" [function-put c-keep-region-active speed -1 put byte-optimizer byte-compile-inline-expand c-mode c-mode-prefix "c-" c++-mode "c++-" objc-mode "objc-" java-mode "java-" idl-mode "idl-" pike-mode "pike-" awk-mode "awk-"] 5)
#@104 Prefix the current mode prefix (e.g. "c-") to SUFFIX and return
the corresponding symbol.

(fn SUFFIX)
(defalias 'c-mode-symbol #[257 "\204\301\302!\210\303N\211\204\301\304\"\210\305
P!\207" [c-buffer-is-cc-mode error "Not inside a CC Mode based mode" c-mode-prefix "%S has no mode prefix known to `c-mode-symbol'" intern] 5 (#$ . 48833)])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put c-mode-symbol speed -1 put byte-optimizer byte-compile-inline-expand] 5)
#@120 Prefix the current mode prefix (e.g. "c-") to SUFFIX and return
the value of the variable with that name.

(fn SUFFIX)
(defalias 'c-mode-var #[257 "\211\204	\301\302!\210\303N\211\204\301\304\"\210\305
P!\266\202J\207" [c-buffer-is-cc-mode error "Not inside a CC Mode based mode" c-mode-prefix "%S has no mode prefix known to `c-mode-symbol'" intern] 6 (#$ . 49328)])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put c-mode-var speed -1 put byte-optimizer byte-compile-inline-expand] 5)
#@110 Return non-nil if position POS in the current buffer has any of the
faces in the list FACES.

(fn POS FACES)
(defalias 'c-got-face-at #[514 "\300\301\"\211:\203\211\203\211@>\204\211A\262
\202	\207\211>\207" [get-text-property face] 5 (#$ . 49846)])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put c-got-face-at speed -1 put byte-optimizer byte-compile-inline-expand] 5)
#@17 

(fn FACENAME)
(defalias 'c-face-name-p #[257 "\211\300 >\207" [face-list] 3 (#$ . 50251)])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put c-face-name-p speed -1 put byte-optimizer byte-compile-inline-expand] 5)
#@131 Like `concat' on LIST, but separate each element with SEPARATOR.
Notably, null elements in LIST are ignored.

(fn LIST SEPARATOR)
(defalias 'c-concat-separated #[514 "\300\301\302\303\304\303\"\"#\207" [mapconcat identity delete nil append] 9 (#$ . 50490)])
#@997 Make a regexp that matches all the strings the list.
Duplicates and nil elements in the list are removed.  The
resulting regexp may contain zero or more submatch expressions.

If ADORN is t there will be at least one submatch and the first
surrounds the matched alternative, and the regexp will also not match
a prefix of any identifier.  Adorned regexps cannot be appended.  The
language variable `c-nonsymbol-key' is used to make the adornment.

A value `appendable' for ADORN is like above, but all alternatives in
the list that end with a word constituent char will have \> appended
instead, so that the regexp remains appendable.  Note that this
variant doesn't always guarantee that an identifier prefix isn't
matched since the symbol constituent `_' is normally considered a
nonword token by \>.

The optional MODE specifies the language to get `c-nonsymbol-key' from
when it's needed.  The default is the current language taken from
`c-buffer-is-cc-mode'.

(fn ADORN LIST &optional MODE)
(defalias 'c-make-keywords-re #[770 "\301\302\303!\"\262
\203\347\302\304=\203\203\305\302\302\306P\262\262
\2037\307@\"\2030\310\262
\2027
A\262\202\211\262
\204\311!\262
\211\203\\\307\312@\"\203U\211
@P\240\210\211A\262
\202B\313!\262\314\262
\307#\203~\314\224\315\\\262
\316\317\310\211$\262\202d\266\202\210\313!\262
\302\203\255\307\320@\"\203\246\307\321\322Q@\"\204\246@
B\262
A\262\202\211\211\203\311
\323\324\304=\203\277\325\202\300\326\327\330\"\323#Q\262\210\304=\203\325\331
\332Q\207\203\346\331
\333\334\335\302#\336\260\207\207\203\360\331\332Q\207\207" [regexp-unmatchable delete nil delete-dups appendable "" "@" string-match t copy-tree "\\w\\'" regexp-opt 0 2 replace-match "\\>" "\n" "\\`\\(" "\\)\\'" "\\|" mapconcat #[257 "\300\301\"\203
\302
!\303P\207\302
!\207" [string-match "\\w\\'" regexp-quote "\\>"] 4 "\n\n(fn STR)"] regexp-quote sort #[514 "
G
GV\207" [] 4 "\n\n(fn A B)"] "\\(" "\\)" "\\)\\(" c-get-lang-constant c-nonsymbol-key "\\|$\\)"] 12 (#$ . 50758)])
(put 'c-make-keywords-re 'lisp-indent-function 1)
#@273 Make a character alternative string from the list of characters CHARS.
The returned string is of the type that can be used with
`skip-chars-forward' and `skip-chars-backward'.  If INVERTED is
non-nil, a caret is prepended to invert the set.

(fn CHARS &optional INVERTED)
(defalias 'c-make-bare-char-alt #[513 "\211\203\300\202	\301\302\211\303\304\302\"\305\"\262\203q\211A\262\242\262
\306>\2031\307\310#\262\2028\307\311#\262
\262
\203R\211T@Y\203R\211A\262\242\262
\202;

U\204
T
W\203i\307\312#\262\202\211B\262\202\207" ["^" "" nil sort append < (92 94 45) format "%s\\%c" "%s%c" "%s-%c"] 9 (#$ . 52875)])
(byte-code "\300\301\302\"\210\300\303\304\"\207" [defalias c-regexp-opt regexp-opt c-regexp-opt-depth regexp-opt-depth] 3)
#@1461 A list of certain features in the (X)Emacs you are using.
There are many flavors of Emacs out there, each with different
features supporting those needed by CC Mode.  The following values
might be present:

`8-bit'             8 bit syntax entry flags (XEmacs style).
`1-bit'             1 bit syntax entry flags (Emacs style).
`argumentative-bod-function'    beginning-of-defun and end-of-defun pass
		    ARG through to beginning/end-of-defun-function.
`syntax-properties' It works to override the syntax for specific characters
		    in the buffer with the `syntax-table' property.  It's
		    always set - CC Mode no longer works in emacsen without
		    this feature.
`category-properties' Syntax routines can add a level of indirection to text
		    properties using the `category' property.
`gen-comment-delim' Generic comment delimiters work
		    (i.e. the syntax class `!').
`gen-string-delim'  Generic string delimiters work
		    (i.e. the syntax class `|').
`pps-extended-state' `parse-partial-sexp' returns a list with at least 11
		    elements, i.e. it indicates having stopped after the
		    first character of a potential two-char construct.
`posix-char-classes' The regexp engine understands POSIX character classes.
`col-0-paren'       It's possible to turn off the ad-hoc rule that a paren
		    in column zero is the start of a defun.
`infodock'           This is Infodock (based on XEmacs).

`8-bit' and `1-bit' are mutually exclusive.
(defconst c-emacs-features (byte-code "\306\307\310!\203\311C\262
\312 \306\313\314\315#\210\316!\203+
\314H\262
\211:\203>\211@\262
\202>\317\320!\203:\320\314\"\262
\202>\321\322!\210\323\324\325\"\326\"\326U\203N\327\202O\330B\266\203\306\331C\331C\332\333\"\332\334\"\212\335\336!\205\207
\242\336=\205\207\335 ?\205\207\337\336!\205\207\211\242\336=\205\207\337 ?)\203\220\340B\262+\266\203\234\341
B\262
\342\343!\306\211\211@r\211q\210\344\345 !\210\346\211@\346\313\347\350\"\210\313\351\350\"\210\352c\210eA
^A\353
\211T\354B$\266\336e\\A
^A\353
\211T\354C$\266eb\210\355`\356\"b\210`\357e\\U\203
\360B\262\202
\321\361!\210\3621
\313\363\364\"\210\365\366\367\"\205
\370B\211\2620\210\202 
\210\3711;
\313\363\372\"\210\365\373\367\"\2056
\374B\211\2620\210\202<
\210\365\375\376\"\203e
ed|\210\377c\210\201E\306x\210o\203e
\201F\306w\336U\203e
\201GB\262\307\201D!\203\326
\306\346Ded|\210\344\345 !\210\313\201H\201I\"\210\327>\203\237
\313\201J\201K\"\210\313\201L\201M\"\210\202\267
\330>\203\267
\313\201J\201N\"\210\313\201L\201M\"\210\313\201O\201P\"\210\201Qc\210\201R \210o\203\325
\201SB\262*\201T\306!\210)\201U
!\210+\210\201V1\370
\212\201W``\")G0\202\374
\210\202\377
\206\201X\211\201YY\203\201ZB\207\211\201OY\204\321\201[!\210\210\207" [mark-ring beginning-of-defun-function end-of-defun-function c-use-category lookup-syntax-properties parse-sexp-ignore-comments nil boundp infodock-version infodock copy-syntax-table modify-syntax-entry 97 ". 12345678" arrayp fboundp get-char-table error "CC Mode is incompatible with this version of Emacs" logand ash -16 255 8-bit 1-bit foo make-closure #[256 "\300\242\301=\204\300\302\240\210\300\242\301=\205\300
\240\205\211\303=\207" [V0 foo bar 3] 3 "\n\n(fn &optional ARG)"] #[256 "\300\242\301=\205\300
\240\205\211\302=\207" [V0 foo 3] 3 "\n\n(fn &optional ARG)"] beginning-of-defun 3 end-of-defun argumentative-bod-function category-properties generate-new-buffer " test" set-syntax-table make-syntax-table t 60 "." 62 "<()>" put-text-property syntax-table scan-sexps 1 4 syntax-properties "CC Mode is incompatible with this version of Emacs - support for the `syntax-table' text property is required." (error) 120 "!" string-match "\\s!" "x" gen-comment-delim (error) "|" "\\s|" gen-string-delim "[[:alpha:]]" "a" "foo123" parse-sexp-lookup-properties c-syntax-table-hwm c-<-as-paren-syntax c->-as-paren-syntax open-paren-in-column-0-is-defun-start "[:alnum:]" "[:alpha:]" posix-char-classes 39 "\"" 47 ". 1456" 42 ". 23" ". 124b" 10 "> b" "/* '\n   () */" backward-sexp col-0-paren set-buffer-modified-p kill-buffer (error) parse-partial-sexp 0 11 pps-extended-state "CC Mode is incompatible with this version of Emacs - `parse-partial-sexp' has to return at least 10 elements."] 9) (#$ . 53658))
(byte-code "\301>\203\302\303!\210\304\305!\210\306\307!\210\310\311!\210\312\313!\210\2021\314\315!\210\316\317!\210\320\321!\210\322\323!\210\324\325!\210\301\207" [c-emacs-features posix-char-classes (lambda (#1=#:def-tmp-var) (defconst c-alpha #1#)) "[:alpha:]" (lambda (#1#) (defconst c-alnum #1#)) "[:alnum:]" (lambda (#1#) (defconst c-digit #1#)) "[:digit:]" (lambda (#1#) (defconst c-upper #1#)) "[:upper:]" (lambda (#1#) (defconst c-lower #1#)) "[:lower:]" (lambda (#1#) (defconst c-alpha #1#)) "a-zA-Z" (lambda (#1#) (defconst c-alnum #1#)) "a-zA-Z0-9" (lambda (#1#) (defconst c-digit #1#)) "0-9" (lambda (#1#) (defconst c-upper #1#)) "A-Z" (lambda (#1#) (defconst c-lower #1#)) "a-z"] 2)
#@625 Declare a new language in the language dependent variable system.
This is intended to be used by modes that inherit CC Mode to add new
languages.  It should be used at the top level before any calls to
`c-lang-defconst'.  MODE is the mode name symbol for the new language,
and BASE-MODE is the mode name symbol for the language in CC Mode that
is to be the template for the new mode.

The exact effect of BASE-MODE is to make all language constants that
haven't got a setting in the new language fall back to their values in
BASE-MODE.  It does not have any effect outside the language constant
system.

(fn MODE BASE-MODE)
(defalias 'c-add-language #[514 "\300\301\302!\"\204\303\304\"\210\305\306\307\310\302!\"#\210\211\306N\204%\303\311\"\210\305\312#\207" [string-match "\\`\\(.*-\\)mode\\'" symbol-name error "The mode name symbol `%s' must end with \"-mode\"" put c-mode-prefix match-string 1 "Unknown base mode `%s'" c-fallback-mode] 9 (#$ . 58709)])
(defvar c-lang-constants (make-vector 151 0))
(defvar c-lang-const-expansion nil)
(defalias 'cc-bytecomp-compiling-or-loading #[0 "\203M\302\301!\203M	;\203M\303\304\305!\211\262\203.\211@\203'\211A@\306>\204.
T\262\202\211A@\307>\203:\266\310\207\211A@\311>\203F\266\312\207\313\314!\266\304\207\203S\310\207\302\301!\203`	;\203`\312\207\304\207" [load-in-progress byte-compile-dest-file boundp 0 nil backtrace-frame (load require byte-compile-file byte-recompile-directory batch-byte-compile batch-native-compile) (load require) loading (byte-compile-file byte-recompile-directory batch-byte-compile batch-native-compile) compiling message "cc-bytecomp-compiling-or-loading: System flags spuriously set"] 4])
(defalias 'c-get-current-file #[0 "\302 \211\303\267\202\202	\202\304 \202\305\211\205\306\307!!\207" [load-file-name byte-compile-dest-file cc-bytecomp-compiling-or-loading #s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (loading 8 compiling 12 nil 16)) buffer-file-name nil file-name-sans-extension file-name-nondirectory] 5])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put c-get-current-file speed -1 put byte-optimizer byte-compile-inline-expand] 5)
#@161 Can be used inside a VAL in `c-lang-defconst' to evaluate FORM
immediately, i.e. at the same time as the `c-lang-defconst' form
itself is evaluated.

(fn FORM)
(defalias 'c-lang-defconst-eval-immediately '(macro . #[257 "\300
!\207" [eval] 3 (#$ . 60940)]))
(put 'c-lang-defconst-eval-immediately 'edebug-form-spec t)
#@1926 Set the language specific values of the language constant NAME.
The second argument can optionally be a docstring.  The rest of the
arguments are one or more repetitions of LANG VAL where LANG specifies
the language(s) that VAL applies to.  LANG is the name of the
language, i.e. the mode name without the "-mode" suffix, or a list
of such language names, or t for all languages.  VAL is a form to
evaluate to get the value.

If LANG isn't t or one of the core languages in CC Mode, it must
have been declared with `c-add-language'.

Neither NAME, LANG nor VAL are evaluated directly - they should not be
quoted.  `c-lang-defconst-eval-immediately' can however be used inside
VAL to evaluate parts of it directly.

When VAL is evaluated for some language, that language is temporarily
made current so that `c-lang-const' without an explicit language can
be used inside VAL to refer to the value of a language constant in the
same language.  That is particularly useful if LANG is t.

VAL is not evaluated right away but rather when the value is requested
with `c-lang-const'.  Thus it's possible to use `c-lang-const' inside
VAL to refer to language constants that haven't been defined yet.
However, if the definition of a language constant is in another file
then that file must be loaded (at compile time) before it's safe to
reference the constant.

The assignments in ARGS are processed in sequence like `setq', so
(c-lang-const NAME) may be used inside a VAL to refer to the last
assigned value to this language constant, or a value that it has
gotten in another earlier loaded file.

To work well with repeated loads and interactive reevaluation, only
one `c-lang-defconst' for each NAME is permitted per file.  If there
already is one it will be completely replaced; the value in the
earlier definition will not affect `c-lang-const' on the same
constant.  A file is identified by its base name.

(fn NAME &rest ARGS)
(defalias 'c-lang-defconst '(macro . #[385 "\211C\303\304!\"\305\306\303\307 \206\310\311!!\312\2119\204$\310\313\"\210\242\242;\203:\314\315\242@#\210\211\242A\240\210\242\204E\310\316\"\210\242\203\303\242@\306=\203V\306\202\207\242@9\203k\303\304\242@!\317P!C\202\207\242@<\203\200\320\321\322\"\242@\"\202\207\310\323\242@\"\312\242A\204\227\310\324\242@\"\210\211\242A\240\210\242@\262
\325
\312\"\262
\326\211\327D\330\312EEE\262\211\242A\240\266\202E\320\331\332N\"\262

>\203\327
>A\262
\211\237\262
\333\334\327	D\205\352\327DC*BBBD\207" [c-lang-constants c-lang-const-expansion c-langs-are-parametric intern symbol-name call t #[0 "\302 \211\303\267\202\202	\202\304 \202\305\211\205\306\307!!\207" [load-file-name byte-compile-dest-file cc-bytecomp-compiling-or-loading #s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (loading 8 compiling 12 nil 16)) buffer-file-name nil file-name-sans-extension file-name-nondirectory] 5] error "`c-lang-defconst' can only be used in a file" nil "Not a symbol: %S" put variable-documentation "No assignments in `c-lang-defconst' for %S" "-mode" mapcar make-closure #[257 "\2119\204\f\301\302\300\242@\"\210\303\304!\305P!\207" [V0 error "Not a list of symbols: %S" intern symbol-name "-mode"] 4 "\n\n(fn LANG)"] "Not a symbol or a list of symbols: %S" "No value for %S" macroexpand-all cons quote lambda car source eval-and-compile c-define-lang-constant] 15 (#$ . 61266)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put c-lang-defconst lisp-indent-function 1 put edebug-form-spec (&define name [&optional stringp] [&rest sexp def-form])] 5)
#@42 

(fn NAME BINDINGS &optional PRE-FILES)
(defalias 'c-define-lang-constant #[770 "\301\302!\"\211\303N\301\304 \206\305\306!!\211\236\211\204@\2033@\236\204,@CB\262A\262\202\307\303C\211\262B#\210\211\241\210\310L\210\311N\312\313\314\"\310\203\217@\262A\262\301\302!\"\210\310L\210\311N\262
\211\203Q\211@\262\211A\262
\315\302!\"\204pB\262\202p\266\207" [c-lang-constants intern symbol-name source #[0 "\302 \211\303\267\202\202	\202\304 \202\305\211\205\306\307!!\207" [load-file-name byte-compile-dest-file cc-bytecomp-compiling-or-loading #s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (loading 8 compiling 12 nil 16)) buffer-file-name nil file-name-sans-extension file-name-nondirectory] 5] error "`c-lang-defconst' must be used in a file" put nil dependents make-vector 101 0 intern-soft] 13 (#$ . 64922)])
#@356 Get the mode specific value of the language constant NAME in language LANG.
LANG is the name of the language, i.e. the mode name without the
"-mode" suffix.  If used inside `c-lang-defconst' or
`c-lang-defvar', LANG may be left out to refer to the current
language.  NAME and LANG are not evaluated so they should not be
quoted.

(fn NAME &optional LANG)
(defalias 'c-lang-const '(macro . #[513 "
9\204\n\303\304\"\210\2119\204\303\304\"\210\305\306!\"
\205%\305\306!\307P!\211\310N\2044\211\2034\303\311\"\210	\312=\203B\313\314\315#D\207\316 C\211\242\203Q\211\305\242!\240\210\317\320\321\"\322N\"\237\262

\205e\313DC
\204m\211\203x
\205t\313D
B\262
	\323=\204\215	\204\206\203\215\324 \325=\204\226\314\313DBB\207\326\327\302\313\nDE\330\314\313\nDBBD\314\313\nDBBF\207" [c-lang-constants c-lang-const-expansion c-version-sym error "Not a symbol: %S" intern symbol-name "-mode" c-mode-prefix "Unknown language %S: no `c-mode-prefix' property" immediate quote c-get-lang-constant nil #[0 "\302 \211\303\267\202\202	\202\304 \202\305\211\205\306\307!!\207" [load-file-name byte-compile-dest-file cc-bytecomp-compiling-or-loading #s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (loading 8 compiling 12 nil 16)) buffer-file-name nil file-name-sans-extension file-name-nondirectory] 5] mapcan make-closure #[257 "\300\242
@=?\205\f\211@C\207" [V0] 3 "\n\n(fn ELEM)"] source call cc-bytecomp-compiling-or-loading compiling if eq cc-eval-when-compile] 12 (#$ . 65847)]))
(put 'c-lang-const 'edebug-form-spec '(name &optional symbolp))
#@320 Alist of constants in the process of being evaluated.
The `cdr' of each entry indicates how far we've looked in the list
of definitions, so that the def for var FOO in `c-mode' can be defined in
terms of the def for that same var FOO (which will then rely on the
fallback definition for all modes, to break the cycle).
(defvar c-lang-constants-under-evaluation nil (#$ . 67474))
(defconst c-lang--novalue "novalue")
#@41 

(fn NAME &optional SOURCE-FILES MODE)
(defalias 'c-get-lang-constant #[769 "\211\204\211\262\204\306\307!\210\310\311!	\"\211\312N\313\n\205 \n@@\211\2037\211\314N>\2047\315\314\314NB#\210\203\\@\236\204U\315\312@CB\211\262#\210\313L\210A\262\2027\316!\203oJ\236\211\262\203o
A\207\n\236\206}\317\313\"B\211\nB\320N\313\321]\f\322]
\203\271\323A!\324A\n\313$\211\262
=\205\264\324\241\325$\211\262
=\262
\202\307\324A	\325
$\211\262
=\203\322\306\326\n#\210\3271\340\211 \211\2620\210\202\365\330\331	#\210\332!\210\333
@A\"\266BJBL\210,\207" [c-buffer-is-cc-mode c-lang-constants c-lang-constants-under-evaluation max-specpdl-size max-lisp-eval-depth c-lang--novalue error "No current language" intern symbol-name source nil dependents put boundp vector c-fallback-mode 3000 1000 copy-sequence c-find-assignment-for-mode t "`%s' got no (prior) value in %S (might be a cyclic reference)" (error) message "Eval error in the `c-lang-defconst' for `%S' in %s:" makunbound signal] 16 (#$ . 67896)])
#@44 

(fn SOURCE-POS MODE MATCH-ANY-LANG NAME)
(defalias 'c-find-assignment-for-mode #[1028 "\3022x\303\234\304\234\305
\204L\203t\304@A\211\262I\204B\306@@!\305\307
\305\310#\210)\210@A\211\262\204B@\305CC\211\262\241\210\303A\211\262I\210
@\262
\304A\211\262I\210\211@<\203g
@>\202h\203\311\302A\"\210\202	\266\2030\207" [c-lang-constants-under-evaluation c-lang--novalue found 0 1 nil symbol-name load t throw] 12 (#$ . 68986)])
#@13 

(fn MODE)
(defalias 'c-lang-major-mode-is #[257 "\211<\204	\211C\262
\301\211>\203\302\262\202 \211\303N\211\262\204
\207" [c-buffer-is-cc-mode nil t c-fallback-mode] 5 (#$ . 69455)])
(provide 'cc-defs)