CODEWITHSUNDEEP
emacsreferenceelisp
user797257
user797257

Reputation:

ELisp: forward references (reference a symbol before it is defined)

How do you go about solving this problem?

Suppose I want to write a function that does the following: if the user has library X installed, then use function X-function, otherwise - skip?

What I tried:

(when (symbol-function 'X-function)
  (X-function))

I'm getting a warning for this code - so what is the right way?

Upvotes: 2

Views: 929

Answers (3)

Bernard Hurley
Bernard Hurley

Reputation: 366

Another case when you can get the warning that a function cannot be found is when you define a function programmatically and use fset to set it. The following example illustrates this and what to do about it:

(eval-and-compile
  (fset 'my-function1 (lambda () nil)))

(my-function1)

(fset 'my-function2 (lambda () nil))

(my-function2)

(my-function3)

(eval-and-compile
  (fset 'my-function3 (lambda () nil)))

If you compile this you get the warnings:

Warning: the function `my-function2' is not known to be defined.

and:

Warning: the function `my-function3' might not be defined at runtime.

The second warning goes away if you re-compile the code a second time in the same Emacs session, but the first doesn't.

What is happening here is this: When the compiler sees eval-and-compile, it first evaluates the body of the in the current Emacs session and then compiles it. Having evaluated the code, Emacs knows about the programmatically defined function.

  1. In the case of function1, the byte compiler sees the function call after Emacs has evaluated the form and so you don't get any warnings.
  2. In the case of function2 the byte compiler never knows the functions is defined so you always get a warning.
  3. In the case of function3, the first time round, the bite compiler doesn't know the function exists when it sees the function call. By the end of the compilation it knows the function exists but it isn't intelligent enough to work out how it knows so you get a different warning. However, if you re-compile it in the same Emacs session, it does know so the warning goes away.

Note that eval-and-compile, like eval-with-compile, look like a progn to the Emacs interpreter.

Upvotes: 0

Bernard Hurley
Bernard Hurley

Reputation: 366

The way to suppress this compiler warning is with something like:

(declare-function X-function "ext:X-library.el")

(when (fboundp 'X-function)
     (X-function))

Here X-library is the name of the library that X-function is defined in when the library is there. The byte-compiler will then do the following:

  1. It will look for the library in the load path.
  2. If it finds it, it will check that the function has been defined.
  3. If it does not find the library it will assume that it will be when the library is there and pass on without error.

Thus if there is no X-library it won't complain, but if there is one and it does not define the function then it will. This means that if an updated version of the library does not contain X-function then you will know when you try to re-compile your code.

If you look up the documentation for declare-function you will find that it can also check the argument list of functions.

Incidentally If you get similar warnings about undeclared variables you can suppress these with:

(defvar X-variable)

However it is important not to set the variable even if you know what value the library sets it to as this could change in a later version.

This gives you one version of the program that works whether or not X-library is present. You might prefer to have two versions, one for when X-library is present and one for when it is not. This can be done with a macro:

(defmacro run? (function &rest args)
  "Expand to function call if function exists."
  (when (fboundp `,function)
    `(,function ,@args)))

Now instead of a call like:

(X-function a1 a2 a3)

You write:

(run? X-function a1 a2 a3)

If you compile it with X-library present this expands to the call to X-function. If the library is not present then it expands to nothing at all. You will not need the declare-function in any case. This gives two different versions, but it should be more efficient because the decisions as to whether the library is there or not are taken at compile time not run time.

One small caveat. If you go for this second solution you must either compile the whole program in the X-library environment or outside it. If you try loading the library half way through the program then when interpreted it will work as you might expect with the macro expanding differently before and after the load. But in a compiled program a macro is only expanded once. The test test for the library is in code that does the expanding not in the expansion, so the macro will not work the same before and after the load.

Upvotes: 4

Guido Simone
Guido Simone

Reputation: 7952

How about this:

(when (fboundp 'X-function)
    (X-function))

The docs at http://www.gnu.org/software/emacs/manual/html_node/elisp/Function-Cells.html says about symbol-function

If the symbol's function cell is void, a void-function error is signaled.

I'm guessing that is what you are seeing. On the other hand, fboundp just returns t or nil depending on whether the function exists.

Upvotes: 4

Related Questions