HOME

Mini Shell 1.0
DIR:/proc/self/root/usr/share/emacs/26.1/lisp/progmodes/
Current File : //proc/self/root/usr/share/emacs/26.1/lisp/progmodes/cc-bytecomp.elc
;ELC
;;; Compiled
;;; in Emacs version 26.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 cc-bytecomp-unbound-variables nil)
(defvar cc-bytecomp-original-functions nil)
(defvar cc-bytecomp-original-properties nil)
(defvar cc-bytecomp-loaded-files nil)
(byte-code "\304\211\304\211\304\207" [cc-bytecomp-unbound-variables cc-bytecomp-original-functions cc-bytecomp-original-properties cc-bytecomp-loaded-files nil] 2)
(defvar cc-bytecomp-environment-set nil)
(defalias 'cc-bytecomp-debug-msg '(macro . #[(&rest args) "\301\210\207" [args nil] 2]))
(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])
#@47 Return non-nil if eval'ed during compilation.
(defalias 'cc-bytecomp-is-compiling #[nil "\300 \301=\207" [cc-bytecomp-compiling-or-loading compiling] 2 (#$ . 1474)])
(put 'cc-bytecomp-is-compiling 'byte-optimizer 'byte-compile-inline-expand)
#@116 Return non-nil if eval'ed during loading.
Nil will be returned if we're in a compilation triggered by the loading.
(defalias 'cc-bytecomp-is-loading #[nil "\300 \301=\207" [cc-bytecomp-compiling-or-loading loading] 2 (#$ . 1723)])
(put 'cc-bytecomp-is-loading 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'cc-bytecomp-setup-environment #[nil "\306 \307=?\205\235\310	\203\311\312!\210\n\211\2039\313@!\2042\314\315@D!\210@\316\317\320@!P!L\210A\211\204\211\203o@@@A@\321
!\204g\f\203]\314\322
\fBB!\210\202g
\316\323\320
!P!M\210*A\211\204?\211\203\231@@@@@A@A@\324#\210+A\211\204v\325)\310\207" [p cc-bytecomp-environment-set cc-bytecomp-unbound-variables cc-bytecomp-original-functions temp-macro fun cc-bytecomp-compiling-or-loading loading nil error "Byte compilation environment already set - perhaps a `cc-bytecomp-restore-environment' is forgotten somewhere" boundp eval defvar intern "cc-bytecomp-ignore-var:" symbol-name fboundp defmacro "cc-bytecomp-ignore-fun:" put t cc-bytecomp-original-properties tempdef prop sym] 6])
(defalias 'cc-bytecomp-restore-environment #[nil "\306 \307=?\205\274\310	\211\2032@\311\n!\203*\312\313\314\n!P!\nJ=\203*\315\n!\210)A\211\204\211\203}@@@A@@AA@\316!\203u
\206[\312\317\314!P!K=\203u\f\320=\203p\321!\210\202u\fM\210+A\211\2048\211\203\267@@@@@A@A@@AA\211N=\203\257\322#\210,A\211\204\204\310)\310\207" [p cc-bytecomp-unbound-variables var cc-bytecomp-original-functions def temp-macro cc-bytecomp-compiling-or-loading loading nil boundp intern "cc-bytecomp-ignore-var:" symbol-name makunbound fboundp "cc-bytecomp-ignore-fun:" unbound fmakunbound put fun cc-bytecomp-original-properties origdef tempdef prop sym cc-bytecomp-environment-set] 5])
(defalias 'cc-bytecomp-load #[(_cc-part) "\300\207" [nil] 1])
(defun cc-bytecomp-load (cc-part) (if (and (boundp 'byte-compile-dest-file) (stringp byte-compile-dest-file)) (progn (cc-bytecomp-restore-environment) (let ((load-path (cons (file-name-directory byte-compile-dest-file) load-path)) (cc-file (concat cc-part ".el"))) (if (member cc-file cc-bytecomp-loaded-files) nil (setq cc-bytecomp-loaded-files (cons cc-file cc-bytecomp-loaded-files)) (cc-bytecomp-debug-msg "cc-bytecomp-load: Loading %S" cc-file) (load cc-file nil t t) (cc-bytecomp-debug-msg "cc-bytecomp-load: Loaded %S" cc-file))) (cc-bytecomp-setup-environment) t)))
#@250 Force loading of the corresponding .el file in the current directory
during compilation, but compile in a `require'.  Don't use within
`eval-when-compile'.

Having cyclic cc-require's will result in infinite recursion.  That's
somewhat intentional.
(defalias 'cc-require '(macro . #[(cc-part) "\301\302\303\304DDD\305DE\207" [cc-part progn eval-when-compile cc-bytecomp-load symbol-name require] 5 (#$ . 4194)]))
#@272 If the CONDITION is satisfied at compile time, (i) force the
file CC-PART.el in the current directory to be loaded at compile
time, (ii) generate code to load the file at load time.

CC-PART will normally be a quoted name such as 'cc-fix.
CONDITION should not be quoted.
(defalias 'cc-conditional-require '(macro . #[(cc-part condition) "\302!\203\303\304\302	!!!\210\305	D\207\306\207" [condition cc-part eval cc-bytecomp-load symbol-name require (progn)] 4 (#$ . 4616)]))
#@335 If the CONDITION is satisfied at compile time, (i) force the
file CC-PART.el in the current directory to be loaded at compile
time, (ii) generate an `eval-after-load' form to load CC-PART.el
after the loading of FILE.

CC-PART will normally be a quoted name such as 'cc-fix.  FILE
should be a string.  CONDITION should not be quoted.
(defalias 'cc-conditional-require-after-load '(macro . #[(cc-part file condition) "\303!\203\304\305\303	!!!\210\306\n\307\310	DDE\207\311\207" [condition cc-part file eval cc-bytecomp-load symbol-name eval-after-load quote require (progn)] 5 (#$ . 5100)]))
#@130 A replacement for the `provide' form that restores the environment
after the compilation.  Don't use within `eval-when-compile'.
(defalias 'cc-provide '(macro . #[(feature) "\301\302\303DE\207" [feature progn (eval-when-compile (cc-bytecomp-restore-environment)) provide] 4 (#$ . 5702)]))
#@242 Force loading of the corresponding .el file in the current directory
during compilation.  Don't use outside `eval-when-compile' or
`eval-and-compile'.

Having cyclic cc-load's will result in infinite recursion.  That's
somewhat intentional.
(defalias 'cc-load '(macro . #[(cc-part) "\301\302\303\304DE\305\306BBE\207" [cc-part or and (featurep 'cc-bytecomp) cc-bytecomp-load load (nil t nil)] 5 (#$ . 5999)]))
#@172 Force loading of the corresponding .el file in the current directory
during compilation, but do a compile time `require' otherwise.  Don't
use within `eval-when-compile'.
(defalias 'cc-require-when-compile '(macro . #[(cc-part) "\301\302\303\302\304\305DD\306\307DDE\310DFD\207" [cc-part eval-when-compile if (and (fboundp 'cc-bytecomp-is-compiling) (cc-bytecomp-is-compiling)) not featurep cc-bytecomp-load symbol-name require] 8 (#$ . 6418)]))
#@156 Do a `require' of an external package.
This restores and sets up the compilation environment before and
afterwards.  Don't use within `eval-when-compile'.
(defalias 'cc-external-require '(macro . #[(feature) "\301\302\303D\304BBB\207" [feature progn (eval-when-compile (cc-bytecomp-restore-environment)) require ((eval-when-compile (cc-bytecomp-setup-environment)))] 4 (#$ . 6874)]))
#@133 Binds the symbol as a variable during compilation of the file,
to silence the byte compiler.  Don't use within `eval-when-compile'.
(defalias 'cc-bytecomp-defvar '(macro . #[(var) "\301\302\303\304DD\305\306\304DE\302\307\310\304D\311BBD\312\305\313\304DE\314\315\316\304D\317BBEEE\302\320\312\321D\322\304D\323\324\325\326\304DDEDE\305\327\304DEFE\257D\207" [var eval-when-compile if boundp quote cc-bytecomp-debug-msg "cc-bytecomp-defvar: %s bound already as variable" not memq (cc-bytecomp-unbound-variables) progn "cc-bytecomp-defvar: Saving %s (as unbound)" setq cc-bytecomp-unbound-variables cons (cc-bytecomp-unbound-variables) (cc-bytecomp-is-compiling) defvar set intern concat "cc-bytecomp-ignore-var:" symbol-name "cc-bytecomp-defvar: Covered variable %s"] 17 (#$ . 7266)]))
#@458 Bind the symbol as a function during compilation of the file,
to silence the byte compiler.  Don't use within `eval-when-compile'.

If the symbol already is bound as a function, it will keep that
definition.  That means that this macro will not shut up warnings
about incorrect number of arguments.  It's dangerous to try to replace
existing functions since the byte compiler might need the definition
at compile time, e.g. for macros and inline functions.
(defalias 'cc-bytecomp-defun '(macro . #[(fun) "\301\302\303\304DD\305\306\304DE\302\307\310\304D\311BBD\312\305\313\304DE\314\315\316\317\304D\320BB\321BBEEE\302\322\312\323\304D\324\325\326\327\304DDEDE\305\330\304DEEE\257D\207" [fun eval-when-compile if fboundp quote cc-bytecomp-debug-msg "cc-bytecomp-defun: %s bound already as function" not assq (cc-bytecomp-original-functions) progn "cc-bytecomp-defun: Saving %s (as unbound)" setq cc-bytecomp-original-functions cons list (nil 'unbound) (cc-bytecomp-original-functions) (cc-bytecomp-is-compiling) fset intern concat "cc-bytecomp-ignore-fun:" symbol-name "cc-bytecomp-defun: Covered function %s"] 16 (#$ . 8069)]))
#@117 Set a property on a symbol during compilation (and evaluation) of
the file.  Don't use outside `eval-when-compile'.
(defalias 'cc-bytecomp-put '(macro . #[(symbol propname value) "\303\304\305\306\307	E\310BBD\311\312\313	\314	E\257\315\316\307\211\211	E\307\n\314	EEE\317BBEEE\320	\nF\312\321	\n\257F\207" [symbol propname value eval-when-compile if not assoc cons (cc-bytecomp-original-properties) progn cc-bytecomp-debug-msg "cc-bytecomp-put: Saving property %s for %s with value %s" get setq cc-bytecomp-original-properties (cc-bytecomp-original-properties) put "cc-bytecomp-put: Bound property %s for %s to %s"] 15 (#$ . 9215)]))
#@226 Return non-nil if the given symbol is bound as a variable outside
the compilation.  This is the same as using `boundp' but additionally
exclude any variables that have been bound during compilation with
`cc-bytecomp-defvar'.
(defalias 'cc-bytecomp-boundp '(macro . #[(symbol) "\302 \303=\205\fA@	>?\205\304D\207" [symbol cc-bytecomp-unbound-variables cc-bytecomp-compiling-or-loading compiling boundp] 2 (#$ . 9866)]))
#@226 Return non-nil if the given symbol is bound as a function outside
the compilation.  This is the same as using `fboundp' but additionally
exclude any functions that have been bound during compilation with
`cc-bytecomp-defun'.
(defalias 'cc-bytecomp-fboundp '(macro . #[(symbol) "\303\304 \305=\205	A@\n\236\211\205\306\234\307=?\205\310	D)\207" [fun-elem symbol cc-bytecomp-original-functions nil cc-bytecomp-compiling-or-loading compiling 2 unbound fboundp] 2 (#$ . 10297)]))
(provide 'cc-bytecomp)