run-hooks vs. run-mode-hooks.

run-hooks vs. run-mode-hooks.

[Lute Kamstra]

Can somebody confirm that this change is correct?

Lute.


Index: src/eval.c
===================================================================
RCS file: /cvsroot/emacs/emacs/src/eval.c,v
retrieving revision 1.238
diff -C4 -r1.238 eval.c
*** src/eval.c	8 May 2005 16:30:13 -0000	1.238
--- src/eval.c	25 May 2005 12:25:23 -0000
***************
*** 2291,2306 ****
  static Lisp_Object run_hook_with_args P_ ((int, Lisp_Object *,
  					   enum run_hooks_condition));
  
  DEFUN ("run-hooks", Frun_hooks, Srun_hooks, 0, MANY, 0,
!        doc: /* Run each hook in HOOKS.  Major mode functions use this.
  Each argument should be a symbol, a hook variable.
  These symbols are processed in the order specified.
  If a hook symbol has a non-nil value, that value may be a function
  or a list of functions to be called to run the hook.
  If the value is a function, it is called with no arguments.
  If it is a list, the elements are called, in order, with no arguments.
  
  Do not use `make-local-variable' to make a hook variable buffer-local.
  Instead, use `add-hook' and specify t for the LOCAL argument.
  usage: (run-hooks &rest HOOKS)  */)
       (nargs, args)
--- 2291,2309 ----
  static Lisp_Object run_hook_with_args P_ ((int, Lisp_Object *,
  					   enum run_hooks_condition));
  
  DEFUN ("run-hooks", Frun_hooks, Srun_hooks, 0, MANY, 0,
!        doc: /* Run each hook in HOOKS.
  Each argument should be a symbol, a hook variable.
  These symbols are processed in the order specified.
  If a hook symbol has a non-nil value, that value may be a function
  or a list of functions to be called to run the hook.
  If the value is a function, it is called with no arguments.
  If it is a list, the elements are called, in order, with no arguments.
  
+ Major modes should not use this function directly to run their mode
+ hook; they should use `run-mode-hooks' instead.
+ 
  Do not use `make-local-variable' to make a hook variable buffer-local.
  Instead, use `add-hook' and specify t for the LOCAL argument.
  usage: (run-hooks &rest HOOKS)  */)
       (nargs, args)

Re: run-hooks vs. run-mode-hooks.

[Richard Stallman]

This change is correct--please install it.

Re: run-hooks vs. run-mode-hooks.

[Katsumi Yamaoka]

Hi,

run-mode-hooks is only available in Emacs 22, while Gnus v5.11
still supports Emacs 20 and 21 (and No Gnus supports Emacs 21).

2005-05-26  Lute Kamstra  <lute@gnu.org>

	* score-mode.el (gnus-score-mode): Use run-mode-hooks.

Is it possible to use run-hooks in those Emacs versions?

Regards,

Re: run-hooks vs. run-mode-hooks.

[Lute Kamstra]

Katsumi Yamaoka <yamaoka@jpl.org> writes:

> run-mode-hooks is only available in Emacs 22, while Gnus v5.11
> still supports Emacs 20 and 21 (and No Gnus supports Emacs 21).
>
> 2005-05-26  Lute Kamstra  <lute@gnu.org>
>
> 	* score-mode.el (gnus-score-mode): Use run-mode-hooks.

Sorry about that.

> Is it possible to use run-hooks in those Emacs versions?

Maybe Gnus can do something like:

(or (fboundp 'run-mode-hooks)
    (defalias 'run-mode-hooks 'run-hooks))

I saw that most hooks are run with gnus-run-hooks, which calls
run-hooks.  Maybe you can also define a gnus-run-mode-hooks that uses
run-mode-hooks instead and use that function for Gnus' major modes?

Lute.

Re: run-hooks vs. run-mode-hooks.

[Katsumi Yamaoka]

>>>>> In <87hdgp4fa1.fsf@xs4all.nl> Lute Kamstra wrote:

>> Is it possible to use run-hooks in those Emacs versions?

> Maybe Gnus can do something like:

> (or (fboundp 'run-mode-hooks)
>     (defalias 'run-mode-hooks 'run-hooks))

> I saw that most hooks are run with gnus-run-hooks, which calls
> run-hooks.  Maybe you can also define a gnus-run-mode-hooks that uses
> run-mode-hooks instead and use that function for Gnus' major modes?

I've added gnus-run-mode-hooks to both the Gnus trunk and the
v5-10 branch (synch'd with the Emacs trunk).  Thank you for the
good suggestion.

Re: run-hooks vs. run-mode-hooks.

[Juanma Barranquero]

> Maybe Gnus can do something like:
> 
> (or (fboundp 'run-mode-hooks)
>     (defalias 'run-mode-hooks 'run-hooks))

(Not in this case, that's already been fixed but) that would not be good.

The usual answer is making your own lookalike:

  (if (fboundp 'function-in-doubt)
      (defalias 'mymodule-function-in-doubt 'function-in-doubt)
    (defun mymodule-function-in-doubt ...))

Otherwise, you're gonna mislead any module loaded afterwards that
tries to determine whether 'function-in-doubt exists or not.

-- 
                    /L/e/k/t/u

Re: run-hooks vs. run-mode-hooks.

[Richard Stallman]

    Is it possible to use run-hooks in those Emacs versions?

Yes, but it won't always be correct.

    Maybe Gnus can do something like:

    (or (fboundp 'run-mode-hooks)
	(defalias 'run-mode-hooks 'run-hooks))

Definitely not!  Gnus should not mess with the way Emacs defines
(or doesn't define) these functions!

Gnus should define a function called gnus-run-mode-hooks, which calls
run-mode-hooks if that is defined, otherwise run-hooks.  Then all the
modes in Gnus could use gnus-run-mode-hooks.

Re: run-hooks vs. run-mode-hooks.

[Lute Kamstra]

Richard Stallman <rms@gnu.org> writes:

>     Maybe Gnus can do something like:
>
>     (or (fboundp 'run-mode-hooks)
> 	(defalias 'run-mode-hooks 'run-hooks))
>
> Definitely not!  Gnus should not mess with the way Emacs defines
> (or doesn't define) these functions!

It seems that that I was badly educated by code I read: I've quite
often seen the use of constructs like the one above.

> Gnus should define a function called gnus-run-mode-hooks, which calls
> run-mode-hooks if that is defined, otherwise run-hooks.  Then all the
> modes in Gnus could use gnus-run-mode-hooks.

That's what Katsumi did for gnus-score-mode.  Other major mode in Gnus
still use gnus-run-hooks which uses run-hooks.  Katsumi, could you fix
those modes in a similar way?

Lute.

Re: run-hooks vs. run-mode-hooks.

[Stefan Monnier]

>   (if (fboundp 'function-in-doubt)
>       (defalias 'mymodule-function-in-doubt 'function-in-doubt)
>     (defun mymodule-function-in-doubt ...))

Actually this form has the disadvantage that the byte-compiler would have to
check which functions are defnied in every branch.  And snice it doesn't do
that as of now, the byte-compiler won't noticve that this form does define
`mymodule-function-in-doubt' and will hencforth issue warnings when you call
that function.

Better use:

   (defalias 'mymodule-function-in-doubt
     (if (fboundp 'function-in-doubt)
         'function-in-doubt
       (lambda (..) ...)))

which makes it trivially obvious that `mymodule-function-in-doubt' will
indeed always be defined.


        Stefan

RE: run-hooks vs. run-mode-hooks.

[Drew Adams]

    >   (if (fboundp 'function-in-doubt)
    >       (defalias 'mymodule-function-in-doubt 'function-in-doubt)
    >     (defun mymodule-function-in-doubt ...))
    Actually this form has the disadvantage that the
    byte-compiler would have to check which functions
    are defnied in every branch.  And snice it doesn't
    do that as of now, the byte-compiler won't noticve
    that this form does define
    `mymodule-function-in-doubt' and will hencforth
    issue warnings when you call that function.
    Better use:
       (defalias 'mymodule-function-in-doubt
         (if (fboundp 'function-in-doubt)
             'function-in-doubt
           (lambda (..) ...)))
    which makes it trivially obvious that `mymodule-function-in-doubt' will
    indeed always be defined.

Is the behavior of the byte-compiler for this kind of thing explained
somewhere? That is, are there coding guidelines somewhere to guide Lisp
users wrt the byte compiler?

Re: run-hooks vs. run-mode-hooks.

[Miles Bader]

Lute Kamstra <Lute.Kamstra.lists@xs4all.nl> writes:
> It seems that that I was badly educated by code I read: I've quite
> often seen the use of constructs like the one above.

There is, or at least used to be, a fair amount of bad old code that
does stuff like that.  One of the worst offenders was (not sure if it's
been fixed) w3.

I remember lots of bug reports where the problem was eventually revealed
to be some package getting confused by w3's mucking around with the
namespace.

-Miles
-- 
Yo mama's so fat when she gets on an elevator it HAS to go down.

Re: run-hooks vs. run-mode-hooks.

[Juanma Barranquero]

> Better use:
> 
>    (defalias 'mymodule-function-in-doubt
>      (if (fboundp 'function-in-doubt)
>          'function-in-doubt
>        (lambda (..) ...)))

I was only highlighting the fact that defining functions from "future"
Emacsen is Not Good, but yes, your way is better. Every non-contrived
way to get rid of warnings is good in my book :)

-- 
                    /L/e/k/t/u

Re: run-hooks vs. run-mode-hooks.

[Katsumi Yamaoka]

> Richard Stallman <rms@gnu.org> writes:

>> Gnus should define a function called gnus-run-mode-hooks, which calls
>> run-mode-hooks if that is defined, otherwise run-hooks.  Then all the
>> modes in Gnus could use gnus-run-mode-hooks.

>>>>> In <87br6w8zzo.fsf@xs4all.nl>
>>>>>	Lute Kamstra <Lute.Kamstra.lists@xs4all.nl> wrote:

> That's what Katsumi did for gnus-score-mode.  Other major mode in Gnus
> still use gnus-run-hooks which uses run-hooks.  Katsumi, could you fix
> those modes in a similar way?

Ok, I'll make time to do that, maybe in Monday.

Regards,

Re: run-hooks vs. run-mode-hooks.

[Richard Stallman]

    >     (or (fboundp 'run-mode-hooks)
    > 	(defalias 'run-mode-hooks 'run-hooks))

    It seems that that I was badly educated by code I read: I've quite
    often seen the use of constructs like the one above.

Are there any examples in the Emacs sources?
If so, could you show me a few?

Re: run-hooks vs. run-mode-hooks.

[Katsumi Yamaoka]

>>>>>> In <87br6w8zzo.fsf@xs4all.nl>
>>>>>>	Lute Kamstra <Lute.Kamstra.lists@xs4all.nl> wrote:

>> Other major mode in Gnus still use gnus-run-hooks which uses
>> run-hooks.  Katsumi, could you fix those modes in a similar way?

>>>>> In <yotld5rccjry.fsf@jpl.org> Katsumi Yamaoka wrote:

> Ok, I'll make time to do that, maybe in Monday.

>>>>> In <E1DbfhH-0004Zk-BU@fencepost.gnu.org> Richard Stallman wrote:

>     Is it possible to use run-hooks in those Emacs versions?

> Gnus should define a function called gnus-run-mode-hooks, which calls
> run-mode-hooks if that is defined, otherwise run-hooks.  Then all the
> modes in Gnus could use gnus-run-mode-hooks.

I've done it in the Gnus trunk and the v5-10 branch.

Re: run-hooks vs. run-mode-hooks.

[Richard Stallman]

    > Gnus should define a function called gnus-run-mode-hooks, which calls
    > run-mode-hooks if that is defined, otherwise run-hooks.  Then all the
    > modes in Gnus could use gnus-run-mode-hooks.

    I've done it in the Gnus trunk and the v5-10 branch.

Thank you.