lisp/generic.el

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