;;; compiled by jimb@wookumz.gnu.ai.mit.edu on Wed May 26 23:09:21 1993 ;;; from file /gd/gnu/emacs/19.0/lisp/advice.el ;;; emacs version 19.8.0. ;;; bytecomp version FSF 2.08 ;;; optimization is on. (byte-code "!\"!\" " [provide advice-preload require "advice.el" fboundp \` autoload "backquote" "2.1" ad-version] 3) (defconst ad-emacs19-p (byte-code "!\n  \"?" [boundp epoch::version string-lessp emacs-version "19"] 3) "\ Non-NIL if we run Emacs version 19 or higher. This will be true for GNU Emacs-19 as well as Lemacs.") (defconst ad-lemacs-p (byte-code " \"" [ad-emacs19-p string-match "Lucid" emacs-version] 3) "\ Non-NIL if we run Lucid's version of Emacs-19.") (defvar ad-start-advice-on-load nil "\ *Non-NIL will start advice magic when this file gets loaded. Also see function `ad-start-advice'.") (defvar ad-activate-on-definition nil "\ *Non-NIL means automatic advice activation at function definition. Set this variable to t if you want to enable forward advice (which is automatic advice activation of a previously undefined function at the point the function gets defined/loaded/autoloaded). The value of this variable takes effect only during the execution of `ad-start-advice'. If non-NIL it will enable definition hooks regardless of the value of `ad-enable-definition-hooks'.") (defvar ad-redefinition-action (quote warn) "\ *Defines what to do with redefinitions during de/activation. Redefinition occurs if a previously activated function that already has an original definition associated with it gets redefined and then de/activated. In such a case we can either accept the current definition as the new original definition, discard the current definition and replace it with the old original, or keep it and raise an error. The values `accept', `discard', `error' or `warn' govern what will be done. `warn' is just like `accept' but it additionally prints a warning message. All other values will be interpreted as `error'.") (defvar ad-definition-hooks nil "\ *List of hooks to be run after a function definition. The variable `ad-defined-function' will be bound to the name of the currently defined function when the hook function is run.") (defvar ad-enable-definition-hooks nil "\ *Non-NIL will enable hooks to be run on function definition. Setting this variable is a noop unless the value of `ad-activate-on-definition' (which see) is NIL.") (defvar ad-use-jwz-byte-compiler (fboundp (quote eval-when-compile)) "\ *Non-NIL means Jamie Zawinski's v19 byte-compiler will be used. If you use a v18 Emacs and don't use jwz's optimizing byte-compiler (the normal case) then this variable should be NIL, because otherwise enabling definition hooks (e.g., for forward advice) will redefine the `byte-code' subr which will lead to some performance degradation for byte-compiled code.") (byte-code "!KMN#N#!&KMMM" [fboundp ad-real-fset fset put byte-compile byte-opcode ad-real-byte-code byte-code ad-substitute-tree #[(sUbTrEe-TeSt fUnCtIoN tReE) ":, @!\n@!$@:\" \n@#$@ \nA#B !6\n!" [tReE sUbTrEe-TeSt fUnCtIoN ad-substitute-tree] 5] ad-copy-tree #[(tree) ":@!A!B" [tree ad-copy-tree] 3]] 5) (defalias 'ad-dolist '(macro . #[(varform &rest body) "\nA@D\n@D\n@ECC$\nAA@F ˍ+ E- )" [let ad-dO-vAr varform append (while ad-dO-vAr) setq (car ad-dO-vAr) body (setq ad-dO-vAr (cdr ad-dO-vAr)) expansion contains-return (byte-code " #ć" [ad-substitute-tree #[(subtree) " != !=\"" [car-safe subtree ad-dolist ad-do-return throw contains-return t] 3] identity body nil] 4) catch (quote ad-dO-eXiT)] 7 "\ A Common-Lisp-style dolist iterator with the following syntax: (ad-dolist ( []) {body-form}*) which will iterate over the list yielded by binding to the current head at every iteration. If is supplied its value will be returned at the end of the iteration, NIL otherwise. The iteration can be exited prematurely with (ad-do-return [])."])) (byte-code "MN#!MMMN1#MMMMMMMM" [ad-do-return (macro . #[(value) "\nE" [throw (quote ad-dO-eXiT) value] 3]) ad-dolist lisp-indent-hook put 1 boundp ad-advised-functions nil ad-pushnew-advised-function (macro . #[(function) " DED DDEEE" [if not assoc symbol-name function ad-advised-functions setq cons list] 8]) ad-pop-advised-function (macro . #[(function) " DEEE" [setq ad-advised-functions delq assoc symbol-name function] 6]) ad-do-advised-functions (macro . #[(varform &rest body) "\n@\nA@E\n@\n@DDED#" [append (ad-dolist) varform ad-advised-functions setq intern car body] 8]) ad-get-advice-info (macro . #[(function) " E" [get function (quote ad-advice-info)] 3]) ad-set-advice-info (macro . #[(function advice-info) " F" [put function (quote ad-advice-info) advice-info] 4]) ad-copy-advice-info (macro . #[(function) "\nED" [ad-copy-tree get function (quote ad-advice-info)] 4]) ad-is-advised (macro . #[(function) " D" [ad-get-advice-info function] 2]) ad-initialize-advice-info #[(function) "\n! \"\n!C B\nBC#" [assoc symbol-name function ad-advised-functions put ad-advice-info active nil] 5] ad-get-advice-info-field (macro . #[(function field) "\n DED" [cdr assq field ad-get-advice-info function] 5]) ad-set-advice-info-field #[(function field value) "N\" N\" N\" \"N BC\"" [function ad-advice-info assq field rplacd value nconc] 5] ad-is-active #[(function) "\nN\"A" [assq active function ad-advice-info] 4]] 4) (defalias 'ad-make-advice #[(name protect enable definition) " \n F" [name protect enable definition] 4 "\ 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 ({}*) [docstring] [(interactive ...)] {body-form}*)"]) (byte-code "MMMMMMMM!)MMMMMMMMM!Z\"%MMM!o.MMM" [ad-advice-name (macro . #[(advice) " D" [car advice] 2]) ad-advice-protected (macro . #[(advice) "\nE" [nth 1 advice] 3]) ad-advice-enabled (macro . #[(advice) "\nE" [nth 2 advice] 3]) ad-advice-definition (macro . #[(advice) "\nE" [nth 3 advice] 3]) ad-advice-set-enabled #[(advice flag) " AA\n\"" [rplaca advice flag] 3] ad-class-p #[(thing) " >" [thing ad-advice-classes] 2] ad-name-p #[(thing) "9" [thing] 1] ad-position-p #[(thing) " ! >" [natnump thing (first last)] 2] boundp ad-advice-classes (before around after activation deactivation) ad-has-enabled-advice #[(function class) "" [ad-dO-eXiT (byte-code " \nN\"A'@ 8\"A*ć" [assq class function ad-advice-info nil advice ad-dO-vAr 2 throw ad-dO-eXiT t] 5)] 2] ad-has-redefining-advice #[(function) "N\"\"\"" [function ad-advice-info ad-has-enabled-advice before around after] 3] ad-has-any-advice #[(function) "N Í" [function ad-advice-info ad-dO-eXiT (byte-code "! @\n N\"A\" A*" [ad-advice-classes nil class ad-dO-vAr assq function ad-advice-info throw ad-dO-eXiT t] 5)] 2] ad-get-enabled-advices #[(function class) " N\"A,@8# BA* !)" [nil enabled-advices assq class function ad-advice-info advice ad-dO-vAr 2 reverse] 5] ad-make-origname #[(function) " \"!" [intern format "ad-Orig-%s" function] 4] ad-get-orig-definition (macro . #[(function) " EDCE" [let origname ad-get-advice-info-field function (quote origname) (if (fboundp origname) (symbol-function origname))] 5]) ad-set-orig-definition (macro . #[(function definition) "\nE" [ad-real-fset (ad-get-advice-info-field function (quote origname)) definition] 3]) ad-clear-orig-definition (macro . #[(function) "\nED" [fmakunbound ad-get-advice-info-field function (quote origname)] 4]) ad-read-advised-function #[(&optional prompt predicate default) "! ō\"  $ #-$\"J NC N \"N!*" [ad-advised-functions error "ad-read-advised-function: There are no advised functions" default ad-dO-eXiT (byte-code "& @\n@!  \n!\n\" A*" [ad-advised-functions nil function ad-dO-vAr intern predicate throw ad-dO-eXiT] 4) "ad-read-advised-function: %s" "There are no qualifying advised functions" predicate ad-pReDiCaTe completing-read format "%s(default %s) " prompt "Function: " #[(function) "\n@!!" [ad-pReDiCaTe intern function] 3] t function equal "" ad-advice-info "ad-read-advised-function: `%s' is not advised" intern] 5] ad-advice-class-completion-table mapcar #[(class) " !C" [symbol-name class] 2] ad-read-advice-class #[(function &optional prompt default) " \" # $\"-1!)" [default ad-dO-eXiT (byte-code "! @\n N\"A\n\" A*" [ad-advice-classes nil class ad-dO-vAr assq function ad-advice-info throw ad-dO-eXiT] 5) error "ad-read-advice-class: `%s' has no advices" function completing-read format "%s(default %s) " prompt "Class: " ad-advice-class-completion-table nil t class equal "" intern] 5] ad-read-advice-name #[(function class &optional prompt) " N\"A\" #@@  & #  $\"D !H!," [mapcar #[(advice) " @!C" [symbol-name advice] 2] assq class function ad-advice-info name-completion-table error "ad-read-advice-name: `%s' has no %s advice" default format "%s(default %s) " prompt "Name: " completing-read nil t name equal "" intern] 7] ad-read-advice-specification #[(&optional prompt) " !\n!\n \"\n E+" [ad-read-advised-function prompt function ad-read-advice-class class ad-read-advice-name name] 3] ad-last-regexp "" ad-read-regexp #[(&optional prompt) "  \"ł \"P!\"% ')" [read-from-minibuffer prompt "Regular expression: " equal ad-last-regexp "" format "(default \"%s\") " regexp] 5] ad-find-advice (macro . #[(function class name) " EE" [assq name ad-get-advice-info-field function class] 5]) ad-advice-position #[(function class name) " \n N\"A\"\n N\"A !G >GZ*" [assq name class function ad-advice-info found-advice advices] 6]] 3) (defalias 'ad-find-some-advice #[(function class name) "N ō)" [function ad-advice-info nil found-advice ad-dO-eXiT (byte-code ". @ =\n =Ǎ'\" A*" [ad-advice-classes nil advice-class ad-dO-vAr class any ad-dO-eXiT (byte-code " \nN\"A:@;$ @!\", @=1 \"A*ć" [assq advice-class function ad-advice-info nil advice ad-dO-vAr name string-match symbol-name throw ad-dO-eXiT] 5) found-advice throw] 4)] 2 "\ Finds 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 legal advice classes will be checked."]) (fset (quote ad-enable-advice-internal) #[(function class name flag) "Nw t@=&=kN\"A j@  ;N  @!\"W  @=a T \"A7*A* )" [function ad-advice-info 0 matched-advices ad-advice-classes nil advice-class ad-dO-vAr class any assq advice name string-match symbol-name ad-advice-set-enabled flag] 5]) (defalias 'ad-enable-advice #[(function class name) "N $= $\"" [function ad-advice-info ad-enable-advice-internal class name t 0 error "ad-enable-advice: `%s' has no %s advice matching `%s'" "ad-enable-advice: `%s' is not advised"] 5 "\ Enables the advice of FUNCTION with CLASS and NAME." (ad-read-advice-specification "Enable advice of: ")]) (defalias 'ad-disable-advice #[(function class name) "N $= $\"" [function ad-advice-info ad-enable-advice-internal class name nil 0 error "ad-disable-advice: `%s' has no %s advice matching `%s'" "ad-disable-advice: `%s' is not advised"] 5 "\ Disables the advice of FUNCTION with CLASS and NAME." (ad-read-advice-specification "Disable advice of: ")]) (fset (quote ad-enable-regexp-internal) #[(regexp class flag) "\n) @ @!  \n$ \\ A\n* )" [0 matched-advices ad-advised-functions nil advised-function ad-dO-vAr intern ad-enable-advice-internal class regexp flag] 7]) (defalias 'ad-enable-regexp #[(regexp) " #t \" )" [ad-enable-regexp-internal regexp any t matched-advices message "%d matching advices enabled"] 4 "\ Enables all advices with names that contain a match for REGEXP. All currently advised functions will be considered." (list (ad-read-regexp "Enable advices via regexp: "))]) (defalias 'ad-disable-regexp #[(regexp) " #t \" )" [ad-enable-regexp-internal regexp any nil matched-advices message "%d matching advices disabled"] 4 "\ Disables all advices with names that contain a match for REGEXP. All currently advised functions will be considered." (list (ad-read-regexp "Disable advices via regexp: "))]) (defalias 'ad-remove-advice #[(function class name) "N. N\"A\"& N\"A\"#, $)\"" [function ad-advice-info assq name class advice-to-remove ad-set-advice-info-field delq error "ad-remove-advice: `%s' has no %s advice `%s'" "ad-remove-advice: `%s' is not advised"] 10 "\ Removes 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." (ad-read-advice-specification "Remove advice of: ")]) (defalias 'ad-add-advice #[(function advice class position) "N!!#@# N\"A  V =6΂V =C GV !U  G^]V @\">h! z  \"\" U B# S \"  \"B\"+" [function ad-advice-info ad-initialize-advice-info ad-set-advice-info-field origname ad-make-origname ad-advice-position class advice previous-position assq advices position first 0 last numberp ad-get-cache-class-id ad-clear-cache setcar nthcdr setcdr] 6 "\ Adds a piece of ADVICE to FUNCTION's list of advices in CLASS. If FUNCTION already has one or more pieces of advice of the specified CLASS then POSITION determines where the new piece will go. The value of POSITION can either be `first', `last' or a number where 0 corresponds to `first'. Numbers outside the range will be mapped to the closest extreme position. If there was already a piece of ADVICE with the same name, then the position argument will be ignored and the old advice will be overwritten with the new one. If the FUNCTION was not advised already, then its advice info will be initialized. Redefining a piece of advice whose name is part of the cache-id will clear the cache."]) (byte-code "MM!\"MMMMMM!;!;MMMMMMMMMMMMMM!x2MMMMMM@AM" [ad-macrofy (macro . #[(definition) "\nE" [cons (quote macro) definition] 3]) ad-lambdafy (macro . #[(definition) " D" [cdr definition] 2]) boundp ad-special-forms mapcar symbol-function (and catch cond condition-case defconst defmacro defun defvar function if interactive let let* or prog1 prog2 progn quote save-excursion save-restriction save-window-excursion setq setq-default unwind-protect while with-output-to-temp-buffer) ad-special-form-p (macro . #[(definition) " E" [memq definition ad-special-forms] 3]) ad-interactive-p (macro . #[(definition) " D" [commandp definition] 2]) ad-subr-p (macro . #[(definition) " D" [subrp definition] 2]) ad-macro-p (macro . #[(definition) "\nDE" [eq car-safe definition (quote macro)] 3]) ad-lambda-p (macro . #[(definition) "\nDE" [eq car-safe definition (quote lambda)] 3]) ad-advice-p (macro . #[(definition) "\nDE" [eq car-safe definition (quote advice)] 3]) fboundp byte-code-function-p compiled-function-p ad-v19-compiled-p (macro . #[(definition) " D D DDEEE" [and ad-emacs19-p or byte-code-function-p definition ad-macro-p ad-lambdafy] 9]) ad-v19-compiled-code (macro . #[(compiled-definition) "\nD\nD\nF" [if ad-macro-p compiled-definition ad-lambdafy] 4]) ad-lambda-expression #[(definition) " !=\n != A != AŇ" [car-safe definition lambda macro advice nil] 2] ad-arglist #[(definition &optional name) "*\n!\n!=*\nA!*\n!=&\nA'\nH\n:5\n!A@\n!^E!\n\"\"!!O!!" [ad-emacs19-p byte-code-function-p definition car-safe macro 0 ad-lambda-expression subrp name ad-subr-arglist format "%s" string-match "^#]+\\)>$" intern match-beginning 1 match-end] 6] ad-define-subr-args (macro . #[(subr arglist) " DF" [put subr (quote ad-subr-arglist) list arglist] 5]) ad-undefine-subr-args (macro . #[(subr) " F" [put subr (quote ad-subr-arglist) nil] 4]) ad-subr-args-defined-p (macro . #[(subr) " E" [get subr (quote ad-subr-arglist)] 3]) ad-get-subr-args (macro . #[(subr) "\nED" [car get subr (quote ad-subr-arglist)] 4]) ad-subr-arglist #[(subr-name) "N N@\n!5 \"5 !!#@C#N@6)" [subr-name ad-subr-arglist ad-emacs19-p documentation doc string-match "[\n ]*\narguments: ?\\((.*)\\)\n?\\'" put read-from-string match-beginning 1 match-end (&rest ad-subr-args)] 9] ad-docstring #[(definition) " \n!\n!= \nA! Ǐ&\n!AA@ ;4 !6 )" [ad-emacs19-p byte-code-function-p definition car-safe macro nodoc (byte-code " != A H" [car-safe definition macro 4] 2) ((error)) ad-lambda-expression docstring natnump] 4] ad-interactive-form #[(definition) "2\n!\n!=2\nA!2\n!G\n!=-\nA.\nHD\n!=B\n!=G\n!!" [ad-emacs19-p byte-code-function-p definition car-safe macro commandp interactive 5 advice lambda ad-lambda-expression] 3] ad-body-forms #[(definition) "5\n!\n!=5\nA!5\n!=&\nA'\n\nH\nH\nHFC\n:X\n!EƂF\n!PƂQ\\\n!AA\"" [ad-emacs19-p byte-code-function-p definition car-safe macro byte-code 1 2 3 nthcdr ad-docstring 0 ad-interactive-form ad-lambda-expression] 5] ad-compiled-p #[(definition) "\n!!\n!=\nA!!\n!@!>" [ad-emacs19-p byte-code-function-p definition car-safe macro ad-body-forms (byte-code ad-real-byte-code)] 3] ad-advised-definition-docstring-regexp "^\\$ad-doc: \\(.+\\)\\$$" ad-make-advised-definition-docstring #[(function) " !\"" [format "$ad-doc: %s$" prin1-to-string function] 4] ad-advised-definition-p #[(definition) " != != !' !;&\")" [car-safe definition lambda macro ad-compiled-p ad-docstring docstring string-match ad-advised-definition-docstring-regexp] 4] ad-definition-type #[(definition) " !=\n‡ ! >ŇƇ !=( !*ɇ !=3ʇ" [car-safe definition macro subrp ad-special-forms special-form subr lambda ad-compiled-p function advice] 2] ad-has-proper-definition #[(function) "9!K!=?" [function fboundp car-safe autoload] 2] ad-real-definition #[(function) " ! K9\n!\n)" [ad-has-proper-definition function definition ad-real-definition] 3] ad-real-orig-definition #[(function) "NN\"A!" [function ad-advice-info ad-real-definition assq origname] 5] ad-is-compilable #[(function) " ! K!= K!= K!?" [ad-has-proper-definition function car-safe lambda macro ad-compiled-p] 2]] 3) (defalias 'ad-compile-function #[(function) " !$\" !$ K!=$ K!!BM" [ad-is-compilable function require byte-compile "bytecomp" car-safe macro byte-compile-lambda ad-lambda-expression] 5 "\ Byte-compiles FUNCTION (or macro) if it is not yet compiled." "aByte-compile function: "]) (byte-code "MMMMMMMMMMMMM" [ad-real-byte-codify #[(function) " ! K \n!-\n!= \nA!-\n!-\n!@\")" [ad-compile-function function definition ad-emacs19-p byte-code-function-p car-safe macro ad-compiled-p setcar ad-body-forms ad-real-byte-code] 3] ad-prognify #[(forms) "GX\n@B" [forms 1 progn] 2] ad-parse-arglist #[(arglist) " >A@ !>A! >A. !>A!0  \n E+" [nil required optional rest &rest arglist reverse &optional] 5] ad-retrieve-args-form #[(arglist) " !\n8\n@\"\nA@\" ! D FC$*" [ad-parse-arglist arglist parsed-arglist 2 rest append (list) mapcar #[(req) "\nD\nF" [list quote req (quote required)] 4] #[(opt) "\nD\nF" [list quote opt (quote optional)] 4] list quote (quote rest)] 8] ad-arg-binding-field #[(binding field) "= \n@=\nA@=\nAA@" [field name binding value type] 2] ad-list-access #[(position list) "U\nU\nD\nE" [position 0 list 1 cdr nthcdr] 3] ad-element-access #[(position list) "U\n DU DD E" [position 0 car list 1 cdr nth] 3] ad-access-argument #[(arglist index) " !\n@\nA@\"\n8 GW  8-- GZD+" [ad-parse-arglist arglist parsed-arglist append reqopt-args 2 rest-arg index] 3] ad-get-argument #[(arglist index) " \n\": @ A@\" )" [ad-access-argument arglist index argument-access ad-element-access] 4] ad-set-argument #[(arglist index value-form) " \n\": @ A@\"E) $ E)\n #)" [ad-access-argument arglist index argument-access setcar ad-list-access value-form setq error "ad-set-argument: No argument at position %d of `%s'"] 5] ad-get-arguments #[(arglist index) " !\n@\nA@\"\n8 GW& \"\"F;EF GZ\"," [ad-parse-arglist arglist parsed-arglist append reqopt-args 2 rest-arg nil args-form index (list) nthcdr nconc ad-list-access] 5] ad-set-arguments #[(arglist index values-form) "\"X 9& \"#\nBM @U9 A@ \"EG @S A@\" \"E\nBT T\nf#\nGUv\n@#DCC\n!C$+" [0 nil set-forms argument-access values-index ad-access-argument arglist index 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 #[(form) "=" [form ad-vAlUeS] 2] (lambda (form) values-form) append (let) values-form reverse] 6] ad-insert-argument-access-forms #[(definition arglist) " #" [ad-substitute-tree #[(form) "=!>A!!" [form ad-arg-bindings car-safe (ad-get-arg ad-get-args ad-set-arg ad-set-args) integerp] 3] #[(form) "=\n !@A@A \"A@=) \"U=9  #U=H \"U=U  #+" [form ad-arg-bindings ad-retrieve-args-form arglist ad-insert-argument-access-forms val index accessor ad-get-arg ad-get-argument ad-set-arg ad-set-argument ad-get-args ad-get-arguments ad-set-args ad-set-arguments] 6] definition] 4]] 2) (defalias 'ad-map-arglists #[(source-arglist target-arglist) " !\n@\nA@\"\n8!@A@\" 8\n/\n   >΂?D O C\"a \n_ G \"\"\"\"." [ad-parse-arglist source-arglist parsed-source-arglist append source-reqopt-args 2 source-rest-arg target-arglist parsed-target-arglist target-reqopt-args target-rest-arg need-apply -1 target-arg-index apply funcall function mapcar #[(arg) "T\n\"" [target-arg-index ad-get-argument source-arglist] 3] nthcdr] 9 "\ Makes 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 function a (car args) (car (cdr args)) (nth 2 args))"]) (byte-code "MMMMMMMMMMM" [ad-make-mapped-call #[(source-arglist target-arglist target-function) " \n\"@= AAB A D\")" [ad-map-arglists source-arglist target-arglist mapped-form funcall target-function setcar quote] 6] ad-make-single-advice-docstring #[(advice class) "\n8!\n@ ǂ %)" [ad-docstring 3 advice advice-docstring format "%s (%s):%s%s" class "\n" ""] 6] ad-make-advised-docstring #[(function) " !\n ?#%˂&\n!!#&*" [ad-real-orig-definition function origdef apply documentation ad-emacs19-p ad-lemacs-p (t) origdoc concat "" "\n\n" "\n" "This " symbol-name ad-definition-type " is advised with the following advice(s):" mapconcat #[(class) " \"#" [mapconcat #[(advice) "\n \"P" ["\n\n" ad-make-single-advice-docstring advice class] 4] ad-get-enabled-advices function class ""] 5] ad-advice-classes] 10] ad-advised-arglist #[(function) "" [ad-dO-eXiT (byte-code "\n\"\n\"\n\"#8@8! . \")A*Ƈ" [append ad-get-enabled-advices function before around after nil advice ad-dO-vAr ad-arglist 3 arglist throw ad-dO-eXiT] 7)] 2] ad-advised-interactive-form #[(function) "" [ad-dO-eXiT (byte-code "\n\"\n\"\n\"#8@8! . \")A*Ƈ" [append ad-get-enabled-advices function before around after nil advice ad-dO-vAr ad-interactive-form 3 interactive-form throw ad-dO-eXiT] 7)] 2] ad-make-advised-definition #[(function) "N!!N\"A ! !\n  > != \"!>!Nւxx !xx!@vG\"DDw) ߂D\"ED\nDD#F#(΂ !(\"\"\"&. " [function ad-advice-info ad-has-redefining-advice ad-real-orig-definition origdef assq origname commandp orig-interactive-p subrp orig-subr-p ad-special-forms orig-special-form-p car-safe macro orig-macro-p ad-arglist orig-arglist ad-advised-arglist advised-arglist ad-advised-interactive-form advised-interactive-form nil ad-interactive-form ad-parse-arglist reqargs interactive quote make-list (interactive) interactive-form macroexpand eval cons ad-get-arguments 0 if (interactive-p) call-interactively ad-make-mapped-call orig-form ad-assemble-advised-definition special-form ad-make-advised-definition-docstring ad-get-enabled-advices before around after] 12] ad-assemble-advised-definition #[(type args docstring interactive orig &optional befores arounds afters) "I@A@6 6 !D8!\"C@ 8!\"A*E!@A@j8!!#A]* ! EC C\"@A@\n\n!D8!\"C\n8!\"A*>CCC\n=C#C& \"-" [nil definition after-forms around-form-protected around-form before-forms befores advice ad-dO-vAr append unwind-protect ad-prognify ad-body-forms 3 setq ad-return-value orig reverse arounds t ad-substitute-tree #[(form) "=" [form ad-do-it] 2] (lambda (form) around-form) afters type (macro special-form) (macro) (lambda) args docstring interactive (let (ad-return-value)) special-form (list (quote quote) ad-return-value) ad-insert-argument-access-forms] 12] ad-make-hook-form #[(function hook-name) " \"\" \"!)" [mapcar #[(advice) "\n8!" [ad-body-forms 3 advice] 3] ad-get-enabled-advices function hook-name hook-forms ad-prognify apply append] 6] ad-get-cache-definition (macro . #[(function) "\nED" [car ad-get-advice-info-field function (quote cache)] 4]) ad-get-cache-id (macro . #[(function) "\nED" [cdr ad-get-advice-info-field function (quote cache)] 4]) ad-set-cache (macro . #[(function definition id) " EF" [ad-set-advice-info-field function (quote cache) cons definition id] 6])] 2) (defalias 'ad-clear-cache #[(function) " #" [ad-set-advice-info-field function cache nil] 4 "\ 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." (list (ad-read-advised-function "Clear cached definition of: "))]) (byte-code "MMMMMMM" [ad-make-cache-id #[(function) " ! N\"A@ \"\" \"\" \"\"! \" !\"9ӂ> \"!=P! !\"&*" [ad-real-orig-definition function assq cache ad-advice-info cached-definition original-definition list mapcar #[(advice) "@" [advice] 1] ad-get-enabled-advices before #[(advice) "@" [advice] 1] around #[(advice) "@" [advice] 1] after ad-definition-type equal ad-arglist t ad-interactive-form] 10] ad-get-cache-class-id #[(function class) "\nN\"AA = @# = A@# 8)" [assq cache function ad-advice-info cache-id class before around 2] 4] ad-verify-cache-class-id #[(cache-class-id advices) "" [ad-dO-eXiT (byte-code "+ @\n8$ @\n@= A$\" A *?" [advices nil advice ad-dO-vAr 2 cache-class-id throw ad-dO-eXiT] 4)] 2] ad-cache-id-verification-code #[(function) "\nN\"AA@\nN\"A\"ɉ8\nN\"A\"̉8\nN\"A\"ω\n!\nN\"A@8!=Չ8=\n\"8!\"ډ8!!\"* *" [assq cache function ad-advice-info before-advice-mismatch code cache-id ad-verify-cache-class-id before around-advice-mismatch 1 around after-advice-mismatch 2 after definition-type-mismatch ad-real-orig-definition cached-definition original-definition 3 ad-definition-type arglist-mismatch equal 4 t ad-arglist interactive-form-mismatch 5 ad-interactive-form verified] 6] ad-verify-cache-id #[(function) " !=" [ad-cache-id-verification-code function verified] 2] ad-preactivate-advice #[(function advice class position) " !\n K N!Ȏ \n  $  \n@# ! \" !V N\"A@V N\"A@ N\"AAD-" [fboundp function function-defined-p old-definition ad-copy-tree ad-advice-info old-advice-info ad-advised-functions ((byte-code " #  M !" [put function ad-advice-info old-advice-info function-defined-p old-definition fmakunbound] 4)) ad-add-advice advice class position ad-enable-advice ad-clear-cache ad-activate nil ad-is-active assq cache] 6] ad-activate-advised-definition #[(function compile) " ! N\"A@  !M\" ! @ K=?W K N\"AAB#W ! KB# K !B#)" [ad-verify-cache-id function assq cache ad-advice-info verified-cached-definition ad-make-advised-definition compile ad-compile-function ad-set-advice-info-field ad-clear-cache nil ad-make-cache-id] 8]] 2) (defalias 'ad-handle-definition #[(function) "\nN\"A ! K)\n!\nKm|=?|!?| >F\n#| =T\nM|\nN\"AM =|\n\"||\nN\"AM*" [assq origname function ad-advice-info fboundp ad-real-definition current-definition original-definition ad-advised-definition-p ad-redefinition-action (accept discard warn) error "ad-handle-definition (see its doc): `%s' %s" "illegally redefined" discard warn message "ad-handle-definition: `%s' got redefined"] 5 "\ Handles 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."]) (defalias 'ad-activate #[(function &optional compile) "N \"!N\"A!\"K)N!0!!K \"#\"!!" [function ad-advice-info error "ad-activate: `%s' is not advised" ad-handle-definition assq origname fboundp ad-has-any-advice ad-unadvise ad-has-redefining-advice ad-activate-advised-definition compile ad-set-advice-info-field active t eval ad-make-hook-form activation ad-deactivate] 4 "\ Activates 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. With an argument (compile is non-NIL) the resulting function (or a compilable cached definition) will also be compiled. 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." (list (ad-read-advised-function "Activate advice of: ") current-prefix-arg)]) (defalias 'ad-deactivate #[(function) "N \"!V!N\"A!(K)1\"N\"A!EK)M#\"!" [function ad-advice-info error "ad-deactivate: `%s' is not advised" ad-is-active ad-handle-definition assq origname fboundp "ad-deactivate: `%s' has no original definition" ad-set-advice-info-field active nil eval ad-make-hook-form deactivation] 5 "\ Deactivates 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'." (list (ad-read-advised-function "Deactivate advice of: " (quote ad-is-active)))]) (defalias 'ad-update #[(function &optional compile) " !  K!\"" [ad-is-active function ad-activate compile ad-compiled-p] 4 "\ Update the advised definition of FUNCTION if its advice is active. With a prefix argument or if the current definition is compiled compile the resulting advised definition." (list (ad-read-advised-function "Update advised definition of: " (quote ad-is-active)))]) (defalias 'ad-unadvise #[(function) "N.!!N\"A!#! \" \" " [function ad-advice-info ad-is-active ad-deactivate fmakunbound assq origname put nil delq assoc symbol-name ad-advised-functions] 5 "\ Deactivates FUNCTION and then removes all its advice information. If FUNCTION was not advised this will be a noop." (list (ad-read-advised-function "Unadvise function: "))]) (defalias 'ad-recover #[(function) "NLN\"A ! K)8N\"A !+ K)MN\"A!#! \" \" " [function ad-advice-info assq origname fboundp fmakunbound put nil delq assoc symbol-name ad-advised-functions] 5 "\ Tries to recover FUNCTION's original definition and unadvises it. This is more low-level than `ad-unadvise' because it does not do any deactivation which might run hooks and get into other trouble. Use in emergencies." (list (intern (completing-read "Recover advised function: " obarray nil t)))]) (defalias 'ad-activate-regexp #[(regexp &optional compile) "& @\n@!\n#\n \" A*" [ad-advised-functions nil function ad-dO-vAr intern ad-find-some-advice any regexp ad-activate compile] 5 "\ Activates functions with an advice name containing a REGEXP match. With prefix argument compiles resulting advised definitions." (list (ad-read-regexp "Activate via advice regexp: ") current-prefix-arg)]) (defalias 'ad-deactivate-regexp #[(regexp) "$ @\n@!\n#\n! A*" [ad-advised-functions nil function ad-dO-vAr intern ad-find-some-advice any regexp ad-deactivate] 5 "\ Deactivates functions with an advice name containing REGEXP match." (list (ad-read-regexp "Deactivate via advice regexp: "))]) (defalias 'ad-update-regexp #[(regexp &optional compile) "& @\n@!\n#\n \" A*" [ad-advised-functions nil function ad-dO-vAr intern ad-find-some-advice any regexp ad-update compile] 5 "\ Updates functions with an advice name containing a REGEXP match. With prefix argument compiles resulting advised definitions." (list (ad-read-regexp "Update via advice regexp: ") current-prefix-arg)]) (defalias 'ad-activate-all #[(&optional compile) " @\n@!\n! A*" [ad-advised-functions nil function ad-dO-vAr intern ad-activate] 3 "\ Activates all currently advised functions. With prefix argument compiles resulting advised definitions." "P"]) (defalias 'ad-deactivate-all #[nil " @\n@!\n! A*" [ad-advised-functions nil function ad-dO-vAr intern ad-deactivate] 3 "\ Deactivates all currently advised functions." nil]) (defalias 'ad-update-all #[(&optional compile) " @\n@!\n\" A*" [ad-advised-functions nil function ad-dO-vAr intern ad-update compile] 4 "\ Updates all currently advised functions. With prefix argument compiles resulting advised definitions." "P"]) (defalias 'ad-unadvise-all #[nil " @\n@!\n! A*" [ad-advised-functions nil function ad-dO-vAr intern ad-unadvise] 3 "\ Unadvises all currently advised functions." nil]) (defalias 'ad-recover-all #[nil " @\n@!Ǐ A*" [ad-advised-functions nil function ad-dO-vAr intern ignore-errors (ad-recover function) ((error))] 4 "\ Recovers all currently advised functions. Use in emergencies." nil]) (byte-code "!" [boundp ad-defadvice-flags (("protect") ("disable") ("activate") ("compile") ("preactivate"))] 2) (defalias 'defadvice '(macro . #[(function args &rest body) " ! \" @ ! \" A@!/\"? AA @!? @ A @>? D#$>{   $ DD D D%C D@!=@ADD@DA@DFC> D>EC DC%." [ad-name-p function error "defadvice: Illegal function name: %s" args class ad-class-p "defadvice: Illegal advice class: %s" name "defadvice: Illegal advice name: %s" ad-position-p position arglist mapcar #[(flag) "\n! \"=\n\" \" !\"\n\")" [try-completion symbol-name flag ad-defadvice-flags completion t assoc intern error "defadvice: Illegal or ambiguous flag: %s"] 4] flags ad-make-advice protect disable append (advice) lambda body advice preactivate ad-preactivate-advice preactivation (progn) list ad-add-advice quote ad-set-cache car-safe macro ad-macrofy activate ad-activate compile t] 9 "\ Defines a piece of advice for FUNCTION (a symbol). (defadvice ( [] [] {}*) [ [] [] ] {}* ) ::= name of the function to be advised ::= before | around | after | activation | deactivation ::= non-NIL symbol that names this piece of advice ::= first | last | (optional, defaults to `first', see also `ad-add-advice') ::= 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. ::= protect | disable | activate | compile | preactivate All flags can be specified with unambiguous initial substrings. ::= optional documentation for this piece of advice ::= optional interactive form to be used for the advised function. The first one found in before/around/after advices will be used. ::= 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 the 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 (with a v18 byte-compiler put the defadvice into the body of a defun). Look at the file advice.el for comprehensive documentation."])) (defalias 'ad-with-originals '(macro . #[(functions &rest body) " \"  \" #D \"\"E*" [-1 index mapcar #[(function) "T\"!DDD" [index intern format "ad-oRiGdEf-%d" symbol-function quote function] 4] functions current-bindings let append unwind-protect (progn) #[(function) "T D DD8@EE" [index ad-real-fset quote function or ad-get-orig-definition current-bindings] 6] body #[(function) "T D 8@E" [index ad-real-fset quote function current-bindings] 4]] 9 "\ Binds FUNCTIONS to their original definitions and executes 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."])) (byte-code "N #!Ƈ" [ad-with-originals lisp-indent-hook put 1 boundp ad-defined-function nil] 4) (defalias 'ad-activate-defined-function #[(&optional function) "\n \n N!K!\"" [function ad-defined-function ad-advice-info ad-real-definition ad-activate ad-compiled-p] 4 "\ Activates the advice of an advised and defined FUNCTION. If the current definition of FUNCTION is byte-compiled then the advised definition will be compiled too. FUNCTION defaults to the value of `ad-defined-function'."]) (byte-code "C#C#MK! !) !2 !;!D! !  S\\!#!P!& +MM" [ad-emacs19-p put documentation ad-subr-arglist (fun1) fset (sym newdef) ad-execute-defadvices #[nil "$BB#$BB#$B#$B#$B#$B#ڇ" [ad-add-advice defun (ad-definition-hooks nil t (advice lambda nil "Whenever a function gets re/defined with `defun' all hook functions\nin `ad-definition-hooks' will be run after the re/definition with\n`ad-defined-function' bound to the name of the function." (let ((ad-defined-function (ad-get-arg 0))) (run-hooks (quote ad-definition-hooks))))) after first ad-set-advice-info-field cache macro #[(&rest ad-subr-args) " B! @!) )D" [nil ad-return-value eval ad-Orig-defun ad-subr-args ad-defined-function run-hooks ad-definition-hooks quote] 3 "$ad-doc: defun$"] (nil nil (ad-definition-hooks) special-form t nil) defmacro (ad-definition-hooks nil t (advice lambda nil "Whenever a macro gets re/defined with `defmacro' all hook functions\nin `ad-definition-hooks' will be run after the re/definition with\n`ad-defined-function' bound to the name of the function." (let ((ad-defined-function (ad-get-arg 0))) (run-hooks (quote ad-definition-hooks))))) #[(&rest ad-subr-args) " B! @!) )D" [nil ad-return-value eval ad-Orig-defmacro ad-subr-args ad-defined-function run-hooks ad-definition-hooks quote] 3 "$ad-doc: defmacro$"] (nil nil (ad-definition-hooks) special-form t nil) fset (ad-definition-hooks nil t (advice lambda nil "Whenever a function gets re/defined with `fset' all hook functions\nin `ad-definition-hooks' will be run after the re/definition with\n`ad-defined-function' bound to the name of the function. This advice was\nmainly created to handle forward-advice for byte-compiled files created\nby jwz's byte-compiler used in Lemacs.\nCAUTION: If you need the primitive `fset' behavior either deactivate\n its advice or use `ad-real-fset' instead!" (let ((ad-defined-function (ad-get-arg 0))) (run-hooks (quote ad-definition-hooks))))) #[(sym newdef) " \" !) )" [nil ad-return-value ad-Orig-fset sym newdef ad-defined-function run-hooks ad-definition-hooks] 3 "$ad-doc: fset$"] (nil nil (ad-definition-hooks) subr t nil) defalias (ad-definition-hooks nil t (advice lambda nil "Whenever a function gets re/defined with `defalias' all hook functions\nin `ad-definition-hooks' will be run after the re/definition with\n`ad-defined-function' bound to the name of the function. This advice was\nmainly created to handle forward-advice for byte-compiled files created\nby jwz's byte-compiler used in GNU Emacs-19." (let ((ad-defined-function (ad-get-arg 0))) (ad-with-originals (defalias) (run-hooks (quote ad-definition-hooks)))))) #[(sym newdef) " \" KȎN\"A\n\n!#\nK))M!+ )" [nil ad-return-value ad-Orig-defalias sym newdef ad-defined-function defalias ad-oRiGdEf-0 ((byte-code " M" [defalias ad-oRiGdEf-0] 2)) assq origname ad-advice-info fboundp run-hooks ad-definition-hooks] 5 "$ad-doc: defalias$"] (nil nil (ad-definition-hooks) subr t nil) define-function (ad-definition-hooks nil t (advice lambda nil "Whenever a function gets re/defined with `define-function' all hook\nfunctions in `ad-definition-hooks' will be run after the re/definition with\n`ad-defined-function' bound to the name of the function." (let ((ad-defined-function (ad-get-arg 0))) (ad-with-originals (define-function) (run-hooks (quote ad-definition-hooks)))))) #[(sym newdef) " \" KȎN\"A\n\n!#\nK))M!+ )" [nil ad-return-value ad-Orig-define-function sym newdef ad-defined-function define-function ad-oRiGdEf-0 ((byte-code " M" [define-function ad-oRiGdEf-0] 2)) assq origname ad-advice-info fboundp run-hooks ad-definition-hooks] 5 "$ad-doc: define-function$"] (nil nil (ad-definition-hooks) subr t nil) documentation (ad-advised-docstring nil t (advice lambda nil "Builds an advised docstring if FUNCTION is advised." (if (and (stringp ad-return-value) (string-match ad-advised-definition-docstring-regexp ad-return-value)) (let ((function (car (read-from-string ad-return-value (match-beginning 1) (match-end 1))))) (cond ((ad-is-advised function) (setq ad-return-value (ad-make-advised-docstring function)) (if (not (ad-get-arg 1)) (setq ad-return-value (substitute-command-keys ad-return-value))))))))) #[(function &optional raw) " \";2 \"2 !!#@N1 ! 1 !) )" [nil ad-return-value ad-Orig-documentation function raw string-match ad-advised-definition-docstring-regexp read-from-string match-beginning 1 match-end ad-advice-info ad-make-advised-docstring substitute-command-keys] 6 "$ad-doc: documentation$"] (nil nil (ad-advised-docstring) subr t nil)] 5] ad-compiled-p boundp byte-constant 192 byte-constant-limit 64 byte-constant2 129 byte-fset 77 ad-byte-code-fset-regexp format "[%s-%s]" char-to-string constant-reference "[-][-]" constant2-reference fset-opcode concat "\\(" "\\|" "\\)" ad-find-fset-in-byte-code #[(code constants start) " \n #ĉs\n HU0\n TH\n TH\"\\ T;\n H\nZ T\n HU[\n TH\n TH\"\\ Te\n H\nZ T H H Et+" [string-match ad-byte-code-fset-regexp code start nil code-index name-index byte-constant2 * 256 byte-constant constants] 6] ad-scan-byte-code-for-fsets #[(ad-code ad-constants) "KMď" [byte-code ad-real-byte-code ignore-errors (byte-code " AA@#2 @9 @! @K A@= @!)KM)" [(0 0 0) fset-args ad-find-fset-in-byte-code ad-code ad-constants fboundp ad-defined-function run-hooks ad-definition-hooks byte-code ad-advised-byte-code] 4) ((error))] 3]] 12) (defalias 'ad-advised-byte-code-definition #[(ad-cOdE ad-cOnStAnTs ad-dEpTh) " \n #  \n\"" [ad-real-byte-code ad-cOdE ad-cOnStAnTs ad-dEpTh load-in-progress ad-scan-byte-code-for-fsets] 4 "\ Modified version of `byte-code' subr used by the advice package. `byte-code' has been modified to allow automatic activation of forward advice for functions that are defined in byte-compiled files generated by jwz's byte-compiler (as standardly used in v19s). See `ad-real-byte-code' for original documentation."]) (byte-code "!KM" [ad-real-byte-codify ad-advised-byte-code-definition ad-advised-byte-code] 2) (defalias 'ad-recover-byte-code #[nil "KM" [byte-code ad-real-byte-code] 2 "\ Recovers the real `byte-code' functionality." nil]) (byte-code "!! !" [ad-real-byte-codify ad-recover-byte-code boundp ad-orig-max-lisp-eval-depth max-lisp-eval-depth ad-orig-max-specpdl-size max-specpdl-size] 2) (defalias 'ad-adjust-stack-sizes #[(&optional reset) "\n   \" \n\"\"\\" [reset ad-orig-max-lisp-eval-depth max-lisp-eval-depth ad-orig-max-specpdl-size max-specpdl-size * 3 / 5] 5 "\ Increases stack sizes for the advised `byte-code' function. When called with a prefix argument the stack sizes will be reset to their original values. Calling this function should only be necessary if you get stack overflows because you run highly recursive v18 compiled code in a v19 Emacs with definition hooks enabled." "P"]) (byte-code "MM!" [ad-enable-definition-hooks #[nil " @\n#\n\" A* 8!!KM?8 " [(defun defmacro fset defalias define-function) nil definer ad-dO-vAr ad-enable-advice after ad-definition-hooks ad-activate compile ad-use-jwz-byte-compiler ad-real-byte-codify ad-advised-byte-code ad-scan-byte-code-for-fsets byte-code ad-emacs19-p ad-adjust-stack-sizes] 5] ad-disable-definition-hooks #[nil "  @ # ! A * ?)!" [ad-recover-byte-code (defun defmacro fset defalias define-function) nil definer ad-dO-vAr ad-disable-advice after ad-definition-hooks ad-update ad-emacs19-p ad-adjust-stack-sizes reset] 5] ad-real-byte-codify] 2) (defalias 'ad-start-advice #[nil "#\"  6\n>/\n;\nB;\n\"\n" [ad-enable-advice documentation after ad-advised-docstring ad-activate compile ad-activate-on-definition ad-enable-definition-hooks ad-disable-definition-hooks ad-activate-defined-function ad-definition-hooks delq] 4 "\ Redefines some primitives to start the advice magic. If `ad-activate-on-definition' is t then advice information will automatically get activated whenever an advised function gets defined or redefined. This will enable goodies such as forward advice and automatically enable function definition hooks. If its value is nil but the value of `ad-enable-definition-hooks' is t then definition hooks will be enabled without having automatic advice activation, otherwise function definition hooks will be disabled too. If definition hooks are enabled then functions stored in `ad-definition-hooks' are run whenever a function gets defined or redefined." nil]) (defalias 'ad-stop-advice #[nil " #!  \" " [ad-recover-byte-code ad-disable-advice documentation after ad-advised-docstring ad-update ad-disable-definition-hooks delq ad-activate-defined-function ad-definition-hooks] 4 "\ Undefines some primitives to stop the advice magic. This can also be used to recover from advice related emergencies." nil]) (ad-real-byte-codify (quote ad-stop-advice)) (defalias 'ad-recover-normality #[nil " ‰" [ad-recover-byte-code ad-recover-all nil ad-advised-functions] 2 "\ Undoes all advice related redefinitions and unadvises everything. Use only in REAL emergencies." nil]) (byte-code "!\nK! !" [ad-real-byte-codify ad-recover-normality ad-start-advice-on-load ad-compiled-p ad-execute-defadvices ad-start-advice provide advice] 2)