4:03 p.m.
In my .emacs file I have initializations to smash various modes
in various ways. For example:
(setq sql-mode-font-lock-keywords sql-mode-oracle-font-lock-keywords)
(define-key tcl-mode-map [(meta backspace)] 'backward-kill-word)
(define-key makefile-mode-map "$" 'self-insert-command)
(define-key makefile-mode-map "\^x\$" 'makefile-insert-macro-ref)
However doing these things require that I load all of the packages
first.
(require 'sql)
(require 'tcl)
(require 'makefile)
Is there some standard way to do initializations like these (that
require that the file be loaded first) without causing the file to
be loaded? Basically what I want is a load-hook, but most packages
do not have load hooks (comint has one).
I hacked something up to do what I wanted, but there's got to
be a better way.
-jeff
Example:
;; stuff to do after sql gets loaded
(after-provided 'sql
'(lambda () (setq sql-mode-font-lock-keywords sql-mode-oracle-font-lock-keywords)))
;; stuff to do after tcl gets loaded
(after-provided 'tcl
'(lambda () (define-key tcl-mode-map [(meta backspace)] 'backward-kill-word)))
;; stuff to do after makefile gets loaded
(after-provided 'makefile
'(lambda ()
(define-key makefile-mode-map "$" 'self-insert-command)
(define-key makefile-mode-map "\^x\$" 'makefile-insert-macro-ref)))
;; Keep track of nesting level of require/load. Don't do after-provide stuff until
we
;; know that we are done loading the files. Some files do the provide at the top of the
file
(defvar load-level 0)
;; Track packages that have been provided.
(defvar provided ())
(put 'after-provided 'lisp-indent-function 1)
(defun after-provided (symbol function)
(if (memq symbol features)
;; Package has already been loaded, just do it.
(progn
;;(message "already loaded %s" symbol)
(funcall function))
;; Keep function around until package gets provided.
(setf (get symbol 'after-provide)
(cons function (get symbol 'after-provide)))))
(defun provided (symbol)
(while (not (null (get symbol 'after-provide)))
;;(message "after %s" symbol)
(funcall (pop (get symbol 'after-provide)))))
(defadvice load (around first activate protect)
(incf load-level)
ad-do-it
(decf load-level)
;; If load has caused some packages to have been provided then do after stuff, when done
loading.
(when (zerop load-level)
(while (not (null provided))
(provided (pop provided)))))
(defadvice provide (around first activate protect)
(incf load-level)
ad-do-it
(decf load-level)
(push (ad-get-arg 0) provided)
;; Some packages to have been provided do after stuff, when done loading.
;; Doing a (provide 'foo) at top level will cause the after stuff to run.
(when (zerop load-level)
(while (not (null provided))
(provided (pop provided)))))
(defadvice require (around first activate protect)
(incf load-level)
ad-do-it
(decf load-level)
;; We're done doing require, look for packages that have been provided.
(when (zerop load-level)
(while (not (null provided))
(provided (pop provided)))
;; If package already loaded just do the cleanup, this also catches the case where
;; the package loaded didn't do a provide - underlying require already gave
error.
(provided (ad-get-arg 0))))
4:41 p.m.
Jeff Mincy <jmincy(a)muniversal.com> wrote:
Is there some standard way to do initializations like these (that
require that the file be loaded first) without causing the file to
be loaded? Basically what I want is a load-hook, but most packages
do not have load hooks (comint has one).
eval-after-load
But in many cases, using Custom is more elegant.
--
Didier Verna, didier(a)lrde.epita.fr, http://www.lrde.epita.fr/~didier
EPITA / LRDE, 14-16 rue Voltaire Tel.+33 (1) 53 14 59 47
94276 Le Kremlin-Bicêtre, France Fax.+33 (1) 44 08 01 99 didier(a)xemacs.org
7:54 p.m.
Didier Verna writes:
Jeff Mincy <jmincy(a)muniversal.com> wrote:
Is there some standard way to do initializations like these (that
require that the file be loaded first) without causing the file to
be loaded? Basically what I want is a load-hook, but most packages
do not have load hooks (comint has one).
A couple of people suggested using eval-after-load.
Thanks - I wasn't aware of the function.
I appropos searched for the feature on provide,
since that's where I thought the feature should be.
I didn't think about load. Interestingly enough,
the comment with eval-after-load provides the rationale.
from subr.el:
================
;; This was not present before. I think Jamie had some objections
;; to this, so I'm leaving this undefined for now. --ben
;;; The objection is this: there is more than one way to load the same file.
;;; "foo", "foo.elc", "foo.el", and
"/some/path/foo.elc" are all different
;;; ways to load the exact same code. `eval-after-load' is too stupid to
;;; deal with this sort of thing. If this sort of feature is desired, then
;;; it should work off of a hook on `provide'. Features are unique and
;;; the arguments to (load) are not. --Stig
;; We provide this for FSFmacs compatibility, at least until we devise
;; something better.
(defun eval-after-load ....)
================
But in many cases, using Custom is more elegant.
15 years ago, when I started using zmacs we didn't
have any woosie customize. All we had was setq and fset....
-jeff
11:29 p.m.
>>>> "drv" == Didier Verna
<didier(a)xemacs.org> writes:
But in many cases, using Custom is more elegant.
I'm not sure I understand. In what way is it more elegant ?
Unless custom is more clever on XEmacs than on Emacs, all it does it either
a variant of `setq' (which usually works just fine without having to
use a require or a hook) or does q `require+setq' whicch gets you back
to square one (after all, the poster asked how to avoid the `require').
Stefan
11:49 p.m.
"Stefan Monnier" <monnier+lists.xemacs.beta/news/(a)RUM.cs.yale.edu>
writes:
>>>>> "drv" == Didier Verna
<didier(a)xemacs.org> writes:
> But in many cases, using Custom is more elegant.
I'm not sure I understand. In what way is it more elegant ? Unless
custom is more clever on XEmacs than on Emacs, all it does it either
a variant of `setq' (which usually works just fine without having to
use a require or a hook) or does q `require+setq' whicch gets you
back to square one (after all, the poster asked how to avoid the
`require').
See :get, :set, and :initialize keywords to defcustom.
They don't help you with `define-key', but their capabilities
decidedly exceed simple `setq' or `require+setq'. Of course, it is
required that the package author actually uses them.
9:55 p.m.
Jeff Mincy <jmincy(a)muniversal.com> writes:
In my .emacs file I have initializations to smash various modes
in various ways. For example:
(setq sql-mode-font-lock-keywords sql-mode-oracle-font-lock-keywords)
(define-key tcl-mode-map [(meta backspace)] 'backward-kill-word)
(define-key makefile-mode-map "$" 'self-insert-command)
(define-key makefile-mode-map "\^x\$" 'makefile-insert-macro-ref)
Is there some reason you don't put these on the appropriate mode-hook?
(defun my-tcl-mode-hook ()
"A hook run in tcl-mode buffers"
(define-key tcl-mode-map [(meta backspace)] 'backward-kill-word))
(add-hook 'tcl-mode-hook 'my-tcl-mode-hook)
-Mark
8611
days inactive
8612
days old
5 comments
5 participants
participants (5)
-
Didier Verna -
Hrvoje Niksic -
Jeff Mincy -
Mark Thomas -
Stefan Monnier