[Top][All Lists]

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: Specifying mode in file variables trouble

From: Lennart Borgman (gmail)
Subject: Re: Specifying mode in file variables trouble
Date: Tue, 23 Sep 2008 11:47:44 +0200
User-agent: Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv: Gecko/20071031 Thunderbird/ Mnenhy/

Richard M. Stallman wrote:
>     For web template files (like PHP, JSP, Genshi etc) there are however
>     often several major mode chunks involved. In for example a php file
>     there may be chunks with these major modes
>       - nxhtml-mode / html-mode
>       - php-mode
>       - css-mode
>       - javascript-mode
> It seems to me that if PHP files are likely to contain these other
> things, it is good for Emacs to handle them automatically in PHP files.

Yes, I agree.

> Here's one way: rename the basic PHP mode to `php-only-mode', and
> define `php-mode' as the mumamo mode to handle all of these.  What do
> you think?

I am not sure. I liked html+php-mode better.

Maybe using the name php-mode would also create confusion since the name
is already in use. However php-only-mode may be a good choice.

BTW, php-mode.el (or some version of it) is still not in Emacs. I am
distributing it as part of nXhtml (and it can also be found on Emacs Wiki).

> Another variant is to make `php-mode' check for other languages, and
> call either `php-only-mode' or `php-mumamo-mode'.  Or perhaps it could
> select among a larger variety of modes, depending on what combinations
> of languages are actually used in one file.
> If we don't do this, users can cope by adding explicit -*- specs.  But
> that is inconvenient, so why not do this automatically?

I have suggested a different solution to this quite general problem. I
think a list of major mode priorities would be better. I have
implemented that in majmodpri.el which I am resending here. (I think I
might have made some changes since last time I sent it.)

;;; majmodpri.el --- Major mode priorities handling
;; Author: Lennart Borgman (lennart O borgman A gmail O com)
;; Created: 2008-08-26
(defconst majmodpri:version "0.6") ;;Version:
;; Last-Updated: 2008-08-26T19:21:00+0200 Tue
;; URL:
;; Keywords:
;; Compatibility:
;; Features that might be required by this library:
;;   None
;;; Commentary:
;; Different elisp libraries may try to handle the same type of files.
;; They normally do that by entering their major mode for a file type
;; in `auto-mode-alist' or the other lists affecting `normal-mode'.
;; Since the libraries may be loaded in different orders in different
;; Emacs sessions this can lead to rather stochastic choices of major
;; mode.
;; This library tries to give the control of which major modes will be
;; used back to the user.  It does that by letting the user set up
;; priorities among the major modes.  This priorities are used to sort
;; the lists used by `normal-mode'.
;; To setup this libray and get more information do
;;   M-x customize-group RET majmodpri RET
;; Or, see the commands `majmodpri-sort-lists'.
;;; Change log:
;; This program is free software; you can redistribute it and/or
;; modify it under the terms of the GNU General Public License as
;; published by the Free Software Foundation; either version 2, or
;; (at your option) any later version.
;; This program is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; General Public License for more details.
;; You should have received a copy of the GNU General Public License
;; along with this program; see the file COPYING.  If not, write to
;; the Free Software Foundation, Inc., 51 Franklin Street, Fifth
;; Floor, Boston, MA 02110-1301, USA.
;;; Code:

;;;; Idle sorting

(defvar majmodpri-idle-sort-timer nil)

(defun majmodpri-cancel-idle-sort ()
  "Cancel idle sorting request."
  (when majmodpri-idle-sort-timer
    (cancel-timer majmodpri-idle-sort-timer)
    (setq majmodpri-idle-sort-timer nil)))

(defun majmodpri-start-idle-sort ()
  "Request idle sorting."
  (setq majmodpri-idle-sort-timer
        (run-with-idle-timer 0 nil 'majmodpri-sort-lists-in-timer)))

(defun majmodpri-sort-lists-in-timer ()
  (condition-case err
    (error (message "(majmodpri-sort-lists): %s" err))))

;;;; Custom

(defgroup majmodpri nil
  "Customization group for majmodpri.el"
  :group 'nxhml

(defcustom majmodpri-sort-after-load
  "Sort major mode lists after loading elisp libraries.
Sorting is not done immediately.  Instead it runs in an idle
timer.  This means that if several elisp libraries are loaded in
a command then the sorting will only be done once, after the
command has finished.

See `majmodpri-sort-lists' for more information."
  :type '(choice (const :tag "Never" nil)
                 (const :tag "After loading any elisp library" t)
                 (repeat :tag "After loading specified libraries" symbol))
  :set (lambda (sym val)
         (set-default sym val)
         ;; Clean up `after-load-alist' first.
         (setq after-load-alist
               (delq nil
                     (mapcar (lambda (rec)
                               (unless (equal (cadr rec)
         (when val
           (if (not (listp val))
               (add-to-list 'after-load-alist
                            '(".*" (majmodpri-start-idle-sort)))
             (dolist (feat val)
               (unless (featurep feat)
                 (eval-after-load feat '(majmodpri-start-idle-sort)))))
  :group 'majmodpri)

(defcustom majmodpri-lists-to-sort
  '(magic-mode-alist auto-mode-alist magic-fallback-mode-alist)
  "Which major mode lists to sort.
See `majmodpri-sort-lists' for more information."
  :type '(set (const magic-mode-alist)
              (const auto-mode-alist)
              (const magic-fallback-mode-alist))
  :set (lambda (sym val)
         (set-default sym val)
         (when majmodpri-sort-after-load
  :group 'majmodpri)

(defcustom majmodpri-mode-priorities


  "Priority list for major modes.
Modes that comes first have higher priority.
See `majmodpri-sort-lists' for more information."
  :type '(repeat symbol)
  :set (lambda (sym val)
         (set-default sym val)
         (when majmodpri-sort-after-load
  :group 'majmodpri)

;;;; Sorting

(defvar majmodpri-schwarzian-ordnum nil)
(defun majmodpri-schwarzian-in (rec)
  "Transform REC before sorting."
  (setq majmodpri-schwarzian-ordnum (1+ majmodpri-schwarzian-ordnum))
  (let ((mode (cdr rec)))
     (list mode majmodpri-schwarzian-ordnum)

(defun majmodpri-schwarzian-out (rec)
  "Get original value of REC after sorting."
  (cadr rec))

(defsubst majmodpri-priority (mode)
  "Return major mode MODE priority."
  (length (memq mode majmodpri-mode-priorities)))

(defun majmodpri-compare-auto-modes (rec1 rec2)
  "Compare record REC1 and record REC2.

- First check `majmodpri-mode-priorities'.
- Then use old order in list."
  (let* ((schw1 (car rec1))
         (schw2 (car rec2))
         (mod1     (nth 0 schw1))
         (mod2     (nth 0 schw2))
         (ord1     (nth 1 schw1))
         (ord2     (nth 1 schw2))
         (pri1 (majmodpri-priority mod1))
         (pri2 (majmodpri-priority mod2)))
     ((/= pri1 pri2) (> pri1 pri2))
     (t (> ord1 ord2)))))

;;(benchmark 100 (quote (majmodpri-sort-lists)))
;;(defvar my-auto-mode-alist nil)
(defun majmodpri-sort-auto-mode-alist ()
  "Sort `auto-mode-alist' after users priorities."
  (setq majmodpri-schwarzian-ordnum 0)
  ;; Do not reorder function part, but put it first.
  (let (fun-list
    (dolist (rec auto-mode-alist)
      (if (listp (cdr rec))
          (setq fun-list (cons rec fun-list))
        (setq mod-list (cons rec mod-list))))
    (setq fun-list (nreverse fun-list))
    (setq auto-mode-alist
           (mapcar 'majmodpri-schwarzian-out
                    (mapcar 'majmodpri-schwarzian-in mod-list)

(defun majmodpri-sort-magic-list (magic-mode-list-sym)
  "Sort list MAGIC-MODE-LIST-SYM after users priorities."
  (let ((orig-ordnum 0))
    (set magic-mode-list-sym
         ;; S out
         (mapcar (lambda (rec)
                   (cadr rec))
                 ;; Sort
                  ;; S in
                  (mapcar (lambda (rec)
                            (setq orig-ordnum (1+ orig-ordnum))
                            (let ((mode (cdr rec)))
                               (list mode orig-ordnum)
                          (symbol-value magic-mode-list-sym))
                  (lambda (rec1 rec2)
                    (let* ((schw1 (car rec1))
                           (schw2 (car rec2))
                           (mod1 (nth 0 schw1))
                           (mod2 (nth 0 schw2))
                           (ord1 (nth 1 schw1))
                           (ord2 (nth 1 schw2))
                           (pri1 (majmodpri-priority mod1))
                           (pri2 (majmodpri-priority mod2)))
                       ((/= pri1 pri2) (> pri1 pri2))
                       (t (> ord1 ord2))))))))))

(defun majmodpri-sort-lists ()
  "Sort the list used when selecting major mode.
Only sort those lists choosen in `majmodpri-lists-to-sort'.
Sort according to priorities in `majmodpri-mode-priorities'.
Keep the old order in the list otherwise.

The lists can be sorted when loading elisp libraries, see

See also `majmodpri-apply-priorities'."
  (message "majmodpri-sort-lists running ...")
  (when (memq 'magic-mode-alist majmodpri-lists-to-sort)
    (majmodpri-sort-magic-list 'magic-mode-alist))
  (when (memq 'auto-mode-alist majmodpri-lists-to-sort)
  (when (memq 'magic-fallback-mode-alist majmodpri-lists-to-sort)
    (majmodpri-sort-magic-list 'magic-fallback-mode-alist)))

(defun majmodpri-apply-priorities (change-modes)
  "Apply major mode priorities.
First run `majmodpri-sort-lists' and then if CHANGE-MODES is
non-nil apply to existing file buffers.  If interactive ask
before applying."
  (interactive '(nil))
  (when (or change-modes
    (let (file-buffers)
      (dolist (buffer (buffer-list))
        (with-current-buffer buffer
          (let ((name (buffer-name))
                (file buffer-file-name))
            (or (string= (substring name 0 1) " ") ;; Internal
                (not file)
                (setq file-buffers (cons buffer file-buffers))))))
      (if (not file-buffers)
          (when change-modes
            (message "No file buffers to change modes in"))
        (when (called-interactively-p)
          (setq change-modes
                (y-or-n-p "Check major mode in all file visiting buffers? ")))
        (when change-modes
          (dolist (buffer file-buffers)
            (with-current-buffer buffer (normal-mode))))))))

(provide 'majmodpri)
;;; majmodpri.el ends here

reply via email to

[Prev in Thread] Current Thread [Next in Thread]