;ELC ;;; compiled by roland@churchy.gnu.ai.mit.edu on Fri Jul 16 15:53:21 1993 ;;; from file /gd/gnu/emacs/19.0/lisp/advice.el ;;; emacs version 19.16.11. ;;; bytecomp version FSF 2.10 ;;; optimization is on. ;;; this file uses opcodes which do not exist in Emacs 18. (if (and (boundp 'emacs-version) (or (and (boundp 'epoch::version) epoch::version) (string-lessp emacs-version "19"))) (error "This file was compiled for Emacs 19")) (byte-code "АБ!€ВБГ\"€ДЕ!„ЖЕЗ\"€И А‡" [provide advice-preload require "advice.el" fboundp \` autoload "backquote" "2.1" ad-version] 3) (defconst ad-emacs19-p (byte-code "АБ!ѓ\n † \nГ™?‡" [boundp epoch::version emacs-version "19"] 2) "\ 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 t "\ *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 "АБ!„БВKM€ГБДВДN#€ГБЕВЕN#€АЖ!„&ЖЗKM€ИЙК\"€ИЛМ\"‡" [fboundp ad-real-fset fset put byte-compile byte-opcode ad-real-byte-code byte-code defalias 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@ЖECИC$\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) "ўБ=†ўВ=…ГДЕ\"‡" [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 "АБВ\"€ГДN„ЕГДЖ#€ЗИ!„ЙАКЛ\"€АМН\"€АОП\"€ОДN„5ЕОДЖ#€АРС\"€АТУ\"€АФХ\"€АЦЧ\"€АШЩ\"€АЪЫ\"€АЬЭ\"€АЮЯ\"‡" [defalias 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) "АБВГDЕEDЖЕЗИГDDЕEEE‡" [if not assoc symbol-name function ad-advised-functions setq cons list] 8]) ad-pop-advised-function (macro . #[(function) "АБВГД DБEБEE‡" [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) "АБ\nГED‡" [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!CBД\nЕЖЗBC#‡" [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БNћЎ‡БN\nBC¤‡" [function ad-advice-info field value] 3] ad-is-active #[(function) "А ВNћA‡" [active function ad-advice-info] 3]] 4) (defalias 'ad-make-advice #[(name protect enable definition) " \nF‡" [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 "АБВ\"€АГД\"€АЕЖ\"€АЗИ\"€АЙК\"€АЛМ\"€АНО\"€АПР\"€СТ!„1УАФХ\"€АЦЧ\"€АШЩ\"€АЪЫ\"€АЬЭ\"€АЮЯ\"€Ааб\"€Авг\"€Аде\"€Сж!„kзи\"&Айк\"€Алм\"€Ано\"€Сп!„ѓр/Аст\"€Ауф\"€Ахц\"‡" [defalias 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 ‡" [advice flag] 2] 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 " ВNћAГ‰ѓ\" @Ж8ѓЗИЙ\"€ A‰„ *Г‡" [class function ad-advice-info nil advice ad-dO-vAr 2 throw ad-dO-eXiT t] 4)] 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ћAѓЖЗИ\"€A‰„*Б‡" [ad-advice-classes nil class ad-dO-vAr function ad-advice-info throw ad-dO-eXiT t] 4)] 2] ad-get-enabled-advices #[(function class) "А\nДNћAА‰ѓ'@З 8ѓ BA‰„*И !)‡" [nil enabled-advices class function ad-advice-info advice ad-dO-vAr 2 reverse] 4] ad-make-origname #[(function) "АБВ\"!‡" [intern format "ad-Orig-%s" function] 4] ad-get-orig-definition (macro . #[(function) "АБВДEDCЕE‡" [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) "АБ\nГED‡" [fmakunbound ad-get-advice-info-field function (quote origname)] 4]) ad-read-advised-function #[(&optional prompt predicate default) "„БВ!€†ДЕЌ†БЖЗ\" КЛМ †$О#…-ПР$‰ТљѓHУNѓA‚LБФ\"‚LХ!*‡" [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 "" ad-advice-info "ad-read-advised-function: `%s' is not advised" intern] 6] ad-advice-class-completion-table mapcar #[(class) "А !C‡" [symbol-name class] 2] ad-read-advice-class #[(function &optional prompt default) "†БВЌ†ГД \"ЖЗИ †К#МН$‰Пљѓ+‚/Р!)‡" [default ad-dO-eXiT (byte-code "Б‰ѓ @‰ЕNћAѓЖЗ\n\"€A‰„*Б‡" [ad-advice-classes nil class ad-dO-vAr function ad-advice-info throw ad-dO-eXiT] 4) 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 "" intern] 6] ad-read-advice-name #[(function class &optional prompt) "АБ\nДNћA\"‰„ЖЗ\n#‚ @@ЙК†#М#Н ОП$‰Сљѓ>Т!‚BТ!,‡" [mapcar #[(advice) "А @!C‡" [symbol-name advice] 2] 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 "" intern] 6] ad-read-advice-specification #[(&optional prompt) "А !Г\n!Е\n\"\nE+‡" [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: " ad-last-regexp "" format "(default \"%s\") " regexp] 6] 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*‡" [name class function ad-advice-info found-advice advices] 4]] 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 " ВNћAГ‰ѓ5 @;ѓ!ЗИ@!\"„)@=ѓ.ЙК\"€ A‰„ *Г‡" [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."]) (defalias (quote ad-enable-advice-internal) #[(function class name flag) "БN…vВЕ‰ѓs@Й=„&=ѓjБNћAЕ\n‰ѓi@\n;ѓMМН\n@!\"„V\n@=ѓ`TО\n\"€A‰„6*A‰„*)‡" [function ad-advice-info 0 matched-advices ad-advice-classes nil advice-class ad-dO-vAr class any 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: ")]) (defalias (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БNћAћ‰ѓ#ЕЖБNћA\"#‚)ЗИ\n$)‡ЗЙ\"‡" [function ad-advice-info 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"] 9 "\ 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\n †TМ=ѓ5Н‚TО=ѓB\nG‚T§ѓSН\nG^]‚TН@П\">ѓfР!€ ѓv\n› ‚™НUѓЉГ\nB#‚™S\n›\n›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 advices position first 0 last ad-get-cache-class-id ad-clear-cache] 5 "\ 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 "АБВ\"€АГД\"€ЕЖ!„ЗИЙ\"АКЛ\"€АМН\"€АОП\"€АРС\"€АТУ\"€АФХ\"€ЦЧ!„EЦШ!ѓEЩЧШ\"€АЪЫ\"€АЬЭ\"€АЮЯ\"€Ааб\"€Авг\"€Аде\"€Ажз\"€Аий\"€Акл\"€Амн\"€Аоп\"€Арс\"€Ату\"€Еф!„Џх4Ацч\"€Ашщ\"€Аъы\"€Аьэ\"€Аюя\"€АЃ@ЃA\"€АЃBЃC\"‡" [defalias 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) "АБ\nDГE‡" [eq car-safe definition (quote macro)] 3]) ad-lambda-p (macro . #[(definition) "АБ\nDГE‡" [eq car-safe definition (quote lambda)] 3]) ad-advice-p (macro . #[(definition) "АБ\nDГE‡" [eq car-safe definition (quote advice)] 3]) fboundp byte-code-function-p compiled-function-p ad-real-fset 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) "ўБ=ѓ ‡ўВ=ѓA‡ўГ=ѓA‡Д‡" [definition lambda macro advice nil] 2] ad-arglist #[(definition &optional name) "ѓ(Б\n!„\nўГ=ѓ(Б\nA!ѓ(\nўГ=ѓ$\nA‚%\nДH‡\n:ѓ3Е\n!A@‡Ж\n!…ZѓCИ!‡ЙК\n\"ЛМ\"€ИНО”О•O!!‡" [ad-emacs19-p byte-code-function-p definition macro 0 ad-lambda-expression subrp name ad-subr-arglist format "%s" string-match "^#]+\\)>$" intern 1] 5] 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) "АБ\nГED‡" [car get subr (quote ad-subr-arglist)] 4]) ad-subr-arglist #[(subr-name) "БNѓБN@‡\n…Г!‰ѓ3ЕЖ\"ѓ3ЗБИЙ”Й•#@C#€БN@‚4К)‡" [subr-name ad-subr-arglist ad-emacs19-p documentation doc string-match "[\n ]*\narguments: ?\$(.*)\$\n?\\'" put read-from-string 1 (&rest ad-subr-args)] 8] ad-docstring #[(definition) "ѓБ\n!„\nўГ=ѓБ\nA!ѓДЕЖЏ‚%З\n!AA@‰;„3Й!…5)‡" [ad-emacs19-p byte-code-function-p definition macro nodoc (byte-code "ўБ=ѓA‚ ВH‡" [definition macro 4] 2) ((error)) ad-lambda-expression docstring natnump] 4] ad-interactive-form #[(definition) "ѓ0Б\n!„\nўГ=ѓ0Б\nA!ѓ0Д\n!…CЕ\nўГ=ѓ+\nA‚,\nЖHD‡\nўЗ=„>\nўИ=…CДЙ\n!!‡" [ad-emacs19-p byte-code-function-p definition macro commandp interactive 5 advice lambda ad-lambda-expression] 3] ad-body-forms #[(definition) "ѓ3Б\n!„\nўГ=ѓ3Б\nA!ѓ3\nўГ=ѓ$\nA‚%\nД\nЕH\nЖH\nЗHFC‡\n:…UИ\n!ѓBЕ‚CЙК\n!ѓMЕ‚NЙ\\Л\n!AA›‡" [ad-emacs19-p byte-code-function-p definition macro byte-code 1 2 3 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 macro ad-body-forms (byte-code ad-real-byte-code)] 2] 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) "ўБ=„ўВ=„Г!…#Д!‰;…\"Ж \")‡" [definition lambda macro ad-compiled-p ad-docstring docstring string-match ad-advised-definition-docstring-regexp] 4] ad-definition-type #[(definition) "ўБ=ѓ Б‡В!ѓ>ѓД‡Е‡ўЖ=„&З!ѓ(И‡ўЙ=…0Й‡" [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 autoload] 2] ad-real-definition #[(function) "А !… K‰9ѓГ\n!‚\n)‡" [ad-has-proper-definition function definition ad-real-definition] 3] ad-real-orig-definition #[(function) "БN…ВГБNћA!‡" [function ad-advice-info ad-real-definition origname] 4] ad-is-compilable #[(function) "А !… KўВ=„ KўГ=…Д K!?‡" [ad-has-proper-definition function lambda macro ad-compiled-p] 2]] 3) (defalias 'ad-compile-function #[(function) "А !…$ВГД\"€Г !†$ KўЕ=…$Ж ЕЗИ K!!B\"‡" [ad-is-compilable function require byte-compile "bytecomp" macro ad-real-fset byte-compile-lambda ad-lambda-expression] 6 "\ Byte-compiles FUNCTION (or macro) if it is not yet compiled." "aByte-compile function: "]) (byte-code "АБВ\"€АГД\"€АЕЖ\"€АЗИ\"€АЙК\"€АЛМ\"€АНО\"€АПР\"€АСТ\"€АУФ\"€АХЦ\"€АЧШ\"€АЩЪ\"‡" [defalias ad-real-byte-codify #[(function) "А !€ KѓД\n!†+\nўЕ=ѓД\nA!†+Ж\n!…+З\n!@И )‡" [ad-compile-function function definition ad-emacs19-p byte-code-function-p macro ad-compiled-p ad-body-forms ad-real-byte-code] 2] ad-prognify #[(forms) "GБXѓ\n@‡ВB‡" [forms 1 progn] 2] ad-parse-arglist #[(arglist) "АААД >A@‰ѓЖДЖ !>A!З >A‰ѓ.ЖЗЖ !>A!‚0 \nE+‡" [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\nГF‡" [list quote req (quote required)] 4] #[(opt) "АБ\nD\nГF‡" [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ѓ\n‡ГUѓД\nD‡Е\nE‡" [position 0 list 1 cdr nthcdr] 3] ad-element-access #[(position list) "БUѓ\nВD‡ДUѓВЕDD‡ЖE‡" [position 0 car list 1 cdr nth] 3] ad-access-argument #[(arglist index) "А !Г\n@\nA@\"Е\n8GWѓ 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ѓ%ГК ›\"ѓEѓ:ЛE‚EМ GZ\",‡" [ad-parse-arglist arglist parsed-arglist append reqopt-args 2 rest-arg nil args-form index (list) nconc ad-list-access] 4] ad-set-arguments #[(arglist index values-form) "АБ‰Е\"‰ѓX9ѓ&ИЙК\"#\nB‚M@АUѓ9ЛA@МК\"E‚GНМ@SA@\"МК\"E\nBБTT‚\n„fОП#‚„\nGРUѓvСТУ\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 (ad-get-arg ad-get-args ad-set-arg ad-set-args)] 2] #[(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]] 3) (defalias 'ad-map-arglists #[(source-arglist target-arglist) "А !Г\n@\nA@\"Е\n8А!Г@A@\" Е8\n…/\nМ Гѓ>О‚?ПРDѓOГC\"‚`СТГ \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]] 8 "\ 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 "АБВ\"€АГД\"€АЕЖ\"€АЗИ\"€АЙК\"€АЛМ\"€АНО\"€АПР\"€АСТ\"€АУФ\"€АХЦ\"‡" [defalias 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 quote] 5] 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 "" "\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>ўМ= О\"Р!†;Т! ѓKФ‚u†uХ!†u…uЦ!@‰ѓsШЩЪGФ\"DD‚tЫ)„Ѓ ѓ™ ѓЉЭ‚‹ЮЯЩ Dаб\"ED‚Б ѓєѓє„євгдЩ DDе #F‚Бе #&з ѓНМ‚ЧѓЦи‚ЧАй!&кл\"км\"кн\"&.‡" [function ad-advice-info ad-has-redefining-advice ad-real-orig-definition origdef origname commandp orig-interactive-p subrp orig-subr-p ad-special-forms orig-special-form-p 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ЙКЛ !DМН8!\"C‚@Й МН8!\"A‰„*ОПEС!А‰ѓЂ@‰A@ѓjУФХЦЛМН8!!#A‰„]*ѓ“ ѓ“КЛ !EC‚Й C\"А‰ѓШ@‰A@ѓЕ\nѓЕЙКЛ\n!DМН8!\"C‚ПЙ\nМН8!\"A‰„¤*ЙЩ>…вЪЫC…оC…цCЙЯ\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) "АБ\nГED‡" [car ad-get-advice-info-field function (quote cache)] 4]) ad-get-cache-id (macro . #[(function) "АБ\nГED‡" [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])] 3) (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 "АБВ\"€АГД\"€АЕЖ\"€АЗИ\"€АЙК\"€АЛМ\"€АНО\"‡" [defalias ad-make-cache-id #[(function) "А !В ГNћA@ЖЗИ Й\"\"ЖКИ Л\"\"ЖМИ Н\"\"О !П \"П!љѓ3Р‚7П \"О !Б=…FС !С!љЇ*‡" [ad-real-orig-definition function cache ad-advice-info cached-definition original-definition mapcar #[(advice) "@‡" [advice] 1] ad-get-enabled-advices before #[(advice) "@‡" [advice] 1] around #[(advice) "@‡" [advice] 1] after ad-definition-type ad-arglist t ad-interactive-form] 8] ad-get-cache-class-id #[(function class) "А ВNћAAЕ=ѓ@‚\"Ж=ѓA@‚\"З8)‡" [cache function ad-advice-info cache-id class before around 2] 3] 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) "А ВNћAAГЖ @З ВNћA\"ѓљИ‰ѓљЖЙ 8К ВNћA\"ѓљЛ‰ѓљЖМ 8Н ВNћA\"ѓљО‰ѓљП !А ВNћA@Т 8У!=ѓ™Ф‰ѓ™Х 8Ц=ѓtЧ \"‚wХ 8Ч!љѓ™Ш‰ѓ™Щ 8ѓ—Ъ!Ъ!љѓ™Ы**‡" [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 4 t ad-arglist interactive-form-mismatch 5 ad-interactive-form verified] 5] 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@#€О !€П Р\"€С !…SТ ЕNћA@…SТ Е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 "А В#€ѓЕ \"€‚З !€А‡" [put function ad-advice-info old-advice-info function-defined-p ad-real-fset old-definition fmakunbound] 4)) ad-add-advice advice class position ad-enable-advice ad-clear-cache ad-activate nil ad-is-active cache] 6] ad-activate-advised-definition #[(function compile) "А !… В ГNћA@Е †Ж !\"€ѓ\"И !€ѓ? K=?…VЙ В KВ ГNћAAB#‚VК !€Й В KЛB#€Й В KМ !B#)‡" [ad-verify-cache-id function cache ad-advice-info verified-cached-definition ad-real-fset ad-make-advised-definition compile ad-compile-function ad-set-advice-info-field ad-clear-cache nil ad-make-cache-id] 7]] 3) (defalias 'ad-handle-definition #[(function) "А ВNћAГ!…K)Д !… K‰ѓh …u =?…uЗ !?…uЙ>„AКЛ М#‚uН=ѓPО \"‚uОА ВNћA \"€П=…uРС \"‚u …uОА ВNћA \"*‡" [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 ad-real-fset 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)…JЗ!„,И!‡Й!ѓGК\"€МНО#€ПРС\"!€‡Т!‡" [function ad-advice-info error "ad-activate: `%s' is not advised" ad-handle-definition 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„ВГ\"‡Д!…UЕ!€ЖБNћAЗ!…'K)„0ВИ\"‡ЙЖБNћAЗ!…DK)\"€КЛМ#€НОП\"!€‡" [function ad-advice-info error "ad-deactivate: `%s' is not advised" ad-is-active ad-handle-definition origname fboundp "ad-deactivate: `%s' has no original definition" ad-real-fset 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 origname put nil delq assoc symbol-name ad-advised-functions] 4 "\ 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) "БN…JВБNћAГ\n!…\nK)ѓ6ДВБNћAГ\n!…*\nK)\"€ЕВБNћA!€ЖБЗ#€ИЙК!\"\"‰‡" [function ad-advice-info origname fboundp ad-real-fset 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@<…L@AНО\"РС>Т>?УФХD#$Ш>…{Щ $УЫЬЭ DЭDЭ DЭDЇC…»ЮЭ D@ўЯ=ѓ®аБ@ADD‚іБ@DЭA@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) ad-add-advice quote ad-set-cache macro ad-macrofy activate ad-activate compile t] 8 "\ 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БВD8@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#€ЗИЙ\"€КИK!ѓ!И €ЛМ!„*НЛО!„3ПЛР!„<СЛТ!„EУЛФ!„ХЦЧ!ЧS\\!#Ч!ЩPЧ!ЬЭЮЬЭЮ°+ЗЯа\"€Збв\"‡" [ad-emacs19-p put documentation ad-subr-arglist (fun1) fset (sym newdef) defalias ad-execute-defadvices #[nil "АБВГД$€ЕБЖЗИBЙB#€АКЛГД$€ЕКЖЗМBНB#€АОПГД$€ЕОЖРС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)†)\"€НО!€+ )‡" [nil ad-return-value ad-Orig-defalias sym newdef ad-defined-function defalias ad-oRiGdEf-0 ((byte-code "АБ\n\"‡" [ad-real-fset defalias ad-oRiGdEf-0] 3)) ad-real-fset 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)†)\"€НО!€+ )‡" [nil ad-return-value ad-Orig-define-function sym newdef ad-defined-function define-function ad-oRiGdEf-0 ((byte-code "АБ\n\"‡" [ad-real-fset define-function ad-oRiGdEf-0] 3)) ad-real-fset 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) "АВ\"‰;ѓ0Е \"ѓ0З И”И•#@‰ЙNѓ/К!„/Л !) )‡" [nil ad-return-value ad-Orig-documentation function raw string-match ad-advised-definition-docstring-regexp read-from-string 1 ad-advice-info ad-make-advised-docstring substitute-command-keys] 5 "$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 "\$" "\\|" "\$" ad-find-fset-in-byte-code #[(code constants start) "А \n#Д‰‰ѓq\nHUѓ/\nT‰H\nT‰HИ_\\T‚:\nH ZT\nHUѓY\nT‰H\nT‰HИ_\\T‚c\nH ZT\nH\n HE‚rД+‡" [string-match ad-byte-code-fset-regexp code start nil code-index name-index byte-constant2 256 byte-constant constants] 5] ad-scan-byte-code-for-fsets #[(ad-code ad-constants) "АБВK\"€ГДЕЏ‡" [ad-real-fset byte-code ad-real-byte-code ignore-errors (byte-code "АВ AA@#‰ѓ2 @9ѓЕ @!ѓ @K A@=ѓ @ЗИ!€)‚ЙКЛK\")‡" [(0 0 0) fset-args ad-find-fset-in-byte-code ad-code ad-constants fboundp ad-defined-function run-hooks ad-definition-hooks ad-real-fset byte-code ad-advised-byte-code] 4) ((error))] 3]] 11) (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 "АБ!€ВГБK\"‡" [ad-real-byte-codify ad-advised-byte-code-definition ad-real-fset ad-advised-byte-code] 3) (defalias 'ad-recover-byte-code #[nil "АБВK\"‡" [ad-real-fset byte-code ad-real-byte-code] 3 "\ 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] 3 "\ 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 "АБВ\"€АГД\"€ЕГ!‡" [defalias ad-enable-definition-hooks #[nil "АБ‰ѓ@Д\nЕЖ#€З\nИ\"€A‰„* …9КЛ!€КМ!€НОЛK\"€?…9Р ‡" [(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 ad-real-fset 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] 3) (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 "АБ!€\nѓГДK!ѓЕ €ЖЗ!‡" [ad-real-byte-codify ad-recover-normality ad-start-advice-on-load ad-compiled-p ad-execute-defadvices ad-start-advice provide advice] 2)