Constructing a combined definition to execute advice is moderately expensive. When a library advises many functions, this can make loading the library slow. In that case, you can use preactivation to construct suitable combined definitions in advance.
To use preactivation, specify the
preactivate flag when you
define the advice with
creates a combined definition which embodies this piece of advice
(whether enabled or not) plus any other currently enabled advice for the
same function, and the function's own definition. If the
defadvice is compiled, that compiles the combined definition
When the function's advice is subsequently activated, if the enabled advice for the function matches what was used to make this combined definition, then the existing combined definition is used, thus avoiding the need to construct one. Thus, preactivation never causes wrong results—but it may fail to do any good, if the enabled advice at the time of activation doesn't match what was used for preactivation.
Here are some symptoms that can indicate that a preactivation did not work properly, because of a mismatch.
byte-compileis included in the value of
featureseven though you did not ever explicitly use the byte compiler.
Compiled preactivated advice works properly even if the function itself is not defined until later; however, the function needs to be defined when you compile the preactivated advice.
There is no elegant way to find out why preactivated advice is not being
used. What you can do is to trace the function
ad-cache-id-verification-code (with the function
trace-function-background) before the advised function's advice
is activated. After activation, check the value returned by
ad-cache-id-verification-code for that function:
means that the preactivated advice was used, while other values give
some information about why they were considered inappropriate.
Warning: There is one known case that can make preactivation fail, in that a preconstructed combined definition is used even though it fails to match the current state of advice. This can happen when two packages define different pieces of advice with the same name, in the same class, for the same function. But you should avoid that anyway.blog comments powered by Disqus