| 1 | ;;; generic.el --- Defining simple major modes with comment and font-lock. |
| 2 | ;; |
| 3 | ;; Copyright (C) 1997, 1999 Free Software Foundation, Inc. |
| 4 | ;; |
| 5 | ;; Author: Peter Breton <pbreton@cs.umb.edu> |
| 6 | ;; Created: Fri Sep 27 1996 |
| 7 | ;; Keywords: generic, comment, font-lock |
| 8 | |
| 9 | ;; This file is part of GNU Emacs. |
| 10 | |
| 11 | ;; GNU Emacs is free software; you can redistribute it and/or modify |
| 12 | ;; it under the terms of the GNU General Public License as published by |
| 13 | ;; the Free Software Foundation; either version 2, or (at your option) |
| 14 | ;; any later version. |
| 15 | |
| 16 | ;; GNU Emacs is distributed in the hope that it will be useful, |
| 17 | ;; but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 18 | ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 19 | ;; GNU General Public License for more details. |
| 20 | |
| 21 | ;; You should have received a copy of the GNU General Public License |
| 22 | ;; along with GNU Emacs; see the file COPYING. If not, write to the |
| 23 | ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330, |
| 24 | ;; Boston, MA 02111-1307, USA. |
| 25 | |
| 26 | ;; Purpose: |
| 27 | |
| 28 | ;; Meta-mode to create simple major modes |
| 29 | ;; with basic comment and font-lock support |
| 30 | |
| 31 | ;;; Commentary: |
| 32 | |
| 33 | ;; INTRODUCTION: |
| 34 | |
| 35 | ;; Generic-mode is a meta-mode which can be used to define small modes |
| 36 | ;; which provide basic comment and font-lock support. These modes are |
| 37 | ;; intended for the many configuration files and such which are too small |
| 38 | ;; for a "real" mode, but still have a regular syntax, comment characters |
| 39 | ;; and the like. |
| 40 | ;; |
| 41 | ;; Each generic mode can define the following: |
| 42 | ;; |
| 43 | ;; * List of comment-characters. The entries in this list should be |
| 44 | ;; either a character, a one or two character string or a cons pair. |
| 45 | ;; If the entry is a character or a one-character string |
| 46 | ;; LIMITATIONS: Emacs does not support comment strings of more than |
| 47 | ;; two characters in length. |
| 48 | ;; |
| 49 | ;; * List of keywords to font-lock. Each keyword should be a string. |
| 50 | ;; If you have additional keywords which should be highlighted in a face |
| 51 | ;; different from `font-lock-keyword-face', you can use the convenience |
| 52 | ;; function `generic-make-keywords-list' (which see), and add the |
| 53 | ;; result to the following list: |
| 54 | ;; |
| 55 | ;; * Additional expressions to font-lock. This should be a list of |
| 56 | ;; expressions, each of which should be of the same form |
| 57 | ;; as those in `font-lock-defaults-alist'. |
| 58 | ;; |
| 59 | ;; * List of regular expressions to be placed in auto-mode-alist. |
| 60 | ;; |
| 61 | ;; * List of functions to call to do some additional setup |
| 62 | ;; |
| 63 | ;; This should pretty much cover basic functionality; if you need much |
| 64 | ;; more than this, or you find yourself writing extensive customizations, |
| 65 | ;; perhaps you should be writing a major mode instead! |
| 66 | ;; |
| 67 | ;; LOCAL VARIABLES: |
| 68 | ;; |
| 69 | ;; To put a file into generic mode using local variables, use a line |
| 70 | ;; like this in a Local Variables block: |
| 71 | ;; |
| 72 | ;; mode: default-generic |
| 73 | ;; |
| 74 | ;; Do NOT use "mode: generic"! |
| 75 | ;; See also "AUTOMATICALLY ENTERING GENERIC MODE" below. |
| 76 | ;; |
| 77 | ;; DEFINING NEW GENERIC MODES: |
| 78 | ;; |
| 79 | ;; Use the `define-generic-mode' function to define new modes. |
| 80 | ;; For example: |
| 81 | ;; |
| 82 | ;; (require 'generic) |
| 83 | ;; (define-generic-mode 'foo-generic-mode |
| 84 | ;; (list ?% ) |
| 85 | ;; (list "keyword") |
| 86 | ;; nil |
| 87 | ;; (list "\\.FOO\\'") |
| 88 | ;; (list 'foo-setup-function)) |
| 89 | ;; |
| 90 | ;; defines a new generic-mode `foo-generic-mode', which has '%' as a |
| 91 | ;; comment character, and "keyword" as a keyword. When files which end in |
| 92 | ;; '.FOO' are loaded, Emacs will go into foo-generic-mode and call |
| 93 | ;; foo-setup-function. You can also use the function `foo-generic-mode' |
| 94 | ;; (which is interactive) to put a buffer into foo-generic-mode. |
| 95 | ;; |
| 96 | ;; AUTOMATICALLY ENTERING GENERIC MODE: |
| 97 | ;; |
| 98 | ;; Generic-mode provides a hook which automatically puts a |
| 99 | ;; file into default-generic-mode if the first few lines of a file in |
| 100 | ;; fundamental mode start with a hash comment character. To disable |
| 101 | ;; this functionality, set the variable `generic-use-find-file-hook' |
| 102 | ;; to nil BEFORE loading generic-mode. See the variables |
| 103 | ;; `generic-lines-to-scan' and `generic-find-file-regexp' for customization |
| 104 | ;; options. |
| 105 | ;; |
| 106 | ;; GOTCHAS: |
| 107 | ;; |
| 108 | ;; Be careful that your font-lock definitions are correct. Getting them |
| 109 | ;; wrong can cause emacs to continually attempt to fontify! This problem |
| 110 | ;; is not specific to generic-mode. |
| 111 | ;; |
| 112 | |
| 113 | ;; Credit for suggestions, brainstorming, help with debugging: |
| 114 | ;; ACorreir@pervasive-sw.com (Alfred Correira) |
| 115 | ;; Extensive cleanup by: |
| 116 | ;; Stefan Monnier (monnier+gnu/emacs@flint.cs.yale.edu) |
| 117 | ;; |
| 118 | ;;; Code: |
| 119 | |
| 120 | (eval-when-compile |
| 121 | (require 'cl)) |
| 122 | |
| 123 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
| 124 | ;; Internal Variables |
| 125 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
| 126 | |
| 127 | (defvar generic-font-lock-defaults nil |
| 128 | "Global defaults for font-lock in a generic mode.") |
| 129 | (make-variable-buffer-local 'generic-font-lock-defaults) |
| 130 | |
| 131 | (defvar generic-mode-list nil |
| 132 | "A list of mode names for `generic-mode'. |
| 133 | Do not add entries to this list directly; use `define-generic-mode' |
| 134 | instead (which see).") |
| 135 | |
| 136 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
| 137 | ;; Customization Variables |
| 138 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
| 139 | |
| 140 | (defgroup generic nil |
| 141 | "Define simple major modes with comment and font-lock support." |
| 142 | :prefix "generic-" |
| 143 | :group 'extensions) |
| 144 | |
| 145 | (defcustom generic-use-find-file-hook t |
| 146 | "*If non-nil, add a hook to enter default-generic-mode automatically. |
| 147 | This is done if the first few lines of a file in fundamental mode start |
| 148 | with a hash comment character." |
| 149 | :group 'generic |
| 150 | :type 'boolean |
| 151 | ) |
| 152 | |
| 153 | (defcustom generic-lines-to-scan 3 |
| 154 | "*Number of lines that `generic-mode-find-file-hook' looks at. |
| 155 | Relevant when deciding whether to enter `generic-mode' automatically. |
| 156 | This variable should be set to a small positive number." |
| 157 | :group 'generic |
| 158 | :type 'integer |
| 159 | ) |
| 160 | |
| 161 | (defcustom generic-find-file-regexp "^#" |
| 162 | "*Regular expression used by `generic-mode-find-file-hook'. |
| 163 | Files in fundamental mode whose first few lines contain a match for |
| 164 | this regexp, should be put into `default-generic-mode' instead. |
| 165 | The number of lines tested for the matches is specified by the value |
| 166 | of the variable `generic-lines-to-scan', which see." |
| 167 | :group 'generic |
| 168 | :type 'regexp |
| 169 | ) |
| 170 | |
| 171 | (defcustom generic-ignore-files-regexp "[Tt][Aa][Gg][Ss]\\'" |
| 172 | "*Regular expression used by `generic-mode-find-file-hook'. |
| 173 | Files whose names match this regular expression should not be put |
| 174 | into `default-generic-mode', even if they have lines which match the |
| 175 | regexp in `generic-find-file-regexp'. If the value is nil, |
| 176 | `generic-mode-find-file-hook' does not check the file names." |
| 177 | :group 'generic |
| 178 | :type '(choice (const :tag "Don't check file names" nil) regexp) |
| 179 | ) |
| 180 | |
| 181 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
| 182 | ;; Functions |
| 183 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
| 184 | |
| 185 | ;;;###autoload |
| 186 | (defun define-generic-mode (name comment-list keyword-list font-lock-list |
| 187 | auto-mode-list function-list |
| 188 | &optional description) |
| 189 | "Create a new generic mode with NAME. |
| 190 | |
| 191 | Args: (NAME COMMENT-LIST KEYWORD-LIST FONT-LOCK-LIST AUTO-MODE-LIST |
| 192 | FUNCTION-LIST &optional DESCRIPTION) |
| 193 | |
| 194 | NAME should be a symbol; its string representation is used as the function |
| 195 | name. If DESCRIPTION is provided, it is used as the docstring for the new |
| 196 | function. |
| 197 | |
| 198 | COMMENT-LIST is a list, whose entries are either a single character, |
| 199 | a one or two character string or a cons pair. If the entry is a character |
| 200 | or a one-character string, it is added to the mode's syntax table with |
| 201 | `comment-start' syntax. If the entry is a cons pair, the elements of the |
| 202 | pair are considered to be `comment-start' and `comment-end' respectively. |
| 203 | Note that Emacs has limitations regarding comment characters. |
| 204 | |
| 205 | KEYWORD-LIST is a list of keywords to highlight with `font-lock-keyword-face'. |
| 206 | Each keyword should be a string. |
| 207 | |
| 208 | FONT-LOCK-LIST is a list of additional expressions to highlight. Each entry |
| 209 | in the list should have the same form as an entry in `font-lock-defaults-alist' |
| 210 | |
| 211 | AUTO-MODE-LIST is a list of regular expressions to add to `auto-mode-alist'. |
| 212 | These regexps are added to `auto-mode-alist' as soon as `define-generic-mode' |
| 213 | is called; any old regexps with the same name are removed. |
| 214 | |
| 215 | FUNCTION-LIST is a list of functions to call to do some additional setup. |
| 216 | |
| 217 | See the file generic-x.el for some examples of `define-generic-mode'." |
| 218 | |
| 219 | ;; Add a new entry |
| 220 | (unless (assq name generic-mode-list) |
| 221 | (push (list (symbol-name name)) generic-mode-list)) |
| 222 | |
| 223 | ;; Add it to auto-mode-alist |
| 224 | (dolist (re auto-mode-list) |
| 225 | (add-to-list 'auto-mode-alist (cons re name))) |
| 226 | |
| 227 | ;; Define a function for it using `defalias' (not `fset') to make |
| 228 | ;; the mode appear on load-history. |
| 229 | (defalias name |
| 230 | `(lambda nil |
| 231 | ,(or description (concat "Generic mode for type " (symbol-name name))) |
| 232 | (interactive) |
| 233 | (generic-mode-internal ',name ',comment-list ',keyword-list |
| 234 | ',font-lock-list ',function-list))) |
| 235 | ) |
| 236 | |
| 237 | (defun generic-mode-internal (mode comments keywords font-lock-list funs) |
| 238 | "Go into the generic-mode MODE." |
| 239 | (let* ((generic-mode-hooks (intern (concat (symbol-name mode) "-hook"))) |
| 240 | (modename (symbol-name mode)) |
| 241 | (name (if (string-match "-mode\\'" modename) |
| 242 | (substring modename 0 (match-beginning 0)) |
| 243 | modename)) |
| 244 | ) |
| 245 | |
| 246 | ;; Put this after the point where we read generic-mode-name! |
| 247 | (kill-all-local-variables) |
| 248 | |
| 249 | (setq |
| 250 | major-mode mode |
| 251 | mode-name (capitalize name) |
| 252 | ) |
| 253 | |
| 254 | (generic-mode-set-comments comments) |
| 255 | |
| 256 | ;; Font-lock functionality |
| 257 | ;; Font-lock-defaults are always set even if there are no keywords |
| 258 | ;; or font-lock expressions, so comments can be highlighted. |
| 259 | (setq generic-font-lock-defaults nil) |
| 260 | (generic-mode-set-font-lock keywords font-lock-list) |
| 261 | (make-local-variable 'font-lock-defaults) |
| 262 | (setq font-lock-defaults (list 'generic-font-lock-defaults nil)) |
| 263 | |
| 264 | ;; Call a list of functions |
| 265 | (mapcar 'funcall funs) |
| 266 | |
| 267 | (run-hooks generic-mode-hooks) |
| 268 | ) |
| 269 | ) |
| 270 | |
| 271 | ;;;###autoload |
| 272 | (defun generic-mode (type) |
| 273 | "Basic comment and font-lock functionality for `generic' files. |
| 274 | \(Files which are too small to warrant their own mode, but have |
| 275 | comment characters, keywords, and the like.) |
| 276 | |
| 277 | To define a generic-mode, use the function `define-generic-mode'. |
| 278 | Some generic modes are defined in `generic-x.el'." |
| 279 | (interactive |
| 280 | (list (completing-read "Generic Type: " generic-mode-list nil t))) |
| 281 | (funcall (intern type))) |
| 282 | |
| 283 | ;;; Comment Functionality |
| 284 | (defun generic-mode-set-comments (comment-list) |
| 285 | "Set up comment functionality for generic mode." |
| 286 | (let ((st (make-syntax-table)) |
| 287 | (chars nil) |
| 288 | (comstyles)) |
| 289 | (make-local-variable 'comment-start) |
| 290 | (make-local-variable 'comment-start-skip) |
| 291 | (make-local-variable 'comment-end) |
| 292 | |
| 293 | ;; Go through all the comments |
| 294 | (dolist (start comment-list) |
| 295 | (let ((end ?\n) (comstyle "")) |
| 296 | ;; Normalize |
| 297 | (when (consp start) |
| 298 | (setq end (or (cdr start) end)) |
| 299 | (setq start (car start))) |
| 300 | (when (char-valid-p start) (setq start (char-to-string start))) |
| 301 | (when (char-valid-p end) (setq end (char-to-string end))) |
| 302 | |
| 303 | ;; Setup the vars for `comment-region' |
| 304 | (if comment-start |
| 305 | ;; We have already setup a comment-style, so use style b |
| 306 | (progn |
| 307 | (setq comstyle "b") |
| 308 | (setq comment-start-skip |
| 309 | (concat comment-start-skip "\\|" (regexp-quote start) "+\\s-*"))) |
| 310 | ;; First comment-style |
| 311 | (setq comment-start start) |
| 312 | (setq comment-end (if (string-equal end "\n") "" end)) |
| 313 | (setq comment-start-skip (concat (regexp-quote start) "+\\s-*"))) |
| 314 | |
| 315 | ;; Reuse comstyles if necessary |
| 316 | (setq comstyle |
| 317 | (or (cdr (assoc start comstyles)) |
| 318 | (cdr (assoc end comstyles)) |
| 319 | comstyle)) |
| 320 | (push (cons start comstyle) comstyles) |
| 321 | (push (cons end comstyle) comstyles) |
| 322 | |
| 323 | ;; Setup the syntax table |
| 324 | (if (= (length start) 1) |
| 325 | (modify-syntax-entry (string-to-char start) |
| 326 | (concat "< " comstyle) st) |
| 327 | (let ((c0 (elt start 0)) (c1 (elt start 1))) |
| 328 | ;; Store the relevant info but don't update yet |
| 329 | (push (cons c0 (concat (cdr (assoc c0 chars)) "1")) chars) |
| 330 | (push (cons c1 (concat (cdr (assoc c1 chars)) |
| 331 | (concat "2" comstyle))) chars))) |
| 332 | (if (= (length end) 1) |
| 333 | (modify-syntax-entry (string-to-char end) |
| 334 | (concat ">" comstyle) st) |
| 335 | (let ((c0 (elt end 0)) (c1 (elt end 1))) |
| 336 | ;; Store the relevant info but don't update yet |
| 337 | (push (cons c0 (concat (cdr (assoc c0 chars)) |
| 338 | (concat "3" comstyle))) chars) |
| 339 | (push (cons c1 (concat (cdr (assoc c1 chars)) "4")) chars))))) |
| 340 | |
| 341 | ;; Process the chars that were part of a 2-char comment marker |
| 342 | (dolist (cs (nreverse chars)) |
| 343 | (modify-syntax-entry (car cs) |
| 344 | (concat (char-to-string (char-syntax (car cs))) |
| 345 | " " (cdr cs)) |
| 346 | st)) |
| 347 | (set-syntax-table st))) |
| 348 | |
| 349 | (defun generic-mode-set-font-lock (keywords font-lock-expressions) |
| 350 | "Set up font-lock functionality for generic mode." |
| 351 | (setq generic-font-lock-defaults |
| 352 | (append |
| 353 | (when keywords |
| 354 | (list (generic-make-keywords-list keywords font-lock-keyword-face))) |
| 355 | font-lock-expressions))) |
| 356 | |
| 357 | ;; Support for [KEYWORD] constructs found in INF, INI and Samba files |
| 358 | (defun generic-bracket-support () |
| 359 | (setq imenu-generic-expression |
| 360 | '((nil "^\\[\\(.*\\)\\]" 1)) |
| 361 | imenu-case-fold-search t)) |
| 362 | |
| 363 | ;; This generic mode is always defined |
| 364 | (define-generic-mode 'default-generic-mode (list ?#) nil nil nil nil) |
| 365 | |
| 366 | ;; A more general solution would allow us to enter generic-mode for |
| 367 | ;; *any* comment character, but would require us to synthesize a new |
| 368 | ;; generic-mode on the fly. I think this gives us most of what we |
| 369 | ;; want. |
| 370 | (defun generic-mode-find-file-hook () |
| 371 | "Hook function to enter `default-generic-mode' automatically. |
| 372 | Done if the first few lines of a file in `fundamental-mode' start with |
| 373 | a match for the regexp in `generic-find-file-regexp', unless the |
| 374 | file's name matches the regexp which is the value of the variable |
| 375 | `generic-ignore-files-regexp'. |
| 376 | This hook will be installed if the variable |
| 377 | `generic-use-find-file-hook' is non-nil. The variable |
| 378 | `generic-lines-to-scan' determines the number of lines to look at." |
| 379 | (when (and (eq major-mode 'fundamental-mode) |
| 380 | (or (null generic-ignore-files-regexp) |
| 381 | (not (string-match |
| 382 | generic-ignore-files-regexp |
| 383 | (file-name-sans-versions buffer-file-name))))) |
| 384 | (save-excursion |
| 385 | (goto-char (point-min)) |
| 386 | (when (re-search-forward generic-find-file-regexp |
| 387 | (save-excursion |
| 388 | (forward-line generic-lines-to-scan) |
| 389 | (point)) t) |
| 390 | (goto-char (point-min)) |
| 391 | (default-generic-mode))))) |
| 392 | |
| 393 | (defun generic-mode-ini-file-find-file-hook () |
| 394 | "Hook function to enter default-generic-mode automatically for INI files. |
| 395 | Done if the first few lines of a file in `fundamental-mode' look like an |
| 396 | INI file. This hook is NOT installed by default." |
| 397 | (and (eq major-mode 'fundamental-mode) |
| 398 | (save-excursion |
| 399 | (goto-char (point-min)) |
| 400 | (and (looking-at "^\\s-*\\[.*\\]") |
| 401 | (ini-generic-mode))))) |
| 402 | |
| 403 | (and generic-use-find-file-hook |
| 404 | (add-hook 'find-file-hooks 'generic-mode-find-file-hook)) |
| 405 | |
| 406 | (defun generic-make-keywords-list (keywords-list face &optional prefix suffix) |
| 407 | "Return a regular expression matching the specified KEYWORDS-LIST. |
| 408 | The regexp is highlighted with FACE." |
| 409 | (unless (listp keywords-list) |
| 410 | (error "Keywords argument must be a list of strings")) |
| 411 | (list (concat prefix "\\<" |
| 412 | ;; Use an optimized regexp. |
| 413 | (regexp-opt keywords-list t) |
| 414 | "\\>" suffix) |
| 415 | 1 |
| 416 | face)) |
| 417 | |
| 418 | (provide 'generic) |
| 419 | |
| 420 | ;;; generic.el ends here |