| 1 | ;;; generic.el --- Defining simple major modes with comment and font-lock. |
| 2 | ;; |
| 3 | ;; Copyright (C) 1997 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 | |
| 116 | ;;; Code: |
| 117 | |
| 118 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
| 119 | ;; Internal Variables |
| 120 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
| 121 | |
| 122 | (make-variable-buffer-local |
| 123 | (defvar generic-font-lock-defaults nil |
| 124 | "Global defaults for font-lock in a generic mode.")) |
| 125 | |
| 126 | (make-variable-buffer-local |
| 127 | (defvar generic-mode-name 'default-generic-mode |
| 128 | "The name of the generic mode. |
| 129 | This is the car of one of the items in `generic-mode-alist'. |
| 130 | This variable is buffer-local.")) |
| 131 | |
| 132 | (make-variable-buffer-local |
| 133 | (defvar generic-comment-list nil |
| 134 | "List of comment characters for a generic mode.")) |
| 135 | |
| 136 | (make-variable-buffer-local |
| 137 | (defvar generic-keywords-list nil |
| 138 | "List of keywords for a generic mode.")) |
| 139 | |
| 140 | (make-variable-buffer-local |
| 141 | (defvar generic-font-lock-expressions nil |
| 142 | "List of font-lock expressions for a generic mode.")) |
| 143 | |
| 144 | (make-variable-buffer-local |
| 145 | (defvar generic-mode-function-list nil |
| 146 | "List of customization functions to call for a generic mode.")) |
| 147 | |
| 148 | (make-variable-buffer-local |
| 149 | (defvar generic-mode-syntax-table nil |
| 150 | "Syntax table for use in a generic mode.")) |
| 151 | |
| 152 | (defvar generic-mode-alist nil |
| 153 | "An association list for generic-mode. |
| 154 | Each entry in the list looks like this: |
| 155 | |
| 156 | NAME COMMENT-LIST KEYWORD-LIST FONT-LOCK-LIST AUTO-MODE-LIST FUNCTION-LIST. |
| 157 | |
| 158 | Do not add entries to this list directly; use `define-generic-mode' |
| 159 | instead (which see).") |
| 160 | |
| 161 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
| 162 | ;; Customization Variables |
| 163 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
| 164 | |
| 165 | (defgroup generic nil |
| 166 | "Define simple major modes with comment and font-lock support." |
| 167 | :prefix "generic-" |
| 168 | :group 'extensions) |
| 169 | |
| 170 | (defcustom generic-use-find-file-hook t |
| 171 | "*If non-nil, add a hook to enter default-generic-mode automatically |
| 172 | if the first few lines of a file in fundamental mode start with a hash |
| 173 | comment character." |
| 174 | :group 'generic |
| 175 | :type 'boolean |
| 176 | ) |
| 177 | |
| 178 | (defcustom generic-lines-to-scan 3 |
| 179 | "*Number of lines that `generic-mode-find-file-hook' looks at |
| 180 | when deciding whether to enter generic-mode automatically. |
| 181 | This variable should be set to a small positive number." |
| 182 | :group 'generic |
| 183 | :type 'integer |
| 184 | ) |
| 185 | |
| 186 | (defcustom generic-find-file-regexp "#.*\n\\(.*\n\\)?" |
| 187 | "*Regular expression used by `generic-mode-find-file-hook' |
| 188 | to determine if files in fundamental mode should be put into |
| 189 | `default-generic-mode' instead." |
| 190 | :group 'generic |
| 191 | :type 'regexp |
| 192 | ) |
| 193 | |
| 194 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
| 195 | ;; Inline functions |
| 196 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
| 197 | |
| 198 | (defsubst generic-read-type () |
| 199 | (completing-read |
| 200 | "Generic Type: " |
| 201 | (mapcar |
| 202 | '(lambda (elt) (list (symbol-name (car elt)))) |
| 203 | generic-mode-alist) nil t)) |
| 204 | |
| 205 | ;; Basic sanity checks. It does *not* check whether the elements of the lists |
| 206 | ;; are of the correct type. |
| 207 | (defsubst generic-mode-sanity-check (name comment-list keyword-list |
| 208 | font-lock-list auto-mode-list |
| 209 | function-list &optional description) |
| 210 | (and (not (symbolp name)) |
| 211 | (error "%s is not a symbol" (princ name))) |
| 212 | |
| 213 | (mapcar '(lambda (elt) |
| 214 | (if (not (listp elt)) |
| 215 | (error "%s is not a list" (princ elt)))) |
| 216 | (list comment-list keyword-list font-lock-list |
| 217 | auto-mode-list function-list)) |
| 218 | |
| 219 | (and (not (or (null description) (stringp description))) |
| 220 | (error "Description must be a string or nil")) |
| 221 | ) |
| 222 | |
| 223 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
| 224 | ;; Functions |
| 225 | ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
| 226 | |
| 227 | ;;;###autoload |
| 228 | (defun define-generic-mode (name comment-list keyword-list font-lock-list |
| 229 | auto-mode-list function-list |
| 230 | &optional description) |
| 231 | "Create a new generic mode with NAME. |
| 232 | NAME should be a symbol; its string representation is used as the function |
| 233 | name. If DESCRIPTION is provided, it is used as the docstring for the new |
| 234 | function. |
| 235 | |
| 236 | COMMENT-LIST is a list, whose entries are either a single character, |
| 237 | a one or two character string or a cons pair. If the entry is a character |
| 238 | or a one-character string, it is added to the mode's syntax table with |
| 239 | comment-start syntax. If the entry is a cons pair, the elements of the |
| 240 | pair are considered to be comment-start and comment-end respectively. |
| 241 | Note that Emacs has limitations regarding comment characters. |
| 242 | |
| 243 | KEYWORD-LIST is a list of keywords to highlight with `font-lock-keyword-face'. |
| 244 | Each keyword should be a string. |
| 245 | |
| 246 | FONT-LOCK-LIST is a list of additional expressions to highlight. Each entry |
| 247 | in the list should have the same form as an entry in `font-lock-defaults-alist' |
| 248 | |
| 249 | AUTO-MODE-LIST is a list of regular expressions to add to auto-mode-alist. |
| 250 | These regexps are added to auto-mode-alist as soon as `define-generic-mode' |
| 251 | is called; any old regexps with the same name are removed. |
| 252 | |
| 253 | FUNCTION-LIST is a list of functions to call to do some additional setup. |
| 254 | |
| 255 | See the file generic-x.el for some examples of `define-generic-mode'." |
| 256 | |
| 257 | ;; Basic sanity check |
| 258 | (generic-mode-sanity-check name |
| 259 | comment-list keyword-list font-lock-list |
| 260 | auto-mode-list function-list description) |
| 261 | |
| 262 | ;; Remove any old entry |
| 263 | (setq generic-mode-alist |
| 264 | (delq (assq name generic-mode-alist) |
| 265 | generic-mode-alist)) |
| 266 | |
| 267 | ;; Add a new entry |
| 268 | (setq generic-mode-alist |
| 269 | (append |
| 270 | (list |
| 271 | (list |
| 272 | name comment-list keyword-list font-lock-list |
| 273 | auto-mode-list function-list |
| 274 | )) |
| 275 | generic-mode-alist)) |
| 276 | |
| 277 | ;; Add it to auto-mode-alist |
| 278 | (generic-add-to-auto-mode name auto-mode-list t) |
| 279 | |
| 280 | ;; Define a function for it |
| 281 | (generic-create-generic-function name description) |
| 282 | ) |
| 283 | |
| 284 | (defun generic-add-to-auto-mode (mode auto-mode-list |
| 285 | &optional remove-old prepend) |
| 286 | "Add the entries for mode to `auto-mode-alist'. |
| 287 | If remove-old is non-nil, removes old entries first. If prepend is |
| 288 | non-nil, prepends entries to auto-mode-alist; otherwise, appends them." |
| 289 | |
| 290 | (if (not (listp auto-mode-list)) |
| 291 | (error "%s is not a list" (princ auto-mode-list))) |
| 292 | |
| 293 | (let ((new-mode (intern (symbol-name mode)))) |
| 294 | (and remove-old |
| 295 | (let ((auto-mode-entry)) |
| 296 | (while (setq auto-mode-entry (rassq new-mode auto-mode-alist)) |
| 297 | (setq auto-mode-alist |
| 298 | (delq auto-mode-entry |
| 299 | auto-mode-alist))))) |
| 300 | |
| 301 | (mapcar '(lambda (entry) |
| 302 | (generic-add-auto-mode-entry new-mode entry prepend)) |
| 303 | auto-mode-list))) |
| 304 | |
| 305 | (defun generic-add-auto-mode-entry (name entry &optional prepend) |
| 306 | "Add a new entry to the end of auto-mode-alist. |
| 307 | If prepend is non-nil, add the entry to the front of the list." |
| 308 | (let ((new-entry (list (cons entry name)))) |
| 309 | (setq auto-mode-alist |
| 310 | (if prepend |
| 311 | (append new-entry auto-mode-alist) |
| 312 | (append auto-mode-alist new-entry))))) |
| 313 | |
| 314 | (defun generic-create-generic-function (name &optional description) |
| 315 | "Create a generic mode function with NAME. |
| 316 | If DESCRIPTION is provided, it is used as the docstring." |
| 317 | (let ((symname (symbol-name name))) |
| 318 | (fset (intern symname) |
| 319 | (list 'lambda nil |
| 320 | (or description |
| 321 | (concat "Generic mode for type " symname)) |
| 322 | (list 'interactive) |
| 323 | (list 'generic-mode-with-type (list 'quote name)))))) |
| 324 | |
| 325 | (defun generic-mode-with-type (&optional mode) |
| 326 | "Go into the generic-mode MODE." |
| 327 | (let* ((type (or mode generic-mode-name)) |
| 328 | (generic-mode-list (assoc type generic-mode-alist)) |
| 329 | (generic-mode-hooks (intern (concat (symbol-name type) "-hooks"))) |
| 330 | ) |
| 331 | |
| 332 | (and (not generic-mode-list) |
| 333 | (error "Can't find generic-mode information for type %s" |
| 334 | (princ generic-mode-name))) |
| 335 | |
| 336 | ;; Put this after the point where we read generic-mode-name! |
| 337 | (kill-all-local-variables) |
| 338 | |
| 339 | (setq |
| 340 | generic-mode-name type |
| 341 | generic-comment-list (nth 1 generic-mode-list) |
| 342 | generic-keywords-list (nth 2 generic-mode-list) |
| 343 | generic-font-lock-expressions (nth 3 generic-mode-list) |
| 344 | generic-mode-function-list (nth 5 generic-mode-list) |
| 345 | major-mode type |
| 346 | mode-name (symbol-name type) |
| 347 | ) |
| 348 | |
| 349 | (generic-mode-set-comments generic-comment-list) |
| 350 | |
| 351 | ;; Font-lock functionality |
| 352 | ;; Font-lock-defaults are always set even if there are no keywords |
| 353 | ;; or font-lock expressions, so comments can be highlighted. |
| 354 | (setq generic-font-lock-defaults nil) |
| 355 | (generic-mode-set-font-lock generic-keywords-list |
| 356 | generic-font-lock-expressions) |
| 357 | (make-local-variable 'font-lock-defaults) |
| 358 | (setq font-lock-defaults (list 'generic-font-lock-defaults nil)) |
| 359 | |
| 360 | ;; Call a list of functions |
| 361 | (and generic-mode-function-list |
| 362 | (mapcar 'funcall generic-mode-function-list)) |
| 363 | |
| 364 | (run-hooks generic-mode-hooks) |
| 365 | ) |
| 366 | ) |
| 367 | |
| 368 | ;;;###autoload |
| 369 | (defun generic-mode (type) |
| 370 | "A mode to do basic comment and font-lock functionality |
| 371 | for files which are too small to warrant their own mode, but have |
| 372 | comment characters, keywords, and the like. |
| 373 | |
| 374 | To define a generic-mode, use the function `define-generic-mode'. |
| 375 | Some generic modes are defined in `generic-x.el'." |
| 376 | (interactive |
| 377 | (list (generic-read-type))) |
| 378 | (generic-mode-with-type (intern type))) |
| 379 | |
| 380 | ;;; Comment Functionality |
| 381 | (defun generic-mode-set-comments (comment-list) |
| 382 | "Set up comment functionality for generic mode." |
| 383 | (if (null comment-list) |
| 384 | nil |
| 385 | (let ((generic-mode-syntax-table (make-syntax-table))) |
| 386 | (make-local-variable 'comment-start) |
| 387 | (make-local-variable 'comment-start-skip) |
| 388 | (make-local-variable 'comment-end) |
| 389 | (mapcar 'generic-mode-set-a-comment comment-list) |
| 390 | (set-syntax-table generic-mode-syntax-table)))) |
| 391 | |
| 392 | (defun generic-mode-set-a-comment (comment) |
| 393 | (and (char-or-string-p comment) |
| 394 | (if (stringp comment) |
| 395 | (cond |
| 396 | ((eq (length comment) 1) |
| 397 | (generic-mode-set-comment-char |
| 398 | (string-to-char comment))) |
| 399 | ((eq (length comment) 2) |
| 400 | (generic-mode-set-comment-string comment)) |
| 401 | (t |
| 402 | (error "Character string %s must be one or two characters long" |
| 403 | comment)) |
| 404 | ) |
| 405 | (generic-mode-set-comment-char comment))) |
| 406 | (and (consp comment) |
| 407 | (generic-mode-set-comment-pair comment))) |
| 408 | |
| 409 | (defun generic-mode-set-comment-char (comment-char) |
| 410 | "Set the given character as a comment character for generic mode." |
| 411 | (if (not comment-char) |
| 412 | nil |
| 413 | (setq |
| 414 | comment-end "" |
| 415 | comment-start (char-to-string comment-char) |
| 416 | comment-start-skip (concat comment-start "+ *") |
| 417 | ) |
| 418 | |
| 419 | (modify-syntax-entry comment-char "<" |
| 420 | generic-mode-syntax-table) |
| 421 | (modify-syntax-entry ?\n ">" |
| 422 | generic-mode-syntax-table))) |
| 423 | |
| 424 | (defun generic-mode-set-comment-string (comment-string) |
| 425 | "Set the given string as a comment string for generic mode." |
| 426 | (if (not comment-string) |
| 427 | nil |
| 428 | (setq |
| 429 | comment-end "" |
| 430 | comment-start comment-string |
| 431 | comment-start-skip (concat comment-start " *") |
| 432 | ) |
| 433 | |
| 434 | (let ((first (elt comment-string 0)) |
| 435 | (second (elt comment-string 1))) |
| 436 | ;; C++ style comments |
| 437 | (if (char-equal first second) |
| 438 | (progn |
| 439 | (modify-syntax-entry first "<12b" |
| 440 | generic-mode-syntax-table) |
| 441 | (modify-syntax-entry ?\n ">b" |
| 442 | generic-mode-syntax-table))) |
| 443 | ;; Some other two character string |
| 444 | (modify-syntax-entry first "<1" |
| 445 | generic-mode-syntax-table) |
| 446 | (modify-syntax-entry second "<2" |
| 447 | generic-mode-syntax-table) |
| 448 | (modify-syntax-entry ?\n ">" |
| 449 | generic-mode-syntax-table)))) |
| 450 | |
| 451 | (defun generic-mode-set-comment-pair (comment-pair) |
| 452 | "Set the given comment pair as a comment start and end for generic mode." |
| 453 | (let ((generic-comment-start (car comment-pair)) |
| 454 | (generic-comment-end (cdr comment-pair)) |
| 455 | ) |
| 456 | (setq |
| 457 | comment-end generic-comment-end |
| 458 | comment-start generic-comment-start |
| 459 | comment-start-skip (concat generic-comment-start " *") |
| 460 | ) |
| 461 | |
| 462 | ;; Sanity checks |
| 463 | (and (not (and (stringp generic-comment-start) |
| 464 | (stringp generic-comment-end))) |
| 465 | (error "Elements of cons pair must be strings")) |
| 466 | (and (not (and (equal (length generic-comment-start) 2) |
| 467 | (equal (length generic-comment-end) 2))) |
| 468 | (error "Start and end must be exactly two characters long")) |
| 469 | |
| 470 | (let ((first (elt generic-comment-start 0)) |
| 471 | (second (elt generic-comment-start 1)) |
| 472 | (third (elt generic-comment-end 0)) |
| 473 | (fourth (elt generic-comment-end 1)) |
| 474 | ) |
| 475 | |
| 476 | (modify-syntax-entry first ". 1" generic-mode-syntax-table) |
| 477 | (modify-syntax-entry second ". 2" generic-mode-syntax-table) |
| 478 | |
| 479 | (modify-syntax-entry |
| 480 | third |
| 481 | (concat |
| 482 | "." |
| 483 | (cond |
| 484 | ((char-equal first third) " 13") |
| 485 | ((char-equal second third) " 23") |
| 486 | (t " 3")) |
| 487 | ) |
| 488 | generic-mode-syntax-table) |
| 489 | |
| 490 | (modify-syntax-entry |
| 491 | fourth |
| 492 | (concat |
| 493 | "." |
| 494 | (cond |
| 495 | ((char-equal first fourth) " 14") |
| 496 | ((char-equal second fourth) " 24") |
| 497 | (t " 4")) |
| 498 | ) |
| 499 | generic-mode-syntax-table) |
| 500 | ))) |
| 501 | |
| 502 | (defun generic-mode-set-font-lock (keywords font-lock-expressions) |
| 503 | "Set up font-lock functionality for generic mode." |
| 504 | (let ((generic-font-lock-expressions)) |
| 505 | ;; Keywords |
| 506 | (and keywords |
| 507 | (setq |
| 508 | generic-font-lock-expressions |
| 509 | (append |
| 510 | (list (let ((regexp (regexp-opt keywords))) |
| 511 | (list (concat "\\<\\(" regexp "\\)\\>") |
| 512 | 1 |
| 513 | 'font-lock-keyword-face))) |
| 514 | generic-font-lock-expressions))) |
| 515 | ;; Other font-lock expressions |
| 516 | (and font-lock-expressions |
| 517 | (setq generic-font-lock-expressions |
| 518 | (append |
| 519 | font-lock-expressions |
| 520 | generic-font-lock-expressions))) |
| 521 | (and (or font-lock-expressions keywords) |
| 522 | (setq generic-font-lock-defaults generic-font-lock-expressions)) |
| 523 | )) |
| 524 | |
| 525 | ;; Support for [KEYWORD] constructs found in INF, INI and Samba files |
| 526 | (defun generic-bracket-support () |
| 527 | (setq imenu-generic-expression |
| 528 | '((nil "^\\[\\(.*\\)\\]" 1)) |
| 529 | imenu-case-fold-search t)) |
| 530 | |
| 531 | ;; This generic mode is always defined |
| 532 | (define-generic-mode 'default-generic-mode (list ?#) nil nil nil nil) |
| 533 | |
| 534 | ;; A more general solution would allow us to enter generic-mode for |
| 535 | ;; *any* comment character, but would require us to synthesize a new |
| 536 | ;; generic-mode on the fly. I think this gives us most of what we |
| 537 | ;; want. |
| 538 | (defun generic-mode-find-file-hook () |
| 539 | "Hook to enter default-generic-mode automatically |
| 540 | if the first few lines of a file in fundamental-mode start with a hash |
| 541 | comment character. This hook will be installed if the variable |
| 542 | `generic-use-find-file-hook' is non-nil. The variable `generic-lines-to-scan' |
| 543 | determines the number of lines to look at." |
| 544 | (if (not (eq major-mode 'fundamental-mode)) |
| 545 | nil |
| 546 | (and (or (> 1 generic-lines-to-scan) |
| 547 | (< 50 generic-lines-to-scan)) |
| 548 | (error "Variable `generic-lines-to-scan' should be set to a small" |
| 549 | " positive number")) |
| 550 | (let ((comment-regexp "") |
| 551 | (count 0) |
| 552 | ) |
| 553 | (while (< count generic-lines-to-scan) |
| 554 | (setq comment-regexp (concat comment-regexp |
| 555 | generic-find-file-regexp)) |
| 556 | (setq count (1+ count))) |
| 557 | (save-excursion |
| 558 | (goto-char (point-min)) |
| 559 | (and (looking-at comment-regexp) |
| 560 | (generic-mode-with-type 'default-generic-mode)))))) |
| 561 | |
| 562 | (defun generic-mode-ini-file-find-file-hook () |
| 563 | "Hook to enter default-generic-mode automatically |
| 564 | if the first few lines of a file in fundamental-mode look like an INI file. |
| 565 | This hook is NOT installed by default." |
| 566 | (and (eq major-mode 'fundamental-mode) |
| 567 | (save-excursion |
| 568 | (goto-char (point-min)) |
| 569 | (and (looking-at "^\\s-*\\[.*\\]") |
| 570 | (generic-mode-with-type 'ini-generic-mode))))) |
| 571 | |
| 572 | (and generic-use-find-file-hook |
| 573 | (add-hook 'find-file-hooks 'generic-mode-find-file-hook)) |
| 574 | |
| 575 | (defun generic-make-keywords-list (keywords-list face &optional prefix suffix) |
| 576 | "Return a regular expression matching the specified keywords. |
| 577 | The regexp is highlighted with FACE." |
| 578 | (and (not (listp keywords-list)) |
| 579 | (error "Keywords argument must be a list of strings")) |
| 580 | (list (concat (or prefix "") |
| 581 | "\\<\\(" |
| 582 | ;; Use an optimized regexp. |
| 583 | (regexp-opt keywords-list t) |
| 584 | "\\)\\>" |
| 585 | (or suffix "")) |
| 586 | 1 |
| 587 | face)) |
| 588 | |
| 589 | (provide 'generic) |
| 590 | |
| 591 | ;;; generic.el ends here |