* lisp/generic.el patch.
@ 2005-03-15 17:06 Lute Kamstra
2005-03-15 18:53 ` Stefan Monnier
` (2 more replies)
0 siblings, 3 replies; 12+ messages in thread
From: Lute Kamstra @ 2005-03-15 17:06 UTC (permalink / raw)
I worked on this item in etc/TODO:
** Redefine define-generic-mode as a macro, so the compiler
sees the definitions it generates.
and fixed some minor things along the way. Does anybody see any
problems with this patch?
Lute.
Index: lisp/ChangeLog
===================================================================
RCS file: /cvsroot/emacs/emacs/lisp/ChangeLog,v
retrieving revision 1.7100
diff -c -r1.7100 ChangeLog
*** lisp/ChangeLog 15 Mar 2005 10:44:51 -0000 1.7100
--- lisp/ChangeLog 15 Mar 2005 16:50:52 -0000
***************
*** 1,3 ****
--- 1,13 ----
+ 2005-03-15 Lute Kamstra <lute@gnu.org>
+
+ * generic.el: Fix commentary section.
+ (generic-use-find-file-hook): Fix docstring.
+ (define-generic-mode): Make it a defmacro. Fix docstring.
+ (generic-mode-internal): Code cleanup.
+ (generic-mode): Fix docstring.
+ (generic-mode-set-comments): Code cleanup.
+ (generic-mode-ini-file-find-file-hook): Fix docstring.
+
2005-03-15 Juri Linkov <juri@jurta.org>
* isearch.el (isearch-error): New variable.
Index: lisp/generic.el
===================================================================
RCS file: /cvsroot/emacs/emacs/lisp/generic.el,v
retrieving revision 1.27
diff -c -r1.27 generic.el
*** lisp/generic.el 14 Mar 2005 11:06:20 -0000 1.27
--- lisp/generic.el 15 Mar 2005 17:02:21 -0000
***************
*** 34,60 ****
;; Generic-mode is a meta-mode which can be used to define small modes
;; which provide basic comment and font-lock support. These modes are
! ;; intended for the many configuration files and such which are too small
! ;; for a "real" mode, but still have a regular syntax, comment characters
! ;; and the like.
;;
;; Each generic mode can define the following:
;;
;; * List of comment-characters. The entries in this list should be
;; either a character, a one or two character string or a cons pair.
! ;; If the entry is a character or a one-character string
! ;; LIMITATIONS: Emacs does not support comment strings of more than
;; two characters in length.
;;
;; * List of keywords to font-lock. Each keyword should be a string.
! ;; If you have additional keywords which should be highlighted in a face
! ;; different from `font-lock-keyword-face', you can use the convenience
! ;; function `generic-make-keywords-list' (which see), and add the
! ;; result to the following list:
;;
;; * Additional expressions to font-lock. This should be a list of
! ;; expressions, each of which should be of the same form
! ;; as those in `font-lock-keywords'.
;;
;; * List of regular expressions to be placed in auto-mode-alist.
;;
--- 34,64 ----
;; Generic-mode is a meta-mode which can be used to define small modes
;; which provide basic comment and font-lock support. These modes are
! ;; intended for the many configuration files and such which are too
! ;; small for a "real" mode, but still have a regular syntax, comment
! ;; characters and the like.
;;
;; Each generic mode can define the following:
;;
;; * List of comment-characters. The entries in this list should be
;; either a character, a one or two character string or a cons pair.
! ;; If the entry is a character or a string, it is added to the
! ;; mode's syntax table with `comment-start' syntax. If the entry is
! ;; a cons pair, the elements of the pair are considered to be
! ;; `comment-start' and `comment-end' respectively. (The latter
! ;; should be nil if you want comments to end at end of line.)
! ;; LIMITATIONS: Emacs does not support comment strings of more than
;; two characters in length.
;;
;; * List of keywords to font-lock. Each keyword should be a string.
! ;; If you have additional keywords which should be highlighted in a
! ;; face different from `font-lock-keyword-face', you can use the
! ;; convenience function `generic-make-keywords-list' (which see),
! ;; and add the result to the following list:
;;
;; * Additional expressions to font-lock. This should be a list of
! ;; expressions, each of which should be of the same form as those in
! ;; `font-lock-keywords'.
;;
;; * List of regular expressions to be placed in auto-mode-alist.
;;
***************
*** 79,113 ****
;; Use the `define-generic-mode' function to define new modes.
;; For example:
;;
- ;; (require 'generic)
;; (define-generic-mode 'foo-generic-mode
! ;; (list ?% )
! ;; (list "keyword")
! ;; nil
! ;; (list "\\.FOO\\'")
! ;; (list 'foo-setup-function))
;;
;; defines a new generic-mode `foo-generic-mode', which has '%' as a
! ;; comment character, and "keyword" as a keyword. When files which end in
! ;; '.FOO' are loaded, Emacs will go into foo-generic-mode and call
! ;; foo-setup-function. You can also use the function `foo-generic-mode'
! ;; (which is interactive) to put a buffer into foo-generic-mode.
;;
;; AUTOMATICALLY ENTERING GENERIC MODE:
;;
! ;; Generic-mode provides a hook which automatically puts a
! ;; file into default-generic-mode if the first few lines of a file in
! ;; fundamental mode start with a hash comment character. To disable
;; this functionality, set the variable `generic-use-find-file-hook'
! ;; to nil BEFORE loading generic-mode. See the variables
! ;; `generic-lines-to-scan' and `generic-find-file-regexp' for customization
! ;; options.
;;
;; GOTCHAS:
;;
! ;; Be careful that your font-lock definitions are correct. Getting them
! ;; wrong can cause emacs to continually attempt to fontify! This problem
! ;; is not specific to generic-mode.
;;
;; Credit for suggestions, brainstorming, help with debugging:
--- 83,117 ----
;; Use the `define-generic-mode' function to define new modes.
;; For example:
;;
;; (define-generic-mode 'foo-generic-mode
! ;; (list ?%)
! ;; (list "keyword")
! ;; nil
! ;; (list "\\.FOO\\'")
! ;; (list 'foo-setup-function))
;;
;; defines a new generic-mode `foo-generic-mode', which has '%' as a
! ;; comment character, and "keyword" as a keyword. When files which
! ;; end in '.FOO' are loaded, Emacs will go into foo-generic-mode and
! ;; call foo-setup-function. You can also use the function
! ;; `foo-generic-mode' (which is interactive) to put a buffer into
! ;; foo-generic-mode.
;;
;; AUTOMATICALLY ENTERING GENERIC MODE:
;;
! ;; Generic-mode provides a hook which automatically puts a file into
! ;; default-generic-mode if the first few lines of a file in
! ;; fundamental mode start with a hash comment character. To disable
;; this functionality, set the variable `generic-use-find-file-hook'
! ;; to nil BEFORE loading generic-mode. See the variables
! ;; `generic-lines-to-scan' and `generic-find-file-regexp' for
! ;; customization options.
;;
;; GOTCHAS:
;;
! ;; Be careful that your font-lock definitions are correct. Getting
! ;; them wrong can cause Emacs to continually attempt to fontify! This
! ;; problem is not specific to generic-mode.
;;
;; Credit for suggestions, brainstorming, help with debugging:
***************
*** 143,162 ****
:group 'extensions)
(defcustom generic-use-find-file-hook t
! "*If non-nil, add a hook to enter default-generic-mode automatically.
This is done if the first few lines of a file in fundamental mode start
with a hash comment character."
:group 'generic
! :type 'boolean
! )
(defcustom generic-lines-to-scan 3
"*Number of lines that `generic-mode-find-file-hook' looks at.
Relevant when deciding whether to enter `generic-mode' automatically.
This variable should be set to a small positive number."
:group 'generic
! :type 'integer
! )
(defcustom generic-find-file-regexp "^#"
"*Regular expression used by `generic-mode-find-file-hook'.
--- 147,164 ----
:group 'extensions)
(defcustom generic-use-find-file-hook t
! "*If non-nil, add a hook to enter `default-generic-mode' automatically.
This is done if the first few lines of a file in fundamental mode start
with a hash comment character."
:group 'generic
! :type 'boolean)
(defcustom generic-lines-to-scan 3
"*Number of lines that `generic-mode-find-file-hook' looks at.
Relevant when deciding whether to enter `generic-mode' automatically.
This variable should be set to a small positive number."
:group 'generic
! :type 'integer)
(defcustom generic-find-file-regexp "^#"
"*Regular expression used by `generic-mode-find-file-hook'.
***************
*** 165,172 ****
The number of lines tested for the matches is specified by the value
of the variable `generic-lines-to-scan', which see."
:group 'generic
! :type 'regexp
! )
(defcustom generic-ignore-files-regexp "[Tt][Aa][Gg][Ss]\\'"
"*Regular expression used by `generic-mode-find-file-hook'.
--- 167,173 ----
The number of lines tested for the matches is specified by the value
of the variable `generic-lines-to-scan', which see."
:group 'generic
! :type 'regexp)
(defcustom generic-ignore-files-regexp "[Tt][Aa][Gg][Ss]\\'"
"*Regular expression used by `generic-mode-find-file-hook'.
***************
*** 175,275 ****
regexp in `generic-find-file-regexp'. If the value is nil,
`generic-mode-find-file-hook' does not check the file names."
:group 'generic
! :type '(choice (const :tag "Don't check file names" nil) regexp)
! )
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Functions
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;###autoload
! (defun define-generic-mode (name comment-list keyword-list font-lock-list
! auto-mode-list function-list
! &optional description)
"Create a new generic mode with NAME.
! NAME should be a symbol; its string representation is used as the function
! name. If DESCRIPTION is provided, it is used as the docstring for the new
function.
! COMMENT-LIST is a list, whose entries are either a single character,
! a one or two character string or a cons pair. If the entry is a character
! or a one-character string, it is added to the mode's syntax table with
! `comment-start' syntax. If the entry is a cons pair, the elements of the
! pair are considered to be `comment-start' and `comment-end' respectively.
! \(The latter should be nil if you want comments to end at end of line.)
! Note that Emacs has limitations regarding comment characters.
!
! KEYWORD-LIST is a list of keywords to highlight with `font-lock-keyword-face'.
! Each keyword should be a string.
!
! FONT-LOCK-LIST is a list of additional expressions to highlight. Each entry
! in the list should have the same form as an entry in `font-lock-keywords'.
!
! AUTO-MODE-LIST is a list of regular expressions to add to `auto-mode-alist'.
! These regexps are added to `auto-mode-alist' as soon as `define-generic-mode'
! is called; any old regexps with the same name are removed.
! FUNCTION-LIST is a list of functions to call to do some additional setup.
See the file generic-x.el for some examples of `define-generic-mode'."
!
! ;; Add a new entry
! (add-to-list 'generic-mode-list (symbol-name name))
!
! ;; Add it to auto-mode-alist
! (dolist (re auto-mode-list)
! (add-to-list 'auto-mode-alist (cons re name)))
!
! ;; Define a function for it using `defalias' (not `fset') to make
! ;; the mode appear on load-history.
! (defalias name
! `(lambda nil
! ,(or description (concat "Generic mode for type " (symbol-name name)))
! (interactive)
! (generic-mode-internal ',name ',comment-list ',keyword-list
! ',font-lock-list ',function-list)))
! )
(defun generic-mode-internal (mode comments keywords font-lock-list funs)
"Go into the generic-mode MODE."
! (let* ((generic-mode-hooks (intern (concat (symbol-name mode) "-hook")))
! (modename (symbol-name mode))
! (name (if (string-match "-mode\\'" modename)
! (substring modename 0 (match-beginning 0))
! modename))
! )
- ;; Put this after the point where we read generic-mode-name!
(kill-all-local-variables)
! (setq
! major-mode mode
! mode-name (capitalize name)
! )
! (generic-mode-set-comments comments)
;; Font-lock functionality
;; Font-lock-defaults are always set even if there are no keywords
;; or font-lock expressions, so comments can be highlighted.
(setq generic-font-lock-defaults nil)
! (generic-mode-set-font-lock keywords font-lock-list)
! (make-local-variable 'font-lock-defaults)
(setq font-lock-defaults (list 'generic-font-lock-defaults nil))
;; Call a list of functions
(mapcar 'funcall funs)
! (run-hooks generic-mode-hooks)
! )
! )
;;;###autoload
(defun generic-mode (type)
! "Basic comment and font-lock functionality for `generic' files.
! \(Files which are too small to warrant their own mode, but have
! comment characters, keywords, and the like.)
To define a generic-mode, use the function `define-generic-mode'.
Some generic modes are defined in `generic-x.el'."
--- 176,276 ----
regexp in `generic-find-file-regexp'. If the value is nil,
`generic-mode-find-file-hook' does not check the file names."
:group 'generic
! :type '(choice (const :tag "Don't check file names" nil) regexp))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Functions
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;###autoload
! (defmacro define-generic-mode (name comment-list keyword-list
! font-lock-list auto-mode-list
! function-list &optional description)
"Create a new generic mode with NAME.
! NAME should be a symbol whose name ends in `-mode'. It will be
! the name of the mode function. The string representation of NAME
! sans `-mode' is used as the mode's name in the mode line. If
! DESCRIPTION is provided, it is used as the docstring for the mode
function.
! COMMENT-LIST is a list, whose entries are either a single
! character, a one or two character string or a cons pair. If the
! entry is a character or a string, it is added to the mode's
! syntax table with `comment-start' syntax. If the entry is a cons
! pair, the elements of the pair are considered to be
! `comment-start' and `comment-end' respectively. (The latter
! should be nil if you want comments to end at end of line.) Note
! that Emacs has limitations regarding comment characters.
!
! KEYWORD-LIST is a list of keywords to highlight with
! `font-lock-keyword-face'. Each keyword should be a string.
!
! FONT-LOCK-LIST is a list of additional expressions to highlight.
! Each entry in the list should have the same form as an entry in
! `font-lock-keywords'.
!
! AUTO-MODE-LIST is a list of regular expressions to add to
! `auto-mode-alist'. These regexps are added to `auto-mode-alist'
! as soon as `define-generic-mode' is called.
! FUNCTION-LIST is a list of functions to call to do some
! additional setup.
See the file generic-x.el for some examples of `define-generic-mode'."
! (let* ((name-unquoted (eval name))
! (name-string (symbol-name name-unquoted)))
!
! `(progn
!
! ;; Add a new entry
! (add-to-list 'generic-mode-list ,name-string)
!
! ;; Add it to auto-mode-alist
! (dolist (re ,auto-mode-list)
! (add-to-list 'auto-mode-alist (cons re ,name)))
!
! (defun ,name-unquoted ()
! ,(or description
! (concat "Generic mode for type " name-string "."))
! (interactive)
! (generic-mode-internal ,name ,comment-list ,keyword-list
! ,font-lock-list ,function-list)))))
(defun generic-mode-internal (mode comments keywords font-lock-list funs)
"Go into the generic-mode MODE."
! (let* ((modename (symbol-name mode))
! (generic-mode-hooks (intern (concat modename "-hook")))
! (pretty-name (capitalize (replace-regexp-in-string
! "-mode\\'" "" modename))))
(kill-all-local-variables)
! (setq major-mode mode
! mode-name pretty-name)
! (generic-mode-set-comments comments)
;; Font-lock functionality
;; Font-lock-defaults are always set even if there are no keywords
;; or font-lock expressions, so comments can be highlighted.
(setq generic-font-lock-defaults nil)
! (generic-mode-set-font-lock keywords font-lock-list)
! (make-local-variable 'font-lock-defaults)
(setq font-lock-defaults (list 'generic-font-lock-defaults nil))
;; Call a list of functions
(mapcar 'funcall funs)
! (run-hooks generic-mode-hooks)))
;;;###autoload
(defun generic-mode (type)
! "Enter generic mode for type TYPE.
!
! Generic modes provide basic comment and font-lock functionality
! for `generic' files. (Files which are too small to warrant their
! own mode, but have comment characters, keywords, and the like.)
To define a generic-mode, use the function `define-generic-mode'.
Some generic modes are defined in `generic-x.el'."
***************
*** 283,298 ****
(let ((st (make-syntax-table))
(chars nil)
(comstyles))
! (make-local-variable 'comment-start)
! (make-local-variable 'comment-start-skip)
! (make-local-variable 'comment-end)
;; Go through all the comments
(dolist (start comment-list)
! (let ((end nil) (comstyle ""))
;; Normalize
(when (consp start)
! (setq end (or (cdr start) end))
(setq start (car start)))
(when (char-valid-p start) (setq start (char-to-string start)))
(cond
--- 284,299 ----
(let ((st (make-syntax-table))
(chars nil)
(comstyles))
! (make-local-variable 'comment-start)
! (make-local-variable 'comment-start-skip)
! (make-local-variable 'comment-end)
;; Go through all the comments
(dolist (start comment-list)
! (let (end (comstyle ""))
;; Normalize
(when (consp start)
! (setq end (cdr start))
(setq start (car start)))
(when (char-valid-p start) (setq start (char-to-string start)))
(cond
***************
*** 390,396 ****
(default-generic-mode)))))
(defun generic-mode-ini-file-find-file-hook ()
! "Hook function to enter default-generic-mode automatically for INI files.
Done if the first few lines of a file in `fundamental-mode' look like an
INI file. This hook is NOT installed by default."
(and (eq major-mode 'fundamental-mode)
--- 391,397 ----
(default-generic-mode)))))
(defun generic-mode-ini-file-find-file-hook ()
! "Hook function to enter `default-generic-mode' automatically for INI files.
Done if the first few lines of a file in `fundamental-mode' look like an
INI file. This hook is NOT installed by default."
(and (eq major-mode 'fundamental-mode)
^ permalink raw reply [flat|nested] 12+ messages in thread
* Re: lisp/generic.el patch.
2005-03-15 17:06 lisp/generic.el patch Lute Kamstra
@ 2005-03-15 18:53 ` Stefan Monnier
2005-03-15 20:19 ` Lute Kamstra
2005-03-16 16:22 ` Richard Stallman
2005-03-17 16:34 ` Lute Kamstra
2 siblings, 1 reply; 12+ messages in thread
From: Stefan Monnier @ 2005-03-15 18:53 UTC (permalink / raw)
Cc: emacs-devel
> and fixed some minor things along the way. Does anybody see any
> problems with this patch?
When loading a byte-compiled file that used define-generic-mode, I think
you'll get an error that generic-mode-list is not defined (because
generic.el doesn't get loaded: the autoload caused generic.el to be loaded
during byte-compilation, but it doesn't have any such effect when loading
the macro-expanded code).
Of course, maybe I'm wrong, I've only superficially looked at the patch.
Stefan
^ permalink raw reply [flat|nested] 12+ messages in thread
* Re: lisp/generic.el patch.
2005-03-15 18:53 ` Stefan Monnier
@ 2005-03-15 20:19 ` Lute Kamstra
2005-03-15 20:52 ` Stefan Monnier
0 siblings, 1 reply; 12+ messages in thread
From: Lute Kamstra @ 2005-03-15 20:19 UTC (permalink / raw)
Cc: emacs-devel
Stefan Monnier <monnier@iro.umontreal.ca> writes:
> When loading a byte-compiled file that used define-generic-mode, I
> think you'll get an error that generic-mode-list is not defined
> (because generic.el doesn't get loaded: the autoload caused
> generic.el to be loaded during byte-compilation, but it doesn't have
> any such effect when loading the macro-expanded code).
Good point. The same goes for calling generic-mode-internal. I'll
add autoload cookies to generic-mode-list and generic-mode-internal.
Lute.
^ permalink raw reply [flat|nested] 12+ messages in thread
* Re: lisp/generic.el patch.
2005-03-15 20:19 ` Lute Kamstra
@ 2005-03-15 20:52 ` Stefan Monnier
2005-03-15 21:47 ` Lute Kamstra
0 siblings, 1 reply; 12+ messages in thread
From: Stefan Monnier @ 2005-03-15 20:52 UTC (permalink / raw)
Cc: emacs-devel
>> When loading a byte-compiled file that used define-generic-mode, I
>> think you'll get an error that generic-mode-list is not defined
>> (because generic.el doesn't get loaded: the autoload caused
>> generic.el to be loaded during byte-compilation, but it doesn't have
>> any such effect when loading the macro-expanded code).
> Good point. The same goes for calling generic-mode-internal. I'll
> add autoload cookies to generic-mode-list and generic-mode-internal.
Maybe a better choice is to put a (require 'generic) in the macro
expanded code.
Stefan
^ permalink raw reply [flat|nested] 12+ messages in thread
* Re: lisp/generic.el patch.
2005-03-15 20:52 ` Stefan Monnier
@ 2005-03-15 21:47 ` Lute Kamstra
2005-03-21 22:48 ` Luc Teirlinck
0 siblings, 1 reply; 12+ messages in thread
From: Lute Kamstra @ 2005-03-15 21:47 UTC (permalink / raw)
Cc: emacs-devel
Stefan Monnier <monnier@iro.umontreal.ca> writes:
>>> When loading a byte-compiled file that used define-generic-mode, I
>>> think you'll get an error that generic-mode-list is not defined
>>> (because generic.el doesn't get loaded: the autoload caused
>>> generic.el to be loaded during byte-compilation, but it doesn't
>>> have any such effect when loading the macro-expanded code).
>
>> Good point. The same goes for calling generic-mode-internal. I'll
>> add autoload cookies to generic-mode-list and generic-mode-internal.
>
> Maybe a better choice is to put a (require 'generic) in the macro
> expanded code.
I thought about that. The difference is that adding (require
'generic) causes generic.el to be loaded the moment a file with a
compiled define-generic-mode call gets loaded. Using autoload cookies
delays loading generic.el until the generic-mode function is actually
called.
I prefer the latter. Maybe the mode function will never be called.
For example, it makes it possible to remove (require 'generic) from
generic-x.el. So you can just load generic-x.elc to define a bunch of
major modes (and add them to auto-mode-alist) and generic.el will only
be loaded when you actually use one of them.
Why do you prefer adding (require 'generic)?
Lute.
^ permalink raw reply [flat|nested] 12+ messages in thread
* Re: lisp/generic.el patch.
2005-03-15 17:06 lisp/generic.el patch Lute Kamstra
2005-03-15 18:53 ` Stefan Monnier
@ 2005-03-16 16:22 ` Richard Stallman
2005-03-16 16:37 ` Lute Kamstra
2005-03-16 16:37 ` David Kastrup
2005-03-17 16:34 ` Lute Kamstra
2 siblings, 2 replies; 12+ messages in thread
From: Richard Stallman @ 2005-03-16 16:22 UTC (permalink / raw)
Cc: emacs-devel
Thanks very much for making etc/TODO smaller.
I have one minor criticism:
(defcustom generic-use-find-file-hook t
! "*If non-nil, add a hook to enter `default-generic-mode' automatically.
That doc string should say
(defcustom generic-use-find-file-hook t
! "*If non-nil, add a hook to enter Default-Generic mode automatically.
because the convention for referring to modes in English text
is to use the mode's name in English, rather than a Lisp symbol name.
There are some other doc strings and comments that need a like change.
^ permalink raw reply [flat|nested] 12+ messages in thread
* Re: lisp/generic.el patch.
2005-03-16 16:22 ` Richard Stallman
@ 2005-03-16 16:37 ` Lute Kamstra
2005-03-16 16:37 ` David Kastrup
1 sibling, 0 replies; 12+ messages in thread
From: Lute Kamstra @ 2005-03-16 16:37 UTC (permalink / raw)
Cc: emacs-devel
Richard Stallman <rms@gnu.org> writes:
> Thanks very much for making etc/TODO smaller.
> I have one minor criticism:
>
> (defcustom generic-use-find-file-hook t
> ! "*If non-nil, add a hook to enter `default-generic-mode' automatically.
>
> That doc string should say
>
> (defcustom generic-use-find-file-hook t
> ! "*If non-nil, add a hook to enter Default-Generic mode automatically.
>
> because the convention for referring to modes in English text
> is to use the mode's name in English, rather than a Lisp symbol name.
>
> There are some other doc strings and comments that need a like change.
I'll incorporate that.
Lute
^ permalink raw reply [flat|nested] 12+ messages in thread
* Re: lisp/generic.el patch.
2005-03-16 16:22 ` Richard Stallman
2005-03-16 16:37 ` Lute Kamstra
@ 2005-03-16 16:37 ` David Kastrup
2005-03-17 23:01 ` Richard Stallman
1 sibling, 1 reply; 12+ messages in thread
From: David Kastrup @ 2005-03-16 16:37 UTC (permalink / raw)
Cc: Lute Kamstra, emacs-devel
Richard Stallman <rms@gnu.org> writes:
> Thanks very much for making etc/TODO smaller.
> I have one minor criticism:
>
> (defcustom generic-use-find-file-hook t
> ! "*If non-nil, add a hook to enter `default-generic-mode' automatically.
>
> That doc string should say
>
> (defcustom generic-use-find-file-hook t
> ! "*If non-nil, add a hook to enter Default-Generic mode automatically.
>
> because the convention for referring to modes in English text
> is to use the mode's name in English, rather than a Lisp symbol name.
>
> There are some other doc strings and comments that need a like change.
In this case, I'd prefer to have
(defcustom generic-use-find-file-hook t
! "*If non-nil, add a hook to call `default-generic-mode' automatically.
The main rationale is that this will give a working cross reference
link in the help window.
--
David Kastrup, Kriemhildstr. 15, 44793 Bochum
^ permalink raw reply [flat|nested] 12+ messages in thread
* Re: lisp/generic.el patch.
2005-03-15 17:06 lisp/generic.el patch Lute Kamstra
2005-03-15 18:53 ` Stefan Monnier
2005-03-16 16:22 ` Richard Stallman
@ 2005-03-17 16:34 ` Lute Kamstra
2005-03-17 16:39 ` Lute Kamstra
2 siblings, 1 reply; 12+ messages in thread
From: Lute Kamstra @ 2005-03-17 16:34 UTC (permalink / raw)
Cc: Stefan Monnier, Richard M. Stallman
Here is an updated patch that incorporates the feedback of Stefan and
Richard.
I also changed three other things:
I removed the (eval-when-compile (require 'cl)) as that is not
needed.
I changed define-generic-mode so that the name of the mode command
need not be quoted (while retaining backward compatibility). This
makes define-generic-mode more like other defining forms. I updated
the docstring of define-generic-mode to reflect this change.
I changed the default docstring of a generic mode.
Ok to commit?
Lute.
2005-03-17 Lute Kamstra <lute@gnu.org>
* generic.el: Fix commentary section. Don't require cl for
compilation.
(generic-mode-list): Add autoload cookie.
(generic-use-find-file-hook, generic-lines-to-scan)
(generic-find-file-regexp, generic-ignore-files-regexp)
(generic-mode, generic-mode-find-file-hook)
(generic-mode-ini-file-find-file-hook): Fix docstrings.
(define-generic-mode): Make it a defmacro. Fix docstring.
(generic-mode-internal): Code cleanup. Add autoload cookie.
(generic-mode-set-comments): Code cleanup.
Index: lisp/generic.el
===================================================================
RCS file: /cvsroot/emacs/emacs/lisp/generic.el,v
retrieving revision 1.27
diff -c -r1.27 generic.el
*** lisp/generic.el 14 Mar 2005 11:06:20 -0000 1.27
--- lisp/generic.el 17 Mar 2005 16:29:31 -0000
***************
*** 34,60 ****
;; Generic-mode is a meta-mode which can be used to define small modes
;; which provide basic comment and font-lock support. These modes are
! ;; intended for the many configuration files and such which are too small
! ;; for a "real" mode, but still have a regular syntax, comment characters
! ;; and the like.
;;
;; Each generic mode can define the following:
;;
;; * List of comment-characters. The entries in this list should be
;; either a character, a one or two character string or a cons pair.
! ;; If the entry is a character or a one-character string
! ;; LIMITATIONS: Emacs does not support comment strings of more than
;; two characters in length.
;;
;; * List of keywords to font-lock. Each keyword should be a string.
! ;; If you have additional keywords which should be highlighted in a face
! ;; different from `font-lock-keyword-face', you can use the convenience
! ;; function `generic-make-keywords-list' (which see), and add the
! ;; result to the following list:
;;
;; * Additional expressions to font-lock. This should be a list of
! ;; expressions, each of which should be of the same form
! ;; as those in `font-lock-keywords'.
;;
;; * List of regular expressions to be placed in auto-mode-alist.
;;
--- 34,64 ----
;; Generic-mode is a meta-mode which can be used to define small modes
;; which provide basic comment and font-lock support. These modes are
! ;; intended for the many configuration files and such which are too
! ;; small for a "real" mode, but still have a regular syntax, comment
! ;; characters and the like.
;;
;; Each generic mode can define the following:
;;
;; * List of comment-characters. The entries in this list should be
;; either a character, a one or two character string or a cons pair.
! ;; If the entry is a character or a string, it is added to the
! ;; mode's syntax table with `comment-start' syntax. If the entry is
! ;; a cons pair, the elements of the pair are considered to be
! ;; `comment-start' and `comment-end' respectively. (The latter
! ;; should be nil if you want comments to end at end of line.)
! ;; LIMITATIONS: Emacs does not support comment strings of more than
;; two characters in length.
;;
;; * List of keywords to font-lock. Each keyword should be a string.
! ;; If you have additional keywords which should be highlighted in a
! ;; face different from `font-lock-keyword-face', you can use the
! ;; convenience function `generic-make-keywords-list' (which see),
! ;; and add the result to the following list:
;;
;; * Additional expressions to font-lock. This should be a list of
! ;; expressions, each of which should be of the same form as those in
! ;; `font-lock-keywords'.
;;
;; * List of regular expressions to be placed in auto-mode-alist.
;;
***************
*** 79,113 ****
;; Use the `define-generic-mode' function to define new modes.
;; For example:
;;
- ;; (require 'generic)
;; (define-generic-mode 'foo-generic-mode
! ;; (list ?% )
! ;; (list "keyword")
! ;; nil
! ;; (list "\\.FOO\\'")
! ;; (list 'foo-setup-function))
;;
;; defines a new generic-mode `foo-generic-mode', which has '%' as a
! ;; comment character, and "keyword" as a keyword. When files which end in
! ;; '.FOO' are loaded, Emacs will go into foo-generic-mode and call
! ;; foo-setup-function. You can also use the function `foo-generic-mode'
! ;; (which is interactive) to put a buffer into foo-generic-mode.
;;
;; AUTOMATICALLY ENTERING GENERIC MODE:
;;
! ;; Generic-mode provides a hook which automatically puts a
! ;; file into default-generic-mode if the first few lines of a file in
! ;; fundamental mode start with a hash comment character. To disable
;; this functionality, set the variable `generic-use-find-file-hook'
! ;; to nil BEFORE loading generic-mode. See the variables
! ;; `generic-lines-to-scan' and `generic-find-file-regexp' for customization
! ;; options.
;;
;; GOTCHAS:
;;
! ;; Be careful that your font-lock definitions are correct. Getting them
! ;; wrong can cause emacs to continually attempt to fontify! This problem
! ;; is not specific to generic-mode.
;;
;; Credit for suggestions, brainstorming, help with debugging:
--- 83,117 ----
;; Use the `define-generic-mode' function to define new modes.
;; For example:
;;
;; (define-generic-mode 'foo-generic-mode
! ;; (list ?%)
! ;; (list "keyword")
! ;; nil
! ;; (list "\\.FOO\\'")
! ;; (list 'foo-setup-function))
;;
;; defines a new generic-mode `foo-generic-mode', which has '%' as a
! ;; comment character, and "keyword" as a keyword. When files which
! ;; end in '.FOO' are loaded, Emacs will go into foo-generic-mode and
! ;; call foo-setup-function. You can also use the function
! ;; `foo-generic-mode' (which is interactive) to put a buffer into
! ;; foo-generic-mode.
;;
;; AUTOMATICALLY ENTERING GENERIC MODE:
;;
! ;; Generic-mode provides a hook which automatically puts a file into
! ;; default-generic-mode if the first few lines of a file in
! ;; fundamental mode start with a hash comment character. To disable
;; this functionality, set the variable `generic-use-find-file-hook'
! ;; to nil BEFORE loading generic-mode. See the variables
! ;; `generic-lines-to-scan' and `generic-find-file-regexp' for
! ;; customization options.
;;
;; GOTCHAS:
;;
! ;; Be careful that your font-lock definitions are correct. Getting
! ;; them wrong can cause Emacs to continually attempt to fontify! This
! ;; problem is not specific to generic-mode.
;;
;; Credit for suggestions, brainstorming, help with debugging:
***************
*** 117,125 ****
;;
;;; Code:
- (eval-when-compile
- (require 'cl))
-
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Internal Variables
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
--- 121,126 ----
***************
*** 128,133 ****
--- 129,135 ----
"Global defaults for font-lock in a generic mode.")
(make-variable-buffer-local 'generic-font-lock-defaults)
+ ;;;###autoload
(defvar generic-mode-list nil
"A list of mode names for `generic-mode'.
Do not add entries to this list directly; use `define-generic-mode'
***************
*** 143,281 ****
:group 'extensions)
(defcustom generic-use-find-file-hook t
! "*If non-nil, add a hook to enter default-generic-mode automatically.
! This is done if the first few lines of a file in fundamental mode start
! with a hash comment character."
:group 'generic
! :type 'boolean
! )
(defcustom generic-lines-to-scan 3
"*Number of lines that `generic-mode-find-file-hook' looks at.
! Relevant when deciding whether to enter `generic-mode' automatically.
This variable should be set to a small positive number."
:group 'generic
! :type 'integer
! )
(defcustom generic-find-file-regexp "^#"
"*Regular expression used by `generic-mode-find-file-hook'.
! Files in fundamental mode whose first few lines contain a match for
! this regexp, should be put into `default-generic-mode' instead.
! The number of lines tested for the matches is specified by the value
! of the variable `generic-lines-to-scan', which see."
:group 'generic
! :type 'regexp
! )
(defcustom generic-ignore-files-regexp "[Tt][Aa][Gg][Ss]\\'"
"*Regular expression used by `generic-mode-find-file-hook'.
Files whose names match this regular expression should not be put
! into `default-generic-mode', even if they have lines which match the
! regexp in `generic-find-file-regexp'. If the value is nil,
`generic-mode-find-file-hook' does not check the file names."
:group 'generic
! :type '(choice (const :tag "Don't check file names" nil) regexp)
! )
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Functions
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;###autoload
! (defun define-generic-mode (name comment-list keyword-list font-lock-list
! auto-mode-list function-list
! &optional description)
! "Create a new generic mode with NAME.
!
! NAME should be a symbol; its string representation is used as the function
! name. If DESCRIPTION is provided, it is used as the docstring for the new
! function.
!
! COMMENT-LIST is a list, whose entries are either a single character,
! a one or two character string or a cons pair. If the entry is a character
! or a one-character string, it is added to the mode's syntax table with
! `comment-start' syntax. If the entry is a cons pair, the elements of the
! pair are considered to be `comment-start' and `comment-end' respectively.
! \(The latter should be nil if you want comments to end at end of line.)
! Note that Emacs has limitations regarding comment characters.
!
! KEYWORD-LIST is a list of keywords to highlight with `font-lock-keyword-face'.
! Each keyword should be a string.
!
! FONT-LOCK-LIST is a list of additional expressions to highlight. Each entry
! in the list should have the same form as an entry in `font-lock-keywords'.
!
! AUTO-MODE-LIST is a list of regular expressions to add to `auto-mode-alist'.
! These regexps are added to `auto-mode-alist' as soon as `define-generic-mode'
! is called; any old regexps with the same name are removed.
! FUNCTION-LIST is a list of functions to call to do some additional setup.
See the file generic-x.el for some examples of `define-generic-mode'."
! ;; Add a new entry
! (add-to-list 'generic-mode-list (symbol-name name))
!
! ;; Add it to auto-mode-alist
! (dolist (re auto-mode-list)
! (add-to-list 'auto-mode-alist (cons re name)))
!
! ;; Define a function for it using `defalias' (not `fset') to make
! ;; the mode appear on load-history.
! (defalias name
! `(lambda nil
! ,(or description (concat "Generic mode for type " (symbol-name name)))
! (interactive)
! (generic-mode-internal ',name ',comment-list ',keyword-list
! ',font-lock-list ',function-list)))
! )
!
(defun generic-mode-internal (mode comments keywords font-lock-list funs)
! "Go into the generic-mode MODE."
! (let* ((generic-mode-hooks (intern (concat (symbol-name mode) "-hook")))
! (modename (symbol-name mode))
! (name (if (string-match "-mode\\'" modename)
! (substring modename 0 (match-beginning 0))
! modename))
! )
- ;; Put this after the point where we read generic-mode-name!
(kill-all-local-variables)
! (setq
! major-mode mode
! mode-name (capitalize name)
! )
! (generic-mode-set-comments comments)
;; Font-lock functionality
;; Font-lock-defaults are always set even if there are no keywords
;; or font-lock expressions, so comments can be highlighted.
(setq generic-font-lock-defaults nil)
! (generic-mode-set-font-lock keywords font-lock-list)
! (make-local-variable 'font-lock-defaults)
(setq font-lock-defaults (list 'generic-font-lock-defaults nil))
;; Call a list of functions
(mapcar 'funcall funs)
! (run-hooks generic-mode-hooks)
! )
! )
;;;###autoload
! (defun generic-mode (type)
! "Basic comment and font-lock functionality for `generic' files.
! \(Files which are too small to warrant their own mode, but have
! comment characters, keywords, and the like.)
To define a generic-mode, use the function `define-generic-mode'.
Some generic modes are defined in `generic-x.el'."
(interactive
! (list (completing-read "Generic Type: " generic-mode-list nil t)))
! (funcall (intern type)))
;;; Comment Functionality
(defun generic-mode-set-comments (comment-list)
--- 145,284 ----
:group 'extensions)
(defcustom generic-use-find-file-hook t
! "*If non-nil, add a hook to enter Default-Generic mode automatically.
! This is done if the first few lines of a file in fundamental mode
! start with a hash comment character."
:group 'generic
! :type 'boolean)
(defcustom generic-lines-to-scan 3
"*Number of lines that `generic-mode-find-file-hook' looks at.
! Relevant when deciding whether to enter Default-Generic mode automatically.
This variable should be set to a small positive number."
:group 'generic
! :type 'integer)
(defcustom generic-find-file-regexp "^#"
"*Regular expression used by `generic-mode-find-file-hook'.
! Files in fundamental mode whose first few lines contain a match
! for this regexp, should be put into Default-Generic mode instead.
! The number of lines tested for the matches is specified by the
! value of the variable `generic-lines-to-scan', which see."
:group 'generic
! :type 'regexp)
(defcustom generic-ignore-files-regexp "[Tt][Aa][Gg][Ss]\\'"
"*Regular expression used by `generic-mode-find-file-hook'.
Files whose names match this regular expression should not be put
! into Default-Generic mode, even if they have lines which match
! the regexp in `generic-find-file-regexp'. If the value is nil,
`generic-mode-find-file-hook' does not check the file names."
:group 'generic
! :type '(choice (const :tag "Don't check file names" nil) regexp))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Functions
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;###autoload
! (defmacro define-generic-mode (mode comment-list keyword-list
! font-lock-list auto-mode-list
! function-list &optional docstring)
! "Create a new generic mode MODE.
!
! MODE is the name of the command for the generic mode; it need not
! be quoted. The optional DOCSTRING is the documentation for the
! mode command. If you do not supply it, a default documentation
! string will be used instead.
!
! COMMENT-LIST is a list, whose entries are either a single
! character, a one or two character string or a cons pair. If the
! entry is a character or a string, it is added to the mode's
! syntax table with `comment-start' syntax. If the entry is a cons
! pair, the elements of the pair are considered to be
! `comment-start' and `comment-end' respectively. (The latter
! should be nil if you want comments to end at end of line.) Note
! that Emacs has limitations regarding comment characters.
!
! KEYWORD-LIST is a list of keywords to highlight with
! `font-lock-keyword-face'. Each keyword should be a string.
!
! FONT-LOCK-LIST is a list of additional expressions to highlight.
! Each entry in the list should have the same form as an entry in
! `font-lock-keywords'.
!
! AUTO-MODE-LIST is a list of regular expressions to add to
! `auto-mode-alist'. These regexps are added to `auto-mode-alist'
! as soon as `define-generic-mode' is called.
! FUNCTION-LIST is a list of functions to call to do some
! additional setup.
See the file generic-x.el for some examples of `define-generic-mode'."
+ (let* ((name-unquoted (if (eq (car-safe mode) 'quote) ; Backward compatibility.
+ (eval mode)
+ mode))
+ (name-string (symbol-name name-unquoted))
+ (pretty-name (capitalize (replace-regexp-in-string
+ "-mode\\'" "" name-string))))
+
+ `(progn
+ ;; Add a new entry.
+ (add-to-list 'generic-mode-list ,name-string)
+
+ ;; Add it to auto-mode-alist
+ (dolist (re ,auto-mode-list)
+ (add-to-list 'auto-mode-alist (cons re ',name-unquoted)))
+
+ (defun ,name-unquoted ()
+ ,(or docstring
+ (concat pretty-name " mode.\n"
+ "This a generic mode defined with `define-generic-mode'."))
+ (interactive)
+ (generic-mode-internal ',name-unquoted ,comment-list ,keyword-list
+ ,font-lock-list ,function-list)))))
! ;;;###autoload
(defun generic-mode-internal (mode comments keywords font-lock-list funs)
! "Go into the generic mode MODE."
! (let* ((modename (symbol-name mode))
! (generic-mode-hooks (intern (concat modename "-hook")))
! (pretty-name (capitalize (replace-regexp-in-string
! "-mode\\'" "" modename))))
(kill-all-local-variables)
! (setq major-mode mode
! mode-name pretty-name)
! (generic-mode-set-comments comments)
;; Font-lock functionality
;; Font-lock-defaults are always set even if there are no keywords
;; or font-lock expressions, so comments can be highlighted.
(setq generic-font-lock-defaults nil)
! (generic-mode-set-font-lock keywords font-lock-list)
! (make-local-variable 'font-lock-defaults)
(setq font-lock-defaults (list 'generic-font-lock-defaults nil))
;; Call a list of functions
(mapcar 'funcall funs)
! (run-hooks generic-mode-hooks)))
;;;###autoload
! (defun generic-mode (mode)
! "Enter generic mode MODE.
!
! Generic modes provide basic comment and font-lock functionality
! for \"generic\" files. (Files which are too small to warrant their
! own mode, but have comment characters, keywords, and the like.)
To define a generic-mode, use the function `define-generic-mode'.
Some generic modes are defined in `generic-x.el'."
(interactive
! (list (completing-read "Generic mode: " generic-mode-list nil t)))
! (funcall (intern mode)))
;;; Comment Functionality
(defun generic-mode-set-comments (comment-list)
***************
*** 283,298 ****
(let ((st (make-syntax-table))
(chars nil)
(comstyles))
! (make-local-variable 'comment-start)
! (make-local-variable 'comment-start-skip)
! (make-local-variable 'comment-end)
;; Go through all the comments
(dolist (start comment-list)
! (let ((end nil) (comstyle ""))
;; Normalize
(when (consp start)
! (setq end (or (cdr start) end))
(setq start (car start)))
(when (char-valid-p start) (setq start (char-to-string start)))
(cond
--- 286,301 ----
(let ((st (make-syntax-table))
(chars nil)
(comstyles))
! (make-local-variable 'comment-start)
! (make-local-variable 'comment-start-skip)
! (make-local-variable 'comment-end)
;; Go through all the comments
(dolist (start comment-list)
! (let (end (comstyle ""))
;; Normalize
(when (consp start)
! (setq end (cdr start))
(setq start (car start)))
(when (char-valid-p start) (setq start (char-to-string start)))
(cond
***************
*** 360,377 ****
imenu-case-fold-search t))
;; This generic mode is always defined
! (define-generic-mode 'default-generic-mode (list ?#) nil nil nil nil)
;; A more general solution would allow us to enter generic-mode for
;; *any* comment character, but would require us to synthesize a new
;; generic-mode on the fly. I think this gives us most of what we
;; want.
(defun generic-mode-find-file-hook ()
! "Hook function to enter `default-generic-mode' automatically.
! Done if the first few lines of a file in `fundamental-mode' start with
! a match for the regexp in `generic-find-file-regexp', unless the
! file's name matches the regexp which is the value of the variable
! `generic-ignore-files-regexp'.
This hook will be installed if the variable
`generic-use-find-file-hook' is non-nil. The variable
`generic-lines-to-scan' determines the number of lines to look at."
--- 363,382 ----
imenu-case-fold-search t))
;; This generic mode is always defined
! (define-generic-mode default-generic-mode (list ?#) nil nil nil nil)
;; A more general solution would allow us to enter generic-mode for
;; *any* comment character, but would require us to synthesize a new
;; generic-mode on the fly. I think this gives us most of what we
;; want.
(defun generic-mode-find-file-hook ()
! "Hook function to enter Default-Generic mode automatically.
!
! Done if the first few lines of a file in Fundamental mode start
! with a match for the regexp in `generic-find-file-regexp', unless
! the file's name matches the regexp which is the value of the
! variable `generic-ignore-files-regexp'.
!
This hook will be installed if the variable
`generic-use-find-file-hook' is non-nil. The variable
`generic-lines-to-scan' determines the number of lines to look at."
***************
*** 390,397 ****
(default-generic-mode)))))
(defun generic-mode-ini-file-find-file-hook ()
! "Hook function to enter default-generic-mode automatically for INI files.
! Done if the first few lines of a file in `fundamental-mode' look like an
INI file. This hook is NOT installed by default."
(and (eq major-mode 'fundamental-mode)
(save-excursion
--- 395,402 ----
(default-generic-mode)))))
(defun generic-mode-ini-file-find-file-hook ()
! "Hook function to enter Default-Generic mode automatically for INI files.
! Done if the first few lines of a file in Fundamental mode look like an
INI file. This hook is NOT installed by default."
(and (eq major-mode 'fundamental-mode)
(save-excursion
^ permalink raw reply [flat|nested] 12+ messages in thread
* Re: lisp/generic.el patch.
2005-03-17 16:34 ` Lute Kamstra
@ 2005-03-17 16:39 ` Lute Kamstra
0 siblings, 0 replies; 12+ messages in thread
From: Lute Kamstra @ 2005-03-17 16:39 UTC (permalink / raw)
Lute Kamstra <Lute.Kamstra.lists@xs4all.nl> writes:
> I changed define-generic-mode so that the name of the mode command
> need not be quoted (while retaining backward compatibility). This
> makes define-generic-mode more like other defining forms. I updated
> the docstring of define-generic-mode to reflect this change.
What about font-locking define-generic-mode like other defining forms?
Lute.
Index: lisp/font-lock.el
===================================================================
RCS file: /cvsroot/emacs/emacs/lisp/font-lock.el,v
retrieving revision 1.233
diff -c -r1.233 font-lock.el
*** lisp/font-lock.el 6 Mar 2005 00:02:04 -0000 1.233
--- lisp/font-lock.el 17 Mar 2005 16:35:54 -0000
***************
*** 1902,1908 ****
;; Function declarations.
"\\(advice\\|varalias\\|alias\\|generic\\|macro\\*?\\|method\\|"
"setf\\|subst\\*?\\|un\\*?\\|"
! "ine-\\(condition\\|\\(?:derived\\|minor\\)-mode\\|"
"method-combination\\|setf-expander\\|skeleton\\|widget\\|"
"function\\|\\(compiler\\|modify\\|symbol\\)-macro\\)\\)\\|"
;; Variable declarations.
--- 1902,1908 ----
;; Function declarations.
"\\(advice\\|varalias\\|alias\\|generic\\|macro\\*?\\|method\\|"
"setf\\|subst\\*?\\|un\\*?\\|"
! "ine-\\(condition\\|\\(?:derived\\|minor\\|generic\\)-mode\\|"
"method-combination\\|setf-expander\\|skeleton\\|widget\\|"
"function\\|\\(compiler\\|modify\\|symbol\\)-macro\\)\\)\\|"
;; Variable declarations.
^ permalink raw reply [flat|nested] 12+ messages in thread
* Re: lisp/generic.el patch.
2005-03-16 16:37 ` David Kastrup
@ 2005-03-17 23:01 ` Richard Stallman
0 siblings, 0 replies; 12+ messages in thread
From: Richard Stallman @ 2005-03-17 23:01 UTC (permalink / raw)
Cc: Lute.Kamstra.lists, emacs-devel
In this case, I'd prefer to have
(defcustom generic-use-find-file-hook t
! "*If non-nil, add a hook to call `default-generic-mode' automatically.
The main rationale is that this will give a working cross reference
link in the help window.
That is ok.
^ permalink raw reply [flat|nested] 12+ messages in thread
* Re: lisp/generic.el patch.
2005-03-15 21:47 ` Lute Kamstra
@ 2005-03-21 22:48 ` Luc Teirlinck
0 siblings, 0 replies; 12+ messages in thread
From: Luc Teirlinck @ 2005-03-21 22:48 UTC (permalink / raw)
Cc: monnier, emacs-devel
Lute Kamstra wrote:
I prefer the latter. Maybe the mode function will never be called.
For example, it makes it possible to remove (require 'generic) from
generic-x.el. So you can just load generic-x.elc to define a bunch of
major modes (and add them to auto-mode-alist) and generic.el will only
be loaded when you actually use one of them.
Why do you prefer adding (require 'generic)?
generic is a tiny file. (generic-x is the large one.)
Sincerely,
Luc.
^ permalink raw reply [flat|nested] 12+ messages in thread
end of thread, other threads:[~2005-03-21 22:48 UTC | newest]
Thread overview: 12+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2005-03-15 17:06 lisp/generic.el patch Lute Kamstra
2005-03-15 18:53 ` Stefan Monnier
2005-03-15 20:19 ` Lute Kamstra
2005-03-15 20:52 ` Stefan Monnier
2005-03-15 21:47 ` Lute Kamstra
2005-03-21 22:48 ` Luc Teirlinck
2005-03-16 16:22 ` Richard Stallman
2005-03-16 16:37 ` Lute Kamstra
2005-03-16 16:37 ` David Kastrup
2005-03-17 23:01 ` Richard Stallman
2005-03-17 16:34 ` Lute Kamstra
2005-03-17 16:39 ` Lute Kamstra
Code repositories for project(s) associated with this public inbox
https://git.savannah.gnu.org/cgit/emacs.git
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).