WWWWWW

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

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

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

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


(byte-code "\300\301!\210\302\303!\304U\203\305\306!\204%\307\310!\203\311\312!\204%\313\312\314\315\314$\210\314\207" [require regexp-opt regexp-opt-depth "\\(\\(\\)\\)" 2 fboundp push featurep cc-bytecomp cc-bytecomp-load "cc-fix" load nil t] 5)
#@25 CC Mode version number.
(defconst c-version "5.32.4" (#$ . 814))
(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 (#$ . 930))
(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-inside-eval-when-compile nil)
#@238 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.
(defalias 'cc-eval-when-compile '(macro . #[(&rest body) "\203\302	B\207\303\304\305\306\307	BBDDD\207" [c-inside-eval-when-compile body progn eval-when-compile eval quote let ((c-inside-eval-when-compile t))] 6 (#$ . 1542)]))
(put 'cc-eval-when-compile 'lisp-indent-hook 0)
#@757 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
`eol'   -- end of line
`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.
(defalias 'c-point '(macro . #[(position &optional point) "\242\302=\203\203\303!\211\304=\203/\305\306!\203	\204\307\202\201\310\311	\205)\312	DC\313\"B\202\201\314=\203S\305\315!\203C	\204C\316\202\201\310\311	\205M\312	DC\317\"B\202\201\320=\203i\310\311	\205c\312	DC\321\"B\202\201\322=\203\310\311	\205y\312	DC\323\"B\202\201\324=\203\225\310\311	\205\217\312	DC\325\"B\202\201\326=\203\271\305\306!\203\251	\204\251\327\202\201\310\311	\205\263\312	DC\330\"B\202\201\331=\203\335\305\306!\203\315	\204\315\332\202\201\310\311	\205\327\312	DC\333\"B\202\201\334=\203\305\315!\203\361	\204\361\335\202\201\310\311	\205\373\312	DC\336\"B\202\201\337=\203%\305\315!\203	\204\340\202\201\310\311	\205\312	DC\341\"B\202\201\342=\203;\310\311	\2055\312	DC\343\"B\202\201\344=\203Q\310\311	\205K\312	DC\345\"B\202\201\346=\203g\310\311	\205a\312	DC\347\"B\202\201\350=\203}\310\311	\205w\312	DC\351\"B\202\201\352\353\")\207\354\355!\210\310\311	\205\221\312	DC\356\300DC\357BB\360B\"B\207" [position point quote eval bol fboundp line-beginning-position (line-beginning-position) save-excursion append goto-char ((beginning-of-line) (point)) eol line-end-position (line-end-position) ((end-of-line) (point)) boi ((back-to-indentation) (point)) bod ((c-beginning-of-defun-1) (point)) eod ((c-end-of-defun-1) (point)) bopl (line-beginning-position 0) ((forward-line -1) (point)) bonl (line-beginning-position 2) ((forward-line 1) (point)) eopl (line-end-position 0) ((beginning-of-line) (or (bobp) (backward-char)) (point)) eonl (line-end-position 2) ((forward-line 1) (end-of-line) (point)) iopl ((forward-line -1) (back-to-indentation) (point)) ionl ((forward-line 1) (back-to-indentation) (point)) bosws ((c-backward-syntactic-ws) (point)) eosws ((c-forward-syntactic-ws) (point)) error "Unknown buffer position requested: %s" message "Warning: c-point long expansion" let ((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))] 7 (#$ . 2064)]))
(defalias 'c-region-is-active-p '(macro . #[nil "\300\301!\203\301\207\302\207" [boundp mark-active (region-active-p)] 2]))
(defalias 'c-set-region-active '(macro . #[(activate) "\301\302!\203\f\303\304BB\207\305\306E\207" [activate fboundp zmacs-activate-region if ((zmacs-activate-region) (zmacs-deactivate-region)) setq mark-active] 3]))
#@54 Delete the text between START and END and return it.
(defalias 'c-delete-and-extract-region '(macro . #[(start end) "\302\303!\203\303	E\207\304\305	E\306	EE\207" [start end fboundp delete-and-extract-region prog1 buffer-substring delete-region] 5 (#$ . 5884)]))
(defalias 'c-safe '(macro . #[(&rest body) "\301\302\303B\304BBB\207" [body condition-case nil progn ((error nil))] 4]))
(put 'c-safe 'lisp-indent-function 0)
(defalias 'c-int-to-char '(macro . #[(integer) "\301\302!\203\n\302D\207\207" [integer fboundp int-to-char] 2]))
(defalias 'c-sentence-end '(macro . #[nil "\300\301!\203\302\207\301\207" [fboundp sentence-end (sentence-end)] 2]))
(defalias 'c-default-value-sentence-end '(macro . #[nil "\300\301!\203\302\207\303\207" [fboundp sentence-end (let (sentence-end) (sentence-end)) (default-value 'sentence-end)] 2]))
#@1186 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.
(defalias 'c-save-buffer-state '(macro . #[(varlist &rest body) "\302\303\304\305\306\307\310\311\312\313BBBBBBBBB\314\315	B\316BBE\207" [varlist body 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)))] 11 (#$ . 6739)]))
(put 'c-save-buffer-state 'lisp-indent-function 1)
#@689 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.
(defalias 'c-tentative-buffer-changes '(macro . #[(&rest body) "\301\302\303\304\305\306\307\310\311\312B\257\313BBE\207" [body let (-tnt-chng-keep -tnt-chng-state) unwind-protect setq buffer-undo-list (cons nil buffer-undo-list) -tnt-chng-state (c-tnt-chng-record-state) -tnt-chng-keep progn ((c-tnt-chng-cleanup -tnt-chng-keep -tnt-chng-state))] 11 (#$ . 8456)]))
(put 'c-tentative-buffer-changes 'lisp-indent-function 0)
(defalias 'c-tnt-chng-record-state #[nil "\302p`\303\304!	\305 &\207" [buffer-undo-list mark-active vector mark t buffer-modified-p] 7])
(defalias 'c-tnt-chng-cleanup #[(keep saved-state) "\306\234\n	=\203	A\211\202j\203-\n\211A	=\204%\fA\211\202\f	A\241)\202j	A\307\310\311\n\"\211	=\2032)\312\311\234!\205j\311\234q\210\313\234b\210\314\315\234!\210\316\234\317\234?\205j\320 \205j\321\322!)\207" [saved-state saved-undo-list buffer-undo-list keep p undo-in-progress 0 t primitive-undo 1 buffer-live-p 2 set-mark 3 4 5 buffer-modified-p set-buffer-modified-p nil mark-active] 4])
#@559 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.

Note that this function might do hidden buffer changes.  See the
comment at the start of cc-engine.el for more info.
(defalias 'c-forward-syntactic-ws '(macro . #[(&optional limit) "\203\301\302\303\304\305BBE\306BB\207\307\207" [limit save-restriction narrow-to-region (point-min) or ((point-max)) ((c-forward-sws)) (c-forward-sws)] 6 (#$ . 10190)]))
#@573 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.

Note that this function might do hidden buffer changes.  See the
comment at the start of cc-engine.el for more info.
(defalias 'c-backward-syntactic-ws '(macro . #[(&optional limit) "\203\301\302\303\304BB\305BB\306BB\207\307\207" [limit save-restriction narrow-to-region or ((point-min)) ((point-max)) ((c-backward-sws)) (c-backward-sws)] 5 (#$ . 10994)]))
#@364 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.
(defalias 'c-forward-sexp '(macro . #[(&optional count) "\204\301\302\303\304ED\207" [count 1 goto-char scan-sexps (point)] 4 (#$ . 11818)]))
#@46 See `c-forward-sexp' and reverse directions.
(defalias 'c-backward-sexp '(macro . #[(&optional count) "\204\301\302\247\203[\202\303DD\207" [count 1 c-forward-sexp -] 3 (#$ . 12334)]))
#@172 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.
(defalias 'c-safe-scan-lists '(macro . #[(from count depth &optional limit) "\305\306	\nFD\f\203<\307	\247\203'	\310W\203 \311\f\312BB\2027\311\313\fE\2027\314\315	\316BB\311\f\317BB\311\320\fEFE\202=)\207" [from count depth res limit c-safe scan-lists save-restriction 0 narrow-to-region ((point-max)) (point-min) if < (0) ((point-max)) (point-min)] 7 (#$ . 12537)]))
#@148 Move backward across one balanced group of parentheses.

Return POINT when we succeed, NIL when we fail.  In the latter case, leave
point unmoved.
(defalias 'c-go-list-forward '(macro . #[nil "\300\207" [(c-safe (let ((endpos (scan-lists (point) 1 0))) (goto-char endpos) endpos))] 1 (#$ . 13094)]))
#@148 Move backward across one balanced group of parentheses.

Return POINT when we succeed, NIL when we fail.  In the latter case, leave
point unmoved.
(defalias 'c-go-list-backward '(macro . #[nil "\300\207" [(c-safe (let ((endpos (scan-lists (point) -1 0))) (goto-char endpos) endpos))] 1 (#$ . 13401)]))
#@223 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.
(defalias 'c-up-list-forward '(macro . #[(&optional pos limit) "\302\206\303\304\211	\257\207" [pos limit c-safe-scan-lists (point) 1] 5 (#$ . 13710)]))
#@226 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.
(defalias 'c-up-list-backward '(macro . #[(&optional pos limit) "\302\206\303\304\305	\257\207" [pos limit c-safe-scan-lists (point) -1 1] 5 (#$ . 14096)]))
#@225 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.
(defalias 'c-down-list-forward '(macro . #[(&optional pos limit) "\302\206\303\304\305	\257\207" [pos limit c-safe-scan-lists (point) 1 -1] 5 (#$ . 14489)]))
#@223 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.
(defalias 'c-down-list-backward '(macro . #[(&optional pos limit) "\302\206\303\304\211	\257\207" [pos limit c-safe-scan-lists (point) -1] 5 (#$ . 14882)]))
#@294 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.
(defalias 'c-go-up-list-forward '(macro . #[(&optional pos limit) "\303\304\305\206\306\307BBD\310BB\n\203\311\312\313\nE	E\202	)\207" [pos res limit c-safe goto-char scan-lists (point) (1 1) (t) save-restriction narrow-to-region (point-min)] 5 (#$ . 15272)]))
#@297 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.
(defalias 'c-go-up-list-backward '(macro . #[(&optional pos limit) "\303\304\305\206\306\307BBD\310BB\n\203\311\312\n\313BB	E\202 	)\207" [pos res limit c-safe goto-char scan-lists (point) (-1 1) (t) save-restriction narrow-to-region ((point-max))] 5 (#$ . 15841)]))
#@292 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.
(defalias 'c-go-down-list-forward '(macro . #[(&optional pos limit) "\303\304\305\206\306\307BBD\310BB\n\203\311\312\313\nE	E\202	)\207" [pos res limit c-safe goto-char scan-lists (point) (1 -1) (t) save-restriction narrow-to-region (point-min)] 5 (#$ . 16418)]))
#@290 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.
(defalias 'c-go-down-list-backward '(macro . #[(&optional pos limit) "\303\304\305\206\306\307BBD\310BB\n\203\311\312\n\313BB	E\202 	)\207" [pos res limit c-safe goto-char scan-lists (point) (-1 -1) (t) save-restriction narrow-to-region ((point-max))] 5 (#$ . 16988)]))
(defalias 'c-beginning-of-defun-1 '(macro . #[nil "\300\301\302\303\304BB\303\305BBB\306BB\207" [progn if and nil (c-enable-xemacs-performance-kludge-p) ((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]))
(defalias 'c-at-vsemi-p '(macro . #[(&optional pos) "\301\302\303\302\205\nCBBE\207" [pos if c-at-vsemi-p-fn funcall] 5]))
(defalias 'c-vsemi-status-unknown-p '(macro . #[nil "\300\207" [(if c-vsemi-status-unknown-p-fn (funcall c-vsemi-status-unknown-p-fn))] 1]))
(defalias 'c-benign-error '(macro . #[(format &rest args) "\302\303	BB\304BB\207" [format args progn message ((ding))] 4]))
(defalias 'c-with-syntax-table '(macro . #[(table &rest code) "\302\303\304\305\306D	BB\307BBE\207" [table code let ((c-with-syntax-table-orig-table (syntax-table))) unwind-protect progn set-syntax-table ((set-syntax-table c-with-syntax-table-orig-table))] 6]))
(put 'c-with-syntax-table 'lisp-indent-function 1)
#@127 Skip over any whitespace following point.
This function skips over horizontal and vertical whitespace and line
continuations.
(defalias 'c-skip-ws-forward '(macro . #[(&optional limit) "\203\301\300\302\303BBDC\304BB\207\305\207" [limit let 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)))))] 5 (#$ . 18594)]))
#@127 Skip over any whitespace preceding point.
This function skips over horizontal and vertical whitespace and line
continuations.
(defalias 'c-skip-ws-backward '(macro . #[(&optional limit) "\203\301\300\302\303BBDC\304BB\207\305\207" [limit let 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))] 5 (#$ . 19176)]))
(defvar c-langs-are-parametric nil)
#@115 Return non-nil if the current CC Mode major mode is MODE.
MODE is either a mode symbol or a list of mode symbols.
(defalias 'c-major-mode-is '(macro . #[(mode) "\203\302	D\207	\242\303=\203)\304	!\211<\203!\305\306\303	DE\202'\307\306\303	DE)\207\310\301	DC\311BB\207" [c-langs-are-parametric mode c-lang-major-mode-is quote eval memq c-buffer-is-cc-mode eq let ((if (listp mode) (memq c-buffer-is-cc-mode mode) (eq c-buffer-is-cc-mode mode)))] 5 (#$ . 19727)]))
(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))
(defalias 'c-put-char-property-fun 'ignore)
(defalias 'c-put-char-property '(macro . #[(pos property value) "\304!	\204\305\306!\204\307\n\310DF\207\311\312\nDC\313\312\314\310D\257E\207" [property c-use-extents pos value eval boundp text-property-default-nonsticky c-put-char-property-fun quote let -pos- put-text-property (1+ -pos-)] 7]))
(defalias 'c-get-char-property '(macro . #[(pos property) "\303!	\203\304\305\306\n\307\310DFDC\311\305\312\305\310DEEE\207\313\n\310DE\207" [property c-use-extents pos eval let ext extent-at nil quote if extent-property get-text-property] 8]))
(defalias 'c-clear-char-property-fun nil)
(defalias 'c-clear-char-property '(macro . #[(pos property) "\303!	\203\304\305\306\n\307\310DFDC\311BB\207\312\313!\203-\304\302\nDC\314\302\315\310\316BDFE\207\317\n\310DE\207" [property c-use-extents pos eval let ext extent-at nil quote ((if ext (delete-extent ext))) boundp text-property-default-nonsticky remove-text-properties (1+ pos) (nil) c-clear-char-property-fun] 8]))
(defalias 'c-clear-char-properties '(macro . #[(from to property) "\304!	\203\305\306\307\n\307\211\310D\257\207\311\n\310\312BDF\207" [property c-use-extents from to eval map-extents (lambda (ext ignored) (delete-extent ext)) nil quote remove-text-properties (nil)] 9]))
#@292 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.
(defalias 'c-search-forward-char-property '(macro . #[(property value &optional limit) "\303\304\305\306\307\310\206\311E\312\313\314\310	E\nEDE\315\310\316\310	\317\206!\320\257EE\321\307\310\206-\322E\323BBF\207" [limit property value let ((place (point))) while and < place (point-max) not equal get-text-property setq next-single-property-change nil (point-max) when (point-max) ((goto-char place) (search-forward-regexp ".") (point))] 11 (#$ . 21780)]))
#@290 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.
(defalias 'c-search-backward-char-property '(macro . #[(property value &optional limit) "\303\304\305\306\307\310\206\311E\312\313\314\315	E\nEDE\316\310\317\310	\320\206!\321\257EE\322\307\310\206-\323E\324BBF\207" [limit property value let ((place (point))) while and > place (point-min) not equal get-text-property (1- place) setq previous-single-property-change nil (point-min) when (point-max) ((goto-char place) (search-backward-regexp ".") (point))] 11 (#$ . 22545)]))
#@250 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.
(defalias 'c-clear-char-property-with-value-function #[(from to property value) "\306\211W\203\307\n\f\"
\232\204\310\n\f\306$\211\202\nW\2059\310\n\f\306$\311\n	\f\306B#\210	\211\202*\207" [from end-place place to property value nil get-text-property next-single-property-change remove-text-properties] 6 (#$ . 23325)])
#@250 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.
(defalias 'c-clear-char-property-with-value '(macro . #[(from to property value) "\203\305\306	DC\307\310\311\n\f\312BBBBBBE\207\313\n	\f\257\207" [c-use-extents property from to value 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] 9 (#$ . 23921)]))
(defalias 'c-put-overlay '(macro . #[(from to property value) "\304\305!\203\306\307\305	EDC\310\307\nF\311BBB\207\306\312\313	EDC\314\312\nF\315BBB\207" [from to property value fboundp make-overlay let ol overlay-put (ol) ext make-extent set-extent-property (ext)] 6]))
(defalias 'c-delete-overlay '(macro . #[(overlay) "\301\302!\203\n\303D\207\304D\207" [overlay fboundp make-overlay delete-overlay delete-extent] 2]))
(byte-code "\300\301\302\303#\210\300\304\302\303#\210\300\305\302\303#\210\300\306\302\303#\210\300\307\302\310#\210\300\311\302\303#\210\300\312\302\303#\210\300\313\302\303#\210\300\314\302\303#\210\300\315\302\303#\210\300\316\302\303#\210\300\317\302\303#\210\300\320\302\303#\210\300\321\302\303#\210\300\322\302\303#\210\300\323\302\303#\210\300\324\302\303#\210\300\325\302\303#\210\300\326\302\303#\210\300\327\302\303#\210\300\330\302\303#\210\300\331\302\303#\210\300\332\302\303#\210\300\333\302\303#\210\300\334\302\303#\210\300\335\302\303#\210\300\336\302\303#\207" [put cc-eval-when-compile edebug-form-spec t c-point c-set-region-active c-safe c-save-buffer-state let* c-tentative-buffer-changes c-forward-syntactic-ws c-backward-syntactic-ws c-forward-sexp c-backward-sexp c-up-list-forward c-up-list-backward c-down-list-forward c-down-list-backward c-add-syntax c-add-class-syntax c-benign-error c-with-syntax-table c-skip-ws-forward c-skip-ws-backward c-major-mode-is c-put-char-property c-get-char-property c-clear-char-property c-clear-char-properties c-put-overlay c-delete-overlay] 4)
(defalias 'c-end-of-defun-1 #[nil "`\304\305w\210\305\211\306 \210*\203\307!\203\310\225b\210\305f\311=\203)\312`\313\"b\210`W\2051db)\207" [start end-of-defun-function beginning-of-defun-function defun-prompt-regexp "^}" nil beginning-of-defun looking-at 0 123 scan-sexps 1] 3])
(put 'c-end-of-defun-1 'byte-optimizer 'byte-compile-inline-expand)
(defconst c-<-as-paren-syntax '(4 . 62))
(put 'c-<-as-paren-syntax 'syntax-table c-<-as-paren-syntax)
(defalias 'c-mark-<-as-paren #[(pos) "\302	\211T\303\304$)\207" [pos -pos- put-text-property category c-<-as-paren-syntax] 5])
(put 'c-mark-<-as-paren 'byte-optimizer 'byte-compile-inline-expand)
(defconst c->-as-paren-syntax '(5 . 60))
(put 'c->-as-paren-syntax 'syntax-table c->-as-paren-syntax)
(defalias 'c-mark->-as-paren #[(pos) "\302	\211T\303\304$)\207" [pos -pos- put-text-property category c->-as-paren-syntax] 5])
(put 'c-mark->-as-paren 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'c-unmark-<->-as-paren #[(pos) "\301\211T\302#)\207" [pos remove-text-properties (category nil)] 4])
(put 'c-unmark-<->-as-paren 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'c-suppress-<->-as-parens #[nil "\300\301\302\303#\210\300\304\302\303#\207" [put c-<-as-paren-syntax syntax-table nil c->-as-paren-syntax] 4])
(put 'c-suppress-<->-as-parens 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'c-restore-<->-as-parens #[nil "\302\300\303#\210\302\301\303	#\207" [c-<-as-paren-syntax c->-as-paren-syntax put syntax-table] 4])
(put 'c-restore-<->-as-parens 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'c-with-<->-as-parens-suppressed '(macro . #[(&rest forms) "\301\302\303BB\304BB\207" [forms unwind-protect progn (c-suppress-<->-as-parens) ((c-restore-<->-as-parens))] 4]))
(defconst c-cpp-delimiter '(14))
(defalias 'c-set-cpp-delimiters '(macro . #[(beg end) "\302\303\304BB\305\306	\307BB\303	\310BBEE\207" [beg end progn c-put-char-property ('category 'c-cpp-delimiter) if < ((point-max)) ('category 'c-cpp-delimiter)] 7]))
(defalias 'c-clear-cpp-delimiters '(macro . #[(beg end) "\302\303\304BB\305\306	\307BB\303	\310BBEE\207" [beg end progn c-clear-char-property ('category) if < ((point-max)) ('category)] 7]))
(defalias 'c-comment-out-cpps #[nil "\301\300\302#\207" [c-cpp-delimiter put syntax-table] 4])
(put 'c-comment-out-cpps 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'c-uncomment-out-cpps #[nil "\300\301\302\303#\207" [put c-cpp-delimiter syntax-table nil] 4])
(put 'c-uncomment-out-cpps 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'c-with-cpps-commented-out '(macro . #[(&rest forms) "\301\302\303\304BBB\305BB\207" [forms unwind-protect c-save-buffer-state nil (c-comment-out-cpps) ((c-save-buffer-state nil (c-uncomment-out-cpps)))] 5]))
(defalias 'c-with-all-but-one-cpps-commented-out '(macro . #[(beg end &rest forms) "\303\304\305\306	E\307\nBF\304\305\310	EEE\207" [beg end forms unwind-protect c-save-buffer-state nil c-clear-cpp-delimiters c-with-cpps-commented-out c-set-cpp-delimiters] 7]))
(defalias 'c-intersect-lists #[(list alist) "\303	\203	@\n\236\211\204	A\211\204)\207" [match list alist nil] 3])
(put 'c-intersect-lists 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'c-lookup-lists #[(list alist1 alist2) "	\305\203@\n\236\211\204A\211\204\n+@\f\236\207" [list alist1 alist match alist2 nil] 2])
(put 'c-lookup-lists 'byte-optimizer 'byte-compile-inline-expand)
#@215 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'.
(defalias 'c-langelem-sym #[(langelem) "@\207" [langelem] 1 (#$ . 29576)])
(put 'c-langelem-sym 'byte-optimizer 'byte-compile-inline-expand)
#@239 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'.
(defalias 'c-langelem-pos #[(langelem) "A:\203\nA\242\207A\207" [langelem] 1 (#$ . 29939)])
(put 'c-langelem-pos 'byte-optimizer 'byte-compile-inline-expand)
#@299 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'.
(defalias 'c-langelem-col #[(langelem &optional preserve-point) "\211A:\203A\242\202A)`\211\203&\nb\210i\203'	b\210\202'\304*\207" [langelem here pos preserve-point 0] 3 (#$ . 30346)])
#@293 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.
(defalias 'c-langelem-2nd-pos #[(langelem) "\243\243\242\207" [langelem] 1 (#$ . 30850)])
(put 'c-langelem-2nd-pos 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'c-keep-region-active #[nil "\301\300!\205	\302\211\207" [zmacs-region-stays boundp t] 2])
(byte-code "\300\301\302\303#\210\300\304\305\306#\210\300\307\305\310#\210\300\311\305\312#\210\300\313\305\314#\210\300\315\305\316#\210\300\317\305\320#\210\300\321\305\322#\207" [put c-keep-region-active 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-"] 4)
#@91 Prefix the current mode prefix (e.g. "c-") to SUFFIX and return
the corresponding symbol.
(defalias 'c-mode-symbol #[(suffix) "\204\303\304!\210\305N\211\204\303\306\"\210\307	\nP!)\207" [c-buffer-is-cc-mode mode-prefix suffix error "Not inside a CC Mode based mode" c-mode-prefix "%S has no mode prefix known to `c-mode-symbol'" intern] 4 (#$ . 31794)])
(put 'c-mode-symbol 'byte-optimizer 'byte-compile-inline-expand)
#@107 Prefix the current mode prefix (e.g. "c-") to SUFFIX and return
the value of the variable with that name.
(defalias 'c-mode-var #[(suffix) "	\204\n\303\304!\210	\305N\211\204\303\306	\"\210\307\nP!*J\207" [suffix c-buffer-is-cc-mode mode-prefix error "Not inside a CC Mode based mode" c-mode-prefix "%S has no mode prefix known to `c-mode-symbol'" intern] 3 (#$ . 32229)])
(put 'c-mode-var 'byte-optimizer 'byte-compile-inline-expand)
#@94 Return non-nil if position POS in the current buffer has any of the
faces in the list FACES.
(defalias 'c-got-face-at #[(pos faces) "\303\304\"\211:\203 	\203	@\n>\204	A\211\204	\202#	\n>)\207" [pos pos-faces faces get-text-property face] 4 (#$ . 32677)])
(put 'c-got-face-at 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'c-face-name-p #[(facename) "\301 >\207" [facename face-list] 2])
(put 'c-face-name-p 'byte-optimizer 'byte-compile-inline-expand)
#@110 Like `concat' on LIST, but separate each element with SEPARATOR.
Notably, null elements in LIST are ignored.
(defalias 'c-concat-separated #[(list separator) "\302\303\304\305\306\305\"\"	#\207" [list separator mapconcat identity delete nil append] 7 (#$ . 33158)])
#@964 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'.
(defalias 'c-make-keywords-re #[(adorn list &optional mode) "\306	\306\211\203@\211\235\204\nBA\211\204\n*\307\306\")	\203\306
\310=\203\247\311\306#\306$\312P	\211#\203\\\313#@\"\203S\314$\202\\#A\211#\204D$)\2046	\211#\203\203\313\315#@\"\203z#\211@P\240\210#A\211#\204i\316	!\317#\313\f##\203\243\317\224\320\\#\321\322\314\211\f$\202\212*\202\253\316	!\306%	\203\323\313\323	@\"\203\314\313\324\f\325Q	@\"\204\314	@%B%	A\211\204\262%\203\357\f\326\327
\310=\203\345\330\202\346\331\332%\333\"\326#Q)
\310=\203\375\334\f\335Q\202
\203\334\f\335\334\336\337\306&#\340\260\202\f)\207
\203\341\207\342\207" [unique list elt --dolist-tail-- re adorn nil delete appendable "" "@" string-match t "\\w\\'" regexp-opt 0 2 replace-match "\\>" "\n" "\\`\\(" "\\)\\'" "\\|" mapconcat #[(str) "\301\302\"\203
\303!\304P\207\303!\207" [str string-match "\\w\\'" regexp-quote "\\>"] 3] regexp-quote sort #[(a b) "G	GV\207" [a b] 2] "\\(" "\\)" c-get-lang-constant c-nonsymbol-key "\\|$\\)" "\\(\\<\\>\\)" "\\<\\>" pos found fail-list mode] 9 (#$ . 33432)])
(put 'c-make-keywords-re 'lisp-indent-function 1)
#@242 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.
(defalias 'c-make-bare-char-alt #[(chars &optional inverted) "\203\305\202	\306\307\211\310\311\f\307\"\312\"\f\203j\f\211A@\211\313>\203/\314\315\n#\2025\314\316\n#\n\f\203L	T\f@Y\203L\f\211A@\2027\n	U\204\nT	W\203b\314\317	#\202	\fB\211\204+\207" [inverted char2 char str chars "^" "" nil sort append < (92 94 45) format "%s\\%c" "%s%c" "%s-%c"] 5 (#$ . 35585)])
(byte-code "\300\301\302\"\210\300\303\304\"\207" [defalias c-regexp-opt regexp-opt c-regexp-opt-depth regexp-opt-depth] 3)
#@1475 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 passes ARG through
                    to a non-null beginning-of-defun-function.  It is assumed
		    the end-of-defun does the same thing.
'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.
'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 10
		    elements, i.e. it contains the position of the start of
		    the last comment or string.  It's always set - CC Mode
                    no longer works in emacsen without this feature.
'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\f\311B\312 \306\313\314\315\n#\210\316\n!\203,\n\314H\211:\203>	@\202>\317\320!\203:\320\314\n\"\202>\321\322!\210\323\324	\325\"\326\"\326U\203N\327\202O\330B*\306\331\211\332@\333A\212\334\335!\205\201\f\335=\205\201\334 ?\205\201\336\335!\205\201
\335=\205\201\336 ?)\203\211\337B-\340\341!\306\211\211BCDErEq\210\342\343 !\210\344\211DC\344B\313\345\346\"\210\313\347\346\"\210\350c\210e\211FG\351G\211T\352\353$*\210\335e\\\211FG\351G\211T\352\354$*\210eb\210\355`\356\"b\210`\357e\\U\203\362\360B\202\366\321\361!\210\306\362\363\217\210\306\364\365\217\210\366\367\370\"\203\"ed|\210\371c\210\372\306x\210o\203\"\373\306w\335U\203\"\374B\307\375!\203\215\306\344C=ed|\210\342\343 !\210\313\376\377\"\210\327>\203W\313\201H\201I\"\210\313\201J\201K\"\210\202o\330>\203o\313\201H\201L\"\210\313\201J\201K\"\210\313\201M\201N\"\210\201Oc\210\201P \210o\203\214\201QB*\201R\306!\210)\201SE!\210,\306\201T\201U\217\203\260\201VB\202\266\321\201W!\210)\207" [list entry table mark-ring bod-param eod-param 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 lsh -16 255 8-bit 1-bit foo #[(&optional arg) "\302=\204\303\302=\205	\211\205	\304=\207" [bod-param arg foo bar 3] 2] #[(&optional arg) "\302=\205	\211\205	\303=\207" [eod-param arg foo 3] 2] beginning-of-defun 3 end-of-defun argumentative-bod-function generate-new-buffer " test" set-syntax-table make-syntax-table t 60 "." 62 "<()>" put-text-property category c-<-as-paren-syntax c->-as-paren-syntax scan-sexps 1 4 syntax-properties "CC Mode is incompatible with this version of Emacs - support for the `syntax-table' text property is required." (byte-code "\301\302\303\"\210\304\305\306\"\203\307B\301\207" [list modify-syntax-entry 120 "!" string-match "\\s!" "x" gen-comment-delim] 3) ((error)) (byte-code "\301\302\303\"\210\304\305\306\"\203\307B\301\207" [list modify-syntax-entry 120 "|" string-match "\\s|" "x" gen-string-delim] 3) ((error)) string-match "[[:alpha:]]" "a" "foo123" "[:alnum:]" "[:alpha:]" posix-char-classes open-paren-in-column-0-is-defun-start 39 "\"" beginning-of-defun-function end-of-defun-function lookup-syntax-properties parse-sexp-ignore-comments parse-sexp-lookup-properties buf pos -pos- 47 ". 1456" 42 ". 23" ". 124b" 10 "> b" "/* '\n   () */" backward-sexp col-0-paren set-buffer-modified-p kill-buffer (byte-code "\212\300``\")G\301Y\207" [parse-partial-sexp 10] 3) ((error)) pps-extended-state "CC Mode is incompatible with this version of Emacs - `parse-partial-sexp' has to return at least 10 elements."] 6) (#$ . 36357))
(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)
#@604 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.
(defalias 'c-add-language #[(mode base-mode) "\302\303\304!\"\204\305\306\"\210\307\310\311\312\304!\"#\210	\310N\204$\305\313	\"\210\307\314	#\207" [mode base-mode 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] 7 (#$ . 41374)])
(defvar c-lang-constants (make-vector 151 0))
(defvar c-lang-const-expansion nil)
(defalias 'c-get-current-file #[nil "\203	\202\304\302!\203\n;\203\n\202\305 \211\205!\306!)\207" [load-in-progress load-file-name byte-compile-dest-file file boundp buffer-file-name file-name-base] 3])
(put 'c-get-current-file 'byte-optimizer 'byte-compile-inline-expand)
#@150 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.
(defalias 'c-lang-defconst-eval-immediately '(macro . #[(form) "\301!\207" [form eval] 2 (#$ . 42723)]))
#@1910 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.
(defalias 'c-lang-defconst '(macro . #[(name &rest args) "\306\307!	\"\310\311\312\2119\204\313\314\"\210\242;\203.\315\n\316@#\210A\2048\313\317\"\210\203\245@\311=\203I\311\202s@9\203]\306\307@!\320P!C\202s@<\203m\321\322@\"\202s\313\323@\"\312A\204\205\313\324@\"\210A\211@\325!B
BA*\2028\321\326\n\327N\"\237\330\331\332D\332
D\205\300\332DC-BBBD\207" [name c-lang-constants sym c-lang-const-expansion c-langs-are-parametric bindings intern symbol-name call t nil error "Not a symbol: %s" put variable-documentation "No assignments in `c-lang-defconst' for %s" "-mode" mapcar #[(lang) "9\204\302\303	@\"\210\304\305!\306P!\207" [lang args error "Not a list of symbols: %s" intern symbol-name "-mode"] 3] "Not a symbol or a list of symbols: %s" "No value for %s" cl-macroexpand-all car source eval-and-compile c-define-lang-constant quote pre-files args val assigned-mode] 7 (#$ . 42986)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put c-lang-defconst lisp-indent-function 1 edebug-form-spec (&define name [&optional stringp] [&rest sexp def-form])] 4)
(defalias 'c-define-lang-constant #[(name bindings &optional pre-files) "\306\307!	\"\211\303N\306\f\203
\202'\310\311!\203%	;\203%	\202'\312 \211\2051\313!)\2068\314\315!!\211\236\211\204n\203a@\236\204X@CBA\211\204I\316\n\303C\211B#\210\241\210\n\317L\210\n\320N\321\322\323\"\317\203\306@A\306\307\n!\"\210\n\317L\210\n\320N\203\206@A\324\307\n!\"\204\245\nB\202\245+,\207" [name c-lang-constants sym source load-in-progress load-file-name intern symbol-name boundp byte-compile-dest-file buffer-file-name file-name-base error "`c-lang-defconst' must be used in a file" put nil dependents make-vector 101 0 intern-soft file elem pre-files bindings ptr visited agenda] 6])
#@330 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.
(defalias 'c-lang-const '(macro . #[(name &optional lang) "9\204\n\306\307\"\210	9\204\306\307	\"\210\310\311!\n\"\312\211\211	\203;\310\311	!\313P!\211\314N\204;\306\315\311	!\"\210 \316=\203L\317\320\312
#D\202\354!\203V\"\202i\321\322!\203g;\203g\202i\323 \211#\205s\324#!)\211#\203\200\310#!#\325\326\327\330\331N\"\"\237)
\205\225\317
DC\f\204\236\203\250\f\205\245\317\fDB \332=\204\311 \204\270
\203\311!\204\311\321\322!\203\311;\204\323\320\317DBB\202\354\333\334\335\317DE\336\320\317DBBD\320\317DBBF,\207" [name lang c-lang-constants args source-files mode error "Not a symbol: %s" intern symbol-name nil "-mode" c-mode-prefix "Unknown language %S since it got no `c-mode-prefix' property" immediate quote c-get-lang-constant boundp byte-compile-dest-file buffer-file-name file-name-base apply nconc mapcar #[(elem) "	@=?\205	@C\207" [file elem] 2] source call if eq c-version-sym cc-eval-when-compile sym c-lang-const-expansion load-in-progress load-file-name file] 7 (#$ . 46822)]))
(defvar c-lang-constants-under-evaluation nil)
(defalias 'c-get-lang-constant #[(name &optional source-files mode) "\204	\211\204\306\307!\210\310\311\n!\"\211\305N\312\205)\211@@)\211\203C\f\313N>\204C\314\f\313\f\313NB#\210\203j@
\236\204a\314\f\305@C
B\211#\210\f\312L\210A\211\204H\315\f!\203\200\fJ\236\211\203\200A\202\f\236\206\217\f\316
\312\"B\211B\317N\312 !\320]!\"\321]\"\203\333\322A!#\323A\312\n$\211 =\205\327\323#\241\324\n$\211 =)\202\350\323A\324\n$\211 =\203\361\306\325\n#\210\326\327\330\217\210\f B\fJBL\210 .,\207" [mode c-buffer-is-cc-mode name c-lang-constants sym source error "No current language" intern symbol-name 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)" err (byte-code "\301!\301\207" [value eval] 2) ((error (byte-code "\303\304	#\210\305!\210\306\n@\nA\"\207" [sym mode err message "Eval error in the `c-lang-defconst' for `%s' in %s:" makunbound signal] 4))) elem c-lang-constants-under-evaluation x eval-in-sym source-files source-pos fallback value max-specpdl-size max-lisp-eval-depth backup-source-pos] 7])
(defalias 'c-find-assignment-for-mode #[(source-pos mode match-any-lang name) "\300\301\215\207" [found (byte-code "\306\234\307\234\310\n\204N\203u\307\211@A)\211I\204F\311\211@@)!\310
\312
!\210*\211@A)\211\204F@\310CC\211\241\210\306A\211I\210\n@\307\nA\211I\210	@<\203g	@>\202i\203\n\313\314	A\"\210\202\n+\207" [source-pos assignment assignment-entry file-entry x c-lang-constants-under-evaluation 0 1 nil symbol-name load throw found file mode match-any-lang c-lang-constants] 5)] 2])
(defalias 'c-lang-major-mode-is #[(mode) "<\204C\304	\n>\203\305\202\n\306N\211\204\f*\207" [mode c-buffer-is-cc-mode buf-mode match nil t c-fallback-mode] 2])
(provide 'cc-defs)
F1l3 Manager
