lisp/generic.el patch.

[Lute Kamstra]

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  <address@hidden>
+ 
+       * 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  <address@hidden>
  
        * 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)