Gecko [ fernandoquevedodop.com ]

Name	Size	Permission
antlr-mode.elc	77.56 KB	-rw-r--r--
asm-mode.elc	7.42 KB	-rw-r--r--
autoconf.elc	4.55 KB	-rw-r--r--
bat-mode.elc	6.56 KB	-rw-r--r--
bug-reference.elc	7.3 KB	-rw-r--r--
cc-align.elc	39.52 KB	-rw-r--r--
cc-awk.elc	17.95 KB	-rw-r--r--
cc-bytecomp.elc	10.56 KB	-rw-r--r--
cc-cmds.elc	97.51 KB	-rw-r--r--
cc-defs.elc	66.37 KB	-rw-r--r--
cc-engine.elc	231.26 KB	-rw-r--r--
cc-fonts.elc	153.13 KB	-rw-r--r--
cc-guess.elc	13.35 KB	-rw-r--r--
cc-langs.elc	110.05 KB	-rw-r--r--
cc-menus.elc	8.05 KB	-rw-r--r--
cc-mode.elc	227.86 KB	-rw-r--r--
cc-styles.elc	16.66 KB	-rw-r--r--
cc-vars.elc	77.01 KB	-rw-r--r--
cfengine.elc	48.18 KB	-rw-r--r--
cmacexp.elc	6.2 KB	-rw-r--r--
compile.elc	92.53 KB	-rw-r--r--
cperl-mode.elc	212.98 KB	-rw-r--r--
cpp.elc	23.2 KB	-rw-r--r--
cwarn.elc	11.9 KB	-rw-r--r--
dcl-mode.elc	50.32 KB	-rw-r--r--
ebnf-abn.elc	6.95 KB	-rw-r--r--
ebnf-bnf.elc	8.02 KB	-rw-r--r--
ebnf-dtd.elc	13.53 KB	-rw-r--r--
ebnf-ebx.elc	8.12 KB	-rw-r--r--
ebnf-iso.elc	7.77 KB	-rw-r--r--
ebnf-otz.elc	8.47 KB	-rw-r--r--
ebnf-yac.elc	7.4 KB	-rw-r--r--
ebnf2ps.elc	121.12 KB	-rw-r--r--
ebrowse.elc	202.8 KB	-rw-r--r--
elisp-mode.elc	58.74 KB	-rw-r--r--
etags.elc	61.3 KB	-rw-r--r--
executable.elc	7.83 KB	-rw-r--r--
f90.elc	95.13 KB	-rw-r--r--
flymake-cc.elc	3.55 KB	-rw-r--r--
flymake-proc.elc	38.04 KB	-rw-r--r--
flymake.elc	63.5 KB	-rw-r--r--
fortran.elc	59.75 KB	-rw-r--r--
gdb-mi.elc	188.72 KB	-rw-r--r--
glasses.elc	10.37 KB	-rw-r--r--
grep.elc	40.95 KB	-rw-r--r--
gud.elc	98.55 KB	-rw-r--r--
hideif.elc	48.36 KB	-rw-r--r--
hideshow.elc	25.56 KB	-rw-r--r--
icon.elc	16.75 KB	-rw-r--r--
idlw-complete-structtag.elc	4.22 KB	-rw-r--r--
idlw-help.elc	35.91 KB	-rw-r--r--
idlw-shell.elc	129.89 KB	-rw-r--r--
idlw-toolbar.elc	27.44 KB	-rw-r--r--
idlwave.elc	250.95 KB	-rw-r--r--
inf-lisp.elc	21.06 KB	-rw-r--r--
js.elc	176.3 KB	-rw-r--r--
ld-script.elc	5.44 KB	-rw-r--r--
m4-mode.elc	6.34 KB	-rw-r--r--
make-mode.elc	62.21 KB	-rw-r--r--
meta-mode.elc	31.41 KB	-rw-r--r--
mixal-mode.elc	36.18 KB	-rw-r--r--
modula2.elc	30.37 KB	-rw-r--r--
octave.elc	63.2 KB	-rw-r--r--
opascal.elc	52.47 KB	-rw-r--r--
pascal.elc	39.22 KB	-rw-r--r--
perl-mode.elc	29.41 KB	-rw-r--r--
prog-mode.elc	15.82 KB	-rw-r--r--
project.elc	17.06 KB	-rw-r--r--
prolog.elc	85.47 KB	-rw-r--r--
ps-mode.elc	33 KB	-rw-r--r--
python.elc	178.17 KB	-rw-r--r--
ruby-mode.elc	63.86 KB	-rw-r--r--
scheme.elc	18.81 KB	-rw-r--r--
sh-script.elc	116.3 KB	-rw-r--r--
simula.elc	44.83 KB	-rw-r--r--
sql.elc	182.59 KB	-rw-r--r--
subword.elc	18.77 KB	-rw-r--r--
tcl.elc	40.14 KB	-rw-r--r--
vera-mode.elc	45.08 KB	-rw-r--r--
verilog-mode.elc	450.39 KB	-rw-r--r--
vhdl-mode.elc	528.7 KB	-rw-r--r--
which-func.elc	10.4 KB	-rw-r--r--
xref.elc	56.91 KB	-rw-r--r--
xscheme.elc	38 KB	-rw-r--r--

Code Editor : cc-defs.elc

;ELC���
;;; Compiled
;;; in Emacs version 27.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.

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

(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.34.1" (#$ . 590))
(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 (#$ . 706))
(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)
#@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 (#$ . 1367)]))
(put 'cc-eval-when-compile 'lisp-indent-hook 0)
(defalias 'c--mapcan '(macro . #[(fun liszt) "\303\304!\203�\305\304K!\203�\304	E\207\n\306=\203�\307	E\207\310\311\312	EE\207" [fun liszt c--cl-library fboundp mapcan subrp cl-lib cl-mapcan apply 'nconc mapcar] 5]))
(defalias 'c--set-difference '(macro . #[(liszt1 liszt2 &rest other-args) "\304=\203�\305	\nBBB\207\306	\nBBB\207" [c--cl-library liszt1 liszt2 other-args cl-lib cl-set-difference set-difference] 4]))
(defalias 'c--intersection '(macro . #[(liszt1 liszt2 &rest other-args) "\304=\203�\305	\nBBB\207\306	\nBBB\207" [c--cl-library liszt1 liszt2 other-args cl-lib cl-intersection intersection] 4]))
(defalias 'c--macroexpand-all '(macro . #[(form &optional environment) "\302\303!\203�\303	E\207\304	E\207" [form environment fboundp macroexpand-all cl-macroexpand-all] 3]))
(defalias 'c--delete-duplicates '(macro . #[(cl-seq &rest cl-keys) "\303=\203\f�\304	\nBB\207\305	\nBB\207" [c--cl-library cl-seq cl-keys cl-lib cl-delete-duplicates delete-duplicates] 3]))
#@133 Declare the region BEG...END's fontification as out-of-date.
On XEmacs and older Emacsen, this refontifies that region immediately.
(defalias 'c-font-lock-flush '(macro . #[(beg end) "\302\303!\203�\303	E\207\304	E\207" [beg end fboundp font-lock-flush font-lock-fontify-region] 3 (#$ . 2885)]))
#@814 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
`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.
(defalias 'c-point '(macro . #[(position &optional point) "\242\302=\203K\303!\211\304\267\202E\305\306!\203�	\204�\307\202I\310\311	\205)�\312	DC\313\"B\202I\305\314!\203=�	\204=�\315\202I\310\311	\205G�\312	DC\316\"B\202I\310\311	\205W�\312	DC\317\"B\202I\310\311	\205g�\312	DC\320\"B\202I\310\311	\205w�\312	DC\321\"B\202I\310\311	\205\207�\312	DC\322\"B\202I\305\306!\203\233�	\204\233�\323\202I\310\311	\205\245�\312	DC\324\"B\202I\305\306!\203\271�	\204\271�\325\202I\310\311	\205\303�\312	DC\326\"B\202I\305\314!\203\327�	\204\327�\327\202I\310\311	\205\341�\312	DC\330\"B\202I\305\314!\203\365�	\204\365�\331\202I\310\311	\205\377�\312	DC\332\"B\202I\310\311	\205\312	DC\333\"B\202I\310\311	\205\312	DC\334\"B\202I\310\311	\205/\312	DC\335\"B\202I\310\311	\205?\312	DC\336\"B\202I\337\340\")\207\341\342!\210\310\311	\205Y\312	DC\343\300DC\344BB\345B\"B\207" [position point quote eval #s(hash-table size 14 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (bol 17 eol 47 eoll 77 boi 93 bod 109 eod 125 bopl 141 bonl 171 eopl 201 eonl 231 iopl 261 ionl 277 bosws 293 eosws 309)) fboundp line-beginning-position (line-beginning-position) save-excursion append goto-char ((beginning-of-line) (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 ((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 (#$ . 3191)]))
(defconst c-use-category (byte-code "\303\304!rq\210\305\216\306\211\307\310 !\210\311c\210\312eeT\313\314$\210\312\315e\\\316e\\\313\317$\210eb\210\320 \210`\316e\\U-\207" [#1=#:temp-buffer lookup-syntax-properties parse-sexp-lookup-properties generate-new-buffer " *temp*" #[nil "\301!\205	�\302!\207" [#1# buffer-name kill-buffer] 2] t set-syntax-table make-syntax-table "<()>" put-text-property category c-<-as-paren-syntax 3 4 c->-as-paren-syntax forward-sexp] 5))
(defalias 'c-is-escaped '(macro . #[(pos) "\301\302D\303BB\207" [pos save-excursion goto-char ((not (zerop (logand (skip-chars-backward "\\\\") 1))))] 3]))
(defalias 'c-will-be-escaped '(macro . #[(pos beg end) "\303\304\305D\306B\307	D\310\311\312\307\nD\313BBB\314BBBBBD\207" [end pos beg 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))))] 9]))
(defalias 'c-next-single-property-change '(macro . #[(position prop &optional object limit) "\203�\305\306!\203�\306	\n\f\257\207\307	\n\f\257\207" [c-use-extents position prop object limit fboundp next-single-char-property-change next-single-property-change] 5]))
(defalias 'c-region-is-active-p '(macro . #[nil "\300\301!\203�\302\207\303\207" [fboundp region-active-p (region-active-p) mark-active] 2]))
(defalias 'c-set-region-active '(macro . #[(activate) "\301\302!\203\f�\303\304BB\207\305\306E\207" [activate fboundp zmacs-activate-region if ((zmacs-activate-region) (zmacs-deactivate-region)) setq mark-active] 3]))
(defalias 'c-set-keymap-parent '(macro . #[(map parent) "\302\303!\203�\303	E\207\302\304!\203�\304	E\207\305\306!\207" [map parent fboundp set-keymap-parents set-keymap-parent error "CC Mode is incompatible with this version of Emacs"] 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 (#$ . 8668)]))
(defalias 'c-safe '(macro . #[(&rest body) "\301\302\303B\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�\302D\207\207" [integer fboundp int-to-char] 2]))
(defalias 'c-characterp '(macro . #[(arg) "\301\250\203	�\302D\207\303D\207" [arg 99 integerp characterp] 2]))
(defalias 'c-last-command-char '(macro . #[nil "\300\207" [last-command-event] 1]))
(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]))
(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 . #[nil "\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]))
(defalias 'c-at-c++-raw-string-opener '(macro . #[(&optional pos) "\203\f�\301\302D\303BB\207\304\207" [pos save-excursion goto-char ((c-sub-at-c++-raw-string-opener)) (c-sub-at-c++-raw-string-opener)] 3]))
#@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!\203�\303\304	BBD\207\304\305\306\307\310\311\312\313\314\315BBBBBBBBB\316\317	B\320BBE\207" [varlist body 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)))] 11 (#$ . 10290)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put c-save-buffer-state edebug-form-spec t function-put lisp-indent-function 1] 4)
#@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\312B\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 (#$ . 12167)]))
(put 'c-tentative-buffer-changes 'lisp-indent-function 0)
(defalias 'c-tnt-chng-record-state #[nil "\301p`\302\303!\304 \305 &\207" [buffer-undo-list vector mark t region-active-p buffer-modified-p] 7])
(defalias 'c-tnt-chng-cleanup #[(keep saved-state) "\306\234\n	=\203�	A\211\202j�\203-�\n\211A	=\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 (#$ . 13910)]))
#@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 (#$ . 14714)]))
#@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\304ED\207" [count 1 goto-char scan-sexps (point)] 4 (#$ . 15538)]))
#@46 See `c-forward-sexp' and reverse directions.
(defalias 'c-backward-sexp '(macro . #[(&optional count) "\204�\301\302\247\203�[\202�\303DD\207" [count 1 c-forward-sexp -] 3 (#$ . 16054)]))
#@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\310\f	\247\203)�	\311W\203\"�\312\f\313BB\2029�\312\314\fE\2029�\315\316	\317BB\312\f\320BB\312\321\fEFEE\202@�)\207" [from count depth res limit c-safe scan-lists save-restriction when 0 narrow-to-region ((point-max)) (point-min) if < (0) ((point-max)) (point-min)] 9 (#$ . 16257)]))
#@258 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.
(defalias 'c-go-list-forward '(macro . #[(&optional pos limit) "\302\303\304\206�\305\306\307	\257DC\310BB\207" [pos limit let dest c-safe-scan-lists (point) 1 0 ((when dest (goto-char dest) dest))] 7 (#$ . 16827)]))
#@258 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.
(defalias 'c-go-list-backward '(macro . #[(&optional pos limit) "\302\303\304\206�\305\306\307	\257DC\310BB\207" [pos limit let dest c-safe-scan-lists (point) -1 0 ((when dest (goto-char dest) dest))] 7 (#$ . 17311)]))
#@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 (#$ . 17797)]))
#@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 (#$ . 18183)]))
#@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 (#$ . 18576)]))
#@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 (#$ . 18969)]))
#@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) "\302\303\304	EDC\305BB\207" [pos limit let dest c-up-list-forward ((when dest (goto-char dest) t))] 5 (#$ . 19359)]))
#@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) "\302\303\304	EDC\305BB\207" [pos limit let dest c-up-list-backward ((when dest (goto-char dest) t))] 5 (#$ . 19845)]))
#@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) "\302\303\304	EDC\305BB\207" [pos limit let dest c-down-list-forward ((when dest (goto-char dest) t))] 5 (#$ . 20336)]))
#@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) "\302\303\304	EDC\305BB\207" [pos limit let dest c-down-list-backward ((when dest (goto-char dest) t))] 5 (#$ . 20824)]))
(defalias 'c-beginning-of-defun-1 '(macro . #[nil "\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]))
(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\306D	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 (#$ . 22836)]))
#@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 (#$ . 23418)]))
(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 (#$ . 23969)]))
(defalias 'c-put-syn-tab '(macro . #[(pos value) "\302\303D\304	DD\305BB\207" [pos value let -pos- -value- ((c-put-char-property -pos- 'syntax-table -value-) (c-put-char-property -pos- 'c-fl-syn-tab -value-) (c-truncate-lit-pos-cache -pos-))] 4]))
(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)
(defalias 'c-put-char-property '(macro . #[(pos property value) "\304!	\204�\305\306!\204�\307\n\310DF\207\311\312\nDC\313\314\315!\205)�\316=\205)�\317\320\312\321\310D\257C\"BB\207" [property c-use-extents pos value 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-)] 9]))
(defalias 'c-get-char-property '(macro . #[(pos property) "\303!	\203�\304\305\306\n\307\310DFDC\311\305\312\305\310DEEE\207\313\n\310DE\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\310DFDC\311BB\207\312\313!\203>�\304\302\nDC\314\315\316!\2050�\317=\2050�\320\321\302\322\310\323BDFC\"BB\207\324\n\310DE\207" [property c-use-extents pos eval let ext extent-at nil quote ((if ext (delete-extent ext))) boundp text-property-default-nonsticky 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] 10]))
(defalias 'c-clear-syn-tab '(macro . #[(pos) "\301\302DC\303BB\207" [pos let -pos- ((c-clear-char-property -pos- 'syntax-table) (c-clear-char-property -pos- 'c-fl-syn-tab) (c-truncate-lit-pos-cache -pos-))] 3]))
(defalias 'c-min-property-position '(macro . #[(from to property) "\303\304D\305	D\306BB\307\310\311\312\304\nEE\313B\314\315\316\317\304\n\320BBBE\321BB\322B\323BBBE\207" [from to property 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))] 11]))
(defalias 'c-clear-char-properties '(macro . #[(from to property) "\304!	\203�\305\306\307\n\307\211\310D\257\207\311\312!\203A�\313=\203A�\314\315\nD\316DD\317\320\321\320\322\315\316\310DFEE\323\315\316\310\324BDFF\207\323\n\310\325BDF\207" [property c-use-extents from to eval map-extents (lambda (ext ignored) (delete-extent ext)) nil quote fboundp syntax-ppss syntax-table let -from- -to- setq c-syntax-table-hwm min c-min-property-position remove-text-properties (nil) (nil)] 11]))
(defalias 'c-clear-syn-tab-properties '(macro . #[(from to) "\302\303D\304	DD\305BB\207" [from to let -from- -to- ((c-clear-char-properties -from- -to- 'syntax-table) (c-clear-char-properties -from- -to- 'c-fl-syn-tab))] 4]))
#@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\257EE\321\307\310\206-�\322E\323BBF\207" [limit property value 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))] 11 (#$ . 27796)]))
#@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) "\304\305\306\307\310\311\206�\312E\313\314\315\316	E\nEDE\317\311\203&�\320\321!\203&�\321\202'�\322\311	\323\206/�\324\257EE\325\310\311\206;�\326E\327BBF\207" [limit property value 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))] 11 (#$ . 28576)]))
#@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\211W\203�\307\n\f\"
\232\204�\310\n\f\306$\211\202�\nW\205K�\311\312!\2036�\f\313=\2036�
\n^
\310\n\f\306$\314\n	\f\306D#\210	\211\202�*\207" [from end-place place to property value nil get-text-property next-single-property-change fboundp syntax-ppss syntax-table remove-text-properties c-syntax-table-hwm] 6 (#$ . 29460)])
#@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 (#$ . 30143)]))
#@357 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 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.
(defalias 'c-search-backward-char-property-with-value-on-char '(macro . #[(property value char &optional limit) "\304\305\306\307\310DED\311\312	\313BBD\314\nDE\315\316\317\320\321\322\323E\324BBDE\325BB\326BBB\207" [char limit value property 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)))] 10 (#$ . 31706)]))
#@350 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.
(defalias 'c-search-forward-char-property-without-value-on-char '(macro . #[(property value char &optional limit) "\304\305\306\307\310DED\311\312	\313BBD\314\nDE\315\316\317\320\321\322E\323BBE\324BB\325BBB\207" [char limit value property 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)))] 9 (#$ . 32635)]))
#@330 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.
(defalias 'c-clear-char-property-with-value-on-char-function #[(from to property value char) "\306\211W\203�\307\n\f\"
\232\204�\310\n\f\306$\211\202�\nW\203N�\nf=\203G�\311\n\211T\f\306D#\210	\204G�\n\f\312=\203G�\f\n^\f\nT\211\202�	*\207" [from first place to property value nil get-text-property next-single-property-change remove-text-properties syntax-table char c-syntax-table-hwm] 6 (#$ . 33539)])
#@330 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.
(defalias 'c-clear-char-property-with-value-on-char '(macro . #[(from to property value char) "\203 �\306\307	D\310\nD\311BB\312\313\314\f
\315BBBBBB\316BBB\207\317\f	
\n\257\207" [c-use-extents property char from to value 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] 9 (#$ . 34297)]))
#@104 Put the text property PROPERTY with value VALUE on characters
with value CHAR in the region [FROM to).
(defalias 'c-put-char-properties-on-char '(macro . #[(from to property value char) "\305\306\307\310\311DED\312	DD\313\314\nD\315\316\317\320\321!\205#�\322!\323=\205#�\324\325\326\fF\327B\"BBEE\207" [char to from property value 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))] 12 (#$ . 35251)]))
(defalias 'c-with-extended-string-fences '(macro . #[(beg end &rest body) "\303\304D\305	DD\306\307\310\311\312\nBB\313BBD\314\nB\315\316\317\nBBBFE\207" [beg end body let -beg- -end- cond (null c-fl-syn-tab-region) unwind-protect progn (c-restore-string-fences -beg- -end-) ((c-clear-string-fences)) (and (>= -beg- (car c-fl-syn-tab-region)) (<= -end- (cdr c-fl-syn-tab-region))) t (setq -beg- (min -beg- (car c-fl-syn-tab-region)) -end- (max -end- (cdr c-fl-syn-tab-region))) (c-restore-string-fences -beg- -end-)] 9]))
(defalias 'c-put-overlay '(macro . #[(from to property value) "\304\305!\203�\306\307\305	EDC\310\307\nF\311BBB\207\306\312\313	EDC\314\312\nF\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�\303D\207\304D\207" [overlay fboundp make-overlay delete-overlay delete-extent] 2]))
(byte-code "\300\301\302\303#\210\300\304\302\305#\210\300\306\302\305#\210\300\307\302\310#\210\300\311\302\312#\210\300\313\302\314#\210\300\315\302\305#\210\300\316\302\305#\210\300\317\302\305#\210\300\320\302\305#\210\300\321\302\305#\210\300\322\302\305#\210\300\323\302\305#\210\300\324\302\305#\210\300\325\302\305#\210\300\326\302\305#\210\300\327\302\330#\210\300\331\302\305#\210\300\332\302\305#\210\300\333\302\305#\210\300\334\302\305#\210\300\335\302\305#\210\300\336\302\305#\210\300\337\302\305#\210\300\340\302\305#\210\300\341\302\305#\210\300\342\302\305#\210\300\343\302\305#\210\300\344\302\305#\210\300\345\302\305#\210\300\346\302\305#\210\300\347\302\305#\210\300\350\302\305#\210\300\351\302\305#\210\300\352\302\305#\210\300\353\302\305#\210\300\354\302\305#\210\300\355\302\305#\210\300\356\302\305#\210\300\357\302\305#\210\300\360\302\305#\210\300\361\302\305#\210\300\362\302\305#\210\300\363\302\305#\210\300\364\302\305#\210\300\365\302\305#\210\300\366\302\305#\210\300\367\302\305#\210\300\370\302\305#\210\300\371\302\305#\210\300\372\302\305#\210\300\373\302\305#\210\300\374\302\305#\210\300\375\302\305#\210\300\376\302\377#\210\300\201@�\302\305#\210\300\201A�\302\305#\210\300\201B�\302\305#\210\300\201C�\302\305#\210\300\201D�\302\305#\210\300\201E�\302\201F�#\210\300\201G�\302\201H�#\210\300\201I�\302\305#\210\300\201J�\302\305#\210\300\201K�\302\305#\210\300\201L�\302\305#\210\300\201M�\302\305#\210\300\201N�\302\305#\207" [put cc-eval-when-compile edebug-form-spec (&rest def-form) c-font-lock-flush t c--mapcan c--set-difference (form form &rest [symbolp form]) c--intersection (form form &rest [symbolp form]) c--delete-duplicates (form &rest [symbolp form]) c-point c-is-escaped c-will-be-escaped c-next-single-property-change c-delete-and-extract-region c-set-region-active c-set-keymap-parent c-safe c-int-to-char c-characterp c-save-buffer-state let* c-tentative-buffer-changes c-forward-syntactic-ws c-backward-syntactic-ws c-forward-sexp c-backward-sexp c-safe-scan-lists c-go-list-forward c-go-list-backward c-up-list-forward c-up-list-backward c-down-list-forward c-down-list-backward c-go-up-list-forward c-go-up-list-backward c-go-down-list-forward c-go-down-list-backward c-at-vsemi-p 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-search-forward-char-property c-search-backward-char-property c-put-char-property c-put-syn-tab c-get-char-property c-clear-char-property c-clear-syn-tab c-min-property-position c-clear-char-property-with-value c-clear-char-property-with-value-on-char c-put-char-properties-on-char c-clear-char-properties c-clear-syn-tab-properties c-with-extended-string-fences (form form body) c-put-overlay c-delete-overlay c-mark-<-as-paren c-mark->-as-paren c-unmark-<->-as-paren c-with-<->-as-parens-suppressed (body) c-self-bind-state-cache (body) c-sc-scan-lists-no-category+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 c-sc-scan-lists c-sc-parse-partial-sexp] 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\2051�db)\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)
(defalias 'c-mark-<-as-paren '(macro . #[(pos) "\203\n�\302	\303BB\207\302	\304BB\207" [c-use-category pos c-put-char-property ('category 'c-<-as-paren-syntax) ('syntax-table c-<-as-paren-syntax)] 3]))
(defalias 'c-mark->-as-paren '(macro . #[(pos) "\203\n�\302	\303BB\207\302	\304BB\207" [c-use-category pos c-put-char-property ('category 'c->-as-paren-syntax) ('syntax-table c->-as-paren-syntax)] 3]))
(defalias 'c-unmark-<->-as-paren '(macro . #[(pos) "\302	\203\n�\303\202�\304E\207" [pos c-use-category c-clear-char-property 'category 'syntax-table] 3]))
(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\303BB\304BB\207" [forms unwind-protect progn (c-suppress-<->-as-parens) ((c-restore-<->-as-parens))] 4]))
(defalias 'c-self-bind-state-cache '(macro . #[(&rest forms) "\301\302\303\304B\305BBE\207" [forms let* ((c-state-cache (copy-tree c-state-cache)) (c-state-cache-good-pos c-state-cache-good-pos) (c-state-brace-pair-desert (copy-tree c-state-brace-pair-desert)) (c-state-point-min c-state-point-min) (c-state-point-min-lit-type c-state-point-min-lit-type) (c-state-point-min-lit-start c-state-point-min-lit-start) (c-state-min-scan-pos c-state-min-scan-pos) (c-state-old-cpp-beg-marker (if (markerp c-state-old-cpp-beg-marker) (copy-marker c-state-old-cpp-beg-marker) c-state-old-cpp-beg-marker)) (c-state-old-cpp-beg (if (markerp c-state-old-cpp-beg) c-state-old-cpp-beg-marker c-state-old-cpp-beg)) (c-state-old-cpp-end-marker (if (markerp c-state-old-cpp-end-marker) (copy-marker c-state-old-cpp-end-marker) c-state-old-cpp-end-marker)) (c-state-old-cpp-end (if (markerp c-state-old-cpp-end) c-state-old-cpp-end-marker c-state-old-cpp-end)) (c-parse-state-state c-parse-state-state)) prog1 progn ((if (markerp c-state-old-cpp-beg-marker) (move-marker c-state-old-cpp-beg-marker nil)) (if (markerp c-state-old-cpp-end-marker) (move-marker c-state-old-cpp-end-marker nil)))] 5]))
(defalias 'c-sc-scan-lists-no-category+1+1 '(macro . #[(from) "\301\302\303\304\305BBDD\306BB\207" [from let (here (point)) pos scan-lists (1 1) ((while (eq (char-before pos) 62) (setq pos (scan-lists pos 1 1))) pos)] 6]))
(defalias 'c-sc-scan-lists-no-category+1-1 '(macro . #[(from) "\301\302\303\304\305BBDD\306BB\207" [from let (here (point)) 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]))
(defalias 'c-sc-scan-lists-no-category-1+1 '(macro . #[(from) "\301\302\303\304\305BBDD\306BB\207" [from let (here (point)) pos scan-lists (-1 1) ((while (eq (char-after pos) 60) (setq pos (scan-lists pos -1 1))) pos)] 6]))
(defalias 'c-sc-scan-lists-no-category-1-1 '(macro . #[(from) "\301\302\303\304\305BBDD\306BB\207" [from let (here (point)) 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]))
(defalias 'c-sc-scan-lists '(macro . #[(from count depth) "\203\n�\304	\nF\207\n\305=\203�\305=\203�\306	D\207\n\305=\203*�\307=\203*�\310	D\207\n\307=\203:�\305=\203:�\311	D\207\n\307=\203J�\307=\203J�\312	D\207\313\314!\207" [c-use-category from count depth 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"] 4]))
(defalias 'c-sc-parse-partial-sexp-no-category #[(from to targetdepth stopbefore oldstate) "\306	\n\f%`	W\203=�`Sf\307=\204�`Sf\310=\203=�
`Sf\311>\203-�
@T\2020�
@S\240\210\306`	\n\f%\202�
)\207" [from to targetdepth stopbefore oldstate state parse-partial-sexp 60 62 (62 41 125 93)] 6])
(defalias 'c-sc-parse-partial-sexp '(macro . #[(from to &optional targetdepth stopbefore oldstate) "\203
�\306	\n\f
\257\207\307	\n\f
\257\207" [c-use-category from to targetdepth stopbefore oldstate parse-partial-sexp c-sc-parse-partial-sexp-no-category] 6]))
#@66 Are we looking at a character which isn't alphanumeric or space?
(defalias 'c-looking-at-non-alphnumspace '(macro . #[nil "\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 (#$ . 44662)]))
(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 (#$ . 45544)])
(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\207A\207" [langelem] 1 (#$ . 45907)])
(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) "\211A:\203�A\242\202�A)`\211\203&�\nb\210i\203'�	b\210\202'�\304*\207" [langelem here pos preserve-point 0] 3 (#$ . 46314)])
#@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 (#$ . 46818)])
(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 (#$ . 47762)])
(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\nP!*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 (#$ . 48197)])
(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 (#$ . 48645)])
(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 (#$ . 49126)])
#@965 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\307\310!\"\211\203\347�\307\n\311=\203{�\312\307\307\f\313P\211\2037�\314\f@\"\2030�\315\2027�A\211\204#�
)\204�\316!\211\203Z�\314\317@\"\203S�\211@\fP\240\210A\211\204D�\320!\321\314\f	#\203w�\321\224\322\\\323\324\315\211	$\202`�*\202�\320!\307$\203\247�\314\325@\"\203\240�\314\326	\327Q@\"\204\240�@$B$A\211\204\206�$\203\303�	\330\331\n\311=\203\271�\332\202\272�\333\334$\335\"\330#Q)\n\311=\203\321�\336	\337Q\202\345�\n\203\344�\336	\340\341\342\307%#\343\260\202\345�	)\207\n\203\361�\336&\337Q\207&\207" [list re adorn pos unique found delete nil delete-dups appendable "" "@" string-match t copy-tree "\\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 "\\|$\$" fail-list mode regexp-unmatchable] 8 (#$ . 49400)])
(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\242\211\313>\203/�\314\315\n#\2025�\314\316\n#\n\f\203L�	T\f@Y\203L�\f\211A\242\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 (#$ . 51497)])
(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\f�\311B\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�\330B*\306\331\211\332@\333A\212\334\335!\205\201�\f\335=\205\201�\334 ?\205\201�\336\335!\205\201�
\335=\205\201�\336 ?)\203\211�\337B-B\203\223�\340B\341\342!\306\211\211CDEFrFq\210\343\344 !\210\345\211ED\345C\313\346\347\"\210\313\350\347\"\210\351c\210eGHG^H\352G\211T\353I$\210)\335e\\GHG^H\352G\211T\353J$\210)eb\210\354`\355\"b\210`\356e\\U\203\357B\202	\321\360!\210\3611\"\313\362\363\"\210\364\365\366\"\205\367B\2110\202&\210\202'\210\3701@\313\362\371\"\210\364\372\366\"\205<\373B\2110\202D\210\202E\210\364\374\375\"\203ked|\210\376c\210\377\306x\210o\203k\201M�\306w\335U\203k\201N�B\307\201K�!\203\334\306\345DKed|\210\343\344 !\210\313\201O�\201P�\"\210\327>\203\246\313\201Q�\201R�\"\210\313\201S�\201T�\"\210\202\276\330>\203\276\313\201Q�\201U�\"\210\313\201S�\201T�\"\210\313\201V�\201W�\"\210\201X�c\210\201Y� \210o\203\333\201Z�B*\201[�\306!\210)\201\\�F!\210,\201]�1\376\212\201^�``\")G0\202\210\202\206\201_�\211L\201`�Y\203\201a�B\202*L\201V�Y\204*\321\201b�!\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 ash -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 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" "[:alnum:]" beginning-of-defun-function end-of-defun-function c-use-category lookup-syntax-properties parse-sexp-ignore-comments parse-sexp-lookup-properties buf -pos- c-syntax-table-hwm c-<-as-paren-syntax c->-as-paren-syntax open-paren-in-column-0-is-defun-start ppss-size "[: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."] 6) (#$ . 52275))
(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 (#$ . 57270)])
(defvar c-lang-constants (make-vector 151 0))
(defvar c-lang-const-expansion nil)
(defalias 'cc-bytecomp-compiling-or-loading #[nil "\203M�\304\301!\203M�	;\203M�\305\306\307!\211\203.�\n@\203(�\nA@\310>\204.�T\202�\nA@\311>\203:�\312\202K�\nA@\313>\203F�\314\202K�\315\316!\210\306*\207\203S�\312\207\304\301!\203`�	;\203`�\314\207\306\207" [load-in-progress byte-compile-dest-file elt n boundp 0 nil backtrace-frame (load require byte-compile-file byte-recompile-directory batch-byte-compile) (load require) loading (byte-compile-file byte-recompile-directory batch-byte-compile) compiling message "cc-bytecomp-compiling-or-loading: System flags spuriously set"] 2])
(defalias 'c-get-current-file #[nil "\304 \211\305\267\202�	\202�\n\202�?\205�\306 \211\205\"�\307\310!!*\207" [c-or-l load-file-name byte-compile-dest-file file cc-bytecomp-compiling-or-loading #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (loading 9 compiling 13)) buffer-file-name file-name-sans-extension file-name-nondirectory] 4])
(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 (#$ . 59382)]))
#@1904 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\306\312 \206�\313\314!!\315\211 9\204&�\313\316\"\210!\242;\203:�\317\n\320!@#\210!A!!\204D�\313\321\"\210!\203\273�!@\311=\203U�\311\202�!@9\203i�\306\307!@!\322P!C\202�!@<\203y�\323\324!@\"\202�\313\325!@\"\315\"#!A\204\221�\313\326!@\"\210!A\211!@\"\327\"\315\"\"\330\211\331#D\332\315\"EEE!A!*\202D�\323\333\n\334N\" 
 >\203\321�
 >A  \237 \335\336\331D \205\347�\331 DC.BBBD\207" [name c-lang-constants sym c-lang-const-expansion c-langs-are-parametric file intern symbol-name call t #[nil "\304 \211\305\267\202�	\202�\n\202�?\205�\306 \211\205\"�\307\310!!*\207" [c-or-l load-file-name byte-compile-dest-file file cc-bytecomp-compiling-or-loading #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (loading 9 compiling 13)) buffer-file-name file-name-sans-extension file-name-nondirectory] 4] 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 #[(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" macroexpand-all cons quote lambda car source eval-and-compile c-define-lang-constant bindings pre-files args val assigned-mode] 7 (#$ . 59645)]))
(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\310 \206�\311\312!!\211\236\211\204F�\203;�@\236\2042�@CBA\211\204#�\313\n\303\fC\211B#\210
\241\210\n\314L\210\n\315N\316\317\320\"\314\203\235�@A\306\307\n!\"\210\n\314L\210\n\315N\203]�@A\321\307\n!\"\204|�\nB\202|�+,\207" [name c-lang-constants sym source file elem intern symbol-name #[nil "\304 \211\305\267\202�	\202�\n\202�?\205�\306 \211\205\"�\307\310!!*\207" [c-or-l load-file-name byte-compile-dest-file file cc-bytecomp-compiling-or-loading #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (loading 9 compiling 13)) buffer-file-name file-name-sans-extension file-name-nondirectory] 4] error "`c-lang-defconst' must be used in a file" put nil dependents make-vector 101 0 intern-soft 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\"	\205%�\310\311	!\312P!\313N\2046�\2036�\306\314	\"\210
\315=\203F�\316\317\320#D\202\273�\321 \211\203T�\310!\322\323\f\324N\"\237)\205d�\316DC\211\204q�\203�\205z�\316DB
\325=\204\224�
\204\215�\203\224�\326 \327=\204\237�\317\316DBB\202\272�\330\331\332\316DE\333\317\316DBBD\317\316DBBF**\207" [name lang c-lang-constants mode sym c-lang-const-expansion 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 #[nil "\304 \211\305\267\202�	\202�\n\202�?\205�\306 \211\205\"�\307\310!!*\207" [c-or-l load-file-name byte-compile-dest-file file cc-bytecomp-compiling-or-loading #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (loading 9 compiling 13)) buffer-file-name file-name-sans-extension file-name-nondirectory] 4] mapcan #[(elem) "	@=?\205�	@C\207" [file elem] 2] source call cc-bytecomp-compiling-or-loading compiling if eq c-version-sym cc-eval-when-compile file args source-files] 7 (#$ . 64150)]))
#@318 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 (#$ . 65705))
(defconst c-lang--novalue "novalue")
(defalias 'c-get-lang-constant #[(name &optional source-files mode) "\204�	\211\204�\306\307!\210\310\311\n!\"\211\305N\312\205%�@@\211\203?�\f\313N>\204?�\314\f\313\f\313NB#\210\203f�@
\236\204]�\314\f\305@C
B\211#\210\f\312L\210A\211\204D�\315\f!\203|�\fJ\236\211\203|�A\202\"\f\236\206\213�\f\316
\312\"B\211B\317N \312!\"\320]\"#\321]# \203\331�\322A!$\323A\312\n$\211!%=\205\325�\323$\241 \324\n$\211!%=)\202\347�\323A\324\n$\211!%=\203\360�\306\325\n#\210\3261\376�! \211!0\202&\327\330\f#\210\331\f!\210\332&@&A\")\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)" (error) message "Eval error in the `c-lang-defconst' for `%S' in %s:" makunbound signal elem c-lang-constants-under-evaluation eval-in-sym source-files source-pos fallback value max-specpdl-size max-lisp-eval-depth backup-source-pos c-lang--novalue err] 7])
(defalias 'c-find-assignment-for-mode #[(source-pos mode match-any-lang _name) "\3062t�\307\234\310\234\311\n\204I�\203p�\310@A\211I\204A�\312@@!\311\313
\311\314#\210*@A\211\204A�@\311CC\211\241\210\307A\211I\210\n@\310\nA\211I\210	@<\203b�	@>\202d�\203�\315\306	A\"\210\202�+0\207" [source-pos assignment assignment-entry file-entry c-lang-constants-under-evaluation file found 0 1 nil symbol-name load t throw mode match-any-lang c-lang--novalue] 4])
(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)

${this.title}

Code Editor : cc-defs.elc