HOME


sh-3ll 1.0
DIR:/proc/self/root/usr/share/emacs/26.1/lisp/emacs-lisp/
Upload File :
Current File : //proc/self/root/usr/share/emacs/26.1/lisp/emacs-lisp/nadvice.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.

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


#@288 List of descriptions of how to add a function.
Each element has the form (WHERE BYTECODE STACK) where:
  WHERE is a keyword indicating where the function is added.
  BYTECODE is the corresponding byte-code that will be used.
  STACK is the amount of stack space needed by the byte-code.
(defvar advice--where-alist '((:around "\300\301\302#\207" 5) (:before "\300\301\"\210\300\302\"\207" 4) (:after "\300\302\"\300\301\"\210\207" 5) (:override "\300\301\"\207" 4) (:after-until "\300\302\"\206\300\301\"\207" 4) (:after-while "\300\302\"\205\300\301\"\207" 4) (:before-until "\300\301\"\206\300\302\"\207" 4) (:before-while "\300\301\"\205\300\302\"\207" 4) (:filter-args "\300\302\301!\"\207" 5) (:filter-return "\301\300\302\"!\207" 5)) (#$ . 409))
(defvar advice--bytecodes (mapcar 'cadr advice--where-alist))
#@15 

(fn OBJECT)
(defalias 'advice--p #[257 "\301!\205$\211\302H\303=\205$\211G\304>\205$\211\305H>\205$\211\306H\302H\307=\207" [advice--bytecodes byte-code-function-p 0 128 (5 6) 1 2 apply] 3 (#$ . 1253)])
#@10 

(fn F)
(defalias 'advice--car #[257 "\211\300H\301H\207" [2 1] 3 (#$ . 1470)])
(put 'advice--car 'byte-optimizer 'byte-compile-inline-expand)
#@10 

(fn F)
(defalias 'advice--cdr #[257 "\211\300H\300H\207" [2] 3 (#$ . 1620)])
(put 'advice--cdr 'byte-optimizer 'byte-compile-inline-expand)
#@10 

(fn F)
(defalias 'advice--props #[257 "\211\300H\301H\207" [2 3] 3 (#$ . 1768)])
(put 'advice--props 'byte-optimizer 'byte-compile-inline-expand)
#@10 

(fn F)
(defalias 'advice--cd*r #[257 "\300!\203\211\211\301H\301H\262\262\202\207" [advice--p 2] 4 (#$ . 1922)])
#@10 

(fn F)
(defalias 'advice--where #[257 "\211\301H\302\211\203\211@A@=\203\211@\262A\266\202\202\210\207" [advice--where-alist 1 nil] 7 (#$ . 2050)])
#@74 Build the raw docstring for FUNCTION, presumably advised.

(fn FUNCTION)
(defalias 'advice--make-docstring #[257 "\300!\301\211\242\302=\203A\262\303!\203\220\304H\305!\250\203$\262\306\307\310\"\311\312#\211\313H\314H\262\2119\203B\315\316\"\202}\317\211\313H\320H\262\236A\321\322\"\323\f\"\211\203_\211A\262\203v\203o\307\324#\202{\307\325\"\202{\206{\326\266\203\262\327R\266\203\211\313H\313H\262\262\202\211\203\231\211\327P\262\204\240\262=?\205\253\321\322\"\323\"\211\204\312\330!\211;\203\300\322\202\305\331\"\262\202\320\211A\262\211@\262\332P\"\266\202\207" [indirect-function nil macro advice--p 4 advice--where propertize format "%s advice: " face warning 2 1 format-message "`%S'" name 3 documentation t help-split-fundoc "%s\n%s" "%s" "No documentation" "\n" help-function-arglist help--make-usage-docstring help-add-fundoc-usage] 16 (#$ . 2217)])
#@48 Evaluate the interactive spec SPEC.

(fn SPEC)
(defalias 'advice-eval-interactive-spec #[257 "\211;\203\300\301\302\303D\304BBB!\207\305!\207" [call-interactively lambda (&rest args) interactive (args) eval] 6 (#$ . 3162)])
#@17 

(fn FUNCTION)
(defalias 'advice--interactive-form #[257 "\300!\205&\2119\203\301!\211\242\302=\262\204\303!\207\304\305\306\303\307DDDDD\207" [commandp indirect-function autoload interactive-form interactive advice-eval-interactive-spec cadr quote] 7 (#$ . 3396)])
#@22 

(fn FUNCTION MAIN)
(defalias 'advice--make-interactive-form #[514 "\300!\300!A@\211\242\301=\203\211A@\262\302!\203(\303\304D\304A@DE\202/\206-A@\207" [advice--interactive-form function functionp funcall quote] 9 (#$ . 3679)])
#@100 Build a function value that adds FUNCTION to MAIN.

(fn BYTE-CODE STACK-DEPTH FUNCTION MAIN PROPS)
(defalias 'advice--make-1 #[1285 "\301\"\302\303\304\305\302			$	\306\307!\204#\307\n!\205*\310\"C&\2036\311#\210\207" [advertised-signature-table gethash apply make-byte-code 128 vector nil commandp advice--make-interactive-form puthash] 16 (#$ . 3929)])
#@156 Build a function value that adds FUNCTION to MAIN at WHERE.
WHERE is a symbol to select an entry in `advice--where-alist'.

(fn WHERE FUNCTION MAIN PROPS)
(defalias 'advice--make #[1028 "\301\236A\206\302\303!\205\301\211\304H\305H\262\236A\206\302\211\203YV\203Y\306\211\304H\304H\262$\307\310H\305H\211\304H\310H\262	\211\304H\305H\262%\262\202v\236\211\204f\311\312\"\210\307A@\3048%\262\207" [advice--where-alist depth 0 advice--p 2 3 advice--make advice--make-1 1 error "Unknown add-function location `%S'"] 15 (#$ . 4314)])
#@37 

(fn FUNCTION USE-NAME DEFINITION)
(defalias 'advice--member-p #[771 "\300\211\204`\301!\203`\302=\203.\303\211\304H\305H\262\236A\232\204M\211\304H\306H\262\232\202J\203A\303\211\304H\305H\262\236A\202I\211\304H\306H\262\232\203S\262\202\211\304H\304H\262\262\202\211\207" [nil advice--p :use-both name 2 3 1] 9 (#$ . 4898)])
#@22 

(fn FLIST TWEAKER)
(defalias 'advice--tweak #[514 "\300!\204\f\211\301\301#\207\211\302H\303H\262\211\302H\302H\262\211\302H\304H\262#\211\2032\211@\202S\305\"=\203B\202Q\306\303H\304H%\262\262\207" [advice--p nil 2 1 3 advice--tweak advice--make-1] 13 (#$ . 5263)])
#@23 

(fn FLIST FUNCTION)
(defalias 'advice--remove-function #[514 "\300\301\302\303\304\305!\306\"\307\310%\"\207" [advice--tweak make-byte-code 771 "\204\207\300\232\204\300\301\236A\232\205\302\300\"C\207" vconcat vector [name advice--remove-function] 6 "\n\n(fn FIRST REST PROPS)"] 10 (#$ . 5573)])
#@293 keeps an example of the special "run the default value" functions.
These functions play the same role as t in buffer-local hooks, and to recognize
them, we keep a sample here against which to compare.  Each instance is
different, but `function-equal' will hopefully ignore those differences.
(defvar advice--buffer-local-function-sample nil (#$ . 5893))
#@16 

(fn VAR VAL)
(defalias 'advice--set-buffer-local #[514 "\301\"\203\302!\207\303!L\207" [advice--buffer-local-function-sample function-equal kill-local-variable make-local-variable] 5 (#$ . 6253)])
#@70 Buffer-local value of VAR, presumed to contain a function.

(fn VAR)
(defalias 'advice--buffer-local #[257 "\301!\203	\211J\207\302\303\304\305\306!\307\"\310\311%\211\207" [advice--buffer-local-function-sample local-variable-p make-byte-code 128 "\301\302\300!\"\207" vconcat vector [apply default-value] 4 "\n\n(fn &rest ARGS)"] 7 (#$ . 6465)])
(byte-code "\300\301\302\303#\300\207" [function-put advice--buffer-local gv-expander #[385 "\300\301\302$\207" [gv--defsetter advice--buffer-local #[385 "\300\301C\"B\207" [advice--set-buffer-local append] 6 "\n\n(fn VAL &rest ARGS)"]] 7 "\n\n(fn DO &rest ARGS)"]] 4)
#@14 

(fn PLACE)
(defalias 'advice--normalize-place #[257 "\211\242\300=\203\f\301AB\207\211\242\302=\203\211A@\207\2119\203\"\303\304DD\207\207" [local advice--buffer-local var default-value quote] 4 (#$ . 7096)])
#@2360 Add a piece of advice on the function stored at PLACE.
FUNCTION describes the code to add.  WHERE describes where to add it.
WHERE can be explained by showing the resulting new function, as the
result of combining FUNCTION and the previous value of PLACE, which we
call OLDFUN here:
`:before'	(lambda (&rest r) (apply FUNCTION r) (apply OLDFUN r))
`:after'	(lambda (&rest r) (prog1 (apply OLDFUN r) (apply FUNCTION r)))
`:around'	(lambda (&rest r) (apply FUNCTION OLDFUN r))
`:override'	(lambda (&rest r) (apply FUNCTION r))
`:before-while'	(lambda (&rest r) (and (apply FUNCTION r) (apply OLDFUN r)))
`:before-until'	(lambda (&rest r) (or  (apply FUNCTION r) (apply OLDFUN r)))
`:after-while'	(lambda (&rest r) (and (apply OLDFUN r) (apply FUNCTION r)))
`:after-until'	(lambda (&rest r) (or  (apply OLDFUN r) (apply FUNCTION r)))
`:filter-args'	(lambda (&rest r) (apply OLDFUN (funcall FUNCTION r)))
`:filter-return'(lambda (&rest r) (funcall FUNCTION (apply OLDFUN r)))
If FUNCTION was already added, do nothing.
PROPS is an alist of additional properties, among which the following have
a special meaning:
- `name': a string or symbol.  It can be used to refer to this piece of advice.
- `depth': a number indicating a preference w.r.t ordering.
  The default depth is 0.  By convention, a depth of 100 means that
  the advice  should be innermost (i.e. at the end of the list),
  whereas a depth of -100 means that the advice should be outermost.

If PLACE is a symbol, its `default-value' will be affected.
Use (local \='SYMBOL) if you want to apply FUNCTION to SYMBOL buffer-locally.
Use (var VAR) if you want to apply FUNCTION to the (lexical) VAR.
If you are trying to modify an existing named function rather
than a function value, you probably want to use `advice-add'
instead (see Info node `(elisp) Advising Named Functions').

If one of FUNCTION or OLDFUN is interactive, then the resulting function
is also interactive.  There are 3 cases:
- FUNCTION is not interactive: the interactive spec of OLDFUN is used.
- The interactive spec of FUNCTION is itself a function: it should take one
  argument (the interactive spec of OLDFUN, which it can pass to
  `advice-eval-interactive-spec') and return the list of arguments to use.
- Else, use the interactive spec of FUNCTION and ignore the one of OLDFUN.

(fn WHERE PLACE FUNCTION &optional PROPS)
(defalias 'add-function '(macro . #[1027 "\300\301\302!D\257\207" [advice--add-function gv-ref advice--normalize-place] 9 (#$ . 7321)]))
(put 'add-function 'edebug-form-spec '(form [&or symbolp ("local" form) ("var" sexp) gv-place] form &optional form))
#@33 

(fn WHERE REF FUNCTION PROPS)
(defalias 'advice--add-function #[1028 "\300\236A\301\206\n\205\302\211@ \262#\211\2036\211A\303\211@ \262\2062\211\304H\305H\262\"!\266\211A\306	\211@ \262$!\262\207" [name advice--member-p t advice--remove-function 2 1 advice--make] 13 (#$ . 9946)])
#@215 Remove the FUNCTION piece of advice from PLACE.
If FUNCTION was not added to PLACE, do nothing.
Instead of FUNCTION being the actual function, it can also be the `name'
of the piece of advice.

(fn PLACE FUNCTION)
(defalias 'remove-function '(macro . #[514 "\300\301!\302\303\304\305\306!\307\"\310\311%\"\207" [gv-get advice--normalize-place make-byte-code 514 "\301\300E\302!\203\211\202\303\304!\305\306E!E=\203%\211\202,\307DC\"\207" vconcat vector [advice--remove-function macroexp-const-p make-symbol "new" unless eq macroexp-let*] 8 "\n\n(fn GETTER SETTER)"] 10 (#$ . 10267)]))
(put 'remove-function 'edebug-form-spec '([&or symbolp ("local" form) ("var" sexp) gv-place] form))
#@196 Apply F to every advice function in FUNCTION-DEF.
F is called with two arguments: the function that was added, and the
properties alist that was specified when it was added.

(fn F FUNCTION-DEF)
(defalias 'advice-function-mapc #[514 "\300!\205&\211\301H\302H\262\211\301H\303H\262\"\210\211\211\301H\301H\262\262\202\207" [advice--p 2 1 3] 7 (#$ . 10980)])
#@175 Return non-nil if ADVICE is already in FUNCTION-DEF.
Instead of ADVICE being the actual function, it can also be the `name'
of the piece of advice.

(fn ADVICE FUNCTION-DEF)
(defalias 'advice-function-member-p #[514 "\300\301#\207" [advice--member-p :use-both] 6 (#$ . 11355)])
#@16 

(fn OLD NEW)
(defalias 'advice--subst-main #[514 "\300\301\302\303\304\305!\306\"\307\310%\"\207" [advice--tweak make-byte-code 771 "?\205\300\207" vconcat vector [] 4 "\n\n(fn FIRST REST PROPS)"] 10 (#$ . 11641)])
#@19 

(fn SYMBOL DEF)
(defalias 'advice--normalize #[514 "\300!\203\301\302\"\207\2119\2030\303!\2030\304\305\306\307\310\311!\312\"\313\314%B\315\316AB#\210\211\207\211\242\304=\203O\3171E\211A\241\210\3200\202G\210\321\204O\304AB\207\207" [special-form-p error "Advice impossible: %S is a special form" macrop macro make-byte-code 128 "\301\300B!\207" vconcat vector [macroexpand] 4 "\n\n(fn &rest R)" put advice--saved-rewrite (error) t nil] 9 (#$ . 11870)])
#@10 

(fn X)
(defalias 'advice--strip-macro #[257 "\211\242\300=\203\n\211A\207\207" [macro] 3 (#$ . 12353)])
(put 'advice--strip-macro 'byte-optimizer 'byte-compile-inline-expand)
#@15 

(fn SYMBOL)
(defalias 'advice--symbol-function #[257 "\211\300N\206\211K\211\242\301=\203\211A\262\207" [advice--pending macro] 4 (#$ . 12537)])
#@30 

(fn FSETFUN SYMBOL NEWDEF)
(defalias 'advice--defalias-fset #[771 "\204\300\262\301!\203\302!\262\202+\211\242\303=\203+\301A!\203+\303\302A!B\262\304N\2037\305\304\306#\210\307\"\262\310!\203z\211\242\311=\262\204z\211\242\303=\203Z\211A\262\312\"\305\313\306#\210=\203q\202t\303B\"\266\202\202\217\211\313N=\204\213\305\313\312\306\"#\210\"\207" [fset advice--p advice--cd*r macro advice--saved-rewrite put nil advice--normalize advice--symbol-function autoload advice--subst-main advice--pending] 10 (#$ . 12695)])
#@220 Like `add-function' but for the function named SYMBOL.
Contrary to `add-function', this will properly handle the cases where SYMBOL
is defined as a macro, alias, command, ...

(fn SYMBOL WHERE FUNCTION &optional PROPS)
(defalias 'advice-add #[1027 "K\300\"=\204M\210\301\242\302=\2038\303\304\305\306\307!\310\"\311$\303\312\313\306\307!\310\"\314\315%B\262\202\203\203F\211\242\316=\262\203f\303\304\317\306\307!\320\"\321$\303\312\322\306\307!\323\"\324\315%B\262\202\203\303\304\325\306\307!\310\"\311$\303\312\326\306\307!\310\"\314\315%B\262\303\304\327\306\307!\310\"\311$\303\312\330\306\307!\310\"\314\331%B\262$\210\332\333\334\335\nDD#\210\301\336\303\304\317\306\307!\337\"\321$\303\312\322\306\307!\340\"\324\331%B\262\341\342$\266\342\207" [advice--normalize advice--add-function macro make-byte-code 0 "\300A\207" vconcat vector [] 1 257 "\300\241\207" 3 "\n\n(fn V1374)" autoload "\300\301N\207" [advice--pending] 2 "\301\300\302#\207" [put advice--pending] 5 "\300K\207" "\300M\207" "\300@ \207" "\300A!\207" "\n\n(fn GV--VAL)" put function-documentation advice--make-docstring quote :around [defalias-fset-function] [put defalias-fset-function] advice--defalias-fset nil] 16 (#$ . 13272)])
#@292 Like `remove-function' but for the function named SYMBOL.
Contrary to `remove-function', this also works when SYMBOL is a macro
or an autoload and it preserves `fboundp'.
Instead of the actual function to remove, FUNCTION can also be the `name'
of the piece of advice.

(fn SYMBOL FUNCTION)
(defalias 'advice-remove #[514 "K\300N\203'\301\302\303\304\305!\306\"\307$\301\310\311\304\305!\312\"\313\314%B\262\202i\211\242\315=\203M\211\301\302\316\304\305!\317\"\320$\301\310\321\304\305!\317\"\322\314%B\262\202i\301\302\323\304\305!\317\"\320$\301\310\324\304\305!\317\"\322\314%B\262\325@ \"\211@ =\204|A!\210\266\326\327!!\204\265\325\330N\331\"\211\330N=\204\233\332\330#\210\266\333N\211\203\264K\243A=\203\264\211\333N@M\210\210\210\334\207" [advice--pending make-byte-code 0 "\300\301N\207" vconcat vector [advice--pending] 2 257 "\301\300\302#\207" [put advice--pending] 5 "\n\n(fn V1375)" macro "\300A\207" [] 1 "\300\241\207" 3 "\300K\207" "\300M\207" advice--remove-function advice--p advice--symbol-function defalias-fset-function advice--defalias-fset put advice--saved-rewrite nil] 11 (#$ . 14544)])
#@273 Define an advice and add it to function named SYMBOL.
See `advice-add' and `add-function' for explanation on the
arguments.  Note if NAME is nil the advice is anonymous;
otherwise it is named `SYMBOL@NAME'.

(fn SYMBOL (WHERE LAMBDA-LIST &optional NAME DEPTH) &rest BODY)
(defalias 'define-advice '(macro . #[642 "<\204\f\300\301\302D\"\210\303\304G\305#\204\300\306\304\305GE\"\210@A@\3048\3078\211\2051\310BC\204>\311BB\202X;\204H9\203T\312\313\314\n#!\202X\315\316\"\317\3209\205i\321BBBC\322\323
D\n\324D\205~\323	DCBBBBC\"B\207" [signal wrong-type-argument listp <= 2 4 wrong-number-of-arguments 3 depth lambda intern format "%s@%s" error "Unrecognized name spec `%S'" prog1 append defun advice-add quote function] 18 (#$ . 15710)]))
(byte-code "\300\301\302\303#\300\301\304\305#\306\301\307\310#\207" [function-put define-advice lisp-indent-function 2 doc-string-elt 3 put edebug-form-spec (sexp sexp body)] 6)
#@192 Apply FUN to every advice function in SYMBOL.
FUN is called with a two arguments: the function that was added, and the
properties alist that was specified when it was added.

(fn FUN SYMBOL)
(defalias 'advice-mapc #[514 "\300\301!\"\207" [advice-function-mapc advice--symbol-function] 6 (#$ . 16678)])
#@167 Return non-nil if ADVICE has been added to SYMBOL.
Instead of ADVICE being the actual function, it can also be the `name'
of the piece of advice.

(fn ADVICE SYMBOL)
(defalias 'advice-member-p #[514 "\300\301!\"\207" [advice-function-member-p advice--symbol-function] 6 (#$ . 16989)])
(add-hook 'called-interactively-p-functions 'advice--called-interactively-skip)
#@28 

(fn ORIGI FRAME1 FRAME2)
(defalias 'advice--called-interactively-skip #[771 "\211CCC\300\242A@\301=\205\221\211#\210\302\303\242A@!!\205\221\211#\210\302\242A@!\203\212\242A@\242A@\301=\203Z#\210\302\303\242A@!!\203Z#\210\202\206#\210\242\203x\242A@\301=\203Z\304\2428=\203Z#\210#\210\210\202'\305\242\306#\266\202\207" [#[771 "\242\240\210\300\242\301\"\240\210\211\242T\240\207" [backtrace-frame called-interactively-p] 7 "\n\n(fn FRAME1 FRAME2 I)"] apply advice--p indirect-function 3 - 1] 12 (#$ . 17362)])
(provide 'nadvice)