Gecko [ fernandoquevedodop.com ]

Name	Size	Permission
advice.elc	54 KB	-rw-r--r--
autoload.elc	28.25 KB	-rw-r--r--
avl-tree.elc	27.45 KB	-rw-r--r--
backquote.elc	4.68 KB	-rw-r--r--
backtrace.elc	40.98 KB	-rw-r--r--
benchmark.elc	3.74 KB	-rw-r--r--
bindat.elc	10.73 KB	-rw-r--r--
byte-opt.elc	39.59 KB	-rw-r--r--
byte-run.elc	17.44 KB	-rw-r--r--
bytecomp.elc	154.17 KB	-rw-r--r--
cconv.elc	20.71 KB	-rw-r--r--
chart.elc	25.98 KB	-rw-r--r--
check-declare.elc	9.01 KB	-rw-r--r--
checkdoc.elc	74.78 KB	-rw-r--r--
cl-extra.elc	29.37 KB	-rw-r--r--
cl-generic.elc	59.25 KB	-rw-r--r--
cl-indent.elc	18.03 KB	-rw-r--r--
cl-lib.elc	31.72 KB	-rw-r--r--
cl-loaddefs.el	45.79 KB	-rw-r--r--
cl-macs.elc	90.7 KB	-rw-r--r--
cl-preloaded.elc	27.28 KB	-rw-r--r--
cl-print.elc	14.77 KB	-rw-r--r--
cl-seq.elc	38.35 KB	-rw-r--r--
copyright.elc	10.17 KB	-rw-r--r--
crm.elc	7.62 KB	-rw-r--r--
cursor-sensor.elc	6.74 KB	-rw-r--r--
debug.elc	36.42 KB	-rw-r--r--
derived.elc	11.88 KB	-rw-r--r--
disass.elc	6.11 KB	-rw-r--r--
easy-mmode.elc	19.78 KB	-rw-r--r--
easymenu.elc	19.88 KB	-rw-r--r--
edebug.elc	123.13 KB	-rw-r--r--
eieio-base.elc	17.17 KB	-rw-r--r--
eieio-compat.elc	8.41 KB	-rw-r--r--
eieio-core.elc	36.91 KB	-rw-r--r--
eieio-custom.elc	15.8 KB	-rw-r--r--
eieio-datadebug.elc	3.17 KB	-rw-r--r--
eieio-loaddefs.el	3.96 KB	-rw-r--r--
eieio-opt.elc	9.32 KB	-rw-r--r--
eieio-speedbar.elc	13.13 KB	-rw-r--r--
eieio.elc	33.03 KB	-rw-r--r--
eldoc.elc	19.14 KB	-rw-r--r--
elint.elc	30.6 KB	-rw-r--r--
elp.elc	12.68 KB	-rw-r--r--
ert-x.elc	11.48 KB	-rw-r--r--
ert.elc	177.96 KB	-rw-r--r--
ewoc.elc	25.26 KB	-rw-r--r--
faceup.elc	16.97 KB	-rw-r--r--
find-func.elc	21.61 KB	-rw-r--r--
float-sup.elc	1.21 KB	-rw-r--r--
generator.elc	27.42 KB	-rw-r--r--
generic.elc	7.18 KB	-rw-r--r--
gv.elc	22.69 KB	-rw-r--r--
helper.elc	3.96 KB	-rw-r--r--
inline.elc	8.37 KB	-rw-r--r--
let-alist.elc	3.04 KB	-rw-r--r--
lisp-mnt.elc	22.59 KB	-rw-r--r--
lisp-mode.elc	38.03 KB	-rw-r--r--
lisp.elc	21.44 KB	-rw-r--r--
macroexp.elc	18.01 KB	-rw-r--r--
map-ynp.elc	10.54 KB	-rw-r--r--
map.elc	18.25 KB	-rw-r--r--
nadvice.elc	17.65 KB	-rw-r--r--
package-x.elc	9.06 KB	-rw-r--r--
package.elc	146.54 KB	-rw-r--r--
pcase.elc	23.11 KB	-rw-r--r--
pp.elc	5.5 KB	-rw-r--r--
radix-tree.elc	5.88 KB	-rw-r--r--
re-builder.elc	25.78 KB	-rw-r--r--
regexp-opt.elc	6.3 KB	-rw-r--r--
regi.elc	6 KB	-rw-r--r--
ring.elc	6.32 KB	-rw-r--r--
rmc.elc	4.79 KB	-rw-r--r--
rx.elc	40.69 KB	-rw-r--r--
seq.elc	23.64 KB	-rw-r--r--
shadow.elc	9.34 KB	-rw-r--r--
smie.elc	48.84 KB	-rw-r--r--
subr-x.elc	11.17 KB	-rw-r--r--
syntax.elc	26.13 KB	-rw-r--r--
tabulated-list.elc	26.57 KB	-rw-r--r--
tcover-ses.elc	14.29 KB	-rw-r--r--
tcover-unsafep.elc	3.87 KB	-rw-r--r--
testcover.elc	23.03 KB	-rw-r--r--
text-property-search.elc	8.13 KB	-rw-r--r--
thunk.elc	3.06 KB	-rw-r--r--
timer-list.elc	4.3 KB	-rw-r--r--
timer.elc	21.65 KB	-rw-r--r--
tq.elc	3.99 KB	-rw-r--r--
trace.elc	7.27 KB	-rw-r--r--
unsafep.elc	4.45 KB	-rw-r--r--
warnings.elc	9.75 KB	-rw-r--r--

Code Editor : advice.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.

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

(byte-code "\300\301!\210\302\303\304\305\306\307\310\311\312\313&	\207" [require macroexp custom-declare-group advice nil "An overloading mechanism for Emacs Lisp functions." :prefix "ad-" :link (custom-manual "(elisp)Advising Functions") :group lisp] 10)
(defconst ad-version "2.14")
(byte-code "\300\301\302\303\304DD\305\306\307\310\311&\210\300\312\302\303\313DD\314\306\315\310\311&\207" [custom-declare-variable ad-redefinition-action funcall function #[0 "\300\207" [warn] 1] "Defines what to do with redefinitions during Advice de/activation.\nRedefinition occurs if a previously activated function that already has an\noriginal definition associated with it gets redefined and then de/activated.\nIn such a case we can either accept the current definition as the new\noriginal definition, discard the current definition and replace it with the\nold original, or keep it and raise an error.  The values `accept', `discard',\n`error' or `warn' govern what will be done.  `warn' is just like `accept' but\nit additionally prints a warning message.  All other values will be\ninterpreted as `error'." :type (choice (const accept) (const discard) (const warn) (other :tag "error" error)) :group advice ad-default-compilation-action #[0 "\300\207" [maybe] 1] "Defines whether to compile advised definitions during activation.\nA value of `always' will result in unconditional compilation, `never' will\nalways avoid compilation, `maybe' will compile if the byte-compiler is already\nloaded, and `like-original' will compile if the original definition of the\nadvised function is compiled or a built-in function.  Every other value will\nbe interpreted as `maybe'.  This variable will only be considered if the\nCOMPILE argument of `ad-activate' was supplied as nil." (choice (const always) (const never) (const like-original) (other :tag "maybe" maybe))] 8)
#@416 Substitute qualifying subTREEs with result of FUNCTION(subTREE).
Only proper subtrees are considered, for example, if TREE is (1 (2 (3)) 4)
then the subtrees will be 1 (2 (3)) 2 (3) 3 4, dotted structures are
allowed too.  Once a qualifying subtree has been found its subtrees will
not be considered anymore.  (ad-substitute-tree \='atom \='identity tree)
generates a copy of TREE.

(fn SUBTREE-TEST FUNCTION TREE)
(defalias 'ad-substitute-tree #[771 "\211:\203,�@!\203�@!\202$�\211@:\203\"�\300@#\202$�\211@\300A#B\207!\2036�!\207\207" [ad-substitute-tree] 8 (#$ . 2273)])
(defvar ad-advised-functions nil)
#@81 Add FUNCTION to `ad-advised-functions' unless its already there.

(fn FUNCTION)
(defalias 'ad-pushnew-advised-function #[257 "\301!\211\235\203
�\202�\211B\211\207" [ad-advised-functions symbol-name] 4 (#$ . 2902)])
#@61 Remove FUNCTION from `ad-advised-functions'.

(fn FUNCTION)
(defalias 'ad-pop-advised-function #[257 "\301\302!\"\211\207" [ad-advised-functions delete symbol-name] 4 (#$ . 3130)])
#@215 `dolist'-style iterator that maps over advised functions.
(ad-do-advised-functions (VAR)
   BODY-FORM...)
On each iteration VAR will be bound to the name of an advised function
(a symbol).

(fn VARFORM &rest BODY)
(defalias 'ad-do-advised-functions '(macro . #[385 "\300@\301B\302@\303@DEBBB\207" [dolist (ad-advised-functions) setq intern] 8 (#$ . 3321)]))
(byte-code "\300\301\302\303#\300\207" [function-put ad-do-advised-functions lisp-indent-function 1] 4)
#@17

(fn FUNCTION)
(defalias 'ad-get-advice-info #[257 "\211\300N\207" [ad-advice-info] 3 (#$ . 3794)])
(byte-code "\300\301\302\303#\210\304\305\301\306#\210\307\305\301\310#\207" [put ad-get-advice-info byte-optimizer byte-compile-inline-expand defalias ad-get-advice-info-macro nil make-obsolete "27.1"] 4)
#@29

(fn FUNCTION ADVICE-INFO)
(defalias 'ad-set-advice-info #[514 "\211\203)�\300\301\302\303\304\305\306!\307\"\310$\302\311\312\305\306!\313\"\314\315%B\262\316\317$\210\202F�\320N\203F�\321\320N\316\"\211\320N=\204D�\322\320#\210\266\322\323#\207" [advice--add-function :around make-byte-code 0 "\300\301N\207" vconcat vector [defalias-fset-function] 2 257 "\301\300\302#\207" [put defalias-fset-function] 5 "\n\n(fn GV--VAL)" ad--defalias-fset nil defalias-fset-function advice--remove-function put ad-advice-info] 12 (#$ . 4107)])
(put 'ad-set-advice-info 'byte-optimizer 'byte-compile-inline-expand)
#@17

(fn FUNCTION)
(defalias 'ad-copy-advice-info #[257 "\300\301N!\207" [copy-tree ad-advice-info] 4 (#$ . 4732)])
(byte-code "\300\301\302\303#\210\304\305\306\307#\207" [put ad-copy-advice-info byte-optimizer byte-compile-inline-expand defalias ad-is-advised ad-get-advice-info "Return non-nil if FUNCTION has any advice info associated with it.\nThis does not mean that the advice is also active."] 4)
#@105 Initialize the advice info for FUNCTION.
Assumes that FUNCTION has not yet been advised.

(fn FUNCTION)
(defalias 'ad-initialize-advice-info #[257 "\300!\210\211\301\302BC\211\2032�\303\304\305\306\307\310\311!\312\"\313$\305\314\315\310\311!\316\"\317\320%B\262\321\302$\210\202O�\322N\203O�\323\322N\321\"\211\322N=\204M�\324\322#\210\266\324\325#\207" [ad-pushnew-advised-function active nil advice--add-function :around make-byte-code 0 "\300\301N\207" vconcat vector [defalias-fset-function] 2 257 "\301\300\302#\207" [put defalias-fset-function] 5 "\n\n(fn GV--VAL)" ad--defalias-fset defalias-fset-function advice--remove-function put ad-advice-info] 13 (#$ . 5143)])
#@79 Retrieve the value of the advice info FIELD of FUNCTION.

(fn FUNCTION FIELD)
(defalias 'ad-get-advice-info-field #[514 "\211\211\300N\262\236A\207" [ad-advice-info] 6 (#$ . 5840)])
(put 'ad-get-advice-info-field 'byte-optimizer 'byte-compile-inline-expand)
#@93 Destructively modify VALUE of the advice info FIELD of FUNCTION.

(fn FUNCTION FIELD VALUE)
(defalias 'ad-set-advice-info-field #[771 "\211\300N\262\211\205�\236\203�\236\241\202�\211BC\244\207" [ad-advice-info] 7 (#$ . 6106)])
#@69 Return non-nil if FUNCTION is advised and activated.

(fn FUNCTION)
(defalias 'ad-is-active #[257 "\211\300\211\211\301N\262\236A\207" [active ad-advice-info] 7 (#$ . 6352)])
#@300 Constructs single piece of advice to be stored in some advice-info.
NAME should be a non-nil symbol, PROTECT and ENABLE should each be
either t or nil, and DEFINITION should be a list of the form
`(advice lambda ARGLIST [DOCSTRING] [INTERACTIVE-FORM] BODY...)'.

(fn NAME PROTECT ENABLE DEFINITION)
(defalias 'ad-make-advice #[1028 "F\207" [] 8 (#$ . 6536)])
#@15

(fn ADVICE)
(defalias 'ad-advice-name #[257 "\211@\207" [] 2 (#$ . 6905)])
(put 'ad-advice-name 'byte-optimizer 'byte-compile-inline-expand)
#@15

(fn ADVICE)
(defalias 'ad-advice-protected #[257 "\211A@\207" [] 2 (#$ . 7054)])
(put 'ad-advice-protected 'byte-optimizer 'byte-compile-inline-expand)
#@15

(fn ADVICE)
(defalias 'ad-advice-enabled #[257 "\3008\207" [2] 3 (#$ . 7214)])
(put 'ad-advice-enabled 'byte-optimizer 'byte-compile-inline-expand)
#@15

(fn ADVICE)
(defalias 'ad-advice-definition #[257 "\3008\207" [3] 3 (#$ . 7371)])
(put 'ad-advice-definition 'byte-optimizer 'byte-compile-inline-expand)
#@20

(fn ADVICE FLAG)
(defalias 'ad-advice-set-enabled #[514 "AA\240\207" [] 4 (#$ . 7534)])
#@33 List of defined advice classes.
(defvar ad-advice-classes '(before around after activation deactivation) (#$ . 7632))
#@14

(fn THING)
(defalias 'ad-class-p #[257 "\211>\207" [ad-advice-classes] 3 (#$ . 7756)])
#@14

(fn THING)
(defalias 'ad-name-p #[257 "\211\205�\2119\207" [] 2 (#$ . 7852)])
#@14

(fn THING)
(defalias 'ad-position-p #[257 "\300!\206	�\211\301>\207" [natnump (first last)] 3 (#$ . 7939)])
#@86 True if at least one of FUNCTION's advices in CLASS is enabled.

(fn FUNCTION CLASS)
(defalias 'ad-has-enabled-advice #[514 "\3002/�\211\211\301N\262\236A\266\202\211\205,�\211@\211\3028\262\203%�\303\300\304\"\210A\266\202\202�\2620\207" [--cl-block-nil-- ad-advice-info 2 throw t] 8 (#$ . 8056)])
#@154 True if FUNCTION's advice info defines at least 1 redefining advice.
Redefining advices affect the construction of an advised definition.

(fn FUNCTION)
(defalias 'ad-has-redefining-advice #[257 "\300!\205�\301\302\"\206�\301\303\"\206�\301\304\"\207" [ad-is-advised ad-has-enabled-advice before around after] 4 (#$ . 8371)])
#@81 True if the advice info of FUNCTION defines at least one advice.

(fn FUNCTION)
(defalias 'ad-has-any-advice #[257 "\301!\2050�\30220�\211\205-�\211@\211\211\303N\262\236A\266\202\203&�\304\302\305\"\210A\266\202\202�\2620\207" [ad-advice-classes ad-is-advised --cl-block-nil-- ad-advice-info throw t] 9 (#$ . 8710)])
#@79 Return the list of enabled advices of FUNCTION in CLASS.

(fn FUNCTION CLASS)
(defalias 'ad-get-enabled-advices #[514 "\300\211\211\301N\262\236A\266\202\211\203)�\211@\211\3028\262\203\"�\211B\262A\266\202\202�\210\303!\207" [nil ad-advice-info 2 reverse] 9 (#$ . 9043)])
(defalias 'ad-activate-internal 'ad-activate)
#@76 Make name to be used to call the assembled advice function.

(fn FUNCTION)
(defalias 'ad-make-advicefunname #[257 "\300\301\302\"!\207" [intern format "ad-Advice-%s"] 5 (#$ . 9379)])
#@17

(fn FUNCTION)
(defalias 'ad-get-orig-definition #[257 "\2119\203�\300!\205�\211K\211\242\301=\203�\211A\262\262\302!\203-�\211\211\303H\303H\262\262\202�\207" [fboundp macro advice--p 2] 4 (#$ . 9569)])
#@17

(fn FUNCTION)
(defalias 'ad-clear-advicefunname-definition #[257 "\211\300\211\211\301N\262\236A\266\202\302\"\210\303!\207" [advicefunname ad-advice-info advice-remove fmakunbound] 7 (#$ . 9790)])
#@377 Read name of advised function with completion from the minibuffer.
An optional PROMPT will be used to prompt for the function.  PREDICATE
plays the same role as for `try-completion' (which see).  DEFAULT will
be returned on empty input (defaults to the first advised function or
function at point for which PREDICATE returns non-nil).

(fn &optional PROMPT PREDICATE DEFAULT)
(defalias 'ad-read-advised-function #[768 "\204�\301\302!\210\211\206^�\303\304!\210\305 \211\205)�\306!\235\205)�\203(�!\205)�\211\262\206^�\3072W�\211\205T�\211@\310!\262\203H�!\203M�\311\307\"\210A\266\202\2023�\2620\206^�\301\312\313\"\262\314\315\316\206h�\317#\205|�\320\321\322\323\324	!\325\"\326\327%\330$\211\331\232\203\225�\332!\203\216�\202\230�\301\333\"\202\230�\310!\207" [ad-advised-functions error "ad-read-advised-function: There are no advised functions" require help function-called-at-point symbol-name --cl-block-nil-- intern throw "ad-read-advised-function: %s" "There are no qualifying advised functions" completing-read format "%s (default %s): " "Function" make-byte-code 257 "\300\301@!!\207" vconcat vector [intern] 4 "\n\n(fn FUNCTION)" t "" ad-is-advised "ad-read-advised-function: `%s' is not advised"] 12 (#$ . 10002)])
(defvar ad-advice-class-completion-table (mapcar #[257 "\300!C\207" [symbol-name] 3 "\n\n(fn CLASS)"] ad-advice-classes))
#@262 Read a valid advice class with completion from the minibuffer.
An optional PROMPT will be used to prompt for the class.  DEFAULT will
be returned on empty input (defaults to the first non-empty advice
class of FUNCTION).

(fn FUNCTION &optional PROMPT DEFAULT)
(defalias 'ad-read-advice-class #[769 "\211\2065�\3022.�\211\205+�\211@\211\211\303N\262\236A\266\202\203$�\304\302\"\210A\266\202\202	�\2620\2065�\305\306\"\262\307\310\311\206?�\312#	\313\314$\211\315\232\203O�\202R�\316!\207" [ad-advice-classes ad-advice-class-completion-table --cl-block-nil-- ad-advice-info throw error "ad-read-advice-class: `%s' has no advices" completing-read format "%s (default %s): " "Class" nil t "" intern] 11 (#$ . 11389)])
#@158 Read name of existing advice of CLASS for FUNCTION with completion.
An optional PROMPT is used to prompt for the name.

(fn FUNCTION CLASS &optional PROMPT)
(defalias 'ad-read-advice-name #[770 "\300\301\211\211\302N\262\236A\266\202\"\211\204�\303\304#\202�\211@@\305\306\206&�\307#\310\311\312$\211\313\232\203:�\314!\202=�\314!\207" [mapcar #[257 "\300\211@\262!C\207" [symbol-name] 4 "\n\n(fn ADVICE)"] ad-advice-info error "ad-read-advice-name: `%s' has no %s advice" format "%s (default %s): " "Name" completing-read nil t "" intern] 11 (#$ . 12126)])
#@196 Read a complete function/class/name specification from minibuffer.
The list of read symbols will be returned.  The optional PROMPT will
be used to prompt for the function.

(fn &optional PROMPT)
(defalias 'ad-read-advice-specification #[256 "\300!\301!\302\"E\207" [ad-read-advised-function ad-read-advice-class ad-read-advice-name] 7 (#$ . 12707)])
(defvar ad-last-regexp "")
#@71 Read a regular expression from the minibuffer.

(fn &optional PROMPT)
(defalias 'ad-read-regexp #[256 "\301\206�\302\303\232\203�\304\202�\305\306\"P!\211\303\232\203 �\202!�\211\211\207" [ad-last-regexp read-from-minibuffer "Regular expression" "" ": " format " (default %s): "] 6 (#$ . 13097)])
#@81 Find the first advice of FUNCTION in CLASS with NAME.

(fn FUNCTION CLASS NAME)
(defalias 'ad-find-advice #[771 "\211\211\211\300N\262\236A\266\202\236\207" [ad-advice-info] 10 (#$ . 13408)])
(put 'ad-find-advice 'byte-optimizer 'byte-compile-inline-expand)
#@91 Return position of first advice of FUNCTION in CLASS with NAME.

(fn FUNCTION CLASS NAME)
(defalias 'ad-advice-position #[771 "\211\211\211\300N\262\236A\266\202\236\266\203\211\211\300N\262\236A\266\202\205,�\211G>GZ\207" [ad-advice-info] 13 (#$ . 13676)])
#@226 Find the first of FUNCTION's advices in CLASS matching NAME.
NAME can be a symbol or a regular expression matching part of an advice name.
If CLASS is `any' all valid advice classes will be checked.

(fn FUNCTION CLASS NAME)
(defalias 'ad-find-some-advice #[771 "\301!\205x�\302\3032v�\211\205s�\211@\304=\204�\211=\203c�\3032a�\211\211\305N\262\236A\266\202\211\205^�\211@;\203H�\306\307\211@\262!\"\204R�\211@\262=\203W�\310\303\"\210A\266\202\202/�\2620\262\203l�\310\303\"\210A\266\202\202\f�\2620\262\207" [ad-advice-classes ad-is-advised nil --cl-block-nil-- any ad-advice-info string-match symbol-name throw] 13 (#$ . 13955)])
#@410 Set enable FLAG of FUNCTION's advices in CLASS matching NAME.
If NAME is a string rather than a symbol then it's interpreted as a regular
expression and all advices whose name contain a match for it will be
affected.  If CLASS is `any' advices in all valid advice classes will be
considered.  The number of changed advices will be returned (or nil if
FUNCTION was not advised).

(fn FUNCTION CLASS NAME FLAG)
(defalias 'ad-enable-advice-internal #[1028 "\301!\205k�\302\211\203g�\211@\303=\204�\211=\203`�\211\211\304N\262\236A\266\202\211\203_�\211@;\203C�\305\306\211@\262!\"\204N�\211@\262=\203X�T\262\307\"\210A\266\202\202)�\210A\266\202\202�\210\211\262\207" [ad-advice-classes ad-is-advised 0 any ad-advice-info string-match symbol-name ad-advice-set-enabled] 14 (#$ . 14622)])
#@79 Enables the advice of FUNCTION with CLASS and NAME.

(fn FUNCTION CLASS NAME)
(defalias 'ad-enable-advice #[771 "\300!\203�\301\302$\303=\205�\304\305$\207\304\306\"\207" [ad-is-advised ad-enable-advice-internal t 0 error "ad-enable-advice: `%s' has no %s advice matching `%s'" "ad-enable-advice: `%s' is not advised"] 8 (#$ . 15443) (ad-read-advice-specification "Enable advice of")])
#@79 Disable the advice of FUNCTION with CLASS and NAME.

(fn FUNCTION CLASS NAME)
(defalias 'ad-disable-advice #[771 "\300!\203�\301\302$\303=\205�\304\305$\207\304\306\"\207" [ad-is-advised ad-enable-advice-internal nil 0 error "ad-disable-advice: `%s' has no %s advice matching `%s'" "ad-disable-advice: `%s' is not advised"] 8 (#$ . 15845) (ad-read-advice-specification "Disable advice of")])
#@208 Set enable FLAGs of all CLASS advices whose name contains a REGEXP match.
If CLASS is `any' all valid advice classes are considered.  The number of
affected advices will be returned.

(fn REGEXP CLASS FLAG)
(defalias 'ad-enable-regexp-internal #[771 "\301\211\203%�\211@\302!\262\303	$\206�\301\\\262A\266\202\202�\210\211\207" [ad-advised-functions 0 intern ad-enable-advice-internal] 12 (#$ . 16254)])
#@130 Enables all advices with names that contain a match for REGEXP.
All currently advised functions will be considered.

(fn REGEXP)
(defalias 'ad-enable-regexp #[257 "\300\301\302#\303\304!\203�\305\306\"\210\211\207" [ad-enable-regexp-internal any t called-interactively-p interactive message "%d matching advices enabled"] 5 (#$ . 16679) (byte-code "\300\301!C\207" [ad-read-regexp "Enable advices via regexp"] 2)])
#@130 Disable all advices with names that contain a match for REGEXP.
All currently advised functions will be considered.

(fn REGEXP)
(defalias 'ad-disable-regexp #[257 "\300\301\302#\303\304!\203�\305\306\"\210\211\207" [ad-enable-regexp-internal any nil called-interactively-p interactive message "%d matching advices disabled"] 5 (#$ . 17104) (byte-code "\300\301!C\207" [ad-read-regexp "Disable advices via regexp"] 2)])
#@176 Remove FUNCTION's advice with NAME from its advices in CLASS.
If such an advice was found it will be removed from the list of advices
in that CLASS.

(fn FUNCTION CLASS NAME)
(defalias 'ad-remove-advice #[771 "\300!\203>�\211\211\211\301N\262\236A\266\202\236\266\203\211\2037�\302\303\211\211\301N\262\236A\266\202\"#\202=�\304\305$\207\304\306\"\207" [ad-is-advised ad-advice-info ad-set-advice-info-field delq error "ad-remove-advice: `%s' has no %s advice `%s'" "ad-remove-advice: `%s' is not advised"] 15 (#$ . 17534) (ad-read-advice-specification "Remove advice of")])
#@1016 Add a piece of ADVICE to FUNCTION's list of advices in CLASS.

ADVICE has the form (NAME PROTECTED ENABLED DEFINITION), where
NAME is the advice name; PROTECTED is a flag specifying whether
to protect against non-local exits; ENABLED is a flag specifying
whether to initially enable the advice; and DEFINITION has the
form (advice . LAMBDA), where LAMBDA is a lambda expression.

If FUNCTION already has a piece of advice with the same name,
then POSITION is ignored, and the old advice is overwritten with
the new one.

If FUNCTION already has one or more pieces of advice of the
specified CLASS, then POSITION determines where the new piece
goes.  POSITION can either be `first', `last' or a number (where
0 corresponds to `first', and numbers outside the valid range are
mapped to the closest extremal position).

If FUNCTION was not advised already, its advice info will be
initialized.  Redefining a piece of advice whose name is part of
the cache-id will clear the cache.

(fn FUNCTION ADVICE CLASS POSITION)
(defalias 'ad-add-advice #[1028 "\300!\204�\301!\210\302\303\304!#\210\305\211@\262#\211\211\306N\262\236A\266\202\206K�\307\267\202<�\310\202K�\211G\202K�\247\203J�\310G^]\202K�\310\211@\262\311\">\203_�\312!\210\203l�\211\233\240\202\212�\211\310U\203�\302B#\202\212�\211S\233\233B\241\207" [ad-is-advised ad-initialize-advice-info ad-set-advice-info-field advicefunname ad-make-advicefunname ad-advice-position ad-advice-info #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (first 51 last 55)) 0 ad-get-cache-class-id ad-clear-cache] 12 (#$ . 18138)])
#@80 Take a lambda function DEFINITION and make a macro out of it.

(fn DEFINITION)
(defalias 'ad-macrofy #[257 "\300B\207" [macro] 3 (#$ . 19795)])
(byte-code "\300\301\302\303#\210\304\305\306\307#\207" [put ad-macrofy byte-optimizer byte-compile-inline-expand defalias ad-lambdafy cdr "Take a macro function DEFINITION and make a lambda out of it."] 4)
#@19

(fn DEFINITION)
(defalias 'ad-lambda-p #[257 "\211\242\300=\207" [lambda] 3 (#$ . 20153)])
(put 'ad-lambda-p 'byte-optimizer 'byte-compile-inline-expand)
#@19

(fn DEFINITION)
(defalias 'ad-advice-p #[257 "\211\242\300=\207" [advice] 3 (#$ . 20315)])
(put 'ad-advice-p 'byte-optimizer 'byte-compile-inline-expand)
#@79 Return non-nil if DEFINITION is a compiled byte-code object.

(fn DEFINITION)
(defalias 'ad-compiled-p #[257 "\300!\206�\301!\205�\300\302!!\207" [byte-code-function-p macrop ad-lambdafy] 4 (#$ . 20477)])
(put 'ad-compiled-p 'byte-optimizer 'byte-compile-inline-expand)
#@81 Return the byte-code object of a COMPILED-DEFINITION.

(fn COMPILED-DEFINITION)
(defalias 'ad-compiled-code #[257 "\300!\203\n�\301!\207\207" [macrop ad-lambdafy] 3 (#$ . 20758)])
(put 'ad-compiled-code 'byte-optimizer 'byte-compile-inline-expand)
#@86 Return the lambda expression of a function/macro/advice DEFINITION.

(fn DEFINITION)
(defalias 'ad-lambda-expression #[257 "\211\211\242\300=\262\203�\207\301!\203�\302!\207\211\211\242\303=\262\203\"�\211A\207\304\207" [lambda macrop ad-lambdafy advice nil] 4 (#$ . 21014)])
#@58 Return the argument list of DEFINITION.

(fn DEFINITION)
(defalias 'ad-arglist #[257 "\300\301!\204�\211\242\302=\262\203�A\202�\303\"\207" [help-function-arglist macrop advice preserve-names] 5 (#$ . 21302)])
#@65 Return the unexpanded docstring of DEFINITION.

(fn DEFINITION)
(defalias 'ad-docstring #[257 "\211\300!\206�\301!\205�\300\302!!\262\203�\303\304\"\202$�\305!AA@\211;\204/�\306!\2050�\211\207" [byte-code-function-p macrop ad-lambdafy documentation t ad-lambda-expression natnump] 5 (#$ . 21526)])
#@122 Return the interactive form of DEFINITION.
Like `interactive-form', but also works on pieces of advice.

(fn DEFINITION)
(defalias 'ad-interactive-form #[257 "\300\211\242\301=\262\203�\302!\202�!\207" [interactive-form advice ad-lambda-expression] 5 (#$ . 21841)])
#@63 Return the list of body forms of DEFINITION.

(fn DEFINITION)
(defalias 'ad-body-forms #[257 "\211\300!\206�\301!\205�\300\302!!\262\203�\303\207\211:\205;�\304!\203(�\305\202)�\306\307!\2033�\305\2024�\306\\\310!AA\233\207" [byte-code-function-p macrop ad-lambdafy nil ad-docstring 1 0 ad-interactive-form ad-lambda-expression] 5 (#$ . 22119)])
#@71 Return symbol that describes the type of DEFINITION.

(fn DEFINITION)
(defalias 'ad-definition-type #[257 "\300!\203�\301\207\302!\203�\303\207\211\211\242\304=\262\2041�\211\305!\206,�\300!\205,�\305\306!!\262\2033�\307\207\211\211\242\310=\262\205>�\311\207" [macrop macro2 subrp subr2 lambda byte-code-function-p ad-lambdafy fun2 advice advice2] 5 (#$ . 22481)])
#@132 True if FUNCTION is a symbol with a proper definition.
For that it has to be fbound with a non-autoload definition.

(fn FUNCTION)
(defalias 'ad-has-proper-definition #[257 "\2119\205�\300!\205�\211K\211\242\301=\262?\207" [fboundp autoload] 4 (#$ . 22864)])
#@84 Find FUNCTION's definition at the end of function cell indirection.

(fn FUNCTION)
(defalias 'ad-real-definition #[257 "\300!\205�\211K\2119\203�\301!\202�\211\262\207" [ad-has-proper-definition ad-real-definition] 4 (#$ . 23133)])
#@17

(fn FUNCTION)
(defalias 'ad-real-orig-definition #[257 "\300!\301!\211\211\242\302=\262?\205�\211\207" [ad-get-orig-definition indirect-function autoload] 6 (#$ . 23377)])
#@85 True if FUNCTION has an interpreted definition that can be compiled.

(fn FUNCTION)
(defalias 'ad-is-compilable #[257 "\300!\205.�\211K\211\242\301=\262\204�\302K!\205.�\211K\303!\206+�\302!\205+�\303\304!!\262?\207" [ad-has-proper-definition lambda macrop byte-code-function-p ad-lambdafy] 5 (#$ . 23561)])
#@60 Byte-compile the assembled advice function.

(fn FUNCTION)
(defalias 'ad-compile-function #[257 "\302\303!\210\304\305\306!\203�\307\310!\210\311\312\211\211\313N\262\236A\266\202!*\207" [byte-compile-warnings warning-suppress-types require bytecomp ((bytecomp)) featurep cl byte-compile-disable-warning cl-functions byte-compile advicefunname ad-advice-info] 8 (#$ . 23883)])
#@276 Parse ARGLIST into its required, optional and rest parameters.
A three-element list is returned, where the 1st element is the list of
required arguments, the 2nd is the list of optional arguments, and the 3rd
is the name of an optional rest parameter (or nil).

(fn ARGLIST)
(defalias 'ad-parse-arglist #[257 "\300\211\211\301>A@\262\211\203�\302\301\302!>A!\262\303>A\262\2031�\302\303\302!>A!\262\2024�\262E\207" [nil &rest reverse &optional] 8 (#$ . 24274)])
#@432 Generate a form which evaluates into names/values/types of ARGLIST.
When the form gets evaluated within a function with that argument list
it will result in a list with one entry for each argument, where the
first element of each entry is the name of the argument, the second
element is its actual current value, and the third element is either
`required', `optional' or `rest' depending on the type of the argument.

(fn ARGLIST)
(defalias 'ad-retrieve-args-form #[257 "\300!\3018\302\303\304\305@\"\304\306A@\"\205$�\302\307D\310BBBC#B\207" [ad-parse-arglist 2 list append mapcar #[257 "\300\301D\302BBB\207" [list quote ('required)] 5 "\n\n(fn REQ)"] #[257 "\300\301D\302BBB\207" [list quote ('optional)] 5 "\n\n(fn OPT)"] quote ('rest)] 11 (#$ . 24760)])
#@22

(fn BINDING FIELD)
(defalias 'ad-arg-binding-field #[514 "\211\300\267\202�@\207A@\207AA@\207\301\207" [#s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (name 6 value 9 type 13)) nil] 4 (#$ . 25539)])
#@22

(fn POSITION LIST)
(defalias 'ad-list-access #[514 "\300U\203�\207\301U\203�\302D\207\303E\207" [0 1 cdr nthcdr] 5 (#$ . 25788)])
#@22

(fn POSITION LIST)
(defalias 'ad-element-access #[514 "\300U\203\n�\301D\207\302U\203�\301\303DD\207\304E\207" [0 car 1 cdr nth] 5 (#$ . 25933)])
#@217 Tell how to access ARGLIST's actual argument at position INDEX.
For a required/optional arg it simply returns it, if a rest argument has
to be accessed, it returns a list with the index and name.

(fn ARGLIST INDEX)
(defalias 'ad-access-argument #[514 "\300!\301@A@\"\3028GW\203�8\202$�\211\205$�GZD\207" [ad-parse-arglist append 2] 7 (#$ . 26095)])
#@112 Return form to access ARGLIST's actual argument at position INDEX.
INDEX counts from zero.

(fn ARGLIST INDEX)
(defalias 'ad-get-argument #[514 "\300\"\211:\203�\301@A@\"\202�\211\207" [ad-access-argument ad-element-access] 6 (#$ . 26464)])
#@120 Return form to set ARGLIST's actual arg at INDEX to VALUE-FORM.
INDEX counts from zero.

(fn ARGLIST INDEX VALUE-FORM)
(defalias 'ad-set-argument #[771 "\300\"\211:\203�\301\302@A@\"E\202'�\211\203!�\303E\202'�\304\305#\207" [ad-access-argument setcar ad-list-access setq error "ad-set-argument: No argument at position %d of `%s'"] 8 (#$ . 26718)])
#@92 Return form to access all actual arguments starting at position INDEX.

(fn ARGLIST INDEX)
(defalias 'ad-get-arguments #[514 "\300!\301@A@\"\3028\303GW\203�\304\233B\262\2036�\211\203-�\305E\262\2026�\306GZ\"\262\207" [ad-parse-arglist append 2 nil list nconc ad-list-access] 9 (#$ . 27085)])
#@142 Make form to assign elements of VALUES-FORM as actual ARGLIST args.
The assignment starts at position INDEX.

(fn ARGLIST INDEX VALUES-FORM)
(defalias 'ad-set-arguments #[771 "\300\301\211\302\"\211\262\203U�9\203\"�\303\304\305\"#\202F�\301\262@\300U\2038�\306A@\307\305\"E\202F�\310\307@SA@\"\307\305\"EB\262T\262T\262\202�\211\204c�\311\312#\202\214�\211G\313U\203�\314\315\316\317\320\321\322\n!\323\"\324\325%@#\202\214�\326\305DC\327\330!\331\"BB\207" [0 nil ad-access-argument ad-set-argument ad-element-access ad-vAlUeS setq ad-list-access setcdr error "ad-set-arguments: No argument at position %d of `%s'" 1 ad-substitute-tree #[257 "\211\300=\207" [ad-vAlUeS] 3 "\n\n(fn FORM)"] make-byte-code 257 "\300\207" vconcat vector [] 2 "\n\n(fn FORM)" let append reverse (ad-vAlUeS)] 14 (#$ . 27403)])
#@93 Expands arg-access text macros in DEFINITION according to ARGLIST.

(fn DEFINITION ARGLIST)
(defalias 'ad-insert-argument-access-forms #[514 "\300\301\302\303\304\305\306!\307\"\310\311%#\207" [ad-substitute-tree #[257 "\211\300=\206�\211\242\301>\205�\211A\242\250\207" [ad-arg-bindings (ad-get-arg ad-get-args ad-set-arg ad-set-args)] 3 "\n\n(fn FORM)"] make-byte-code 257 "\211\301=\203\n�\302\300!\207\211@A@\303A\300\"A@\304\267\202:�\305\300\"\202;�\306\300#\202;�\307\300\"\202;�\310\300#\202;�\311\207" vconcat vector [ad-arg-bindings ad-retrieve-args-form ad-insert-argument-access-forms #s(hash-table size 4 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (ad-get-arg 28 ad-set-arg 35 ad-get-args 43 ad-set-args 50)) ad-get-argument ad-set-argument ad-get-arguments ad-set-arguments nil] 8 "\n\n(fn FORM)"] 10 (#$ . 28250)])
#@638 Make `funcall/apply' form to map SOURCE-ARGLIST to TARGET-ARGLIST.
The arguments supplied to TARGET-ARGLIST will be taken from SOURCE-ARGLIST just
as if they had been supplied to a function with TARGET-ARGLIST directly.
Excess source arguments will be neglected, missing source arguments will be
supplied as nil.  Returns a `funcall' or `apply' form with the second element
being `function' which has to be replaced by an actual function argument.
Example: (ad-map-arglists \='(a &rest args) \='(w x y z)) will return
         (funcall ad--addoit-function a (car args) (car (cdr args)) (nth 2 args)).

(fn SOURCE-ARGLIST TARGET-ARGLIST)
(defalias 'ad-map-arglists #[514 "\300!\301@A@\"\3028\300!\301@A@\"\3028\205�\211\303C\301\203*�\304\202+�\305\306D\203;�\301		C\"\202[�\307\310\311\312\313\314	\"\315\"\316\317%\301\205Y�	G
\233\"\"\"\207" [ad-parse-arglist append 2 -1 apply funcall ad--addoit-function mapcar make-byte-code 257 "\301\211\242T\240\210\302\300\301\242\"\207" vconcat vector [ad-get-argument] 4 "\n\n(fn ARG)"] 20 (#$ . 29122)])
#@37

(fn ADVICE CLASS &optional STYLE)
(defalias 'ad-make-single-advice-docstring #[770 "\300\3018\262!\302=\203�\211\2028�\211\203)�\303\304\305\306!!\211@\262$\2028�\303\307\305\306!!\211@\262#\207" [ad-docstring 3 plain format "%s-advice `%s':\n%s" capitalize symbol-name "%s-advice `%s'."] 9 (#$ . 30200)])
#@467 Construct a documentation string for the advised FUNCTION.
Concatenate the original documentation with the documentation
strings of the individual pieces of advice.  Optional argument
STYLE specifies how to format the pieces of advice; it can be
`plain', or any other value which means the default formatting.

The advice documentation is shown in order of before/around/after
advice type, obeying the priority in each of these types.

(fn FUNCTION &optional STYLE)
(defalias 'ad--make-advised-docstring #[513 "C\211\242\301N\302\303\304\305\306\"\307\"\310$\216\311\242\301\312#\210\313\242\314\")\2429\203@�\315\316\317\242!\"\203@�\320\321\317\242!\303\225\"!\240\210\322\242\"\312\211\204O�\314\202U�A\262@\262\203_�C\262\211\203\223�\211@\323\242\"\211\203\213�\211@\324
#\262\203\204�B\262A\266\202\202l�\210A\266\202\202`�\210\205\236�\325\326\237\327#\262\330\"\266\203\266\202\207" [ad-advice-classes function-documentation make-byte-code 0 "\302\300\242\303\301#\207" vconcat vector [put function-documentation] 4 put nil documentation t string-match "\\`ad-+Advice-" symbol-name intern substring help-split-fundoc ad-get-enabled-advices ad-make-single-advice-docstring mapconcat identity "\n\n" help-add-fundoc-usage] 16 (#$ . 30531)])
#@77 Find first defined arglist in FUNCTION's redefining advices.

(fn FUNCTION)
(defalias 'ad-advised-arglist #[257 "\30024�\301\302\303\"\302\304\"\302\305\"#\211\2051�\211@\306\3078\262!\211\203)�\310\300\"\210\210A\266\202\202�\2620\207" [--cl-block-nil-- append ad-get-enabled-advices before around after ad-arglist 3 throw] 7 (#$ . 31826)])
#@78 Find first interactive form in FUNCTION's redefining advices.

(fn FUNCTION)
(defalias 'ad-advised-interactive-form #[257 "\30024�\301\302\303\"\302\304\"\302\305\"#\211\2051�\211@\306\3078\262!\211\203)�\310\300\"\210\210A\266\202\202�\2620\207" [--cl-block-nil-- append ad-get-enabled-advices before around after ad-interactive-form 3 throw] 7 (#$ . 32184)])
#@81 Generate an advised definition of FUNCTION from its advice info.

(fn FUNCTION)
(defalias 'ad-make-advised-definition #[257 "\300!\205D�\301!\205D�\302!\303!\211<\203�\211\202�\304\262\305!\206%�\211\306!\307\"\310\311\312\313\"\312\f\314\"\312
\315\"&\266\205\207" [ad-is-advised ad-has-redefining-advice ad-real-orig-definition ad-arglist (&rest args) ad-advised-arglist ad-advised-interactive-form ad-map-arglists ad-assemble-advised-definition nil ad-get-enabled-advices before around after] 16 (#$ . 32561)])
#@504 Assemble the advices into an overall advice function.
ARGS is the argument list that has to be used,
DOCSTRING if non-nil defines the documentation of the definition,
INTERACTIVE if non-nil is the interactive form to be used,
ORIG is a form that calls the body of the original unadvised function,
and BEFORES, AROUNDS and AFTERS are the lists of advices with which ORIG
should be modified.  The assembled function will be returned.

(fn ARGS DOCSTRING INTERACTIVE ORIG &optional BEFORES AROUNDS AFTERS)
(defalias 'ad-assemble-advised-definition #[1796 "\300\301\302DEC\303\211\211\211\211\203K�\211@\211\211A@\262\2036�\2036�\304\305!\306\3078\262!BBC\262\202D�\310\306\3078\262!\"\262A\266\202\202�\210\311!\211\203\210�\211@\211\211A@\262\203b�\312\262\313\314\315\316\317\320\321!\322\"\323\324%\305\306\3078\262!!#\240\210A\266\202\202P�\210\203\235�\203\235�\304\305!\242EC\202\244�\310\242C\"\262\211\203\342�\211@\211\211A@\262\203\316�\203\316�\304\305!\306\3078\262!BBC\262\202\333�\310\306\3078\262!\"\262A\266\202\202\247�\210\325\326
B\310
\205\361�
C
\205\371�
C\327\330\310	\331\"BBC#BB\262\332
\"\207" [setq ad-return-value with-no-warnings nil unwind-protect macroexp-progn ad-body-forms 3 append reverse t ad-substitute-tree #[257 "\211\300=\207" [ad-do-it] 3 "\n\n(fn FORM)"] make-byte-code 257 "\300\242\207" vconcat vector [] 2 "\n\n(fn FORM)" lambda ad--addoit-function let (ad-return-value) (ad-return-value) ad-insert-argument-access-forms] 23 (#$ . 33101)])
#@91 Make hook-form from FUNCTION's advice bodies in class HOOK-NAME.

(fn FUNCTION HOOK-NAME)
(defalias 'ad-make-hook-form #[514 "\300\301\302\"\"\211\205�\303\304\305\"!\207" [mapcar #[257 "\300\3018\262!\207" [ad-body-forms 3] 5 "\n\n(fn ADVICE)"] ad-get-enabled-advices macroexp-progn apply append] 7 (#$ . 34654)])
#@17

(fn FUNCTION)
(defalias 'ad-get-cache-definition #[257 "\211\300\211\211\301N\262\236A\266\202@\207" [cache ad-advice-info] 7 (#$ . 34982)])
(put 'ad-get-cache-definition 'byte-optimizer 'byte-compile-inline-expand)
#@17

(fn FUNCTION)
(defalias 'ad-get-cache-id #[257 "\211\300\211\211\301N\262\236A\266\202A\207" [cache ad-advice-info] 7 (#$ . 35208)])
(put 'ad-get-cache-id 'byte-optimizer 'byte-compile-inline-expand)
#@31

(fn FUNCTION DEFINITION ID)
(defalias 'ad-set-cache #[771 "\300\301B#\207" [ad-set-advice-info-field cache] 8 (#$ . 35418)])
(put 'ad-set-cache 'byte-optimizer 'byte-compile-inline-expand)
#@178 Clears a previously cached advised definition of FUNCTION.
Clear the cache if you want to force `ad-activate' to construct a new
advised definition from scratch.

(fn FUNCTION)
(defalias 'ad-clear-cache #[257 "\300\301\302#\207" [ad-set-advice-info-field cache nil] 5 (#$ . 35619) (byte-code "\300\301!C\207" [ad-read-advised-function "Clear cached definition of"] 2)])
#@82 Generate an identifying image of the current advices of FUNCTION.

(fn FUNCTION)
(defalias 'ad-make-cache-id #[257 "\300!\211\301\211\211\302N\262\236A\266\202@\262\303\304\305\306\"\"\303\304\305\307\"\"\303\304\305\310\"\"\311!\312!\312!\232\203>�\313\202B�\312!\311!\314=\205T�\315!\315!\232\257\207" [ad-real-orig-definition cache ad-advice-info mapcar ad-advice-name ad-get-enabled-advices before around after ad-definition-type ad-arglist t function interactive-form] 11 (#$ . 35996)])
#@84 Return the part of FUNCTION's cache id that identifies CLASS.

(fn FUNCTION CLASS)
(defalias 'ad-get-cache-class-id #[514 "\211\300\211\211\301N\262\236A\266\202A\262\302=\203�\211@\202+�\303=\203(�\211A@\202+�\3048\207" [cache ad-advice-info before around 2] 9 (#$ . 36518)])
#@31

(fn CACHE-CLASS-ID ADVICES)
(defalias 'ad-verify-cache-class-id #[514 "\30027�\211\211\2032�\211@\211\3018\262\203+�@\211@\262=\203&�A\262\202+�\302\300\303\"\210A\266\202\202�?\2620\207" [--cl-block-nil-- 2 throw nil] 7 (#$ . 36809)])
#@17

(fn FUNCTION)
(defalias 'ad-cache-id-verification-code #[257 "\211\211\300\211\211\301N\262\236A\266\202A\262\302\303@\304\211\211\301N\262\236A\266\202\"\203\276�\305\211\262\203\276�\303A@\306\211\211\301N\262\236A\266\202\"\203\276�\307\211\262\203\276�\303\3108\311\211\211\301N\262\236A\266\202\"\203\276�\312\211\262\203\276�\313!\211\300\211\211\301N\262\236A\266\202@\262\3148\315!=\203\274�\316\211\262\203\274�\3178\320=\203\230�\321!\202\233�\3178\321!\232\203\274�\322\211\262\203\274�\3238\203\271�\324!\324!\232\203\274�\325\262\266\207" [cache ad-advice-info before-advice-mismatch ad-verify-cache-class-id before around-advice-mismatch around after-advice-mismatch 2 after definition-type-mismatch ad-real-orig-definition 3 ad-definition-type arglist-mismatch 4 t ad-arglist interactive-form-mismatch 5 interactive-form verified] 11 (#$ . 37064)])
#@84 True if FUNCTION's cache-id is compatible with its current advices.

(fn FUNCTION)
(defalias 'ad-verify-cache-id #[257 "\300!\301=\207" [ad-cache-id-verification-code verified] 3 (#$ . 37972)])
#@93 Preactivate FUNCTION and return the constructed cache.

(fn FUNCTION ADVICE CLASS POSITION)
(defalias 'ad-preactivate-advice #[1028 "\301\211\211\302N\262\236A\266\202\211K\303\302N!\262\304\305\306\307\310$\311\"\312$\216\313$\210\314\211@\262#\210\315!\210\316\317\"\210\320!\205\220�\211\321\211\211\302N\262\236A\266\202@\262\205\220�\211\321\211\211\302N\262\236A\266\202@\262\211\321\211\211\302N\262\236A\266\202A\262D*\207" [ad-advised-functions advicefunname ad-advice-info copy-tree make-byte-code 0 "\300\303\211\203+�\304\305\306\307\310\311\312!\313\"\314$\306\315\316\311\312!\317\"\320\321%B\262\322\323$\210\202H�\324N\203H�\325\324N\322\"\211\324N=\204F�\326\324#\210\266\326\327#\266\330\300\301\"\210\301\203\\�\301\302M\210\302\205e�\331\300\305\301#\207" vconcat vector [advice--add-function :around make-byte-code 0 "\300\301N\207" vconcat vector [defalias-fset-function] 2 257 "\301\300\302#\207" [put defalias-fset-function] 5 "\n\n(fn GV--VAL)" ad--defalias-fset nil defalias-fset-function advice--remove-function put ad-advice-info advice-remove advice-add] 12 ad-add-advice ad-enable-advice ad-clear-cache ad-activate -1 ad-is-active cache] 16 (#$ . 38173)])
#@306 Return non-nil if the advised FUNCTION should be compiled.
If COMPILE is non-nil and not a negative number then it returns t.
If COMPILE is a negative number then it returns nil.
If COMPILE is nil then the result depends on the value of
`ad-default-compilation-action' (which see).

(fn FUNCTION COMPILE)
(defalias 'ad-should-compile #[514 "\301!\204�\302\207\211\250\203�\211\303Y\207\211\206?�\304\267\202<�\302\207\305\207\306\307!!\206?�\307!\310!\206;�\311!\205;�\310\312!!\207\313\314!\207" [ad-default-compilation-action ad-real-orig-definition nil 0 #s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (never 27 always 29 like-original 31)) t subrp ad-get-orig-definition byte-code-function-p macrop ad-lambdafy featurep byte-compile] 6 (#$ . 39434)])
#@235 Redefine FUNCTION with its advised definition from cache or scratch.
The resulting FUNCTION will be compiled if `ad-should-compile' returns t.
The current definition and its cache-id will be put into the cache.

(fn FUNCTION COMPILE)
(defalias 'ad-activate-advised-definition #[514 "\300!\205�\211\301\211\211\302N\262\236A\266\202@\262\303\211\211\302N\262\236A\266\202\304!\2060�\305!M\210\306\307\310\311DD#\210\304!\232\204J�\312\"\210\313\314#\210\315\"\203[�\316!\210\203\210�K=?\205\251�K\211\301\211\211\302N\262\236A\266\202A\262\317\301B#\266\203\202\251�\320!\210K\321\317\301B#\266K\322!\317\301B#\266\203\207" [ad-verify-cache-id cache ad-advice-info advicefunname interactive-form ad-make-advised-definition put function-documentation ad--make-advised-docstring quote advice-remove advice-add :around ad-should-compile ad-compile-function ad-set-advice-info-field ad-clear-cache nil ad-make-cache-id] 14 (#$ . 40243)])
#@737 Handle re/definition of an advised FUNCTION during de/activation.
If FUNCTION does not have an original definition associated with it and
the current definition is usable, then it will be stored as FUNCTION's
original definition.  If no current definition is available (even in the
case of undefinition) nothing will be done.  In the case of redefinition
the action taken depends on the value of `ad-redefinition-action' (which
see).  Redefinition occurs when FUNCTION already has an original definition
associated with it but got redefined with a new definition and then
de/activated.  If you do not like the current redefinition action change
the value of `ad-redefinition-action' and de/activate again.

(fn FSETFUN FUNCTION NEWDEF)
(defalias 'ad--defalias-fset #[771 "\301!\301!\203O�\211\203D�\211=?\205_�\302>\204#�\303\304\305#\202_�\306=?\205_�\206/�\307\"\210\310!\210\311=\205_�\312\313\"\202_�\206I�\307\"\202_�\206T�\307\"\210\211\205_�\310!\207" [ad-redefinition-action ad-get-orig-definition (accept discard warn) error "ad-redefinition-action: `%s' %s" "invalidly redefined" discard fset ad-activate-internal warn message "ad-handle-definition: `%s' got redefined"] 9 (#$ . 41236)])
#@1039 Activate all the advice information of an advised FUNCTION.
If FUNCTION has a proper original definition then an advised
definition will be generated from FUNCTION's advice info and the
definition of FUNCTION will be replaced with it.  If a previously
cached advised definition was available, it will be used.
The optional COMPILE argument determines whether the resulting function
or a compilable cached definition will be compiled.  If it is negative
no compilation will be performed, if it is positive or otherwise non-nil
the resulting function will be compiled, if it is nil the behavior depends
on the value of `ad-default-compilation-action' (which see).
Activation of an advised function that has an advice info but no actual
pieces of advice is equivalent to a call to `ad-unadvise'.  Activation of
an advised function that has actual pieces of advice but none of them are
enabled is equivalent to a call to `ad-deactivate'.  The current advised
definition will always be cached for later usage.

(fn FUNCTION &optional COMPILE)
(defalias 'ad-activate #[513 "\300!\204�\301\302\"\207\303!\204�\304\207\305!\204�\306!\207\307!\2037�\310\"\210\311\312\313#\210\314\315\316\"!\210\207\317!\207" [ad-is-advised error "ad-activate: `%s' is not advised" ad-get-orig-definition nil ad-has-any-advice ad-unadvise ad-has-redefining-advice ad-activate-advised-definition ad-set-advice-info-field active t eval ad-make-hook-form activation ad-deactivate] 6 (#$ . 42462) (byte-code "\301\302!D\207" [current-prefix-arg ad-read-advised-function "Activate advice of"] 2)])
(defalias 'ad-activate-on 'ad-activate)
#@294 Deactivate the advice of an actively advised FUNCTION.
If FUNCTION has a proper original definition, then the current
definition of FUNCTION will be replaced with it.  All the advice
information will still be available so it can be activated again with
a call to `ad-activate'.

(fn FUNCTION)
(defalias 'ad-deactivate #[257 "\300!\204�\301\302\"\207\303!\205.�\304!\204�\301\305\"\207\306!\210\307\310\311#\210\312\313\314\"!\210\211\207" [ad-is-advised error "ad-deactivate: `%s' is not advised" ad-is-active ad-get-orig-definition "ad-deactivate: `%s' has no original definition" ad-clear-advicefunname-definition ad-set-advice-info-field active nil eval ad-make-hook-form deactivation] 5 (#$ . 44093) (byte-code "\300\301\302\"C\207" [ad-read-advised-function "Deactivate advice of" ad-is-active] 3)])
#@171 Update the advised definition of FUNCTION if its advice is active.
See `ad-activate' for documentation on the optional COMPILE argument.

(fn FUNCTION &optional COMPILE)
(defalias 'ad-update #[513 "\300!\205\n�\301\"\207" [ad-is-active ad-activate] 5 (#$ . 44915) (byte-code "\300\301\302\"C\207" [ad-read-advised-function "Update advised definition of" ad-is-active] 3)])
#@129 Deactivate FUNCTION and then remove all its advice information.
If FUNCTION was not advised this will be a noop.

(fn FUNCTION)
(defalias 'ad-unadvise #[257 "\300!\205f�\301!\203�\302!\210\303!\210\211\304\211\203?�\305\306\307\310\311\312\313!\314\"\315$\307\316\317\312\313!\320\"\321\322%B\262\323\304$\210\202\\�\324N\203\\�\325\324N\323\"\211\324N=\204Z�\326\324#\210\266\326\327#\266\330!\207" [ad-is-advised ad-is-active ad-deactivate ad-clear-advicefunname-definition nil advice--add-function :around make-byte-code 0 "\300\301N\207" vconcat vector [defalias-fset-function] 2 257 "\301\300\302#\207" [put defalias-fset-function] 5 "\n\n(fn GV--VAL)" ad--defalias-fset defalias-fset-function advice--remove-function put ad-advice-info ad-pop-advised-function] 13 (#$ . 45298) (byte-code "\300\301!C\207" [ad-read-advised-function "Unadvise function"] 2)])
#@229 Try to recover FUNCTION's original definition, and unadvise it.
This is more low-level than `ad-unadvise' in that it does not do
deactivation, which might run hooks and get into other trouble.
Use in emergencies.

(fn FUNCTION)
(defalias 'ad-recover #[257 "\300!\205\\�\301!\210\211\302\211\2035�\303\304\305\306\307\310\311!\312\"\313$\305\314\315\310\311!\316\"\317\320%B\262\321\302$\210\202R�\322N\203R�\323\322N\321\"\211\322N=\204P�\324\322#\210\266\324\325#\266\326!\207" [ad-is-advised ad-clear-advicefunname-definition nil advice--add-function :around make-byte-code 0 "\300\301N\207" vconcat vector [defalias-fset-function] 2 257 "\301\300\302#\207" [put defalias-fset-function] 5 "\n\n(fn GV--VAL)" ad--defalias-fset defalias-fset-function advice--remove-function put ad-advice-info ad-pop-advised-function] 13 (#$ . 46190) (byte-code "\301\302\303\304\305$!C\207" [obarray intern completing-read "Recover advised function: " nil t] 6)])
#@290 Activate functions with an advice name containing a REGEXP match.
This activates the advice for each function
that has at least one piece of advice whose name includes a match for REGEXP.
See `ad-activate' for documentation on the optional COMPILE argument.

(fn REGEXP &optional COMPILE)
(defalias 'ad-activate-regexp #[513 "\211\205!�\211@\301!\262\302\303#\203�\304\"\210A\266\202\202�\207" [ad-advised-functions intern ad-find-some-advice any ad-activate] 8 (#$ . 47166) (byte-code "\301\302!D\207" [current-prefix-arg ad-read-regexp "Activate via advice regexp"] 2)])
#@204 Deactivate functions with an advice name containing REGEXP match.
This deactivates the advice for each function
that has at least one piece of advice whose name includes a match for REGEXP.

(fn REGEXP)
(defalias 'ad-deactivate-regexp #[257 "\211\205�\211@\301!\262\302\303#\203�\304!\210A\266\202\202�\207" [ad-advised-functions intern ad-find-some-advice any ad-deactivate] 7 (#$ . 47758) (byte-code "\300\301!C\207" [ad-read-regexp "Deactivate via advice regexp"] 2)])
#@290 Update functions with an advice name containing a REGEXP match.
This reactivates the advice for each function
that has at least one piece of advice whose name includes a match for REGEXP.
See `ad-activate' for documentation on the optional COMPILE argument.

(fn REGEXP &optional COMPILE)
(defalias 'ad-update-regexp #[513 "\211\205!�\211@\301!\262\302\303#\203�\304\"\210A\266\202\202�\207" [ad-advised-functions intern ad-find-some-advice any ad-update] 8 (#$ . 48247) (byte-code "\301\302!D\207" [current-prefix-arg ad-read-regexp "Update via advice regexp"] 2)])
#@137 Activate all currently advised functions.
See `ad-activate' for documentation on the optional COMPILE argument.

(fn &optional COMPILE)
(defalias 'ad-activate-all #[256 "\211\205�\211@\301!\262\302\"\210A\266\202\202�\207" [ad-advised-functions intern ad-activate] 6 (#$ . 48833) "P"])
#@45 Deactivate all currently advised functions.
(defalias 'ad-deactivate-all #[0 "\211\205�\211@\301!\262\302!\210A\266\202\202�\207" [ad-advised-functions intern ad-deactivate] 4 (#$ . 49133) nil])
#@126 Update all currently advised functions.
With prefix argument, COMPILE resulting advised definitions.

(fn &optional COMPILE)
(defalias 'ad-update-all #[256 "\211\205�\211@\301!\262\302\"\210A\266\202\202�\207" [ad-advised-functions intern ad-update] 6 (#$ . 49342) "P"])
#@43 Unadvise all currently advised functions.
(defalias 'ad-unadvise-all #[0 "\211\205�\211@\301!\262\302!\210A\266\202\202�\207" [ad-advised-functions intern ad-unadvise] 4 (#$ . 49627) nil])
#@296 Recover all currently advised functions.  Use in emergencies.
To recover a function means to try to find its original (pre-advice)
definition, and delete all advice.
This is more low-level than `ad-unadvise' in that it does not do
deactivation, which might run hooks and get into other trouble.
(defalias 'ad-recover-all #[0 "\211\205#�\211@\301!\262\3021�\303!0\202�\210\202�\210A\266\202\202�\207" [ad-advised-functions intern (error) ad-recover] 4 (#$ . 49830) nil])
(defconst ad-defadvice-flags '("protect" "disable" "activate" "compile" "preactivate"))
#@2134 Define a piece of advice for FUNCTION (a symbol).
The syntax of `defadvice' is as follows:

(defadvice FUNCTION (CLASS NAME [POSITION] [ARGLIST] FLAG...)
    [DOCSTRING] [INTERACTIVE-FORM]
    BODY...)

FUNCTION ::= Name of the function to be advised.
CLASS ::= `before' | `around' | `after' | `activation' | `deactivation'.
NAME ::= Non-nil symbol that names this piece of advice.
POSITION ::= `first' | `last' | NUMBER. Optional, defaults to `first',
    see also `ad-add-advice'.
ARGLIST ::= An optional argument list to be used for the advised function
    instead of the argument list of the original.  The first one found in
    before/around/after-advices will be used.
FLAG ::= `protect'|`disable'|`activate'|`compile'|`preactivate'.
    All flags can be specified with unambiguous initial substrings.
DOCSTRING ::= Optional documentation for this piece of advice.
INTERACTIVE-FORM ::= Optional interactive form to be used for the advised
    function.  The first one found in before/around/after-advices will be used.
BODY ::= Any s-expression.

Semantics of the various flags:
`protect': The piece of advice will be protected against non-local exits in
any code that precedes it.  If any around-advice of a function is protected
then automatically all around-advices will be protected (the complete onion).

`activate': All advice of FUNCTION will be activated immediately if
FUNCTION has been properly defined prior to this application of `defadvice'.

`compile': In conjunction with `activate' specifies that the resulting
advised function should be compiled.

`disable': The defined advice will be disabled, hence, it will not be used
during activation until somebody enables it.

`preactivate': Preactivates the advised FUNCTION at macro-expansion/compile
time.  This generates a compiled advised definition according to the current
advice state that will be used during activation if appropriate.  Only use
this if the `defadvice' gets actually compiled.

usage: (defadvice FUNCTION (CLASS NAME [POSITION] [ARGLIST] FLAG...)
          [DOCSTRING] [INTERACTIVE-FORM]
          BODY...)

(fn FUNCTION ARGS &rest BODY)
(defalias 'defadvice '(macro . #[642 "\300!\204�\301\302\"\210@\303!\204�\301\304\"\202�A@\300!\204*�\301\305\"\202<�AA\262\306@!\205<�@A\262@<\205H�@A\262\307\310\"\311\312>\313>?\314\315\fBBB$\316>\205o�\317	$\320\321\322\fD\322D\322D\322\nD\257\323\205\255�\324\322D\325@!\203\240�\326\327\330@!DD\202\245�\327@D\322A@DFC\331>\205\303�\332\322D\333	>\205\301�\334EC\322DC#BB\207" [ad-name-p error "defadvice: Invalid function name: %s" ad-class-p "defadvice: Invalid advice class: %s" "defadvice: Invalid advice name: %s" ad-position-p mapcar #[257 "\301\302!\"\211\303=\203�\202 �\211\235\203�\304!\202 �\305\306\"\207" [ad-defadvice-flags try-completion symbol-name t intern error "defadvice: Invalid or ambiguous flag: %s"] 5 "\n\n(fn FLAG)"] ad-make-advice protect disable advice lambda preactivate ad-preactivate-advice progn ad-add-advice quote append ad-set-cache macrop ad-macrofy function ad-lambdafy activate ad-activate compile t] 19 (#$ . 50405)]))
(byte-code "\300\301\302\303#\300\301\304\305#\306\301\307\310#\207" [function-put defadvice doc-string-elt 3 lisp-indent-function 2 put edebug-form-spec (&define name (name name &rest sexp) [&optional stringp] [&optional ("interactive" interactive)] def-body)] 6)
#@276 Binds FUNCTIONS to their original definitions and execute BODY.
For any members of FUNCTIONS that are not currently advised the rebinding will
be a noop.  Any modifications done to the definitions of FUNCTIONS will be
undone on exit of this macro.

(fn FUNCTIONS &rest BODY)
(defalias 'ad-with-originals '(macro . #[385 "\300C\301\302\303\304\305\306!\307\"\310\311%\"\312\313\314\315\300\240\210\301\302\303\316\305\306\f\f\"\317\"\320\311%\n\"\"B\300\240\210\301\302\303\321\305\306\"\322\"\310\311%	\"BBE\207" [-1 mapcar make-byte-code 257 "\300\211\242T\240\210\301\302\303\300\242\"!\304\305DDD\207" vconcat vector [intern format "ad-oRiGdEf-%d" symbol-function quote] 5 "\n\n(fn FUNCTION)" let unwind-protect progn append "\300\211\242T\240\210\302\303D\304\305\303DD\300\242\3018@EE\207" [fset quote or ad-get-orig-definition] 7 "\300\211\242T\240\210\302\303D\300\242\3018@E\207" [fset quote]] 17 (#$ . 53842)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put ad-with-originals lisp-indent-function 1 make-obsolete nil "27.1"] 5)
#@95 Undo all advice related redefinitions and unadvises everything.
Use only in REAL emergencies.
(defalias 'ad-recover-normality #[0 "\301 \210\211\205�\211@\302!\262\303\304\"\210\305!\210A\266\202\202�\207" [ad-advised-functions ad-recover-all intern message "Oops! Left over advised function %S" ad-pop-advised-function] 5 (#$ . 54926) nil])
(provide 'advice)

${this.title}

Code Editor : advice.elc